@solidev/data 0.0.1-alpha.0

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@solidev/data" />
+export * from './public-api';

package/lib/auth/auth-interceptor.service.d.ts

@@ -0,0 +1,17 @@
+import { InjectionToken } from '@angular/core';
+import { HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { AuthServiceBase } from './auth.service';
+import * as i0 from "@angular/core";
+export declare const DATA_AUTH_SERVICE: InjectionToken<AuthServiceBase<any, any, any>>;
+export declare class AuthInterceptor implements HttpInterceptor {
+    private _auth;
+    private _apiUrl;
+    private _isRefreshing;
+    private _refreshTokenSubject;
+    constructor(_auth: AuthServiceBase<any, any, any>, _apiUrl: string);
+    intercept(req: HttpRequest<any>, next: HttpHandler): import("rxjs").Observable<import("@angular/common/http").HttpEvent<any>>;
+    private _handle401Error;
+    private _addToken;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthInterceptor>;
+}

package/lib/auth/auth.service.d.ts

@@ -0,0 +1,43 @@
+import { InjectionToken } from '@angular/core';
+import { IJwtBaseData, IJwtRefreshResponseJson } from './jwt';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { DataModel } from '../data/data-model';
+import { Collection } from '../data/data-collection';
+import { Router } from '@angular/router';
+import { DataMessageService } from '../messages/message.service';
+export interface AuthParams {
+    tokenUrl: string;
+    tokenRefreshUrl: string;
+    loginField: string;
+    passwordField: string;
+    loginRoute: string[];
+}
+/**
+ * DATA_API_URL: stores data api base url
+ */
+export declare const DATA_AUTH_PARAMS: InjectionToken<AuthParams>;
+export declare const DATA_AUTH_USER_SERVICE: InjectionToken<Collection<any>>;
+export declare class AuthServiceBase<User extends DataModel, UserService extends Collection<User>, UserData extends IJwtBaseData> {
+    userService: UserService;
+    private _params;
+    private _router;
+    private _http;
+    private _msgs;
+    private _user;
+    private _user$;
+    private _token;
+    constructor(userService: UserService, _params: AuthParams, _router: Router, _http: HttpClient, _msgs: DataMessageService);
+    get isAnonymous(): boolean;
+    get accessToken(): string | null;
+    get refreshToken(): string | null;
+    get currentUser(): User | null;
+    get currentUser$(): Observable<User | null>;
+    get refreshUrl(): string;
+    get loginUrl(): string;
+    logout(): void;
+    autoLogin(): void;
+    login(username: string, password: string): Observable<boolean>;
+    saveAuth(): void;
+    refresh(): Observable<IJwtRefreshResponseJson | null>;
+}

package/lib/auth/jwt.d.ts

@@ -0,0 +1,22 @@
+export interface IJwtResponseJson {
+    access: string;
+    refresh: string;
+}
+export interface IJwtRefreshResponseJson {
+    access: string;
+}
+export interface IJwtBaseData {
+    token_type: 'access' | 'refresh';
+    user_id: number;
+}
+export declare class Jwt<UserJwtData extends IJwtBaseData> {
+    readonly access?: string;
+    readonly refresh?: string;
+    private readonly _data;
+    constructor(response?: IJwtResponseJson);
+    get data(): UserJwtData | null;
+    toJson(): {
+        access: string | undefined;
+        refresh: string | undefined;
+    };
+}

package/lib/data/data-backend.d.ts

@@ -0,0 +1,47 @@
+import { HttpClient } from '@angular/common/http';
+import { TransferState } from '@angular/platform-browser';
+import { Observable } from 'rxjs';
+import { Collection, IActionParams } from './data-collection';
+import { DataModel } from './data-model';
+import * as i0 from "@angular/core";
+/**
+ * DataBackend provides CRUD operations to a REST api.
+ * TransferState can be used if DATA_MAX_TRANSFERSTATE_TIME is set and > 0
+ */
+export declare class DataBackend {
+    private _http;
+    private _transferState;
+    private _platform;
+    private _apiUrl;
+    private _maxTransferstateTime;
+    private _created;
+    constructor(_http: HttpClient, _transferState: TransferState, _platform: any, _apiUrl: string, _maxTransferstateTime?: number);
+    /**
+     * Return api url for this backend.
+     */
+    get apiUrl(): string;
+    /**
+     * Launch an action on collection.
+     * If method is GET and collection.useTranserState & transferState are enabled,
+     * result is stored / retrieved from transferState.
+     *
+     * @param collection Collection reference
+     * @param method HTTP method
+     * @param url full URL for action
+     * @param body JSON body
+     * @param params query parameters
+     * @param headers query headers
+     *
+     * @return an observable of response body
+     */
+    action<T extends DataModel, RT>(collection: Collection<T>, method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', url: string, { body, params, headers }?: IActionParams): Observable<RT>;
+    put<T extends DataModel>(collection: Collection<T>, url: string, { body, params, headers }?: IActionParams): Observable<T>;
+    post<T extends DataModel>(collection: Collection<T>, url: string, { body, params, headers }?: IActionParams): Observable<Partial<T>>;
+    patch<T extends DataModel>(collection: Collection<T>, url: string, { body, params, headers }?: IActionParams): Observable<Partial<T>>;
+    delete<T extends DataModel, R>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<R>;
+    _cachedGet<T extends DataModel, RT>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<RT>;
+    get<T extends DataModel>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<Partial<T>>;
+    list<T extends DataModel>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataBackend, [null, null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataBackend>;
+}

package/lib/data/data-collection.d.ts

@@ -0,0 +1,87 @@
+import { DataModel } from './data-model';
+import { DataBackend } from './data-backend';
+import { Observable } from 'rxjs';
+import { FilterData, IQuerysetOptions, Queryset } from './data-query';
+export declare type IHttpMethod = 'POST' | 'GET' | 'DELETE' | 'PUT' | 'PATCH';
+export interface IActionParams {
+    body?: any;
+    headers?: {
+        [index: string]: string;
+    };
+    params?: {
+        [index: string]: string;
+    };
+}
+export interface ICollectionCacheParams {
+    transferState?: {
+        enabled: boolean;
+        maxTime: number;
+        maxCount: number;
+    };
+}
+export declare type DataModelType<T extends DataModel> = new (_coll?: Collection<T>) => T;
+export declare class Collection<T extends DataModel> {
+    protected backend: DataBackend;
+    protected path: string;
+    model: DataModelType<T>;
+    useTransferState: boolean;
+    constructor(backend: DataBackend, path: string, model: DataModelType<T>);
+    create(data?: Partial<T>): T;
+    fromJson(data: Partial<T>): T;
+    fromJson(data: Partial<T>[]): T[];
+    queryset(options?: IQuerysetOptions): Queryset<T>;
+    fetch(id: number, { prefix, suffix, params, headers, }?: {
+        prefix?: string;
+        suffix?: string;
+        params?: {
+            [_index: string]: string;
+        };
+        headers?: {
+            [_index: string]: string;
+        };
+    }): Observable<T>;
+    action<RT>(model: T | null, method: IHttpMethod, action: string, { body, params, headers }?: IActionParams): Observable<RT>;
+    save(model: T, { updateModel }?: {
+        updateModel?: boolean;
+    }): Observable<T>;
+    update(model: T, fields?: string[], { updateModel }?: {
+        updateModel?: boolean;
+    }): Observable<T>;
+    delete(model: T, { params, headers }?: IActionParams): Observable<any>;
+    list(query?: FilterData, { prefix, suffix, params, headers, }?: {
+        prefix?: string;
+        suffix?: string;
+        params?: {
+            [_index: string]: string;
+        };
+        headers?: {
+            [_index: string]: string;
+        };
+    }): Observable<T[]>;
+    /**
+     * Calls *method* endpoint for this collection and returns raw results.
+     *
+     * @param method GET/POST/...
+     * @param prefix collection_urlPREFIXSUFFIX
+     * @param suffix collection_urlPREFIXSUFFIX
+     * @param params query paremeters
+     * @param body body as json
+     * @param headers headers
+     */
+    raw<RT>({ method, prefix, suffix, params, body, headers, }?: {
+        method?: IHttpMethod;
+        prefix?: string;
+        suffix?: string;
+        body?: any;
+        params?: {
+            [_index: string]: string;
+        };
+        headers?: {
+            [_index: string]: string;
+        };
+    }): Observable<RT>;
+    getUrl(id?: number | null, { prefix, suffix }?: {
+        prefix?: string;
+        suffix?: string;
+    }): string;
+}

package/lib/data/data-collection.mock.d.ts

@@ -0,0 +1,19 @@
+import { DataModel } from "./data-model";
+import { Observable } from "rxjs";
+import { IQuerysetOptions } from "./data-query";
+import { QuerysetMock } from "./data-query.mock";
+import { Collection, IActionParams, IHttpMethod } from "./data-collection";
+export declare class CollectionMock<T extends DataModel> {
+    protected model: new (coll: Collection<T>) => T;
+    mockValue?: T;
+    mockValues?: T[];
+    actionValue: any;
+    constructor(model: new (coll: Collection<T>) => T);
+    fetch(id: number, suffix?: string): Observable<T>;
+    action(model: T | null, method: IHttpMethod, action: string, params: IActionParams): Observable<any>;
+    queryset(options?: IQuerysetOptions): QuerysetMock<T>;
+    list(query?: {
+        [index: string]: string;
+    }, suffix?: string): Observable<any>;
+    fromJson(data: any, many?: boolean): T | any;
+}

package/lib/data/data-model.d.ts

@@ -0,0 +1,93 @@
+import { BaseFieldManager, IFieldStoredMetadata } from './fields/base';
+import { FormControl, FormGroup, ValidationErrors } from '@angular/forms';
+import { Collection } from './data-collection';
+import { Observable } from 'rxjs';
+export declare type DataModelFields = Readonly<Map<string, IFieldStoredMetadata<any>>>;
+/**
+ * Base class for data model.
+ *
+ * Each class must have a static __name
+ * primary field is given with id field.
+ *
+ * Some methods are provided to be used with a collection, mostly for CRUD operations.
+ *
+ */
+export declare class DataModel {
+    protected _coll?: Collection<any> | undefined;
+    /**
+     * data model name
+     * this need to be given because class name is not fully available because of minification.
+     */
+    protected static readonly __name: string;
+    /**
+     * Primary field; readonly; must be created and auto incremented on db side.
+     */
+    id: number;
+    private readonly _F;
+    /**
+     * Constructor for data model instance.
+     * A matching collection can be provided.
+     * ___fields readonly property is also populated from Reflected metadata
+     *
+     * @param _coll collection used for CRUD, etc..
+     */
+    constructor(_coll?: Collection<any> | undefined);
+    get _collection(): Collection<any>;
+    set _collection(coll: Collection<any>);
+    /**
+     *  HashMap of fields metadata (type, name, manager, etc...)
+     */
+    get F(): DataModelFields;
+    get FN(): IterableIterator<string>;
+    /**
+     * Loads model data from json.
+     * If partial is true, only fields with matching data keys will be loaded
+     * @param data
+     * @param options
+     */
+    fromJson(data: {
+        [index: string]: any;
+    }, { partial, check }?: {
+        partial?: boolean;
+        check?: boolean;
+    }): null | ValidationErrors;
+    toJson(fields?: string | string[]): any;
+    action<T, RT extends {
+        [index: string]: any;
+    }>(method: 'POST' | 'PATCH' | 'GET' | 'DELETE' | 'PUT', name: string, { body, update, updatePartial, updateCheck, params, headers, }?: {
+        body?: {
+            [_index: string]: any;
+        };
+        update?: boolean;
+        updatePartial?: boolean;
+        updateCheck?: boolean;
+        params?: {
+            [_index: string]: string;
+        };
+        headers?: {
+            [_index: string]: string;
+        };
+    }): Observable<RT>;
+    FM<FT>(field: string): BaseFieldManager<FT>;
+    FV<FT>(field: string): FT;
+    /**
+     * Set field value. If check is true, only set value if all validators pass.
+     *
+     * The validation result is returned.
+     *
+     * @param field field name
+     * @param value field valued
+     * @param check default false
+     * @return null or ValidationError
+     */
+    setFV<FT>(field: string, value: FT, check?: boolean): null | ValidationErrors;
+    FC(): FormGroup;
+    FC(field: string): FormControl;
+    FC(field: string[]): FormGroup;
+    save({ updateModel }?: {
+        updateModel?: boolean;
+    }): Observable<this>;
+    update(fields?: string[], { updateModel }?: {
+        updateModel?: boolean;
+    }): Observable<this>;
+}

package/lib/data/data-parameters.d.ts

@@ -0,0 +1,26 @@
+import { InjectionToken } from "@angular/core";
+/**
+ * DATA_API_URL: stores data api base url
+ */
+export declare const DATA_API_URL: InjectionToken<string>;
+/**
+ * DATA_MAX_TRANSFERSTATE_TIME: max duration to use transferstate time
+ * If DATA_MAX_TRANSFERSTATE_TIME is zero, TransferState is not used
+ */
+export declare const DATA_MAX_TRANSFERSTATE_TIME: InjectionToken<number>;
+/**
+ * DataDisplayConfig interface provides default values for display classes
+ */
+export interface DataDisplayConfig {
+    dispEdit: {
+        defaultMode: "inline" | "dd";
+        inputClasses: {
+            [index: string]: string;
+        };
+    };
+}
+export declare const BootstrapDataDisplayConfig: DataDisplayConfig;
+/**
+ * DATA_DISPLAY_CONFIG: display config & default classes injection token
+ */
+export declare const DATA_DISPLAY_CONFIG: InjectionToken<DataDisplayConfig>;

package/lib/data/data-query.d.ts

@@ -0,0 +1,101 @@
+import { Collection } from './data-collection';
+import { DataModel } from './data-model';
+import { Observable } from 'rxjs';
+import { ActivatedRoute, Router } from '@angular/router';
+export interface FilterData {
+    [index: string]: string | number | boolean | undefined | null;
+}
+export declare type SortData = string;
+/**
+ * Queryset parameters
+ */
+export interface IQuerysetOptions {
+    /** Emit fields list */
+    emitFields?: boolean;
+    /** Queryset name */
+    name?: string;
+    /** TODO: see usage */
+    route?: ActivatedRoute;
+    /** TODO: see usage */
+    router?: Router;
+    /** TODO: see usage */
+    hash?: string;
+}
+export interface IQueryNav {
+    page: number;
+    page_size: number;
+}
+export interface IQueryMetaNav {
+    count: number;
+    next: number | null;
+    page: number;
+    pages: number;
+    prev: number | null;
+    size: number;
+}
+export interface IQueryMetaNavParams {
+    page: string;
+    page_size: string;
+}
+export interface IQueryMeta {
+    nav: IQueryMetaNav;
+    parameters: IQueryMetaNavParams;
+}
+export interface IQueryFullResponse<T> extends IQueryMeta {
+    results: T[];
+}
+export declare class Queryset<T extends DataModel> {
+    protected _coll: Collection<T>;
+    /** Current filter data */
+    filterData: FilterData;
+    /** Current sorter data */
+    sortData: SortData[];
+    /** Current fields */
+    fields: string[];
+    /** Current page size */
+    pageSize: number;
+    /** Current page number */
+    page: number;
+    options: IQuerysetOptions;
+    constructor(_coll: Collection<T>, options?: IQuerysetOptions);
+    private _pristine;
+    /** Pristine status (true if it has not collected results yet) */
+    get pristine(): boolean;
+    private _loading;
+    /** Loading status (true if currently fetching data) */
+    get loading(): Observable<boolean>;
+    private _meta;
+    /** Results meta part observable */
+    get meta(): Observable<IQueryMeta>;
+    private _results;
+    /** Results data part observable */
+    get results(): Observable<T[]>;
+    private _full?;
+    /** Full results observable (results, loading, meta) */
+    get full(): Observable<[T[], boolean, IQueryMeta]>;
+    /**
+     * Update current filter data. Null or undefined values are removed from filter data.
+     * @param params filter data
+     * @param update boolean to update filter data instead of recreating it from scratch
+     */
+    filter(params?: FilterData, update?: boolean): Queryset<T>;
+    /**
+     * Update sorting parameters, list of strings giving sort parameters e.g. sort("+name", "-id").
+     * @param sorting strings of sort parameters
+     */
+    sort(...sorting: string[]): Queryset<T>;
+    /**
+     * Update page size.
+     * @param pageSize required page size
+     */
+    paginateBy(pageSize?: number): Queryset<T>;
+    /**
+     * Update current page number.
+     * @param page required pqge
+     * @param fragment TODO: fragment usage for router usage
+     */
+    setPage(page?: number, fragment?: string): Queryset<T>;
+    setFields(fields: string[]): Queryset<T>;
+    getQueryParams(): FilterData;
+    get(refresh?: boolean): Observable<T[]>;
+}

package/lib/data/data-query.mock.d.ts

@@ -0,0 +1,25 @@
+import { DataModel } from "./data-model";
+import { CollectionMock } from "./data-collection.mock";
+import { FilterData, IQueryMeta, IQuerysetOptions, SortData } from "./data-query";
+import { Observable } from "rxjs";
+export declare class QuerysetMock<T extends DataModel> {
+    protected _coll: CollectionMock<T>;
+    options: IQuerysetOptions;
+    mockData: T[];
+    filterData: FilterData;
+    sortData: SortData[];
+    pageSize: number;
+    page: number;
+    pristine: boolean;
+    loading: Observable<boolean>;
+    constructor(_coll: CollectionMock<T>, options?: IQuerysetOptions);
+    get results(): Observable<T[]>;
+    get meta(): Observable<IQueryMeta>;
+    get full(): Observable<[T[], boolean, IQueryMeta]>;
+    filter(params?: FilterData): QuerysetMock<T>;
+    sort(...sorting: string[]): QuerysetMock<T>;
+    paginateBy(pageSize?: number): QuerysetMock<T>;
+    setPage(page: number): QuerysetMock<T>;
+    getQueryParams(): FilterData;
+    get(): Observable<T[]>;
+}

package/lib/data/fields/base.d.ts

@@ -0,0 +1,116 @@
+import 'reflect-metadata';
+import { FormControl, ValidatorFn } from '@angular/forms';
+import { DataModel } from '../data-model';
+import { DISPEDIT_DISPLAY_TYPES, DISPEDIT_EDITOR_TYPES } from '../../dispedit/dispedit/dispedit.constants';
+export declare const PROPERTY_METADATA_KEY: unique symbol;
+/**
+ * Descriptive info for all fields.
+ * All are optional.
+ */
+export interface IFieldMetadata<FT> {
+    /** Field name (for display, column title, etc..) */
+    name?: string;
+    /** Field help text (for input) */
+    help?: string;
+    /** Field description (for details on hover etc..) */
+    description?: string;
+    /** Field required : no undefined allowed on save ? */
+    required?: boolean;
+    /** Field cannot be updated */
+    readonly?: boolean;
+    /** Default value */
+    defaultValue?: FT | ((args: any) => FT) | null;
+}
+/**
+ * Base field manager, stores metadata and provides common field utilities
+ *
+ * - name : field name, should be the same in data structure and model
+ * - help : field help text, blank by default
+ * - description : field name for humans
+ * - readonly : field is readonly (cannot be changed / pushed to api)
+ * - default : default value for field
+ *
+ * - editor_type : editor type
+ * - display_type : display type
+ *
+ * - fromJson(data) : deserializer
+ * - toJson(data) : serialiser
+ * - toString(data,format) : to string, for display
+ *
+ * - formControl : returns field form control
+ * - validators : returns field validator
+ */
+export declare class BaseFieldManager<FT> implements IFieldMetadata<FT> {
+    /** Name is mandatory in a field manager. It is given by
+     * field decorator if not directly given in field manager. */
+    name: string;
+    description: string;
+    help: string;
+    required: boolean;
+    readonly: boolean;
+    defaultValue?: FT | ((args: any) => FT);
+    editorType: DISPEDIT_EDITOR_TYPES;
+    displayType: DISPEDIT_DISPLAY_TYPES;
+    constructor(params: IFieldMetadata<FT>);
+    /** Return field validators */
+    get validators(): ValidatorFn[];
+    /** Returns current field name */
+    get fname(): string;
+    /** Create a new typed formControl for this field. */
+    formControl(instance: DataModel): FormControl<FT | null>;
+    /** JSON deserializer base method. */
+    fromJson(data: any): FT;
+    /** JSON serializer base method. */
+    toJson(data: FT): any;
+    /**
+     * Display value (as string)
+     * @param data
+     * @param format (not used)
+     */
+    toString(data: FT, format?: string): string;
+    /** Return validators
+     *
+     * @protected
+     */
+    protected getValidators(): ValidatorFn[];
+    /**
+     * Returns default value for model, using args if needed.
+     * @param args
+     */
+    default(args?: any): FT | undefined;
+    /**
+     * Returns default value for model, using args if needed.
+     * @param args
+     * @protected
+     */
+    protected getDefaultValue(args?: any): FT | undefined;
+}
+/**
+ * Field data stored on reflected metadata.
+ */
+export interface IFieldStoredMetadata<FT> extends IFieldMetadata<FT> {
+    self: string;
+    name: string;
+    type: string;
+    manager: BaseFieldManager<FT>;
+}
+/** Manager constructor
+ *  FT is js field type;
+ *  T is manager type
+ * */
+declare type BaseFieldManagerConstructor<FT, T extends BaseFieldManager<FT>> = new (params: any) => T;
+/**
+ * Field decorator function
+ */
+export declare type FieldDecoratorFn = (target: any, propertyKey: string | symbol) => void;
+/**
+ * Creates a field decorator that can only be applied within
+ * an object containing a static __name property.
+ *
+ *
+ * @param meta field metadata
+ * @param type field type code
+ * @param manager field manager
+ */
+export declare function genericDataField<FT, MD extends IFieldMetadata<FT>, MG extends BaseFieldManager<FT>>(meta: MD, type: string, manager: BaseFieldManagerConstructor<FT, MG>): FieldDecoratorFn;
+export {};

package/lib/data/fields/boolean.d.ts

@@ -0,0 +1,9 @@
+import { BaseFieldManager, IFieldMetadata } from './base';
+import { DISPEDIT_DISPLAY_TYPES, DISPEDIT_EDITOR_TYPES } from '../../dispedit/dispedit/dispedit.constants';
+export declare type IBooleanFieldMetadata = IFieldMetadata<boolean | null>;
+export declare class BooleanFieldManager extends BaseFieldManager<boolean | null> implements IBooleanFieldMetadata {
+    editorType: DISPEDIT_EDITOR_TYPES;
+    displayType: DISPEDIT_DISPLAY_TYPES;
+    fromJson(data: any): boolean | null;
+}
+export declare const booleanField: (updates?: IBooleanFieldMetadata) => import("./base").FieldDecoratorFn;

package/lib/data/fields/datetime.d.ts

@@ -0,0 +1,39 @@
+import { BaseFieldManager, IFieldMetadata } from './base';
+import { DISPEDIT_DISPLAY_TYPES, DISPEDIT_EDITOR_TYPES } from '../../dispedit/dispedit/dispedit.constants';
+import { ValidatorFn } from '@angular/forms';
+export interface IDateFieldMetadata extends IFieldMetadata<Date | null> {
+    autoNow?: boolean;
+    autoNowAdd?: boolean;
+    min?: Date;
+    max?: Date;
+}
+export declare const dateMinimum: (date: Date) => ValidatorFn;
+export declare const dateMaximum: (date: Date) => ValidatorFn;
+export interface IDatetimeFieldMetadata extends IDateFieldMetadata {
+    timezone?: string;
+}
+export declare class DateFieldManager extends BaseFieldManager<Date | null> {
+    autoNow: boolean;
+    autoNowAdd: boolean;
+    min?: Date;
+    max?: Date;
+    editorType: DISPEDIT_EDITOR_TYPES;
+    displayType: DISPEDIT_DISPLAY_TYPES;
+    get validators(): ValidatorFn[];
+    fromJson(data: any): Date | null;
+    toJson(data: Date | string | null): null | string;
+    /**
+     * Returns default value for model, using args if needed.
+     * @param args
+     * @protected
+     */
+    protected getDefaultValue(args?: any): Date | null | undefined;
+}
+export declare class DatetimeFieldManager extends DateFieldManager implements IDatetimeFieldMetadata {
+    timezone: string;
+    editorType: DISPEDIT_EDITOR_TYPES;
+    displayType: DISPEDIT_DISPLAY_TYPES;
+    toJson(data: Date): string | null;
+}
+export declare const dateField: (updates?: IDateFieldMetadata) => import("./base").FieldDecoratorFn;
+export declare const datetimeField: (updates?: IDatetimeFieldMetadata) => import("./base").FieldDecoratorFn;

package/lib/data/fields/index.d.ts

@@ -0,0 +1,6 @@
+export { charField, emailField, textField, passwordField, } from './stringfields';
+export { primaryField } from './primaryfield';
+export { dateField, datetimeField } from './datetime';
+export { foreignKeyField, manyToManyField, reverseForeignKeyField, detailsField, } from './relations';
+export { booleanField } from './boolean';
+export { decimalField, integerField, floatField } from './numbers';