import { Service } from '../Core/index';
import { GdaCellRequest, GdaCellsRequest, GdaCellsResult, GdaColumnRequest, GdaFilterRequest, GdaFilterResult, GdaGet, GdaGetResult, GdaList, GdaListResult, GdaMultiGetRequest, GdaMultiGetResult, GdaPut, GdaPuts, GdaPutsResult, GdaRange, GdaRangeResult, GdaReduceRequest, GdaReduceResult, GdaRemoveRange, GdaRowRequest } from './GdaTypes';
/**
 * Generic Data Access
 *
 * Generic Data Access Service : NoSQL storage
 * */
export declare class Gda extends Service {
    /**
     * Get deployment type associated to Gda service
     * @return {string}
     */
    static readonly DEPLOYMENT_TYPE: string;
    /**
     * Get default deployment id associated to Gda service
     * @return {string}
     */
    static readonly DEFAULT_DEPLOYMENT_ID: string;
    /**
     * GDA User API
     *
     * User API for Generic Data Access.
     * The data are stored on a per-user basis.
     * Users can put, get, list their data.
     * @access public
     * */
    /**
     * Filters a range of rows
     *
     * Similar to range, but rows can be filtered out according to a developer-supplied predicate.
     * A range consists of consecutive rows from the start key (inclusive) to the stop key (exclusive).
     * You can specify partial keys for the start and stop fields.
     * @access public
     * */
    filter(body: GdaFilterRequest): Promise<GdaFilterResult>;
    /**
     * Asks for a data row
     *
     * Returns a full data row.
     * @access public
     * */
    get(body: GdaGet): Promise<GdaGetResult>;
    /**
     * Asks for a data cell
     *
     * Returns a precise list of cells from a column in a data row.
     * @access public
     * */
    getCells(body: GdaCellsRequest): Promise<GdaCellsResult>;
    /**
     * Increments an integer value
     *
     * Increments a cell 64-bit signed integer value and returns the result in the data field.
     * The increment is atomic : if you concurrently increment 10 times a value by 1, the final result will be the initial value plus 10. The actual individual resulting values seen by the 10 concurrent callers may vary discontinuously, with duplicates : at least one of them will see the final (+10) result.
     * @access public
     * */
    inc(body: GdaPut): Promise<GdaPut>;
    /**
     * Asks for a list of rows
     *
     * Returns a paginated list of rows from the given table.
     * @access public
     * */
    list(body: GdaList): Promise<GdaListResult>;
    /**
     * Asks for several data rows
     *
     * Returns full data rows, in the order they were asked.
     * @access public
     * */
    mget(body: GdaMultiGetRequest): Promise<GdaMultiGetResult>;
    /**
     * Puts some data into a cell
     *
     * Creates or replaces the contents of a particular cell.
     * @access public
     * */
    put(body: GdaPut): Promise<GdaPut>;
    /**
     * Puts several rows
     *
     * Creates or replaces the (maybe partial) contents of a collection of rows.
     * This method only creates or replaces cells for non-null input values.
     * @access public
     * */
    puts(body: GdaPuts): Promise<GdaPutsResult>;
    /**
     * Asks for a range of rows
     *
     * Returns a paginated range of rows from the given table.
     * A range consists of consecutive rows from the start key (inclusive) to the stop key (exclusive).
     * You can specify partial keys for the start and stop fields.
     * @access public
     * */
    range(body: GdaRange): Promise<GdaRangeResult>;
    /**
     * Reduces a range of rows
     *
     * Returns a computed single reduced result from a range of rows from the given table.
     * A range consists of consecutive rows from the start key (inclusive) to the stop key (exclusive).
     * You can specify partial keys for the start and stop fields.
     * @access public
     * */
    reduce(body: GdaReduceRequest): Promise<GdaReduceResult>;
    /**
     * Removes one cell inside a column of a row
     *
     * Removes only one cell of the given column of the given row from the given table.
     * @access public
     * */
    removeCell(body: GdaCellRequest): Promise<GdaCellRequest>;
    /**
     * Removes one full column of a row
     *
     * Removes all cells of the given column of the given row from the given table.
     * @access public
     * */
    removeColumn(body: GdaColumnRequest): Promise<GdaColumnRequest>;
    /**
     * Removes a range of rows
     *
     * Removes the specified columns of the given range of rows from the given table.
     * @access public
     * */
    removeRange(body: GdaRemoveRange): Promise<GdaRemoveRange>;
    /**
     * Removes one full row
     *
     * Removes all columns of the given row from the given table.
     * @access public
     * */
    removeRow(body: GdaRowRequest): Promise<GdaRowRequest>;
}