import { scalar } from "./base.scalar";
import { memberModel } from "./memberModel";
import { pair } from "./base.pair";
import { middlewareComponent } from "./middlewareComponent";
import { mergeTypeEnum } from "./mergeTypeEnum";
import { httpComponent } from "./httpComponent";
import { wrapEnum } from "./wrapEnum";
import { searchTargetEnum } from "./searchTargetEnum";
import { idTypeEnum } from "./idTypeEnum";
import { model } from "./base.model";
import { projectEntity } from "./projectEntity";
import { countryEnum } from "./countryEnum";
import { languageEnum } from "./languageEnum";
import { applicationEnum } from "./applicationEnum";
import { platformEnum } from "./platformEnum";
export declare namespace entity {
    type AnyId = scalar.Uuid | scalar.Integer | scalar.Alpha;
    interface SyncAll {
    }
    type NumType = 'smallint' | 'int';
    interface Minimal<T extends scalar.PossibleId = scalar.Alpha> extends scalar.AnyObject {
        id?: T;
    }
    interface Classic<T extends scalar.PossibleId = scalar.Alpha> extends Minimal<T> {
        createdAt?: scalar.IsoDatetime;
        updatedAt?: scalar.IsoDatetime;
    }
    interface Action<T extends scalar.PossibleId = scalar.Alpha> extends Minimal<T> {
        createdAt?: scalar.IsoDatetime;
        createdBy?: memberModel.AnyId;
        updatedAt?: scalar.IsoDatetime;
        updatedBy?: memberModel.AnyId;
        _revision?: scalar.Integer;
    }
    interface Pure<T extends scalar.PossibleId = scalar.Alpha> extends Minimal<T> {
        createdAt?: scalar.IsoDatetime;
        createdBy?: memberModel.AnyId;
        updatedAt?: scalar.IsoDatetime;
        updatedBy?: memberModel.AnyId;
        _type?: scalar.Alpha;
        _revision?: scalar.Integer;
        _keywords?: Array<scalar.Title>;
        name?: scalar.Unknown;
        _name?: scalar.Unknown;
        num?: scalar.Integer;
    }
    interface Doc<T extends scalar.PossibleId = scalar.Alpha> extends Pure<T> {
        _merge?: scalar.StrMap<Partial<Pure<T>>>;
        _i18n?: scalar.StrMap<Partial<Pure<T>>>;
    }
    interface View<T extends scalar.PossibleId = scalar.Alpha> extends Minimal<T> {
        dummy?: unknown;
    }
    interface Sys extends scalar.AnyObject {
        $trash?: scalar.Uuid;
        $trashedBy?: memberModel.AnyId;
        $trashedAt?: scalar.IsoDatetime;
        $trashInfo?: scalar.Title;
        $ver?: scalar.Integer;
        $irregulars?: Array<scalar.Alpha>;
        $relation?: scalar.Integer;
        $createdAt?: scalar.IsoDatetime;
        $createdBy?: memberModel.AnyId;
        $updatedAt?: scalar.IsoDatetime;
        $updatedBy?: memberModel.AnyId;
    }
    interface Wrapper<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>> extends Minimal<T> {
        deleted?: scalar.Boolean;
        doc?: E;
        sys?: Sys;
        num?: scalar.Integer;
        search?: Search;
    }
    interface Search {
        id: Array<scalar.Uuid>;
        word: Array<scalar.Alpha>;
        sentence: Array<scalar.Alpha>;
        soundex: Array<scalar.Alpha>;
        metaphone: Array<scalar.Alpha>;
        stemmed: Array<scalar.Alpha>;
    }
    interface Option extends Record<string, unknown> {
        mandatory?: scalar.Boolean;
        exists?: scalar.Boolean;
        formatted?: scalar.Boolean;
        isList?: scalar.Boolean;
        mergePath?: scalar.Title;
        requestIfExists?: scalar.Boolean;
        modifyType?: scalar.Alpha;
        existingId?: scalar.Uuid;
        orderThrowing?: scalar.Boolean;
        searchIn?: scalar.Boolean;
    }
    interface ListCriteria {
        _order?: scalar.Alpha;
        _desc?: scalar.Boolean;
        _limit?: scalar.Integer;
        _offset?: scalar.Integer;
        _search?: scalar.Title;
    }
    interface Filter extends scalar.AnyObject {
    }
    type CastOptFn = (REQ: httpComponent.Req) => scalar.AnyObject;
    type RouteFn = (router: httpComponent.Router) => void;
    type FilterCollectFn<F extends Filter = Filter> = (filter: F, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type FilterQueryFn<F extends Filter = Filter> = (q: unknown, filter: F, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type ReferenceQueryFn = (q: unknown, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type ReferenceCheckFn = (ref: scalar.Unknown) => scalar.Alpha;
    type ReferenceConvertFn = (ref: scalar.Unknown) => scalar.Alpha;
    type BeforeListFn<F extends Filter = Filter> = (filter: F, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type AfterListFn<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>, F extends Filter = Filter> = (docs: Array<E>, filter: F, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type FindQueryFn = (q: unknown, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type AfterFindFn<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>> = (doc: E, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type BeforeFormatFn<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>> = (doc: E, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type AfterFormatFn<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>> = (doc: E, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type BeforeCreateFn<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>> = (doc: E, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type AfterCreateFn<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>> = (doc: E, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type BeforeUpdateFn<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>> = (doc: E, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type AfterUpdateFn<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>> = (doc: E, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type BeforeSetFn<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>> = (doc: E, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type AfterSetFn<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>> = (doc: E, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type BeforeSyncFn<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>> = (doc: E, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type AfterSyncFn<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>> = (doc: E, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type BeforeDeleteFn<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>> = (doc: E, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type AfterDeleteFn<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>> = (doc: E, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type AfterAnyModify<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>> = (doc: E, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type BeforeBaseCheck<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>> = (existing: E, doc: E, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    type AfterBaseCheck<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>> = (existing: E, doc: E, OPT?: Option, REQ?: httpComponent.Req) => Promise<void>;
    interface RelationItem {
        ownedName: string;
        ownedId: string;
        ownedPath: string;
        childName: string;
        childId: string;
    }
    interface RelationFind {
        ownedName: string;
        ownedPath: string;
        count: number;
    }
    interface BanAssignEntity {
        bannedProjects?: Array<projectEntity.Id>;
        bannedCountries?: Array<countryEnum.Id>;
        bannedLanguages?: Array<languageEnum.Id>;
        bannedApplications?: Array<applicationEnum.Id>;
        bannedPlatforms?: Array<platformEnum.Id>;
    }
    interface ProjectAssignEntity {
        forAllProjects?: scalar.Boolean;
        projects?: Array<projectEntity.Id>;
        _projects?: Array<projectEntity.Id>;
    }
    interface ProjectAssignService<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>> {
        findProjectsAsync(doc: E, OPT?: Option, req?: httpComponent.Req): Promise<void>;
        findProjects(doc: E, OPT?: Option, req?: httpComponent.Req): void;
        afterProjectAddAsync(projectDoc: projectEntity.Doc, OPT?: Option, req?: httpComponent.Req): Promise<void>;
        afterProjectDeleteAsync(projectDoc: projectEntity.Doc, OPT?: Option, req?: httpComponent.Req): Promise<void>;
    }
    interface Service<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>, P extends pair.Core<T> = pair.Core<T>, F extends Filter = Filter> extends BaseExt<T, E, P, F>, ConfigExt<T, E, P, F>, HandleExt<T, E, P, F>, LambdaExt<T, E, P, F>, PrivateExt<T, E, P, F>, GetFindExt<T, E, P, F>, model.Base<T>, GetPairExt<T, E, P, F>, GetOtherExt<T, E, P, F>, ModifyExt<T, E, P, F>, CacheExt<T, E, P, F>, PropertyExt<T, E, P, F> {
        new (name: string): Service<T, E, P, F>;
    }
    interface BaseExt<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>, P extends pair.Core<T> = pair.Core<T>, F extends Filter = Filter> {
        name: scalar.Alpha;
        type: scalar.Alpha;
        optType(type?: scalar.Alpha): Service<T, E, P, F>;
        table: scalar.Alpha;
        optTable(table?: scalar.Alpha, schema?: scalar.Alpha): Service<T, E, P, F>;
        schema: scalar.Alpha;
        optSchema(schema?: scalar.Title): Service<T, E, P, F>;
        db: {
            table: string;
            schema: string;
        };
        setCustoms(): void;
        folder: scalar.Alpha;
        optFolder(folder?: scalar.Title): Service<T, E, P, F>;
        route: RouteFn;
        optRoute(fn?: RouteFn): Service<T, E, P, F>;
        _throwLambdaError(name: scalar.Alpha, fn: scalar.AnyFunc, mandatory?: scalar.Boolean): scalar.AnyFunc;
    }
    interface ConfigExt<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>, P extends pair.Core<T> = pair.Core<T>, F extends Filter = Filter> {
        isNameI18n: scalar.Boolean;
        uniqueField: scalar.Alpha;
        optIgnoreCheck(ignoreCheck?: scalar.Boolean): Service<T, E, P, F>;
        version: scalar.Integer;
        optVersion(version?: scalar.Integer): Service<T, E, P, F>;
        merges: Array<mergeTypeEnum.Id>;
        optMerges(...merges: Array<mergeTypeEnum.Id>): Service<T, E, P, F>;
        ignoredFields: scalar.Alpha[];
        optIgnoredFields(...fields: Array<scalar.Alpha>): Service<T, E, P, F>;
        bannedFields: scalar.Alpha[];
        optBannedFields(...fields: Array<scalar.Alpha>): Service<T, E, P, F>;
    }
    interface HandleExt<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>, P extends pair.Core<T> = pair.Core<T>, F extends Filter = Filter> {
        pairHandle: middlewareComponent.CmsMode;
        optPairHandle(option?: middlewareComponent.CmsModeOption): Service<T, E, P, F>;
        getHandle: middlewareComponent.CmsMode;
        optGetHandle(option?: middlewareComponent.CmsModeOption): Service<T, E, P, F>;
        listHandle: middlewareComponent.CmsMode;
        optListHandle(option?: middlewareComponent.CmsModeOption): Service<T, E, P, F>;
        createHandle: middlewareComponent.CmsMode;
        optCreateHandle(option?: middlewareComponent.CmsModeOption): Service<T, E, P, F>;
        updateHandle: middlewareComponent.CmsMode;
        optUpdateHandle(option?: middlewareComponent.CmsModeOption): Service<T, E, P, F>;
        deleteHandle: middlewareComponent.CmsMode;
        optDeleteHandle(option?: middlewareComponent.CmsModeOption): Service<T, E, P, F>;
    }
    interface LambdaExt<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>, P extends pair.Core<T> = pair.Core<T>, F extends Filter = Filter> {
        optFilterCollectAsync(fn?: FilterCollectFn<F>): Service<T, E, P, F>;
        optFilterQueryAsync(fn?: FilterQueryFn<F>): Service<T, E, P, F>;
        optBeforeListAsync(fn?: BeforeListFn<F>): Service<T, E, P, F>;
        optAfterListAsync(fn?: AfterListFn<T, E, F>): Service<T, E, P, F>;
        optFindQueryAsync(fn?: FindQueryFn): Service<T, E, P, F>;
        optAfterFindAsync(fn?: AfterFindFn<T, E>): Service<T, E, P, F>;
        optBeforeFormatAsync(fn?: BeforeFormatFn<T, E>): Service<T, E, P, F>;
        optAfterFormatAsync(fn?: AfterFormatFn<T, E>): Service<T, E, P, F>;
        optReferenceQueryAsync(fn?: ReferenceQueryFn): Service<T, E, P, F>;
        optBeforeCreateAsync(fn?: BeforeCreateFn<T, E>): Service<T, E, P, F>;
        optAfterCreateAsync(fn?: AfterCreateFn<T, E>): Service<T, E, P, F>;
        optBeforeUpdateAsync(fn?: BeforeUpdateFn<T, E>): Service<T, E, P, F>;
        optAfterUpdateAsync(fn?: AfterUpdateFn<T, E>): Service<T, E, P, F>;
        optBeforeSetAsync(fn?: BeforeSetFn<T, E>): Service<T, E, P, F>;
        optAfterSetAsync(fn?: AfterSetFn<T, E>): Service<T, E, P, F>;
        optAfterDeleteAsync(fn?: AfterDeleteFn<T, E>): Service<T, E, P, F>;
        optBeforeDeleteAsync(fn?: BeforeDeleteFn<T, E>): Service<T, E, P, F>;
        optAfterAnyChangingAsync(fn: AfterAnyModify<T, E>): Service<T, E, P, F>;
        optBeforeBaseCheckAsync(fn: BeforeBaseCheck<T, E>): Service<T, E, P, F>;
        optAfterBaseCheckAsync(fn: AfterBaseCheck<T, E>): Service<T, E, P, F>;
    }
    interface PrivateExt<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>, P extends pair.Core<T> = pair.Core<T>, F extends Filter = Filter> {
        _optGrab(REQ: httpComponent.Req): Option;
        _optExt(OPT: Option, ext: scalar.AnyObject): Option;
        _applyOrder(q: scalar.Unknown, criteria: ListCriteria, OPT?: Option, REQ?: httpComponent.Req): void;
        _applyLimitOffset(q: scalar.Unknown, criteria: ListCriteria, OPT?: Option, REQ?: httpComponent.Req): void;
        _searchInSql(q: scalar.Unknown, keywords: Array<scalar.Title>, OPT?: Option, REQ?: httpComponent.Req): void;
        _applySearch(q: scalar.Unknown, criteria: ListCriteria, OPT?: Option, REQ?: httpComponent.Req): void;
        _validateRefAsync(existing: E, doc: E, OPT?: Option, REQ?: httpComponent.Req): Promise<void>;
        _iterateNewRefAsync(property: Property, ref: scalar.Title, OPT?: Option, REQ?: httpComponent.Req): Promise<scalar.Alpha>;
        _checkRefWithIdAsync(ref: scalar.Title, OPT?: Option, REQ?: httpComponent.Req): Promise<E>;
        _clearSilents(doc: E, OPT?: Option, REQ?: httpComponent.Req): void;
        _clearInsertables(doc: E, OPT?: Option, REQ?: httpComponent.Req): void;
        _requestInsertablesAsync(doc: E, OPT?: Option, REQ?: httpComponent.Req): Promise<void>;
        _requestUpdatablesAsync(doc: E, OPT?: Option, REQ?: httpComponent.Req): Promise<void>;
        _syncFields(doc: E, OPT?: Option, REQ?: httpComponent.Req): Sys;
        _clearRelationsAsync(doc: E, OPT?: Option, REQ?: httpComponent.Req): Promise<scalar.Integer>;
        _getRelationsAsync(doc: E, OPT?: Option, REQ?: httpComponent.Req): Promise<Array<RelationFind>>;
        _addRelationsAsync(doc: E, OPT?: Option, REQ?: httpComponent.Req): Promise<Array<RelationItem>>;
        _addHistoryAsync(existing: E, doc: E, OPT?: Option, REQ?: httpComponent.Req): Promise<void>;
    }
    interface GetFindExt<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>, P extends pair.Core<T> = pair.Core<T>, F extends Filter = Filter> {
        /**
         * Finds record with any reference (id, code or num)
         * */
        findAsync(ref: scalar.Unknown, OPT?: Option, REQ?: httpComponent.Req): Promise<E | null>;
        /**
         * Finds record with id
         * */
        findByIdAsync(ref: scalar.Unknown, OPT?: Option, REQ?: httpComponent.Req): Promise<E | null>;
        /**
         * Finds record with code or name
         * */
        findByCodeAsync(ref: scalar.Unknown, OPT?: Option, REQ?: httpComponent.Req): Promise<E | null>;
        /**
         * Finds record with num
         * */
        findByNumAsync(ref: scalar.Unknown, OPT?: Option, REQ?: httpComponent.Req): Promise<E | null>;
        /**
         * Lists records with any reference (id, code or num)
         * */
        findArrayAsync(refs: scalar.Unknown, OPT?: Option, REQ?: httpComponent.Req): Promise<Array<E>>;
    }
    interface GetPairExt<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>, P extends pair.Core<T> = pair.Core<T>, F extends Filter = Filter> {
        pairSize: scalar.Integer;
        optPairSize(pairSize: scalar.Integer): Service<T, E, P, F>;
        suggestSize: scalar.Integer;
        optSuggestSize(suggestSize: scalar.Integer): Service<T, E, P, F>;
        _suggestQuery(q: unknown, keyword: scalar.Title, level: 'starts' | 'includes' | 'search', ids?: Array<scalar.Uuid>, OPT?: Option, REQ?: httpComponent.Req): void;
        /**
         * Builds pair
         * */
        _buildPair(doc: E, OPT?: Option, REQ?: httpComponent.Req): P;
        /**
         * Returns default pair
         * */
        defaultPair(OPT?: Option, REQ?: httpComponent.Req): P;
        /**
         * Lists pairs
         * */
        listPairsAsync(filter: F, OPT?: Option, REQ?: httpComponent.Req): Promise<Array<P>>;
        /**
         * Suggests pairs by keyword
         * */
        suggestPairsAsync(keyword: scalar.Unknown, filter: F, OPT?: Option, REQ?: httpComponent.Req): Promise<Array<P>>;
        /**
         * get pair by ref
         * */
        pairAsync(ref: scalar.Unknown, OPT?: Option, REQ?: httpComponent.Req): Promise<P>;
        /**
         * get pair array by ref array
         * */
        pairArrayAsync(refs: scalar.Unknown, OPT?: Option, REQ?: httpComponent.Req): Promise<Array<P>>;
    }
    interface GetOtherExt<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>, P extends pair.Core<T> = pair.Core<T>, F extends Filter = Filter> {
        /**
         * Formats document
         * */
        formatAsync(doc: E, OPT?: Option, REQ?: httpComponent.Req): Promise<E>;
        /**
         * Lists document array
         * */
        listAsync(filter: F, OPT?: Option, REQ?: httpComponent.Req): Promise<Array<E>>;
        /**
         * Returns raw document
         * */
        rawAsync(ref: scalar.Unknown, OPT?: Option, REQ?: httpComponent.Req): Promise<Wrapper<T, E>>;
    }
    interface ModifyExt<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>, P extends pair.Core<T> = pair.Core<T>, F extends Filter = Filter> {
        syncSize: scalar.Integer;
        optSyncSize(syncSize: scalar.Integer): Service<T, E, P, F>;
        /**
         * Creates a record
         * */
        createAsync(body: Partial<E>, OPT?: Option, REQ?: httpComponent.Req): Promise<E>;
        /**
         * Prepares a record for creation
         * */
        prepareAsync(OPT?: Option, REQ?: httpComponent.Req): Promise<E>;
        /**
         * Prepares an existing record for cloning/creation
         * */
        cloneAsync(ref: scalar.Unknown, OPT?: Option, REQ?: httpComponent.Req): Promise<E>;
        /**
         * Updates a record, full-update
         * */
        updateAsync(ref: scalar.Unknown, body: Partial<E>, OPT?: Option, REQ?: httpComponent.Req): Promise<E>;
        /**
         * Updates a record, partially-update
         * */
        setPartialAsync(ref: scalar.Unknown, body: Partial<E>, OPT?: Option, REQ?: httpComponent.Req): Promise<E>;
        /**
         * Syncs a record
         * */
        syncAsync(ref: scalar.Unknown, OPT?: Option, REQ?: httpComponent.Req): Promise<E>;
        /**
         * Syncs all records
         * */
        syncAllAsync(OPT?: Option, REQ?: httpComponent.Req): Promise<SyncAll>;
        /**
         * Deletes a record
         * */
        deleteAsync(ref: scalar.Unknown, OPT?: Option, REQ?: httpComponent.Req): Promise<E>;
        /**
         * General on update
         * */
        baseCheckAsync(existing: E, doc: E, OPT?: Option, REQ?: httpComponent.Req): Promise<void>;
    }
    interface CacheExt<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>, P extends pair.Core<T> = pair.Core<T>, F extends Filter = Filter> {
        cacheEnabled: scalar.Boolean;
        optCacheEnabled(cacheEnabled?: scalar.Boolean): Service<T, E, P, F>;
        cacheShared: scalar.Boolean;
        optCacheShared(cacheShared?: scalar.Boolean): Service<T, E, P, F>;
        _cacheHashId(id: string): string;
        _cacheHashCode(code: string): string;
        _cacheHashNum(num: number): string;
        _cacheGetAsync(REQ: httpComponent.Req, hash: string): Promise<E | null>;
        _cacheSetAsync(REQ: httpComponent.Req, doc: E, ...parts: Array<idTypeEnum.Id>): Promise<void>;
        _cacheDeleteAsync(REQ: httpComponent.Req, doc: E): Promise<void>;
        _cacheRefreshAsync(REQ: httpComponent.Req, doc: E): Promise<void>;
    }
    interface PropertyExt<T extends scalar.PossibleId = scalar.Alpha, E extends Doc<T> = Doc<T>, P extends pair.Core<T> = pair.Core<T>, F extends Filter = Filter> {
        orderDefault: scalar.Alpha;
        finalized: scalar.Boolean;
        numType: NumType;
        hiddenFields: Array<scalar.Alpha>;
        onlyReadFields: Array<scalar.Alpha>;
        transientFields: Array<scalar.Alpha>;
        insertableFields: Array<scalar.Alpha>;
        updatableFields: Array<scalar.Alpha>;
        optionalFields: Array<scalar.Alpha>;
        mergeableFields: Array<scalar.Alpha>;
        historyFields: Array<scalar.Alpha>;
        alphaFields: Array<scalar.Alpha>;
        alphaTargets: Array<scalar.Alpha>;
        i18nFields: Array<scalar.Alpha>;
        orderFields: Array<scalar.Alpha>;
        relationFields: Array<scalar.Alpha>;
        referenceFields: Array<scalar.Alpha>;
        searchFields: Array<scalar.Alpha>;
        properties: Map<string, Property>;
        hasProperty(name: string): scalar.Boolean;
        getProperty(name: string): Property;
        optProperty(name: string): Property;
        optNumType(numType: NumType): Service<T, E, P, F>;
        validate(): Service<T, E, P, F>;
    }
    interface Property {
        new (service: Service, name: string): Property;
        _service: Service;
        _name: string;
        _pathName: string;
        back(): Service;
        _hidden?: scalar.Boolean;
        hidden(hidden?: scalar.Boolean): Property;
        _onlyRead?: scalar.Boolean;
        onlyRead(onlyRead?: scalar.Boolean): Property;
        _mergeable?: scalar.Boolean;
        mergeable(mergeable?: scalar.Boolean): Property;
        _insertable?: scalar.Boolean;
        insertable(insertable?: scalar.Boolean): Property;
        _updatable?: scalar.Boolean;
        updatable(updatable?: scalar.Boolean): Property;
        _optional?: scalar.Boolean;
        optional(optional?: scalar.Boolean): Property;
        _transient?: scalar.Boolean;
        transient(transient?: scalar.Boolean): Property;
        _inHistory?: scalar.Boolean;
        inHistory(inHistory?: scalar.Boolean): Property;
        _alphaTarget?: scalar.String;
        alphaTarget(alphaTarget?: scalar.String): Property;
        _i18n?: scalar.Boolean;
        i18n(i18n?: scalar.Boolean): Property;
        _casting?: scalar.Alpha;
        casting(casting?: scalar.Alpha): Property;
        castingText(): Property;
        castingInt(): Property;
        castingUuid(): Property;
        castingBool(): Property;
        castingDatetime(): Property;
        castingFloat(): Property;
        _wrap?: wrapEnum.Id;
        wrap(wrap?: wrapEnum.Id): Property;
        wrapPlain(): Property;
        wrapArray(): Property;
        wrapMap(): Property;
        wrapCustom(): Property;
        _searchTarget?: searchTargetEnum.Id;
        searchTarget(searchTarget?: searchTargetEnum.Id): Property;
        searchAsId(): Property;
        searchAsWord(): Property;
        searchAsSentence(): Property;
        _relation?: Relation;
        relation(relation?: string | Relation): Property;
        _order?: Order;
        order(order?: Order): Property;
        orderAsc(): Property;
        orderDesc(): Property;
        _reference?: Reference;
        reference(reference?: Reference): Property;
        referenceStandard(): Property;
        _prepareValue: scalar.Unknown | scalar.AnyFunc;
        prepareValue(prepareValue?: scalar.Unknown | scalar.AnyFunc): Property;
        _read?: scalar.CastFn;
        _isSyncRead?: scalar.Boolean;
        _optRead?: scalar.AnyObject | CastOptFn;
        read(fn: scalar.CastFn, isSync?: scalar.Boolean, opt?: scalar.AnyObject | CastOptFn): Property;
        readDirect(fn: scalar.CastFn, opt?: scalar.AnyObject | CastOptFn): Property;
        readAwait(fn: scalar.CastFn, opt?: scalar.AnyObject | CastOptFn): Property;
        _format?: scalar.CastFn;
        _isSyncFormat?: scalar.Boolean;
        _optFormat?: scalar.AnyObject | CastOptFn;
        format(fn: scalar.CastFn, isSync?: scalar.Boolean, opt?: scalar.AnyObject | CastOptFn): Property;
        formatDirect(fn: scalar.CastFn, opt?: scalar.AnyObject | CastOptFn): Property;
        formatAwait(fn: scalar.CastFn, opt?: scalar.AnyObject | CastOptFn): Property;
    }
    interface Relation {
        name: scalar.Alpha;
    }
    interface Order {
        def?: scalar.Boolean;
        desc?: scalar.Boolean;
    }
    interface Reference {
        delimiter?: scalar.Alpha;
        iteration?: scalar.Integer;
        checkFn?: ReferenceCheckFn;
        convertFn?: ReferenceConvertFn;
    }
}