@speclynx/apidom-core 1.12.1

package/types/minim.d.ts

@@ -0,0 +1,236 @@
+/* eslint-disable spaced-comment, max-classes-per-file */
+/// <reference types="node" />
+
+declare module 'minim' {
+  export type Meta = Record<string, any>;
+  export type Attributes = Record<string, any>;
+  export type Predicate = (element: Element) => boolean;
+  type Callback = (element: Element) => void;
+
+  export function refract(value: any): Element;
+
+  export class Element {
+    static refract(value: any, options?: Record<string, any>): Element;
+
+    public element: string;
+
+    public meta: ObjectElement;
+
+    public attributes: ObjectElement;
+
+    public classes: ArrayElement;
+
+    public children: ArraySlice;
+
+    public parent: Element;
+
+    public content: Array<unknown>;
+
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+
+    set id(element: Element);
+
+    get id(): Element;
+
+    equals(value: any): boolean;
+
+    toValue(): any;
+
+    getMetaProperty(name: string, value?: any): any;
+
+    setMetaProperty(name: string, value: any): void;
+
+    freeze(): void;
+
+    clone(): Element;
+
+    primitive(): string | undefined;
+
+    [key: string]: unknown;
+  }
+
+  interface Type<T> extends Element {
+    new (...args: any[]): T;
+  }
+
+  type ExtendingElement<T extends Element = Element> = Record<string, T>;
+
+  export class Namespace {
+    get elements(): Record<string, Element>;
+
+    toRefract(element: Element): JSON;
+
+    toElement(value: any): Element;
+
+    fromRefract(doc: Record<string, any> | Array<any>): Element;
+
+    register(name: string, elementClass: any): Namespace;
+
+    detect(test: any, elementClass: any, givenPrepend: boolean): Namespace;
+
+    use(plugin: NamespacePlugin): Namespace;
+
+    getElementClass(element: string): typeof Element;
+  }
+
+  export interface NamespacePluginOptions {
+    base: Namespace;
+  }
+
+  export interface NamespacePlugin {
+    namespace(options: NamespacePluginOptions): Namespace;
+  }
+
+  export class StringElement extends Element {
+    constructor(content?: string, meta?: Meta, attributes?: Attributes);
+  }
+
+  export class NumberElement extends Element {
+    constructor(content?: number, meta?: Meta, attributes?: Attributes);
+  }
+
+  export class NullElement extends Element {}
+
+  export class BooleanElement extends Element {
+    constructor(content?: boolean, meta?: Meta, attributes?: Attributes);
+  }
+
+  export class ArrayElement extends Element {
+    constructor(content?: unknown[], meta?: Meta, attributes?: Attributes);
+
+    first: Element | undefined;
+
+    second: Element | undefined;
+
+    get(index: string | number): any;
+
+    set(index: string | number, element: Element): void;
+
+    find(predicate: Predicate): ArraySlice;
+
+    findElements(condition: Predicate, givenOptions: any): Array<Element>;
+
+    filter(predicate: Predicate): ArraySlice;
+
+    contains(value: any): boolean;
+
+    includes(value: any): boolean;
+
+    push(value: any): ArrayElement;
+
+    concat(value: ArrayElement): ArrayElement;
+
+    ['fantasy-land/map'](transform: any): ArrayElement;
+
+    forEach(callback: (item: Element, index: number) => void, thisArg?: unknown): void;
+
+    [Symbol.iterator](): IterableIterator<any>;
+
+    get length(): number;
+
+    map(callback: (element: Element) => Element, thisArg?: unknown): Array<Element>;
+  }
+
+  export class ObjectElement extends ArrayElement {
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+
+    remove(name: string): Element;
+
+    set(key: string | StringElement | number, value: any): ObjectElement;
+
+    hasKey(value: string): boolean;
+
+    getKey(value: string): StringElement;
+
+    getMember(key: string): MemberElement;
+
+    // @ts-ignore
+    forEach(
+      callback: (value: Element, key: Element, item: Element) => void,
+      thisArg?: unknown,
+    ): void;
+
+    map(
+      callback: (value: Element, key: Element, member: MemberElement) => MemberElement,
+      thisArg?: unknown,
+    ): Array<MemberElement>;
+
+    keys(): unknown[];
+  }
+
+  export class MemberElement extends Element {
+    constructor(key?: unknown, value?: unknown, meta?: Meta, attributes?: Attributes);
+
+    get key(): unknown;
+
+    set key(key: unknown);
+
+    get value(): unknown;
+
+    set value(value: unknown);
+  }
+
+  export class LinkElement extends Element {
+    constructor(content?: unknown, meta?: Meta, attributes?: Attributes);
+
+    get relation(): string;
+
+    set relation(relation: string);
+
+    get href(): string;
+
+    set href(key: string);
+  }
+
+  export class RefElement extends Element {
+    constructor(content?: unknown, meta?: Meta, attributes?: Attributes);
+
+    get path(): string;
+
+    set path(path: string);
+  }
+
+  export class ArraySlice {
+    constructor(elements?: Array<unknown>);
+
+    get length(): number;
+
+    get first(): Element;
+
+    get isEmpty(): boolean;
+
+    filter(predicate: Predicate, thisArg?: unknown): ArraySlice;
+
+    reject(predicate: Predicate, thisArg?: unknown): ArraySlice;
+
+    forEach(callback: Callback): void;
+
+    reduce<T>(callback: (acc: T, cur: Element) => T, initialValue: T): ArraySlice;
+
+    map(callback: (currentValue: any, index: number) => any, thisArg?: unknown): ArraySlice;
+
+    hasKey(value: string): boolean;
+
+    get<T extends Element>(index: number): T;
+
+    [Symbol.iterator](): IterableIterator<any>;
+
+    toValue(): any;
+
+    clone(): ArraySlice;
+  }
+
+  export class ObjectSlice extends ArraySlice {
+    clone(): ObjectSlice;
+  }
+
+  export class KeyValuePair {
+    public key: Element | undefined;
+
+    public value: Element | undefined;
+
+    constructor(key?: Element, value?: Element);
+
+    clone(): KeyValuePair;
+  }
+}