/**
 * Copyright (c) "Neo4j"
 * Neo4j Sweden AB [https://neo4j.com]
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import { auth, BookmarkManager, bookmarkManager, BookmarkManagerConfig, authTokenManagers, AuthTokenManager, AuthTokenManagers, AuthTokenAndExpiration, Connection, ConnectionProvider, Date, DateTime, Driver, Duration, error, int, Integer, internal, isDate, isDateTime, isDuration, isInt, isLocalDateTime, isLocalTime, isNode, isPath, isPathSegment, isPoint, isRelationship, isRetriableError, isRetryableError, isTime, isUnboundRelationship, LocalDateTime, LocalTime, Neo4jError, Node, Notification, notificationCategory, NotificationCategory, NotificationPosition, notificationSeverityLevel, NotificationSeverityLevel, Path, PathSegment, Plan, Point, ProfiledPlan, QueryConfig, QueryResult, QueryStatistics, Record, RecordShape, Relationship, Result, ResultObserver, ResultSummary, ResultTransformer, resultTransformers, ServerInfo, Session, SessionConfig, Time, types as coreTypes, UnboundRelationship, Transaction, TransactionConfig, TransactionPromise, ManagedTransaction } from 'neo4j-driver-core';
import { logging } from './logging';
import { HttpUrl, Wrapper, WrapperSession, WrapperConfig, WrapperSessionConfig } from './types';
type AuthToken = coreTypes.AuthToken;
type Config = coreTypes.Config;
type TrustStrategy = coreTypes.TrustStrategy;
type EncryptionLevel = coreTypes.EncryptionLevel;
type SessionMode = coreTypes.SessionMode;
type Logger = internal.logger.Logger;
declare function wrapper(url: HttpUrl | string, authToken: AuthToken | AuthTokenManager, config?: Config): Wrapper;
/**
 * Object containing constructors for all neo4j types.
 */
declare const types: {
    Node: typeof Node;
    Relationship: typeof Relationship;
    UnboundRelationship: typeof UnboundRelationship;
    PathSegment: typeof PathSegment;
    Path: typeof Path;
    Result: typeof Result;
    ResultSummary: typeof ResultSummary;
    Record: typeof Record;
    Point: typeof Point;
    Date: typeof Date;
    DateTime: typeof DateTime;
    Duration: typeof Duration;
    LocalDateTime: typeof LocalDateTime;
    LocalTime: typeof LocalTime;
    Time: typeof Time;
    Integer: typeof Integer;
};
/**
 * Object containing string constants representing session access modes.
 */
declare const session: {
    READ: coreTypes.SessionMode;
    WRITE: coreTypes.SessionMode;
};
/**
 * Object containing functions to work with {@link Integer} objects.
 */
declare const integer: {
    toNumber: typeof Integer.toNumber;
    toString: typeof Integer.toString;
    inSafeRange: typeof Integer.inSafeRange;
};
/**
 * Object containing functions to work with spatial types, like {@link Point}.
 */
declare const spatial: {
    isPoint: typeof isPoint;
};
/**
 * Object containing functions to work with temporal types, like {@link Time} or {@link Duration}.
 */
declare const temporal: {
    isDuration: typeof isDuration;
    isLocalTime: typeof isLocalTime;
    isTime: typeof isTime;
    isDate: typeof isDate;
    isLocalDateTime: typeof isLocalDateTime;
    isDateTime: typeof isDateTime;
};
/**
 * Object containing functions to work with graph types, like {@link Node} or {@link Relationship}.
 */
declare const graph: {
    isNode: typeof isNode;
    isPath: typeof isPath;
    isPathSegment: typeof isPathSegment;
    isRelationship: typeof isRelationship;
    isUnboundRelationship: typeof isUnboundRelationship;
};
declare const forExport: {
    authTokenManagers: AuthTokenManagers;
    int: typeof Integer.fromValue;
    isInt: typeof Integer.isInteger;
    isPoint: typeof isPoint;
    isDuration: typeof isDuration;
    isLocalTime: typeof isLocalTime;
    isTime: typeof isTime;
    isDate: typeof isDate;
    isLocalDateTime: typeof isLocalDateTime;
    isDateTime: typeof isDateTime;
    isNode: typeof isNode;
    isPath: typeof isPath;
    isPathSegment: typeof isPathSegment;
    isRelationship: typeof isRelationship;
    isUnboundRelationship: typeof isUnboundRelationship;
    integer: {
        toNumber: typeof Integer.toNumber;
        toString: typeof Integer.toString;
        inSafeRange: typeof Integer.inSafeRange;
    };
    Neo4jError: typeof Neo4jError;
    isRetriableError: typeof Neo4jError.isRetriable;
    isRetryableError: typeof Neo4jError.isRetryable;
    auth: {
        basic: (username: string, password: string, realm?: string | undefined) => {
            scheme: string;
            principal: string;
            credentials: string;
            realm: string;
        } | {
            scheme: string;
            principal: string;
            credentials: string;
            realm?: undefined;
        };
        kerberos: (base64EncodedTicket: string) => {
            scheme: string;
            principal: string;
            credentials: string;
        };
        bearer: (base64EncodedToken: string) => {
            scheme: string;
            credentials: string;
        };
        none: () => {
            scheme: string;
        };
        custom: (principal: string, credentials: string, realm: string, scheme: string, parameters?: object | undefined) => any;
    };
    logging: {
        console: (level: coreTypes.LogLevel) => {
            level: coreTypes.LogLevel;
            logger: (level: coreTypes.LogLevel, message: string) => void;
        };
    };
    types: {
        Node: typeof Node;
        Relationship: typeof Relationship;
        UnboundRelationship: typeof UnboundRelationship;
        PathSegment: typeof PathSegment;
        Path: typeof Path;
        Result: typeof Result;
        ResultSummary: typeof ResultSummary;
        Record: typeof Record;
        Point: typeof Point;
        Date: typeof Date;
        DateTime: typeof DateTime;
        Duration: typeof Duration;
        LocalDateTime: typeof LocalDateTime;
        LocalTime: typeof LocalTime;
        Time: typeof Time;
        Integer: typeof Integer;
    };
    session: {
        READ: coreTypes.SessionMode;
        WRITE: coreTypes.SessionMode;
    };
    error: {
        SERVICE_UNAVAILABLE: string;
        SESSION_EXPIRED: string;
        PROTOCOL_ERROR: string;
    };
    graph: {
        isNode: typeof isNode;
        isPath: typeof isPath;
        isPathSegment: typeof isPathSegment;
        isRelationship: typeof isRelationship;
        isUnboundRelationship: typeof isUnboundRelationship;
    };
    spatial: {
        isPoint: typeof isPoint;
    };
    temporal: {
        isDuration: typeof isDuration;
        isLocalTime: typeof isLocalTime;
        isTime: typeof isTime;
        isDate: typeof isDate;
        isLocalDateTime: typeof isLocalDateTime;
        isDateTime: typeof isDateTime;
    };
    Driver: typeof Driver;
    Result: typeof Result;
    Record: typeof Record;
    ResultSummary: typeof ResultSummary;
    Transaction: typeof Transaction;
    TransactionPromise: typeof TransactionPromise;
    ManagedTransaction: typeof ManagedTransaction;
    Node: typeof Node;
    Relationship: typeof Relationship;
    UnboundRelationship: typeof UnboundRelationship;
    PathSegment: typeof PathSegment;
    Path: typeof Path;
    Integer: typeof Integer;
    Plan: typeof Plan;
    ProfiledPlan: typeof ProfiledPlan;
    QueryStatistics: typeof QueryStatistics;
    Notification: typeof Notification;
    ServerInfo: typeof ServerInfo;
    Session: typeof Session;
    Point: typeof Point;
    Duration: typeof Duration;
    LocalTime: typeof LocalTime;
    Time: typeof Time;
    Date: typeof Date;
    LocalDateTime: typeof LocalDateTime;
    DateTime: typeof DateTime;
    ConnectionProvider: typeof ConnectionProvider;
    Connection: typeof Connection;
    bookmarkManager: typeof bookmarkManager;
    resultTransformers: {
        eagerResultTransformer<Entries extends RecordShape<PropertyKey, any> = RecordShape<PropertyKey, any>>(): ResultTransformer<import("neo4j-driver-core").EagerResult<Entries>>;
        eager<Entries_1 extends RecordShape<PropertyKey, any> = RecordShape<PropertyKey, any>>(): ResultTransformer<import("neo4j-driver-core").EagerResult<Entries_1>>;
        mappedResultTransformer<R = Record<RecordShape<PropertyKey, any>, PropertyKey, RecordShape<PropertyKey, number>>, T = {
            records: R[];
            keys: string[];
            summary: ResultSummary<Integer>;
        }>(config: {
            map?: ((rec: Record<RecordShape<PropertyKey, any>, PropertyKey, RecordShape<PropertyKey, number>>) => R | undefined) | undefined;
            collect?: ((records: R[], summary: ResultSummary<Integer>, keys: string[]) => T) | undefined;
        }): ResultTransformer<T>;
        mapped<R_1 = Record<RecordShape<PropertyKey, any>, PropertyKey, RecordShape<PropertyKey, number>>, T_1 = {
            records: R_1[];
            keys: string[];
            summary: ResultSummary<Integer>;
        }>(config: {
            map?: ((rec: Record<RecordShape<PropertyKey, any>, PropertyKey, RecordShape<PropertyKey, number>>) => R_1 | undefined) | undefined;
            collect?: ((records: R_1[], summary: ResultSummary<Integer>, keys: string[]) => T_1) | undefined;
        }): ResultTransformer<T_1>;
        first<Entries_2 extends RecordShape<PropertyKey, any> = RecordShape<PropertyKey, any>>(): ResultTransformer<Record<Entries_2, keyof Entries_2, RecordShape<keyof Entries_2, number>> | undefined>;
        summary<T_2 extends import("neo4j-driver-core/types/graph-types").NumberOrInteger = Integer>(): ResultTransformer<ResultSummary<T_2>>;
        hydrated<T_3 extends {} = Object>(rules: import("neo4j-driver-core").Rules): ResultTransformer<{
            records: T_3[];
            summary: ResultSummary<Integer>;
        }>;
        hydrated<T_4 extends {} = Object>(genericConstructor: import("neo4j-driver-core/types/mapping.highlevel").GenericConstructor<T_4>, rules?: import("neo4j-driver-core").Rules | undefined): ResultTransformer<{
            records: T_4[];
            summary: ResultSummary<Integer>;
        }>;
    };
    notificationCategory: {
        UNKNOWN: "UNKNOWN";
        HINT: "HINT";
        UNRECOGNIZED: "UNRECOGNIZED";
        UNSUPPORTED: "UNSUPPORTED";
        PERFORMANCE: "PERFORMANCE";
        TOPOLOGY: "TOPOLOGY";
        SECURITY: "SECURITY";
        DEPRECATION: "DEPRECATION";
        GENERIC: "GENERIC";
        SCHEMA: "SCHEMA";
    };
    notificationSeverityLevel: {
        UNKNOWN: "UNKNOWN";
        WARNING: "WARNING";
        INFORMATION: "INFORMATION";
    };
    wrapper: typeof wrapper;
};
export { authTokenManagers, int, isInt, isPoint, isDuration, isLocalTime, isTime, isDate, isLocalDateTime, isDateTime, isNode, isPath, isPathSegment, isRelationship, isUnboundRelationship, integer, Neo4jError, isRetriableError, isRetryableError, auth, logging, types, session, error, graph, spatial, temporal, Driver, Result, Record, ResultSummary, Node, Relationship, UnboundRelationship, PathSegment, Path, Integer, Plan, ProfiledPlan, QueryStatistics, Notification, ServerInfo, Session, Transaction, TransactionPromise, ManagedTransaction, Point, Duration, LocalTime, Time, Date, LocalDateTime, DateTime, ConnectionProvider, Connection, bookmarkManager, resultTransformers, notificationCategory, notificationSeverityLevel, wrapper };
export type { QueryResult, AuthToken, AuthTokenManager, AuthTokenManagers, AuthTokenAndExpiration, Config, EncryptionLevel, TrustStrategy, SessionMode, ResultObserver, NotificationPosition, BookmarkManager, BookmarkManagerConfig, SessionConfig, QueryConfig, RecordShape, ResultTransformer, TransactionConfig, NotificationCategory, NotificationSeverityLevel, Logger, HttpUrl, Wrapper, WrapperConfig, WrapperSession, WrapperSessionConfig };
export default forExport;