@anticrm/core Package

export declare enum ClassifierKind 

export declare enum SortingOrder 

export declare enum TxContextSource 

export declare function combineStorage(...storages: Storage[]): Storage;

export declare function generateId(): Ref<Doc>;

export declare function isValidSelector(selector: ObjectSelector[]): boolean;

export declare function mixinFromKey(key: string): {
    mixin: Ref<Mixin<Obj>>;
    key: string;
};

export declare function mixinKey(mixin: Ref<Mixin<Obj>>, key: string): string;

export declare function txContext(source?: TxContextSource, network?: Promise<void>): TxContext;

CORE_CLASS_ARRAY_OF: Ref<Class<ArrayOf>>

CORE_CLASS_ATTRIBUTE: Ref<Class<Attribute>>

CORE_CLASS_BAG_OF: Ref<Class<BagOf>>

CORE_CLASS_BOOLEAN: Ref<Class<Type>>

CORE_CLASS_CLASS: Ref<Class<Class<Obj>>>

CORE_CLASS_DOC: Ref<Class<Doc>>

CORE_CLASS_EMB: Ref<Class<Emb>>

CORE_CLASS_ENUM_OF: Ref<Class<EnumOf<EnumKey>>>

CORE_CLASS_ENUM: Ref<Class<Enum<any>>>

CORE_CLASS_INSTANCE_OF: Ref<Class<InstanceOf<Emb>>>

CORE_CLASS_MIXIN: Ref<Class<Mixin<Obj>>>

CORE_CLASS_NUMBER: Ref<Class<Type>>

CORE_CLASS_OBJ: Ref<Class<Obj>>

CORE_CLASS_REF_TO: Ref<Class<RefTo<Doc>>>

CORE_CLASS_STRING: Ref<Class<Type>>

CORE_CLASS_TYPE: Ref<Class<Type>>

CORE_MIXIN_INDICES: Ref<Mixin<Indices>>

MODEL_DOMAIN = "model"

export declare type AllAttributes<T extends E, E extends Obj> = Required<Attributes<T, E>> & Partial<Attributes<E, Obj>>;

export declare type ArrayQueryType<A> = A extends Array<infer T> ? ObjQueryType<T> | Array<ObjQueryType<T>> : ObjQueryType<A>;

export declare type Attributes<T extends E, E extends Obj> = Record<Exclude<keyof T, keyof E>, Attribute>;

export declare type BooleanProperty = Property<boolean, boolean>;

export declare type Class<T extends Obj> = EClass<T, Obj>;

export declare type DateProperty = Property<number, Date>;

export declare type DocumentQuery<T> = {
    [P in keyof T]?: ArrayQueryType<T[P]>;
};

export declare type DocumentSorting<T> = T extends Obj ? DocumentSortingValueRaw<T> : SortingOrder;

export declare type DocumentSortingValueRaw<T> = {
    [P in keyof T]?: TSortingWithoutEmbArray<T[P]>;
};

export declare type DocumentValue<T> = T extends Doc ? DocumentValueRaw<Omit<T, keyof Doc>> : never | T extends Emb ? DocumentValueRaw<Omit<T, keyof Emb>> : never | T extends Obj ? T : T;

export declare type DocumentValueRaw<T> = {
    [P in keyof T]: TWithoutEmbArray<T[P]>;
};

export declare type Enum<T extends EnumKey> = EEnum<T, EnumLiteral>;

export declare type EnumKey = string | number | symbol;

export declare type EnumLiterals<T extends EnumKey, E extends EnumLiteral> = {
    [Q in T]: E;
};

export declare type Mixin<T extends Obj> = EMixin<T, Obj>;

export declare type NumberProperty = Property<number, number>;

export declare type ObjQueryType<T> = T extends Obj ? DocumentQuery<T> : T | RegExpression;

export declare type PrimitiveType = number | string | boolean | undefined;

export declare type Property<P extends PrimitiveType, T> = P & {
    __property: T;
};

export declare type PropertyType = Property<PrimitiveType, any> | Ref<Doc> | Emb | PropertyType[] | {
    [key: string]: PropertyType;
};

export declare type Ref<T extends Doc> = string & {
    __ref: T;
};

export declare type StringProperty = Property<string, string>;

export declare type TSortingWithoutEmbArray<A> = A extends Array<infer T> ? DocumentSorting<T> : DocumentSorting<A>;

export declare type TWithoutEmbArray<A> = A extends Array<infer T> ? Array<DocumentValue<T>> : DocumentValue<A>;