/**
 * (c) Copyright Ascensio System SIA 2026
 *
 * 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.
 *
 * @license
 */
import type { TCreateRoomOptions, TFileInfo, TFilesResponse, TFolderInfo, TFrameConfig, TFrameFilter, THashSettings, TManagerViewMode, TRoomInfo, TRoomsResponse, TUserInfo, TCustomActionsConfig, TFormsSection, TLoginResult, TPersonalSection } from "../types";
/**
 * Manages a single ONLYOFFICE Apps iframe, handles postMessage communication,
 * and exposes methods for operating on the embedded ONLYOFFICE Apps UI.
 *
 * Instances are created and stored by {@link SDK}. Do not construct directly —
 * use {@link SDK.init} or any `init*` convenience wrapper.
 *
 * :::note
 * Every method that talks to the frame returns a promise that rejects with an {@link SDKError}:
 * {@link SDKErrorCode.ApiError} when the portal reports a failure (HTTP status in {@link SDKError.status}),
 * {@link SDKErrorCode.ModeMismatch} when the current mode has no such method,
 * {@link SDKErrorCode.Timeout} after {@link TFrameConfig.methodTimeout} and
 * {@link SDKErrorCode.Disconnected} when the frame is not connected. Two legacy methods differ:
 * {@link SDKInstance.login} and {@link SDKInstance.createRoom} resolve a portal failure as `{ status, message }`.
 * A portal older than ONLYOFFICE Apps 4.0 does not flag failures: there every method resolves the portal's
 * error object instead of rejecting.
 * :::
 *
 * @example
 * ```typescript
 * import { SDK } from '@onlyoffice/docspace-sdk-js';
 *
 * const sdk = new SDK();
 * const instance = sdk.initManager({
 *   frameId: 'ds-frame',
 *   src: 'https://portal.example.com',
 * });
 *
 * instance.getUserInfo().then((user) => console.log(user));
 * ```
 */
export declare class SDKInstance {
    #private;
    /** The iframe configuration options. See {@link TFrameConfig}. */
    config: TFrameConfig;
    /** @param config - Initial frame configuration. See {@link TFrameConfig}. */
    constructor(config: TFrameConfig);
    private static _loaderCache;
    private static _iframeTemplate;
    /**
     * Marks the frame as loaded: fades out the loader spinner, reveals the iframe,
     * and fires {@link TFrameEvents.onContentReady}.
     *
     * The ONLYOFFICE Apps iframe calls this automatically once its content is ready, so most
     * integrations never need to. Call it manually to reveal the frame on your own schedule,
     * for example when the host page shows its own loading overlay. Every call re-applies the
     * iframe size and visibility and fires {@link TFrameEvents.onContentReady}; the loader is
     * removed by the first one.
     *
     * @example
     * ```typescript
     * instance.setIsLoaded();
     * ```
     *
     * @example
     * Reveal the frame from a host-side button instead of waiting for the iframe, then react
     * to the completion via {@link TFrameEvents.onContentReady}.
     * ```typescript
     * const instance = sdk.initManager({
     *   frameId: 'ds-frame',
     *   src: 'https://portal.example.com',
     *   events: { onContentReady: () => console.log('Frame is visible') },
     * });
     *
     * document.getElementById('show-frame').onclick = () => instance.setIsLoaded();
     * ```
     */
    setIsLoaded(): void;
    /**
     * Inserts the ONLYOFFICE Apps iframe into the DOM element identified by {@link TFrameConfig.frameId}.
     *
     * Merges `config` with {@link defaultConfig} and the instance's stored config,
     * replaces the target `<div>` with a container holding the iframe (and an optional loader),
     * attaches the `message` listener, and registers the instance in the global
     * `DocSpace.SDK.frames` registry.
     *
     * Called automatically by {@link SDK.init}. Call again to reinitialize in-place.
     *
     * @param config - Frame configuration. See {@link TFrameConfig}.
     * @returns The created `<iframe>` element, or `null` if the target element was not found.
     *
     * @example
     * ```typescript
     * const iframe = instance.initFrame({
     *   frameId: 'ds-frame',
     *   src: 'https://portal.example.com',
     *   mode: SDKMode.Viewer,
     *   id: 42,
     * });
     * ```
     *
     * @example
     * With event handlers — see {@link TFrameEvents} for the full list of available events.
     * ```typescript
     * const iframe = instance.initFrame({
     *   frameId: 'ds-editor',
     *   src: 'https://portal.example.com',
     *   mode: SDKMode.Editor,
     *   id: 42,
     *   events: {
     *     onAppReady: () => console.log('ready'),
     *     onEditorOpen: () => console.log('document opened'),
     *     onEditorCloseCallback: () => history.back(),
     *   },
     * });
     * ```
     */
    initFrame(config: TFrameConfig): HTMLIFrameElement | null;
    /**
     * Tears down the iframe and releases all resources associated with this instance.
     *
     * Replaces the container with a plain `<div>` (preserving the original `frameId` and CSS classes,
     * showing {@link TFrameConfig.destroyText}), removes the `message` listener, rejects pending
     * method calls with {@link SDKErrorCode.Disconnected}, cancels the proactive OAuth token refresh,
     * and removes the instance from the global `DocSpace.SDK.frames` registry (the `frames` map of the
     * {@link SDK} that created it keeps the entry, so a later `init*` with the same `frameId` reuses the instance). In OAuth mode this is
     * how a host ends the embedded session: no cookie exists, so nothing outlives the frame.
     *
     * The call is synchronous and complete when it returns: the placeholder keeps the `frameId`, so
     * an `SDK.init*` call on the same `frameId` may follow immediately — there is nothing to await.
     *
     * @example
     * ```typescript
     * instance.destroyFrame();
     * ```
     *
     * @example
     * Destroy and reinitialize the same frame in a different mode using {@link SDK.initEditor}.
     * ```typescript
     * instance.destroyFrame();
     * sdk.initEditor({ frameId: 'ds-frame', src: 'https://portal.example.com', id: 99 });
     * ```
     */
    destroyFrame(): void;
    /**
     * Merges `config` into the stored config and sends it to the iframe.
     *
     * When `reload` is `true`, reinitializes the iframe entirely via {@link SDKInstance.initFrame}
     * instead of sending a postMessage update.
     *
     * @param config - Partial frame configuration to merge into the stored config.
     * @param reload - When `true`, reinitializes the frame. Defaults to `false`.
     * @returns A promise that resolves with the iframe's response, or with the merged config if `reload` is `true`.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure.
     *
     * @example
     * ```typescript
     * await instance.setConfig({ theme: Theme.Dark, locale: 'fr-FR' });
     * ```
     *
     * @example
     * Switch to a different document while keeping existing settings —
     * read them first via {@link SDKInstance.getConfig}.
     * ```typescript
     * const current = instance.getConfig();
     * await instance.setConfig({ ...current, id: 99, mode: SDKMode.Editor }, true);
     * ```
     */
    setConfig(config?: Partial<TFrameConfig>, reload?: boolean): Promise<object>;
    /**
     * Returns the current merged configuration object.
     *
     * @returns The active {@link TFrameConfig} for this instance.
     *
     * @example
     * ```typescript
     * const config = instance.getConfig();
     * console.log(config.mode, config.src);
     * ```
     *
     * @example
     * Preserve existing settings when making a partial update via {@link SDKInstance.setConfig}.
     * ```typescript
     * const config = instance.getConfig();
     * await instance.setConfig({ ...config, theme: Theme.Dark });
     * ```
     */
    getConfig(): TFrameConfig;
    /**
     * Available in {@link SDKMode.Manager} and {@link SDKMode.Personal}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Returns metadata about the folder currently open in the frame.
     *
     * @returns A promise that resolves with {@link TFolderInfo}.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure.
     *
     * @example
     * ```typescript
     * const info = await instance.getFolderInfo();
     * console.log(info);
     * ```
     *
     * @example
     * Check write access before calling {@link SDKInstance.createFolder}.
     * ```typescript
     * const info = await instance.getFolderInfo();
     * if (info.security?.create) {
     *   await instance.createFolder(info.id, 'Archive');
     * }
     * ```
     */
    getFolderInfo(): Promise<TFolderInfo>;
    /**
     * Available in {@link SDKMode.Manager} and {@link SDKMode.Personal}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Returns the items currently selected in the frame.
     *
     * @returns A promise that resolves with an array of {@link TFileInfo}.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure.
     *
     * @example
     * ```typescript
     * const selection = await instance.getSelection();
     * console.log(selection);
     * ```
     *
     * @example
     * Pass the selection as context to {@link SDKInstance.openModal}.
     * ```typescript
     * const selection = await instance.getSelection();
     * if (selection.length > 0) {
     *   await instance.openModal('share', { items: selection });
     * }
     * ```
     */
    getSelection(): Promise<TFileInfo[]>;
    /**
     * Available in {@link SDKMode.Manager}, {@link SDKMode.Personal} and {@link SDKMode.Forms}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Returns the files in the folder currently open in the frame.
     *
     * @returns A promise that resolves with {@link TFilesResponse}.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure.
     *
     * @example
     * ```typescript
     * const files = await instance.getFiles();
     * console.log(files);
     * ```
     *
     * @example
     * Open the first file in viewer mode via {@link SDKInstance.setConfig}.
     * ```typescript
     * const files = await instance.getFiles();
     * if (files.files[0]) {
     *   await instance.setConfig({ id: files.files[0].id, mode: SDKMode.Viewer }, true);
     * }
     * ```
     */
    getFiles(): Promise<TFilesResponse>;
    /**
     * Available in {@link SDKMode.Manager}, {@link SDKMode.Personal} and {@link SDKMode.Forms}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Returns the subfolders of the folder currently open in the frame.
     *
     * @returns A promise that resolves with {@link TFilesResponse}.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure.
     *
     * @example
     * ```typescript
     * const folders = await instance.getFolders();
     * console.log(folders);
     * ```
     *
     * @example
     * Navigate into the first subfolder via {@link SDKInstance.setConfig}.
     * ```typescript
     * const folders = await instance.getFolders();
     * if (folders.folders[0]) {
     *   await instance.setConfig({ id: folders.folders[0].id }, true);
     * }
     * ```
     */
    getFolders(): Promise<TFilesResponse>;
    /**
     * Available in {@link SDKMode.Manager}, {@link SDKMode.Personal} and {@link SDKMode.Forms}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Returns all files and folders in the folder currently open in the frame.
     *
     * Use {@link SDKInstance.getFiles} or {@link SDKInstance.getFolders}
     * when you need only one content type.
     *
     * @returns A promise that resolves with {@link TFilesResponse}.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure.
     *
     * @example
     * ```typescript
     * const list = await instance.getList();
     * console.log(list);
     * ```
     *
     * @example
     * ```typescript
     * const list = await instance.getList();
     * console.log('Files:', list.files.length, 'Folders:', list.folders.length);
     * ```
     */
    getList(): Promise<TFilesResponse>;
    /**
     * Available in {@link SDKMode.Manager}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Returns a list of rooms, filtered by `filter`.
     *
     * @param filter - Filter and sort criteria. See {@link TFrameFilter}.
     * @returns A promise that resolves with {@link TRoomsResponse}.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure.
     *
     * @example
     * ```typescript
     * const rooms = await instance.getRooms({
     *   search: 'alpha',
     *   sortBy: FilterSortBy.Name,
     *   sortOrder: FilterSortOrder.Ascending,
     * });
     * console.log(rooms);
     * ```
     *
     * @example
     * Find rooms and remove an outdated tag from each using {@link SDKInstance.removeTagsFromRoom}.
     * ```typescript
     * const rooms = await instance.getRooms({ search: 'sprint-22' });
     * for (const room of rooms.folders) {
     *   await instance.removeTagsFromRoom(room.id, ['in-progress']);
     * }
     * ```
     *
     * @example
     * The rooms of one room group ({@link TFrameFilter.groupId}), e.g. the rooms attached to a deal.
     * ```typescript
     * const deal = await instance.getRooms({ groupId: '42' });
     * console.log(deal.folders.map((room) => room.title));
     * ```
     */
    getRooms(filter: TFrameFilter): Promise<TRoomsResponse>;
    /**
     * Available in {@link SDKMode.Manager}, {@link SDKMode.System}, {@link SDKMode.Personal} and {@link SDKMode.Forms}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Returns information about the currently authenticated user.
     *
     * @returns A promise that resolves with {@link TUserInfo}.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure.
     *
     * @example
     * ```typescript
     * const user = await instance.getUserInfo();
     * console.log(user);
     * ```
     *
     * @example
     * Apply the user's preferred locale via {@link SDKInstance.setConfig}.
     * ```typescript
     * const user = await instance.getUserInfo();
     * if (user.cultureName) {
     *   await instance.setConfig({ locale: user.cultureName });
     * }
     * ```
     */
    getUserInfo(): Promise<TUserInfo>;
    /**
     * Available in {@link SDKMode.Manager} and {@link SDKMode.System}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Returns the server's password hash settings needed by {@link SDKInstance.createHash}.
     *
     * @returns A promise that resolves with {@link THashSettings}.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure.
     *
     * @example
     * ```typescript
     * const settings = await instance.getHashSettings();
     * console.log(settings);
     * ```
     *
     * @example
     * Full authentication flow using {@link SDKInstance.createHash} and {@link SDKInstance.login}.
     * ```typescript
     * const settings = await instance.getHashSettings();
     * const hash = await instance.createHash('p@ssw0rd', settings);
     * await instance.login('user@example.com', hash);
     * ```
     */
    getHashSettings(): Promise<THashSettings>;
    /**
     * Available in {@link SDKMode.Manager} and {@link SDKMode.Personal}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Opens a modal dialog of the specified type inside the frame.
     *
     * @param type - The modal type identifier.
     * @param options - Modal-specific configuration options.
     * @returns A promise that resolves with the modal result.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure.
     *
     * @example
     * ```typescript
     * const result = await instance.openModal('invite', { roomId: 42 });
     * console.log(result);
     * ```
     *
     * @example
     * Open a share dialog for the items currently selected in the frame using {@link SDKInstance.getSelection}.
     * ```typescript
     * const selection = await instance.getSelection();
     * if (selection.length > 0) {
     *   await instance.openModal('share', { items: selection });
     * }
     * ```
     */
    openModal(type: string, options: object): Promise<object>;
    /**
     * Available in {@link SDKMode.Manager} and {@link SDKMode.Personal}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Creates a new file in the specified folder.
     *
     * @param folderId - The ID of the target folder.
     * @param title - The file title. An extension is optional: `"Report.docx"` keeps it, `"Report"` gets `.docx` from the portal.
     * @param templateId - The ID of a file to copy the content from. Omit for an empty document.
     * @param formId - The ID of a form to create the file from. Omit when the file is not based on a form.
     * @returns A promise that resolves with {@link TFileInfo}.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure.
     *
     * @example
     * ```typescript
     * const file = await instance.createFile('folder-123', 'Project Proposal');
     * console.log(file);
     * ```
     *
     * @example
     * Create a file from a template and immediately open it in the editor using {@link SDKInstance.setConfig}.
     * ```typescript
     * const file = await instance.createFile('folder-123', 'Report.docx', 'template-456');
     * await instance.setConfig({ id: file.id, mode: SDKMode.Editor }, true);
     * ```
     */
    createFile(folderId: string | number, title: string, templateId?: string, formId?: string): Promise<TFileInfo>;
    /**
     * Available in {@link SDKMode.Manager} and {@link SDKMode.Personal}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Creates a new folder inside the specified parent folder.
     *
     * @param parentFolderId - The ID of the parent folder.
     * @param title - The folder title.
     * @returns A promise that resolves with {@link TFolderInfo}.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure.
     *
     * @example
     * ```typescript
     * const folder = await instance.createFolder('parent-123', 'Archive');
     * console.log(folder);
     * ```
     *
     * @example
     * Create a folder and immediately add a file inside it using {@link SDKInstance.createFile}.
     * ```typescript
     * const folder = await instance.createFolder('parent-123', 'Q1 Reports');
     * await instance.createFile(folder.id, 'Summary');
     * ```
     */
    createFolder(parentFolderId: string | number, title: string): Promise<TFolderInfo>;
    /**
     * Available in {@link SDKMode.Manager}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Creates a new room with the given type and optional settings.
     *
     * :::note
     * The room type decides which access levels the room accepts: reviewing and commenting exist only in
     * {@link RoomType.Custom}; a {@link RoomType.Collaboration} room offers editing and reading only.
     * Creating a room requires the room admin role on the portal; a user without it gets a `403` result.
     * :::
     *
     * @param title - The room display name.
     * @param roomType - The room type: a {@link RoomType} value or its numeric API value.
     * @param options - Optional room settings. See {@link TCreateRoomOptions}. A JavaScript caller may still pass
     *   the positional arguments of SDK 2.1 (`quota`, `tags`, `color`, `cover`, `indexing`, `denyDownload`).
     * @returns A promise that resolves with {@link TRoomInfo}, or with `{ status, message }` when the portal
     *   reports a failure — unlike the other methods, `createRoom` does not reject on portal errors.
     *
     * @example
     * ```typescript
     * const room = await instance.createRoom('Design Team', RoomType.Collaboration, { tags: ['design'] });
     * console.log(room);
     * ```
     *
     * @example
     * Create a room, then create a new tag and apply it using {@link SDKInstance.createTag}
     * and {@link SDKInstance.addTagsToRoom}.
     * ```typescript
     * const room = await instance.createRoom('Marketing', RoomType.Custom);
     * await instance.createTag('campaigns');
     * await instance.addTagsToRoom(room.id, ['campaigns']);
     * ```
     */
    createRoom(title: string, roomType: string | number, options?: TCreateRoomOptions): Promise<TRoomInfo>;
    /**
     * Available in {@link SDKMode.Manager} and {@link SDKMode.Personal}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Switches the file list display mode.
     *
     * @param viewType - The view mode: `"row"`, `"table"`, or `"tile"`.
     * @returns A promise that resolves with the result of the operation.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure.
     *
     * @example
     * ```typescript
     * await instance.setListView('table');
     * ```
     *
     * @example
     * Switch to tile view only when in manager mode — read the current mode via {@link SDKInstance.getConfig}.
     * ```typescript
     * const { mode } = instance.getConfig();
     * if (mode === SDKMode.Manager) {
     *   await instance.setListView('tile');
     * }
     * ```
     */
    setListView(viewType: TManagerViewMode): Promise<object>;
    /**
     * Available in {@link SDKMode.Manager} and {@link SDKMode.System}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Creates a password hash using the provided hash settings.
     *
     * Obtain `hashSettings` from {@link SDKInstance.getHashSettings} before calling this method.
     *
     * @param password - The plaintext password to hash.
     * @param hashSettings - Hash algorithm settings from {@link SDKInstance.getHashSettings}.
     * @returns A promise that resolves with the generated hash.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure.
     *
     * @example
     * ```typescript
     * const settings = await instance.getHashSettings();
     * const hash = await instance.createHash('p@ssw0rd', settings);
     * console.log(hash);
     * ```
     *
     * @example
     * Full login flow using {@link SDKInstance.getHashSettings} and {@link SDKInstance.login}.
     * ```typescript
     * const settings = await instance.getHashSettings();
     * const hash = await instance.createHash('p@ssw0rd', settings);
     * await instance.login('user@example.com', hash, undefined, true);
     * ```
     */
    createHash(password: string, hashSettings: object): Promise<object>;
    /**
     * Available in {@link SDKMode.Manager} and {@link SDKMode.System}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Authenticates a user using email and a hashed password.
     *
     * Obtain `passwordHash` from {@link SDKInstance.createHash}. The portal's SDK dispatcher
     * (client 4.0.0) forwards only `email` and `passwordHash` to its sign-in and always requests a
     * persistent session; the REST endpoint behind it would also take a plaintext password and a
     * session flag, but neither reaches it from the frame.
     *
     * :::note
     * A failed sign-in is **resolved, not rejected** — see {@link TLoginResult}. `url === "/"` means a
     * session exists; a `url` under `/confirm/` means the account needs a second factor and no
     * session was created — call `login` again with the same credentials and the one-time `code`;
     * a `status` (`401` for wrong credentials) with a `message` means the attempt failed. Only SDK-side
     * failures reject: {@link SDKErrorCode.Timeout}, {@link SDKErrorCode.Disconnected},
     * {@link SDKErrorCode.ModeMismatch} — the latter also in OAuth mode ({@link TFrameConfig.getToken} or
     * {@link TFrameConfig.accessToken} set), where the host owns the session and no cookie sign-in is
     * possible. A portal whose SDK dispatcher predates the `code`
     * argument ignores it and answers the challenge again; on such a portal the login page remains
     * the only way to complete a two-factor sign-in.
     * :::
     *
     * @param email - The user's email address.
     * @param passwordHash - The hashed password (from {@link SDKInstance.createHash}).
     * @param password - Not forwarded by the portal's SDK dispatcher (client 4.0.0); use `passwordHash`.
     * @param session - Not forwarded by the portal's SDK dispatcher (client 4.0.0); the session is always persistent.
     * @param code - One-time code from the authenticator app or SMS; finishes a login that answered with a `/confirm/…` url.
     * @returns A promise that resolves with the authentication result — see {@link TLoginResult}.
     *   Unlike the other methods, a portal failure is resolved as `{ status, message }`, not rejected.
     *
     * @example
     * Login with a pre-hashed password from {@link SDKInstance.createHash}.
     * ```typescript
     * const result = await instance.login('user@example.com', passwordHash);
     * if (!result.url) throw new Error(result.message ?? 'login failed');
     * ```
     *
     * @example
     * Two-factor sign-in using {@link SDKInstance.getHashSettings} and {@link SDKInstance.createHash}.
     * ```typescript
     * const settings = await instance.getHashSettings();
     * const hash = await instance.createHash('p@ssw0rd', settings);
     * const first = await instance.login('user@example.com', hash);
     * if (first.url?.startsWith('/confirm/')) {
     *   const code = await askUserForCode();
     *   const second = await instance.login('user@example.com', hash, undefined, undefined, code);
     *   if (second.status) throw new Error('wrong code');
     * }
     * ```
     */
    login(email: string, passwordHash: string, password?: string, session?: boolean, code?: string): Promise<TLoginResult>;
    /**
     * Available in {@link SDKMode.Manager} and {@link SDKMode.System}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Ends the current user session.
     *
     * In OAuth mode ({@link TFrameConfig.getToken} or {@link TFrameConfig.accessToken} set) there is no
     * portal session to end: the frame authenticates every request with the host's token. The call
     * rejects with {@link SDKErrorCode.ModeMismatch}; revoke the token on the host and call
     * {@link SDKInstance.destroyFrame} instead.
     *
     * @returns A promise that resolves with the logout result.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure,
     *   and with {@link SDKErrorCode.ModeMismatch} in OAuth mode.
     *
     * @example
     * ```typescript
     * await instance.logout();
     * ```
     *
     * @example
     * Log out and immediately authenticate as a different user using {@link SDKInstance.getHashSettings},
     * {@link SDKInstance.createHash}, and {@link SDKInstance.login}.
     * ```typescript
     * await instance.logout();
     * const settings = await instance.getHashSettings();
     * const hash = await instance.createHash('newpassword', settings);
     * await instance.login('other@example.com', hash);
     * ```
     */
    logout(): Promise<object>;
    /**
     * Available in {@link SDKMode.Manager}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Creates a new tag with the given name.
     *
     * @param name - The tag name.
     * @returns A promise that resolves with the created tag data.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure.
     *
     * @example
     * ```typescript
     * const tag = await instance.createTag('Project Alpha');
     * console.log(tag);
     * ```
     *
     * @example
     * Create a tag and immediately apply it to a room using {@link SDKInstance.addTagsToRoom}.
     * ```typescript
     * await instance.createTag('archived');
     * await instance.addTagsToRoom('room-123', ['archived']);
     * ```
     */
    createTag(name: string): Promise<object>;
    /**
     * Available in {@link SDKMode.Manager}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Adds the specified tags to a room.
     *
     * @param roomId - The room ID.
     * @param tags - Tag names to add.
     * @returns A promise that resolves with the result of the operation.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure.
     *
     * @example
     * ```typescript
     * await instance.addTagsToRoom('room-123', ['design', 'q1']);
     * ```
     *
     * @example
     * Create a new tag with {@link SDKInstance.createTag} and apply it
     * to a newly created room via {@link SDKInstance.createRoom}.
     * ```typescript
     * await instance.createTag('design');
     * const room = await instance.createRoom('Creative Hub', RoomType.Collaboration);
     * await instance.addTagsToRoom(room.id, ['design']);
     * ```
     */
    addTagsToRoom(roomId: string | number, tags: string[]): Promise<object>;
    /**
     * Available in {@link SDKMode.Manager}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Removes the specified tags from a room.
     *
     * @param roomId - The room ID.
     * @param tags - Tag names to remove.
     * @returns A promise that resolves with the result of the operation.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure.
     *
     * @example
     * ```typescript
     * await instance.removeTagsFromRoom('room-123', ['draft', 'in-progress']);
     * ```
     *
     * @example
     * Find rooms by name and clean up a tag from each using {@link SDKInstance.getRooms}.
     * ```typescript
     * const rooms = await instance.getRooms({ search: 'sprint-22' });
     * for (const room of rooms.folders) {
     *   await instance.removeTagsFromRoom(room.id, ['in-progress']);
     * }
     * ```
     */
    removeTagsFromRoom(roomId: string | number, tags: string[]): Promise<object>;
    /**
     * Available in {@link SDKMode.Editor} and {@link SDKMode.Viewer}; in any other mode the portal answers that
     * the method does not exist and the promise rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Runs a callback function inside the active document editor.
     *
     * The callback is serialized with `Function.prototype.toString` and re-created inside the
     * editor frame, so it must not reference outer-scope variables, closures or imports — pass
     * everything it needs through `data`. The editor frame invokes it as
     * `callback(editor, asc, data)`:
     *
     * - `editor` — the DocsAPI editor object (`window.DocEditor.instances[...]`). Call
     *   `editor.createConnector()` yourself to get a connector with `callCommand` /
     *   `executeMethod`; the SDK does not create one for you.
     * - `asc` — `window.Asc` of the editor frame. `asc.scope` is serialized into every
     *   `connector.callCommand(fn)` and is the way to pass data into Document Builder code.
     * - `data` — the `data` argument of this method, JSON-serialized.
     *
     * @param callback - The function to run inside the editor context. Invoked as
     *   `callback(editor, asc, data)` — note that `data` is the **third** argument.
     * @param data - Optional JSON-serializable data passed as the third argument to `callback`.
     * @returns A promise that resolves with `{}` once the editor frame has run the callback.
     *   An error thrown by the callback is logged inside the editor frame and does not reject the promise.
     *
     * @example
     * ```typescript
     * instance.executeInEditor((editor, _asc, data) => {
     *   editor.insertText(data.text);
     * }, { text: 'Hello, World!' });
     * ```
     *
     * @example
     * Initialize editor mode with {@link SDK.initEditor} and inject content when the document is ready.
     * ```typescript
     * const instance = sdk.initEditor({
     *   frameId: 'ds-editor',
     *   src: 'https://portal.example.com',
     *   id: 42,
     *   events: {
     *     onEditorOpen: () => {
     *       instance.executeInEditor((editor, _asc, data) => {
     *         editor.insertText(data.header);
     *       }, { header: 'Generated by SDK' });
     *     },
     *   },
     * });
     * ```
     *
     * @example
     * Fill form fields with the Document Builder API through a connector. Data reaches the
     * `callCommand` function via `Asc.scope`; the function itself must be closure-free.
     * ```typescript
     * instance.executeInEditor(function (editor, asc, data) {
     *   const connector = editor.createConnector();
     *   asc.scope = { values: data.values };
     *   connector.callCommand(function () {
     *     const doc = Api.GetDocument();
     *     for (const form of doc.GetAllForms()) {
     *       const value = Asc.scope.values[form.GetFormKey()];
     *       if (value === undefined) continue;
     *       if (form.GetFormType() === 'checkBoxForm') form.SetChecked(!!value);
     *       else form.SetText(String(value));
     *     }
     *   });
     * }, { values: { FullName: 'Jane Doe', Agree: true } });
     * ```
     */
    executeInEditor(callback: (editor: any, asc: any, data?: any) => void, data?: object): Promise<object>;
    /**
     * Available in {@link SDKMode.Forms} and {@link SDKMode.Personal}; any other mode rejects with {@link SDKErrorCode.ModeMismatch}.
     *
     * Navigates the frame to a specific section.
     *
     * @param section - Target section. For {@link SDKMode.Forms} — {@link TFormsSection};
     *   for {@link SDKMode.Personal} — {@link TPersonalSection}.
     * @returns A promise that resolves when the navigation is complete.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure,
     *   or with {@link SDKErrorCode.ModeMismatch} in any other mode.
     *
     * @example
     * Forms mode.
     * ```typescript
     * await instance.navigateSection("completed-forms");
     * ```
     *
     * @example
     * Personal mode.
     * ```typescript
     * const personal = sdk.initPersonal({
     *   frameId: 'ds-personal',
     *   src: 'https://portal.example.com',
     * });
     * await personal.navigateSection("trash");
     * ```
     */
    navigateSection(section: TFormsSection | TPersonalSection): Promise<object>;
    /**
     * Replaces the custom actions of the frame: context menu items for files, folders and rooms and
     * items of the create ("+") menu. Groups left out of `config` are cleared; pass `{}` to remove all items.
     * Available in {@link SDKMode.Manager}, {@link SDKMode.Personal} and {@link SDKMode.Forms}.
     * Room actions are shown in {@link SDKMode.Manager} only, create menu items in {@link SDKMode.Manager}
     * and {@link SDKMode.Personal}. When an action is clicked, {@link TFrameEvents.onCustomAction} fires
     * with a {@link TCustomActionEvent}. To show the items from the first render, set
     * {@link TFrameConfig.customActions} instead.
     *
     * @param config - Custom actions configuration. See {@link TCustomActionsConfig}.
     * @returns A promise that resolves when the actions are applied.
     *   Rejects with {@link SDKError} ({@link SDKErrorCode.ApiError}) when the portal reports a failure,
     *   or with {@link SDKErrorCode.ModeMismatch} in any other mode.
     *
     * @example
     * ```typescript
     * await instance.setCustomActions({
     *   contextMenu: {
     *     file: [
     *       { key: "send-to-crm", label: "Send to CRM", icon: "https://example.com/icon.svg" },
     *       { key: "export", label: "Export", extensions: ["pdf"] },
     *     ],
     *     room: [{ key: "unlink", label: "Unlink from deal", requireSecurity: ["EditRoom"] }],
     *   },
     *   createMenu: [{ key: "upload-from-crm", label: "Upload from CRM" }],
     * });
     * ```
     *
     * @example
     * Handle the custom action event on the host page.
     * ```typescript
     * const manager = sdk.initManager({
     *   frameId: 'ds-frame',
     *   src: 'https://portal.example.com',
     *   events: {
     *     onCustomAction: ({ action, items }) => console.log(action, items),
     *   },
     * });
     * await manager.setCustomActions({
     *   contextMenu: { file: [{ key: "approve", label: "Approve" }] },
     * });
     * ```
     */
    setCustomActions(config: TCustomActionsConfig): Promise<object>;
    /**
     * Uploads a file into the frame's current location: the form filling room in
     * {@link SDKMode.Forms}, the open folder in {@link SDKMode.Personal}.
     * The file is transferred to the iframe via zero-copy ArrayBuffer and uploaded
     * using the chunked upload API. The file list refreshes automatically when complete.
     *
     * @param file - The file to upload. Callers should validate type and size before calling.
     * @returns A promise that resolves with the {@link TUploadResult} of {@link TFrameEvents.onUploadSuccess},
     *   so a handler for that event is optional. Rejects with {@link SDKErrorCode.UploadFailed} on
     *   {@link TFrameEvents.onUploadError} or after 120 seconds, {@link SDKErrorCode.ModeMismatch} in any
     *   other mode, {@link SDKErrorCode.Disconnected} before the frame is connected.
     *
     * :::note
     * The entire file is read into memory via `arrayBuffer()` before transfer.
     * Callers should validate file size before invoking this method to avoid
     * excessive memory usage on the host page. The server-side upload limit
     * is configured in ONLYOFFICE Apps and will reject files that exceed it.
     *
     * The ArrayBuffer is transferred to the iframe (zero-copy). After `upload()`
     * returns, the buffer is neutered and cannot be reused.
     *
     * {@link TFrameConfig.methodTimeout} does not apply to the transfer, and
     * {@link TFrameEvents.onUploadProgress} is not emitted for it.
     * :::
     *
     * @example
     * ```typescript
     * const input = document.querySelector("input[type=file]");
     * const file = input.files[0];
     * const result = await instance.upload(file);
     * ```
     *
     * @example
     * Upload with error handling.
     * ```typescript
     * try {
     *   await forms.upload(file);
     *   console.log("Upload complete");
     * } catch (err) {
     *   console.error("Upload failed:", err.message);
     * }
     * ```
     */
    upload(file: File): Promise<object>;
}