import { EntityConstructor, EntityInterface } from './Entity.types.js';
export type NymphOptions = {
    /**
     * The URL of your Nymph REST server.
     */
    restUrl: string;
    /**
     * The URL of your Nymph PubSub server.
     */
    pubsubUrl?: string;
    /**
     * A fetch implementation.
     */
    fetch?: WindowOrWorkerGlobalScope['fetch'];
    /**
     * A WebSocket implementation.
     */
    WebSocket?: typeof WebSocket;
    /**
     * Return `null` or empty array instead of error when entity/ies not found.
     */
    returnNullOnNotFound?: boolean;
    /**
     * Whether to not output status messages to the console.
     */
    noConsole?: boolean;
    /**
     * Don't automatically try to connect to PubSub server.
     */
    noAutoconnect?: boolean;
    /**
     * Use a WeakRef based cache of entities.
     *
     * This ensures all entities returned are the same instance if they have the
     * same class and GUID. This also means that whenever an entity is returned
     * from the server, the single instance in memory will be refreshed. This
     * could have annoying results, like destroying dirty data (the dreaded
     * triple-D).
     *
     * This could also be a potential source of memory leaks. Although the
     * entities themselves are referenced weakly so they get garbage collected,
     * the GUID used as a key and the WeakRef object itself are not weak
     * references, so not destroyed when the instance is garbage collected.
     *
     * However, even with these caveats, this might help you if you have a big app
     * with the same entities stored in several different places in memory. This
     * can help to synchronize them correctly and avoid data conflicts.
     */
    weakCache?: boolean;
    /**
     * Whether to renew tokens when a request is made.
     *
     * If you turn this off, the client will request that the server not renew an
     * authentication token, even if it is within the renewal time of the
     * expiration date.
     *
     * This defaults to true.
     */
    renewTokens?: boolean;
};
export type EventType = 'request' | 'response';
export type RequestCallback = (url: string, options: RequestInit) => void;
export type ResponseCallback = (response: Response, text: string) => void;
export type Options<T extends EntityConstructor = EntityConstructor> = {
    /**
     * The Entity class to query.
     */
    class: T;
    /**
     * The limit of entities to be returned. Not needed when using `getEntity`, as
     * it always returns only one.
     */
    limit?: number;
    /**
     * The offset from the first matching entity, in order, to start retrieving.
     */
    offset?: number;
    /**
     * If true, entities will be retrieved from newest to oldest/largest to
     * smallest (with regard to `sort`).
     */
    reverse?: boolean;
    /**
     * How to sort the entities. Should be "cdate", "mdate", the name of a
     * property, or null.
     */
    sort?: 'cdate' | 'mdate' | string | null;
    /**
     * What to return, the entities with their data, just the GUIDs, or just a
     * count.
     */
    return?: 'entity' | 'guid' | 'count';
    /**
     * If true, Nymph will skip the cache and retrieve the entity from the DB.
     */
    skipCache?: boolean;
    /**
     * The level(s) of access control requested.
     *
     * Limiting the access control can significantly improve the performance of
     * the query.
     */
    acRequest?: TilmeldAccessRequest;
};
export type Clause<C> = C | Exclude<C, undefined>[];
export type OrWithTime<T> = T | [string, null, string];
type PrimitiveSelector = {
    guid?: string;
    '!guid'?: PrimitiveSelector['guid'];
    tag?: string;
    '!tag'?: PrimitiveSelector['tag'];
    defined?: string;
    '!defined'?: PrimitiveSelector['defined'];
    truthy?: string;
    '!truthy'?: PrimitiveSelector['truthy'];
    equal?: [string, any];
    '!equal'?: PrimitiveSelector['equal'];
    contain?: [string, any];
    '!contain'?: PrimitiveSelector['contain'];
    search?: [string, string];
    '!search'?: PrimitiveSelector['search'];
    match?: [string, string];
    '!match'?: PrimitiveSelector['match'];
    imatch?: [string, string];
    '!imatch'?: PrimitiveSelector['imatch'];
    like?: [string, string];
    '!like'?: PrimitiveSelector['like'];
    ilike?: [string, string];
    '!ilike'?: PrimitiveSelector['ilike'];
    gt?: [string, number];
    '!gt'?: PrimitiveSelector['gt'];
    gte?: [string, number];
    '!gte'?: PrimitiveSelector['gte'];
    lt?: [string, number];
    '!lt'?: PrimitiveSelector['lt'];
    lte?: [string, number];
    '!lte'?: PrimitiveSelector['lte'];
    ref?: [string, EntityInterface | string];
    '!ref'?: PrimitiveSelector['ref'];
    qref?: [string, [Options, ...PrimitiveSelector[]]];
    '!qref'?: PrimitiveSelector['qref'];
    selector?: PrimitiveSelector;
    '!selector'?: PrimitiveSelector['selector'];
};
export type Selector = {
    type: '&' | '|' | '!&' | '!|';
    guid?: Clause<PrimitiveSelector['guid']>;
    '!guid'?: Clause<PrimitiveSelector['guid']>;
    tag?: Clause<PrimitiveSelector['tag']>;
    '!tag'?: Clause<PrimitiveSelector['tag']>;
    defined?: Clause<PrimitiveSelector['defined']>;
    '!defined'?: Clause<PrimitiveSelector['defined']>;
    truthy?: Clause<PrimitiveSelector['truthy']>;
    '!truthy'?: Clause<PrimitiveSelector['truthy']>;
    equal?: Clause<OrWithTime<PrimitiveSelector['equal']>>;
    '!equal'?: Clause<OrWithTime<PrimitiveSelector['equal']>>;
    contain?: Clause<OrWithTime<PrimitiveSelector['contain']>>;
    '!contain'?: Clause<OrWithTime<PrimitiveSelector['contain']>>;
    search?: Clause<PrimitiveSelector['search']>;
    '!search'?: Clause<PrimitiveSelector['search']>;
    match?: Clause<PrimitiveSelector['match']>;
    '!match'?: Clause<PrimitiveSelector['match']>;
    imatch?: Clause<PrimitiveSelector['imatch']>;
    '!imatch'?: Clause<PrimitiveSelector['imatch']>;
    like?: Clause<PrimitiveSelector['like']>;
    '!like'?: Clause<PrimitiveSelector['like']>;
    ilike?: Clause<PrimitiveSelector['ilike']>;
    '!ilike'?: Clause<PrimitiveSelector['ilike']>;
    gt?: Clause<OrWithTime<PrimitiveSelector['gt']>>;
    '!gt'?: Clause<OrWithTime<PrimitiveSelector['gt']>>;
    gte?: Clause<OrWithTime<PrimitiveSelector['gte']>>;
    '!gte'?: Clause<OrWithTime<PrimitiveSelector['gte']>>;
    lt?: Clause<OrWithTime<PrimitiveSelector['lt']>>;
    '!lt'?: Clause<OrWithTime<PrimitiveSelector['lt']>>;
    lte?: Clause<OrWithTime<PrimitiveSelector['lte']>>;
    '!lte'?: Clause<OrWithTime<PrimitiveSelector['lte']>>;
    ref?: Clause<PrimitiveSelector['ref']>;
    '!ref'?: Clause<PrimitiveSelector['ref']>;
    qref?: Clause<[string, [Options, ...Selector[]]]>;
    '!qref'?: Selector['qref'];
    selector?: Clause<Selector>;
    '!selector'?: Selector['selector'];
};
export declare enum TilmeldAccessRequest {
    /**
     * The default level, any possible entity readable by the user.
     *
     * This is the same as or-ing together all of the levels listed below.
     */
    ALL_LEVELS = 0,
    /**
     * Owned by and accessible to the user.
     *
     * This is always enabled, so not including it has no effect. It's here to
     * allow the selection of _only_ user owned entities.
     */
    USER_OWNED = 1,
    /**
     * Owned by and accessible to the user's primary group.
     */
    PRIMARY_GROUP_OWNED = 2,
    /**
     * Owned by and accessible to one of the user's secondary groups.
     */
    SECONDARY_GROUP_OWNED = 4,
    /**
     * The user is listed in an access control list.
     */
    USER_ACCESSIBLE = 8,
    /**
     * The user's primary group is listed in an access control list.
     */
    PRIMARY_GROUP_ACCESSIBLE = 16,
    /**
     * One of the user's secondary groups is listed in an access control list.
     */
    SECONDARY_GROUP_ACCESSIBLE = 32,
    /**
     * The entity is accessible to any user.
     */
    OTHER_ACCESSIBLE = 64,
    /**
     * The entity is not owned by anyone.
     */
    UNOWNED = 128
}
export {};