import { RxapElement } from '../element';
import { ParsedElement } from '../elements/parsed-element';
import { XmlParserService } from '../xml-parser.service';
import { XmlSerializerService } from '../xml-serializer.service';
import { ElementParser } from './element.parser';
import { ElementSerializer } from './element.serializer';
import { TagElementOptions, TagElementMixin } from './mixins/tag-element.mixin';
import { TextContentElementOptions, TextContentElementMixin } from './mixins/text-content-element.mixin';
export interface ElementChildRawContentParserOptions<Value> extends TextContentElementOptions<Value>, TagElementOptions {
}
/**
 * Asserts that the provided `options` object is an instance of `ElementChildRawContentOptions`.
 * This function performs a runtime check to ensure that the `options` object conforms to the expected structure
 * of `ElementChildRawContentOptions`. Specifically, it checks if the `options` object has a "tag" property,
 * which is essential for identifying it as a valid `ElementChildRawContentOptions` instance.
 *
 * @param options - The object to be validated as an instance of `ElementChildRawContentOptions`.
 * @throws {Error} Throws an error if the `options` object does not have a "tag" property, indicating
 * that it is not a valid `ElementChildRawContentOptions`.
 * @template T - The type parameter that specifies the type of the content within the `ElementChildRawContentOptions`.
 */
export declare function AssertElementChildRawContentOptions(options: any): asserts options is ElementChildRawContentParserOptions<any>;
export interface ElementChildRawContentParser<T extends ParsedElement> extends TextContentElementMixin<string>, TagElementMixin {
}
export declare class ElementChildRawContentParser<T extends ParsedElement> implements ElementParser<T> {
    readonly propertyKey: string;
    readonly options: ElementChildRawContentParserOptions<string>;
    constructor(propertyKey: string, options: ElementChildRawContentParserOptions<string>);
    parse(xmlParser: XmlParserService, element: RxapElement, parsedElement: T): T;
}
export interface ElementChildRawContentSerializerOptions<Value> extends TextContentElementOptions<Value>, TagElementOptions {
}
export interface ElementChildRawContentSerializer<T extends ParsedElement> extends TextContentElementMixin<string>, TagElementMixin {
}
export declare class ElementChildRawContentSerializer<T extends ParsedElement> implements ElementSerializer<T> {
    readonly propertyKey: string;
    readonly options: ElementChildRawContentParserOptions<string>;
    constructor(propertyKey: string, options: ElementChildRawContentParserOptions<string>);
    serialize(xmlParser: XmlSerializerService, element: RxapElement, parsedElement: T): void;
}
/**
 * Decorator factory that creates a decorator to parse and inject raw content from a child element into a class property.
 *
 * This decorator can be applied to properties within classes that are meant to interact with DOM-like structures, where
 * the content of a specified child element is directly assigned to the property. The child element is identified by a tag,
 * which can be customized through the options provided.
 *
 * @param {Partial<ElementChildRawContentParserOptions<Value>> | string} optionsOrString - This parameter can either be a string
 * representing the tag of the child element or an object containing various configuration options. If a string is provided,
 * it is used as the tag name of the child element. If an object is provided, it can specify detailed options such as the tag name,
 * whether the child element is required, and other parser-specific options.
 *
 * @returns {Function} A class decorator function that takes two parameters: `target`, the constructor of the class, and
 * `propertyKey`, the name of the property to which the decorator is applied. This decorator function initializes and configures
 * an instance of `ElementChildRawContentParser` based on the provided options and attaches it to the metadata of the target class.
 *
 * ### Usage
 *
 * ```typescript
 * class MyComponent {
 * @ElementChildRawContent({ tag: 'my-child', required: true })
 * content: string;
 * }
 * ```
 *
 * In the above example, the `ElementChildRawContent` decorator is used to specify that the `content` property of `MyComponent`
 * should be filled with the raw content of a child element `<my-child>` which is required to be present.
 *
 */
export declare function ElementChildRawContent<Value>(optionsOrString?: Partial<ElementChildRawContentParserOptions<Value> & ElementChildRawContentSerializerOptions<Value>> | string): (target: any, propertyKey: string) => void;