@allgemein/schema-api/lib/AbstractRef.d.ts

Library for schema api

import { JS_DATA_TYPES, METADATA_TYPE } from './Constants';
import { IBaseRef } from '../api/IBaseRef';
import { IClassRef } from '../api/IClassRef';
import { ILookupRegistry } from '../api/ILookupRegistry';
export declare abstract class AbstractRef implements IBaseRef {
    /**
     * Type of this entry
     */
    readonly metaType: METADATA_TYPE;
    /**
     * Namespace better registry of this entry
     */
    namespace: string;
    private _cachedOptions;
    readonly name: string;
    readonly object: IClassRef;
    constructor(type: METADATA_TYPE, name: string, object?: IClassRef | Function | string, namespace?: string);
    getNamespace(): string;
    getSourceRef(): IClassRef;
    abstract getClassRefFor(object: string | Function | IClassRef, type: METADATA_TYPE): IClassRef;
    abstract getRegistry(): ILookupRegistry;
    protected getOptionsEntry(): any;
    getOptions(key?: string, defaultValue?: any): any;
    setOptions(options: any): void;
    setOption(key: string, value: any): void;
    hasOption(key: string): boolean;
    /**
     * Return class ref
     */
    getClassRef(): IClassRef;
    /**
     * Get class for the entry
     *
     * @param create: create anonymous placeholder if no class exists
     */
    getClass(create?: boolean): Function;
    /**
     * Return the name of the class ref, if not exits then return null
     */
    get originalName(): string;
    /**
     * Return internal name (same as calling storingName)
     */
    get internalName(): string;
    /**
     * Return name in snake case notation
     */
    get machineName(): string;
    /**
     * Return internal name, check if internalName is set else check if name options is present
     *
     */
    get storingName(): any;
    abstract id(): string;
    /**
     * Return supported primitive data types
     */
    getSupportedDataTypes(): JS_DATA_TYPES[];
}