@decaf-ts/db-decorators 0.4.30 → 0.4.32

package/lib/operations/OperationsRegistry.d.ts

@@ -1,34 +0,0 @@
-import { OperationHandler } from "./types";
-import { OperationKeys } from "./constants";
-import { IRepository } from "../interfaces/IRepository";
-import { Model } from "@decaf-ts/decorator-validation";
-/**
- * @summary Holds the registered operation handlers
- *
- * @class OperationsRegistry
- * @implements IRegistry<OperationHandler<any>>
- *
- * @see OperationHandler
- *
- * @category Operations
- */
-export declare class OperationsRegistry {
-    private readonly cache;
-    /**
-     * @summary retrieves an {@link OperationHandler} if it exists
-     * @param {string} target
-     * @param {string} propKey
-     * @param {string} operation
-     * @param accum
-     * @return {OperationHandler | undefined}
-     */
-    get<T extends Model, V extends IRepository<T>, Y>(target: string | Record<string, any>, propKey: string, operation: string, accum?: OperationHandler<T, V, Y>[]): OperationHandler<T, V, Y>[] | undefined;
-    /**
-     * @summary Registers an {@link OperationHandler}
-     * @param {OperationHandler} handler
-     * @param {string} operation
-     * @param {{}} target
-     * @param {string | symbol} propKey
-     */
-    register<T extends Model, V extends IRepository<T>, Y>(handler: OperationHandler<T, V, Y>, operation: OperationKeys, target: T, propKey: string | symbol): void;
-}

package/lib/operations/constants.d.ts

@@ -1,24 +0,0 @@
-/**
- * @summary Set of constants to define db CRUD operations and their equivalent 'on' and 'after' phases
- * @const OperationKeys
- *
- * @memberOf module:db-decorators.Operations
- */
-export declare enum OperationKeys {
-    REFLECT = "decaf.model.db.operations.",
-    CREATE = "create",
-    READ = "read",
-    UPDATE = "update",
-    DELETE = "delete",
-    ON = "on.",
-    AFTER = "after."
-}
-export type CrudOperations = OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE;
-/**
- * @summary Maps out groups of CRUD operations for easier mapping of decorators
- *
- * @constant DBOperations
- *
- * @memberOf module:db-decorators.Operations
- */
-export declare const DBOperations: Record<string, CrudOperations[]>;

package/lib/operations/decorators.d.ts

@@ -1,193 +0,0 @@
-import { IdOperationHandler, OperationHandler, StandardOperationHandler, UpdateOperationHandler } from "./types";
-import { OperationKeys } from "./constants";
-/**
- * @summary Defines a behaviour to set on the defined {@link DBOperations.CREATE_UPDATE}
- *
- * @param {OnOperationHandler<any>} handler The method called upon the operation
- * @param data
- * @param {any[]} [args] Arguments that will be passed in order to the handler method
- *
- * @see on
- *
- * @function onCreateUpdate
- *
- * @category Decorators
- */
-export declare function onCreateUpdate<T>(handler: StandardOperationHandler<any, any, T, any> | UpdateOperationHandler<any, any, T, any>, data?: T): (target: object, propertyKey?: any) => void;
-/**
- * @summary Defines a behaviour to set on the defined {@link DBOperations.UPDATE}
- *
- * @param {OnOperationHandler<any>} handler The method called upon the operation
- * @param data
- * @param {any[]} [args] Arguments that will be passed in order to the handler method
- *
- * @see on
- *
- * @function onUpdate
- *
- * @category Decorators
- */
-export declare function onUpdate<T>(handler: UpdateOperationHandler<any, any, T, any>, data?: T): (target: object, propertyKey?: any) => void;
-/**
- * @summary Defines a behaviour to set on the defined {@link DBOperations.CREATE}
- *
- * @param {OnOperationHandler<any>} handler The method called upon the operation
- * @param data
- *
- * @see on
- *
- * @function onCreate
- *
- * @category Decorators
- */
-export declare function onCreate<T>(handler: StandardOperationHandler<any, any, T, any>, data?: T): (target: object, propertyKey?: any) => void;
-/**
- * @summary Defines a behaviour to set on the defined {@link DBOperations.READ}
- *
- * @param {OnOperationHandler<any>} handler The method called upon the operation
- * @param data
- *
- * @see on
- *
- * @function onRead
- *
- * @category Decorators
- */
-export declare function onRead<T>(handler: IdOperationHandler<any, any, T, any>, data: T): (target: object, propertyKey?: any) => void;
-/**
- * @summary Defines a behaviour to set on the defined {@link DBOperations.DELETE}
- *
- * @param {OnOperationHandler<any>} handler The method called upon the operation
- * @param data
- *
- * @see on
- *
- * @function onDelete
- *
- * @category Decorators
- */
-export declare function onDelete<T>(handler: OperationHandler<any, any, T, any>, data: T): (target: object, propertyKey?: any) => void;
-/**
- * @summary Defines a behaviour to set on the defined {@link DBOperations.DELETE}
- *
- * @param {OnOperationHandler<any>} handler The method called upon the operation
- * @param data
- *
- * @see on
- *
- * @function onAny
- *
- * @category Decorators
- */
-export declare function onAny<T>(handler: OperationHandler<any, any, T, any>, data: T): (target: object, propertyKey?: any) => void;
-/**
- * @summary Defines a behaviour to set on the defined {@link DBOperations}
- *
- * @param {OperationKeys[] | DBOperations} op One of {@link DBOperations}
- * @param {OnOperationHandler<any>} handler The method called upon the operation
- * @param data
- *
- * ex: handler(...args, ...props.map(p => target[p]))
- *
- * @function on
- *
- * @category Decorators
- */
-export declare function on<T>(op: OperationKeys[] | undefined, handler: OperationHandler<any, any, T, any>, data?: T): (target: object, propertyKey?: any) => void;
-/**
- * @summary Defines a behaviour to set after the defined {@link DBOperations.CREATE_UPDATE}
- *
- * @param {AfterOperationHandler<any>} handler The method called upon the operation
- * @param data
- *
- * @see after
- *
- * @function afterCreateUpdate
- *
- * @category Decorators
- */
-export declare function afterCreateUpdate<T>(handler: StandardOperationHandler<any, any, T, any> | UpdateOperationHandler<any, any, T, any>, data: T): (target: object, propertyKey?: any) => void;
-/**
- * @summary Defines a behaviour to set after the defined {@link DBOperations.UPDATE}
- *
- * @param {AfterOperationHandler<any>} handler The method called upon the operation
- * @param data
- *
- * @see after
- *
- * @function afterUpdate
- *
- * @category Decorators
- */
-export declare function afterUpdate<T>(handler: UpdateOperationHandler<any, any, T, any>, data: T): (target: object, propertyKey?: any) => void;
-/**
- * @summary Defines a behaviour to set after the defined {@link DBOperations.CREATE}
- *
- * @param {AfterOperationHandler<any>} handler The method called upon the operation
- * @param data
- *
- * @see after
- *
- * @function afterCreate
- *
- * @category Decorators
- */
-export declare function afterCreate<T>(handler: StandardOperationHandler<any, any, T, any>, data: T): (target: object, propertyKey?: any) => void;
-/**
- * @summary Defines a behaviour to set after the defined {@link DBOperations.READ}
- *
- * @param {AfterOperationHandler<any>} handler The method called upon the operation
- * @param data
- * @param {any[]} [args] Arguments that will be passed in order to the handler method
- *
- * @see after
- *
- * @function afterRead
- *
- * @category Decorators
- */
-export declare function afterRead<T>(handler: StandardOperationHandler<any, any, T, any>, data?: T): (target: object, propertyKey?: any) => void;
-/**
- * @summary Defines a behaviour to set after the defined {@link DBOperations.DELETE}
- *
- * @param {AfterOperationHandler<any>} handler The method called upon the operation
- * @param data
- * @param {any[]} [args] Arguments that will be passed in order to the handler method
- *
- * @see after
- *
- * @function afterDelete
- *
- * @category Decorators
- */
-export declare function afterDelete<T>(handler: StandardOperationHandler<any, any, T, any>, data?: T): (target: object, propertyKey?: any) => void;
-/**
- * @summary Defines a behaviour to set after the defined {@link DBOperations.DELETE}
- *
- * @param {AfterOperationHandler<any>} handler The method called upon the operation
- * @param data
- * @param {any[]} [args] Arguments that will be passed in order to the handler method
- *
- * @see after
- *
- * @function afterAny
- *
- * @category Decorators
- */
-export declare function afterAny<T>(handler: StandardOperationHandler<any, any, T, any>, data?: T): (target: object, propertyKey?: any) => void;
-/**
- * @summary Defines a behaviour to set on the defined {@link DBOperations}
- *
- * @param {OperationKeys[] | DBOperations} op One of {@link DBOperations}
- * @param {AfterOperationHandler<any>} handler The method called upon the operation
- *
- * ex: handler(...args, ...props.map(p => target[p]))
- *
- * @param data
- * @param args
- * @function after
- *
- * @category Decorators
- */
-export declare function after<T>(op: OperationKeys[] | undefined, handler: OperationHandler<any, any, T, any>, data?: T): (target: object, propertyKey?: any) => void;
-export declare function operation<T>(baseOp: OperationKeys.ON | OperationKeys.AFTER, operation: OperationKeys[] | undefined, handler: OperationHandler<any, any, T, any>, dataToAdd?: T): (target: object, propertyKey?: any) => void;

package/lib/operations/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./constants";
-export * from "./decorators";
-export * from "./Operations";
-export * from "./OperationsRegistry";
-export * from "./types";

package/lib/operations/types.d.ts

@@ -1,29 +0,0 @@
-import { OperationKeys } from "./constants";
-import { IRepository } from "../interfaces/IRepository";
-import { Model } from "@decaf-ts/decorator-validation";
-import { Context } from "../repository/Context";
-export type OperationMetadata<V> = {
-    operation: OperationKeys;
-    handler: string;
-    metadata?: V;
-};
-/**
- * @typedef OperationHandler
- * @memberOf db-decorators.operations
- */
-export type OperationHandler<M extends Model, R extends IRepository<M>, V, C extends Context<M> = Context<M>> = StandardOperationHandler<M, R, V, C> | UpdateOperationHandler<M, R, V, C> | IdOperationHandler<M, R, V, C>;
-/**
- * @typedef OnOperationHandler
- * @memberOf db-decorators.operations
- */
-export type StandardOperationHandler<M extends Model, R extends IRepository<M>, V, C extends Context<M> = Context<M>> = (this: R, context: C, metadata: V, key: any, model: M) => Promise<void> | void;
-/**
- * @typedef IdOperationHandler
- * @memberOf db-decorators.operations
- */
-export type IdOperationHandler<M extends Model, R extends IRepository<M>, V, C extends Context<M> = Context<M>> = (this: R, context: C, decorator: V, key: any, id: string) => Promise<void> | void;
-/**
- * @typedef AfterOperationHandler
- * @memberOf db-decorators.operations
- */
-export type UpdateOperationHandler<M extends Model, R extends IRepository<M>, V, C extends Context<M> = Context<M>> = (this: R, context: C, decorator: V, key: any, model: M, oldModel: M) => Promise<void> | void;

package/lib/repository/BaseRepository.d.ts

@@ -1,36 +0,0 @@
-import { IRepository } from "../interfaces/IRepository";
-import { Constructor, Model } from "@decaf-ts/decorator-validation";
-import { Context } from "./Context";
-export declare abstract class BaseRepository<M extends Model> implements IRepository<M> {
-    private readonly _class;
-    private _pk;
-    get class(): Constructor<M>;
-    get pk(): string;
-    protected constructor(clazz?: Constructor<M>);
-    abstract create(model: M, ...args: any[]): Promise<M>;
-    createAll(models: M[], ...args: any[]): Promise<M[]>;
-    protected createPrefix(model: M, ...args: any[]): Promise<any[]>;
-    protected createSuffix(model: M, context: Context<M>): Promise<M>;
-    protected createAllPrefix(models: M[], ...args: any[]): Promise<any[]>;
-    protected createAllSuffix(models: M[], context: Context<M>): Promise<M[]>;
-    abstract read(key: string | number, ...args: any[]): Promise<M>;
-    readAll(keys: string[] | number[], ...args: any[]): Promise<M[]>;
-    protected readSuffix(model: M, context: Context<M>): Promise<M>;
-    protected readPrefix(key: string, ...args: any[]): Promise<any[]>;
-    protected readAllPrefix(keys: string[] | number[], ...args: any[]): Promise<any[]>;
-    protected readAllSuffix(models: M[], context: Context<M>): Promise<M[]>;
-    abstract update(model: M, ...args: any[]): Promise<M>;
-    updateAll(models: M[], ...args: any): Promise<M[]>;
-    protected updateSuffix(model: M, context: Context<M>): Promise<M>;
-    protected updatePrefix(model: M, ...args: any[]): Promise<any[]>;
-    protected updateAllPrefix(models: M[], ...args: any[]): Promise<any[]>;
-    protected updateAllSuffix(models: M[], context: Context<M>): Promise<M[]>;
-    abstract delete(key: string | number, ...args: any[]): Promise<M>;
-    deleteAll(keys: string[] | number[], ...args: any[]): Promise<M[]>;
-    protected deleteSuffix(model: M, context: Context<M>): Promise<M>;
-    protected deletePrefix(key: any, ...args: any[]): Promise<any[]>;
-    protected deleteAllPrefix(keys: string[] | number[], ...args: any[]): Promise<any[]>;
-    protected deleteAllSuffix(models: M[], context: Context<M>): Promise<M[]>;
-    protected merge(oldModel: M, model: M): M;
-    toString(): string;
-}

package/lib/repository/Context.d.ts

@@ -1,17 +0,0 @@
-import { DataCache } from "./DataCache";
-import { ContextArgs } from "./utils";
-import { Contextual } from "../interfaces/Contextual";
-import { OperationKeys } from "../operations/constants";
-import { Constructor, Model } from "@decaf-ts/decorator-validation";
-export declare class Context<M extends Model> extends DataCache {
-    protected operation: OperationKeys;
-    protected model?: Constructor<M> | undefined;
-    protected parent?: Context<any> | undefined;
-    protected constructor(operation: OperationKeys, model?: Constructor<M> | undefined, parent?: Context<any> | undefined);
-    get timestamp(): Date;
-    get(key: string): Promise<any>;
-    pop(key: string): Promise<any>;
-    child<N extends Model>(operation: OperationKeys, model?: Constructor<N>): Context<N>;
-    static from<M extends Model, C extends Context<M>>(operation: OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE, model: Constructor<M>, ...args: any[]): Promise<C>;
-    static args<M extends Model>(operation: OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE, model: Constructor<M>, args: any[], contextual?: Contextual<M>): Promise<ContextArgs<M>>;
-}

package/lib/repository/DataCache.d.ts

@@ -1,9 +0,0 @@
-export declare class DataCache {
-    protected cache: Record<string, any>;
-    get(key: string): Promise<any>;
-    push(key: string, value: any): Promise<void>;
-    put(key: string, value: any): Promise<void>;
-    pop(key: string): Promise<any>;
-    filter(filter: string | RegExp): Promise<any[]>;
-    purge(key?: string): Promise<void>;
-}

package/lib/repository/Repository.d.ts

@@ -1,10 +0,0 @@
-import { BaseRepository } from "./BaseRepository";
-import { Constructor, Model } from "@decaf-ts/decorator-validation";
-export declare abstract class Repository<M extends Model> extends BaseRepository<M> {
-    protected constructor(clazz?: Constructor<M>);
-    protected createPrefix(model: M, ...args: any[]): Promise<[M, ...any[]]>;
-    protected createAllPrefix(models: M[], ...args: any[]): Promise<any[]>;
-    protected updatePrefix(model: M, ...args: any[]): Promise<[M, ...args: any[]]>;
-    protected updateAllPrefix(models: M[], ...args: any[]): Promise<any[]>;
-    static key(key: string): string;
-}

package/lib/repository/errors.d.ts

@@ -1,69 +0,0 @@
-/**
- * @summary Base Error
- *
- * @param {string} msg the error message
- *
- * @class BaseDLTError
- * @extends Error
- */
-export declare abstract class BaseError extends Error {
-    protected constructor(name: string, msg: string | Error);
-}
-/**
- * @summary Represents a failure in the Model details
- *
- * @param {string} msg the error message
- *
- * @class ValidationError
- * @extends BaseError
- */
-export declare class ValidationError extends BaseError {
-    constructor(msg: string | Error);
-}
-/**
- * @summary Represents an internal failure (should mean an error in code)
- *
- * @param {string} msg the error message
- *
- * @class InternalError
- * @extends BaseError
- */
-export declare class InternalError extends BaseError {
-    constructor(msg: string | Error);
-}
-/**
- * @summary Represents a failure in the Model de/serialization
- *
- * @param {string} msg the error message
- *
- * @class SerializationError
- * @extends BaseError
- *
- */
-export declare class SerializationError extends BaseError {
-    constructor(msg: string | Error);
-}
-/**
- * @summary Represents a failure in finding a model
- *
- * @param {string} msg the error message
- *
- * @class NotFoundError
- * @extends BaseError
- *
- */
-export declare class NotFoundError extends BaseError {
-    constructor(msg: string | Error);
-}
-/**
- * @summary Represents a conflict in the storage
- *
- * @param {string} msg the error message
- *
- * @class ConflictError
- * @extends BaseError
- *
- */
-export declare class ConflictError extends BaseError {
-    constructor(msg: string | Error);
-}

package/lib/repository/index.d.ts

@@ -1,7 +0,0 @@
-export * from "./BaseRepository";
-export * from "./Context";
-export * from "./DataCache";
-export * from "./errors";
-export * from "./Repository";
-export * from "./utils";
-export * from "./wrappers";

package/lib/repository/utils.d.ts

@@ -1,62 +0,0 @@
-import { IRepository } from "../interfaces/IRepository";
-import { DecoratorMetadata } from "@decaf-ts/reflection";
-import { Constructor, Model } from "@decaf-ts/decorator-validation";
-import { Context } from "./Context";
-export type ContextArgs<M extends Model> = {
-    context: Context<M>;
-    args: any[];
-};
-/**
- * @summary retrieves the arguments for the handler
- * @param {any} dec the decorator
- * @param {string} prop the property name
- * @param {{}} m the model
- * @param {{}} [accum] accumulator used for internal recursiveness
- *
- * @function getHandlerArgs
- * @memberOf module:db-decorators.Repository
- */
-export declare const getHandlerArgs: (dec: any, prop: string, m: Constructor<any>, accum?: Record<string, {
-    args: string[];
-}>) => Record<string, {
-    args: string[];
-}> | void;
-/**
- *
- * @param {IRepository<T>} repo
- * @param context
- * @param {T} model
- * @param operation
- * @param prefix
- *
- * @param oldModel
- * @function enforceDBPropertyDecoratorsAsync
- *
- * @memberOf db-decorators.utils
- */
-export declare function enforceDBDecorators<M extends Model, Y extends IRepository<M>, V>(repo: Y, context: Context<M>, model: M, operation: string, prefix: string, oldModel?: M): Promise<void>;
-/**
- * Specific for DB Decorators
- * @param {T} model
- * @param {string} operation CRUD {@link OperationKeys}
- * @param {string} [extraPrefix]
- *
- * @function getDbPropertyDecorators
- *
- * @memberOf db-decorators.utils
- */
-export declare function getDbDecorators<T extends Model>(model: T, operation: string, extraPrefix?: string): Record<string, DecoratorMetadata[]> | undefined;
-/**
- * @summary Retrieves the decorators for an object's properties prefixed by {@param prefixes} recursively
- * @param model
- * @param accum
- * @param prefixes
- *
- * @function getAllPropertyDecoratorsRecursive
- * @memberOf module:db-decorators.Repository
- */
-export declare const getAllPropertyDecoratorsRecursive: <T extends Model>(model: T, accum: {
-    [indexer: string]: any[];
-} | undefined, ...prefixes: string[]) => {
-    [indexer: string]: any[];
-} | undefined;

package/lib/repository/wrappers.d.ts

@@ -1,38 +0,0 @@
-/**
- * @summary Util method to change a method of an object prefixing it with another
- * @param {any} obj The Base Object
- * @param {Function} after The original method
- * @param {Function} prefix The Prefix method. The output will be used as arguments in the original method
- * @param {string} [afterName] When the after function anme cannot be extracted, pass it here
- *
- * @function prefixMethod
- *
- * @memberOf module:db-decorators.Repository
- */
-export declare function prefixMethod(obj: any, after: (...args: any[]) => any, prefix: (...args: any[]) => any, afterName?: string): void;
-/**
- * @summary Util method to change a method of an object suffixing it with another
- * @param {any} obj The Base Object
- * @param {Function} before The original method
- * @param {Function} suffix The Prefix method. The output will be used as arguments in the original method
- * @param {string} [beforeName] When the after function anme cannot be extracted, pass it here
- *
- * @function suffixMethod
- *
- * @memberOf module:db-decorators.Repository
- */
-export declare function suffixMethod(obj: any, before: (...args: any[]) => any, suffix: (...args: any[]) => any, beforeName?: string): void;
-/**
- * @summary Util method to wrap a method of an object with additional logic
- *
- * @param {any} obj The Base Object
- * @param {Function} before the method to be prefixed
- * @param {Function} method the method to be wrapped
- * @param {Function} after The method to be suffixed
- * @param {string} [methodName] When the after function anme cannot be extracted, pass it here
- *
- * @function wrapMethodWithContext
- *
- * @memberOf module:db-decorators.Repository
- */
-export declare function wrapMethodWithContext(obj: any, before: (...args: any[]) => any, method: (...args: any[]) => any, after: (...args: any[]) => any, methodName?: string): void;

package/lib/validation/constants.d.ts

@@ -1,30 +0,0 @@
-/**
- * @summary holds the default error messages
- * @const DEFAULT_ERROR_MESSAGES
- *
- * @memberOf module:db-decorators.Model
- */
-export declare const DEFAULT_ERROR_MESSAGES: {
-    ID: {
-        INVALID: string;
-        REQUIRED: string;
-    };
-    READONLY: {
-        INVALID: string;
-    };
-    TIMESTAMP: {
-        REQUIRED: string;
-        DATE: string;
-        INVALID: string;
-    };
-};
-/**
- * @summary Update reflection keys
- * @const UpdateValidationKeys
- * @memberOf module:db-decorators.Operations
- */
-export declare const UpdateValidationKeys: {
-    REFLECT: string;
-    TIMESTAMP: string;
-    READONLY: string;
-};

package/lib/validation/decorators.d.ts

@@ -1,58 +0,0 @@
-import { Model } from "@decaf-ts/decorator-validation";
-import { OperationKeys } from "../operations/constants";
-import { IRepository } from "../interfaces/IRepository";
-import { Context } from "../repository/Context";
-/**
- * Marks the property as readonly.
- *
- * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES.READONLY.INVALID}
- *
- * @decorator readonly
- *
- * @category Decorators
- */
-export declare function readonly(message?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
-export declare function timestampHandler<M extends Model, V extends IRepository<M>, Y = any>(this: V, context: Context<M>, data: Y, key: string, model: M): Promise<void>;
-/**
- * Marks the property as timestamp.
- * Makes it {@link required}
- * Makes it a {@link date}
- *
- * Date Format:
- *
- * <pre>
- *      Using similar formatting as Moment.js, Class DateTimeFormatter (Java), and Class SimpleDateFormat (Java),
- *      I implemented a comprehensive solution formatDate(date, patternStr) where the code is easy to read and modify.
- *      You can display date, time, AM/PM, etc.
- *
- *      Date and Time Patterns
- *      yy = 2-digit year; yyyy = full year
- *      M = digit month; MM = 2-digit month; MMM = short month name; MMMM = full month name
- *      EEEE = full weekday name; EEE = short weekday name
- *      d = digit day; dd = 2-digit day
- *      h = hours am/pm; hh = 2-digit hours am/pm; H = hours; HH = 2-digit hours
- *      m = minutes; mm = 2-digit minutes; aaa = AM/PM
- *      s = seconds; ss = 2-digit seconds
- *      S = miliseconds
- * </pre>
- *
- * @param {string[]} operation The {@link DBOperations} to act on. Defaults to {@link DBOperations.CREATE_UPDATE}
- * @param {string} [format] The TimeStamp format. defaults to {@link DEFAULT_TIMESTAMP_FORMAT}
- * @param {{new: UpdateValidator}} [validator] defaults to {@link TimestampValidator}
- *
- * @decorator timestamp
- *
- * @category Decorators
- */
-export declare function timestamp(operation?: OperationKeys[], format?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
-export declare function serializeOnCreateUpdate<T extends Model, V extends IRepository<T>, Y = any>(this: V, data: Y, key: string, model: T, oldModel: T): Promise<void>;
-export declare function serializeAfterAll<T extends Model, V extends IRepository<T>, Y = any>(this: V, data: Y, key: string, model: T): Promise<void>;
-/**
- * @summary Serialize Decorator
- * @description properties decorated will the serialized before stored in the db
- *
- * @function serialize
- *
- * @memberOf module:wallet-db.Decorators
- */
-export declare function serialize(): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;

package/lib/validation/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./validators";
-export * from "./constants";
-export * from "./decorators";
-export * from "./validation";