@speclynx/apidom-datamodel 1.12.2

package/types/apidom-datamodel.d.ts

@@ -0,0 +1,887 @@
+/**
+ * ArrayElement represents an array/collection of elements in ApiDOM.
+ *
+ * @typeParam T - The element type contained in the array, defaults to Element
+ * @public
+ */
+export declare class ArrayElement<T extends Element_2 = Element_2> extends CollectionElement<T> {
+    static empty<T extends Element_2 = Element_2>(): ArrayElement<T>;
+    static 'fantasy-land/empty'<T extends Element_2 = Element_2>(): ArrayElement<T>;
+    constructor(content?: unknown[], meta?: Meta, attributes?: Attributes);
+    primitive(): string;
+    /**
+     * Gets the element at the specified index.
+     */
+    get(index: number): T | undefined;
+    /**
+     * Helper for returning the value of an item.
+     */
+    getValue(index: number): unknown;
+    /**
+     * Sets the element at the specified index, or sets the content if called with one argument.
+     */
+    set(indexOrContent: number | unknown, value?: unknown): this;
+    /**
+     * Removes the element at the specified index.
+     */
+    remove(index: number): T | null;
+    /**
+     * Maps each element using the provided callback function.
+     */
+    map<U>(callback: (element: T, index: number, array: T[]) => U, thisArg?: unknown): U[];
+    /**
+     * Maps and then flattens the results.
+     */
+    flatMap<U>(callback: (element: T, index: number, array: T[]) => U | U[], thisArg?: unknown): U[];
+    /**
+     * Returns an array containing the truthy results of calling the given transformation.
+     */
+    compactMap<U>(transform: (element: T) => U | undefined | null, thisArg?: unknown): U[];
+    /**
+     * Filters elements using the provided callback.
+     */
+    filter(callback: (element: T) => boolean, thisArg?: unknown): ArrayElement<T>;
+    /**
+     * Rejects elements that match the provided callback.
+     */
+    reject(callback: (element: T) => boolean, thisArg?: unknown): ArrayElement<T>;
+    /**
+     * Reduces the array to a single value.
+     * This is a reduce function specifically for datamodel arrays and objects.
+     * It allows for returning normal values or datamodel instances.
+     */
+    reduce<U>(callback: (memo: U, item: T, index: number, arr: this) => U, initialValue?: U): U;
+    /**
+     * Executes a provided function once for each element.
+     */
+    forEach(callback: (element: T, index: number) => void, thisArg?: unknown): void;
+    /**
+     * Returns an empty array element.
+     */
+    empty(): ArrayElement<T>;
+    'fantasy-land/map'(transform: (element: T) => T): ArrayElement<T>;
+    'fantasy-land/chain'(transform: (element: T) => ArrayElement<T>): ArrayElement<T>;
+    'fantasy-land/filter'(callback: (element: T) => boolean): ArrayElement<T>;
+    'fantasy-land/reduce'<U>(transform: (acc: U, element: T) => U, initialValue: U): U;
+}
+
+/**
+ * Attributes associated with an element.
+ * Can be a plain object or an ObjectElement.
+ * Attributes are element-specific properties beyond the standard meta.
+ * @public
+ */
+export declare type Attributes = Record<string, unknown> | ObjectElement;
+
+/**
+ * BooleanElement represents a boolean value in ApiDOM.
+ * @public
+ */
+export declare class BooleanElement extends Element_2 {
+    constructor(content?: boolean, meta?: Meta, attributes?: Attributes);
+    primitive(): string;
+}
+
+/**
+ * Type for cloneable objects.
+ * @public
+ */
+export declare interface Cloneable<T> {
+    clone(): T;
+}
+
+/**
+ * CollectionElement is an abstract base class for collection-like elements.
+ * Both ArrayElement and ObjectElement extend this class.
+ *
+ * This class contains the shared functionality between arrays and objects,
+ * while keeping the conflicting methods (get, set, remove, map, filter, etc.)
+ * in the respective subclasses.
+ *
+ * @remarks
+ * This is primarily an implementation detail. Use ArrayElement or ObjectElement directly.
+ *
+ * @typeParam T - The element type contained in the collection, defaults to Element
+ * @public
+ */
+export declare abstract class CollectionElement<T extends Element_2 = Element_2> extends Element_2 {
+    protected _content: T[];
+    constructor(content?: unknown[], meta?: Meta, attributes?: Attributes);
+    /**
+     * Returns the length of the collection.
+     */
+    get length(): number;
+    /**
+     * Returns whether the collection is empty.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Return the first item in the collection.
+     */
+    get first(): T | undefined;
+    /**
+     * Return the second item in the collection.
+     */
+    get second(): T | undefined;
+    /**
+     * Return the last item in the collection.
+     */
+    get last(): T | undefined;
+    /**
+     * Adds the given element to the end of the collection.
+     */
+    push(value: unknown): this;
+    /**
+     * Alias for push.
+     */
+    add(value: unknown): void;
+    /**
+     * Removes the first element from the collection.
+     */
+    shift(): T | undefined;
+    /**
+     * Adds the given element to the beginning of the collection.
+     */
+    unshift(value: unknown): void;
+    /**
+     * Looks for matching children using deep equality.
+     */
+    includes(value: unknown): boolean;
+    /**
+     * Recursively search all descendants using a condition function.
+     */
+    findElements(condition: FindCondition, givenOptions?: FindOptions): Element_2[];
+    /**
+     * Recursively search all descendants using a condition function.
+     */
+    find(condition: FindCondition): ArrayElement;
+    /**
+     * Find elements by their element type name.
+     */
+    findByElement(element: string): ArrayElement;
+    /**
+     * Find elements by class name.
+     */
+    findByClass(className: string): ArrayElement;
+    /**
+     * Search the tree recursively and find the element with the matching ID.
+     */
+    getById(id: string): Element_2 | undefined;
+    /**
+     * Returns an empty collection element.
+     */
+    abstract empty(): CollectionElement<T>;
+    'fantasy-land/empty'(): CollectionElement<T>;
+    /**
+     * Concatenates two collection elements.
+     */
+    concat(other: CollectionElement<T>): CollectionElement<T>;
+    'fantasy-land/concat'(other: CollectionElement<T>): CollectionElement<T>;
+    [Symbol.iterator](): IterableIterator<T>;
+}
+
+/**
+ * Tuple of detection test and element class.
+ * @public
+ */
+export declare type DetectionEntry = [DetectionTest, ElementClass];
+
+/**
+ * Function to test if a value should be converted to a specific element type.
+ * @public
+ */
+export declare type DetectionTest = (value: unknown) => boolean;
+
+/**
+ * Base Element class that all ApiDOM elements extend.
+ *
+ * Elements are the core building blocks of ApiDOM. Each element has:
+ * - An `element` property identifying its type
+ * - Optional `content` holding the element's value
+ * - Optional `meta` for metadata (id, classes, title, description, links)
+ * - Optional `attributes` for element-specific properties
+ *
+ * @public
+ */
+declare class Element_2 implements Cloneable<Element_2>, ToValue, Equatable, Freezable {
+    /**
+     * The element type identifier.
+     * @internal
+     */
+    protected _storedElement: string;
+    /**
+     * The element's content/value.
+     * @internal
+     */
+    protected _content?: ElementContent;
+    /**
+     * Metadata about this element.
+     * @internal
+     */
+    protected _meta?: Element_2;
+    /**
+     * Element-specific attributes.
+     * @internal
+     */
+    protected _attributes?: Element_2;
+    /**
+     * Parent element reference (set when tree is frozen).
+     */
+    parent?: Element_2;
+    /** @internal ObjectElement constructor for creating meta/attributes */
+    ObjectElement: new (content?: Record<string, unknown>) => ObjectElement;
+    /** @internal ArrayElement constructor for creating arrays */
+    ArrayElement: new (content?: Element_2[]) => ArrayElement;
+    /** @internal MemberElement constructor for creating object members */
+    MemberElement: new (key?: unknown, value?: unknown) => Element_2;
+    /** @internal RefElement constructor for creating references */
+    RefElement: new (content?: unknown) => Element_2 & {
+        path?: Element_2;
+    };
+    /** @internal Function to convert values to elements */
+    refract: (value: unknown) => Element_2;
+    constructor(content?: unknown, meta?: Meta, attributes?: Attributes);
+    /**
+     * The element type identifier (e.g., 'string', 'object', 'array').
+     */
+    get element(): string;
+    set element(value: string);
+    /**
+     * The element's content/value.
+     */
+    get content(): ElementContent;
+    set content(value: unknown);
+    /**
+     * Metadata about this element (id, classes, title, description, links).
+     * Lazily creates an ObjectElement if not set.
+     */
+    get meta(): ObjectElement;
+    set meta(value: Meta);
+    /**
+     * Element-specific attributes.
+     * Lazily creates an ObjectElement if not set.
+     */
+    get attributes(): ObjectElement;
+    set attributes(value: Attributes);
+    /** Unique identifier for this element. */
+    get id(): Element_2;
+    set id(value: Element_2 | string);
+    /** CSS-like class names. */
+    get classes(): Element_2;
+    set classes(value: Element_2 | unknown[]);
+    /** Human-readable title. */
+    get title(): Element_2;
+    set title(value: Element_2 | string);
+    /** Human-readable description. */
+    get description(): Element_2;
+    set description(value: Element_2 | string);
+    /** Hyperlinks associated with this element. */
+    get links(): Element_2;
+    set links(value: Element_2 | unknown[]);
+    /** Returns direct children of this element. */
+    get children(): Element_2[];
+    /** Whether this element is frozen (immutable). */
+    get isFrozen(): boolean;
+    /**
+     * Freezes the element tree, making it immutable.
+     * Sets up parent references for tree traversal.
+     */
+    freeze(): void;
+    /**
+     * Creates a deep clone of this element.
+     */
+    clone(): Element_2;
+    /**
+     * Converts the element to its JavaScript value representation.
+     */
+    toValue(): unknown;
+    /**
+     * Checks deep equality with another value.
+     */
+    equals(value: unknown): boolean;
+    /**
+     * Returns the primitive type name for this element.
+     * Override in subclasses (e.g., 'string', 'number', 'array').
+     */
+    primitive(): string | undefined;
+    /**
+     * Sets the content of this element.
+     * @returns this for chaining
+     */
+    set(content: unknown): this;
+    /**
+     * Creates a RefElement pointing to this element.
+     * @param path - Optional path within the referenced element
+     * @throws Error if this element has no ID
+     */
+    toRef(path?: string): Element_2;
+    /**
+     * Gets a meta property, creating it with default value if not present.
+     */
+    protected getMetaProperty(name: string, defaultValue: unknown): Element_2;
+    /**
+     * Sets a meta property.
+     */
+    protected setMetaProperty(name: string, value: unknown): void;
+}
+export { Element_2 as Element }
+
+/**
+ * Constructor type for Element classes.
+ * @public
+ */
+export declare type ElementClass = new (...args: any[]) => Element_2;
+
+/**
+ * Valid content types for an Element.
+ * @public
+ */
+export declare type ElementContent = Element_2 | Element_2[] | KeyValuePair | string | number | bigint | symbol | boolean | null | undefined;
+
+/**
+ * Map of registered element classes.
+ * @public
+ */
+export declare interface ElementsMap {
+    Element: ElementClass;
+    [key: string]: ElementClass;
+}
+
+/**
+ * Type for objects that support deep equality comparison.
+ * @public
+ */
+export declare interface Equatable {
+    equals(value: unknown): boolean;
+}
+
+/**
+ * Condition function for finding elements.
+ * @public
+ */
+export declare type FindCondition = (item: Element_2, keyOrIndex: Element_2 | number, member?: Element_2) => boolean;
+
+/**
+ * Options for finding elements.
+ * @public
+ */
+export declare interface FindOptions {
+    recursive?: boolean;
+    results?: Element_2[];
+}
+
+/**
+ * Type for freezable objects (immutable after freeze).
+ * @public
+ */
+export declare interface Freezable {
+    freeze(): void;
+    readonly isFrozen: boolean;
+}
+
+/**
+ * JSONSerialiser handles serialization and deserialization of ApiDOM elements
+ * to and from JSON Refract format.
+ * @public
+ */
+export declare class JSONSerialiser {
+    namespace: Namespace;
+    Namespace: typeof Namespace;
+    constructor(namespace?: Namespace);
+    /**
+     * Serializes an Element to JSON Refract format.
+     */
+    serialise(element: Element_2): SerializedElement;
+    /**
+     * Deserializes a JSON Refract document to an Element.
+     */
+    deserialise(value: RefractDocument): Element_2;
+    protected serialiseContent(content: unknown): SerializedContent;
+    protected deserialiseContent(content: unknown): unknown;
+    protected serialiseObject(obj: ObjectElement): Record<string, SerializedElement> | undefined;
+    protected deserialiseObject(from: Record<string, RefractDocument>, to: ObjectElement): void;
+}
+
+/**
+ * Represents a key-value pair used in MemberElement content.
+ * This is used internally to store object member data.
+ *
+ * @typeParam K - Key element type
+ * @typeParam V - Value element type
+ * @public
+ */
+export declare class KeyValuePair<K extends Element_2 = Element_2, V extends Element_2 = Element_2> implements Cloneable<KeyValuePair<K, V>> {
+    key: K | undefined;
+    value: V | undefined;
+    constructor(key?: K, value?: V);
+    /**
+     * Creates a deep clone of the KeyValuePair.
+     */
+    clone(): KeyValuePair<K, V>;
+    /**
+     * Converts to a plain JavaScript object representation.
+     */
+    toValue(): {
+        key: unknown;
+        value: unknown;
+    };
+}
+
+/**
+ * LinkElement represents a hyperlink in ApiDOM.
+ *
+ * Hyperlinking MAY be used to link to other resources, provide links to
+ * instructions on how to process a given element (by way of a profile or
+ * other means), and may be used to provide meta data about the element in
+ * which it's found. The meaning and purpose of the hyperlink is defined by
+ * the link relation according to RFC 5988.
+ *
+ * @public
+ */
+export declare class LinkElement extends Element_2 {
+    constructor(content?: unknown, meta?: Meta, attributes?: Attributes);
+    /**
+     * The relation identifier for the link, as defined in RFC 5988.
+     */
+    get relation(): Element_2 | undefined;
+    set relation(relation: string | Element_2 | undefined);
+    /**
+     * The URI for the given link.
+     */
+    get href(): Element_2 | undefined;
+    set href(href: string | Element_2 | undefined);
+}
+
+/**
+ * MemberElement represents a key-value pair member in an ObjectElement.
+ *
+ * The member's content is always a KeyValuePair containing:
+ * - `key`: The key element (typically a StringElement)
+ * - `value`: The value element (any Element type)
+ *
+ * @typeParam K - The key element type, defaults to Element
+ * @typeParam V - The value element type, defaults to Element
+ * @public
+ */
+export declare class MemberElement<K extends Element_2 = Element_2, V extends Element_2 = Element_2> extends Element_2 {
+    protected _content: KeyValuePair;
+    constructor(key?: unknown, value?: unknown, meta?: Meta, attributes?: Attributes);
+    primitive(): string;
+    /**
+     * The key element of this member.
+     */
+    get key(): K | undefined;
+    set key(value: unknown);
+    /**
+     * The value element of this member.
+     */
+    get value(): V | undefined;
+    set value(value: unknown);
+}
+
+/**
+ * Metadata associated with an element.
+ * Can be a plain object or an ObjectElement.
+ * Common meta properties include: id, classes, title, description, links.
+ * @public
+ */
+export declare type Meta = Record<string, unknown> | ObjectElement;
+
+/**
+ * A refract element implementation with an extensible namespace, able to
+ * load other namespaces into it.
+ *
+ * The namespace allows you to register your own classes to be instantiated
+ * when a particular refract element is encountered, and allows you to specify
+ * which elements get instantiated for existing JavaScript objects.
+ *
+ * @public
+ */
+export declare class Namespace {
+    elementMap: Record<string, ElementClass>;
+    elementDetection: DetectionEntry[];
+    Element: typeof Element_2;
+    KeyValuePair: typeof KeyValuePair;
+    protected _elements?: ElementsMap;
+    protected _attributeElementKeys: string[];
+    protected _attributeElementArrayKeys: string[];
+    constructor(options?: NamespaceOptions);
+    /**
+     * Use a namespace plugin or load a generic plugin.
+     */
+    use(plugin: NamespacePlugin): this;
+    /**
+     * Use the default namespace. This preloads all the default elements
+     * into this registry instance.
+     */
+    useDefault(): this;
+    /**
+     * Register a new element class for an element.
+     */
+    register(name: string, ElementClass: ElementClass): this;
+    /**
+     * Unregister a previously registered class for an element.
+     */
+    unregister(name: string): this;
+    /**
+     * Add a new detection function to determine which element
+     * class to use when converting existing JS instances into
+     * refract elements.
+     */
+    detect(test: DetectionTest, ElementClass: ElementClass, givenPrepend?: boolean): this;
+    /**
+     * Convert an existing JavaScript object into refract element instances.
+     * If the item passed in is already refracted, then it is returned unmodified.
+     */
+    toElement(value: unknown): Element_2 | undefined;
+    /**
+     * Get an element class given an element name.
+     */
+    getElementClass(element: string): ElementClass;
+    /**
+     * Convert a refract document into refract element instances.
+     */
+    fromRefract(doc: Record<string, unknown>): Element_2;
+    /**
+     * Convert an element to a Refracted JSON object.
+     */
+    toRefract(element: Element_2): ReturnType<JSONSerialiser['serialise']>;
+    /**
+     * Get an object that contains all registered element classes, where
+     * the key is the PascalCased element name and the value is the class.
+     */
+    get elements(): ElementsMap;
+    /**
+     * Convenience method for getting a JSON Serialiser configured with the
+     * current namespace.
+     */
+    get serialiser(): JSONSerialiser;
+}
+
+/**
+ * Options for Namespace constructor.
+ * @public
+ */
+export declare interface NamespaceOptions {
+    noDefault?: boolean;
+}
+
+/**
+ * Plugin interface for extending Namespace.
+ * @public
+ */
+export declare interface NamespacePlugin {
+    namespace?: (options: {
+        base: Namespace;
+    }) => void;
+    load?: (options: {
+        base: Namespace;
+    }) => void;
+}
+
+/**
+ * NullElement represents a null value in ApiDOM.
+ * @public
+ */
+export declare class NullElement extends Element_2 {
+    constructor(content?: null, meta?: Meta, attributes?: Attributes);
+    primitive(): string;
+    /**
+     * NullElement cannot have its value changed.
+     * @throws Error - NullElement value cannot be modified
+     */
+    set(_content?: unknown): this;
+}
+
+/**
+ * NumberElement represents a numeric value in ApiDOM.
+ * @public
+ */
+export declare class NumberElement extends Element_2 {
+    constructor(content?: number, meta?: Meta, attributes?: Attributes);
+    primitive(): string;
+}
+
+/**
+ * ObjectElement represents an object/dictionary of key-value pairs in ApiDOM.
+ *
+ * @typeParam K - The key element type, defaults to Element
+ * @typeParam V - The value element type, defaults to Element
+ * @public
+ */
+export declare class ObjectElement<K extends Element_2 = Element_2, V extends Element_2 = Element_2> extends CollectionElement<MemberElement<K, V>> {
+    constructor(content?: Record<string, unknown> | MemberElement<K, V>[], meta?: Meta, attributes?: Attributes);
+    primitive(): string;
+    toValue(): Record<string, unknown>;
+    /**
+     * Gets the value element for the given key.
+     */
+    get(name: string): V | undefined;
+    /**
+     * Helper for returning the value of an item by key.
+     */
+    getValue(name: string): unknown;
+    /**
+     * Gets the member element for the given key.
+     */
+    getMember(name: string | undefined): MemberElement<K, V> | undefined;
+    /**
+     * Removes the member with the given key.
+     */
+    remove(name: string): MemberElement<K, V> | null;
+    /**
+     * Gets the key element for the given key name.
+     */
+    getKey(name: string): K | undefined;
+    /**
+     * Set allows either a key/value pair to be given or an object.
+     * If an object is given, each key is set to its respective value.
+     */
+    set(keyOrObject: string | Record<string, unknown>, value?: unknown): this;
+    /**
+     * Returns an array of all keys' values.
+     */
+    keys(): unknown[];
+    /**
+     * Returns an array of all values' values.
+     */
+    values(): unknown[];
+    /**
+     * Returns whether the object has the given key.
+     */
+    hasKey(value: string): boolean;
+    /**
+     * Returns an array of [key, value] pairs.
+     */
+    items(): [unknown, unknown][];
+    /**
+     * Maps over the member elements, calling callback with (value, key, member).
+     */
+    map<U>(callback: ObjectElementCallback<K, V, U>, thisArg?: unknown): U[];
+    /**
+     * Returns an array containing the truthy results of calling the given transformation.
+     */
+    compactMap<U>(callback: ObjectElementCallback<K, V, U | undefined | null>, thisArg?: unknown): U[];
+    /**
+     * Filters member elements using the provided callback.
+     */
+    filter(callback: ObjectElementCallback<K, V, boolean>, thisArg?: unknown): ObjectSlice;
+    /**
+     * Rejects member elements that match the provided callback.
+     */
+    reject(callback: ObjectElementCallback<K, V, boolean>, thisArg?: unknown): ObjectSlice;
+    /**
+     * Executes a provided function once for each member element.
+     */
+    forEach(callback: (value: V, key: K, member: MemberElement<K, V>) => void, thisArg?: unknown): void;
+    /**
+     * Reduces the object to a single value.
+     * Callback receives (memo, value, key, member, obj).
+     */
+    reduce<U>(callback: (memo: U, value: V, key: K, member: MemberElement<K, V>, obj: this) => U, initialValue?: U): U;
+    /**
+     * Returns an empty object element.
+     */
+    empty(): ObjectElement<K, V>;
+}
+
+/**
+ * Callback type for ObjectElement iteration methods.
+ * @public
+ */
+export declare type ObjectElementCallback<K extends Element_2, V extends Element_2, U> = (value: V, key: K, member: MemberElement<K, V>) => U;
+
+/**
+ * ObjectSlice is a collection wrapper for MemberElement arrays.
+ * It provides functional methods with (value, key, member) callback signatures,
+ * which is the standard pattern for iterating over object-like structures.
+ *
+ * Unlike ArraySlice, ObjectSlice uses composition rather than inheritance
+ * because its callback signatures are fundamentally different.
+ *
+ * @public
+ */
+export declare class ObjectSlice {
+    readonly elements: MemberElement[];
+    constructor(elements?: MemberElement[]);
+    /**
+     * Converts all member elements to their JavaScript values.
+     * Returns an array of \{ key, value \} objects.
+     */
+    toValue(): Array<{
+        key: unknown;
+        value: unknown;
+    }>;
+    /**
+     * Maps over the member elements, calling callback with (value, key, member).
+     * @param callback - Function to execute for each member
+     * @param thisArg - Value to use as this when executing callback
+     */
+    map<U>(callback: ObjectSliceCallback<U>, thisArg?: unknown): U[];
+    /**
+     * Filters member elements using the provided callback.
+     * @param callback - Function that receives (value, key, member) and returns boolean
+     * @param thisArg - Value to use as this when executing callback
+     */
+    filter(callback: ObjectSliceCallback<boolean>, thisArg?: unknown): ObjectSlice;
+    /**
+     * Rejects member elements that match the provided callback.
+     * @param callback - Function that receives (value, key, member) and returns boolean
+     * @param thisArg - Value to use as this when executing callback
+     */
+    reject(callback: ObjectSliceCallback<boolean>, thisArg?: unknown): ObjectSlice;
+    /**
+     * Executes a provided function once for each member element.
+     * @param callback - Function that receives (value, key, member, index)
+     * @param thisArg - Value to use as this when executing callback
+     */
+    forEach(callback: ObjectSliceForEachCallback, thisArg?: unknown): void;
+    /**
+     * Returns the first member element that satisfies the callback.
+     * @param callback - Function that receives (value, key, member) and returns boolean
+     * @param thisArg - Value to use as this when executing callback
+     */
+    find(callback: ObjectSliceCallback<boolean>, thisArg?: unknown): MemberElement | undefined;
+    /**
+     * Returns an array of all keys' values.
+     */
+    keys(): unknown[];
+    /**
+     * Returns an array of all values' values.
+     */
+    values(): unknown[];
+    /**
+     * Returns the number of elements in the slice.
+     */
+    get length(): number;
+    /**
+     * Returns whether the slice is empty.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Returns the first element in the slice or undefined if empty.
+     */
+    get first(): MemberElement | undefined;
+    /**
+     * Gets the element at the specified index.
+     * @param index - The index of the element to get
+     */
+    get(index: number): MemberElement | undefined;
+    /**
+     * Adds the given member element to the end of the slice.
+     * @param member - The member element to add
+     */
+    push(member: MemberElement): this;
+    /**
+     * Creates a deep clone of the ObjectSlice.
+     */
+    clone(): ObjectSlice;
+    /**
+     * Determines whether the slice includes a member with the given key value.
+     * @param keyValue - The key value to search for
+     */
+    includesKey(keyValue: unknown): boolean;
+    /**
+     * Iterator support - allows for...of loops.
+     */
+    [Symbol.iterator](): IterableIterator<MemberElement>;
+}
+
+/**
+ * Callback type for ObjectSlice iteration methods.
+ * Receives (value, key, member) - the standard pattern for object-like iteration.
+ * @public
+ */
+export declare type ObjectSliceCallback<U> = (value: Element_2, key: Element_2, member: MemberElement) => U;
+
+/**
+ * Callback type for ObjectSlice forEach that also receives the index.
+ * @public
+ */
+export declare type ObjectSliceForEachCallback = (value: Element_2, key: Element_2, member: MemberElement, index: number) => void;
+
+/**
+ * Primitive JavaScript values that can be element content.
+ * @public
+ */
+export declare type PrimitiveValue = string | number | boolean | null | undefined;
+
+/**
+ * RefElement represents a reference to another element in ApiDOM.
+ * @public
+ */
+export declare class RefElement extends Element_2 {
+    constructor(content?: unknown, meta?: Meta, attributes?: Attributes);
+    /**
+     * Path of referenced element to transclude instead of element itself.
+     * @defaultValue 'element'
+     */
+    get path(): Element_2 | undefined;
+    set path(newValue: string | Element_2 | undefined);
+}
+
+/**
+ * Refracts a JSON type to ApiDOM elements.
+ * @public
+ */
+export declare function refract(value: unknown): Element_2;
+
+/**
+ * Input document format for deserialization.
+ * @public
+ */
+export declare interface RefractDocument {
+    element: string;
+    meta?: Record<string, unknown>;
+    attributes?: Record<string, unknown>;
+    content?: unknown;
+}
+
+/**
+ * Possible content types in a serialized element.
+ * @public
+ */
+export declare type SerializedContent = SerializedElement | SerializedElement[] | SerializedKeyValuePair | string | number | boolean | null | undefined;
+
+/**
+ * Serialized representation of an Element in JSON Refract format.
+ * @public
+ */
+export declare interface SerializedElement {
+    element: string;
+    meta?: Record<string, SerializedElement>;
+    attributes?: Record<string, SerializedElement>;
+    content?: SerializedContent;
+}
+
+/**
+ * Serialized representation of a KeyValuePair in JSON Refract format.
+ * @public
+ */
+export declare interface SerializedKeyValuePair {
+    key: SerializedElement;
+    value?: SerializedElement;
+}
+
+/**
+ * StringElement represents a string value in ApiDOM.
+ * @public
+ */
+export declare class StringElement extends Element_2 {
+    constructor(content?: string, meta?: Meta, attributes?: Attributes);
+    primitive(): string;
+    /**
+     * The length of the string.
+     */
+    get length(): number;
+}
+
+/**
+ * Type for objects that can convert to JavaScript values.
+ * @public
+ */
+export declare interface ToValue<T = unknown> {
+    toValue(): T;
+}
+
+export { }