import type Jsonable from '../../Contracts/Jsonable';
import GuardsAttributes from './GuardsAttributes';
import type Model from '../Model';
import type ModelCollection from '../ModelCollection';
import type { KeysNotMatching, MaybeArray, UnionToIntersection } from '../../Support/type';
type InternalProperties = 'attributeCasing' | 'attributeCasts' | 'attributes' | 'casts' | 'endpoint' | 'exists' | 'fillable' | 'fillableAttributes' | 'guarded' | 'guardedAttributes' | 'hasOneOrManyParentKeyName' | 'loading' | 'mutatedEndpoint' | 'original' | 'primaryKey' | 'relationMethodPrefix' | 'relations' | 'requestCount' | 'serverAttributeCasing';
/**
 * All keys of the model except where the value is a method,
 * or it's a property defined internally.
 *
 * Results in a union of keys.
 */
export type AttributeKeys<T, Ex = CallableFunction> = Exclude<KeysNotMatching<T, Ex>, InternalProperties> | string;
/**
 * All keys of the model except where the value is a method,
 * a relation, or it's a property defined internally.
 *
 * Results in a union of keys.
 */
export type SimpleAttributeKeys<T extends HasAttributes = HasAttributes> = AttributeKeys<T, CallableFunction | Model | ModelCollection<Model> | undefined>;
/**
 * The attributes the model is handling.
 */
export type Attributes<T extends HasAttributes = HasAttributes> = {
    [K in AttributeKeys<T>]: T[K];
};
/**
 * The attributes the model is handling except relation values.
 */
export type SimpleAttributes<T extends HasAttributes = HasAttributes> = {
    [K in SimpleAttributeKeys<T>]: T[K] extends Model | ModelCollection<Model> ? never : T[K];
};
/**
 * Unwrap the model attributes recursively into attributes or array of attributes.
 */
export type RawAttributes<T extends HasAttributes> = {
    [K in AttributeKeys<T>]: T[K] extends Model ? RawAttributes<T[K]> : T[K] extends ModelCollection<infer M> ? RawAttributes<M>[] : T[K];
};
type FilterGetters<T> = {
    [K in keyof T as Extract<K, `get${string}Attribute`>]: T[K] extends (...args: any) => any ? T[K] : never;
};
type TransformGetters<T extends Record<`get${string}Attribute`, (...args: any) => any>> = {
    [K in keyof T]: Record<K extends `get${infer P}Attribute` ? Uncapitalize<P> : never, T[K] extends (...args: any) => infer R ? R : never>;
};
/**
 * Intersect the type with the names of the accessors and their return types.
 *
 * This type is experimental and may change.
 * @experimental
 */
export type Getters<T> = Omit<UnionToIntersection<TransformGetters<FilterGetters<T>>[keyof TransformGetters<FilterGetters<T>>]>, ''> & T;
export default class HasAttributes extends GuardsAttributes implements Jsonable, Iterable<any> {
    /**
     * The model attribute.
     */
    [key: string]: unknown;
    /**
     * Property indicating how attributes and relation names should be cast by default.
     *
     * @type {'snake'|'camel'}
     *
     * @readonly
     */
    protected get attributeCasing(): 'camel' | 'snake';
    /**
     * Property indicating how attributes and relation names
     * should be cast by default when sent to the server.
     *
     * @type {'snake'|'camel'}
     *
     * @protected
     */
    protected get serverAttributeCasing(): 'camel' | 'snake';
    /**
     * The attributes.
     *
     * @protected
     *
     * @type {object}
     */
    protected attributes: SimpleAttributes;
    /**
     * The attribute's original state.
     *
     * @protected
     *
     * @type {object}
     */
    protected original: SimpleAttributes;
    /**
     * The iterator used for looping over the attributes and relations.
     *
     * @type {Symbol.iterator}
     */
    [Symbol.iterator](): Iterator<any>;
    /**
     * Utility to cast the given string to the attributeCasing's case.
     *
     * @param {string} key
     *
     * @see attributeCasing
     *
     * @protected
     *
     * @return {string}
     */
    protected setStringCase(key: AttributeKeys<this> | string): string;
    /**
     * Utility to cast the given string to the serverAttributeCasing's case.
     *
     * @param {string} key
     *
     * @see serverAttributeCasing
     *
     * @protected
     *
     * @return {string}
     */
    protected setServerStringCase(key: AttributeKeys<this> | string): string;
    /**
     * Get an attribute from the model.
     *
     * @param {string} key
     * @param {any=} defaultValue
     *
     * @return {any}
     */
    getAttribute<K extends AttributeKeys<this> | string, T extends this[K]>(key: K, defaultValue: T): T;
    getAttribute<K extends AttributeKeys<this> | string, T extends this[K]>(key: K, defaultValue?: T): T | undefined;
    /**
     * Get all the attributes on the model.
     *
     * @return {object}
     */
    getAttributes(): SimpleAttributes<this>;
    /**
     * Get all the attributes on the model without casting or accessors.
     *
     * @return {object}
     */
    getRawAttributes(): SimpleAttributes<this>;
    /**
     * Get available attribute keys.
     *
     * @return {string[]}
     */
    getAttributeKeys(): string[];
    /**
     * Set a given attribute on the model.
     *
     * @param {string} key
     * @param {any} value
     *
     * @return {this}
     */
    setAttribute<K extends AttributeKeys<this>, T extends this[K]>(key: K, value: T): this;
    setAttribute<K extends string, T>(key: K, value: T): this;
    setAttribute<K extends AttributeKeys<this> | string, T extends K extends AttributeKeys<this> ? this[K] : unknown = K extends AttributeKeys<this> ? this[K] : unknown>(key: K, value: T): this;
    /**
     * Create simple access for the getters and setters that have no underlying attribute set.
     *
     * Should only be called after the attributes have already been set.
     */
    protected setupMagicAccess(this: this): void;
    /**
     * Create descriptors for the given key(s) therefore allowing magic access.
     *
     * @param {string|string[]} keys
     *
     * @return {this}
     */
    protected createDescriptor(keys: MaybeArray<AttributeKeys<this> | string>): this;
    /**
     * Remove the attribute and its magic access if set.
     *
     * @param {string} key
     *
     * @return {this}
     */
    deleteAttribute(key: AttributeKeys<this> | string): this;
    /**
     * Determine if a set mutator exists for an attribute.
     *
     * @param {string} key
     *
     * @return {boolean}
     */
    protected hasSetMutator(key: AttributeKeys<this> | string): boolean;
    /**
     * Determine if a get accessor exists for an attribute.
     *
     * @param {string} key
     *
     * @return {boolean}
     */
    protected hasGetAccessor(key: AttributeKeys<this> | string): boolean;
    /**
     * Fill the model with the given attributes while respecting the guarding settings.
     *
     * @param {object} attributes
     *
     * @return {this}
     */
    fill(attributes: Attributes | Attributes<this>): this;
    /**
     * Fill the model with the given attributes without respecting the guarding settings.
     *
     * @param {object} attributes
     *
     * @return {this}
     */
    forceFill(attributes: Attributes | Attributes<this>): this;
    /**
     * Sync the original attributes with the current.
     *
     * @param {string=} keys
     *
     * @return {this}
     */
    syncOriginal(keys?: MaybeArray<SimpleAttributeKeys<this> | string>): this;
    /**
     * Reset the attributes to the original values.
     *
     * @return {this}
     */
    reset(): this;
    /**
     * Get the original attributes.
     *
     * @param {string} key
     * @param {any} defaultValue
     *
     * @return {any}
     */
    getOriginal<K extends SimpleAttributeKeys<this> | string, T extends this[K]>(key: K, defaultValue?: T): T;
    getOriginal(): SimpleAttributes<this>;
    /**
     * Get the original attributes without casting.
     *
     * @param {string=} key
     * @param {any=} defaultValue
     *
     * @return {any}
     */
    getRawOriginal<K extends SimpleAttributeKeys<this> | string, T extends this[K]>(key: K, defaultValue?: T): T;
    getRawOriginal(): SimpleAttributes<this>;
    /**
     * Get the attributes that were changed.
     *
     * @param {string=} key
     *
     * @return {object}
     */
    getChanges<K extends SimpleAttributeKeys<this>>(key: K): Record<K, this[K] | undefined>;
    getChanges(key?: string): Partial<SimpleAttributes<this>>;
    /**
     * Get the deleted attributes if any.
     *
     * @param {string=} key
     *
     * @return {object}
     */
    getDeletedAttributes<K extends SimpleAttributeKeys<this>>(key: K): Record<K, this[K] | undefined>;
    getDeletedAttributes(key?: string): Partial<SimpleAttributes<this>>;
    /**
     * Get the new attributes if any.
     *
     * @param {string=} key
     *
     * @return {object}
     */
    getNewAttributes<K extends SimpleAttributeKeys<this>>(key: K): Record<K, this[K] | undefined>;
    getNewAttributes(key?: string): Partial<SimpleAttributes<this>>;
    /**
     * Determine whether the given attribute has changed
     * or attributes has been added or deleted.
     *
     * @param {key|undefined} key
     *
     * @return {boolean}
     */
    hasChanges(key?: SimpleAttributeKeys<this> | string): boolean;
    /**
     * Alias for the hasChanges method.
     *
     * @see hasChanges
     *
     * @param {string|undefined} key
     *
     * @return {boolean}
     */
    isDirty(key?: SimpleAttributeKeys<this> | string): boolean;
    /**
     * Determine whether given or any attributes was changed.
     *
     * @param {string|undefined} key
     */
    isClean(key?: SimpleAttributeKeys<this> | string): boolean;
    /**
     * Get a subset of the model's attributes.
     *
     * @param {string|string[]} attributes
     *
     * @return {object}
     */
    only<K extends SimpleAttributeKeys<this>[], R = {
        [P in K[number]]?: SimpleAttributes<this>[P];
    }>(attributes: K): R;
    only<K extends SimpleAttributeKeys<this>, R = Record<K, this[K]>>(attributes: K): R;
    /**
     * Get all model attributes except the given keys.
     *
     * @param {string|string[]} attributes
     *
     * @return {object}
     */
    except<K extends SimpleAttributeKeys<this>[], R = Omit<SimpleAttributes<this>, K[number]>>(attributes: K): R;
    except<K extends SimpleAttributeKeys<this> | string, R = Omit<SimpleAttributes<this>, K>>(attributes: K): R;
    /**
     * @inheritDoc
     */
    toJSON<T extends ReturnType<typeof JSON.parse> = RawAttributes<this>>(): T;
    /**
     * Show the model in a human-readable string representation.
     *
     * @return {string}
     */
    toString(): string;
}
export {};
//# sourceMappingURL=HasAttributes.d.ts.map