@nec-baas/jssdk/dist/baas.d.ts

NEC Mobile Backend Platform JavaScript SDK

/// <reference types="node" />
export declare const root: typeof globalThis;
export declare type AnyJson = boolean | number | string | null | JsonObject | JsonArray;
export interface JsonObject {
    [key: string]: AnyJson;
}
export interface JsonArray extends Array<AnyJson> {
}
/**
 * @typedef {Object} Callbacks
 * @description コールバック。非同期 API 呼び出し時に使用する。
 * コールバックを省略(=undefined)した場合は、非同期 API は Promise を返却する。
 * Promise 完了時の引数は success コールバックの引数と同じ。
 * @property {function} success 成功時に呼び出されるコールバック。<br>
 * success コールバックの引数は1個。引数の内容は、各非同期 API により異なる。
 * @property {function} error エラー発生時に呼び出されるコールバック。<br>
 * error コールバックには Object が渡される。各 API に指定がない限り、以下の形式となる。
 * <pre>
 * {
 *    "status"        : ステータスコード,
 *    "statusText"    : エラーメッセージ,
 *    "responseText"  : レスポンスメッセージ
 * }
 * </pre>
 */
export interface Callbacks {
    success?(data: any): void;
    error?(error: Error): void;
}
/**
 * @description エラーログを出力する
 * @private
 */
export declare const nbError: (message: string) => void;
/**
 * @description ログを出力する
 * @private
 */
export declare const nbLogger: (message: string) => void;
/**
 * @description 引数エラー処理。
 *   callback があれば callback.error を呼び、なければ reject された Promise を返す。
 * @param {Callbacks} callbacks コールバック
 * @param {String} name API名
 * @private
 */
export declare const _doBadRequestCallback: (callbacks: Callbacks, name: string) => Promise<any>;
/**
 * @description callbacks を promise にバインドする
 * @private
 */
export declare const _promisify: (promise: Promise<any>, callbacks?: Callbacks) => Promise<any>;
/**
 * エラーオブジェクト
 */
export interface NbError extends Error {
    /**
     * ステータスコード
     */
    status: number;
    /**
     * ステータステキスト
     */
    statusText: string;
    /**
     * レスポンステキスト
     */
    responseText: string;
    /**
     * データ(あれば)
     */
    data?: any;
}
/**
 * @description エラーオブジェクトを返す
 * @param status ステータスコード
 * @param statusText ステータステキスト
 * @param responseText レスポンステキスト
 * @param data データ(あれば)
 * @returns {any} エラーオブジェクト
 * @private
 */
export declare const _createError: (status: number, statusText: string, responseText: string, data?: any) => NbError;
/**
 * @private
 */
export declare const _errorText: (error: any) => string;
/**
 * @description オブジェクトか判定する
 * @private
 */
export declare const _isObject: (value: any) => boolean;
/**
 * @description オブジェクトを比較する
 * @private
 */
export declare const _compareObject: (src: any, target: any) => boolean;
/**
 * アサーション
 * @param assert
 * @param message
 * @private
 */
export declare const nbAssert: (assert: boolean, message?: string) => void;
import * as _tls from "tls";
/**
 * Node.js 環境かどうか調べる
 * @returns {boolean} Node.js 環境なら true
 * @private
 */
export declare const isNodeJs: () => boolean;
/**
 * Node.js の require。
 * Node.js でのみ動作する。ブラウザ環境では何もしない。
 * browserify/webpack などの展開対象外。
 * @param {string} module
 * @return {any}
 * @private
 */
export declare const _node_require: (module: string) => any;
export declare const URL: any;
export declare const https: any;
export declare const http: any;
export declare const tls: any;
export declare const fs: any;
export declare const util: any;
export declare const http2: any;
/**
 * APIリクエストインタフェース。
 * HttpRequest, _SdeRequest が implement する
 * @private
 */
export interface ApiRequest {
    execute(): Promise<any>;
    setData(data: any): void;
    setMethod?(method: string): void;
    setContentType?(type: string): void;
    setQueryParam?(key: string, value: any): void;
    setQueryParams?(params: any): void;
    setSessionToken?(token: string): void;
}
export interface Headers {
    [index: string]: string;
}
export interface QueryParams {
    [index: string]: string;
}
/**
 * XHRが定義されているか調べる
 * @returns {boolean}
 * @private
 */
export declare const _hasXhr: () => boolean;
export declare abstract class HttpRequestExecutor {
    _req: HttpRequest;
    _resolve: any;
    _reject: any;
    static _xhrFactory: (req: HttpRequest) => HttpRequestExecutor;
    static _nodeFactory: (req: HttpRequest) => HttpRequestExecutor;
    constructor(req: HttpRequest);
    /**
     * リクエスト実行
     * @param {string} method
     * @param {string} url
     * @param {Headers} headers
     * @param {any} body
     * @param {number} timeout
     * @param {string} responseType
     * @param {boolean} receiveResponseHeaders
     * @param {boolean} useHttp2
     */
    abstract execute(method: string, url: string, headers: Headers, body: any, timeout: number, responseType: string, receiveResponseHeaders: boolean, useHttp2: boolean): void;
    abstract setReturnRawMessage(rawMessage: boolean): void;
    /**
     * セッションをcloseする (Node.js 使用時、HTTP/2使用時のみ有効)
     * @param {string} authority 対象のauthority (例: 'http://example.com:1234' パスやパラメータは含めない)
     * <p>未指定の場合は、保持する全てのHTTP/2セッションをcloseする。
     */
    static closeHttp2Session(authority?: string): void;
    /**
     * HttpRequestExecutor のファクトリメソッド
     * @param {HttpRequest} req
     * @return {HttpRequestExecutor}
     */
    static create(req: HttpRequest): HttpRequestExecutor;
    static setXhrFactory(factory: (req: HttpRequest) => HttpRequestExecutor): void;
    static setNodeFactory(factory: (req: HttpRequest) => HttpRequestExecutor): void;
}
export declare class HttpRequest implements ApiRequest {
    private _service;
    private _method;
    private _url;
    private _headers;
    private _contentType;
    private _responseType;
    private _queryParams;
    private _data;
    private _sessionToken;
    private _timeout;
    private _rawMessage;
    private _useHttp2;
    _resolve: any;
    _reject: any;
    private _receiveResponseHeaders;
    private _responseHeaders;
    private static _defaultTimeout;
    static _httpAgent: any;
    static _httpsAgent: any;
    static _httpsAgentOptions: _tls.SecureContextOptions;
    static _proxy: ProxyServer;
    static getProxy(): ProxyServer;
    static setProxy(proxy: ProxyServer): void;
    static setHttpAgent(agent: any): void;
    static setHttpsAgent(agent: any, options?: any): void;
    readonly service: any;
    /**
     * @description レスポンスヘッダ(Node.js のみ)
     * @name HttpRequest#responseHeaders
     * @type {Object}
     */
    responseHeaders: object;
    /**
     * @memberOf HttpRequest
     * @description デフォルト通信タイムアウト値を設定する
     * @param {number} timeout タイムアウト値(ミリ秒)
     */
    static setDefaultTimeout(timeout: number): void;
    /**
     * @memberOf HttpRequest
     * @description デフォルト通信タイムアウト値を取得する
     * @return {number} タイムアウト値(ミリ秒)
     */
    static getDefaultTimeout(): number;
    /**
     * @description raw response message を返す場合に true をセットする (Node.js専用)。
     * <p>true を指定すると、execute 成功時の応答は http.IncomingMessage となる。
     * <p>HTTP/2を使用する場合、http2.ClientHttp2Streamとなる。
     * @name HttpRequest#rawMessage
     * @type {boolean}
     */
    rawMessage: boolean;
    /**
     * @memberOf HttpRequest
     * @description HTTP/2 を使用する場合にtrueをセットする。(Node.js専用)。
     * @name HttpRequest#useHttp2
     * @type {boolean}
     */
    useHttp2: boolean;
    /**
     * @class HttpRequest
     * @classdesc HTTPリクエストクラス
     * @description コンストラクタ。
     * <p>
     * ユーザがログイン中の場合、自動的に SessionToken が設定される。
     * @param {NebulaService} service NebulaService
     * @param {string} path パス
     * @param {Object} option オプション。noprefix プロパティに true を設定すると、パスプレフィクス("/1/{tenantId}")を付与しない。
     */
    constructor(service: NebulaService, path: string, option?: JsonObject);
    /**
     * @memberOf HttpRequest
     * @description レスポンスヘッダ受信設定を行う。
     * <p>
     * true に設定すると、execute 成功時の応答は
     * {body: ..., headers: {...}, status: statusCode}
     * 形式となる。
     * <p>
     * ブラウザ(XHR)の場合は、headers は文字列(全ヘッダ連結したもの)、
     * Node.js の場合は headers はヘッダ名をキーとした Object となる。
     * @param {boolean} receive true の場合はレスポンスヘッダを受信する
     * @return {HttpRequest} this
     */
    setReceiveResponseHeaders(receive: boolean): HttpRequest;
    /**
     * @memberOf HttpRequest
     * @description HTTP リクエストを実行する。
     * X-Application-Id, X-Application-Key, X-Session-Token ヘッダは自動的に付与される。
     * @return {Promise} Promise
     */
    execute(): Promise<any>;
    /**
     * @memberOf HttpRequest
     * @dscription セッションをcloseする (Node.js 使用時、HTTP/2使用時のみ有効)
     * @param {string} authority 対象のauthority 未指定の場合は全てのセッションをcloseする
     */
    static closeHttp2Session(authority?: string): void;
    /**
     * @memberOf HttpRequest
     * @description HTTP メソッドを設定する
     * @param {string} method メソッド
     * @return {HttpRequest} this
     */
    setMethod(method: string): HttpRequest;
    /**
     * @memberOf HttpRequest
     * @description Content-Type 設定する
     * @param {string} contentType Content-Type
     * @return {HttpRequest} this
     */
    setContentType(contentType: string): HttpRequest;
    /**
     * @memberOf HttpRequest
     * @description クエリパラメータを設定する。以前設定されていた値は消去される。
     * @param {Object} params パラメータ(Object形式)
     * @return {HttpRequest} this
     */
    setQueryParams(params: QueryParams): HttpRequest;
    /**
     * @memberOf HttpRequest
     * @description クエリパラメータを追加する。以前設定されていた値に追加される。
     * @param {Object} params パラメータ(Object形式)
     * @return {HttpRequest} this
     */
    addQueryParams(params: QueryParams): HttpRequest;
    /**
     * @memberOf HttpRequest
     * @description クエリパラメータ(1件)を設定する
     * @param {string} key パラメータ名
     * @param {Object} value 値
     * @return {HttpRequest} this
     */
    setQueryParam(key: string, value: any): HttpRequest;
    /**
     * @memberOf HttpRequest
     * @description 送信データを設定する。
     * <p>
     * 文字列を指定した場合は文字列がそのまま設定される。
     * Objectを指定した場合は JSON 文字列に変換される。
     * Blob および Buffer を指定した場合は、バイナリデータが設定される。
     * @param {Object} data データ
     * @return {HttpRequest} this
     */
    setData(data: any): HttpRequest;
    /**
     * @memberOf HttpRequest
     * @description SessionToken を設定する。
     * <p>
     * 通常は本クラスのインスタンス生成時点で自動的に SessionToken は設定されている(ユーザログイン済みの場合)
     * @param {string} sessionToken セッショントークン文字列
     * @return {HttpRequest} this
     */
    setSessionToken(sessionToken: string): HttpRequest;
    /**
     * @memberOf HttpRequest
     * @description ResponseType を設定する。
     * 指定できるタイプは以下のいずれかで、返却されるレスポンスの型が変化する。
     * デフォルトは "text"。
     * <ul>
     *     <li>text : 文字列</li>
     *     <li>json : JSON。レスポンスは JSON.parse されたもの。</li>
     *     <li>blob : blob (ブラウザのみ)</li>
     *     <li>buffer : Buffer (Node.jsのみ)</li>
     * </ul>
     * @param {string} responseType レスポンスタイプ
     * @return {HttpRequest} this
     */
    setResponseType(responseType: string): HttpRequest;
    /**
     * @memberOf HttpRequest
     * @description リクエストヘッダを設定する。
     * <p>注: 1つのヘッダに対して設定できる値は1つのみである。
     * @param {string} header ヘッダ名
     * @param {string} value 値
     * @return {HttpRequest} this
     */
    addRequestHeader(header: string, value: string): HttpRequest;
}
export declare const initHttpXhr: () => void;
/**
 * XHR 実行クラス
 * @private
 */
export declare class HttpXhr extends HttpRequestExecutor {
    private _xhr;
    private _receiveResponseHeaders;
    constructor(req: HttpRequest);
    setReturnRawMessage(rawMessage: boolean): void;
    execute(method: string, url: string, headers: Headers, body: any, timeout: number, responseType: string, receiveResponseHeaders: boolean, useHttp2: boolean): void;
    static closeHttp2Session(authority: string): void;
    /**
     * XHRを生成する
     * @returns {XMLHttpRequest}
     * @private
     */
    _createXhr(): XMLHttpRequest;
    /**
     * XHR状態変更ハンドラ
     * @returns {any}
     * @private
     */
    _onReadyStateChange(): any;
    /**
     * XHRタイムアウトハンドラ
     * @private
     */
    _onXhrTimeout(e: any): void;
}
import { ClientHttp2Session } from "http2";
export declare const initHttpNode: () => void;
/**
 * Node.js 実行クラス
 * @private
 */
export declare class HttpNode extends HttpRequestExecutor {
    private static _http2Sessions;
    private _responseType;
    private _receiveResponseHeaders;
    private _rawMessage;
    constructor(req: HttpRequest);
    setReturnRawMessage(returnRawMessage: boolean): void;
    execute(method: string, urlString: string, headers: Headers, body: any, timeout: number, responseType: string, receiveResponseHeaders: boolean, useHttp2: boolean): void;
    /**
     * HTTP/2リクエストを送信する
     * @param {module:url.Url} url URL
     * @param {HttpRequestOptions} options ヘッダ等のオプション情報
     * @param body リクエストボディ
     * @private
     */
    private _sendHttp2Request;
    /**
     * HTTP/1.1リクエストを送信する
     * @param {module:url.Url} url URL
     * @param {HttpRequestOptions} options ヘッダ等のオプション情報
     * @param body リクエストボディ
     * @private
     */
    private _sendHttpRequest;
    /**
     * スキームが'https'であるか判定する
     * @param {module:url.Url} url 判定対象のURL
     * @returns {boolean} 'https'ならばtrue
     * @private
     */
    private static _isHttps;
    /**
     * HTTPレスポンス受信用のハンドラを設定する (Node.js用)
     * @param {number} status ステータスコード
     * @param res Stream(http.IncomingMessageなど)
     * @private
     */
    private _setResponseHandlers;
    /**
     * HTTP/2レスポンス受信用のハンドラを設定する (Node.js用)
     * @param stream (http2.ClientHttp2Stream)
     * @private
     */
    private _setHttp2ResponseHandlers;
    private _parseNodeResponse;
    /**
     * HTTP/2のsessionをcloseする(Node.js用)
     * @param session http2.ClientHttp2Sessionだが、互換性維持のためanyを使用
     * @param {function(): void} callback close完了後のコールバック
     * @private
     */
    private static _closeSession;
    /**
     * HTTP/2のstreamをcloseする(Node.js用)
     * node versionによりcloseに使用するAPIが異なるため
     * @param stream http2.ClientHttp2Streamだが、互換性維持のためanyを使用
     * @private
     */
    private static _closeStream;
    /**
     * HTTP/2セッションを全て返却する
     * @returns {{index: string, module:http2.ClientHttp2Session}}
     */
    static getHttp2Sessions(): {
        [index: string]: ClientHttp2Session;
    };
    /**
     * 指定したHTTP/2セッションを取得する
     * @param {string} authority
     * @returns {module:http2.ClientHttp2Session} session
     */
    static getHttp2Session(authority: string): ClientHttp2Session;
    /**
     * HTTP/2セッションをキャッシュする
     * @param {string} authority
     * @param {module:http2.ClientHttp2Session} session
     */
    static setHttp2Session(authority: string, session: ClientHttp2Session): void;
    /**
     * 指定したHTTP/2セッションをcloseする。
     * @param {string} authority 未指定の場合は、保持するセッションを全てクローズする
     */
    static closeHttp2Session(authority?: string): void;
}
/**
 * @class SDEブリッジリクエストクラス
 * @private
 */
export declare class _SdeRequest implements ApiRequest {
    static _callbacks: {
        [index: string]: Callbacks;
    };
    static _requestId: number;
    _className: string;
    _methodName: string;
    _data: any;
    constructor(className: string, methodName: string);
    setData(data: any): any;
    execute(): Promise<any>;
    static _createRequestId(): string;
    static sdeCallback(params: any): void;
}
export interface NetworkEventListener {
    onNetworkStateChanged(isOnline: boolean): void;
}
/**
 * @class SdeNetworkEventListener
 * @private
 */
export declare class _SdeNetworkEventListener {
    static _callback: NetworkEventListener;
    constructor();
    static setCallback(callback: NetworkEventListener): any;
    static onNetworkStateChanged(params: JsonObject): void;
}
/**
 * 同期イベントリスナ
 * @private
 */
export interface SyncEventListener {
    onSyncStart(targetBucket: string): void;
    onSyncCompleted(targetBucket: string, objectIds: string): void;
    onSyncConflicted(bucket: any, client: any, server: any): void;
    onResolveConflict(resolveObject: any, resolve: any): void;
    onSyncError(errorCode: number, errorObject: any): void;
}
export interface ResolveConflictParams {
    bucketName: string;
    bucketMode: number;
    objectId: string;
    resolveId: string;
    resolve: number;
}
/**
 * @class SdeSyncEventListener
 * @private
 */
export declare class _SdeSyncEventListener {
    static _listeners: {
        [index: string]: SyncEventListener;
    };
    static _bucketMode: {
        [index: string]: number;
    };
    constructor();
    static setListener(bucket: any, listener: SyncEventListener): any;
    static resolveConflict(data: ResolveConflictParams): any;
    static onSyncStart(params: any): void;
    static onSyncCompleted(params: any): void;
    static onSyncConflicted(params: any): void;
    static onResolveConflict(params: any): void;
    static onSyncError(params: any): void;
}
/** @private */
export interface AccountLinkJson {
    _id: string;
    iss: string;
    sub: string;
    op: string;
}
/**
 * @class AccountLink
 * @classdesc AccountLink クラス
 * @description AccountLink クラスインスタンスを生成する
 * @example
 * var link = new Nebula.AccountLink();
 * @since v6.5.0
 */
export declare class AccountLink {
    __id: string;
    _iss: string;
    _sub: string;
    _op: string;
    constructor();
    /**
     * リンクユーザID
     * @name AccountLink#_id
     * @type string
     */
    _id: string;
    /**
     * Issuer Identifier
     * @name AccountLink#iss
     * @type string
     */
    iss: string;
    /**
     * Subject Identifier
     * @name AccountLink#sub
     * @type string
     */
    sub: string;
    /**
     * OP種別
     * @name AccountLink#op
     * @type string
     */
    op: string;
    /**
     * @memberOf AccountLink
     * @description JSONからAccountLinkインスタンスにデータをセットする
     * @private
     */
    _setAccountLink(obj: AccountLinkJson): AccountLinkJson;
}
/**
 * @namespace AclPermission
 * @description AclPermissionの定義。
 * Deprecatedである。代わりに {@link Acl}のメンバを使用すること。・
 * @deprecated
 */
export declare const AclPermission: {
    /**
     * 読み込み権限(r)
     * @const
     */
    READ: string;
    /**
     * 書き込み権限(w)
     * @const
     */
    WRITE: string;
    /**
     * 作成権限(c)
     * @const
     */
    CREATE: string;
    /**
     * 更新権限(u)
     * @const
     */
    UPDATE: string;
    /**
     * 削除権限(d)
     * @const
     */
    DELETE: string;
    /**
     * 管理権限(admin)
     * @const
     */
    ADMIN: string;
    /**
     * オーナ(owner)
     * @const
     */
    OWNER: string;
};
/**
 * @namespace AclGroup
 * @description AclGroupの定義。
 * Deprecatedである。代わりに {@link Acl}のメンバを使用すること。・
 * @deprecated
 */
export declare const AclGroup: {
    /**
     * 認証ユーザ (g:authenticated)
     */
    AUTHENTICATED: string;
    /**
     * 全ユーザ (g:anonymous)
     */
    ANONYMOUS: string;
};
export interface AclJson {
    owner?: string;
    r?: string[];
    w?: string[];
    c?: string[];
    u?: string[];
    d?: string[];
    admin?: string[];
    [index: string]: string | string[];
}
/**
 * @class Acl
 * @classdesc ACLクラス
 * @example
 * var acl1 = new Nebula.Acl();
 * var acl2 = new Nebula.Acl({"r": [Nebula.Acl.AUTHENTICATED]});
 * @param {Object} json JSON表記のACL。省略時は全エントリが空の状態で生成される。
 */
export declare class Acl {
    /**
     * 読み込み権限(r)
     * @memberOf Acl
     * @const
     */
    static READ: string;
    /**
     * 書き込み権限(w)
     * @memberOf Acl
     * @const
     */
    static WRITE: string;
    /**
     * 作成権限(c)
     * @memberOf Acl
     * @const
     */
    static CREATE: string;
    /**
     * 更新権限(u)
     * @memberOf Acl
     * @const
     */
    static UPDATE: string;
    /**
     * 削除権限(d)
     * @memberOf Acl
     * @const
     */
    static DELETE: string;
    /**
     * 管理権限(admin)
     * @memberOf Acl
     * @const
     */
    static ADMIN: string;
    /**
     * オーナ(owner)
     * @memberOf Acl
     * @const
     */
    static OWNER: string;
    /**
     * ログイン認識した全ユーザ (g:authenticated)
     * @memberOf Acl
     * @const
     */
    static AUTHENTICATED: string;
    /**
     * ログインしていないユーザを含む全ユーザ (g:anonymous)
     * @memberOf Acl
     * @const
     */
    static ANONYMOUS: string;
    private _acl;
    [index: string]: any;
    /**
     * @private
     */
    constructor(json?: AclJson | Acl);
    /**
     * @method
     * @memberOf Acl
     * @description
     *      対象権限にユーザIDまたはグループ名を追加する
     * @example
     * var acl = new Nebula.Acl();
     * var user = new Nebula.User();
     * var group = new Group("MyGroup");
     * ....
     * acl.addEntry(Nebula.Acl.READ, user);
     * acl.addEntry(Nebula.Acl.WRITE, "USER_01");
     * acl.addEntry(Nebula.Acl.CREATE, group);
     * acl.addEntry(Nebula.Acl.UPDATE, "g:GROUP_A");
     * acl.addEntry(Nebula.Acl.DELETE, Nebula.Acl.AUTHENTICATED);
     * @param {String} permission エントリを追加する対象権限
     *      <br />以下のいずれかの値を指定する。
     *      <ul>
     *      <li>{@link Acl.READ}
     *      <li>{@link Acl.WRITE}
     *      <li>{@link Acl.CREATE}
     *      <li>{@link Acl.UPDATE}
     *      <li>{@link Acl.DELETE}
     *      <li>{@link Acl.ADMIN}
     *      </ul>
     * @param {Object} entry ユーザまたはグループ情報
     * 以下のいずれかを指定する。
     * <p>
     * ・ユーザを指定する場合
     * <ul>
     *   <li>{@link User} インスタンス
     *   <li>ユーザIDの文字列
     * </ul>
     *
     * ・グループを指定する場合
     * <ul>
     *   <li>{@link Group} インスタンス
     *   <li>グループ名に g: を付けた文字列。<br>(例) グループ名が GROUP_A の場合、 g:GROUP_A
     *   <li>{@link Acl.AUTHENTICATED} : ログイン認証された全ユーザ
     *   <li>{@link Acl.ANONYMOUS} : ログインしていないユーザを含む全ユーザ
     * </ul>
     * @return {Boolean} 正常追加した場合 true、 パラメータが不正の場合 false を返す
     */
    addEntry(permission: string, entry: string | User | Group): boolean;
    /**
     * @method
     * @memberOf Acl
     * @description
     *      対象権限からにユーザIDまたはグループ名を削除する
     * @example
     * var acl = new Nebula.Acl();
     * var user = new Nebula.User();
     * var group = new Group("MyGroup");
     * ....
     * acl.removeEntry(Nebula.Acl.READ, user);
     * acl.removeEntry(Nebula.Acl.WRITE, "USER_01");
     * acl.removeEntry(Nebula.Acl.CREATE, group);
     * acl.removeEntry(Nebula.Acl.UPDATE, "g:GROUP_A");
     * acl.removeEntry(Nebula.Acl.DELETE, Nebula.Acl.AUTHENTICATED);
     * @param {String} permission エントリを削除する対象権限
     *      <br />以下のいずれかの値を指定する。
     *      <ul>
     *      <li>{@link Acl.READ}
     *      <li>{@link Acl.WRITE}
     *      <li>{@link Acl.CREATE}
     *      <li>{@link Acl.UPDATE}
     *      <li>{@link Acl.DELETE}
     *      <li>{@link Acl.ADMIN}
     *      </ul>
     * @param {Object} entry ユーザまたはグループ情報。
     * 以下のいずれかを指定する。
     * <p>
     * ・ユーザを指定する場合
     * <ul>
     *   <li>{@link User} インスタンス
     *   <li>ユーザIDの文字列
     * </ul>
     *
     * ・グループを指定する場合
     * <ul>
     *   <li>{@link Group} インスタンス
     *   <li>グループ名に g: を付けた文字列。<br>(例) グループ名が GROUP_A の場合、 g:GROUP_A
     *   <li>{@link Acl.AUTHENTICATED} : ログイン認証された全ユーザ
     *   <li>{@link Acl.ANONYMOUS} : ログインしていないユーザを含む全ユーザ
     * </ul>
     */
    removeEntry(permission: string, entry: string | User | Group): boolean;
    /**
     * @method
     * @memberOf Acl
     * @description 所有者のユーザIDを設定する
     * @private
     */
    _setOwner(owner: string): void;
    /**
     * @method
     * @memberOf Acl
     * @description
     *      所有者のユーザIDを取得する
     * @example
     * var acl = ....;
     * ....
     * var userId = acl.getOwner();
     * @return
     *      {String} ユーザIDの文字列を返す。所有者がない場合は、null を返す。
     */
    getOwner(): string;
    /**
     * @method
     * @memberOf Acl
     * @description
     *      対象権限のユーザIDおよびグループ名のエントリ一覧を取得する
     * @example
     * var acl = ....;
     *
     * var entries = acl.getEntries(permission);
     * for (var i = 0; i < entries.length; i++) {
     *     entry = entries[i];
     *     ....;
     * }
     * @param {String} permission 取得するエントリ一覧の対象権限
     *      <br />以下のいずれかの値を指定する。
     *      <ul>
     *      <li>{@link Acl.READ}
     *      <li>{@link Acl.WRITE}
     *      <li>{@link Acl.CREATE}
     *      <li>{@link Acl.UPDATE}
     *      <li>{@link Acl.DELETE}
     *      <li>{@link Acl.ADMIN}
     *      </ul>
     * @return {Object} ユーザIDまたはグループ名の文字列の配列を返す。
     *      エントリがない場合は、空配列を返す。
     *      <br />グループ名には、g: が先頭に付加されている。
     */
    getEntries(permission: string): string[];
    /**
     * @method
     * @memberOf Acl
     * @description ACLのJSONオブジェクトを直接設定する
     * @private
     */
    _set(acl: AclJson): void;
    /**
     * @method
     * @memberOf Acl
     * @description 指定のエントリが含まれているかどうか
     * @private
     */
    _hasEntry(permission: string, target: string): boolean;
    /**
     * @method
     * @memberOf Acl
     * @description ACLのJSONオブジェクトを文字列に変換する
     * @private
     */
    _toString(keyName?: string): string;
    /**
     * @method
     * @memberOf Acl
     * @description ACLのJSONオブジェクトを返す
     * @param keyName "ACL", "contentACL" のいずれかを指定すると、そのキーに ACL が格納される
     * @private
     */
    _toJsonObject(keyName?: string): JsonObject;
}
export declare const RegexOption: {
    CASE_INSENSITIVITY: string;
};
export interface ClauseJson extends JsonObject {
    [index: string]: AnyJson;
}
/**
 * @class Clause
 * @classdesc オブジェクト検索条件 クラス
 * @description Clause インスタンスを生成する
 * @example
 * var clause = new Nebula.Clause();
 */
export declare class Clause {
    _clause: ClauseJson;
    /** @private */
    constructor(clause?: ClauseJson);
    /**
     * @memberOf Clause
     * @description 条件のパラメータをセットする
     * @private
     */
    _setParams(key: string, operator: string, value: AnyJson, options?: AnyJson): Clause;
    /**
     * @memberOf Clause
     * @description JSONで表現された条件式を取得する
     * @return {Object} JSON条件式
     */
    json(): ClauseJson;
    /**
     * @method
     * @name Clause.equals
     * @description
     *      (key == value) の条件を示す Nebula.Clause インスタンスを生成する
     * @example
     * var clause = Nebula.Clause.equals("score", 80);
     * @param {String} key 比較するキー名
     * @param {Object} value 比較する値
     * @return {Clause} Nebula.Clause インスタンスを返す。
     */
    static equals(key: string, value: AnyJson): Clause;
    /**
     * @method
     * @name Clause#equals
     * @description
     *      (key == value) の条件を追加する
     * @example
     * var clause = new Nebula.Clause().equals("score", 80);
     * @param {String} key 比較するキー名
     * @param {Object} value 比較する値
     * @return {Clause} this
     */
    equals(key: string, value: AnyJson): Clause;
    /**
     * @memberOf Clause
     * @description
     *      (key != value) の条件を示す Nebula.Clause インスタンスを生成する
     * @example
     * var clause = Nebula.Clause.notEquals("name", "apple");
     * @param {String} key 比較するキー名
     * @param {Object} value 比較する値
     * @return {Clause} Nebula.Clause インスタンスを返す。
     */
    static notEquals(key: string, value: AnyJson): Clause;
    /**
     * @memberOf Clause
     * @description
     *      (key != value) の条件を追加する
     * @example
     * var clause = new Nebula.Clause().notEquals("name", "apple");
     * @param {String} key 比較するキー名
     * @param {Object} value 比較する値
     * @return {Clause} this
     */
    notEquals(key: string, value: AnyJson): Clause;
    /**
     * @memberOf Clause
     * @description
     *      (key < value) の条件を示す Nebula.Clause インスタンスを生成する
     * @example
     * var clause = Nebula.Clause.lessThan("score", 30);
     * @param {String} key 比較するキー名
     * @param {Object} value 比較する値
     * @return {Clause} Nebula.Clause インスタンスを返す。
     */
    static lessThan(key: string, value: number): Clause;
    /**
     * @memberOf Clause
     * @description
     *      (key < value) の条件を追加する
     * @example
     * var clause = new Nebula.Clause().lessThan("score", 30);
     * @param {String} key 比較するキー名
     * @param {Object} value 比較する値
     * @return {Clause} this
     */
    lessThan(key: string, value: number): Clause;
    /**
     * @memberOf Clause
     * @description
     *      (key <= value) の条件を示す Nebula.Clause インスタンスを生成する
     * @example
     * var clause = Nebula.Clause.lessThanOrEqual("score", 30);
     * @param {String} key 比較するキー名
     * @param {Object} value 比較する値
     * @return {Clause} Nebula.Clause インスタンスを返す。
     */
    static lessThanOrEqual(key: string, value: number): Clause;
    /**
     * @memberOf Clause
     * @description
     *      (key <= value) の条件を追加する
     * @example
     * var clause = new Nebula.Clause().lessThanOrEqual("score", 30);
     * @param {String} key 比較するキー名
     * @param {Object} value 比較する値
     * @return {Clause} this
     */
    lessThanOrEqual(key: string, value: number): Clause;
    /**
     * @memberOf Clause
     * @description
     *      (key > value) の条件を示す Nebula.Clause インスタンスを生成する
     * @example
     * var clause = Nebula.Clause.greaterThan("number", 1000);
     * @param {String} key 比較するキー名
     * @param {Object} value 比較する値
     * @return {Clause} Nebula.Clause インスタンスを返す。
     */
    static greaterThan(key: string, value: number): Clause;
    /**
     * @memberOf Clause
     * @description
     *      (key > value) の条件を追加する
     * @example
     * var clause = new Nebula.Clause().greaterThan("number", 1000);
     * @param {String} key 比較するキー名
     * @param {Object} value 比較する値
     * @return {Clause} this
     */
    greaterThan(key: string, value: number): Clause;
    /**
     * @memberOf Clause
     * @description
     *      (key >= value) の条件を示す Nebula.Clause インスタンスを生成する
     * @example
     * var clause = Nebula.Clause.greaterThanOrEqual("number", 1000);
     * @param {String} key 比較するキー名
     * @param {Object} value 比較する値
     * @return {Clause} Nebula.Clause インスタンスを返す。
     */
    static greaterThanOrEqual(key: string, value: number): Clause;
    /**
     * @memberOf Clause
     * @description
     *      (key >= value) の条件を追加すうｒ
     * @example
     * var clause = Nebula.Clause.greaterThanOrEqual("number", 1000);
     * @param {String} key 比較するキー名
     * @param {Object} value 比較する値
     * @return {Clause} this
     */
    greaterThanOrEqual(key: string, value: number): Clause;
    /**
     * @memberOf Clause
     * @description
     *      key の値が values で指定された中に存在するかの条件を示す Nebula.Clause インスタンスを生成する
     * @name Clause.in
     * @function
     * @example
     * var targets = [1000, 1003, 1005];
     * var clause = Nebula.Clause.in("number", targets);
     * @param {String} key 比較するキー名
     * @param {Object} values 比較する値の配列
     * @return {Clause} Nebula.Clause インスタンスを返す。
     */
    static in(key: string, values: AnyJson[]): Clause;
    /**
     * @memberOf Clause
     * @description
     *      key の値が values で指定された中に存在するかの条件を追加する
     * @name Clause#in
     * @function
     * @example
     * var targets = [1000, 1003, 1005];
     * var clause = new Nebula.Clause().in("number", targets);
     * @param {String} key 比較するキー名
     * @param {Object} values 比較する値の配列
     * @return {Clause} this
     */
    in(key: string, values: AnyJson[]): Clause;
    /**
     * @memberOf Clause
     * @description
     *      key の値が values で指定されたすべてを含んでいるかの条件を示す Nebula.Clause インスタンスを生成する
     * @example
     * var targets = ["ssl", "security"];
     * var clause = Nebula.Clause.all("tags", targets);
     * @param {String} key 比較するキー名
     * @param {Object} values 比較する値の配列
     * @return {Clause} Nebula.Clause インスタンスを返す。
     */
    static all(key: string, values: AnyJson[]): Clause;
    /**
     * @memberOf Clause
     * @description
     *      key の値が values で指定されたすべてを含んでいるかの条件を追加する
     * @example
     * var targets = ["ssl", "security"];
     * var clause = new Nebula.Clause().all("tags", targets);
     * @param {String} key 比較するキー名
     * @param {Object} values 比較する値の配列
     * @return {Clause} this
     */
    all(key: string, values: AnyJson[]): Clause;
    /**
     * @memberOf Clause
     * @description
     *      key で示したフィールドが存在するかどうかを示す Nebula.Clause インスタンスを生成する
     * @example
     * var clause = Nebula.Clause.exist("tags", targets);
     * @param {String} key 比較するキー名
     * @param {Boolean} value 存在を確認する場合は true、 存在しないことを確認する場合は false を指定する。
     * @return {Clause} Nebula.Clause インスタンスを返す。
     */
    static exist(key: string, value: boolean): Clause;
    /**
     * @memberOf Clause
     * @description
     *      key で示したフィールドが存在するかどうかの条件を追加する
     * @example
     * var clause = new Nebula.Clause().exist("tags", targets);
     * @param {String} key 比較するキー名
     * @param {Boolean} value 存在を確認する場合は true、 存在しないことを確認する場合は false を指定する。
     * @return {Clause} this
     */
    exist(key: string, value: boolean): Clause;
    /**
     * @memberOf Clause
     * @description
     *      正規表現による検索条件を示す Nebula.Clause インスタンスを生成する
     * @example
     * var clause = Nebula.Clause.regex("name", "abc*");
     * @param {String} key 比較するキー名
     * @param {String} expression Perl互換の正規表現の条件文字列
     * @param {Object} option オプション
     * <p>option には必要に応じて以下の値を指定してもよい。(省略可能)
     * <ul>
     *     <li>Nebula.RegexOption.CASE_INSENSITIVITY   大文字小文字を区別しない</li>
     * </ul>
     * @return {Clause} Nebula.Clause インスタンスを返す。
     */
    static regex(key: string, expression: string, option?: string): Clause;
    /**
     * @memberOf Clause
     * @description
     *      正規表現による検索条件を追加する
     * @example
     * var clause = new Nebula.Clause().regex("name", "abc*");
     * @param {String} key 比較するキー名
     * @param {String} expression Perl互換の正規表現の条件文字列
     * @param {Object} option オプション
     * <p>
     * <ul>option には必要に応じて以下の値を指定してもよい。(省略可能)
     *     <li>Nebula.RegexOption.CASE_INSENSITIVITY   大文字小文字を区別しない</li>
     * </ul>
     * @return {Clause} this
     */
    regex(key: string, expression: string, option?: string): Clause;
    /**
     * @memberOf Clause
     * @description
     *      Nebula.Clause インスタンスの key の条件を反転させる
     * @example
     * var clause = Nebula.Clause.exist("tags", targets);
     * clause.not("tags");
     * @param {String} key 比較するキー名
     * @return {Clause} Nebula.Clause インスタンス(this)を返す。
     */
    not(key: string): Clause;
    /**
     * @memberOf Clause
     * @description
     *      複数の条件を AND条件で結合する
     * @example
     * var clause1 = Nebula.Clause.equals("name", "AAA");
     * var clause2 = Nebula.Clause.lessThan("score", 50);
     * var clause3 = Nebula.Clause.greaterThan("score", 30);
     * var clause = Nebula.Clause.and(clause1, clause2, clause3);
     * @param {Clause} clauses AND条件をとるNebula.Clauseインスタンス
     * <p>複数のインスタンスを指定できる
     * @return {Clause} Nebula.Clause インスタンスを返す。
     */
    static and(...clauses: Clause[]): Clause;
    /**
     * @memberOf Clause
     * @description
     *      複数の条件を OR条件で結合する
     * @example
     * var clause1 = Nebula.Clause.equals("name", "AAA");
     * var clause2 = Nebula.Clause.lessThan("score", 50);
     * var clause3 = Nebula.Clause.greaterThan("score", 30);
     * var clause = Nebula.Clause.or(clause1, clause2, clause3);
     * @param {Clause} clauses OR条件をとるNebula.Clauseインスタンス
     * <p>複数のインスタンスを指定できる
     * @return {Clause} Nebula.Clause インスタンスを返す。
     */
    static or(...clauses: Clause[]): Clause;
    /**
     * @memberOf Clause
     * @description Nebula.Clause インスタンスの配列からJSON値の配列を生成する
     * @private
     */
    static _convertClauseArray(clauseArray: Clause[]): AnyJson[];
}
export declare class ObjectQuery {
    _clause: Clause;
    _limit: number;
    _skip: number;
    _sort: string[];
    _deleteMark: boolean;
    _countQuery: boolean;
    _projection: JsonObject;
    /**
     * @class ObjectQuery
     * @classdesc オブジェクトクエリ
     * @description オブジェクトクエリを生成する
     * @example
     * var query = new Nebula.ObjectQuery();
     */
    constructor();
    /**
     * @function
     * @memberOf ObjectQuery
     * @description 設定されているClauseインスタンスを取得する
     * @return {Clause} clause
     */
    getClause(): Clause;
    /**
     * @function
     * @memberOf ObjectQuery
     * @description 設定されている検索上限数を取得する
     * @return {number} 検索上限数
     */
    getLimit(): number;
    /**
     * @function
     * @memberOf ObjectQuery
     * @description 設定されているスキップカウントを取得する
     * @return {number} スキップカウント
     */
    getSkipCount(): number;
    /**
     * @function
     * @memberOf ObjectQuery
     * @description 設定されているソート順序を取得する。
     * ソート順序は以下のようなキー文字列の配列。降順の場合はキーの先頭が "-" となる。
     * <pre>
     *     ["key1", "-key2"]
     * </pre>
     * @return {string[]}
     * @since 6.5.0
     */
    getSort(): string[];
    /**
     * @function
     * @memberOf ObjectQuery
     * @description 設定されているソート順序を取得する。
     * <p>
     * Deprecated である。{@link ObjectQuery#getSort} を使用すること。
     * <p>
     * ソート順序は以下のように {キー名: 昇順フラグ} の配列。
     * <pre>
     *     [{"key1": true}, {"key2": false}]
     * </pre>
     * @return {array} ソート順序
     * @deprecated since 6.5.0
     */
    getSortOrder(): Array<{
        [index: string]: boolean;
    }>;
    /**
     * @function
     * @memberOf ObjectQuery
     * @description deleteフラグを取得する
     * @private
     */
    _getDeleteMark(): boolean;
    /**
     * @function
     * @memberOf ObjectQuery
     * @description 設定されているプロジェクションを取得する
     * @return {Object} プロジェクション
     */
    getProjection(): JsonObject;
    /**
     * @function
     * @memberOf ObjectQuery
     * @description deleteフラグをセットする
     * @private
     */
    _setDeleteMark(mark: boolean): void;
    /**
     * @function
     * @memberOf ObjectQuery
     * @description 内部データをクエリパラメータ Object に変換する
     * @private
     */
    _toParam(): any;
    /**
     * @function
     * @memberOf ObjectQuery
     * @description 内部データを JSON Object に変換する
     * @private
     */
    _toParamJson(): any;
    /**
     * @function
     * @memberOf ObjectQuery
     * @description QUERY情報(JSON)をNebula.ObjectQueryインスタンスに変換する
     * @private
     */
    static _toObjectQuery(queryJson: any): ObjectQuery;
    /**
     * @function
     * @memberOf ObjectQuery
     * @description NebulaObjectQueryインスタンスを比較する
     * @private
     */
    _equals(that: ObjectQuery): boolean;
    /**
     * @memberOf ObjectQuery
     * @description
     *      検索条件を設定する
     * @example
     * var clause = Nebula.Clause.lessThan("score", 50);
     * var query = new Nebula.ObjectQuery();
     * query.setClause(clause);
     * @param {Clause} clause Nebula.Clauseインスタンス
     * <p>null を指定した場合は、すでに設定済みの検索条件をクリアする。
     * <p>検索条件がすでに設定されていた場合、検索条件は上書きされる。
     * デフォルトでは、null が設定されている。
     * @return {ObjectQuery} this
     */
    setClause(clause: Clause): ObjectQuery;
    /**
     * @memberOf ObjectQuery
     * @description
     *      検索上限数を設定する
     * @example
     * var clause = Nebula.Clause.lessThan("score", 50);
     * var query = new Nebula.ObjectQuery()
     *     .setClause(clause)
     *     .setLimit(10);
     * @param {number} limit 検索上限数。
     * <ul>
     *   <li>-1 以上の値を指定できる。
     *   <li>-1を設定した場合は「制限なし」となる。
     *   ただし、サーバ側のコンフィグレーションによっては、上限値が制限されている場合がある。この場合、クエリを実行するとサーバからエラーが返る。
     *   <li>デフォルトでは、-1 が設定されている。
     *   <li>範囲外の値が設定された場合は、例外をスローする。
     * </ul>
     * @return {ObjectQuery} this
     */
    setLimit(limit: number): ObjectQuery;
    /**
     * @function
     * @memberOf ObjectQuery
     * @description スキップカウントを設定する。
     * <p>
     * スキップカウントは検索結果の先頭からのスキップ数を表す。
     * @example
     * // この例では検索結果の5件目から10件を取得する。
     * var clause = Nebula.Clause.lessThan("score", 50);
     * var query = new Nebula.ObjectQuery()
     *     .setClause(clause)
     *     .setLimit(10)
     *     .setSkipCount(5);
     * @param {number} skip スキップカウント
     * <p>
     * skip は、0以上の値が設定可能である。
     * 範囲外の値が設定された場合は、例外をスローする。
     * デフォルトでは、0 が設定されている。
     * @return {ObjectQuery} this
     */
    setSkipCount(skip: number): ObjectQuery;
    /**
     * @function
     * @memberOf ObjectQuery
     * @description ソート順序を設定する。
     * @example
     * var query = new Nebula.ObjectQuery()
     *     .setSort(["key1", "-key2"]);
     * @param {string[]} sort ソートキーの配列。
     * 先に指定したものが高優先となる。
     * <p>それぞれデフォルトは昇順。降順の場合は先頭に "-" を付与する。
     * @return {ObjectQuery} this
     * @since 6.5.0
     */
    setSort(sort: string[]): ObjectQuery;
    /**
     * @function
     * @memberOf ObjectQuery
     * @description ソート順序を設定する。
     * <p>
     * 本メソッドはDeprecated である。{@link ObjectQuery#setSort} を使用すること。
     * <p>
     * 複数のキーを設定する場合は、本メソッドを複数呼び出す。
     * 先に設定したキーのほうが優先順位が高い。
     * <p>
     * ソート順序をクリアするには {@link ObjectQuery#clearSortOrder} を使用する。
     * @example
     * // 以下の例では、score降順 -> name昇順で検索する
     * var query = new Nebula.ObjectQuery()
     *     .setSortOrder("score", false)
     *     .setSortOrder("name", true);
     * @param {string} key ソート対象のキー
     * @param {boolean} isAsc 昇順でソートするかどうかを示す。昇順はtrue, 降順はfalse。
     * @return {ObjectQuery} this
     * @deprecated since 6.5.0
     */
    setSortOrder(key: string, isAsc: boolean): ObjectQuery;
    /**
     * @function
     * @memberOf ObjectQuery
     * @description 設定したソート順序をクリアする。<p>
     * Deprecated である。{@link ObjectQuery#setSort} を使用すること。
     * @example
     * var clause = Nebula.Clause.lessThan("score", 50);
     * var query = new Nebula.ObjectQuery()
     *     .setClause(clause)
     *     .setLimit(10)
     *     .setSkipCount(5)
     *     .setSortOrder("name", true);
     * ....
     * query.clearSortOrder("name");
     * @param {string} key クリアするソート対象のキー。省略時は全キーをクリアする。
     * @return {ObjectQuery} this
     * @deprecated since 6.5.0
     */
    clearSortOrder(key?: string): ObjectQuery;
    /**
     * @function
     * @memberOf ObjectQuery
     * @description
     *      クエリ件数取得フラグを設定する.
     *      <br>
     *      クエリ件数取得フラグは、Nebula.ObjectBucket.query() を実行したときに
     *      クエリに合致した件数を取得するかどうかを表し、trueの場合は取得することを示す。
     *      <br>
     *      クエリ件数取得フラグのデフォルト値は、falseである。
     * @example
     * var bucket = ....;
     * var clause = Nebula.Clause.lessThan("score", 50);
     * var conditions = new Nebula.ObjectQuery();
     * conditions.setClause(clause);
     * conditions.setLimit(10);
     * conditions._setCountQuery(true);
     * ....
     * conditions.query(conditions)
     *     .then(function(result) {
     *         // result.count に全件数、result.objects にオブジェクト配列が返る
     *     })
     *     .catch(function(err) {...})
     * @param {Boolean} countQuery クエリ件数取得フラグ
     *      <br/>true または false を指定する。
     * @private
     */
    _setCountQuery(countQuery: boolean): ObjectQuery;
    /**
     * @function
     * @memberOf ObjectQuery
     * @description
     *      クエリ件数取得フラグを取得する.
     *      <br>
     *      クエリ件数取得フラグのデフォルト値は、falseである。
     * @return
     *      {Boolean} クエリ件数取得フラグ(trueまたはfalse)を返す
     * @private
     */
    _isCountQuery(): boolean;
    /**
     * @function
     * @memberOf ObjectQuery
     * @description
     *      プロジェクションを指定する。
     * @example
     * var clause = Nebula.Clause.lessThan("score", 50);
     * var projection = {"score":1};
     * var query = new Nebula.ObjectQuery();
     * query.setClause(clause);
     * query.setProjection(projection);
     * @param {Object} projectionJson
     *      <p>null を指定した場合は、すでに設定済みの値をクリアする。
     *      <p>設定済み状態で、本メソッドを呼び出した場合は上書きされる。
     *      デフォルトでは、null が設定されている。
     * @return {ObjectQuery} this
     */
    setProjection(projectionJson: JsonObject): ObjectQuery;
}
export interface LoginInfo {
    username?: string;
    email?: string;
    token?: string;
    password?: string;
}
export interface UserJson {
    _id?: string;
    username?: string;
    email?: string;
    password?: string;
    options?: JsonObject;
    groups?: string[];
    createdAt?: string;
    updatedAt?: string;
    lastLoginAt?: string;
    etag?: string;
    sessionToken?: string;
    expire?: number;
    clientCertUser?: boolean;
    federated?: boolean;
    token?: string;
    primaryLinkedUserId?: string;
    [index: string]: any;
}
export interface UserQuery {
    _id?: string;
    username?: string;
    email?: string;
    skip?: number;
    limit?: number;
    countQuery?: boolean;
}
/**
 * User 基底クラス
 * @private
 */
export declare class User implements UserJson {
    _service: NebulaService;
    private __id;
    private _username;
    private _email;
    private _password;
    private _options;
    private _groups;
    private _createdAt;
    private _updatedAt;
    private _lastLoginAt;
    private _etag;
    private _sessionToken;
    private _expire;
    private _clientCertUser;
    private _federated;
    private _primaryLinkedUserId;
    [index: string]: any;
    /**
     * @class User
     * @classdesc ユーザ管理 クラス
     * @description ユーザオブジェクトを生成する。
     * <p>
     * 生成しただけの状態では、まだサーバには登録されていない。ユーザ登録は {@link User#register} で実施する。
     * @example
     * var user = new Nebula.User();
     * @return {Object} 新規ユーザオブジェクトのインスタンス
     */
    constructor(service?: NebulaService);
    /**
     * ユーザID
     * @type String
     * @name User#_id
     */
    _id: string;
    /**
     * ユーザ名
     * @type String
     * @name User#username
     */
    username: string;
    /**
     * E-mail アドレス
     * @type String
     * @name User#email
     */
    email: string;
    /**
     * パスワード
     * @type String
     * @name User#password
     */
    password: string;
    /**
     * オプション (JSON)
     * @type Object
     * @name User#options
     */
    options: JsonObject;
    /**
     * 所属グループ一覧 (read only)
     * @type String[]
     * @name User#groups
     */
    groups: string[];
    /**
     * 作成日時
     * @type String
     * @name User#createdAt
     */
    createdAt: string;
    /**
     * 更新日時
     * @type String
     * @name User#updatedAt
     */
    updatedAt: string;
    /**
     * 最終ログイン日時
     * @type String
     * @name User#lastLoginAt
     */
    lastLoginAt: string;
    /**
     * ETag
     * @type String
     * @name User#etag
     */
    etag: string;
    /**
     * セッショントークン
     * @type String
     * @name User#sessionToken
     */
    sessionToken: string;
    /**
     * セッショントークン有効期限(unix time [秒])
     * @type String
     * @name User#expire
     */
    expire: number;
    /**
     * クライアント証明書認証ユーザの場合は true<br>
     * (ブラウザ、またはNode.jsのみ対応)
     * @type boolean
     * @name User#clientCertUser
     */
    clientCertUser: boolean;
    /**
     * 外部認証連携有りの場合は true<br>
     * (ブラウザ、またはNode.jsのみ対応)
     * @type boolean
     * @name User#federated
     * @default false
     */
    federated: boolean;
    /**
     * プライマリリンクユーザID<br>
     * OpenID Connect認証でユーザ自動生成時のリンクユーザID<br>
     * (ブラウザ、またはNode.jsのみ対応)
     * @type String
     * @name User#primaryLinkedUserId
     * @default null
     */
    primaryLinkedUserId: string;
    protected _setUserInfo(response: string): void;
    /**
     * @method
     * @memberOf User
     * @description ユーザプロパティ設定 (Deprecated)
     * <p>
     * ・ユーザオブジェクトのプロパティを設定する。<br>
     * ・設定可能なプロパティの詳細は、各メソッドの説明を参照のこと。<br>
     * ・本メソッドは deprecated である。各フィールドの setter を直接使用すること。<br>
     * @param {String} property プロパティ名。
     * 指定可能なプロパティ名は以下のとおり。
     * <ul>
     *     <li>_id :         ユーザID
     *     <li>username:     ユーザ名
     *     <li>email:        E-mailアドレス
     *     <li>password:     パスワード
     *     <li>options:      オプション情報 (JSON)
     *     <li>createdAt:    ユーザ登録日時
     *     <li>updatedAt:    ユーザ更新日時
     *     <li>sessionToken: セッショントークン
     *     <li>expire:       セッショントークン有効期限(unix time [秒])
     *     <li>clientCertUser: クライアント証明書ユーザ (ブラウザ、またはNode.jsのみ対応)
     *     <li>federated:    外部認証連携有無
     *     <li>primaryLinkedUserId: プライマリリンクユーザID
     * </ul>
     * @param {String} value プロパティ値
     * @return {User} this
     * @deprecated
     */
    set(property: string, value: any): void;
    /**
     * @method
     * @memberOf User
     * @description ユーザプロパティ取得 (Deprecated)
     * <p>
     * ・ユーザオブジェクトのプロパティを取得する。<br>
     * ・取得可能なプロパティの詳細は、各メソッドの説明を参照のこと。<br>
     * ・本メソッドは deprecated である。各フィールドの getter を直接使用すること。
     * @param {String} property プロパティ名。
     * 指定可能なプロパティ名は以下のとおり(APIによって取得可能なプロパティは異なる)。
     * <ul>
     *     <li>_id :         ユーザID
     *     <li>username:     ユーザ名
     *     <li>email:        E-mailアドレス
     *     <li>password:     パスワード
     *     <li>options:      オプション情報 (JSON)
     *     <li>groups:       所属グループ一覧 (配列)
     *     <li>createdAt:    ユーザ登録日時
     *     <li>updatedAt:    ユーザ更新日時
     *     <li>sessionToken: セッショントークン
     *     <li>expire:       セッショントークン有効期限(unix time [秒])
     *     <li>clientCertUser: クライアント証明書ユーザ (ブラウザ、またはNode.jsのみ対応)
     *     <li>federated:    外部認証連携有無
     *     <li>primaryLinkedUserId: プライマリリンクユーザID
     * </ul>
     * @return {String} value プロパティ値
     * @deprecated
     */
    get(property: string): any;
    /**
     * @method
     * @memberOf User
     * @description ユーザを登録する。
     * <p>
     * ユーザ登録に必要なユーザプロパティは、以下の通り。
     * <ul>
     *     <li>email     : E-mailアドレス（必須）
     *     <li>password  : パスワード（必須）
     *     <li>username  : ユーザ名（オプション）
     *     <li>options   : オプション(オプション)。JSON形式で記述された任意のオブジェクトを指定できる。
     * </ul>
     *  クライアント証明書認証用のユーザの登録を行う場合のユーザプロパティは以下の通りとする
     *  clientCertUserをtrueに設定した場合、email/passwordは無視する。
     *  (ブラウザ、またはNode.jsのみ対応)
     * <ul>
     *     <li>username          : ユーザ名（必須）
     *     <li>clientCertUser    : クライアント証明書ユーザ trueを設定すること(必須)
     *     <li>options           : オプション(オプション) optionsには、JSON形式で記述された任意のオブジェクトを指定できる。
     *  </ul>
     * @param {Callbacks} callbacks コールバック (Option)
     * @return {Promise} callbacksを指定しなかった場合、Promiseオブジェクトを返す。callback指定時は返り値なし(undefined)。
     * <p>処理完了時に渡される値は以下の通り。
     * <ul>
     * <li>成功時: ユーザオブジェクトのインスタンス。なお、処理が成功した状態ではまだログインは実施していない。
     *     以下のユーザオブジェクトのプロパティが追加格納される
     *     <ul>
     *     <li>_id         : 登録したユーザのID
     *     <li>createdAt   : 登録日付
     *     <li>updatedAt   : 最終更新日付
     *     </ul>
     * <li>失敗時: エラー要因(JSON)
     * </ul>
     */
    register(callbacks?: Callbacks): Promise<User>;
    /**
     * @method
     * @memberOf User
     * @description ログイン
     * @param {Object} userInfo ユーザ情報。
     * JSON 形式で指定する。null は指定できない。
     * <pre>
     *     {
     *         "email"         : "foo@example.com",
     *         "password"      : "passwOrd"
     *     }</pre>
     * <pre>
     *     {
     *         "token"         : "TOKEN"
     *     }</pre>
     *  <ul>
     *     <li>email       : E-mailアドレス（※）
     *     <li>username    : ユーザ名（※）
     *     <li>token       : ワンタイムトークン（※）
     *     <li>password    : パスワード（E-mailアドレス、ユーザ名指定時は必須）
     *   </ul>
     *  (※) email か username か token のいずれかを指定する。
     * @param {Callbacks} callbacks コールバック (Option)
     * @return {Promise} callbacksを指定しなかった場合、Promiseオブジェクトを返す。callback指定時は返り値なし(undefined)。
     * <p>処理完了時に渡される値は以下の通り。
     * <ul>
     * <li>成功時: ログインしたユーザオブジェクトのインスタンス。
     *           処理の成功により、以下のユーザオブジェクトのプ