declare abstract class CborCodec {
    abstract encode(value: unknown): Uint8Array;
    abstract decode<T = unknown>(value: Uint8Array): T;
}

type EventListener<TArgs extends readonly any[] = any[]> = (...args: TArgs) => void;
type EventUnsubscriber = () => void;
declare class EventEmitter<TEvents extends Record<string, any[]>> {
    #private;
    on<TEvent extends keyof TEvents>(event: TEvent, listener: EventListener<TEvents[TEvent]>): EventUnsubscriber;
    once<TEvent extends keyof TEvents>(event: TEvent, listener: EventListener<TEvents[TEvent]>): EventUnsubscriber;
    off<TEvent extends keyof TEvents>(event: TEvent, listener: EventListener<TEvents[TEvent]>): void;
    emit<TEvent extends keyof TEvents>(event: TEvent, ...args: TEvents[TEvent]): void;
    waitNext<TEvent extends keyof TEvents>(event: TEvent, signal?: AbortSignal): Promise<TEvents[TEvent]>;
}

type Auth = {
    type: "root";
    username: string;
    password: string;
} | {
    type: "database";
    namespace: string;
    database: string;
    username: string;
    password: string;
} | {
    type: "namespace";
    namespace: string;
    username: string;
    password: string;
} | {
    type: "token";
    token: string;
};
type RpcRequest<TMethod extends string = string, TParams extends unknown[] | undefined = unknown[] | undefined> = {
    method: TMethod;
    params: TParams;
    version?: number;
};
type RpcResponse<TResult = unknown> = RpcResponseOk<TResult> | RpcResponseError;
type RpcResponseOk<TResult = unknown> = {
    result: TResult;
    error?: undefined;
};
type RpcResponseError = {
    result?: undefined;
    error: {
        code: number;
        message: string;
    };
};
type WithId<T extends RpcRequest | RpcResponse> = T & {
    id: number;
};

type EngineOptions = {
    namespace?: string;
    database?: string;
    auth?: Auth;
    cbor?: CborCodec;
};
type ConnectionState = {
    token?: string;
};
declare enum ConnectionStatus {
    CONNECTING = "CONNECTING",
    CONNECTED = "CONNECTED",
    DISCONNECTING = "DISCONNECTING",
    DISCONNECTED = "DISCONNECTED",
    ERROR = "ERROR"
}
type EmitterEvents = {
    connecting: [];
    connected: [];
    disconnecting: [];
    disconnected: [error?: Error];
    error: [error: Error];
    [Key: `rpc-${string}`]: [WithId<RpcResponse>];
    [Key: `live-${string}`]: [any];
};
declare abstract class AbstractEngine extends EventEmitter<EmitterEvents> {
    cbor: CborCodec;
    options: EngineOptions;
    state: ConnectionState;
    constructor(options?: EngineOptions);
    abstract isReady(): Promise<void>;
    abstract getStatus(): ConnectionStatus;
    abstract connect(): Promise<void>;
    abstract disconnect(): Promise<void>;
    abstract rpc<TResult>(request: RpcRequest): Promise<RpcResponse<TResult>>;
    abstract version(): Promise<string>;
}

type HttpEngineOptions = {
    namespace?: string;
    database?: string;
    auth?: Auth;
    /**
     * Custom headers to send with every request.
     */
    headers?: HeadersInit;
    cbor?: CborCodec;
};
declare class HttpEngine extends AbstractEngine {
    #private;
    url: URL;
    constructor(url: URL | string, options?: HttpEngineOptions);
    getStatus(): ConnectionStatus;
    isReady(): Promise<void>;
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    rpc<TResult>(request: RpcRequest): Promise<RpcResponse<TResult>>;
    version(): Promise<string>;
}

type WebSocketEngineOptions = {
    namespace?: string;
    database?: string;
    auth?: Auth;
    poolSize?: number;
    readyTimeout?: number;
    reconnectTimeout?: number;
    cbor?: CborCodec;
};
declare class WebSocketEngine extends AbstractEngine {
    #private;
    constructor(url: URL | string, options?: WebSocketEngineOptions);
    getStatus(): ConnectionStatus;
    isReady(): Promise<void>;
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    rpc<TResult>(request: RpcRequest): Promise<RpcResponse<TResult>>;
    version(): Promise<string>;
}

declare class DatabaseError extends Error {
    code: number;
    request: RpcRequest;
    constructor({ code, message }: RpcResponseError["error"], request: RpcRequest);
}
declare class QueryError extends Error {
}
declare class ConnectionError<T = unknown> extends Error {
    details?: T;
    constructor(message: string, details?: T);
}

/** The Standard Schema interface. */
interface StandardSchemaV1<Input = unknown, Output = Input> {
    /** The Standard Schema properties. */
    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
}
declare namespace StandardSchemaV1 {
    /** The Standard Schema properties interface. */
    export interface Props<Input = unknown, Output = Input> {
        /** The version number of the standard. */
        readonly version: 1;
        /** The vendor name of the schema library. */
        readonly vendor: string;
        /** Validates unknown input values. */
        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
        /** Inferred types associated with the schema. */
        readonly types?: Types<Input, Output> | undefined;
    }
    /** The result interface of the validate function. */
    export type Result<Output> = SuccessResult<Output> | FailureResult;
    /** The result interface if validation succeeds. */
    export interface SuccessResult<Output> {
        /** The typed output value. */
        readonly value: Output;
        /** The non-existent issues. */
        readonly issues?: undefined;
    }
    /** The result interface if validation fails. */
    export interface FailureResult {
        /** The issues of failed validation. */
        readonly issues: ReadonlyArray<Issue>;
    }
    /** The issue interface of the failure output. */
    export interface Issue {
        /** The error message of the issue. */
        readonly message: string;
        /** The path of the issue, if any. */
        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
    }
    /** The path segment interface of the issue. */
    export interface PathSegment {
        /** The key representing a path segment. */
        readonly key: PropertyKey;
    }
    /** The Standard Schema types interface. */
    export interface Types<Input = unknown, Output = Input> {
        /** The input type of the schema. */
        readonly input: Input;
        /** The output type of the schema. */
        readonly output: Output;
    }
    /** Infers the input type of a Standard Schema. */
    export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
    /** Infers the output type of a Standard Schema. */
    export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
    export {  };
}

type StandardSchema<TInput = unknown, TOutput = TInput> = StandardSchemaV1<TInput, TOutput>;
type InferStandardInput<TSchema extends StandardSchema> = TSchema extends StandardSchema<infer TInput, infer _> ? TInput : never;
type InferStandardOutput<TSchema extends StandardSchema> = TSchema extends StandardSchema<infer _, infer TOutput> ? TOutput : never;
declare class ValidationError extends Error {
    issues: readonly StandardSchemaV1.Issue[];
    constructor(issues: readonly StandardSchemaV1.Issue[]);
}
/**
 * Validates a value against a schema and returns the validated value.
 *
 * If the schema validation fails, an error will be thrown.
 *
 * @param schema The schema to validate against.
 * @param value The value to validate.
 * @returns The validated value or an error if the validation failed.
 */
declare const parseSchema: <TSchema extends StandardSchema>(schema: TSchema, value: unknown) => Promise<InferStandardOutput<TSchema>>;
declare const mergeSchema: <TInput, TOutput>(schemas: StandardSchema<TInput, TOutput>[]) => StandardSchema<TInput, TOutput>;

/**
 * A schema which defines what data is expected from the database.
 *
 * Optionally an input type can be provided which is useful
 * when you have futures or readonly fields in your database.
 *
 * Input type is used to generate types for create or update queries
 * while the result type is used for queries like select fields
 * or where conditions.
 */
type SchemaContext<TResult = unknown, TInput = TResult> = {
    result: StandardSchema<unknown, TResult>;
    input?: TInput;
};
type InferResult<TContext extends SchemaContext> = TContext extends SchemaContext<infer TResult, infer _> ? TResult : never;
type InferInput<TContext extends SchemaContext> = TContext extends SchemaContext<infer _, infer TInput> ? TInput : never;
type UnknownSchemaContext = SchemaContext<unknown>;
type AnySchemaContext = SchemaContext<any>;

/**
 * A tagged template is a template literal with all variables as an array.
 */
type TaggedTemplate = [string[] | TemplateStringsArray, unknown[]];
/**
 * A variable converter function used in the {@link format} function to convert the variable values to strings.
 *
 * This is needed to convert a {@link TaggedTemplate} into a string.
 */
type FormatVariableConverter = (value: unknown, index: number) => string;
/**
 * Function to create a tagged template using a template literals.
 * This also preserves the variables in the template.
 *
 * @returns A tagged template.
 */
declare const tag: (strings: string[] | TemplateStringsArray, ...values: unknown[]) => TaggedTemplate;
/**
 * Function to create a tagged template from a string without any variables.
 *
 * @param str The string to create the tagged template from.
 * @returns A tagged template.
 */
declare const tagString: (str: string) => TaggedTemplate;
/**
 * Function to merge multiple tagged templates into one.
 *
 * @param tags A list of tagged templates to merge.
 * @param join A optional join string which gets inserted between the tagged templates.
 * @returns A merged tagged template.
 */
declare const merge: (tags: TaggedTemplate[], join?: string) => TaggedTemplate;
/**
 * Function to format a tagged template into a string.
 *
 * @param tag The tagged template to format.
 * @param variableConverter An optional variable converter function to convert the variable values to strings. (default: String constructor)
 * @returns The formatted string.
 */
declare const format: (tag: TaggedTemplate, variableConverter?: FormatVariableConverter) => string;
/**
 * Check whether a tagged template is empty.
 *
 * This means that the template will be formatted to an empty string.
 *
 * @param template The tagged template to check.
 * @returns True if the template is empty, false otherwise.
 */
declare const isEmpty: (template: TaggedTemplate) => boolean;

type QueryOptions<TOutput = unknown> = {
    /**
     * An optional connection to use for executing the query.
     *
     * If not provided, the default connection will be used if available.
     */
    connection?: Surrealize;
    /**
     * An optional schema to use for validating the result.
     */
    schema?: StandardSchema<unknown, TOutput>;
};
type QueryListOptions = {
    /**
     * An optional connection to use for executing the query.
     *
     * If not provided, the default connection will be used if available.
     */
    connection?: Surrealize;
};
declare class Query<TOutput = unknown> {
    readonly template: TaggedTemplate;
    readonly connection?: Surrealize;
    schema?: StandardSchema<unknown, TOutput>;
    constructor(template: TaggedTemplate, options?: QueryOptions<TOutput>);
    withConnection(connection: Surrealize): Query<TOutput>;
    withSchema<TWithOutput = unknown>(schema?: StandardSchema<unknown, TWithOutput>): Query<TWithOutput>;
    with<TWithOutput = unknown>(options?: QueryOptions<TWithOutput>): Query<TWithOutput>;
    execute(): Promise<TOutput>;
}
declare class QueryList<const TQueries extends Query<any>[]> {
    readonly queries: TQueries;
    readonly connection?: Surrealize;
    constructor(queries: TQueries, options?: QueryListOptions);
    withConnection(connection: Surrealize): QueryList<TQueries>;
    executeAll(): Promise<InferQueriesOutput<TQueries>>;
    executeTransaction(): Promise<InferQueriesOutput<TQueries>>;
}
/**
 * Create a query using a tagged template.
 *
 * @returns The query.
 */
declare const surql: (strings: string[] | TemplateStringsArray, ...values: unknown[]) => Query;

/**
 * A raw query is a builder for a tagged template query.
 *
 * Every mutation returns a new {@link RawQuery} instance, so {@link RawQuery}s are immutable.
 */
declare class RawQuery {
    readonly template: TaggedTemplate;
    constructor(template?: TaggedTemplate);
    /**
     * Append a {@link TaggedTemplate} to the current template.
     *
     * @param template The {@link TaggedTemplate} or string to append.
     * @param join The join string to use between the queries. Defaults to a space.
     * @returns A new {@link RawQuery} with the appended template.
     */
    append(template?: TaggedTemplate | string, join?: string): RawQuery;
    /**
     * Convert the query to a {@link Query} object which can be executed.
     *
     * @param options The options to use for the query.
     * @returns The query.
     */
    toQuery<TOutput = unknown>(options?: QueryOptions<TOutput>): Query<TOutput>;
    static empty(): RawQuery;
}

type PreparedQuery = {
    query: string;
    bindings?: Record<string, unknown>;
};
/**
 * A queryable is an object which has a context containing the `toQuery` function.
 *
 * This function returns a {@link Query} or a {@link RawQuery}.
 */
type Queryable<TOutput = unknown> = Record<"toQuery", () => Query<TOutput> | RawQuery>;
/**
 * A query like type which can be a {@link Query} or a {@link Queryable}.
 */
type QueryLike<TOutput = unknown> = Query<TOutput> | Queryable<TOutput>;
/**
 * This is a list of ${@link QueryLike} objects.
 */
type QueriesLike<TResult = unknown> = QueryLike<TResult>[];
/**
 * Infer the output type of a {@link QueryLike} object.
 */
type InferQueryOutput<TQuery extends QueryLike> = TQuery extends QueryLike<infer TOutput> ? TOutput : never;
/**
 * Infer the output type of a list of {@link QueryLike} objects.
 */
type InferQueriesOutput<TQueries extends QueriesLike> = {
    [Key in keyof TQueries]: InferQueryOutput<TQueries[Key]>;
};

/**
 * A deep partial type which allows for deeply partially defined objects and arrays.
 */
type DeepPartial<T> = T extends Record<string, unknown> | Array<unknown> ? {
    [P in keyof T]?: DeepPartial<T[P]>;
} : T;
/**
 *  A type which only makes a subset of keys partial.
 */
type PartialOnly<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
/**
 * A type which only makes a subset of keys required.
 */
type RequiredOnly<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;

type OptionalId<TRecord extends Record<string, unknown>> = PartialOnly<TRecord, "id">;
type RequiredId<TRecord extends Record<string, unknown>> = RequiredOnly<TRecord, "id">;
type _Record<TId extends RecordId = RecordId> = {
    id: TId;
};

type AnyRecord<TId extends RecordId = RecordId> = _Record<TId> & {
    [key: string]: unknown;
};
type RecordSchemaContext<TRecordId extends RecordId = RecordId> = SchemaContext<AnyRecord<TRecordId>>;

type InferTableFromSchema<TSchema extends SchemaContext> = TSchema extends RecordSchemaContext<infer TRecordId> ? TRecordId["table"] : string;
/**
 * A type which represents multiple way of specifying a table.
 *
 * Including the {@link Table} itself and a string representation of the table.
 */
type TableLike<TTable extends string = string> = Table<TTable> | TTable;
/**
 * The table is a collection of records in SurrealDB.
 */
declare class Table<TTable extends string = string> {
    readonly name: TTable;
    constructor(name: TTable);
    /**
     * Checks if the table is equal to another table.
     *
     * @param table The table to compare with.
     * @returns True if the tables are equal, false otherwise.
     */
    equals(table: Table): table is Table<TTable>;
    /**
     * Checks if a record id is belonging to the table.
     *
     * @param recordId The record id to check.
     * @returns True if record id belongs to the table, false otherwise.
     */
    contains(recordId: RecordId): boolean;
    /**
     * Create a record id which belongs to the table.
     *
     * @param id The id of the record id.
     * @returns A record id which belongs to the table.
     */
    getRecordId<TId extends RecordIdValue>(id: TId): RecordId<TTable, TId>;
    /**
     * Get the string representation of the table.
     *
     * This is simply the name of the table.
     *
     * @returns The string representation of the table.
     */
    toString(): string;
    /**
     * Instantiate a table from a table like input.
     *
     * @param table The table like input.
     * @returns The instantiated table.
     */
    static from<const TTable extends string>(table: TableLike<TTable>): Table<TTable>;
}

declare class UUID {
    readonly bytes: Uint8Array;
    constructor(bytes: Uint8Array);
}

/**
 * The value type of a the id part of a record id.
 */
type RecordIdValue = string | number | bigint | UUID | unknown[] | Record<string, unknown>;
/**
 * A type which represents multiple way of specifying a record id.
 *
 * Including the {@link RecordId} itself and a string representation of the record id.
 */
type RecordIdLike<TTable extends string = string, TId extends RecordIdValue = RecordIdValue> = RecordId<TTable, TId> | `${TTable}:${Extract<TId, string | number | bigint>}`;
/**
 * The record id is the primary key of a record in SurrealDB and is used to identify a record.
 *
 * It consists of the table name and an arbitrary id value.
 */
declare class RecordId<TTable extends string = string, TValue extends RecordIdValue = RecordIdValue> {
    readonly table: TTable;
    readonly value: TValue;
    constructor(table: TTable, value: TValue);
    /**
     * Checks if the record id is equal to another record id.
     *
     * @param recordId The record id to compare with.
     * @returns True if the record ids are equal, false otherwise.
     */
    equals(recordId: RecordId): recordId is RecordId<TTable, TValue>;
    /**
     * Get the table of the record id.
     *
     * @returns The table of the record id.
     */
    getTable(): Table<TTable>;
    /**
     * Resolve the actual associated record of the record id using a surrealize connection.
     *
     * @param options The options to resolve the record.
     * @returns The resolved record.
     */
    resolve<TOutput>(options?: {
        /**
         * The surrealize connection to use for resolving the record.
         *
         * If not provided, the default connection will be used (if set).
         */
        connection?: Surrealize;
        /**
         * The schema to use for validating the resolved record.
         */
        schema?: StandardSchema<unknown, TOutput>;
    }): Promise<TOutput>;
    /**
     * Instantiate a record id from a table and value.
     *
     * @example
     * ```ts
     * const rid1 = RecordId.from("user", "bob");
     * const rid2 = RecordId.from(Table.from("user"), "bob");
     * const rid3 = RecordId.from("sensor", ["SENSOR_1", new Date()]);
     * ```
     *
     * @param table The table of the record id.
     * @param value The value of the record id.
     * @returns The instantiated record id.
     */
    static from<const TTable extends string, const TValue extends RecordIdValue>(table: TableLike<TTable>, id: TValue): RecordId<TTable, TValue>;
    /**
     * Instantiate a record id from a record id like input.
     *
     * @example
     * ```ts
     * const rid = RecordId.from("user:bob");
     * ```
     *
     * @param recordId The record id like input.
     * @returns The instantiated record id.
     */
    static from<const TTable extends string, const TValue extends RecordIdValue>(recordId: RecordIdLike<TTable, TValue>): RecordId<TTable, TValue>;
}

/**
 * A target is either a table or a record id.
 *
 * This type represents a target in multiple ways. Like a table or a record id in string representation or in its own types.
 *
 * @example
 *
 * ```ts
 *
 * // RecordId
 * const rid1: TargetLike = "users:123";
 * const rid2: TargetLike = new RecordId("users", "123");
 * const rid3: TargetLike = RecordId.from("users", "123");
 *
 * // Table
 * const table1: TargetLike = "users";
 * const table2: TargetLike = new Table("users");
 * const table3: TargetLike = Table.from("users");
 * ```
 */
type TargetLike<TTable extends string = string, TId extends RecordIdValue | never = RecordIdValue | never> = TableLike<TTable> | RecordIdLike<TTable, TId>;
/**
 * The resolved target type which infers a target like type and returns either a record id or a table depending on the target.
 *
 * This is the return type of the {@link resolveTarget} function.
 */
type ResolvedTarget<TTarget extends TargetLike> = TTarget extends RecordIdLike<infer TTable, infer TId> ? RecordId<TTable, TId> : TTarget extends TableLike<infer TTable> ? Table<TTable> : never;
/**
 * Resolves a target and returns either a record id or a table depending on the target.
 *
 * @param target The target to resolve.
 * @returns The resolved target (either a record id or a table).
 */
declare const resolveTarget: <TTarget extends TargetLike>(target: TTarget) => ResolvedTarget<TTarget>;

type SurrealizeOptions = {
    /**
     * Set the connection as the default connection.
     *
     * This will make the Surrealize instance the default instance for all queries.
     */
    default?: boolean;
};
declare class Surrealize {
    static default: Surrealize | undefined;
    readonly engine: AbstractEngine;
    readonly options: SurrealizeOptions;
    constructor(engine: AbstractEngine, options?: SurrealizeOptions);
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    version(): Promise<string>;
    execute<TOutput = unknown>(queryLike: QueryLike<TOutput>): Promise<TOutput>;
    executeAll<const TQueries extends QueriesLike>(queriesLike: TQueries): Promise<InferQueriesOutput<TQueries>>;
    executeTransaction<const TQueries extends QueriesLike>(queriesLike: TQueries): Promise<InferQueriesOutput<TQueries>>;
    /**
     * Get a specific target from the database. A target can be a record id or a table.
     * In case the target is a table, the result will be an array of records.
     *
     * @param targetLike A target like input (record id or table).
     * @param schema The optional schema to use for validating the result.
     * @returns The target from the database.
     */
    resolve<TOutput = unknown>(targetLike: TargetLike, schema?: StandardSchema<unknown, TOutput>): Promise<TOutput>;
    query<TResult extends unknown[]>(query: string, bindings?: Record<string, unknown>): Promise<TResult>;
}

type BuilderContext<TSchema extends SchemaContext = AnySchemaContext> = {
    schema?: TSchema;
    connection?: Surrealize;
};
type Statement<TFn extends (...args: any[]) => any = (...args: any[]) => any> = (query: RawQuery, ctx: BuilderContext<any>) => TFn;
type Builder<TStatements extends Record<string, Statement> = Record<string, Statement>> = {
    [Key in keyof TStatements]: TStatements[Key] extends Statement<infer TFn> ? TFn : never;
};
type WithBuilderContext<TSchema extends SchemaContext> = {
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
};

declare const DURATIONS: {
    ns: bigint;
    us: bigint;
    µs: bigint;
    ms: bigint;
    s: bigint;
    m: bigint;
    h: bigint;
    d: bigint;
    w: bigint;
    y: bigint;
};
type DurationUnit = keyof typeof DURATIONS;
type DurationValueUnit<TUnit extends DurationUnit> = `${number}${TUnit}` | ``;
type DurationValue = `${DurationValueUnit<"y">}${DurationValueUnit<"w">}${DurationValueUnit<"d">}${DurationValueUnit<"h">}${DurationValueUnit<"m">}${DurationValueUnit<"s">}${DurationValueUnit<"ms">}${DurationValueUnit<"µs">}${DurationValueUnit<"us">}${DurationValueUnit<"ns">}`;
type DurationLike = DurationValue | Duration | bigint | number;
declare class Duration {
    #private;
    /**
     * Create a new duration.
     *
     * @param duration The duration in nanoseconds.
     */
    constructor(duration: bigint);
    add(duration: DurationLike): Duration;
    substract(duration: DurationLike): Duration;
    get nanoseconds(): bigint;
    get milliseconds(): bigint;
    get microseconds(): bigint;
    get seconds(): bigint;
    get minutes(): bigint;
    get hours(): bigint;
    get days(): bigint;
    get weeks(): bigint;
    get years(): bigint;
    /**
     * Create a new duration from a value and an unit.
     *
     * @param value The value as a number or bigint.
     * @param unit The unit of the duration.
     * @returns The duration.
     */
    static from(value: bigint | number, unit: DurationUnit): Duration;
    /**
     * Create a new duration from a duration like input.
     *
     * @param duration The input duration can be a duration string (e.g. `1y2w3d4h5m6s7ms8µs9ns`),
     *                 a number/bigint (in milliseconds) or a duration object itself.
     * @returns The duration.
     */
    static from(duration: DurationLike): Duration;
    /**
     * Parse a duration string into a duration object.
     *
     * @param duration The duration string (e.g. `1y2w3d4h5m6s7ms8µs9ns`)
     * @returns The duration.
     */
    static parseString(duration: DurationValue): Duration;
    static zero(): Duration;
    static years(value: number | bigint): Duration;
    static weeks(value: number | bigint): Duration;
    static days(value: number | bigint): Duration;
    static hours(value: number | bigint): Duration;
    static minutes(value: number | bigint): Duration;
    static seconds(value: number | bigint): Duration;
    static milliseconds(value: number | bigint): Duration;
    static microseconds(value: number | bigint): Duration;
    static nanoseconds(value: number | bigint): Duration;
}

type RawField<T> = unknown extends T ? string : Extract<keyof T, string>;
type Field<TSchema extends SchemaContext = UnknownSchemaContext> = RawField<InferResult<TSchema>>;
type InputField<TSchema extends SchemaContext = UnknownSchemaContext> = RawField<InferInput<TSchema>>;

type ContentLike<TSchema extends SchemaContext> = InferInput<TSchema> extends Record<string, unknown> ? InferInput<TSchema> : Record<string, unknown>;
type SetLike<TSchema extends SchemaContext> = {
    [Key in InputField<TSchema>]?: unknown;
};
type UnsetLike<TSchema extends SchemaContext> = InputField<TSchema>[];
type MergeLike<_TSchema extends SchemaContext> = Record<string, unknown>;
type PatchLike<_TSchema extends SchemaContext> = Record<string, unknown>;

type ReturnType = "none" | "after" | "before" | "diff";

declare const create: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (targets: TargetLike | TargetLike[]) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    content: typeof content$2<TSchema>;
    set: typeof set$2<TSchema>;
    return: typeof _return$3<TSchema>;
    timeout: typeof timeout$4<TSchema>;
    parallel: typeof parallel$4<TSchema>;
}>;
declare const createOnly: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (target: TargetLike) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    content: typeof content$2<TSchema>;
    set: typeof set$2<TSchema>;
    return: typeof _return$3<TSchema>;
    timeout: typeof timeout$4<TSchema>;
    parallel: typeof parallel$4<TSchema>;
}>;
declare const content$2: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (content?: ContentLike<TSchema>) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    return: typeof _return$3<TSchema>;
    timeout: typeof timeout$4<TSchema>;
    parallel: typeof parallel$4<TSchema>;
}>;
declare const set$2: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (set?: SetLike<TSchema>) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    return: typeof _return$3<TSchema>;
    timeout: typeof timeout$4<TSchema>;
    parallel: typeof parallel$4<TSchema>;
}>;
declare const _return$3: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (type?: ReturnType) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    timeout: typeof timeout$4<TSchema>;
    parallel: typeof parallel$4<TSchema>;
}>;
declare const timeout$4: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (timeout?: DurationLike) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    parallel: typeof parallel$4<TSchema>;
}>;
declare const parallel$4: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (append?: any) => Builder<WithBuilderContext<TSchema>>;

type WhereState = {
    conditions: WhereCondition[];
};
type CompareOperator = "=" | "!=" | "==" | "~" | "!~" | "<" | "<=" | ">" | ">=";
type WhereCondition<TSchema extends SchemaContext = UnknownSchemaContext> = WhereCompare<Field<TSchema>> | WhereAnd<TSchema> | WhereOr<TSchema>;
type WhereCompare<TField extends string = string, TOperator extends CompareOperator = CompareOperator, TValue = unknown> = {
    type: "cmp";
    field: TField;
    operator: TOperator;
    value: TValue;
};
type WhereAnd<TSchema extends SchemaContext = UnknownSchemaContext> = {
    type: "and";
    conditions: WhereCondition<TSchema>[];
};
type WhereOr<TSchema extends SchemaContext = UnknownSchemaContext> = {
    type: "or";
    conditions: WhereCondition<TSchema>[];
};
declare const buildWhere: (conditions?: WhereCondition[]) => TaggedTemplate | undefined;
/**
 * Create a `AND` condition.
 *
 * @param conditions The conditions to combine.
 * @returns The `AND` condition.
 */
declare const and: <TSchema extends SchemaContext = UnknownSchemaContext>(...conditions: WhereCondition<TSchema>[]) => WhereAnd<TSchema>;
/**
 * Create a `OR` condition.
 *
 * @param conditions The conditions to combine.
 * @returns The `OR` condition.
 */
declare const or: <TSchema extends SchemaContext = UnknownSchemaContext>(...conditions: WhereCondition<TSchema>[]) => WhereOr<TSchema>;
/**
 * Create a comparator for a field.
 *
 * @param field The field to compare.
 * @param operator The operator to use.
 * @param value The value to compare with.
 * @returns The comparator.
 */
declare const cmp: <TField extends string, TOperator extends CompareOperator, TValue>(field: TField, operator: TOperator, value: TValue) => WhereCompare<TField, TOperator, TValue>;
/**
 * Compares a field using the `==` operator. (strict equality)
 *
 * @param field The field to compare.
 * @param value The value to compare with.
 * @returns The comparator.
 */
declare const eq: <TField extends string, TValue>(field: TField, value: TValue) => WhereCompare<TField, "=", TValue>;
/**
 * Compares a field using the `!=` operator. (inequality)
 *
 * @param field The field to compare.
 * @param value The value to compare with.
 * @returns The comparator.
 */
declare const neq: <TField extends string, TValue>(field: TField, value: TValue) => WhereCompare<TField, "!=", TValue>;
/**
 * Compares a field using the `==` operator. (strict equality)
 *
 * @param field The field to compare.
 * @param value The value to compare with.
 * @returns The comparator.
 */
declare const eqs: <TField extends string, TValue>(field: TField, value: TValue) => WhereCompare<TField, "==", TValue>;
/**
 * Compares a field using the `>` operator. (greater than)
 *
 * @param field The field to compare.
 * @param value The value to compare with.
 * @returns The comparator.
 */
declare const gt: <TField extends string, TValue>(field: TField, value: TValue) => WhereCompare<TField, ">", TValue>;
/**
 * Compares a field using the `>=` operator. (greater than or equal)
 *
 * @param field The field to compare.
 * @param value The value to compare with.
 * @returns The comparator.
 */
declare const gte: <TField extends string, TValue>(field: TField, value: TValue) => WhereCompare<TField, ">=", TValue>;
/**
 * Compares a field using the `<` operator. (less than)
 *
 * @param field The field to compare.
 * @param value The value to compare with.
 * @returns The comparator.
 */
declare const lt: <TField extends string, TValue>(field: TField, value: TValue) => WhereCompare<TField, "<", TValue>;
/**
 * Compares a field using the `<=` operator. (less than or equal)
 *
 * @param field The field to compare.
 * @param value The value to compare with.
 * @returns The comparator.
 */
declare const lte: <TField extends string, TValue>(field: TField, value: TValue) => WhereCompare<TField, "<=", TValue>;

declare const _delete: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (targets: TargetLike | TargetLike[]) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    where: typeof where$3<TSchema>;
    return: typeof _return$2<TSchema>;
    timeout: typeof timeout$3<TSchema>;
    parallel: typeof parallel$3<TSchema>;
}>;
declare const deleteOnly: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (target: TargetLike) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    where: typeof where$3<TSchema>;
    return: typeof _return$2<TSchema>;
    timeout: typeof timeout$3<TSchema>;
    parallel: typeof parallel$3<TSchema>;
}>;
declare const where$3: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (conditions?: WhereCondition<TSchema>[]) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    return: typeof _return$2<TSchema>;
    timeout: typeof timeout$3<TSchema>;
    parallel: typeof parallel$3<TSchema>;
}>;
declare const _return$2: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (type?: ReturnType) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    timeout: typeof timeout$3<TSchema>;
    parallel: typeof parallel$3<TSchema>;
}>;
declare const timeout$3: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (timeout?: DurationLike) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    parallel: typeof parallel$3<TSchema>;
}>;
declare const parallel$3: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (append?: any) => Builder<WithBuilderContext<TSchema>>;

declare const orderDirectionMapping: {
    asc: string;
    ascending: string;
    desc: string;
    descending: string;
};
declare const orderModeMapping: {
    collate: string;
    numeric: string;
};
type OrderDirection = keyof typeof orderDirectionMapping;
type OrderMode = keyof typeof orderModeMapping;
type OrderFieldOptions<TSchema extends SchemaContext> = {
    field: Field<TSchema>;
    mode?: OrderMode;
    direction?: OrderDirection;
};
type OrderFields<TSchema extends SchemaContext = UnknownSchemaContext> = "rand" | Array<Field<TSchema> | OrderFieldOptions<TSchema>>;

declare const select: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (fields?: Field<TSchema>[] | "*") => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    from: typeof from<TSchema>;
    fromOnly: typeof fromOnly<TSchema>;
}>;
declare const selectValue: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (field: Field<TSchema>) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    from: typeof from<TSchema>;
    fromOnly: typeof fromOnly<TSchema>;
}>;
declare const from: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (targets: TargetLike<InferTableFromSchema<TSchema>> | TargetLike<InferTableFromSchema<TSchema>>[]) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    with: typeof _with<TSchema>;
    where: typeof where$2<TSchema>;
    split: typeof split<TSchema>;
    group: typeof group<TSchema>;
    order: typeof order<TSchema>;
    limit: typeof limit<TSchema>;
    start: typeof start<TSchema>;
    fetch: typeof fetch<TSchema>;
    timeout: typeof timeout$2<TSchema>;
    parallel: typeof parallel$2<TSchema>;
    tempfiles: typeof tempfiles<TSchema>;
    explain: typeof explain<TSchema>;
}>;
declare const fromOnly: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (target: TargetLike<InferTableFromSchema<TSchema>>) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    with: typeof _with<TSchema>;
    where: typeof where$2<TSchema>;
    split: typeof split<TSchema>;
    group: typeof group<TSchema>;
    order: typeof order<TSchema>;
    limit: typeof limit<TSchema>;
    start: typeof start<TSchema>;
    fetch: typeof fetch<TSchema>;
    timeout: typeof timeout$2<TSchema>;
    parallel: typeof parallel$2<TSchema>;
    tempfiles: typeof tempfiles<TSchema>;
    explain: typeof explain<TSchema>;
}>;
declare const _with: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (indexes?: string[]) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    where: typeof where$2<TSchema>;
    split: typeof split<TSchema>;
    group: typeof group<TSchema>;
    order: typeof order<TSchema>;
    limit: typeof limit<TSchema>;
    start: typeof start<TSchema>;
    fetch: typeof fetch<TSchema>;
    timeout: typeof timeout$2<TSchema>;
    parallel: typeof parallel$2<TSchema>;
    tempfiles: typeof tempfiles<TSchema>;
    explain: typeof explain<TSchema>;
}>;
declare const where$2: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (conditions?: WhereCondition<TSchema>[]) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    split: typeof split<TSchema>;
    group: typeof group<TSchema>;
    order: typeof order<TSchema>;
    limit: typeof limit<TSchema>;
    start: typeof start<TSchema>;
    fetch: typeof fetch<TSchema>;
    timeout: typeof timeout$2<TSchema>;
    parallel: typeof parallel$2<TSchema>;
    tempfiles: typeof tempfiles<TSchema>;
    explain: typeof explain<TSchema>;
}>;
declare const split: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (field?: Field<TSchema>) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    group: typeof group<TSchema>;
    order: typeof order<TSchema>;
    limit: typeof limit<TSchema>;
    start: typeof start<TSchema>;
    fetch: typeof fetch<TSchema>;
    timeout: typeof timeout$2<TSchema>;
    parallel: typeof parallel$2<TSchema>;
    tempfiles: typeof tempfiles<TSchema>;
    explain: typeof explain<TSchema>;
}>;
declare const group: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (fields?: Field<TSchema>[]) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    order: typeof order<TSchema>;
    limit: typeof limit<TSchema>;
    start: typeof start<TSchema>;
    fetch: typeof fetch<TSchema>;
    timeout: typeof timeout$2<TSchema>;
    parallel: typeof parallel$2<TSchema>;
    tempfiles: typeof tempfiles<TSchema>;
    explain: typeof explain<TSchema>;
}>;
declare const order: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (fields?: OrderFields<TSchema>) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    limit: typeof limit<TSchema>;
    start: typeof start<TSchema>;
    fetch: typeof fetch<TSchema>;
    timeout: typeof timeout$2<TSchema>;
    parallel: typeof parallel$2<TSchema>;
    tempfiles: typeof tempfiles<TSchema>;
    explain: typeof explain<TSchema>;
}>;
declare const limit: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (limit?: number) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    start: typeof start<TSchema>;
    fetch: typeof fetch<TSchema>;
    timeout: typeof timeout$2<TSchema>;
    parallel: typeof parallel$2<TSchema>;
    tempfiles: typeof tempfiles<TSchema>;
    explain: typeof explain<TSchema>;
}>;
declare const start: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (start?: number) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    fetch: typeof fetch<TSchema>;
    timeout: typeof timeout$2<TSchema>;
    parallel: typeof parallel$2<TSchema>;
    tempfiles: typeof tempfiles<TSchema>;
    explain: typeof explain<TSchema>;
}>;
declare const fetch: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (fields?: Field<TSchema>[]) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    timeout: typeof timeout$2<TSchema>;
    parallel: typeof parallel$2<TSchema>;
    tempfiles: typeof tempfiles<TSchema>;
    explain: typeof explain<TSchema>;
}>;
declare const timeout$2: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (timeout?: DurationLike) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    parallel: typeof parallel$2<TSchema>;
    tempfiles: typeof tempfiles<TSchema>;
    explain: typeof explain<TSchema>;
}>;
declare const parallel$2: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (append?: any) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    tempfiles: typeof tempfiles<TSchema>;
    explain: typeof explain<TSchema>;
}>;
declare const tempfiles: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (append?: any) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    explain: typeof explain<TSchema>;
}>;
declare const explain: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (options?: {
    full?: boolean;
} | false) => Builder<WithBuilderContext<TSchema>>;

declare const update: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (targets: TargetLike | TargetLike[]) => Builder<{
    content: typeof content$1<TSchema>;
    merge: typeof _merge$1<TSchema>;
    patch: typeof patch$1<TSchema>;
    set: typeof set$1<TSchema>;
    unset: typeof unset$1<TSchema>;
    where: typeof where$1<TSchema>;
    return: typeof _return$1<TSchema>;
    timeout: typeof timeout$1<TSchema>;
    parallel: typeof parallel$1<TSchema>;
}>;
declare const updateOnly: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (target: TargetLike) => Builder<{
    content: typeof content$1<TSchema>;
    merge: typeof _merge$1<TSchema>;
    patch: typeof patch$1<TSchema>;
    set: typeof set$1<TSchema>;
    unset: typeof unset$1<TSchema>;
    where: typeof where$1<TSchema>;
    return: typeof _return$1<TSchema>;
    timeout: typeof timeout$1<TSchema>;
    parallel: typeof parallel$1<TSchema>;
}>;
declare const content$1: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (content?: ContentLike<TSchema>) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    where: typeof where$1<TSchema>;
    return: typeof _return$1<TSchema>;
    timeout: typeof timeout$1<TSchema>;
    parallel: typeof parallel$1<TSchema>;
}>;
declare const _merge$1: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (merge?: MergeLike<TSchema>) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    where: typeof where$1<TSchema>;
    return: typeof _return$1<TSchema>;
    timeout: typeof timeout$1<TSchema>;
    parallel: typeof parallel$1<TSchema>;
}>;
declare const patch$1: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (patch?: PatchLike<TSchema>) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    where: typeof where$1<TSchema>;
    return: typeof _return$1<TSchema>;
    timeout: typeof timeout$1<TSchema>;
    parallel: typeof parallel$1<TSchema>;
}>;
declare const set$1: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (set?: SetLike<TSchema>) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    unset: typeof unset$1<TSchema>;
    where: typeof where$1<TSchema>;
    return: typeof _return$1<TSchema>;
    timeout: typeof timeout$1<TSchema>;
    parallel: typeof parallel$1<TSchema>;
}>;
declare const unset$1: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (unset?: UnsetLike<TSchema>) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    where: typeof where$1<TSchema>;
    return: typeof _return$1<TSchema>;
    timeout: typeof timeout$1<TSchema>;
    parallel: typeof parallel$1<TSchema>;
}>;
declare const where$1: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (conditions?: WhereCondition<TSchema>[]) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    return: typeof _return$1<TSchema>;
    timeout: typeof timeout$1<TSchema>;
    parallel: typeof parallel$1<TSchema>;
}>;
declare const _return$1: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (type?: ReturnType) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    timeout: typeof timeout$1<TSchema>;
    parallel: typeof parallel$1<TSchema>;
}>;
declare const timeout$1: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (timeout?: DurationLike) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    parallel: typeof parallel$1<TSchema>;
}>;
declare const parallel$1: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (append?: any) => Builder<WithBuilderContext<TSchema>>;

declare const upsert: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (targets: TargetLike | TargetLike[]) => Builder<{
    content: typeof content<TSchema>;
    merge: typeof _merge<TSchema>;
    patch: typeof patch<TSchema>;
    set: typeof set<TSchema>;
    unset: typeof unset<TSchema>;
    where: typeof where<TSchema>;
    return: typeof _return<TSchema>;
    timeout: typeof timeout<TSchema>;
    parallel: typeof parallel<TSchema>;
}>;
declare const upsertOnly: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (target: TargetLike) => Builder<{
    content: typeof content<TSchema>;
    merge: typeof _merge<TSchema>;
    patch: typeof patch<TSchema>;
    set: typeof set<TSchema>;
    unset: typeof unset<TSchema>;
    where: typeof where<TSchema>;
    return: typeof _return<TSchema>;
    timeout: typeof timeout<TSchema>;
    parallel: typeof parallel<TSchema>;
}>;
declare const content: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (content?: ContentLike<TSchema>) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    where: typeof where<TSchema>;
    return: typeof _return<TSchema>;
    timeout: typeof timeout<TSchema>;
    parallel: typeof parallel<TSchema>;
}>;
declare const _merge: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (merge?: MergeLike<TSchema>) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    where: typeof where<TSchema>;
    return: typeof _return<TSchema>;
    timeout: typeof timeout<TSchema>;
    parallel: typeof parallel<TSchema>;
}>;
declare const patch: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (patch?: PatchLike<TSchema>) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    where: typeof where<TSchema>;
    return: typeof _return<TSchema>;
    timeout: typeof timeout<TSchema>;
    parallel: typeof parallel<TSchema>;
}>;
declare const set: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (set?: SetLike<TSchema>) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    unset: typeof unset<TSchema>;
    where: typeof where<TSchema>;
    return: typeof _return<TSchema>;
    timeout: typeof timeout<TSchema>;
    parallel: typeof parallel<TSchema>;
}>;
declare const unset: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (unset?: UnsetLike<TSchema>) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    where: typeof where<TSchema>;
    return: typeof _return<TSchema>;
    timeout: typeof timeout<TSchema>;
    parallel: typeof parallel<TSchema>;
}>;
declare const where: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (conditions?: WhereCondition<TSchema>[]) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    return: typeof _return<TSchema>;
    timeout: typeof timeout<TSchema>;
    parallel: typeof parallel<TSchema>;
}>;
declare const _return: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (type?: ReturnType) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    timeout: typeof timeout<TSchema>;
    parallel: typeof parallel<TSchema>;
}>;
declare const timeout: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (timeout?: DurationLike) => Builder<{
    toQuery: (query: RawQuery, ctx: BuilderContext<TSchema>) => () => Query<InferResult<TSchema>>;
    "~builder": (query: RawQuery, ctx: BuilderContext<TSchema>) => () => {
        query: RawQuery;
        ctx: BuilderContext<TSchema>;
    };
    parallel: typeof parallel<TSchema>;
}>;
declare const parallel: <TSchema extends SchemaContext>(query: RawQuery, ctx: BuilderContext<TSchema>) => (append?: any) => Builder<WithBuilderContext<TSchema>>;

type DefaultBuilder<TSchema extends SchemaContext = UnknownSchemaContext> = Builder<{
    create: typeof create<TSchema>;
    createOnly: typeof createOnly<TSchema>;
    delete: typeof _delete<TSchema>;
    deleteOnly: typeof deleteOnly<TSchema>;
    select: typeof select<TSchema>;
    selectValue: typeof selectValue<TSchema>;
    update: typeof update<TSchema>;
    updateOnly: typeof updateOnly<TSchema>;
    upsert: typeof upsert<TSchema>;
    upsertOnly: typeof upsertOnly<TSchema>;
}>;
declare const q: DefaultBuilder;
declare const createDefaultBuilder: <TSchema extends SchemaContext>(options?: {
    schema?: TSchema;
    connection?: Surrealize;
}) => DefaultBuilder<TSchema>;

declare const resolveQuery: <TOutput>(query: QueryLike<TOutput>) => Query<TOutput>;
/**
 * Convert a tagged template query to a prepared query by replacing variables with bindings.
 *
 * Also encode the variables to their surrealdb.js representation if possible.
 *
 * @param query The tagged template to convert.
 * @returns The compiled query (including the query string and the bindings object).
 */
declare const prepareQuery: (template: TaggedTemplate) => PreparedQuery;
/**
 * Convert a tagged template query list to a compiled query by replacing variables with bindings and wrapping it in a transaction.
 *
 * Also encode the variables to their surrealdb.js representation if possible.
 *
 * @param queries The tagged template queries to convert and wrap in a transaction.
 * @returns The compiled query (including the query string and the bindings object) as a transaction.
 */
declare const prepareTransaction: (queries: Query[]) => PreparedQuery;

type RepositoryWhere<TSchema extends RecordSchemaContext> = InferResult<TSchema> extends Record<string, unknown> ? DeepPartial<InferResult<TSchema>> | WhereCondition<TSchema>[] : Record<string, unknown> | WhereCondition[];
type RepositoryFindByOptions = {
    limit?: number;
    start?: number;
    parallel?: boolean;
    tempfiles?: boolean;
    timeout?: DurationLike;
};
type RepositoryFindOneByOptions = Omit<RepositoryFindByOptions, "limit">;

type RepositoryOptions<TSchema extends RecordSchemaContext> = {
    connection?: Surrealize;
    schema?: TSchema;
};
/**
 * An repository is an easy to use interface to communicate with the database.
 *
 * It provides a simple and easy to use interface to create, update, delete and query records.
 */
declare class Repository<TTable extends string, TSchema extends RecordSchemaContext<RecordId<TTable>>> {
    #private;
    readonly table: Table<InferTableFromSchema<TSchema>>;
    readonly q: DefaultBuilder<TSchema>;
    readonly schema?: TSchema;
    readonly connection?: Surrealize;
    constructor(table: TableLike<TTable>, options?: RepositoryOptions<TSchema>);
    find(options?: RepositoryFindByOptions): Query<InferResult<TSchema>[]>;
    findBy(where?: RepositoryWhere<TSchema>, options?: RepositoryFindByOptions): Query<InferResult<TSchema>[]>;
    findOneBy(where: RepositoryWhere<TSchema>, options?: RepositoryFindOneByOptions): Query<InferResult<TSchema> | undefined>;
    findById(id: RecordIdLike<InferTableFromSchema<TSchema>>): Query<InferResult<TSchema> | undefined>;
    create(record: OptionalId<InferInput<TSchema>>): Query<InferResult<TSchema>>;
    update(record: RequiredId<InferResult<TSchema>>): Query<InferResult<TSchema>>;
    updateBy(where: RepositoryWhere<TSchema>, set: SetLike<TSchema>): Query<InferResult<TSchema>[]>;
    updateById(id: RecordIdLike<InferTableFromSchema<TSchema>>, set: SetLike<TSchema>): Query<InferResult<TSchema>>;
    upsert(record: RequiredId<InferInput<TSchema>>): Query<InferResult<TSchema>>;
    upsertBy(where: RepositoryWhere<TSchema>, set: SetLike<TSchema>): Query<InferResult<TSchema>[]>;
    delete(record: RequiredId<InferInput<TSchema>>): Query<InferResult<TSchema> | undefined>;
    deleteBy(where: RepositoryWhere<TSchema>): Query<undefined>;
    deleteById(id: RecordIdLike<InferTableFromSchema<TSchema>>): Query<undefined>;
}

declare const createSchemaContext: <TResult, TInput = TResult>(schema: StandardSchema<unknown, TResult>) => SchemaContext<TResult, TInput>;

/**
 * Indicates that the value should not be flattened and should be used as is.
 *
 * This is especially useful on update operations,
 * where you want to set a whole object instead of updating individual fields.
 *
 * @param value The value which should not be flattened.
 * @returns The wrapped value which indicates the flatting
 *          functionality to keep the value as is.
 */
declare const keep: <const T extends object>(value: T) => T;
/**
 * Flatten an object making all nested values available at the top level
 * via dot notation.
 *
 * If you want to keep a nested value as is, use the `keep` function.
 *
 * For example:
 * ```ts
 * const source = {
 *   test: 1,
 *   nested: {
 *     test: 2,
 *     nested: {
 *       test: 3
 *     }
 *   }
 * }
 *
 * flatten(source)
 * // result: {
 * //   test: 1,
 * //   "nested.test": 2,
 * //   "nested.nested.test": 3
 * // }
 * ```
 *
 * @param source The object to flatten.
 * @returns The flattened object.
 */
declare const flatten: (source: Record<string, unknown>) => Record<string, unknown>;

export { AbstractEngine, type AnyRecord, type AnySchemaContext, type Auth, CborCodec, type CompareOperator, ConnectionError, type ConnectionState, ConnectionStatus, DatabaseError, Duration, type DurationLike, type DurationValue, type EmitterEvents, type EngineOptions, EventEmitter, type EventListener, type EventUnsubscriber, type FormatVariableConverter, HttpEngine, type HttpEngineOptions, type InferInput, type InferQueriesOutput, type InferQueryOutput, type InferResult, type InferStandardInput, type InferStandardOutput, type PreparedQuery, type QueriesLike, Query, QueryError, type QueryLike, QueryList, type QueryListOptions, type QueryOptions, type _Record as Record, RecordId, type RecordIdLike, type RecordIdValue, Repository, type RepositoryFindByOptions, type RepositoryFindOneByOptions, type RepositoryOptions, type RepositoryWhere, type ResolvedTarget, type RpcRequest, type RpcResponse, type RpcResponseError, type RpcResponseOk, type SchemaContext, type StandardSchema, Surrealize, type SurrealizeOptions, Table, type TableLike, type TaggedTemplate, type TargetLike, UUID, type UnknownSchemaContext, ValidationError, WebSocketEngine, type WebSocketEngineOptions, type WhereAnd, type WhereCompare, type WhereCondition, type WhereOr, type WhereState, type WithId, and, buildWhere, cmp, createDefaultBuilder, createSchemaContext, eq, eqs, flatten, format, gt, gte, isEmpty, keep, lt, lte, merge, mergeSchema, neq, or, parseSchema, prepareQuery, prepareTransaction, q, resolveQuery, resolveTarget, surql, tag, tagString };