@anticrm/model Package

Classes #

List of classes contained in this package or namespace
Class	Description
Builder

Functions #

List of functions contained in this package or namespace
Function	Description
ArrayOf$()	Mark attribute as collection, if attribute already had type, it will be wrapped inside.
BagOf$()
Class$(id, _extends, domain)
Enum$(id)
EnumOf$(of)
extendIds(a, b)
getAttribute(target, propertyKey)
getClass(target)
getEnum(target)
getEnumLiteral(target, propertyKey)
InstanceOf$(of)
isKindOf(target, kind)
Literal(enumVal)	Construct a enum literal
loadClassifier(target)
loadClassifierChild(target, propertyKey)
mergeIds(a, b)
Mixin$(id, _extends)
Primary()
Prop(type)	Construct a property
RefTo$(to)
verifyTranslation(ids, translations)
withMixin(_class, obj)

Interfaces #

List of interfaces contained in this package or namespace
Interface	Description
ClassifierDefinition

Variables #

List of variables contained in this package or namespace
Variable	Description
modelIds

Type Aliases #

List of type aliases contained in this package or namespace
Type Alias	Description
ClassifierPostProcessing

Functions #

ArrayOf$ #

Mark attribute as collection, if attribute already had type, it will be wrapped inside.

Signature:

export declare function ArrayOf$(): (target: any, propertyKey: string) => void;

Returns:

(target: any, propertyKey: string) => void

BagOf$ #

Signature:

export declare function BagOf$(): (target: any, propertyKey: string) => void;

Returns:

(target: any, propertyKey: string) => void

Class$ #

Signature:

export declare function Class$<E extends Obj, T extends E>(id: Ref<Class<T>>, _extends: Ref<Class<E>>, domain?: string): <C extends new () => T>(constructor: C) => void;

Parameters

List of parameters
Parameter	Type	Description
id	Ref<Class>
_extends	Ref<Class>
domain	string

Returns:

<C extends new () => T>(constructor: C) => void

Enum$ #

Signature:

export declare function Enum$<T extends EnumLiterals<E, EnumLiteral>, E extends EnumKey>(id: Ref<Enum<E>>): <C extends new () => T>(constructor: C) => void;

Parameters

List of parameters
Parameter	Type	Description
id	Ref<Enum>

Returns:

<C extends new () => T>(constructor: C) => void

EnumOf$ #

Signature:

export declare function EnumOf$(of: Ref<Enum<any>>): (target: any, propertyKey: string) => void;

Parameters

List of parameters
Parameter	Type	Description
of	Ref<Enum>

Returns:

(target: any, propertyKey: string) => void

extendIds #

Signature:

export declare function extendIds<P extends Service, X extends PluginDependencies, D extends PluginDescriptor<P, X>, N extends Namespace>(a: D, b: N): D & N;

Parameters

List of parameters
Parameter	Type	Description
a	D
b	N

Returns:

D & N

getAttribute #

Signature:

export declare function getAttribute(target: any, propertyKey: string): Attribute;

Parameters

List of parameters
Parameter	Type	Description
target	any
propertyKey	string

Returns:

Attribute

getClass #

Signature:

export declare function getClass(target: any): ClassifierDefinition<Class<Obj>>;

Parameters

List of parameters
Parameter	Type	Description
target	any

Returns:

ClassifierDefinition<Class<Obj>>

getEnum #

Signature:

export declare function getEnum(target: any): ClassifierDefinition<Enum<any>>;

Parameters

List of parameters
Parameter	Type	Description
target	any

Returns:

ClassifierDefinition<Enum<any>>

getEnumLiteral #

Signature:

export declare function getEnumLiteral(target: any, propertyKey: string): EnumLiteral;

Parameters

List of parameters
Parameter	Type	Description
target	any
propertyKey	string

Returns:

EnumLiteral

InstanceOf$ #

Signature:

export declare function InstanceOf$<T extends Emb>(of: Ref<Class<T>>): (target: any, propertyKey: string) => void;

Parameters

List of parameters
Parameter	Type	Description
of	Ref<Class>

Returns:

(target: any, propertyKey: string) => void

isKindOf #

Signature:

export declare function isKindOf(target: any, kind: ClassifierKind): boolean;

Parameters

List of parameters
Parameter	Type	Description
target	any
kind	ClassifierKind

Returns:

boolean

Literal #

Construct a enum literal

Signature:

export declare function Literal(enumVal: any): (target: any, propertyKey: string) => void;

Parameters

List of parameters
Parameter	Type	Description
enumVal	any

Returns:

(target: any, propertyKey: string) => void

loadClassifier #

Signature:

export declare function loadClassifier<T extends Doc>(target: any): ClassifierDefinition<T>;

Parameters

List of parameters
Parameter	Type	Description
target	any

Returns:

ClassifierDefinition<T>

loadClassifierChild #

Signature:

export declare function loadClassifierChild(target: any, propertyKey: string): Emb | undefined;

Parameters

List of parameters
Parameter	Type	Description
target	any
propertyKey	string

Returns:

Emb | undefined

mergeIds #

Signature:

export declare function mergeIds<A extends PluginIds, B extends PluginIds>(a: A, b: B): A & B;

Parameters

List of parameters
Parameter	Type	Description
a	A
b	B

Returns:

A & B

Mixin$ #

Signature:

export declare function Mixin$<E extends Obj, T extends E>(id: Ref<Mixin<T>>, _extends: Ref<Class<E>>): <C extends new () => T>(constructor: C) => void;

Parameters

List of parameters
Parameter	Type	Description
id	Ref<Mixin>
_extends	Ref<Class>

Returns:

<C extends new () => T>(constructor: C) => void

Primary #

Signature:

export declare function Primary(): (target: any, propertyKey: string) => void;

Returns:

(target: any, propertyKey: string) => void

Prop #

Construct a property

Signature:

export declare function Prop(type?: Ref<Class<Type>>): (target: any, propertyKey: string) => void;

Parameters

List of parameters
Parameter	Type	Description
type	Ref<Class<Type>>

Returns:

(target: any, propertyKey: string) => void

RefTo$ #

Signature:

export declare function RefTo$(to: Ref<Class<Doc>>): (target: any, propertyKey: string) => void;

Parameters

List of parameters
Parameter	Type	Description
to	Ref<Class<Doc>>

Returns:

(target: any, propertyKey: string) => void

verifyTranslation #

Signature:

export declare function verifyTranslation<T extends StringIds>(ids: T, translations: AsStrings<T>): {
    [key: string]: string;
};

Parameters

List of parameters
Parameter	Type	Description
ids	T
translations	AsStrings

Returns:

{ [key: string]: string; }

withMixin #

Signature:

export declare function withMixin<T extends Obj>(_class: Ref<Mixin<T>>, obj: Partial<Omit<T, keyof Obj>>): (target: any, propertyKey: string) => void;

Parameters

List of parameters
Parameter	Type	Description
_class	Ref<Mixin>
obj	PartialObj>>

Returns:

(target: any, propertyKey: string) => void

Variables #

modelIds #

Signature:

modelIds: {
    class: {
        Obj: Ref<Class<Obj>>;
        Emb: Ref<Class<Emb>>;
        Doc: Ref<Class<Doc>>;
        Classifier: Ref<Class<Classifier>>;
        Attribute: Ref<Class<Attribute>>;
        Class: Ref<Class<Class<Obj>>>;
        Mixin: Ref<Class<Mixin<Obj>>>;
        EnumLiteral: Ref<Class<EnumLiteral>>;
        Enum: Ref<Class<Enum<any>>>;
        Type: Ref<Class<Type>>;
        String: Ref<Class<Type>>;
        Number: Ref<Class<Type>>;
        Boolean: Ref<Class<Type>>;
        Date: Ref<Class<Type>>;
        ArrayOf: Ref<Class<ArrayOf>>;
        RefTo: Ref<Class<RefTo<Doc>>>;
        BagOf: Ref<Class<BagOf>>;
        InstanceOf: Ref<Class<InstanceOf<Emb>>>;
        EnumOf: Ref<Class<EnumOf<EnumKey>>>;
        Tx: Ref<Class<Tx>>;
        ObjectTx: Ref<Class<ObjectTx>>;
        ObjectTxDetails: Ref<Class<ObjectTxDetails>>;
        CreateTx: Ref<Class<CreateTx>>;
        UpdateTx: Ref<Class<UpdateTx>>;
        ObjectSelector: Ref<Class<ObjectSelector>>;
        TxOperation: Ref<Class<TxOperation>>;
        DeleteTx: Ref<Class<DeleteTx>>;
        Title: Ref<Class<Title>>;
        VDoc: Ref<Class<VDoc>>;
        Space: Ref<Class<Space>>;
        SpaceUser: Ref<Class<SpaceUser>>;
        Reference: Ref<Class<Reference>>;
        Application: Ref<Class<Application>>;
    };
    mixin: {
        Indices: Ref<Mixin<Indices>>;
        ShortID: Ref<Mixin<ShortID>>;
    };
}

Type Aliases #

ClassifierPostProcessing #

Signature:

export declare type ClassifierPostProcessing<T extends Doc> = (model: Model, classifier: T) => void;