/*!
 * Copyright 2024 Google LLC. All Rights Reserved.
 *
 * 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 { Database, Session, Transaction } from '.';
import { MultiplexedSessionInterface } from './multiplexed-session';
import { SessionPoolInterface, SessionPoolOptions } from './session-pool';
import { SessionPoolConstructor } from './database';
declare const common: any;
/**
 * @callback GetSessionCallback
 * @param {?Error} error Request error, if any.
 * @param {Session} session The read-write session.
 * @param {Transaction} transaction The transaction object.
 */
export interface GetSessionCallback {
    (err: Error | null, session?: Session | null, transaction?: Transaction | null): void;
}
/**
 * Interface for implementing session-factory logic.
 *
 * @interface SessionFactoryInterface
 */
export interface SessionFactoryInterface {
    /**
     * When called returns a session.
     *
     * @name SessionFactoryInterface#getSession
     * @param {GetSessionCallback} callback The callback function.
     */
    getSession(callback: GetSessionCallback): void;
    /**
     * When called returns a session for paritioned dml.
     *
     * @name SessionFactoryInterface#getSessionForPartitionedOps
     * @param {GetSessionCallback} callback The callback function.
     */
    getSessionForPartitionedOps(callback: GetSessionCallback): void;
    /**
     * When called returns the pool object.
     *
     * @name SessionFactoryInterface#getPool
     */
    getPool(): SessionPoolInterface;
    /**
     * To be called when releasing a session.
     *
     * @name SessionFactoryInterface#release
     * @param {Session} session The session to be released.
     */
    release(session: Session): void;
    /**
     * When called returns if the multiplexed is enabled or not.
     *
     * @name SessionFactoryInterface#isMultiplexedEnabled
     */
    isMultiplexedEnabled(): boolean;
}
/**
 * Creates a SessionFactory object to manage the creation of
 *      session-pool and multiplexed session.
 *
 * @class
 *
 * @param {Database} database Database object.
 * @param {String} name Name of the database.
 * @param {SessionPoolOptions|SessionPoolInterface} options Session pool
 *     configuration options or custom pool inteface.
 */
export declare class SessionFactory extends common.GrpcServiceObject implements SessionFactoryInterface {
    multiplexedSession_: MultiplexedSessionInterface;
    pool_: SessionPoolInterface;
    isMultiplexed: boolean;
    isMultiplexedPartitionOps: boolean;
    constructor(database: Database, name: String, poolOptions?: SessionPoolConstructor | SessionPoolOptions);
    /**
     * Retrieves a session, either a regular session or a multiplexed session, based on the environment variable configuration.
     *
     * If the environment variable `GOOGLE_CLOUD_SPANNER_MULTIPLEXED_SESSIONS` is set to `true`, the method will attempt to
     * retrieve a multiplexed session. Otherwise, it will retrieve a session from the regular pool.
     *
     * @param {GetSessionCallback} callback The callback function.
     */
    getSession(callback: GetSessionCallback): void;
    /**
     * Retrieves a session for partitioned operations, selecting the appropriate session type
     * based on whether multiplexed sessions are enabled.
     *
     * If multiplexed sessions are enabled for partitioned ops this methods delegates the request to `getSession()`, which returns
     * either a multiplexed session or a regular session based on the configuration.
     *
     * If the multiplexed sessions are disabled, a session is retrieved from the regular session pool.
     *
     * @param {GetSessionCallback} callback The callback function.
     */
    getSessionForPartitionedOps(callback: GetSessionCallback): void;
    /**
     * Returns the regular session pool object.
     *
     * @returns {SessionPoolInterface} The session pool used by current instance.
     */
    getPool(): SessionPoolInterface;
    /**
     * Releases a regular session back to the session pool.
     *
     * This methods does not release a multiplexed session.
     *
     * It returns a session to the pool after it is no longer needed.
     * It is a no-op for multiplexed sessions.
     *
     * @param {Session} session - The session to be released. This should be an instance of `Session` that was
     * previously acquired from the session pool.
     *
     * @throws {Error} If the session is invalid or cannot be released.
     */
    release(session: Session): void;
    /**
     * Returns if a multiplexed is enabled or not.
     *
     * This method returns true if multiplexed session is enabled, otherwise returns false
     *
     * @returns {boolean}
     */
    isMultiplexedEnabled(): boolean;
}
export {};