export declare type AttrValue = any;
export declare type AttrName = string;
export declare type AttrConfig = WritableAttrConfig<any> | CallableAttrConfig<any>;
export declare type AttrConfigSet = Record<AttrName, AttrConfig>;
export declare type AttrSet = Record<AttrName, AttrValue>;
export interface BaseAttrConfig {
    hidden?: boolean;
}
export interface WritableAttrConfig<V extends AttrValue> extends BaseAttrConfig {
    normalizer?: NormalizerFn<V>;
    immutable?: boolean;
    sanitizer: SanitizerFn<V>;
    validator?: ValidatorFn<V>;
    value: V;
    fn?: never;
}
export interface CallableAttrConfig<V extends AttrValue> extends BaseAttrConfig {
    fn: Fn<V>;
    value?: never;
}
export declare type Fn<V> = () => V;
export declare type SanitizerFn<V> = (value: unknown, name: AttrName) => V;
export declare type NormalizerFn<V> = (value: NonNullable<V>, name: AttrName) => V;
export declare type ValidatorFn<V> = (value: NonNullable<V>, name: AttrName) => boolean;
declare type AsAttrName<T> = T extends AttrName ? T : never;
export declare type ResolveAttrName<ACS extends AttrConfigSet> = AsAttrName<keyof ACS>;
export declare type ResolveAttrSet<ACS extends AttrConfigSet> = {
    [K in keyof ACS]: ACS[K] extends CallableAttrConfig<any> ? ReturnType<ACS[K]['fn']> : ACS[K] extends WritableAttrConfig<any> ? ACS[K]['value'] : never;
};
export declare type ResolveCallableAttrName<ACS extends AttrConfigSet> = AsAttrName<{
    [K in keyof ACS]: ACS[K] extends CallableAttrConfig<any> ? K : never;
}[keyof ACS]>;
export declare type ResolveCallableAttrConfigSet<ACS extends AttrConfigSet> = Pick<ACS, ResolveCallableAttrName<ACS>>;
export declare type ResolveCallableAttrSet<ACS extends AttrConfigSet> = ResolveAttrSet<ResolveCallableAttrConfigSet<ACS>>;
export declare type ResolveWritableAttrName<ACS extends AttrConfigSet> = AsAttrName<{
    [K in keyof ACS]: ACS[K] extends WritableAttrConfig<any> ? K : never;
}[keyof ACS]>;
export declare type ResolveWritableAttrConfigSet<ACS extends AttrConfigSet> = Pick<ACS, ResolveWritableAttrName<ACS>>;
export declare type ResolveWritableAttrSet<ACS extends AttrConfigSet> = ResolveAttrSet<ResolveWritableAttrConfigSet<ACS>>;
export declare type ResolveHiddenAttrName<ACS extends AttrConfigSet> = AsAttrName<{
    [K in keyof ACS]: ACS[K]['hidden'] extends true ? K : never;
}[keyof ACS]>;
export declare type ResolveHiddenAttrConfigSet<ACS extends AttrConfigSet> = Pick<ACS, ResolveHiddenAttrName<ACS>>;
export declare type ResolveHiddenAttrSet<ACS extends AttrConfigSet> = ResolveAttrSet<ResolveHiddenAttrConfigSet<ACS>>;
export declare type ResolveVisibleAttrName<ACS extends AttrConfigSet> = AsAttrName<Exclude<keyof ACS, ResolveHiddenAttrName<ACS>>>;
export declare type ResolveVisibleAttrConfigSet<ACS extends AttrConfigSet> = Pick<ACS, ResolveVisibleAttrName<ACS>>;
export declare type ResolveVisibleAttrSet<ACS extends AttrConfigSet> = ResolveAttrSet<ResolveVisibleAttrConfigSet<ACS>>;
export declare type ResolveImmutableAttrName<ACS extends AttrConfigSet> = AsAttrName<{
    [K in keyof ACS]: ACS[K] extends WritableAttrConfig<any> ? ACS[K]['immutable'] extends true ? K : never : never;
}[keyof ACS]>;
export declare type ResolveImmutableAttrConfigSet<ACS extends AttrConfigSet> = Pick<ACS, ResolveImmutableAttrName<ACS>>;
export declare type ResolveImmutableAttrSet<ACS extends AttrConfigSet> = ResolveAttrSet<ResolveImmutableAttrConfigSet<ACS>>;
export declare type ResolveMutableAttrName<ACS extends AttrConfigSet> = AsAttrName<Exclude<ResolveWritableAttrName<ACS>, ResolveImmutableAttrName<ACS>>>;
export declare type ResolveMutableAttrConfigSet<ACS extends AttrConfigSet> = Pick<ACS, ResolveMutableAttrName<ACS>>;
export declare type ResolveMutableAttrSet<ACS extends AttrConfigSet> = ResolveAttrSet<ResolveMutableAttrConfigSet<ACS>>;
export declare type ResolveConstructorData<ACS extends AttrConfigSet> = Partial<ResolveWritableAttrSet<ACS>> | Entity<ACS> | string;
export declare type ResolveFillData<ACS extends AttrConfigSet> = Partial<ResolveMutableAttrSet<ACS>> | Entity<ACS> | string;
declare const EmptyObject: {};
export declare class Entity<ACS extends AttrConfigSet = typeof EmptyObject> {
    #private;
    /**
     * Creates a new [[`Entity`]] instance. The `attrConfigSet` defines the attributes available on
     * the [[`Entity`]] instance. Values defined in `attrConfigSet` are trusted and therefore not
     * sanitized, normalized nor validated. Data provided via `data` must be compatible with the data
     * expected by [[`Entity.fill()`]] but, unlike [[`Entity.fill()`]], may also include values for
     * immutable attributes.
     *
     * @param attrConfigSet
     * @param data
     */
    constructor(attrConfigSet: ACS, data?: ResolveConstructorData<ACS>);
    /**
     * Returns the value of the attribute provided in `name`.
     *
     * @param name
     */
    one<K extends ResolveAttrName<ACS>>(name: K): ResolveAttrSet<ACS>[K];
    /**
     * Returns an attribute set of the attributes provided in `names`.
     *
     * @param names
     */
    many<N extends ResolveAttrName<ACS>[]>(names: N): Pick<ResolveAttrSet<ACS>, typeof names[number]>;
    /**
     * Returns an attribute set of all attributes.
     */
    all(): ResolveAttrSet<ACS>;
    /**
     * Returns an attribute set of all callable (non-writable) attributes.
     */
    callable(): ResolveCallableAttrSet<ACS>;
    /**
     * Returns an attribute set an all writable (non-callable) attributes.
     */
    writable(): ResolveWritableAttrSet<ACS>;
    /**
     * Returns an attribute set of all attributes that have been configured as `immutable`.
     */
    immutable(): ResolveImmutableAttrSet<ACS>;
    /**
     * Returns an attribute set of all attributes that have not been configured as `immutable`.
     */
    mutable(): ResolveMutableAttrSet<ACS>;
    /**
     * Returns an attribute set of all attributes that have been configured as `hidden`.
     */
    hidden(): ResolveHiddenAttrSet<ACS>;
    /**
     * Returns an attribute set of all attributes that have not been configured as `hidden`.
     */
    visible(): ResolveVisibleAttrSet<ACS>;
    /**
     * Returns an attribute set of all attributes that have been modified since instantiation or the
     * last call to [[`Entity.clearModified()`]].
     */
    modified(): Partial<ResolveMutableAttrSet<ACS>>;
    /**
     * Sets the `value` for the attribute `name`. Values can only be set for mutable, writable
     * attributes. The value will be sanitized, normalized and validated.
     *
     * @param name
     * @param value
     */
    set<K extends ResolveMutableAttrName<ACS>>(name: K, value: ResolveMutableAttrSet<ACS>[K]): this;
    /**
     * Sets multiple attribute values using the provided `data`. The incoming data is parsed into an
     * attribute set using [[`Entity.parseData()`]], before being sanitized, normalized and validated.
     *
     * @param data
     */
    fill(data: ResolveFillData<ACS>): this;
    /**
     * Clears the modified attribute state. Typically used after calling an update/save endpoint to
     * signify that the instance is in sync with the upstream datasource.
     */
    clearModified(): this;
    /**
     * Sanitizes a `value` using the configured `sanitizer` function for the attribute `name`. The
     * function will have `this` scoped to the [[`Entity`]] instance.
     *
     * @param name
     * @param value
     */
    sanitize<K extends ResolveWritableAttrName<ACS>>(name: K, value: unknown): ResolveWritableAttrSet<ACS>[K];
    /**
     * Normalizes a `value` using the configured `normalizer` function for the attribute `name`. If
     * the attribute does not have a normalizer function configured then that value is returned as-is.
     * The function will have `this` scoped to the [[`Entity`]] instance.
     *
     * @param name
     * @param value
     */
    normalize<K extends ResolveWritableAttrName<ACS>, V extends ResolveWritableAttrSet<ACS>[K]>(name: K, value: V): V;
    /**
     * Validates a `value` using the configured `validator` function for the attribute `name`. If
     * the attribute does not have a validator function configured then that value is assumed valid.
     * The function will have `this` scoped to the [[`Entity`]] instance.
     *
     * @param name
     * @param value
     */
    validate<K extends ResolveWritableAttrName<ACS>>(name: K, value: ResolveWritableAttrSet<ACS>[K]): boolean;
    /**
     * Attempts to parse incoming data which may be an attribute set, an [[`Entity`]] instance or a
     * JSON string.
     *
     * @param data
     */
    parseData(data: unknown): AttrSet;
    /**
     * Stringifies the instance to JSON.
     */
    toString(): string;
    /**
     * Returns the data to expose when stringifying the instance to JSON.
     */
    toJSON(): ResolveVisibleAttrSet<ACS>;
}
export {};