ydb/contrib/libs/icu/include/unicode/messageformat2_data_model.h

// © 2024 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html

#include "unicode/utypes.h"

#ifndef MESSAGEFORMAT_DATA_MODEL_H
#define MESSAGEFORMAT_DATA_MODEL_H

#if U_SHOW_CPLUSPLUS_API

#if !UCONFIG_NO_FORMATTING

#if !UCONFIG_NO_MF2

#include "unicode/localpointer.h"
#include "unicode/messageformat2_data_model_names.h"

#ifndef U_HIDE_DEPRECATED_API

#include <algorithm>
#include <cstddef>
#include <iterator>
#include <optional>
#include <variant>
#include <vector>

U_NAMESPACE_BEGIN

class UVector;

// Helpers

// Note: this _must_ be declared `inline` or else gcc will generate code
// for its instantiations, which needs to be avoided because it returns
// a std::vector
template<typename T>
static inline std::vector<T> toStdVector(const T* arr, int32_t len) {
    std::vector<T> result;
    for (int32_t i = 0; i < len; i++) {
        result.push_back(arr[i]);
    }
    return result;
}

#if defined(U_REAL_MSVC)
#pragma warning(push)
// Ignore warning 4251 as these templates are instantiated later in this file,
// after the classes used to instantiate them have been defined.
#pragma warning(disable: 4251)
#endif

namespace message2 {
    class Checker;
    class MFDataModel;
    class MessageFormatter;
    class Parser;
    class Serializer;


  namespace data_model {
        class Binding;
        class Literal;
        class Operator;

        /**
         * The `Reserved` class represents a `reserved` annotation, as in the `reserved` nonterminal
         * in the MessageFormat 2 grammar or the `Reserved` interface
         * defined in
         * https://github.com/unicode-org/message-format-wg/blob/main/spec/data-model.md#expressions
         *
         * `Reserved` is immutable, copyable and movable.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        class U_I18N_API Reserved : public UMemory {
        public:
            /**
             * A `Reserved` is a sequence of literals.
             *
             * @return The number of literals.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            int32_t numParts() const;
            /**
             * Indexes into the sequence.
             * Precondition: i < numParts()
             *
             * @param i Index of the part being accessed.
             * @return A reference to he i'th literal in the sequence
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const Literal& getPart(int32_t i) const;

            /**
             * The mutable `Reserved::Builder` class allows the reserved sequence to be
             * constructed one part at a time.
             *
             * Builder is not copyable or movable.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            class U_I18N_API Builder : public UMemory {
            private:
                UVector* parts; // Not a LocalPointer for the same reason as in `SelectorKeys::Builder`

            public:
                /**
                 * Adds a single literal to the reserved sequence.
                 *
                 * @param part The literal to be added. Passed by move.
                 * @param status Input/output error code
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& add(Literal&& part, UErrorCode& status) noexcept;
                /**
                 * Constructs a new immutable `Reserved` using the list of parts
                 * set with previous `add()` calls.
                 *
                 * The builder object (`this`) can still be used after calling `build()`.
                 *
                 * param status Input/output error code
                 * @return          The new Reserved object
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Reserved build(UErrorCode& status) const noexcept;
                /**
                 * Default constructor.
                 * Returns a builder with an empty Reserved sequence.
                 *
                 * param status Input/output error code
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder(UErrorCode& status);
                /**
                 * Destructor.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                virtual ~Builder();
                Builder(const Builder&) = delete;
                Builder& operator=(const Builder&) = delete;
                Builder(Builder&&) = delete;
                Builder& operator=(Builder&&) = delete;
            }; // class Reserved::Builder
            /**
             * Non-member swap function.
             * @param r1 will get r2's contents
             * @param r2 will get r1's contents
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            friend inline void swap(Reserved& r1, Reserved& r2) noexcept {
                using std::swap;

                swap(r1.bogus, r2.bogus);
                swap(r1.parts, r2.parts);
                swap(r1.len, r2.len);
            }
            /**
             * Copy constructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Reserved(const Reserved& other);
            /**
             * Assignment operator
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Reserved& operator=(Reserved) noexcept;
            /**
             * Default constructor.
             * Puts the Reserved into a valid but undefined state.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Reserved() { parts = LocalArray<Literal>(); }
            /**
             * Destructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            virtual ~Reserved();
        private:
            friend class Builder;
            friend class Operator;

            // True if a copy failed; this has to be distinguished
            // from a valid `Reserved` with empty parts
            bool bogus = false;

            // Possibly-empty list of parts
            // `literal` reserved as a quoted literal; `reserved-char` / `reserved-escape`
            // strings represented as unquoted literals
            /* const */ LocalArray<Literal> parts;
            int32_t len = 0;

            Reserved(const UVector& parts, UErrorCode& status) noexcept;
            // Helper
            static void initLiterals(Reserved&, const Reserved&);
        };

      /**
         * The `Literal` class corresponds to the `literal` nonterminal in the MessageFormat 2 grammar,
         * https://github.com/unicode-org/message-format-wg/blob/main/spec/message.abnf and the
         * `Literal` interface defined in
         *   // https://github.com/unicode-org/message-format-wg/blob/main/spec/data-model.md#expressions
         *
         * `Literal` is immutable, copyable and movable.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        class U_I18N_API Literal : public UObject {
        public:
            /**
             * Returns the quoted representation of this literal (enclosed in '|' characters)
             *
             * @return A string representation of the literal enclosed in quote characters.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            UnicodeString quoted() const;
            /**
             * Returns the parsed string contents of this literal.
             *
             * @return A string representation of this literal.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const UnicodeString& unquoted() const;
            /**
             * Determines if this literal appeared as a quoted literal in the message.
             *
             * @return true if and only if this literal appeared as a quoted literal in the
             *         message.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            UBool isQuoted() const { return thisIsQuoted; }
            /**
             * Literal constructor.
             *
             *  @param q True if and only if this literal was parsed with the `quoted` nonterminal
             *           (appeared enclosed in '|' characters in the message text).
             *  @param s The string contents of this literal; escape sequences are assumed to have
             *           been interpreted already.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Literal(UBool q, const UnicodeString& s) : thisIsQuoted(q), contents(s) {}
            /**
             * Copy constructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Literal(const Literal& other) : thisIsQuoted(other.thisIsQuoted), contents(other.contents) {}
            /**
             * Non-member swap function.
             * @param l1 will get l2's contents
             * @param l2 will get l1's contents
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            friend inline void swap(Literal& l1, Literal& l2) noexcept {
                using std::swap;

                swap(l1.thisIsQuoted, l2.thisIsQuoted);
                swap(l1.contents, l2.contents);
            }
            /**
             * Assignment operator.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Literal& operator=(Literal) noexcept;
            /**
             * Default constructor.
             * Puts the Literal into a valid but undefined state.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Literal() = default;
            /**
             * Less than operator. Compares `this.stringContents()` with
             * `other.stringContents()`. This method is used in representing
             * the mapping from key lists to patterns in a message with variants,
             * and is not expected to be useful otherwise.
             *
             * @param other The Literal to compare to this one.
             * @return true if the parsed string corresponding to this `Literal`
             * is less than the parsed string corresponding to the other `Literal`
             * (according to `UnicodeString`'s less-than operator).
             * Returns false otherwise.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            bool operator<(const Literal& other) const;
            /**
             * Equality operator. Compares `this.stringContents()` with
             * `other.stringContents()`. This method is used in representing
             * the mapping from key lists to patterns in a message with variants,
             * and is not expected to be useful otherwise.
             *
             * @param other The Literal to compare to this one.
             * @return true if the parsed string corresponding to this `Literal`
             * equals the parsed string corresponding to the other `Literal`
             * (according to `UnicodeString`'s equality operator).
             * Returns false otherwise.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            bool operator==(const Literal& other) const;
            /**
             * Destructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            virtual ~Literal();

        private:
            friend class Reserved::Builder;

            /* const */ bool thisIsQuoted = false;
            /* const */ UnicodeString contents;
        };
  } // namespace data_model
} // namespace message2

/// @cond DOXYGEN_IGNORE
// Export an explicit template instantiation of the LocalPointer that is used as a
// data member of various MFDataModel classes.
// (When building DLLs for Windows this is required.)
// (See measunit_impl.h, datefmt.h, collationiterator.h, erarules.h and others
// for similar examples.)
#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
template class U_I18N_API LocalPointerBase<message2::data_model::Literal>;
template class U_I18N_API LocalArray<message2::data_model::Literal>;
#endif
#if defined(U_REAL_MSVC)
#pragma warning(pop)
#endif
/// @endcond

U_NAMESPACE_END

/// @cond DOXYGEN_IGNORE
// Export an explicit template instantiation of the std::variants and std::optionals
// that are used as a data member of various MFDataModel classes.
// (When building DLLs for Windows this is required.)
// (See measunit_impl.h, datefmt.h, collationiterator.h, erarules.h and others
// for similar examples.)
#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
#if defined(U_REAL_MSVC) && defined(_MSVC_STL_VERSION)
struct U_I18N_API std::_Nontrivial_dummy_type;
template class U_I18N_API std::_Variant_storage_<false, icu::UnicodeString, icu::message2::data_model::Literal>;
#endif
template class U_I18N_API std::variant<icu::UnicodeString, icu::message2::data_model::Literal>;
template class U_I18N_API std::optional<std::variant<icu::UnicodeString, icu::message2::data_model::Literal>>;
template class U_I18N_API std::optional<icu::message2::data_model::Literal>;
#endif
/// @endcond

U_NAMESPACE_BEGIN

namespace message2 {
  namespace data_model {

        /**
         * The `Operand` class corresponds to the `operand` nonterminal in the MessageFormat 2 grammar,
         * https://github.com/unicode-org/message-format-wg/blob/main/spec/message.abnf .
         * It represents a `Literal | VariableRef` -- see the `operand?` field of the `FunctionRef`
         * interface defined at:
         * https://github.com/unicode-org/message-format-wg/blob/main/spec/data-model.md#expressions
         * with the difference that it can also represent a null operand (the absent operand in an
         * `annotation` with no operand).
         *
         * `Operand` is immutable and is copyable and movable.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        class U_I18N_API Operand : public UObject {
        public:
            /**
             * Determines if this operand represents a variable.
             *
             * @return True if and only if the operand is a variable.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            UBool isVariable() const;
            /**
             * Determines if this operand represents a literal.
             *
             * @return True if and only if the operand is a literal.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            UBool isLiteral() const;
            /**
             * Determines if this operand is the null operand.
             *
             * @return True if and only if the operand is the null operand.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            virtual UBool isNull() const;
            /**
             * Returns a reference to this operand's variable name.
             * Precondition: isVariable()
             *
             * @return A reference to the name of the variable
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const UnicodeString& asVariable() const;
            /**
             * Returns a reference to this operand's literal contents.
             * Precondition: isLiteral()
             *
             * @return A reference to the literal
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const Literal& asLiteral() const;
            /**
             * Default constructor.
             * Creates a null Operand.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Operand() : contents(std::nullopt) {}
            /**
             * Variable operand constructor.
             *
             * @param v The variable name; an operand corresponding
             *        to a reference to `v` is returned.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            explicit Operand(const UnicodeString& v) : contents(VariableName(v)) {}
            /**
             * Literal operand constructor.
             *
             * @param l The literal to use for this operand; an operand
             *        corresponding to `l` is returned.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            explicit Operand(const Literal& l) : contents(l) {}
            /**
             * Non-member swap function.
             * @param o1 will get o2's contents
             * @param o2 will get o1's contents
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            friend inline void swap(Operand& o1, Operand& o2) noexcept {
                using std::swap;
                (void) o1;
                (void) o2;
                swap(o1.contents, o2.contents);
            }
            /**
             * Assignment operator.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            virtual Operand& operator=(Operand) noexcept;
            /**
             * Copy constructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Operand(const Operand&);
            /**
             * Destructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            virtual ~Operand();
        private:
            std::optional<std::variant<VariableName, Literal>> contents;
        }; // class Operand

        /**
         * The `Key` class corresponds to the `key` nonterminal in the MessageFormat 2 grammar,
         * https://github.com/unicode-org/message-format-wg/blob/main/spec/message.abnf .
         * It also corresponds to
         * the `Literal | CatchallKey` that is the
         * element type of the `keys` array in the `Variant` interface
         * defined in https://github.com/unicode-org/message-format-wg/blob/main/spec/data-model.md#messages
         *
         * A key is either a literal or the wildcard symbol (represented in messages as '*')
         *
         * `Key` is immutable, copyable and movable.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        class U_I18N_API Key : public UObject {
        public:
            /**
             * Determines if this is a wildcard key
             *
             * @return True if and only if this is the wildcard key
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            UBool isWildcard() const { return !contents.has_value(); }
            /**
             * Returns the contents of this key as a literal.
             * Precondition: !isWildcard()
             *
             * @return The literal contents of the key
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const Literal& asLiteral() const;
            /**
             * Copy constructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Key(const Key& other) : contents(other.contents) {}
            /**
             * Wildcard constructor; constructs a Key representing the
             * catchall or wildcard key, '*'.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Key() : contents(std::nullopt) {}
            /**
             * Literal key constructor.
             *
             * @param lit A Literal to use for this key. The result matches the
             *        literal `lit`.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            explicit Key(const Literal& lit) : contents(lit) {}
            /**
             * Non-member swap function.
             * @param k1 will get k2's contents
             * @param k2 will get k1's contents
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            friend inline void swap(Key& k1, Key& k2) noexcept {
                using std::swap;

                swap(k1.contents, k2.contents);
            }
            /**
             * Assignment operator
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Key& operator=(Key) noexcept;
            /**
             * Less than operator. Compares the literal of `this` with the literal of `other`.
             * This method is used in representing the mapping from key lists to patterns
             * in a message with variants, and is not expected to be useful otherwise.
             *
             * @param other The Key to compare to this one.
             * @return true if the two `Key`s are not wildcards and if `this.asLiteral()`
             * < `other.asLiteral()`.
             * Returns false otherwise.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            bool operator<(const Key& other) const;
            /**
             * Equality operator. Compares the literal of `this` with the literal of `other`.
             * This method is used in representing the mapping from key lists to patterns
             * in a message with variants, and is not expected to be useful otherwise.
             *
             * @param other The Key to compare to this one.
             * @return true if either both `Key`s are wildcards, or `this.asLiteral()`
             * == `other.asLiteral()`.
             * Returns false otherwise.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            bool operator==(const Key& other) const;
            /**
             * Destructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            virtual ~Key();
        private:
            /* const */ std::optional<Literal> contents;
        }; // class Key
  } // namespace data_model
} // namespace message2

/// @cond DOXYGEN_IGNORE
// Export an explicit template instantiation of the LocalPointer that is used as a
// data member of various MFDataModel classes.
// (When building DLLs for Windows this is required.)
// (See measunit_impl.h, datefmt.h, collationiterator.h, erarules.h and others
// for similar examples.)
#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
template class U_I18N_API LocalPointerBase<message2::data_model::Key>;
template class U_I18N_API LocalArray<message2::data_model::Key>;
#endif
/// @endcond

namespace message2 {
  namespace data_model {
        /**
         * The `SelectorKeys` class represents the key list for a single variant.
         * It corresponds to the `keys` array in the `Variant` interface
         * defined in https://github.com/unicode-org/message-format-wg/blob/main/spec/data-model.md#messages
         *
         * `SelectorKeys` is immutable, copyable and movable.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        class U_I18N_API SelectorKeys : public UObject {
        public:
            /**
             * Returns the underlying list of keys.
             *
             * @return The list of keys for this variant.
             *         Returns an empty list if allocating this `SelectorKeys`
             *         object previously failed.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            std::vector<Key> getKeys() const {
                return toStdVector<Key>(keys.getAlias(), len);
            }
            /**
             * The mutable `SelectorKeys::Builder` class allows the key list to be constructed
             * one key at a time.
             *
             * Builder is not copyable or movable.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            class U_I18N_API Builder : public UMemory {
            private:
                friend class SelectorKeys;
                UVector* keys; // This is a raw pointer and not a LocalPointer<UVector> to avoid undefined behavior warnings,
                               // since UVector is forward-declared
                               // The vector owns its elements
            public:
                /**
                 * Adds a single key to the list.
                 *
                 * @param key    The key to be added. Passed by move
                 * @param status Input/output error code
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& add(Key&& key, UErrorCode& status) noexcept;
                /**
                 * Constructs a new immutable `SelectorKeys` using the list of keys
                 * set with previous `add()` calls.
                 *
                 * The builder object (`this`) can still be used after calling `build()`.
                 *
                 * @param status    Input/output error code
                 * @return          The new SelectorKeys object
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                SelectorKeys build(UErrorCode& status) const;
                /**
                 * Default constructor.
                 * Returns a Builder with an empty list of keys.
                 *
                 * @param status Input/output error code
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder(UErrorCode& status);
                /**
                 * Destructor.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                virtual ~Builder();
                Builder(const Builder&) = delete;
                Builder& operator=(const Builder&) = delete;
                Builder(Builder&&) = delete;
                Builder& operator=(Builder&&) = delete;
            }; // class SelectorKeys::Builder
            /**
             * Less than operator. Compares the two key lists lexicographically.
             * This method makes it possible for a `SelectorKeys` to be used as a map
             * key, which allows variants to be represented as a map. It is not expected
             * to be useful otherwise.
             *
             * @param other The SelectorKeys to compare to this one.
             * @return true if `this` is less than `other`, comparing the two key lists
             * lexicographically.
             * Returns false otherwise.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            bool operator<(const SelectorKeys& other) const;
            /**
             * Default constructor.
             * Puts the SelectorKeys into a valid but undefined state.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            SelectorKeys() : len(0) {}
            /**
             * Non-member swap function.
             * @param s1 will get s2's contents
             * @param s2 will get s1's contents
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            friend inline void swap(SelectorKeys& s1, SelectorKeys& s2) noexcept {
                using std::swap;

                swap(s1.len, s2.len);
                swap(s1.keys, s2.keys);
            }
            /**
             * Copy constructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            SelectorKeys(const SelectorKeys& other);
            /**
             * Assignment operator.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            SelectorKeys& operator=(SelectorKeys other) noexcept;
            /**
             * Destructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            virtual ~SelectorKeys();
        private:
            friend class Builder;
            friend class message2::Checker;
            friend class message2::MessageFormatter;
            friend class message2::Serializer;

            /* const */ LocalArray<Key> keys;
            /* const */ int32_t len;

            const Key* getKeysInternal() const;
            SelectorKeys(const UVector& ks, UErrorCode& status);
        }; // class SelectorKeys


    } // namespace data_model


    namespace data_model {
        class Operator;

        /**
         *  An `Option` pairs an option name with an Operand.
         *
         * `Option` is immutable, copyable and movable.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        class U_I18N_API Option : public UObject {
        public:
            /**
             * Accesses the right-hand side of the option.
             *
             * @return A reference to the operand.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const Operand& getValue() const { return rand; }
            /**
             * Accesses the left-hand side of the option.
             *
             * @return A reference to the option name.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const UnicodeString& getName() const { return name; }
            /**
             * Constructor. Returns an `Option` representing the
             * named option "name=rand".
             *
             * @param n The name of the option.
             * @param r The value of the option.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Option(const UnicodeString& n, Operand&& r) : name(n), rand(std::move(r)) {}
            /**
             * Default constructor.
             * Returns an Option in a valid but undefined state.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Option() {}
            /**
             * Non-member swap function.
             * @param o1 will get o2's contents
             * @param o2 will get o1's contents
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            friend inline void swap(Option& o1, Option& o2) noexcept {
                using std::swap;

                swap(o1.name, o2.name);
                swap(o1.rand, o2.rand);
            }
            /**
             * Copy constructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Option(const Option& other);
            /**
             * Assignment operator
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Option& operator=(Option other) noexcept;
            /**
             * Destructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            virtual ~Option();
        private:
            /* const */ UnicodeString name;
            /* const */ Operand rand;
        }; // class Option
    } // namespace data_model
} // namespace message2

  /// @cond DOXYGEN_IGNORE
// Export an explicit template instantiation of the LocalPointer that is used as a
// data member of various MFDataModel classes.
// (When building DLLs for Windows this is required.)
// (See measunit_impl.h, datefmt.h, collationiterator.h, erarules.h and others
// for similar examples.)
#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
template class U_I18N_API LocalPointerBase<message2::data_model::Option>;
template class U_I18N_API LocalArray<message2::data_model::Option>;
#endif
/// @endcond

namespace message2 {
  namespace data_model {
        // Internal only
        #ifndef U_IN_DOXYGEN
        // Options
        // This is a wrapper class around a vector of options that provides lookup operations
        class U_I18N_API OptionMap : public UObject {
        public:
            int32_t size() const;
            // Needs to take an error code b/c an earlier copy might have failed
            const Option& getOption(int32_t, UErrorCode&) const;
            friend inline void swap(OptionMap& m1, OptionMap& m2) noexcept {
                using std::swap;

                swap(m1.bogus, m2.bogus);
                swap(m1.options, m2.options);
                swap(m1.len, m2.len);
            }
            OptionMap() : len(0) {}
            OptionMap(const OptionMap&);
            OptionMap& operator=(OptionMap);
            std::vector<Option> getOptions() const {
                return toStdVector<Option>(options.getAlias(), len);
            }
            OptionMap(const UVector&, UErrorCode&);
            OptionMap(Option*, int32_t);
            virtual ~OptionMap();

            class U_I18N_API Builder : public UObject {
                private:
                    UVector* options;
                    bool checkDuplicates = true;
                public:
                    Builder& add(Option&& opt, UErrorCode&);
                    Builder(UErrorCode&);
                    static Builder attributes(UErrorCode&);
                    // As this class is private, build() is destructive
                    OptionMap build(UErrorCode&);
		    friend inline void swap(Builder& m1, Builder& m2) noexcept {
		      using std::swap;

		      swap(m1.options, m2.options);
		      swap(m1.checkDuplicates, m2.checkDuplicates);
		    }
		    Builder(Builder&&);
		    Builder(const Builder&) = delete;
		    Builder& operator=(Builder) noexcept;
		    virtual ~Builder();
            }; // class OptionMap::Builder
        private:
            friend class message2::Serializer;

            bool bogus = false;
            LocalArray<Option> options;
            int32_t len;
        }; // class OptionMap
        #endif

      // Internal use only
      #ifndef U_IN_DOXYGEN
      class U_I18N_API Callable : public UObject {
      public:
          friend inline void swap(Callable& c1, Callable& c2) noexcept {
              using std::swap;

              swap(c1.name, c2.name);
              swap(c1.options, c2.options);
          }
          const FunctionName& getName() const { return name; }
          const OptionMap& getOptions() const { return options; }
          Callable(const FunctionName& f, const OptionMap& opts) : name(f), options(opts) {}
          Callable& operator=(Callable) noexcept;
          Callable(const Callable&);
          Callable() = default;
          virtual ~Callable();
      private:
          /* const */ FunctionName name;
          /* const */ OptionMap options;
      };
      #endif
  } // namespace data_model
} // namespace message2

U_NAMESPACE_END

/// @cond DOXYGEN_IGNORE
// Export an explicit template instantiation of the std::variant that is used as a
// data member of various MFDataModel classes.
// (When building DLLs for Windows this is required.)
// (See measunit_impl.h, datefmt.h, collationiterator.h, erarules.h and others
// for similar examples.)
#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
#if defined(U_REAL_MSVC) && defined(_MSVC_STL_VERSION)
template class U_I18N_API std::_Variant_storage_<false, icu::message2::data_model::Reserved,icu::message2::data_model::Callable>;
#endif
template class U_I18N_API std::variant<icu::message2::data_model::Reserved,icu::message2::data_model::Callable>;
#endif
/// @endcond

U_NAMESPACE_BEGIN

namespace message2 {
  namespace data_model {
      /**
         * The `Operator` class corresponds to the `FunctionRef | Reserved` type in the
         * `Expression` interface defined in
         * https://github.com/unicode-org/message-format-wg/blob/main/spec/data-model.md#patterns
         *
         * It represents the annotation that an expression can have: either a function name paired
         * with a map from option names to operands (possibly empty),
         * or a reserved sequence, which has no meaning and results in an error if the formatter
         * is invoked.
         *
         * `Operator` is immutable, copyable and movable.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        class U_I18N_API Operator : public UObject {
        public:
            /**
             * Determines if this operator is a reserved annotation.
             *
             * @return true if and only if this operator represents a reserved sequence.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            UBool isReserved() const { return std::holds_alternative<Reserved>(contents); }
            /**
             * Accesses the function name.
             * Precondition: !isReserved()
             *
             * @return The function name of this operator.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const FunctionName& getFunctionName() const;
            /**
             * Accesses the underlying reserved sequence.
             * Precondition: isReserved()
             *
             * @return The reserved sequence represented by this operator.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const Reserved& asReserved() const;
            /**
             * Accesses function options.
             * Precondition: !isReserved()
             *
             * @return A vector of function options for this operator.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            std::vector<Option> getOptions() const {
                const Callable* f = std::get_if<Callable>(&contents);
                // This case should never happen, as the precondition is !isReserved()
                if (f == nullptr) { return {}; }
                const OptionMap& opts = f->getOptions();
                return opts.getOptions();
            }
            /**
             * The mutable `Operator::Builder` class allows the operator to be constructed
             * incrementally.
             *
             * Builder is not copyable or movable.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            class U_I18N_API Builder : public UMemory {
            private:
                friend class Operator;
                bool isReservedSequence = false;
                bool hasFunctionName = false;
                bool hasOptions = false;
                Reserved asReserved;
                FunctionName functionName;
                OptionMap::Builder options;
            public:
                /**
                 * Sets this operator to be a reserved sequence.
                 * If a function name and/or options were previously set,
                 * clears them.
                 *
                 * @param reserved The reserved sequence to set as the contents of this Operator.
                 *                 (Passed by move.)
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& setReserved(Reserved&& reserved);
                /**
                 * Sets this operator to be a function annotation and sets its name
                 * to `func`.
                 * If a reserved sequence was previously set, clears it.
                 *
                 * @param func The function name.
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& setFunctionName(FunctionName&& func);
                /**
                 * Sets this operator to be a function annotation and adds a
                 * single option.
                 * If a reserved sequence was previously set, clears it.
                 *
                 * @param key The name of the option.
                 * @param value The value (right-hand side) of the option.
                 * @param status Input/output error code.
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& addOption(const UnicodeString &key, Operand&& value, UErrorCode& status) noexcept;
                /**
                 * Constructs a new immutable `Operator` using the `reserved` annotation
                 * or the function name and options that were previously set.
                 * If neither `setReserved()` nor `setFunctionName()` was previously
                 * called, then `status` is set to U_INVALID_STATE_ERROR.
                 *
                 * The builder object (`this`) can still be used after calling `build()`.
                 *
                 * The `build()` method is non-const for internal implementation reasons,
                 * but is observably const.
                 *
                 * @param status    Input/output error code.
                 * @return          The new Operator
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Operator build(UErrorCode& status);
                /**
                 * Default constructor.
                 * Returns a Builder with no function name or reserved sequence set.
                 *
                 * @param status    Input/output error code.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder(UErrorCode& status);
                /**
                 * Destructor.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                virtual ~Builder();
                Builder(const Builder&) = delete;
                Builder& operator=(const Builder&) = delete;
                Builder(Builder&&) = delete;
                Builder& operator=(Builder&&) = delete;
            }; // class Operator::Builder
            /**
             * Copy constructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Operator(const Operator& other) noexcept;
            /**
             * Non-member swap function.
             * @param o1 will get o2's contents
             * @param o2 will get o1's contents
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            friend inline void swap(Operator& o1, Operator& o2) noexcept {
                using std::swap;

                swap(o1.contents, o2.contents);
            }
            /**
             * Assignment operator.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Operator& operator=(Operator) noexcept;
            /**
             * Default constructor.
             * Puts the Operator into a valid but undefined state.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Operator() : contents(Reserved()) {}
            /**
             * Destructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            virtual ~Operator();
        private:
            friend class Binding;
            friend class Builder;
            friend class message2::Checker;
            friend class message2::MessageFormatter;
            friend class message2::Serializer;

            // Function call constructor
            Operator(const FunctionName& f, const UVector& options, UErrorCode&);
            // Reserved sequence constructor
            Operator(const Reserved& r) : contents(r) {}

            const OptionMap& getOptionsInternal() const;
            Operator(const FunctionName&, const OptionMap&);
            /* const */ std::variant<Reserved, Callable> contents;
        }; // class Operator
  } // namespace data_model
} // namespace message2

U_NAMESPACE_END

/// @cond DOXYGEN_IGNORE
// Export an explicit template instantiation of the std::optional that is used as a
// data member of various MFDataModel classes.
// (When building DLLs for Windows this is required.)
// (See measunit_impl.h, datefmt.h, collationiterator.h, erarules.h and others
// for similar examples.)
#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
template class U_I18N_API std::optional<icu::message2::data_model::Operator>;
template class U_I18N_API std::optional<icu::message2::data_model::Reserved>;
#endif
/// @endcond

U_NAMESPACE_BEGIN

namespace message2 {
  namespace data_model {
      // Internal only
      typedef enum UMarkupType {
          UMARKUP_OPEN = 0,
          UMARKUP_CLOSE,
          UMARKUP_STANDALONE,
          UMARKUP_COUNT
      } UMarkupType;

      /**
         * The `Markup` class corresponds to the `markup` nonterminal in the MessageFormat 2
         * grammar and the `markup` interface defined in
         * https://github.com/unicode-org/message-format-wg/blob/main/spec/data-model/message.json
         *
         * `Markup` is immutable, copyable and movable.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        class U_I18N_API Markup : public UObject {
        public:
            /**
             * Checks if this markup is an opening tag.
             *
             * @return True if and only if this represents an opening tag.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            UBool isOpen() const { return (type == UMARKUP_OPEN); }
            /**
             * Checks if this markup is an closing tag.
             *
             * @return True if and only if this represents an closing tag.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            UBool isClose() const { return (type == UMARKUP_CLOSE); }
            /**
             * Checks if this markup is an standalone tag.
             *
             * @return True if and only if this represents a standalone tag.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            UBool isStandalone() const { return (type == UMARKUP_STANDALONE); }
            /**
             * Gets the name of this markup
             *
             * @return A reference to the string identifying the markup
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const UnicodeString& getName() const { return name; }
            /**
             * Gets the options of this markup
             *
             * @return A reference to the string identifying the markup
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            std::vector<Option> getOptions() const { return options.getOptions(); }
            /**
             * Gets the attributes of this markup
             *
             * @return A vector of attributes
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            std::vector<Option> getAttributes() const { return attributes.getOptions(); }
            /**
             * Default constructor.
             * Puts the Markup into a valid but undefined state.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Markup() {}
            /**
             * Destructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            virtual ~Markup();
            /**
             * The mutable `Markup::Builder` class allows the markup to be constructed
             * incrementally.
             *
             * Builder is not copyable or movable.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            class U_I18N_API Builder : public UMemory {
            private:
                friend class Markup;

                UnicodeString name;
                OptionMap::Builder options;
                OptionMap::Builder attributes;
                UMarkupType type = UMARKUP_COUNT;
            public:
                /**
                 * Sets the name of this markup.
                 *
                 * @param n A string representing the name.
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& setName(const UnicodeString& n) { name = n; return *this; }
                /**
                 * Sets this to be an opening markup.
                 *
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& setOpen() { type = UMARKUP_OPEN; return *this; }
                /**
                 * Sets this to be an closing markup.
                 *
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& setClose() { type = UMARKUP_CLOSE; return *this; }
                /**
                 * Sets this to be a standalone markup.
                 *
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& setStandalone() { type = UMARKUP_STANDALONE; return *this; }
                /**
                 * Adds a single option.
                 *
                 * @param key The name of the option.
                 * @param value The value (right-hand side) of the option.
                 * @param status Input/output error code.
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& addOption(const UnicodeString &key, Operand&& value, UErrorCode& status);
                /**
                 * Adds a single attribute.
                 *
                 * @param key The name of the attribute.
                 * @param value The value (right-hand side) of the attribute.
                 * @param status Input/output error code.
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& addAttribute(const UnicodeString &key, Operand&& value, UErrorCode& status);
                /**
                 * Constructs a new immutable `Markup` using the name and type
                 * and (optionally) options and attributes that were previously set.
                 * If `setName()` and at least one of `setOpen()`, `setClose()`, and `setStandalone()`
                 * were not previously called,
                 * then `status` is set to U_INVALID_STATE_ERROR.
                 *
                 * The builder object (`this`) can still be used after calling `build()`.
                 * The `build()` method is non-const for internal implementation reasons,
                 * but is observably const.
                 *
                 * @param status    Input/output error code.
                 * @return          The new Markup.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Markup build(UErrorCode& status);
                /**
                 * Default constructor.
                 * Returns a Builder with no name, type, options, or attributes set.
                 *
                 * @param status    Input/output error code.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder(UErrorCode& status);
                /**
                 * Destructor.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                virtual ~Builder();
                Builder(const Builder&) = delete;
                Builder& operator=(const Builder&) = delete;
                Builder(Builder&&) = delete;
                Builder& operator=(Builder&&) = delete;
            }; // class Markup::Builder

        private:
            friend class Builder;
            friend class message2::Serializer;

            UMarkupType type;
            UnicodeString name;
            OptionMap options;
            OptionMap attributes;
            const OptionMap& getOptionsInternal() const { return options; }
            const OptionMap& getAttributesInternal() const { return attributes; }
            Markup(UMarkupType, UnicodeString, OptionMap&&, OptionMap&&);
        }; // class Markup

        /**
         * The `Expression` class corresponds to the `expression` nonterminal in the MessageFormat 2
         * grammar and the `Expression` interface defined in
         * https://github.com/unicode-org/message-format-wg/blob/main/spec/data-model.md#patterns
         *
         * It represents either an operand with no annotation; an annotation with no operand;
         * or an operand annotated with an annotation.
         *
         * `Expression` is immutable, copyable and movable.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        class U_I18N_API Expression : public UObject {
        public:
            /**
             * Checks if this expression is an annotation
             * with no operand.
             *
             * @return True if and only if the expression has
             *         an annotation and has no operand.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            UBool isStandaloneAnnotation() const;
            /**
             * Checks if this expression has a function
             * annotation (with or without an operand). A reserved
             * sequence is not a function annotation.
             *
             * @return True if and only if the expression has an annotation
             *         that is a function.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            UBool isFunctionCall() const;
            /**
             * Returns true if and only if this expression is
             * annotated with a reserved sequence.
             *
             * @return True if and only if the expression has an
             *         annotation that is a reserved sequence,
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            UBool isReserved() const;
            /**
             * Accesses the function or reserved sequence
             * annotating this expression.
             * If !(isFunctionCall() || isReserved()), sets
             * `status` to U_INVALID_STATE_ERROR.
             *
             * @param status Input/output error code.
             * @return A non-owned pointer to the operator of this expression,
             *         which does not outlive the expression.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const Operator* getOperator(UErrorCode& status) const;
            /**
             * Accesses the operand of this expression.
             *
             * @return A reference to the operand of this expression,
             *         which may be the null operand.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const Operand& getOperand() const;
            /**
             * Gets the attributes of this expression
             *
             * @return A vector of attributes
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            std::vector<Option> getAttributes() const { return attributes.getOptions(); }
            /**
             * The mutable `Expression::Builder` class allows the operator to be constructed
             * incrementally.
             *
             * Builder is not copyable or movable.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            class U_I18N_API Builder : public UMemory {
            private:
                friend class Expression;

                bool hasOperand = false;
                bool hasOperator = false;
                Operand rand;
                Operator rator;
                OptionMap::Builder attributes;
            public:
                /**
                 * Sets the operand of this expression.
                 *
                 * @param rAnd The operand to set. Passed by move.
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& setOperand(Operand&& rAnd);
                /**
                 * Sets the operator of this expression.
                 *
                 * @param rAtor The operator to set. Passed by move.
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& setOperator(Operator&& rAtor);
                /**
                 * Adds a single attribute.
                 *
                 * @param key The name of the attribute.
                 * @param value The value (right-hand side) of the attribute.
                 * @param status Input/output error code.
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& addAttribute(const UnicodeString &key, Operand&& value, UErrorCode& status);
                /**
                 * Constructs a new immutable `Expression` using the operand and operator that
                 * were previously set. If neither `setOperand()` nor `setOperator()` was
                 * previously called, or if `setOperand()` was called with the null operand
                 * and `setOperator()` was never called, then `status` is set to
                 * U_INVALID_STATE_ERROR.
                 *
                 * The builder object (`this`) can still be used after calling `build()`.
                 * The `build()` method is non-const for internal implementation reasons,
                 * but is observably const.

                 * @param status    Input/output error code.
                 * @return          The new Expression.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Expression build(UErrorCode& status);
                /**
                 * Default constructor.
                 * Returns a Builder with no operator or operand set.
                 *
                 * @param status    Input/output error code.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder(UErrorCode& status);
                /**
                 * Destructor.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                virtual ~Builder();
                Builder(const Builder&) = delete;
                Builder& operator=(const Builder&) = delete;
                Builder(Builder&&) = delete;
                Builder& operator=(Builder&&) = delete;
            }; // class Expression::Builder
            /**
             * Non-member swap function.
             * @param e1 will get e2's contents
             * @param e2 will get e1's contents
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            friend inline void swap(Expression& e1, Expression& e2) noexcept {
                using std::swap;

                swap(e1.rator, e2.rator);
                swap(e1.rand, e2.rand);
                swap(e1.attributes, e2.attributes);
            }
            /**
             * Copy constructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Expression(const Expression& other);
            /**
             * Assignment operator.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Expression& operator=(Expression) noexcept;
            /**
             * Default constructor.
             * Puts the Expression into a valid but undefined state.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Expression();
            /**
             * Destructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            virtual ~Expression();
        private:
            friend class message2::Serializer;

            /*
              Internally, an expression is represented as the application of an optional operator to an operand.
              The operand is always present; for function calls with no operand, it's represented
              as an operand for which `isNull()` is true.

              Operator               | Operand
              --------------------------------
              { |42| :fun opt=value } =>  (FunctionName=fun,     | Literal(quoted=true, contents="42")
              options={opt: value})
              { abcd }                =>  null                   | Literal(quoted=false, contents="abcd")
              { : fun opt=value }     =>  (FunctionName=fun,
              options={opt: value})  | NullOperand()
            */

            Expression(const Operator &rAtor, const Operand &rAnd, const OptionMap& attrs) : rator(rAtor), rand(rAnd), attributes(attrs) {}
            Expression(const Operand &rAnd, const OptionMap& attrs) : rator(std::nullopt), rand(Operand(rAnd)), attributes(attrs) {}
            Expression(const Operator &rAtor, const OptionMap& attrs) : rator(rAtor), rand(), attributes(attrs) {}
            /* const */ std::optional<Operator> rator;
            /* const */ Operand rand;
            /* const */ OptionMap attributes;
            const OptionMap& getAttributesInternal() const { return attributes; }
        }; // class Expression
  } // namespace data_model
} // namespace message2

/// @cond DOXYGEN_IGNORE
// Export an explicit template instantiation of the LocalPointer that is used as a
// data member of various MFDataModel classes.
// (When building DLLs for Windows this is required.)
// (See measunit_impl.h, datefmt.h, collationiterator.h, erarules.h and others
// for similar examples.)
#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
template class U_I18N_API LocalPointerBase<message2::data_model::Expression>;
template class U_I18N_API LocalArray<message2::data_model::Expression>;
#endif
/// @endcond

namespace message2 {
  namespace data_model {
      /**
         * The `UnsupportedStatement` class corresponds to the `reserved-statement` nonterminal in the MessageFormat 2
         * grammar and the `unsupported-statement` type defined in:
         * https://github.com/unicode-org/message-format-wg/blob/main/spec/data-model/message.json#L169
         *
         * It represents a keyword (string) together with an optional
         * `Reserved` annotation and a non-empty list of expressions.
         *
         * `UnsupportedStatement` is immutable, copyable and movable.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        class U_I18N_API UnsupportedStatement : public UObject {
        public:
            /**
             * Accesses the keyword of this statement.
             *
             * @return A reference to a string.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const UnicodeString& getKeyword() const { return keyword; }
            /**
             * Accesses the `reserved-body` of this statement.
             *
             * @param status Input/output error code. Set to U_ILLEGAL_ARGUMENT_ERROR
             *         if this unsupported statement has no body.
             * @return A non-owned pointer to a `Reserved` annotation,
             *         which is non-null if U_SUCCESS(status).
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const Reserved* getBody(UErrorCode& status) const;
            /**
             * Accesses the expressions of this statement.
             *
             * @return A vector of Expressions.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            std::vector<Expression> getExpressions() const {
                if (expressionsLen <= 0 || !expressions.isValid()) {
                    // This case should never happen, but we can't use an assertion here
                    return {};
                }
                return toStdVector<Expression>(expressions.getAlias(), expressionsLen);
            }
            /**
             * The mutable `UnsupportedStatement::Builder` class allows the statement to be constructed
             * incrementally.
             *
             * Builder is not copyable or movable.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            class U_I18N_API Builder : public UMemory {
            private:
                friend class UnsupportedStatement;
                friend class message2::Parser;

                UnicodeString keyword;
                std::optional<Reserved> body;
                UVector* expressions; // Vector of expressions;
                                      // not a LocalPointer for
                                      // the same reason as in `SelectorKeys::builder`
            public:
                /**
                 * Sets the keyword of this statement.
                 *
                 * @param k The keyword to set.
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& setKeyword(const UnicodeString& k);
                /**
                 * Sets the body of this statement.
                 *
                 * @param r The `Reserved` annotation to set as the body. Passed by move.
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& setBody(Reserved&& r);
                /**
                 * Adds an expression to this statement.
                 *
                 * @param e The expression to add. Passed by move.
                 * @param status Input/output error code.
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& addExpression(Expression&& e, UErrorCode& status);
                /**
                 * Constructs a new immutable `UnsupportedStatement` using the keyword,
                 * body and (if applicable) expressions that were previously set.
                 * If `setKeyword()` was never called, then `status` is set to
                 * U_INVALID_STATE_ERROR. If `setBody()` was never called, the body is
                 * treated as absent (not an error). If `addExpression()` was not called
                 * at least once, then `status` is set to U_INVALID_STATE_ERROR.
                 *
                 * The builder object (`this`) can still be used after calling `build()`.
                 * @param status    Input/output error code.
                 * @return          The new UnsupportedStatement
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                UnsupportedStatement build(UErrorCode& status) const;
                /**
                 * Default constructor.
                 * Returns a Builder with no keyword or body set.
                 *
                 * @param status    Input/output error code.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder(UErrorCode& status);
                /**
                 * Destructor.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                virtual ~Builder();
                Builder(const Builder&) = delete;
                Builder& operator=(const Builder&) = delete;
                Builder(Builder&&) = delete;
                Builder& operator=(Builder&&) = delete;
            }; // class UnsupportedStatement::Builder
            /**
             * Non-member swap function.
             * @param s1 will get s2's contents
             * @param s2 will get s1's contents
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            friend inline void swap(UnsupportedStatement& s1, UnsupportedStatement& s2) noexcept {
                using std::swap;

                swap(s1.keyword, s2.keyword);
                swap(s1.body, s2.body);
                swap(s1.expressions, s2.expressions);
                swap(s1.expressionsLen, s2.expressionsLen);
            }
            /**
             * Copy constructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            UnsupportedStatement(const UnsupportedStatement& other);
            /**
             * Assignment operator.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            UnsupportedStatement& operator=(UnsupportedStatement) noexcept;
            /**
             * Default constructor.
             * Puts the UnsupportedStatement into a valid but undefined state.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            UnsupportedStatement() : expressions(LocalArray<Expression>()) {}
            /**
             * Destructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            virtual ~UnsupportedStatement();
        private:
            friend class message2::Serializer;

            /* const */ UnicodeString keyword;
            /* const */ std::optional<Reserved> body;
            /* const */ LocalArray<Expression> expressions;
            /* const */ int32_t expressionsLen = 0;

            const Expression* getExpressionsInternal() const { return expressions.getAlias(); }

            UnsupportedStatement(const UnicodeString&, const std::optional<Reserved>&, const UVector&, UErrorCode&);
        }; // class UnsupportedStatement

      class Pattern;

  // Despite the comments, `PatternPart` is internal-only
       /**
         *  A `PatternPart` is a single element (text or expression) in a `Pattern`.
         * It corresponds to the `body` field of the `Pattern` interface
         *  defined in https://github.com/unicode-org/message-format-wg/blob/main/spec/data-model.md#patterns
         *
         * `PatternPart` is immutable, copyable and movable.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        class PatternPart : public UObject {
        public:
            /**
             * Checks if the part is a text part.
             *
             * @return True if and only if this is a text part.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            UBool isText() const { return std::holds_alternative<UnicodeString>(piece); }
            /**
             * Checks if the part is a markup part.
             *
             * @return True if and only if this is a markup part.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            UBool isMarkup() const { return std::holds_alternative<Markup>(piece); }
            /**
             * Checks if the part is an expression part.
             *
             * @return True if and only if this is an expression part.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            UBool isExpression() const { return std::holds_alternative<Expression>(piece); }
            /**
             * Accesses the expression of the part.
             * Precondition: isExpression()
             *
             * @return A reference to the part's underlying expression.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const Expression& contents() const;
            /**
             * Accesses the expression of the part.
             * Precondition: isMarkup()
             *
             * @return A reference to the part's underlying expression.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const Markup& asMarkup() const;
            /**
             * Accesses the text contents of the part.
             * Precondition: isText()
             *
             * @return A reference to a string representing the part's text..
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const UnicodeString& asText() const;
            /**
             * Non-member swap function.
             * @param p1 will get p2's contents
             * @param p2 will get p1's contents
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            friend inline void swap(PatternPart& p1, PatternPart& p2) noexcept {
                using std::swap;

                swap(p1.piece, p2.piece);
            }
            /**
             * Copy constructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            PatternPart(const PatternPart& other);
            /**
             * Assignment operator.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            PatternPart& operator=(PatternPart) noexcept;
            /**
             * Destructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            virtual ~PatternPart();
            /**
             * Text part constructor. Returns a text pattern part
             * with text `t`.
             *
             * @param t A text string.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            explicit PatternPart(const UnicodeString& t) : piece(t) {}
            /**
             * Expression part constructor. Returns an Expression pattern
             * part with expression `e`.
             *
             * @param e An Expression.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            explicit PatternPart(Expression&& e) : piece(e) {}
            /**
             * Markup part constructor. Returns a Markup pattern
             * part with markup `m`
             *
             * @param m A Markup.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            explicit PatternPart(Markup&& m) : piece(m) {}
            /**
             * Default constructor.
             * Puts the PatternPart into a valid but undefined state.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            PatternPart() = default;
        private:
            friend class Pattern;

            std::variant<UnicodeString, Expression, Markup> piece;
        }; // class PatternPart
  } // namespace data_model
} // namespace message2

  /// @cond DOXYGEN_IGNORE
// Export an explicit template instantiation of the LocalPointer that is used as a
// data member of various MFDataModel classes.
// (When building DLLs for Windows this is required.)
// (See measunit_impl.h, datefmt.h, collationiterator.h, erarules.h and others
// for similar examples.)
#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
template class U_I18N_API LocalPointerBase<message2::data_model::PatternPart>;
template class U_I18N_API LocalArray<message2::data_model::PatternPart>;
template class U_I18N_API LocalPointerBase<message2::data_model::UnsupportedStatement>;
template class U_I18N_API LocalArray<message2::data_model::UnsupportedStatement>;
#endif
/// @endcond

namespace message2 {
  namespace data_model {
        /**
         *  A `Pattern` is a sequence of formattable parts.
         * It corresponds to the `Pattern` interface
         * defined in https://github.com/unicode-org/message-format-wg/blob/main/spec/data-model.md#patterns
         *
         * `Pattern` is immutable, copyable and movable.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        class U_I18N_API Pattern : public UObject {
        private:
            friend class PatternPart;

        public:
            struct Iterator;
            /**
             * Returns the parts of this pattern
             *
             * @return A forward iterator of variants. Each element is either a string (text part)
             *         or an expression part.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Iterator begin() const {
                return Iterator(this, 0);
            }
            /**
             * Returns a special value to mark the end of iteration
             *
             * @return A forward iterator of variants. This should only be used for comparisons
             *         against an iterator returned by incrementing begin().
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Iterator end() const {
                return Iterator(this, len);
            }
            /**
             * The mutable `Pattern::Builder` class allows the pattern to be
             * constructed one part at a time.
             *
             * Builder is not copyable or movable.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            class U_I18N_API Builder : public UMemory {
            private:
                friend class Pattern;

                UVector* parts;  // Not a LocalPointer for the same reason as in `SelectorKeys::Builder`

            public:
                /**
                 * Adds a single expression part to the pattern.
                 *
                 * @param part The part to be added (passed by move)
                 * @param status Input/output error code.
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& add(Expression&& part, UErrorCode& status) noexcept;
                /**
                 * Adds a single markup part to the pattern.
                 *
                 * @param part The part to be added (passed by move)
                 * @param status Input/output error code.
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& add(Markup&& part, UErrorCode& status) noexcept;
                /**
                 * Adds a single text part to the pattern. Copies `part`.
                 *
                 * @param part The part to be added (passed by move)
                 * @param status Input/output error code.
                 * @return A reference to the builder.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder& add(UnicodeString&& part, UErrorCode& status) noexcept;
                /**
                 * Constructs a new immutable `Pattern` using the list of parts
                 * set with previous `add()` calls.
                 *
                 * The builder object (`this`) can still be used after calling `build()`.
                 *
                 * @param status    Input/output error code.
                 * @return          The pattern object
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Pattern build(UErrorCode& status) const noexcept;
                /**
                 * Default constructor.
                 * Returns a Builder with an empty sequence of PatternParts.
                 *
                 * @param status Input/output error code
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Builder(UErrorCode& status);
                /**
                 * Destructor.
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                virtual ~Builder();
                Builder(const Builder&) = delete;
                Builder& operator=(const Builder&) = delete;
                Builder(Builder&&) = delete;
                Builder& operator=(Builder&&) = delete;
            }; // class Pattern::Builder

            /**
             * Default constructor.
             * Puts the Pattern into a valid but undefined state.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Pattern() : parts(LocalArray<PatternPart>()) {}
            /**
             * Non-member swap function.
             * @param p1 will get p2's contents
             * @param p2 will get p1's contents
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            friend inline void swap(Pattern& p1, Pattern& p2) noexcept {
                using std::swap;

                swap(p1.bogus, p2.bogus);
                swap(p1.len, p2.len);
                swap(p1.parts, p2.parts);
            }
            /**
             * Copy constructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Pattern(const Pattern& other);
            /**
             * Assignment operator
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Pattern& operator=(Pattern) noexcept;
            /**
             * Destructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            virtual ~Pattern();

            /**
             *  The `Pattern::Iterator` class provides an iterator over the formattable
             * parts of a pattern.
             *
             * `Pattern::Iterator` is mutable and is not copyable or movable.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            struct U_I18N_API Iterator {
            private:
                using iterator_category = std::forward_iterator_tag;
                using difference_type = std::ptrdiff_t;
                using value_type = std::variant<UnicodeString, Expression, Markup>;
                using pointer = value_type*;
                using reference = const value_type&;

                friend class Pattern;
                Iterator(const Pattern* p, int32_t i) : pos(i), pat(p) {}
                friend bool operator== (const Iterator& a, const Iterator& b) { return (a.pat == b.pat && a.pos == b.pos); }

                int32_t pos;
                const Pattern* pat;

            public:
                /**
                 * Dereference operator (gets the element at the current iterator position)
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                reference operator*() const {
                    const PatternPart& part = pat->parts[pos];
                    return patternContents(part);
                }
                /**
                 * Increment operator (advances to the next iterator position)
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                Iterator operator++() { pos++; return *this; }
                /**
                 * Inequality comparison operator (used for comparing an iterator to the result of end())
                 *
                 * @internal ICU 75 technology preview
                 * @deprecated This API is for technology preview only.
                 */
                friend bool operator!= (const Iterator& a, const Iterator& b) { return !(a == b); }
            }; // struct Iterator

        private:
            friend class Builder;
            friend class message2::MessageFormatter;
            friend class message2::Serializer;

            // Set to true if a copy constructor fails;
            // needed in order to distinguish an uninitialized
            // Pattern from a 0-length pattern
            bool bogus = false;

            // Possibly-empty array of parts
            int32_t len = 0;
            LocalArray<PatternPart> parts;

            Pattern(const UVector& parts, UErrorCode& status);
            // Helper
            static void initParts(Pattern&, const Pattern&);

            /**
             * Returns the size.
             *
             * @return The number of parts in the pattern.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            int32_t numParts() const;
            /**
             * Returns the `i`th part in the pattern.
             * Precondition: i < numParts()
             *
             * @param i Index of the part being accessed.
             * @return  A reference to the part at index `i`.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const PatternPart& getPart(int32_t i) const;

            // Gets around not being able to declare Pattern::Iterator as a friend
            // in PatternPart
            static const std::variant<UnicodeString, Expression, Markup>&
                patternContents(const PatternPart& p) { return p.piece; }
        }; // class Pattern

        /**
         *  A `Variant` pairs a list of keys with a pattern
         * It corresponds to the `Variant` interface
         * defined in https://github.com/unicode-org/message-format-wg/tree/main/spec/data-model
         *
         * `Variant` is immutable, copyable and movable.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        class U_I18N_API Variant : public UObject {
        public:
            /**
             * Accesses the pattern of the variant.
             *
             * @return A reference to the pattern.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const Pattern& getPattern() const { return p; }
            /**
             * Accesses the keys of the variant.
             *
             * @return A reference to the keys.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const SelectorKeys& getKeys() const { return k; }
            /**
             * Constructor. Returns a variant that formats to `pattern`
             * when `keys` match the selector expressions in the enclosing
             * `match` construct.
             *
             * @param keys A reference to a `SelectorKeys`.
             * @param pattern A pattern (passed by move)
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Variant(const SelectorKeys& keys, Pattern&& pattern) : k(keys), p(std::move(pattern)) {}
            /**
             * Non-member swap function.
             * @param v1 will get v2's contents
             * @param v2 will get v1's contents
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            friend inline void swap(Variant& v1, Variant& v2) noexcept {
                using std::swap;

                swap(v1.k, v2.k);
                swap(v1.p, v2.p);
            }
            /**
             * Assignment operator
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Variant& operator=(Variant other) noexcept;
            /**
             * Default constructor.
             * Returns a Variant in a valid but undefined state.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Variant() = default;
            /**
             * Copy constructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Variant(const Variant&);
            /**
             * Destructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            virtual ~Variant();
        private:
            /* const */ SelectorKeys k;
            /* const */ Pattern p;
        }; // class Variant
    } // namespace data_model

        namespace data_model {
        /**
         *  A `Binding` pairs a variable name with an expression.
         * It corresponds to the `Declaration` interface
         * defined in https://github.com/unicode-org/message-format-wg/blob/main/spec/data-model.md#messages
         *
         * `Binding` is immutable and copyable. It is not movable.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        class U_I18N_API Binding : public UObject {
        public:
            /**
             * Accesses the right-hand side of a binding.
             *
             * @return A reference to the expression.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const Expression& getValue() const;
            /**
             * Accesses the left-hand side of the binding.
             *
             * @return A reference to the variable name.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            const VariableName& getVariable() const { return var; }
            /**
             * Constructor for input binding.
             *
             * @param variableName The variable name (left-hand side) of the binding. Passed by move.
             * @param rhs The right-hand side of the input binding. Passed by move.
             *                   `rhs` must have an operand that is a variable reference to `variableName`.
             *                   If `rhs` has an operator, it must be a function call.
             *                   If either of these properties is violated, `errorCode` is set to
             *                   U_INVALID_STATE_ERROR.
             * @param errorCode Input/output error code
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            static Binding input(UnicodeString&& variableName, Expression&& rhs, UErrorCode& errorCode);
            /**
             * Returns true if and only if this binding represents a local declaration.
             * Otherwise, it's an input declaration.
             *
             * @return True if this binding represents a variable and expression;
             *         false if it represents a variable plus an annotation.
             */
            UBool isLocal() const { return local; }
            /**
             * Constructor.
             *
             * @param v A variable name.
             * @param e An expression.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Binding(const VariableName& v, Expression&& e) : var(v), expr(std::move(e)), local(true), annotation(nullptr) {}
            /**
             * Non-member swap function.
             * @param b1 will get b2's contents
             * @param b2 will get b1's contents
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            friend inline void swap(Binding& b1, Binding& b2) noexcept {
                using std::swap;

                swap(b1.var, b2.var);
                swap(b1.expr, b2.expr);
                swap(b1.local, b2.local);
                b1.updateAnnotation();
                b2.updateAnnotation();
            }
            /**
             * Copy constructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Binding(const Binding& other);
            /**
             * Copy assignment operator
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Binding& operator=(Binding) noexcept;
            /**
             * Default constructor.
             * Puts the Binding into a valid but undefined state.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Binding() : local(true) {}
            /**
             * Destructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            virtual ~Binding();
        private:
            friend class message2::Checker;
            friend class message2::MessageFormatter;
            friend class message2::Parser;
            friend class message2::Serializer;

            /* const */ VariableName var;
            /* const */ Expression expr;
            /* const */ bool local;

            // The following field is always nullptr for a local
            // declaration, and possibly nullptr for an .input declaration
            // If non-null, the referent is a member of `expr` so
            // its lifetime is the same as the lifetime of the enclosing Binding
            // (as long as there's no mutation)
            const Callable* annotation = nullptr;

            const OptionMap& getOptionsInternal() const;

            bool hasAnnotation() const { return !local && (annotation != nullptr); }
            void updateAnnotation();
        }; // class Binding
    } // namespace data_model
} // namespace message2

  /// @cond DOXYGEN_IGNORE
// Export an explicit template instantiation of the LocalPointer that is used as a
// data member of various MFDataModel classes.
// (When building DLLs for Windows this is required.)
// (See measunit_impl.h, datefmt.h, collationiterator.h, erarules.h and others
// for similar examples.)
#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
template class U_I18N_API LocalPointerBase<message2::data_model::Variant>;
template class U_I18N_API LocalPointerBase<message2::data_model::Binding>;
template class U_I18N_API LocalArray<message2::data_model::Variant>;
template class U_I18N_API LocalArray<message2::data_model::Binding>;
#endif
/// @endcond

namespace message2 {
    using namespace data_model;


    // Internal only

    class MFDataModel;

    #ifndef U_IN_DOXYGEN
    class Matcher : public UObject {
    public:
        Matcher& operator=(Matcher);
        Matcher(const Matcher&);
        /**
         * Non-member swap function.
         * @param m1 will get m2's contents
         * @param m2 will get m1's contents
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        friend inline void swap(Matcher& m1, Matcher& m2) noexcept {
            using std::swap;

            if (m1.bogus) {
                m2.bogus = true;
                return;
            }
            if (m2.bogus) {
                m1.bogus = true;
                return;
            }
            swap(m1.selectors, m2.selectors);
            swap(m1.numSelectors, m2.numSelectors);
            swap(m1.variants, m2.variants);
            swap(m1.numVariants, m2.numVariants);
        }
        virtual ~Matcher();
    private:

        friend class MFDataModel;

        Matcher(Expression* ss, int32_t ns, Variant* vs, int32_t nv);
        Matcher() {}

        // A Matcher may have numSelectors=0 and numVariants=0
        // (this is a data model error, but it's representable).
        // So we have to keep a separate flag to track failed copies.
        bool bogus = false;

        // The expressions that are being matched on.
        LocalArray<Expression> selectors;
        // The number of selectors
        int32_t numSelectors = 0;
        // The list of `when` clauses (case arms).
        LocalArray<Variant> variants;
        // The number of variants
        int32_t numVariants = 0;
    }; // class Matcher
    #endif
} // namespace message2

U_NAMESPACE_END

/// @cond DOXYGEN_IGNORE
// Export an explicit template instantiation of the std::variant that is used as a
// data member of various MFDataModel classes.
// (When building DLLs for Windows this is required.)
// (See measunit_impl.h, datefmt.h, collationiterator.h, erarules.h and others
// for similar examples.)
#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
#if defined(U_REAL_MSVC) && defined(_MSVC_STL_VERSION)
template class U_I18N_API std::_Variant_storage_<false, icu::message2::Matcher,icu::message2::data_model::Pattern>;
#endif
template class U_I18N_API std::variant<icu::message2::Matcher,icu::message2::data_model::Pattern>;
#endif
/// @endcond

U_NAMESPACE_BEGIN

namespace message2 {
    // -----------------------------------------------------------------------
    // Public MFDataModel class

    /**
     *
     * The `MFDataModel` class describes a parsed representation of the text of a message.
     * This representation is public as higher-level APIs for messages will need to know its public
     * interface: for example, to re-instantiate a parsed message with different values for imported
     variables.
     *
     * The MFDataModel API implements <a target="github"
     href="https://github.com/unicode-org/message-format-wg/blob/main/spec/data-model.md">the
     * specification of the abstract syntax (data model representation)</a> for MessageFormat.
     *
     * `MFDataModel` is immutable, copyable and movable.
     *
     * @internal ICU 75 technology preview
     * @deprecated This API is for technology preview only.
     */
    class U_I18N_API MFDataModel : public UMemory {
        /*
          Classes that represent nodes in the data model are nested inside the
          `MFDataModel` class.

          Classes such as `Expression`, `Pattern` and `VariantMap` are immutable and
          are constructed using the builder pattern.

          Most classes representing nodes have copy constructors. This is because builders
          contain immutable data that must be copied when calling `build()`, since the builder
          could go out of scope before the immutable result of the builder does. Copying is
          also necessary to prevent unexpected mutation if intermediate builders are saved
          and mutated again after calling `build()`.

          The copy constructors perform a deep copy, for example by copying the entire
          list of options for an `Operator` (and copying the entire underlying vector.)
          Some internal fields should be `const`, but are declared as non-`const` to make
          the copy constructor simpler to implement. (These are noted throughout.) In
          other words, those fields are `const` except during the execution of a copy
          constructor.

          On the other hand, intermediate `Builder` methods that return a `Builder&`
          mutate the state of the builder, so in code like:

          Expression::Builder& exprBuilder = Expression::builder()-> setOperand(foo);
          Expression::Builder& exprBuilder2 = exprBuilder.setOperator(bar);

          the call to `setOperator()` would mutate `exprBuilder`, since `exprBuilder`
          and `exprBuilder2` are references to the same object.

          An alternate choice would be to make `build()` destructive, so that copying would
          be unnecessary. Or, both copying and moving variants of `build()` could be
          provided. Copying variants of the intermediate `Builder` methods could be
          provided as well, if this proved useful.
        */
    public:
        /**
         * Accesses the local variable declarations for this data model.
         *
         * @return A vector of bindings for local variables.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        std::vector<Binding> getLocalVariables() const {
            std::vector<Binding> result;
            if (!bogus) {
                return toStdVector<Binding>(bindings.getAlias(), bindingsLen);
            }
            return {};
        }
        /**
         * Accesses the selectors. Returns an empty vector if this is a pattern message.
         *
         * @return A vector of selectors.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        const std::vector<Expression> getSelectors() const {
            if (std::holds_alternative<Pattern>(body)) {
                return {};
            }
            const Matcher* match = std::get_if<Matcher>(&body);
            // match must be non-null, given the previous check
            return toStdVector<Expression>(match->selectors.getAlias(), match->numSelectors);
        }
        /**
         * Accesses the variants. Returns an empty vector if this is a pattern message.
         *
         * @return A vector of variants.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        std::vector<Variant> getVariants() const {
            // Return empty vector if no variants
            if (std::holds_alternative<Pattern>(body)) {
                return {};
            }
            const Matcher* match = std::get_if<Matcher>(&body);
            // match must be non-null, given the previous check
            return toStdVector<Variant>(match->variants.getAlias(), match->numVariants);
            return {};
        }
        /**
         * Accesses the unsupported statements for this data model.
         *
         * @return A vector of unsupported statements.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        std::vector<UnsupportedStatement> getUnsupportedStatements() const {
            std::vector<UnsupportedStatement> result;
            if (!bogus) {
                return toStdVector<UnsupportedStatement>(unsupportedStatements.getAlias(), unsupportedStatementsLen);
            }
            return {};
        }
        /**
         * Accesses the pattern (in a message without selectors).
         * Returns a reference to an empty pattern if the message has selectors.
         *
         * @return A reference to the pattern.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        const Pattern& getPattern() const;

        /**
         * The mutable `MFDataModel::Builder` class allows the data model to be
         * constructed incrementally.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        class U_I18N_API Builder;

        /**
         * Default constructor.
         * Puts the MFDataModel into a valid but undefined state.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        MFDataModel();
        /**
         * Non-member swap function.
         * @param m1 will get m2's contents
         * @param m2 will get m1's contents
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        friend inline void swap(MFDataModel& m1, MFDataModel& m2) noexcept {
            using std::swap;

            if (m1.bogus) {
                m2.bogus = true;
                return;
            }
            if (m2.bogus) {
                m1.bogus = true;
                return;
            }
            swap(m1.body, m2.body);
            swap(m1.bindings, m2.bindings);
            swap(m1.bindingsLen, m2.bindingsLen);
            swap(m1.unsupportedStatements, m2.unsupportedStatements);
            swap(m1.unsupportedStatementsLen, m2.unsupportedStatementsLen);
        }
        /**
         * Assignment operator
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        MFDataModel& operator=(MFDataModel) noexcept;
        /**
         * Copy constructor.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        MFDataModel(const MFDataModel& other);
        /**
         * Destructor.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        virtual ~MFDataModel();

        /**
         * The mutable `MFDataModel::Builder` class allows the data model to be
         * constructed incrementally. Builder is not copyable or movable.
         *
         * @internal ICU 75 technology preview
         * @deprecated This API is for technology preview only.
         */
        class U_I18N_API Builder : public UMemory {
        private:
            friend class MFDataModel;

            void checkDuplicate(const VariableName&, UErrorCode&) const;
            void buildSelectorsMessage(UErrorCode&);
            bool hasPattern = true;
            bool hasSelectors = false;
            Pattern pattern;
            // The following members are not LocalPointers for the same reason as in SelectorKeys::Builder
            UVector* selectors = nullptr;
            UVector* variants = nullptr;
            UVector* bindings = nullptr;
            UVector* unsupportedStatements = nullptr;
        public:
            /**
             * Adds a binding, There must not already be a binding
             * with the same name.
             *
             * @param b The binding. Passed by move.
             * @param status Input/output error code. Set to U_DUPLICATE_DECLARATION_ERROR
             *                   if `addBinding()` was previously called with a binding
             *                   with the same variable name as `b`.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Builder& addBinding(Binding&& b, UErrorCode& status);
            /**
             * Adds an unsupported statement.
             *
             * @param s The statement. Passed by move.
             * @param status Input/output error code.
             *
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Builder& addUnsupportedStatement(UnsupportedStatement&& s, UErrorCode& status);
            /**
             * Adds a selector expression. Copies `expression`.
             * If a pattern was previously set, clears the pattern.
             *
             * @param selector Expression to add as a selector. Passed by move.
             * @param errorCode Input/output error code
             * @return A reference to the builder.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Builder& addSelector(Expression&& selector, UErrorCode& errorCode) noexcept;
            /**
             * Adds a single variant.
             * If a pattern was previously set using `setPattern()`, clears the pattern.
             *
             * @param keys Keys for the variant. Passed by move.
             * @param pattern Pattern for the variant. Passed by move.
             * @param errorCode Input/output error code
             * @return A reference to the builder.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Builder& addVariant(SelectorKeys&& keys, Pattern&& pattern, UErrorCode& errorCode) noexcept;
            /**
             * Sets the body of the message as a pattern.
             * If selectors and/or variants were previously set, clears them.
             *
             * @param pattern Pattern to represent the body of the message.
             *                Passed by move.
             * @return A reference to the builder.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Builder& setPattern(Pattern&& pattern);
            /**
             * Constructs a new immutable data model.
             * If `setPattern()` has not been called and if `addSelector()` and
             * `addVariant()` were not each called at least once,
             * `status` is set to `U_INVALID_STATE_ERROR`.
             * If `addSelector()` was called and `addVariant()` was never called,
             * or vice versa, then `status` is set to U_INVALID_STATE_ERROR.
             * Otherwise, either a Pattern or Selectors message is constructed
             * based on the pattern that was previously set, or selectors and variants
             * that were previously set.
             *
             * The builder object (`this`) can still be used after calling `build()`.
             *
             * @param status Input/output error code.
             * @return       The new MFDataModel
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            MFDataModel build(UErrorCode& status) const noexcept;
            /**
             * Default constructor.
             * Returns a Builder with no pattern or selectors set.
             * Either `setPattern()` or both `addSelector()` and
             * `addVariant()` must be called before calling `build()`
             * on the resulting builder.
             *
             * @param status Input/output error code.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            Builder(UErrorCode& status);
            /**
             * Destructor.
             *
             * @internal ICU 75 technology preview
             * @deprecated This API is for technology preview only.
             */
            virtual ~Builder();
            Builder(const Builder&) = delete;
            Builder& operator=(const Builder&) = delete;
            Builder(Builder&&) = delete;
            Builder& operator=(Builder&&) = delete;
        }; // class Builder

    private:
        friend class Checker;
        friend class MessageFormatter;
        friend class Serializer;

        Pattern empty; // Provided so that `getPattern()` can return a result
                       // if called on a selectors message
        bool hasPattern() const { return std::holds_alternative<Pattern>(body); }

        bool bogus = false; // Set if a copy constructor fails

        // A message body is either a matcher (selector list and variant list),
        // or a single pattern
        std::variant<Matcher, Pattern> body;

        // Bindings for local variables
        /* const */ LocalArray<Binding> bindings;
        int32_t bindingsLen = 0;

        // Unsupported statements
        // (Treated as a type of `declaration` in the data model spec;
        // stored separately for convenience)
        /* const */ LocalArray<UnsupportedStatement> unsupportedStatements;
        int32_t unsupportedStatementsLen = 0;

        const Binding* getLocalVariablesInternal() const;
        const Expression* getSelectorsInternal() const;
        const Variant* getVariantsInternal() const;
        const UnsupportedStatement* getUnsupportedStatementsInternal() const;

        int32_t numSelectors() const {
            const Matcher* matcher = std::get_if<Matcher>(&body);
            return (matcher == nullptr ? 0 : matcher->numSelectors);
        }
        int32_t numVariants() const {
            const Matcher* matcher = std::get_if<Matcher>(&body);
            return (matcher == nullptr ? 0 : matcher->numVariants);
        }

        // Helper
        void initBindings(const Binding*);

        MFDataModel(const Builder& builder, UErrorCode&) noexcept;
    }; // class MFDataModel

} // namespace message2

U_NAMESPACE_END

#endif // U_HIDE_DEPRECATED_API

#endif /* #if !UCONFIG_NO_MF2 */

#endif /* #if !UCONFIG_NO_FORMATTING */

#endif /* U_SHOW_CPLUSPLUS_API */

#endif // MESSAGEFORMAT_DATA_MODEL_H

// eof