@webda/core 4.0.0-beta.1 → 4.0.0-beta.3

package/lib/models/coremodel.d.ts

@@ -1,887 +0,0 @@
-import { EventEmitter } from "events";
-import { JSONSchema7 } from "json-schema";
-import { ModelGraph, ModelsTree } from "../application.js";
-import { Core } from "../core.js";
-import { Service } from "../services/service.js";
-import { Store, StoreEvents } from "../stores/store.js";
-import { OperationContext } from "../utils/context.js";
-import { HttpMethodType } from "../utils/httpcontext.js";
-import { ModelActions, RawModel } from "./relations.js";
-/**
- * Expose the model through API or GraphQL if it exists
- * The model will be exposed using its class name + 's'
- * If you need to have a specific plural, use the annotation WebdaPlural
- *  to define the plural name
- *
- * @returns
- */
-export declare function Expose(params?: Partial<ExposeParameters>): (target: CoreModelDefinition) => void;
-/**
- *
- */
-export declare class CoreModelQuery {
-    private type;
-    private model;
-    private attribute;
-    private targetModel;
-    constructor(type: string, model: CoreModel, attribute: string);
-    /**
-     * Retrieve target model definition
-     * @returns
-     */
-    getTargetModel(): CoreModelDefinition;
-    /**
-     * Query the object
-     * @param query
-     * @returns
-     */
-    query(query?: string, context?: OperationContext): Promise<{
-        results: CoreModel[];
-        continuationToken?: string;
-    }>;
-    /**
-     * Complete the query with condition
-     * @param query
-     * @returns
-     */
-    protected completeQuery(query?: string): string;
-    /**
-     *
-     * @param callback
-     * @param context
-     */
-    forEach(callback: (model: any) => Promise<void>, query?: string, context?: OperationContext, parallelism?: number): Promise<void>;
-    /**
-     * Iterate through all
-     * @param context
-     * @returns
-     */
-    iterate(query?: string, context?: OperationContext): AsyncGenerator<CoreModel, any, unknown>;
-    /**
-     * Get all the objects
-     * @returns
-     */
-    getAll(context?: OperationContext): Promise<this[]>;
-}
-/**
- * Attribute of an object
- *
- * Filter out methods
- */
-export type Attributes<T extends object> = {
-    [K in keyof T]: T[K] extends Function ? never : K;
-}[keyof T];
-/**
- * Filter type keys by type
- */
-export type FilterAttributes<T extends CoreModel, K> = {
-    [L in keyof T]: T[L] extends K ? L : never;
-}[keyof T];
-/**
- * Define an Action on a model
- *
- * It is basically a method designed to be called by the API or external
- * systems
- */
-export interface ModelAction {
-    /**
-     * Method for the route
-     *
-     * By default ["PUT"]
-     */
-    methods?: HttpMethodType[];
-    /**
-     * Define if the action is global or per object
-     *
-     * The method that implement the action must be called
-     * `_${actionName}`
-     */
-    global?: boolean;
-    /**
-     * Additional openapi info
-     */
-    openapi?: any;
-    /**
-     * Method of the action
-     */
-    method?: string;
-}
-/**
- * Expose parameters for the model
- */
-export interface ExposeParameters {
-    /**
-     * If model have parent but you still want it to be exposed as root
-     * in domain-like service: DomainService, GraphQL
-     *
-     * It would create alias for the model in the root too
-     */
-    root?: boolean;
-    /**
-     * You can select to not expose some methods like create, update, delete, get, query
-     */
-    restrict: {
-        /**
-         * Create a new object
-         */
-        create?: boolean;
-        /**
-         * Update an existing object
-         *
-         * Includes PUT and PATCH
-         */
-        update?: boolean;
-        /**
-         * Query the object
-         */
-        query?: boolean;
-        /**
-         * Get a single object
-         */
-        get?: boolean;
-        /**
-         * Delete an object
-         */
-        delete?: boolean;
-        /**
-         * Do not create operations for the model
-         */
-        operation?: boolean;
-    };
-}
-/**
- *
- */
-export interface CoreModelDefinition<T extends CoreModel = CoreModel> extends EventEmitter {
-    new (): T;
-    /**
-     * If the model have some Expose annotation
-     */
-    Expose?: ExposeParameters;
-    /**
-     * Create a CoreModel object loaded with the content of object
-     *
-     * It allows polymorphism from Store
-     *
-     * @param model to create by default
-     * @param object to load data from
-     * @param context if the data is unsafe from http
-     */
-    factory<T extends CoreModel>(this: Constructor<T>, object: Partial<T>, context?: OperationContext): T;
-    /**
-     * Get the model actions
-     */
-    getActions(): {
-        [key: string]: ModelAction;
-    };
-    /**
-     * Get the model store
-     */
-    store(): Store<T>;
-    /**
-     * Get the model schema
-     */
-    getSchema(): JSONSchema7;
-    /**
-     * Get the model hierarchy
-     */
-    getHierarchy(): {
-        ancestors: string[];
-        children: ModelsTree;
-    };
-    /**
-     * Get the model relations
-     */
-    getRelations(): ModelGraph;
-    /**
-     * Get Model identifier
-     */
-    getIdentifier(short?: boolean): string;
-    /**
-     * Complete uuid useful to implement uuid prefix or suffix
-     * @param uid
-     */
-    completeUid(uid: string): string;
-    /**
-     * Get the model uuid field if you do not want to use the uuid field
-     */
-    getUuidField(): string;
-    /**
-     * Permission query for the model
-     * @param context
-     */
-    getPermissionQuery(context?: OperationContext): null | {
-        partial: boolean;
-        query: string;
-    };
-    /**
-     * Reference to an object without doing a DB request yet
-     */
-    ref: typeof CoreModel.ref;
-    /**
-     * Create a new model
-     * @param this
-     * @param data
-     */
-    create<T extends CoreModel>(this: Constructor<T>, data: RawModel<T>): Promise<T>;
-    /**
-     * Query the model
-     * @param query
-     */
-    query(query?: string, includeSubclass?: boolean, context?: OperationContext): Promise<{
-        results: T[];
-        continuationToken?: string;
-    }>;
-    /**
-     * Iterate through objects
-     * @param query
-     * @param includeSubclass
-     * @param context
-     */
-    iterate(query?: string, includeSubclass?: boolean, context?: OperationContext): AsyncGenerator<T>;
-    /**
-     * Listen to events on the model
-     * @param event
-     * @param listener
-     * @param async
-     */
-    on<T extends CoreModel, Key extends keyof StoreEvents>(this: Constructor<T>, event: Key, listener: (evt: StoreEvents[Key]) => any, async?: boolean): this;
-    /**
-     * Listen to events on the model asynchronously
-     * @param event
-     * @param listener
-     */
-    onAsync<T extends CoreModel, Key extends keyof StoreEvents>(this: Constructor<T>, event: Key, listener: (evt: StoreEvents[Key]) => any): this;
-    /**
-     * Emit an event for this class
-     * @param this
-     * @param event
-     * @param evt
-     */
-    emit<T extends CoreModel, Key extends keyof StoreEvents>(this: Constructor<T>, event: Key, evt: StoreEvents[Key]): any;
-    /**
-     * Emit an event for this class and wait for all listeners to finish
-     * @param this
-     * @param event
-     * @param evt
-     */
-    emitSync<T extends CoreModel, Key extends keyof StoreEvents>(this: Constructor<T>, event: Key, evt: StoreEvents[Key]): Promise<void>;
-    /**
-     * Return the event on the model that can be listened to by an
-     * external authorized source
-     * @see authorizeClientEvent
-     */
-    getClientEvents(): ({
-        name: string;
-        global?: boolean;
-    } | string)[];
-    /**
-     * Authorize a public event subscription
-     * @param event
-     * @param context
-     */
-    authorizeClientEvent(_event: string, _context: OperationContext, _model?: T): boolean;
-    /**
-     * Iterate through the model
-     * @param query
-     * @param includeSubclass
-     */
-    iterate(query?: string, includeSubclass?: boolean): AsyncGenerator<T>;
-    /**
-     * EventEmitter interface
-     * @param event
-     * @param listener
-     */
-    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-    /**
-     * EventEmitter interface
-     * @param event
-     * @param listener
-     */
-    once(event: string | symbol, listener: (...args: any[]) => void): this;
-    /**
-     * EventEmitter interface
-     * @param event
-     * @param listener
-     */
-    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
-    /**
-     * EventEmitter interface
-     * @param event
-     * @param listener
-     */
-    off(eventName: string | symbol, listener: (...args: any[]) => void): this;
-    /**
-     * EventEmitter interface
-     * @param event
-     * @param listener
-     */
-    removeAllListeners(eventName?: any): this;
-}
-export type Constructor<T, K extends Array<any> = []> = new (...args: K) => T;
-/**
- * Make a property hidden from json and schema
- *
- * This property will not be saved in the store
- * Nor it will be exposed in the API
- *
- * @param target
- * @param propertyKey
- */
-export declare function NotEnumerable(target: any, propertyKey: string): void;
-/**
- * Define an object method as an action
- * @param target
- * @param propertyKey
- */
-export declare function Action(options?: {
-    methods?: HttpMethodType[];
-    openapi?: any;
-    name?: string;
-}): (target: any, propertyKey: string) => void;
-export declare class ModelRef<T extends CoreModel> {
-    protected uuid: string;
-    protected store: Store<T>;
-    protected model: CoreModelDefinition<T>;
-    protected parent: CoreModel;
-    constructor(uuid: string, model: CoreModelDefinition<T>, parent?: CoreModel);
-    get(context?: OperationContext): Promise<T>;
-    set(id: string | T): void;
-    toString(): string;
-    toJSON(): string;
-    getUuid(): string;
-    deleteItemFromCollection(prop: FilterAttributes<T, any[]>, index: number, itemWriteCondition: any, itemWriteConditionField?: string): Promise<this>;
-    upsertItemToCollection(prop: FilterAttributes<T, any[]>, item: any, index?: number, itemWriteCondition?: any, itemWriteConditionField?: string): Promise<this>;
-    exists(): Promise<boolean>;
-    delete(): Promise<void>;
-    conditionalPatch(updates: Partial<T>, conditionField: any, condition: any): Promise<boolean>;
-    patch(updates: Partial<T>): Promise<boolean>;
-    setAttribute(attribute: keyof T, value: any): Promise<this>;
-    removeAttribute(attribute: keyof T, itemWriteCondition?: any, itemWriteConditionField?: keyof T): Promise<this>;
-    incrementAttributes(info: {
-        property: FilterAttributes<T, number>;
-        value: number;
-    }[]): Promise<this>;
-}
-export declare class ModelRefWithCreate<T extends CoreModel> extends ModelRef<T> {
-    /**
-     * Allow to create a model
-     * @param defaultValue
-     * @param context
-     * @param withSave
-     * @returns
-     */
-    create(defaultValue: RawModel<T>, context?: OperationContext, withSave?: boolean): Promise<T>;
-    /**
-     * Load a model from the known store
-     *
-     * @param this the class from which the static is called
-     * @param id of the object to load
-     * @param defaultValue if object not found return a default object
-     * @param context to set on the object
-     * @returns
-     */
-    getOrCreate(defaultValue: RawModel<T>, context?: OperationContext, withSave?: boolean): Promise<T>;
-}
-export declare class ModelRefCustom<T extends CoreModel> extends ModelRef<T> {
-    uuid: string;
-    constructor(uuid: string, model: CoreModelDefinition<T>, data: any, parent: CoreModel);
-    toJSON(): any;
-    getUuid(): string;
-}
-export type ModelRefCustomProperties<T extends CoreModel, K> = ModelRefCustom<T> & K;
-export declare const Emitters: WeakMap<Constructor<CoreModel>, EventEmitter>;
-/**
- * Basic Object in Webda
- *
- * It is used to define a data stored
- * Any variable starting with _ can only be set by the server
- * Any variable starting with __ won't be exported outside of the server
- *
- * @class
- * @WebdaModel
- */
-declare class CoreModel {
-    /**
-     * Class reference to the object
-     */
-    __class: CoreModelDefinition<this>;
-    /**
-     * Type name
-     */
-    __type: string;
-    /**
-     * Types name
-     */
-    __types: string[];
-    /**
-     * Object context
-     *
-     * @TJS-ignore
-     */
-    __ctx: OperationContext;
-    /**
-     * If object is attached to its store
-     *
-     * @TJS-ignore
-     */
-    __store: Store<this>;
-    __dirty: Set<string | symbol>;
-    /**
-     * Creation date
-     */
-    _creationDate: Date;
-    /**
-     * Last update date
-     */
-    _lastUpdate: Date;
-    /**
-     * If an object is deleted but not removed from DB for historic
-     *
-     * @ignore
-     */
-    __deleted: boolean;
-    constructor();
-    /**
-     * Listen to events on the model
-     * @param event
-     * @param listener
-     * @param async
-     */
-    static on<T extends CoreModel, Key extends keyof StoreEvents>(this: Constructor<T>, event: Key, listener: (evt: StoreEvents[Key]) => any, async?: boolean): any;
-    /**
-     * Emit an event for this class
-     * @param this
-     * @param event
-     * @param evt
-     */
-    static emit<T extends CoreModel, Key extends keyof StoreEvents>(this: Constructor<T>, event: Key, evt: StoreEvents[Key]): void;
-    /**
-     * Emit an event for this class and wait for all listeners to finish
-     * @param this
-     * @param event
-     * @param evt
-     */
-    static emitSync<T extends CoreModel, Key extends keyof StoreEvents>(this: Constructor<T>, event: Key, evt: StoreEvents[Key]): Promise<void>;
-    /**
-     * Listen to events on the model asynchronously
-     * @param event
-     * @param listener
-     */
-    static onAsync<Key extends keyof StoreEvents>(event: Key, listener: (evt: StoreEvents[Key]) => any, queue?: string): any;
-    /**
-     *
-     * @param event
-     * @param listener
-     * @returns
-     */
-    static addListener<Key extends keyof StoreEvents>(event: Key, listener: (...args: any[]) => void): any;
-    static emitter(method: any, ...args: any[]): any;
-    static removeListener(...args: any[]): any;
-    static off(...args: any[]): any;
-    static once(...args: any[]): any;
-    static removeAllListeners(...args: any[]): any;
-    static setMaxListeners(...args: any[]): any;
-    static getMaxListeners(...args: any[]): any;
-    static listeners(...args: any[]): any;
-    static rawListeners(...args: any[]): any;
-    static listenerCount(...args: any[]): any;
-    static prependListener(...args: any[]): any;
-    static prependOnceListener(...args: any[]): any;
-    static eventNames(...args: any[]): any;
-    /**
-     *
-     * @returns
-     */
-    static getRelations(): ModelGraph;
-    /**
-     * Do not declare any public events by default
-     * @returns
-     */
-    static getClientEvents(): any[];
-    /**
-     * Does not allow any event by default
-     * @param _event
-     * @param _context
-     * @returns
-     */
-    static authorizeClientEvent(_event: string, _context: OperationContext, _model?: CoreModel): boolean;
-    /**
-     * Get Store for this model
-     * @param this
-     * @returns
-     */
-    static store<T extends CoreModel>(this: Constructor<T>): Store<T>;
-    /**
-     * Complete the uid with prefix if any
-     *
-     * Useful when object are stored with a prefix for full uuid
-     * @param uid
-     * @returns
-     */
-    static completeUid(uid: string): string;
-    /**
-     * Return the known schema
-     * @returns
-     */
-    static getSchema(): JSONSchema7;
-    /**
-     * Get a reference to a model
-     * @param this
-     * @param uid
-     * @returns
-     */
-    static ref<T extends CoreModel>(this: Constructor<T>, uid: string): ModelRefWithCreate<T>;
-    /**
-     * Get a reference to a model
-     * @param this
-     * @param uid
-     * @returns
-     */
-    static create<T extends CoreModel>(this: Constructor<T>, data: RawModel<T>): Promise<T>;
-    /**
-     * Get identifier for this model
-     * @returns
-     */
-    static getIdentifier(short?: boolean): string;
-    /**
-     * Get the model hierarchy
-     *
-     * Ancestors will contain every model it inherits from
-     * Children will contain every model that inherits from this model in a tree structure
-     */
-    static getHierarchy(): {
-        ancestors: string[];
-        children: ModelsTree;
-    };
-    /**
-     * Unflat an object
-     * @param data
-     * @param split
-     * @returns
-     */
-    static unflat<T = any>(data: any, split?: string): T;
-    /**
-     * Create subobject for a model
-     *
-     * Useful for counters
-     *
-     * @param split
-     * @returns
-     */
-    unflat<T>(split?: string): T;
-    /**
-     * Flat an object into another
-     *
-     * {
-     *    a: {
-     *      b: 1
-     *    },
-     *    c: 1
-     * }
-     *
-     * become
-     *
-     * {
-     *    "a#b": 1
-     *    "c": 1
-     * }
-     *
-     * @param target
-     * @param data
-     * @param split
-     * @param prefix
-     */
-    static flat(target: any, data: any, split?: string, prefix?: string): any;
-    /**
-     * Complete the query with __type/__types
-     * @param query
-     * @param includeSubclass
-     * @returns
-     */
-    protected static completeQuery(query: string, includeSubclass?: boolean): string;
-    /**
-     * Iterate through the model
-     *
-     * How to use a iterator is:
-     *
-     * ```
-     * for await (const model of CoreModel.iterate()) {
-     *    // Do something with my model
-     * }
-     * ```
-     *
-     * @param this
-     * @param query
-     * @param includeSubclass
-     * @param context
-     * @returns
-     */
-    static iterate<T extends CoreModel>(this: Constructor<T>, query?: string, includeSubclass?: boolean, context?: OperationContext): AsyncGenerator<T>;
-    /**
-     * Query for models
-     * @param this
-     * @param id
-     * @returns
-     */
-    static query<T extends CoreModel>(this: Constructor<T>, query?: string, includeSubclass?: boolean, context?: OperationContext): Promise<{
-        results: T[];
-        continuationToken?: string;
-    }>;
-    /**
-     * Return a proxy to the object to detect if dirty
-     * @returns
-     */
-    getProxy(): this;
-    /**
-     * Return true if needs a save
-     * @returns
-     */
-    isDirty(): boolean;
-    /**
-     *
-     * @returns the uuid of the object
-     */
-    getUuid(): string;
-    /**
-     *
-     * @param uuid
-     * @param target
-     */
-    setUuid(uuid: string, target?: this): this;
-    /**
-     * Get actions callable on an object
-     *
-     * This will expose them by the Store with /storeUrl/{uuid}/{action}
-     */
-    static getActions<T>(this: Constructor<T>): ModelActions;
-    /**
-     * Return the expressable query for permission
-     *
-     * @param context of the query
-     * @returns
-     */
-    static getPermissionQuery(_ctx: OperationContext): null | {
-        partial: boolean;
-        query: string;
-    };
-    checkAct(context: OperationContext, action: "create" | "update" | "get" | "delete" | "get_binary" | "detach_binary" | "attach_binary" | "update_binary_metadata" | "subscribe" | string): Promise<void>;
-    /**
-     * By default nothing is permitted on a CoreModel
-     * @returns
-     */
-    canAct(_context: OperationContext, _action: "create" | "update" | "get" | "delete" | "get_binary" | "detach_binary" | "attach_binary" | "update_binary_metadata" | "subscribe" | string): Promise<string | boolean>;
-    /**
-     * Get the UUID property
-     */
-    static getUuidField(): string;
-    /**
-     * Create an object
-     * @returns
-     */
-    static factory<T extends CoreModel>(this: Constructor<T>, object: Partial<T>, context?: OperationContext): T;
-    /**
-     * Detect what looks like a CoreModel but can be from different version
-     * @param object
-     * @returns
-     */
-    static instanceOf(object: any): boolean;
-    /**
-     * Return a unique reference within the application to the object
-     *
-     * It contains the Store containing it
-     * @returns
-     */
-    getFullUuid(): string;
-    /**
-     * Get an object from the full uuid
-     * @param core
-     * @param fullUuid
-     * @param partials
-     * @returns
-     */
-    static fromFullUuid<T extends CoreModel = CoreModel>(fullUuid: string, core?: Core, partials?: any): Promise<T>;
-    /**
-     * Allow to define custom permission per attribute
-     *
-     * This method allows you to do permission based attribute
-     * But also a mask destructive attribute
-     *
-     * @param key
-     * @param value
-     * @param mode
-     * @param context
-     * @returns updated value
-     */
-    attributePermission(key: string, value: any, mode: "READ" | "WRITE", context?: OperationContext): any;
-    /**
-     * Load an object from RAW
-     *
-     * @param raw data
-     * @param secure if false will ignore any _ variable
-     */
-    load(raw: RawModel<this>, secure?: boolean, relations?: boolean): this;
-    /**
-     * Patch every attribute that is based on a relation
-     * to add all the helpers
-     */
-    protected handleRelations(): void;
-    /**
-     * Context of the request
-     */
-    setContext(ctx: OperationContext): this;
-    /**
-     * Get object context
-     *
-     * Global object does not belong to a request
-     */
-    getContext<T extends OperationContext>(): T;
-    /**
-     * Return the object registered store
-     */
-    getStore(): Store<this>;
-    /**
-     * Get the object
-     * @returns
-     */
-    get(): Promise<this>;
-    /**
-     * Get the object again
-     *
-     * @throws Error if the object is not coming from a store
-     */
-    refresh(): Promise<this>;
-    /**
-     * Delete this object
-     *
-     * @throws Error if the object is not coming from a store
-     */
-    delete(): Promise<void>;
-    /**
-     * Patch current object with this update
-     * @param obj
-     * @param conditionField if null no condition used otherwise fallback to lastUpdate
-     * @param conditionValue
-     */
-    patch(obj: Partial<this>, conditionField?: keyof this | null, conditionValue?: any): Promise<void>;
-    /**
-     * Save this object
-     *
-     * @throws Error if the object is not coming from a store
-     */
-    save(full?: boolean | keyof this, ...args: (keyof this)[]): Promise<this>;
-    /**
-     * Validate objet modification
-     *
-     * @param ctx
-     * @param updates
-     */
-    validate(ctx: OperationContext, updates: any, ignoreRequired?: boolean): Promise<boolean>;
-    /**
-     * Generate uuid for the object
-     *
-     * @param object
-     * @returns
-     */
-    generateUid(_object?: any): string;
-    /**
-     * Return the object to be serialized without the __store
-     *
-     * @param stringify
-     * @returns
-     */
-    toStoredJSON(stringify?: boolean): any | string;
-    /**
-     * Get a pre typed service
-     *
-     * @param service to retrieve
-     * WARNING: Only object attached to a store can retrieve service
-     */
-    getService<T extends Service>(service: any): T;
-    /**
-     * Remove the specific attributes if not secure
-     *
-     *
-     *
-     * @param secure serialize server fields also
-     * @returns filtered object to be serialized
-     */
-    _toJSON(secure: any): any;
-    /**
-     * Return the object without sensitive attributes
-     *
-     * @returns Object to serialize
-     */
-    toJSON(): any;
-    /**
-     * Called when object is about to be deleted
-     */
-    _onDelete(): Promise<void>;
-    /**
-     * Called when object has been deleted
-     */
-    _onDeleted(): Promise<void>;
-    /**
-     * Called when object is retrieved
-     */
-    _onGet(): Promise<void>;
-    /**
-     * Called when object is about to be saved
-     */
-    _onSave(): Promise<void>;
-    /**
-     * Called when object is saved
-     */
-    _onSaved(): Promise<void>;
-    /**
-     * Called when object is about to be updates
-     *
-     * @param updates to be send
-     */
-    _onUpdate(_updates: any): Promise<void>;
-    /**
-     * Called when object is updated
-     */
-    _onUpdated(): Promise<void>;
-    /**
-     * Set attribute on the object and database
-     * @param property
-     * @param value
-     */
-    setAttribute(property: keyof this, value: any): Promise<void>;
-    /**
-     * Remove attribute from both the object and db
-     * @param property
-     */
-    removeAttribute(property: keyof this): Promise<void>;
-    /**
-     * Increment an attribute both in store and object
-     * @param property
-     * @param value
-     */
-    incrementAttribute(property: FilterAttributes<this, number>, value: number): Promise<void>;
-    /**
-     * Return a model ref
-     * @returns
-     */
-    getRef<T extends this>(): ModelRef<T>;
-    /**
-     * Increment a attributes both in store and object
-     * @param info
-     */
-    incrementAttributes(info: {
-        property: string;
-        value: number;
-    }[]): Promise<void>;
-}
-/**
- * CoreModel with a uuid
- */
-declare class UuidModel extends CoreModel {
-    uuid: string;
-    /**
-     * @override
-     */
-    validate(ctx: OperationContext<any, any>, updates: any, ignoreRequired?: boolean): Promise<boolean>;
-}
-export { CoreModel, UuidModel };