import type { BoardUnitPermissionAction } from '@univerjs-pro/boards';
import type { ICommandService, IObjectPermissionBatchResult, IObjectPermissionChange, IPermissionService } from '@univerjs/core';
/**
 * Command-backed permissions for one Board unit.
 * @hideconstructor
 */
export declare class FBoardPermission {
    private readonly _unitId;
    private readonly _commandService;
    private readonly _permissionService;
    constructor(_unitId: string, _commandService: ICommandService, _permissionService: IPermissionService);
    /**
     * Creates or updates child-object edit policies in this unit; policy: null removes protection and restores inheritance.
     *
     * Requires Authz support and objectPermissionTypes configured for every target type. File and parent restrictions
     * still apply. Use the exported permission object ID helpers, not raw object IDs or server permission IDs.
     * The batch must be nonempty, contain distinct objects, and belong to this unit; file-wide policies are excluded.
     *
     * edit: 'all' allows Unit editors, 'owner' restricts editing to the object owner, and 'members' selects existing
     * Unit collaborators. Pass their collaborator records from the member service; this does not invite new users.
     * Use strategies: [] for the default Edit strategy; child-object strategies support only UnitAction.Edit.
     *
     * Authz writes execute per object and can partially succeed. Inspect failed before retrying only those objects.
     * refreshError means writes finished but permission readback failed; do not retry succeeded objects for that error.
     * Successful binding changes share one undo entry; existing remote policy edits are not undoable.
     * @param {IObjectPermissionChange[]} changes Permission object IDs and policies to apply.
     * @returns {Promise<IObjectPermissionBatchResult>} Successful object IDs, per-object failures, and optional readback error.
     * @throws {Error} Invalid batches or unsupported object types are rejected before Authz writes.
     * @example Set owner/member editing and remove protection in one batch
     * ```ts
     * import type { ICollaborator } from '@univerjs/protocol';
     * import { getBoardElementPermissionObjectId } from '@univerjs-pro/boards';
     *
     * // selectedMembers comes from the existing Unit collaborator picker/service.
     * async function applyPermissions(selectedMembers: ICollaborator[]) {
     *     if (!selectedMembers.length) throw new Error('Select at least one Unit collaborator.');
     *     const board = univerAPI.getActiveBoard();
     *     if (!board) throw new Error('No active board.');
     *     const snapshot = board.getData();
     *     const pageId = snapshot.activePageId ?? snapshot.pageOrder[0];
     *     if (!pageId) throw new Error('No Board page.');
     *     const objectIds = Object.keys(board.getElements()).slice(0, 3)
     *         .map((elementId) => getBoardElementPermissionObjectId(pageId, elementId));
     *     if (objectIds.length < 3) throw new Error('This example requires three elements.');
     *     const result = await board.getPermission().setObjectPermissions([
     *         { objectId: objectIds[0], policy: { edit: 'owner', collaborators: [], strategies: [] } },
     *         { objectId: objectIds[1], policy: { edit: 'members', collaborators: selectedMembers, strategies: [] } },
     *         { objectId: objectIds[2], policy: null },
     *     ]);
     *     // A policy creates protection if absent, or updates the existing policy when already configured.
     *     for (const failure of result.failed) {
     *         console.error(failure.objectId, failure.error);
     *     }
     *     if (result.refreshError) {
     *         console.error(result.refreshError);
     *     }
     *     return result;
     * }
     * ```
     */
    setObjectPermissions(changes: IObjectPermissionChange[]): Promise<IObjectPermissionBatchResult>;
    /**
     * Sets one Board unit permission through the command system.
     *
     * Supported actions are Edit, Copy, Print, Export, and Comment.
     * @param {BoardUnitPermissionAction} action Unit permission action to update.
     * @param {boolean} value Whether the action is allowed.
     * @returns {Promise<void>} Resolves after the permission command finishes.
     * @example
     * ```ts
     * import { UnitAction } from '@univerjs/protocol';
     *
     * const board = univerAPI.getActiveBoard();
     * if (!board) throw new Error('No active Board.');
     * await board.getPermission().setPoint(UnitAction.Copy, false);
     * ```
     */
    setPoint(action: BoardUnitPermissionAction, value: boolean): Promise<void>;
    /**
     * Returns the current value of one Board unit permission.
     * @param {BoardUnitPermissionAction} action Unit permission action to query.
     * @returns {boolean} Whether the action is currently allowed.
     * @example
     * ```ts
     * import { UnitAction } from '@univerjs/protocol';
     *
     * const board = univerAPI.getActiveBoard();
     * console.log(board?.getPermission().getPoint(UnitAction.Print));
     * ```
     */
    getPoint(action: BoardUnitPermissionAction): boolean;
    /**
     * Enables or disables editing for the whole Board.
     * @param {boolean} [editable] Whether editing is allowed. Defaults to true.
     * @returns {Promise<void>} Resolves after the permission command finishes.
     * @example
     * ```ts
     * const board = univerAPI.getActiveBoard();
     * if (!board) throw new Error('No active Board.');
     * await board.getPermission().setEditable();
     * ```
     */
    setEditable(editable?: boolean): Promise<void>;
    /**
     * Makes the whole Board read-only.
     * @returns {Promise<void>} Resolves after the permission command finishes.
     * @example
     * ```ts
     * const board = univerAPI.getActiveBoard();
     * if (!board) throw new Error('No active Board.');
     * await board.getPermission().setReadOnly();
     * ```
     */
    setReadOnly(): Promise<void>;
    /**
     * Returns whether the whole Board is currently editable.
     * @returns {boolean} Whether Board editing is allowed.
     */
    canEdit(): boolean;
}
/**
 * Command-backed Edit permission for one stable Board element.
 * @hideconstructor
 */
export declare class FBoardElementPermission {
    private readonly _unitId;
    private readonly _objectId;
    private readonly _commandService;
    private readonly _permissionService;
    constructor(_unitId: string, _objectId: string, _commandService: ICommandService, _permissionService: IPermissionService);
    /**
     * Enables or disables editing for one stable Board element.
     * @param {boolean} [editable] Whether element editing is allowed. Defaults to true.
     * @returns {Promise<void>} Resolves after the permission command finishes.
     * @example
     * ```ts
     * const board = univerAPI.getActiveBoard();
     * if (!board) throw new Error('No active Board.');
     * const element = Object.values(board.getElements())[0];
     * if (!element) throw new Error('Board element not found.');
     * await board.getElementPermission(element.id).setEditable();
     * ```
     */
    setEditable(editable?: boolean): Promise<void>;
    /**
     * Makes this Board element read-only.
     * @returns {Promise<void>} Resolves after the permission command finishes.
     */
    setReadOnly(): Promise<void>;
    /**
     * Returns the effective Edit result after applying the Board unit and element permissions.
     * @returns {boolean} Whether the element is currently editable.
     */
    canEdit(): boolean;
}