@neo4j-labs/experimental-query-api-wrapper 0.0.1-alpha01

package/types/http-connection/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 HttpConnectionProvider from "./connection-provider.http";
+export { HttpConnectionProvider };

package/types/http-connection/query.codec.d.ts

@@ -0,0 +1,152 @@
+/**
+ * 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 { Node, Relationship, types, Integer, Time, Date, LocalTime, Point, DateTime, LocalDateTime, Duration, Path } from "neo4j-driver-core";
+import { RunQueryConfig } from "neo4j-driver-core/types/connection";
+type RawQueryValueTypes = 'Null' | 'Boolean' | 'Integer' | 'Float' | 'String' | 'Time' | 'Date' | 'LocalTime' | 'ZonedDateTime' | 'OffsetDateTime' | 'LocalDateTime' | 'Duration' | 'Point' | 'Base64' | 'Map' | 'List' | 'Node' | 'Relationship' | 'Path';
+type PointShape = {
+    srid: number;
+    x: string;
+    y: string;
+    z?: string;
+};
+type NodeShape = {
+    _element_id: string;
+    _labels: string[];
+    _properties?: Record<string, RawQueryValue>;
+};
+type RelationshipShape = {
+    _element_id: string;
+    _start_node_element_id: string;
+    _end_node_element_id: string;
+    _type: string;
+    _properties?: Record<string, RawQueryValue>;
+};
+type PathShape = (RawQueryRelationship | RawQueryNode)[];
+type RawQueryValueDef<T extends RawQueryValueTypes, V extends unknown> = {
+    $type: T;
+    _value: V;
+};
+type RawQueryNull = RawQueryValueDef<'Null', null>;
+type RawQueryBoolean = RawQueryValueDef<'Boolean', boolean>;
+type RawQueryInteger = RawQueryValueDef<'Integer', string>;
+type RawQueryFloat = RawQueryValueDef<'Float', string>;
+type RawQueryString = RawQueryValueDef<'String', string>;
+type RawQueryTime = RawQueryValueDef<'Time', string>;
+type RawQueryDate = RawQueryValueDef<'Date', string>;
+type RawQueryLocalTime = RawQueryValueDef<'LocalTime', string>;
+type RawQueryZonedDateTime = RawQueryValueDef<'ZonedDateTime', string>;
+type RawQueryOffsetDateTime = RawQueryValueDef<'OffsetDateTime', string>;
+type RawQueryLocalDateTime = RawQueryValueDef<'LocalDateTime', string>;
+type RawQueryDuration = RawQueryValueDef<'Duration', string>;
+type RawQueryPoint = RawQueryValueDef<'Point', PointShape>;
+type RawQueryBinary = RawQueryValueDef<'Base64', string>;
+interface RawQueryMap extends RawQueryValueDef<'Map', Record<string, RawQueryValue>> {
+}
+interface RawQueryList extends RawQueryValueDef<'List', RawQueryValue[]> {
+}
+type RawQueryNode = RawQueryValueDef<'Node', NodeShape>;
+type RawQueryRelationship = RawQueryValueDef<'Relationship', RelationshipShape>;
+type RawQueryPath = RawQueryValueDef<'Path', PathShape>;
+type RawQueryValue = RawQueryNull | RawQueryBoolean | RawQueryInteger | RawQueryFloat | RawQueryString | RawQueryTime | RawQueryDate | RawQueryLocalTime | RawQueryZonedDateTime | RawQueryOffsetDateTime | RawQueryLocalDateTime | RawQueryDuration | RawQueryPoint | RawQueryBinary | RawQueryMap | RawQueryList | RawQueryNode | RawQueryRelationship | RawQueryPath;
+type Counters = {
+    containsUpdates: boolean;
+    nodesCreated: number;
+    nodesDeleted: number;
+    propertiesSet: number;
+    relationshipsCreated: number;
+    relationshipsDeleted: number;
+    labelsAdded: number;
+    labelsRemoved: number;
+    indexesAdded: number;
+    indexesRemoved: number;
+    constraintsAdded: number;
+    constraintsRemoved: number;
+    containsSystemUpdates: boolean;
+    systemUpdates: number;
+};
+type ProfiledQueryPlan = {
+    dbHits: number;
+    records: number;
+    hasPageCacheStats: boolean;
+    pageCacheHits: number;
+    pageCacheMisses: number;
+    pageCacheHitRatio: number;
+    time: number;
+    operatorType: string;
+    arguments: Record<string, unknown>;
+    identifiers: string[];
+    children: ProfiledQueryPlan[];
+};
+type RawQueryData = {
+    fields: string[];
+    values: RawQueryValue[];
+};
+export type RawQueryResponse = {
+    data: RawQueryData;
+    counters: Counters;
+    bookmarks: string[];
+    profiledQueryPlan?: ProfiledQueryPlan;
+    errors?: [];
+    notifications?: unknown[];
+    [str: string]: unknown;
+};
+export declare class QueryResponseCodec {
+    private _config;
+    private _contentType;
+    private _rawQueryResponse;
+    constructor(_config: types.InternalConfig, _contentType: string, _rawQueryResponse: RawQueryResponse);
+    get hasError(): boolean;
+    get error(): Error;
+    get keys(): string[];
+    stream(): Generator<any[]>;
+    get meta(): Record<string, unknown>;
+    private _decodeStats;
+    private _decodeProfile;
+    private _decodeValue;
+    _decodeInteger(value: string): Integer | number | bigint;
+    _decodeFloat(value: string): number;
+    _decodeTime(value: string): Time<Integer | bigint | number>;
+    _decodeDate(value: string): Date<Integer | bigint | number>;
+    _decodeLocalTime(value: string): LocalTime<Integer | bigint | number>;
+    _decodeZonedDateTime(value: string): DateTime<Integer | bigint | number>;
+    _decodeOffsetDateTime(value: string): DateTime<Integer | bigint | number>;
+    _decodeLocalDateTime(value: string): LocalDateTime<Integer | bigint | number>;
+    _decodeDuration(value: string): Duration<Integer | bigint | number>;
+    _decodeMap(value: Record<string, RawQueryValue>): Record<string, unknown>;
+    _decodePoint(value: PointShape): Point<Integer | bigint | number>;
+    _decodeBase64(value: string): Uint8Array;
+    _decodeList(value: RawQueryValue[]): unknown[];
+    _decodeNode(value: NodeShape): Node<bigint | number | Integer>;
+    _decodeRelationship(value: RelationshipShape): Relationship<bigint | number | Integer>;
+    _decodePath(value: PathShape): Path<bigint | number | Integer>;
+    _normalizeInteger(integer: Integer): Integer | number | bigint;
+}
+export declare class QueryRequestCodec {
+    private _auth;
+    private _query;
+    private _parameters?;
+    private _config?;
+    private _body?;
+    constructor(_auth: types.AuthToken, _query: string, _parameters?: Record<string, unknown> | undefined, _config?: RunQueryConfig | undefined);
+    get contentType(): string;
+    get accept(): string;
+    get authorization(): string;
+    get body(): Record<string, unknown>;
+    _encodeParameters(parameters: Record<string, unknown>): Record<string, RawQueryValue>;
+    _encodeValue(value: unknown): RawQueryValue;
+}
+export {};

package/types/http-connection/stream-observers.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 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 { ResultObserver, internal } from "neo4j-driver-core";
+export interface ResultStreamObserverConfig {
+    highRecordWatermark: number;
+    lowRecordWatermark: number;
+    beforeError?: (error: Error) => void;
+    afterComplete?: (metadata: unknown) => void;
+    server: internal.serverAddress.ServerAddress;
+}
+export declare class ResultStreamObserver implements internal.observer.ResultStreamObserver {
+    private _paused;
+    private _queuedRecords;
+    private _completed;
+    private _keys;
+    private _highRecordWatermark;
+    private _lowRecordWatermark;
+    private _resultObservers;
+    private _metadata?;
+    private _error?;
+    private _beforeError?;
+    private _afterComplete?;
+    private _server;
+    constructor(config: ResultStreamObserverConfig);
+    get completed(): boolean;
+    get paused(): boolean;
+    cancel(): void;
+    pause(): void;
+    resume(): void;
+    prepareToHandleSingleResponse: () => void;
+    markCompleted(): void;
+    subscribe(observer: ResultObserver): void;
+    onKeys(keys: any[]): void;
+    onNext(rawRecord: any[]): void;
+    onError(error: Error): void;
+    onCompleted(meta: any): void;
+}

package/types/index.d.ts

@@ -0,0 +1,247 @@
+/**
+ * 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, 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 } 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, 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;
+    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;
+    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>>;
+        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>;
+    };
+    notificationCategory: {
+        UNKNOWN: "UNKNOWN";
+        HINT: "HINT";
+        UNRECOGNIZED: "UNRECOGNIZED";
+        UNSUPPORTED: "UNSUPPORTED";
+        PERFORMANCE: "PERFORMANCE";
+        TOPOLOGY: "TOPOLOGY";
+        SECURITY: "SECURITY";
+        DEPRECATION: "DEPRECATION";
+        GENERIC: "GENERIC";
+    };
+    notificationSeverityLevel: {
+        WARNING: "WARNING";
+        INFORMATION: "INFORMATION";
+        UNKNOWN: "UNKNOWN";
+    };
+    wrapper: typeof wrapper;
+};
+export { authTokenManagers, int, isInt, isPoint, isDuration, isLocalTime, isTime, isDate, isLocalDateTime, isDateTime, isNode, isPath, isPathSegment, isRelationship, isUnboundRelationship, integer, Neo4jError, isRetriableError, auth, logging, types, session, error, graph, spatial, temporal, Driver, Result, Record, ResultSummary, Node, Relationship, UnboundRelationship, PathSegment, Path, Integer, Plan, ProfiledPlan, QueryStatistics, Notification, ServerInfo, Session, 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, NotificationCategory, NotificationSeverityLevel, Logger, HttpUrl, Wrapper, WrapperConfig, WrapperSession, WrapperSessionConfig };
+export default forExport;

package/types/logging.d.ts

@@ -0,0 +1,14 @@
+import { types as coreTypes } from 'neo4j-driver-core';
+type LogLevel = coreTypes.LogLevel;
+/**
+ * Object containing predefined logging configurations. These are expected to be used as values of the driver config's `logging` property.
+ * @property {function(level: ?string): object} console the function to create a logging config that prints all messages to `console.log` with
+ * timestamp, level and message. It takes an optional `level` parameter which represents the maximum log level to be logged. Default value is 'info'.
+ */
+export declare const logging: {
+    console: (level: LogLevel) => {
+        level: coreTypes.LogLevel;
+        logger: (level: LogLevel, message: string) => void;
+    };
+};
+export {};

package/types/types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 { Driver, Session, SessionConfig, Config, ServerInfo } from "neo4j-driver-core";
+type Disposable = {
+    [Symbol.asyncDispose](): Promise<void>;
+};
+type VerifyConnectivity = {
+    verifyConnectivity(config: {
+        database: string | undefined;
+    } | undefined): Promise<ServerInfo>;
+};
+type HttpUrl = `http://${string}` | `https://${string}`;
+type WrapperSession = Pick<Session, 'run' | 'lastBookmarks' | 'close'> & Disposable;
+type WrapperSessionConfig = Pick<SessionConfig, 'bookmarks' | 'impersonatedUser' | 'bookmarkManager' | 'defaultAccessMode'> & {
+    database: string;
+};
+type Wrapper = Pick<Driver, 'close'> & Disposable & VerifyConnectivity & {
+    session(config: WrapperSessionConfig): WrapperSession;
+};
+type WrapperConfig = Pick<Config, 'encrypted' | 'useBigInt' | 'disableLosslessIntegers'>;
+export type { HttpUrl, WrapperSession, WrapperSessionConfig, Wrapper, WrapperConfig };

package/types/wrapper-session.impl.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 { RecordShape, TransactionConfig, Result, Session } from "neo4j-driver-core";
+import { Query } from "neo4j-driver-core/types/types";
+import { WrapperSession } from "./types";
+export default class WrapperSessionImpl implements WrapperSession {
+    private readonly session;
+    constructor(session: Session);
+    [Symbol.asyncDispose](): Promise<void>;
+    run<R extends RecordShape = RecordShape>(query: Query, parameters?: any, transactionConfig?: TransactionConfig | undefined): Result<R>;
+    lastBookmarks(): string[];
+    close(): Promise<void>;
+}

package/types/wrapper.impl.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 { Driver, ServerInfo } from "neo4j-driver-core";
+import { Wrapper, WrapperSession, WrapperSessionConfig } from "./types";
+export declare class WrapperImpl implements Wrapper {
+    private readonly driver;
+    constructor(driver: Driver);
+    close(): Promise<void>;
+    verifyConnectivity(config: {
+        database: string;
+    }): Promise<ServerInfo>;
+    [Symbol.asyncDispose](): Promise<void>;
+    session(config: WrapperSessionConfig): WrapperSession;
+}