import { O } from 'ts-toolbelt';

declare const wrapValues: (obj: Record<string, unknown>) => Record<string, unknown>;
declare const wrap: (obj: unknown) => unknown;
declare class Expression<T = unknown> {
    private raw;
    private static _isFaunaExpression;
    constructor(raw: T);
    private toJSON;
}

declare type SchemaTypes = {
    AccessProviders?: string[];
    Collections?: Record<string, unknown>;
    Databases?: string[];
    Functions?: Record<string, unknown>;
    Indexes?: string[];
    Roles?: string[];
};
declare type OrExpression<TValue = unknown> = Expression | TValue;
declare type Normalizer = 'NFKCCaseFold' | 'NFC' | 'NFD' | 'NFKC' | 'NFKD';
declare type CreateParams<TData extends unknown> = {
    data?: OrExpression<TData>;
    credentials?: OrExpression<{
        password: string;
    } & Record<string, unknown>>;
    ttl?: Expression;
};
declare type CreateAccessProviderParams<TAccessProviderName extends string> = {
    name: OrExpression<TAccessProviderName>;
    issuer: OrExpression<string>;
    jwks_uri: OrExpression<string>;
    roles?: Expression[] | {
        role: Expression;
        predicate: Expression;
    }[];
    data?: OrExpression<Record<string, unknown>>;
};
declare type CreateCollectionParams<TSchema extends SchemaTypes, TCollectionName extends keyof TSchema['Collections']> = {
    name: OrExpression<TCollectionName>;
    data?: OrExpression<Record<string, unknown>>;
    history_days?: OrExpression<number | null>;
    ttl_days?: OrExpression<number | null>;
};
declare type CreateDatabaseParams<TDatabaseName extends string> = {
    name: OrExpression<TDatabaseName>;
    data?: OrExpression<Record<string, unknown>>;
};
declare type BuiltInRole = 'admin' | 'server' | 'server-readonly' | 'client';
declare type CreateFunctionParams<TFunctionName extends string> = {
    name: OrExpression<TFunctionName>;
    body: Expression;
    data?: OrExpression<Record<string, unknown>>;
    role?: BuiltInRole | Expression;
};
declare type CreateKeyParams = {
    role: BuiltInRole | Expression | Expression[];
    database?: Expression;
    data?: OrExpression<{
        name?: string;
    } & Record<string, unknown>>;
};
declare type SourceObject = {
    collection: Expression;
    fields: OrExpression<Record<string, Expression>>;
};
declare type TermObject = {
    field?: OrExpression<string | string[]>;
    binding?: OrExpression<string>;
};
declare type ValueObject = {
    field?: OrExpression<string | string[]>;
    binding?: OrExpression<string>;
    reverse?: OrExpression<boolean>;
};
declare type EpochUnit = 'day' | 'days' | 'half day' | 'half days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds' | 'microsecond' | 'microseconds' | 'nanosecond' | 'nanoseconds';
declare type CreateIndexParams<TIndexName extends string> = {
    name: OrExpression<TIndexName>;
    source: OrExpression<SourceObject>;
    terms?: OrExpression<TermObject[]>;
    values?: OrExpression<ValueObject[]>;
    unique?: OrExpression<boolean>;
    serialized?: OrExpression<boolean>;
    data?: OrExpression<Record<string, unknown>>;
};
declare type PrivilegeActions = {
    create: boolean | Expression;
    delete: boolean | Expression;
    read: boolean | Expression;
    write: boolean | Expression;
    history_read: boolean | Expression;
    history_write: boolean | Expression;
    unrestricted_read: boolean | Expression;
    call: boolean | Expression;
};
declare type PrivilegeConfigurationObject = {
    resource: Expression;
    actions: OrExpression<O.AtLeast<PrivilegeActions>>;
};
declare type MembershipConfigurationObject = {
    resource: Expression;
    predicate?: Expression;
};
declare type CreateRoleParams<TRoleName extends string> = {
    name: OrExpression<TRoleName>;
    privileges: OrExpression<PrivilegeConfigurationObject[]>;
    membership?: OrExpression<MembershipConfigurationObject[]>;
    data?: OrExpression<Record<string, unknown>>;
};
declare type InsertParams = {
    data: OrExpression<Record<string, unknown>>;
    credentials: OrExpression<Record<string, unknown>>;
    delegates: OrExpression<Record<string, unknown>>;
};
declare type LoginParams = {
    data?: OrExpression<Record<string, unknown>>;
    password: OrExpression<string>;
    ttl?: Expression;
};
declare type PaginateParams = {
    ts?: OrExpression<number>;
    before?: Expression[];
    after?: Expression[];
    size?: OrExpression<number>;
    events?: OrExpression<boolean>;
    sources?: OrExpression<boolean>;
};
declare type ReplaceParams = {
    data: OrExpression<Record<string, unknown>>;
};
declare type UpdateParams = {
    data: OrExpression<Record<string, unknown>>;
    credentials: OrExpression<Record<string, unknown>>;
    delegates: OrExpression<Record<string, unknown>>;
    ttl?: Expression;
};
declare class QueryBuilder<TSchema extends SchemaTypes = SchemaTypes> {
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/abort
     */
    Abort: (message: OrExpression<string>) => Expression<{
        abort: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/abs
     */
    Abs: (value: OrExpression<number>) => Expression<{
        abs: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/accessprovider
     */
    AccessProvider: <TAccessProviderName extends TSchema["AccessProviders"] extends string[] ? TSchema["AccessProviders"][number] : string = TSchema["AccessProviders"] extends string[] ? TSchema["AccessProviders"][number] : string>(name: OrExpression<TAccessProviderName>) => Expression<{
        access_provider: OrExpression<TAccessProviderName>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/accessproviders
     */
    AccessProviders: (database?: Expression<unknown> | undefined) => Expression<{
        access_providers: null;
    }> | Expression<{
        access_providers: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/acos
     */
    Acos: (value: OrExpression<number>) => Expression<{
        acos: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/add
     */
    Add: (...values: OrExpression<number>[]) => Expression<{
        add: OrExpression<number>;
    }> | Expression<{
        add: OrExpression<number>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/all
     */
    All: (...values: OrExpression<number>[]) => Expression<{
        all: OrExpression<number>;
    }> | Expression<{
        all: OrExpression<number>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/and
     */
    And: (...values: OrExpression<boolean>[]) => Expression<{
        and: OrExpression<boolean>;
    }> | Expression<{
        and: OrExpression<boolean>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/any
     */
    Any: (...values: OrExpression<boolean>[]) => Expression<{
        any: OrExpression<boolean>;
    }> | Expression<{
        any: OrExpression<boolean>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/append
     */
    Append: (base: unknown[] | Expression, elems: unknown[] | Expression) => Expression<{
        append: unknown;
        collection: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/asin
     */
    Asin: (value: OrExpression<number>) => Expression<{
        asin: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/at
     */
    At: (timestamp: Expression, expression: unknown) => Expression<{
        at: Expression<unknown>;
        expr: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/atan
     */
    Atan: (value: OrExpression<number>) => Expression<{
        atan: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/bitand
     */
    BitAnd: (...values: OrExpression<number>[]) => Expression<{
        bitand: OrExpression<number>;
    }> | Expression<{
        bitand: OrExpression<number>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/bitnot
     */
    BitNot: (value: OrExpression<number>) => Expression<{
        bitnot: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/bitor
     */
    BitOr: (...values: OrExpression<number>[]) => Expression<{
        bitor: OrExpression<number>;
    }> | Expression<{
        bitor: OrExpression<number>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/bitxor
     */
    BitXor: (...values: OrExpression<number>[]) => Expression<{
        bitxor: OrExpression<number>;
    }> | Expression<{
        bitxor: OrExpression<number>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/call
     */
    Call: <TFunctionName extends keyof TSchema["Functions"] = keyof TSchema["Functions"], TArgs extends TSchema["Functions"][TFunctionName] = TSchema["Functions"][TFunctionName]>(fn: OrExpression<TFunctionName>, args: OrExpression<TArgs>) => Expression<{
        call: OrExpression<TFunctionName>;
        arguments: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/casefold
     */
    Casefold: (value: OrExpression<string>, normalizer?: OrExpression<Normalizer> | undefined) => Expression<{
        casefold: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/ceil
     */
    Ceil: (value: OrExpression<number>) => Expression<{
        ceil: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/collection
     */
    Collection: <TCollectionName extends keyof TSchema["Collections"] = keyof TSchema["Collections"]>(name: OrExpression<TCollectionName>, database?: Expression<unknown> | undefined) => Expression<{
        collection: OrExpression<TCollectionName>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/collections
     */
    Collections: (database?: Expression<unknown> | undefined) => Expression<{
        collections: Expression<unknown>;
    }> | Expression<{
        collections: null;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/concat
     */
    Concat: (value: OrExpression<string>[], separator?: string | Expression<unknown> | undefined) => Expression<{
        concat: OrExpression<string>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/containsfield
     */
    ContainsField: (field: OrExpression<string>, value: unknown) => Expression<{
        contains_field: OrExpression<string>;
        in: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/containspath
     */
    ContainsPath: (path: OrExpression<string | number>[], value: unknown) => Expression<{
        contains_path: OrExpression<string | number>[];
        in: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/containsstr
     */
    ContainsStr: (value: OrExpression<string>, search: OrExpression<string>) => Expression<{
        containsstr: OrExpression<string>;
        search: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/containsstrregex
     */
    ContainsStrRegex: (value: OrExpression<string>, pattern: OrExpression<string>) => Expression<{
        containsstrregex: OrExpression<string>;
        pattern: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/containsvalue
     */
    ContainsValue: (value: unknown, inValue: unknown) => Expression<{
        contains_value: unknown;
        in: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/cos
     */
    Cos: (value: OrExpression<number>) => Expression<{
        cos: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/cosh
     */
    Cosh: (value: OrExpression<number>) => Expression<{
        cosh: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/count
     */
    Count: (arrayOrSet: OrExpression<unknown[]>) => Expression<{
        count: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/create
     */
    Create: <TCollectionName extends keyof TSchema["Collections"] = keyof TSchema["Collections"], TData extends TSchema["Collections"][TCollectionName] = TSchema["Collections"][TCollectionName]>(collection: OrExpression<TCollectionName>, params: OrExpression<CreateParams<TData> & Record<string, unknown>>) => Expression<{
        create: OrExpression<TCollectionName>;
        params: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/createaccessprovider
     */
    CreateAccessProvider: <TAccessProviderName extends TSchema["AccessProviders"] extends string[] ? TSchema["AccessProviders"][number] : string = TSchema["AccessProviders"] extends string[] ? TSchema["AccessProviders"][number] : string>(params: OrExpression<CreateAccessProviderParams<TAccessProviderName>>) => Expression<{
        create_access_provider: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/createcollection
     */
    CreateCollection: (params: OrExpression<CreateCollectionParams<TSchema, keyof TSchema['Collections']>>) => Expression<{
        create_collection: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/createdatabase
     */
    CreateDatabase: <TDatabaseName extends TSchema["Databases"] extends string[] ? TSchema["Databases"][number] : string = TSchema["Databases"] extends string[] ? TSchema["Databases"][number] : string>(params: OrExpression<CreateDatabaseParams<TDatabaseName>>) => Expression<{
        create_database: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/createfunction
     */
    CreateFunction: <TFunctionName extends TSchema["Functions"] extends string[] ? TSchema["Functions"][number] : string = TSchema["Functions"] extends string[] ? TSchema["Functions"][number] : string>(params: OrExpression<CreateFunctionParams<TFunctionName>>) => Expression<{
        create_function: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/createindex
     */
    CreateIndex: <TIndexName extends TSchema["Indexes"] extends string[] ? TSchema["Indexes"][number] : string = TSchema["Indexes"] extends string[] ? TSchema["Indexes"][number] : string>(params: OrExpression<CreateIndexParams<TIndexName>>) => Expression<{
        create_index: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/createkey
     */
    CreateKey: (params: OrExpression<CreateKeyParams>) => Expression<{
        create_key: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/createrole
     */
    CreateRole: <TRoleName extends TSchema["Roles"] extends string[] ? TSchema["Roles"][number] : string = TSchema["Roles"] extends string[] ? TSchema["Roles"][number] : string>(params: OrExpression<CreateRoleParams<TRoleName>>) => Expression<{
        create_role: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/credentials
     */
    Credentials: (database?: Expression<unknown> | undefined) => Expression<{
        credentials: Expression<unknown>;
    }> | Expression<{
        credentials: null;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/currentidentity
     */
    CurrentIdentity: () => Expression<{
        current_identity: null;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/currenttoken
     */
    CurrentToken: () => Expression<{
        current_token: null;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/database
     */
    Database: <TDatabaseName extends TSchema["Databases"] extends string[] ? TSchema["Databases"][number] : string = TSchema["Databases"] extends string[] ? TSchema["Databases"][number] : string>(name: OrExpression<TDatabaseName>, database?: Expression<unknown> | undefined) => Expression<{
        database: OrExpression<TDatabaseName>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/databases
     */
    Databases: (database?: Expression<unknown> | undefined) => Expression<{
        databases: Expression<unknown>;
    }> | Expression<{
        databases: null;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/date
     */
    Date: (str: OrExpression<string>) => Expression<{
        date: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/dayofmonth
     */
    DayOfMonth: (timestamp: Expression) => Expression<{
        day_of_month: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/dayofweek
     */
    DayOfWeek: (timestamp: Expression) => Expression<{
        day_of_week: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/dayofyear
     */
    DayOfYear: (timestamp: Expression) => Expression<{
        day_of_year: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/degrees
     */
    Degrees: (value: OrExpression<number>) => Expression<{
        degrees: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/delete
     */
    Delete: (ref: Expression) => Expression<{
        delete: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/difference
     */
    Difference: (source: unknown[] | Expression, ...diff: unknown[]) => Expression<{
        difference: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/distinct
     */
    Distinct: (source: unknown[] | Expression) => Expression<{
        distinct: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/divide
     */
    Divide: (...values: OrExpression<number>[]) => Expression<{
        divide: OrExpression<number>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/do
     */
    Do: (...expressions: Expression[]) => Expression<{
        do: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/documents
     */
    Documents: (collection: Expression) => Expression<{
        documents: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/drop
     */
    Drop: (num: OrExpression<number>, array: OrExpression<unknown[]>) => Expression<{
        drop: OrExpression<number>;
        collection: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/endswith
     */
    EndsWith: (value: OrExpression<string>, search: OrExpression<string>) => Expression<{
        endswith: OrExpression<string>;
        search: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/epoch
     */
    Epoch: (num: OrExpression<number>, unit: OrExpression<EpochUnit>) => Expression<{
        epoch: OrExpression<number>;
        unit: OrExpression<EpochUnit>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/equals
     */
    Equals: (value1: unknown, value2: unknown, ...values: unknown[]) => Expression<{
        equals: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/events
     */
    Events: (input: Expression) => Expression<{
        events: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/exists
     */
    Exists: (ref: Expression, ts?: OrExpression<number> | undefined) => Expression<{
        exists: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/exp
     */
    Exp: (value: OrExpression<number>) => Expression<{
        exp: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/filter
     */
    Filter: (arrayOrSet: OrExpression<unknown[]>, lambda: Expression) => Expression<{
        collection: unknown;
        filter: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/findstr
     */
    FindStr: (value: OrExpression<string>, find: OrExpression<string>, start?: OrExpression<number> | undefined) => Expression<{
        findstr: OrExpression<string>;
        find: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/findstrregex
     */
    FindStrRegex: (value: OrExpression<string>, find: OrExpression<string>, start?: OrExpression<number> | undefined, numResults?: OrExpression<number> | undefined) => Expression<{
        findstrregex: OrExpression<string>;
        find: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/floor
     */
    Floor: (value: OrExpression<number>) => Expression<{
        floor: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/foreach
     */
    Foreach: (arrayOrPage: OrExpression<unknown[]>, lambda: Expression) => Expression<{
        collection: unknown;
        foreach: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/format
     */
    Format: (format: OrExpression<string>, ...args: unknown[]) => Expression<{
        format: OrExpression<string>;
        values: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/function
     */
    Function: <TFunctionName extends keyof TSchema["Functions"] = keyof TSchema["Functions"]>(name: OrExpression<TFunctionName>, database?: Expression<unknown> | undefined) => Expression<{
        function: OrExpression<TFunctionName>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/functions
     */
    Functions: (database?: Expression<unknown> | undefined) => Expression<{
        functions: Expression<unknown>;
    }> | Expression<{
        functions: null;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/gt
     */
    GT: (...values: OrExpression<number>[]) => Expression<{
        gt: OrExpression<number>;
    }> | Expression<{
        gt: OrExpression<number>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/gte
     */
    GTE: (...values: OrExpression<number>[]) => Expression<{
        gte: OrExpression<number>;
    }> | Expression<{
        gte: OrExpression<number>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/get
     */
    Get: (ref: Expression, ts?: OrExpression<number> | undefined) => Expression<{
        get: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/hascurrentidentity
     */
    HasCurrentIdentity: () => Expression<{
        has_current_identity: null;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/hascurrenttoken
     */
    HasCurrentToken: () => Expression<{
        has_current_token: null;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/hour
     */
    Hour: (timestamp: Expression) => Expression<{
        hour: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/hypot
     */
    Hypot: (a: OrExpression<number>, b?: OrExpression<number> | undefined) => Expression<{
        hypot: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/identify
     */
    Identify: (identity: Expression, password: OrExpression<string>) => Expression<{
        identify: Expression<unknown>;
        password: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/if
     */
    If: (condition: OrExpression<boolean>, thenExpression: unknown, elseExpression: unknown) => Expression<{
        if: OrExpression<boolean>;
        then: unknown;
        else: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/index
     */
    Index: <TIndexName extends TSchema["Indexes"] extends string[] ? TSchema["Indexes"][number] : string = TSchema["Indexes"] extends string[] ? TSchema["Indexes"][number] : string>(name: OrExpression<TIndexName>, database?: Expression<unknown> | undefined) => Expression<{
        index: OrExpression<TIndexName>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/indexes
     */
    Indexes: (database?: Expression<unknown> | undefined) => Expression<{
        indexes: Expression<unknown>;
    }> | Expression<{
        indexes: null;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/insert
     */
    Insert: (ref: Expression, ts: OrExpression<number>, action: OrExpression<'create' | 'delete' | 'update'>, params: OrExpression<O.AtLeast<InsertParams>>) => Expression<{
        insert: Expression<unknown>;
        ts: OrExpression<number>;
        action: OrExpression<"create" | "delete" | "update">;
        params: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/intersection
     */
    Intersection: (...group: OrExpression<unknown[]>[]) => Expression<{
        intersection: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isarray
     */
    IsArray: (value: unknown) => Expression<{
        is_array: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isboolean
     */
    IsBoolean: (value: unknown) => Expression<{
        is_boolean: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isbytes
     */
    IsBytes: (value: unknown) => Expression<{
        is_bytes: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/iscollection
     */
    IsCollection: (value: unknown) => Expression<{
        is_collection: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/iscredentials
     */
    IsCredentials: (value: unknown) => Expression<{
        is_credentials: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isdatabase
     */
    IsDatabase: (value: unknown) => Expression<{
        is_database: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isdate
     */
    IsDate: (value: unknown) => Expression<{
        is_date: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isdoc
     */
    IsDoc: (value: unknown) => Expression<{
        is_doc: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isdouble
     */
    IsDouble: (value: unknown) => Expression<{
        is_double: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isempty
     */
    IsEmpty: (arrayOrSet: OrExpression<unknown[]>) => Expression<{
        is_empty: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isfunction
     */
    IsFunction: (value: unknown) => Expression<{
        is_function: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isindex
     */
    IsIndex: (value: unknown) => Expression<{
        is_index: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isinteger
     */
    IsInteger: (value: unknown) => Expression<{
        is_integer: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/iskey
     */
    IsKey: (value: unknown) => Expression<{
        is_key: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/islambda
     */
    IsLambda: (value: unknown) => Expression<{
        is_lambda: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isnonempty
     */
    IsNonEmpty: (arrayOrSet: OrExpression<unknown[]>) => Expression<{
        is_nonempty: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isnull
     */
    IsNull: (value: unknown) => Expression<{
        is_null: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isnumber
     */
    IsNumber: (value: unknown) => Expression<{
        is_number: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isobject
     */
    IsObject: (value: unknown) => Expression<{
        is_object: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isref
     */
    IsRef: (value: unknown) => Expression<{
        is_ref: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isrole
     */
    IsRole: (value: unknown) => Expression<{
        is_role: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isset
     */
    IsSet: (value: unknown) => Expression<{
        is_set: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/isstring
     */
    IsString: (value: unknown) => Expression<{
        is_string: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/istimestamp
     */
    IsTimestamp: (value: unknown) => Expression<{
        is_timestamp: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/istoken
     */
    IsToken: (value: unknown) => Expression<{
        is_token: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/join
     */
    Join: (source: unknown, target: Expression) => Expression<{
        join: unknown;
        with: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/keyfromsecret
     */
    KeyFromSecret: (secret: OrExpression<string>) => Expression<{
        key_from_secret: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/keys
     */
    Keys: (database?: Expression<unknown> | undefined) => Expression<{
        keys: Expression<unknown>;
    }> | Expression<{
        keys: null;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/lt
     */
    LT: (...values: OrExpression<number>[]) => Expression<{
        lt: OrExpression<number>;
    }> | Expression<{
        lt: OrExpression<number>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/lte
     */
    LTE: (...values: OrExpression<number>[]) => Expression<{
        lte: OrExpression<number>;
    }> | Expression<{
        lte: OrExpression<number>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/ltrim
     */
    LTrim: (value: OrExpression<string>) => Expression<{
        ltrim: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/lambda
     */
    Lambda: (params: string | string[], expression: unknown) => Expression<{
        lambda: string | string[];
        expr: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/length
     */
    Length: (value: OrExpression<string>) => Expression<{
        length: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/let
     */
    Let: (variables: Record<string, unknown>, expression: unknown) => Expression<{
        let: {
            [x: string]: unknown;
        }[];
        in: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/ln
     */
    Ln: (value: OrExpression<number>) => Expression<{
        ln: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/log
     */
    Log: (value: OrExpression<number>) => Expression<{
        log: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/login
     */
    Login: (identity: Expression, params: LoginParams) => Expression<{
        login: Expression<unknown>;
        params: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/logout
     */
    Logout: (allTokens: OrExpression<boolean>) => Expression<{
        logout: OrExpression<boolean>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/lowercase
     */
    LowerCase: (value: OrExpression<string>) => Expression<{
        lowercase: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/map
     */
    Map: (array: OrExpression<unknown[]>, lambda: Expression) => Expression<{
        map: Expression<unknown>;
        collection: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/match
     */
    Match: <TIndexName extends TSchema["Indexes"] extends string[] ? TSchema["Indexes"][number] : string = TSchema["Indexes"] extends string[] ? TSchema["Indexes"][number] : string>(index: OrExpression<TIndexName>, searchTerms?: unknown) => Expression<{
        match: OrExpression<TIndexName>;
        terms: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/max
     */
    Max: (...values: OrExpression<number>[]) => Expression<{
        max: OrExpression<number>;
    }> | Expression<{
        max: OrExpression<number>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/mean
     */
    Mean: (arrayOrSet: OrExpression<unknown[]>) => Expression<{
        mean: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/merge
     */
    Merge: (object1: OrExpression<Record<string, unknown>>, object2: OrExpression<Record<string, unknown>> | OrExpression<Record<string, unknown>>[], customResolver?: Expression<unknown> | undefined) => Expression<{
        merge: unknown;
        with: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/min
     */
    Min: (...values: OrExpression<number>[]) => Expression<{
        min: OrExpression<number>;
    }> | Expression<{
        min: OrExpression<number>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/minute
     */
    Minute: (timestamp: Expression) => Expression<{
        minute: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/modulo
     */
    Modulo: (...values: OrExpression<number>[]) => Expression<{
        modulo: OrExpression<number>;
    }> | Expression<{
        modulo: OrExpression<number>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/month
     */
    Month: (timestamp: Expression) => Expression<{
        month: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/movedatabase
     */
    MoveDatabase: (from: Expression, to: Expression) => Expression<{
        move_database: Expression<unknown>;
        to: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/multiply
     */
    Multiply: (...values: OrExpression<number>[]) => Expression<{
        multiply: OrExpression<number>;
    }> | Expression<{
        multiply: OrExpression<number>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/newid
     */
    NewId: () => Expression<{
        new_id: null;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/not
     */
    Not: (value: OrExpression<boolean>) => Expression<{
        not: OrExpression<boolean>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/now
     */
    Now: () => Expression<{
        now: null;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/or
     */
    Or: (...values: OrExpression<boolean>[]) => Expression<{
        or: OrExpression<boolean>;
    }> | Expression<{
        or: OrExpression<boolean>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/paginate
     */
    Paginate: (input: Expression, params?: OrExpression<PaginateParams> | undefined) => Expression<{
        paginate: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/pow
     */
    Pow: (base: OrExpression<number>, exponent: OrExpression<number>) => Expression<{
        pow: OrExpression<number>;
        exp: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/prepend
     */
    Prepend: (base: OrExpression<unknown[]>, elems: OrExpression<unknown[]>) => Expression<{
        prepend: unknown;
        collection: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/query
     */
    Query: (lambda: Expression) => Expression<{
        query: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/rtrim
     */
    RTrim: (value: OrExpression<string>) => Expression<{
        rtrim: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/radians
     */
    Radians: (value: OrExpression<number>) => Expression<{
        radians: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/range
     */
    Range: (set: Expression, start: OrExpression<unknown | unknown[]>, end: OrExpression<unknown | unknown[]>) => Expression<{
        range: Expression<unknown>;
        from: unknown;
        to: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/reduce
     */
    Reduce: (reducer: Expression, initial: unknown, arrayOrSet: OrExpression<unknown[]>) => Expression<{
        reduce: Expression<unknown>;
        initial: unknown;
        arrayOrSet: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/ref
     */
    Ref: (schemaRef: Expression, documentId: OrExpression<string>) => Expression<{
        id: OrExpression<string>;
        ref: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/regexescape
     */
    RegexEscape: (value: OrExpression<string>) => Expression<{
        regexescape: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/remove
     */
    Remove: (ref: Expression, ts: OrExpression<number>, action: OrExpression<'create' | 'delete' | 'update'>) => Expression<{
        remove: Expression<unknown>;
        ts: OrExpression<number>;
        action: OrExpression<"create" | "delete" | "update">;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/repeat
     */
    Repeat: (value: OrExpression<string>, number?: OrExpression<number> | undefined) => Expression<{
        repeat: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/replace
     */
    Replace: (ref: Expression, params: ReplaceParams) => Expression<{
        replace: Expression<unknown>;
        params: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/replacestr
     */
    ReplaceStr: (value: OrExpression<string>, find: OrExpression<string>, replace: OrExpression<string>) => Expression<{
        replacestr: OrExpression<string>;
        find: OrExpression<string>;
        replace: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/replacestrregex
     */
    ReplaceStrRegex: (value: OrExpression<string>, pattern: OrExpression<string>, replace: OrExpression<string>, firstOnly?: OrExpression<boolean> | undefined) => Expression<{
        replacestrregex: OrExpression<string>;
        pattern: OrExpression<string>;
        replace: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/reverse
     */
    Reverse: (source: OrExpression<unknown[]>) => Expression<{
        reverse: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/role
     */
    Role: <TRoleName extends TSchema["Roles"] extends string[] ? TSchema["Roles"][number] : string = TSchema["Roles"] extends string[] ? TSchema["Roles"][number] : string>(name: OrExpression<TRoleName>, database?: Expression<unknown> | undefined) => Expression<{
        role: OrExpression<TRoleName>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/roles
     */
    Roles: (database?: Expression<unknown> | undefined) => Expression<{
        roles: Expression<unknown>;
    }> | Expression<{
        roles: null;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/round
     */
    Round: (value: OrExpression<number>, precision?: OrExpression<number> | undefined) => Expression<{
        round: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/second
     */
    Second: (timestamp: Expression) => Expression<{
        second: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/select
     */
    Select: <TFromArray extends unknown = unknown, TFrom extends Record<string, unknown> | Expression<unknown> | TFromArray[] = any>(path: TFrom extends Expression<unknown> ? string | number | (string | number)[] : O.Paths<TFrom, []> | O.Paths<TFrom, []>[number], from: TFrom, defaultValue?: unknown) => Expression<{
        from: unknown;
        select: TFrom extends Expression<unknown> ? string | number | (string | number)[] : O.Paths<TFrom, []> | O.Paths<TFrom, []>[number];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/sign
     */
    Sign: (value: OrExpression<number>) => Expression<{
        sign: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/sin
     */
    Sin: (value: OrExpression<number>) => Expression<{
        sin: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/singleton
     */
    Singleton: (ref: Expression) => Expression<{
        singleton: Expression<unknown>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/sinh
     */
    Sinh: (value: OrExpression<number>) => Expression<{
        sinh: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/space
     */
    Space: (count: OrExpression<number>) => Expression<{
        space: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/sqrt
     */
    Sqrt: (value: OrExpression<number>) => Expression<{
        sqrt: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/startswith
     */
    StartsWith: (value: OrExpression<string>, search: OrExpression<string>) => Expression<{
        startswith: OrExpression<string>;
        search: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/substring
     */
    SubString: (value: OrExpression<string>, start: OrExpression<number>, length?: OrExpression<number> | undefined) => Expression<{
        substring: OrExpression<string>;
        start: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/subtract
     */
    Subtract: (...values: OrExpression<number>[]) => Expression<{
        subtract: OrExpression<number>;
    }> | Expression<{
        subtract: OrExpression<number>[];
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/sum
     */
    Sum: (arrayOrSet: OrExpression<unknown[]>) => Expression<{
        sum: OrExpression<unknown[]>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/take
     */
    Take: (num: OrExpression<number>, array: OrExpression<unknown[]>) => Expression<{
        take: OrExpression<number>;
        collection: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/tan
     */
    Tan: (value: OrExpression<number>) => Expression<{
        tan: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/tanh
     */
    Tanh: (value: OrExpression<number>) => Expression<{
        tanh: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/time
     */
    Time: (str: OrExpression<string>) => Expression;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/timeadd
     */
    TimeAdd: (base: Expression, offset: OrExpression<number>, unit: OrExpression<EpochUnit>) => Expression<{
        time_add: Expression<unknown>;
        offset: OrExpression<number>;
        unit: OrExpression<EpochUnit>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/timediff
     */
    TimeDiff: (start: Expression, finish: Expression, unit: OrExpression<EpochUnit>) => Expression<{
        time_diff: Expression<unknown>;
        other: Expression<unknown>;
        unit: OrExpression<EpochUnit>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/timesubtract
     */
    TimeSubtract: (base: Expression, offset: OrExpression<number>, unit: OrExpression<EpochUnit>) => Expression<{
        time_subtract: Expression<unknown>;
        offset: OrExpression<number>;
        unit: OrExpression<EpochUnit>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/titlecase
     */
    TitleCase: (value: OrExpression<string>) => Expression<{
        titlecase: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/toarray
     */
    ToArray: (value: unknown) => Expression<{
        to_array: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/todate
     */
    ToDate: (value: unknown) => Expression<{
        to_date: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/todouble
     */
    ToDouble: (value: unknown) => Expression<{
        to_double: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/tointeger
     */
    ToInteger: (value: unknown) => Expression<{
        to_integer: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/tomicros
     */
    ToMicros: (value: unknown) => Expression<{
        to_micros: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/tomillis
     */
    ToMillis: (value: unknown) => Expression<{
        to_millis: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/tonumber
     */
    ToNumber: (value: unknown) => Expression<{
        to_number: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/toobject
     */
    ToObject: (value: unknown) => Expression<{
        to_object: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/toseconds
     */
    ToSeconds: (value: unknown) => Expression<{
        to_seconds: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/tostring
     */
    ToString: (value: unknown) => Expression<{
        to_string: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/totime
     */
    ToTime: (value: unknown) => Expression<{
        to_time: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/tokens
     */
    Tokens: (database?: Expression<unknown> | undefined) => Expression<{
        tokens: Expression<unknown>;
    }> | Expression<{
        tokens: null;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/trim
     */
    Trim: (value: OrExpression<string>) => Expression<{
        trim: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/trim
     */
    Trunc: (value: OrExpression<number>, precision?: OrExpression<number> | undefined) => Expression<{
        trunc: OrExpression<number>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/union
     */
    Union: (...groups: OrExpression<unknown>[]) => Expression<{
        union: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/update
     */
    Update: (ref: Expression, params: O.AtLeast<OrExpression<UpdateParams>>) => Expression<{
        update: Expression<unknown>;
        params: unknown;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/uppercase
     */
    UpperCase: (value: OrExpression<string>) => Expression<{
        uppercase: OrExpression<string>;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/var
     */
    Var: (name: string) => Expression<{
        var: string;
    }>;
    /**
     * @see https://docs.fauna.com/fauna/current/api/fql/functions/year
     */
    Year: (timestamp: Expression) => Expression<{
        year: Expression<unknown>;
    }>;
}

interface ClientConfig {
    /**
     * Opaque bearer token, associated with a token document or key document
     * within Fauna, that provides access to a specific database.
     * A secret is displayed only once at creation time; it should be stored
     * securely, and needs to be revoked and recreated if lost.
     */
    secret: string;
    /**
     * The URL where your database is located. It's common to use `http://localhost:8443`
     * in development for accesing a local FaunaDB database. For production, you can use
     * one of the region groups's URL. Learn more about region groups here: https://docs.fauna.com/fauna/current/api/fql/region_groups.
     * Defaults to the classic region group URL `https://db.fauna.com`.
     */
    url: RegionGroupURL | string;
    /**
     * How requests will be made to the FaunaDB URL. In the following example, `fetch` is globally
     * available:
     * ```ts
     * const config: ClientConfig = {
     *   // Other config...
     *   fetch: (input, init) => {
     *     return fetch(input, init);
     *   }
     * }
     * ```
     * This function must return a Promise which resolves to a Response compatible with the
     * Fetch API (https://developer.mozilla.org/en-US/docs/Web/API/Response).
     */
    fetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
}
declare enum RegionGroupURL {
    US = "https://db.us.fauna.com/",
    EU = "https://db.eu.fauna.com/",
    CLASSIC = "https://db.fauna.com/"
}
declare class Client {
    private config;
    constructor(config: O.Optional<ClientConfig, 'url' | 'fetch'>);
    query: <TResource = unknown>(expression: unknown) => Promise<TResource>;
}

declare class QueryError extends Error {
    code: string;
    description: string;
    rawErrors: {
        code: string;
        description: string;
        position: string[];
    }[];
    constructor(code: string, description: string, rawErrors: {
        code: string;
        description: string;
        position: string[];
    }[]);
}

export { Client, Expression, QueryBuilder, QueryError, RegionGroupURL, SchemaTypes, wrap, wrapValues };