@sheetxl/sdk 0.7.26 → 0.7.28-beta.1

package/types/src/protectedRange/IProtectedRange.d.ts

@@ -0,0 +1,239 @@
+import { IAnchored } from '../anchored';
+import { ICellRanges } from '../cellRange';
+import { IListener } from '../listener';
+import { IProtection } from '../protection';
+import { ITransaction } from '../transaction';
+/**
+ * A named range (or set of ranges) that stays editable while the sheet as a whole is protected.
+ *
+ * @remarks
+ * Excel surfaces these as *Review → Allow Edit Ranges*, and OOXML persists them as
+ * `<protectedRange>` inside `<protectedRanges>`. Despite the name, a protected range **relaxes**
+ * protection rather than adding it: it is only consulted while {@link ISheetProtection.isLocked}
+ * is true, and it grants an exemption for the cells it covers — optionally behind a password.
+ *
+ * * Like {@link IConditionalFormat} and {@link IDataValidation}, one entry may be anchored to
+ *   several discontiguous ranges (`sqref="A1:B4 D1:D9"`), and any single range can become several
+ *   when a row/column delete splits it.
+ * * {@link getName} is required and unique within the sheet.
+ */
+export interface IProtectedRange extends IAnchored {
+    /**
+     * The unique name for this entry.
+     *
+     * @remarks
+     * Required by OOXML and unique within the sheet, but unrelated to the ranges it covers — it is a
+     * label, not a defined name, and never resolves as a reference.
+     */
+    getName(): string;
+    /**
+     * @see {@link IProtectedRange.getName}
+     *
+     * @param name The new name. Must be non-empty and unique within the sheet.
+     */
+    setName(name: string, options?: ITransaction.OperationOptions): this;
+    /**
+     * Returns the index of this entry within its container.
+     *
+     * @remarks
+     * Unlike {@link IConditionalFormat.getIndex} this carries no evaluation semantics — protected
+     * ranges are an unordered set in OOXML. The index exists so the UI can present a stable list.
+     */
+    getIndex(): number;
+    /**
+     * @see {@link IProtectedRange.getIndex}
+     */
+    setIndex(index: number): this;
+    /**
+     * Re-anchors this protected range to `address`, REPLACING every range it currently covers.
+     *
+     * @param address The range or ranges to cover — anything `ISheet.getRanges` accepts
+     *   (`'A1:C20'`, `'A1:A5, C1:C5'`, coords). Resolved against this protected range's own sheet.
+     * @param options Transaction options; `description` names the entry in undo history.
+     *
+     * @remarks
+     * A REPLACE, not an add: the ranges named become the whole anchor. An address that names
+     * nothing throws rather than leaving the protected range unanchored — clearing is
+     * {@link IAnchored.delete}.
+     *
+     * Undoable, and refused on a protected sheet. A protected range spans several ranges as readily as
+     * one; the OOXML `sqref` carries the whole list.
+     */
+    setRanges(address: ICellRanges.Address, options?: ITransaction.OperationOptions): this;
+    /**
+     * The relative security descriptor, or `null` if there is none.
+     *
+     * @remarks
+     * Names the user accounts that may edit this range without supplying a password, e.g.
+     * `"O:WDG:WDD:(A;;CC;;;AN)"`. SheetXL does not evaluate this — it is preserved for round-trip
+     * until the user identity system lands.
+     *
+     * @see {@link IProtection.IdentityProvider}
+     */
+    getSecurityDescriptor(): string | null;
+    /**
+     * @see {@link IProtectedRange.getSecurityDescriptor}
+     */
+    setSecurityDescriptor(descriptor: string | null, options?: ITransaction.OperationOptions): this;
+    /**
+     * Returns `true` if a password must be supplied to edit this range.
+     */
+    hasPassword(): boolean;
+    /**
+     * Sets (or clears) the password required to edit this range.
+     *
+     * @param password The plain-text password, or `null` to remove it.
+     * @param options {@link IProtectedRange.SetPasswordOptions}
+     *
+     * @remarks
+     * The password is hashed before it reaches the model state — the plain text is never stored and
+     * never serialized. Asynchronous because hashing is (`PasswordHasher` runs a spin count).
+     */
+    setPassword(password: string | null, options?: IProtectedRange.SetPasswordOptions): Promise<this>;
+    /**
+     * Verifies a plain-text password against the stored hash.
+     *
+     * @param password The password to check.
+     * @returns `true` when it matches, or when no password is set. `false` otherwise.
+     *
+     * @remarks
+     * Never throws for a wrong password — unlike {@link IProtection.checkPassword}, which is a
+     * gate. This is a predicate.
+     */
+    checkPassword(password?: string): Promise<boolean>;
+    /**
+     * The stored password hash, or `null` if there is none.
+     *
+     * @remarks
+     * For persistence. The plain text is not recoverable from this.
+     */
+    getEncryptedPassword(): Readonly<Partial<IProtection.EncryptedPassword>> | null;
+    /**
+     * Whether edits to this range are currently permitted on a protected sheet.
+     *
+     * @remarks
+     * * `true` whenever there is no password — that is the whole point of an entry without one, and
+     *   it needs no ceremony.
+     * * With a password, `true` only after {@link unlock} succeeded.
+     *
+     * **Session state, not document state.** It is never serialized, never recorded on the undo
+     * stack, and resets when the workbook is reopened — the same shape as
+     * {@link IProtection.isPaused}. This is what lets the write path consult it synchronously; a
+     * password check is async and cannot be awaited per cell.
+     */
+    isUnlocked(): boolean;
+    /**
+     * Grants edit access to this range for the rest of the session.
+     *
+     * @param password The password, when one is set.
+     * @returns `true` when access was granted, `false` when the password did not match.
+     *
+     * @remarks
+     * Does not throw on a wrong password — callers are UI prompts that want to re-ask.
+     * @see {@link isUnlocked}
+     */
+    unlock(password?: string): Promise<boolean>;
+    /**
+     * Revokes a previous {@link unlock}.
+     *
+     * @remarks
+     * A no-op when there is no password, since such a range is always unlocked.
+     */
+    relock(): this;
+    /**
+     * Set multiple properties at the same time.
+     *
+     * @remarks
+     * `password` here is the **already encrypted** form — use {@link setPassword} to set one from
+     * plain text.
+     */
+    update(properties: Partial<IProtectedRange.Properties> | IProtectedRange, options?: ITransaction.OperationOptions): this;
+    /**
+     * Add Listeners.
+     *
+     * @see
+     * {@link IListener.ISource.addListeners}
+     */
+    addListeners(listeners: IProtectedRange.IListeners, options?: IListener.Options): IListener.Remove;
+    /**
+     * @returns The current state as a JSON object, or `null` if there is no state.
+     */
+    toJSON(): IProtectedRange.JSON | null;
+    /**
+     * For runtime type checking.
+     */
+    readonly isIProtectedRange: true;
+}
+/**
+ * Capabilities for working with ranges that stay editable on a protected sheet.
+ *
+ * @see
+ * ### **Interface**
+ *
+ * {@link IProtectedRange}
+ *
+ * **Additional Interfaces**
+ * * {@link IProtectedRangeCollection}
+ */
+export declare namespace IProtectedRange {
+    /**
+     * Options for {@link IProtectedRange.setPassword}.
+     */
+    interface SetPasswordOptions extends ITransaction.OperationOptions {
+        /**
+         * The hash algorithm.
+         *
+         * @defaultValue `SHA-512`
+         */
+        algorithm?: string;
+        /**
+         * The number of hash iterations.
+         *
+         * @defaultValue `100000`
+         */
+        spinCount?: number;
+    }
+    /**
+     * A set of values that can be set on an {@link IProtectedRange}.
+     */
+    interface Properties {
+        /**
+         * {@inheritDoc IProtectedRange.getName}
+         */
+        name?: string;
+        /**
+         * {@inheritDoc IProtectedRange.getSecurityDescriptor}
+         */
+        securityDescriptor?: string;
+        /**
+         * The encrypted password. An absent value means the range needs no password.
+         *
+         * @remarks
+         * Never the plain text — see {@link IProtectedRange.setPassword}.
+         */
+        password?: Partial<IProtection.EncryptedPassword>;
+    }
+    /**
+     * A JSON representation useful for persistence.
+     */
+    interface JSON extends Properties {
+    }
+    /**
+     * IListener for {@link IProtectedRange} events.
+     */
+    interface Events extends IAnchored.Events<IProtectedRange> {
+        /**
+         * Called when the name, descriptor or password changes.
+         */
+        onConfigChange?(source: IProtectedRange): void;
+        /**
+         * Called when session edit access changes.
+         *
+         * @see {@link IProtectedRange.isUnlocked}
+         */
+        onUnlockChange?(source: IProtectedRange): void;
+    }
+    interface IListeners extends IListener.Callbacks<IProtectedRange, IProtectedRange.Events> {
+    }
+}
+//# sourceMappingURL=IProtectedRange.d.ts.map

package/types/src/protectedRange/IProtectedRangeCollection.d.ts

@@ -0,0 +1,73 @@
+import { ICellRange, ICellRanges } from '../cellRange';
+import { ICollection } from '../type';
+import { ITransaction } from '../transaction';
+import { IProtectedRange } from './IProtectedRange';
+/**
+ * Holds a collection of {@link IProtectedRange}s.
+ */
+export interface IProtectedRangeCollection extends ICollection<IProtectedRange> {
+    /**
+     * Add an `IProtectedRange` to the container.
+     *
+     * @param address The address of the item. May name several discontiguous ranges.
+     * @param options {@link IProtectedRangeCollection.AddOptions}
+     *
+     * @remarks
+     * If no name is supplied one is generated (`Range1`, `Range2`, …), matching Excel.
+     */
+    add(address: ICellRanges.Address | IProtectedRange, options?: IProtectedRangeCollection.AddOptions): IProtectedRange;
+    /**
+     * Returns items that match the filter criteria.
+     *
+     * If no filter criteria is provided, all items will be returned.
+     *
+     * @param options {@link IProtectedRangeCollection.GetItemsOptions}
+     */
+    getItems(options?: IProtectedRangeCollection.GetItemsOptions): IProtectedRange[];
+    /**
+     * Create a temporary item that can be interacted with but is not added to the collection.
+     *
+     * @param template A template to use for the temporary item.
+     */
+    createItem(template?: IProtectedRange): IProtectedRange;
+}
+/**
+ * {@inheritDoc IProtectedRangeCollection}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IProtectedRangeCollection}
+ */
+export declare namespace IProtectedRangeCollection {
+    /**
+     * Options for adding an {@link IProtectedRange}.
+     */
+    interface AddOptions extends IProtectedRange.Properties, ITransaction.OperationOptions {
+    }
+    /**
+     * Options for searching for {@link IProtectedRange}s.
+     */
+    interface GetItemsOptions extends ICollection.GetItemsOptions {
+        /**
+         * If provided, the search will be limited to items that intersect the range.
+         */
+        address?: ICellRange.Address;
+        /**
+         * Indicate if items that are in hidden headers or marked as hidden should be returned.
+         *
+         * @defaultValue false
+         */
+        ignoreHidden?: boolean;
+        /**
+         * Only return items that are completely contained with the search bounds.
+         *
+         * @defaultValue false
+         */
+        fullyContained?: boolean;
+        /**
+         * Search with the given name. This is case insensitive.
+         */
+        name?: string;
+    }
+}
+//# sourceMappingURL=IProtectedRangeCollection.d.ts.map

package/types/src/protectedRange/ProtectedRange.d.ts

@@ -0,0 +1,101 @@
+import { IRange } from '@sheetxl/primitives';
+import { IListener } from '../listener';
+import { ITransaction } from '../transaction';
+import { ICellRanges } from '../cellRange';
+import { Anchored } from '../anchored/Anchored';
+import { AbstractAnchored } from '../anchored/AbstractAnchored';
+import { IProtection } from '../protection';
+import { IProtectedRange } from './IProtectedRange';
+/**
+ * Implementation of {@link IProtectedRange}.
+ *
+ * @remarks
+ * Extends {@link AbstractAnchored} directly rather than `AnchoredConditional`: a protected range
+ * has no condition and does not depend on cell values, so it never subscribes to range events.
+ */
+export declare class ProtectedRange extends AbstractAnchored<State, CommitView, IProtectedRange.Events> implements IProtectedRange {
+    /**
+     * Session edit access — set by {@link unlock}, cleared by {@link relock}.
+     *
+     * @remarks
+     * A plain field, deliberately NOT in `State`: this is session state, so it must not serialize,
+     * must not land on the undo stack, and must not be restored by an undo of an unrelated edit.
+     * Model identity is stable across `AnchoredMap` clones (a shift re-points entries, it does not
+     * rebuild models), so the field survives every path that would rewrite `State`.
+     *
+     * Only meaningful when a password is set — see {@link isUnlocked}.
+     */
+    private _sessionUnlocked;
+    /** @internal */
+    protected _initialize(options: ProtectedRange.ConstructorOptions): void;
+    /** @internal */
+    protected _getActionDescription(action: 'delete' | 'initialize' | 'updateListener'): string | null;
+    /**
+     * Whether the anchor is absolute. See {@link AbstractAnchored._isAnchorAbsolute}.
+     *
+     * @remarks
+     * Always — like data validations and conditional formats, a protected range pins to where it was
+     * authored and Excel presents its `sqref` as absolute.
+     */
+    protected _isAnchorAbsolute(): boolean;
+    /** @internal */
+    protected _processContainerShift(options: Anchored.ShiftOptions): IRange.Coords | null | void;
+    /** {@inheritDoc IProtectedRange.getName} */
+    getName(): string;
+    /** {@inheritDoc IProtectedRange.setName} */
+    setName(name: string, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IProtectedRange.getIndex} */
+    getIndex(): number;
+    /** {@inheritDoc IProtectedRange.setIndex} */
+    setIndex(index: number): this;
+    /** {@inheritDoc IProtectedRange.setRanges} */
+    setRanges(address: ICellRanges.Address, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IProtectedRange.getSecurityDescriptor} */
+    getSecurityDescriptor(): string | null;
+    /** {@inheritDoc IProtectedRange.setSecurityDescriptor} */
+    setSecurityDescriptor(descriptor: string | null, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IProtectedRange.hasPassword} */
+    hasPassword(): boolean;
+    /** {@inheritDoc IProtectedRange.getEncryptedPassword} */
+    getEncryptedPassword(): Readonly<Partial<IProtection.EncryptedPassword>> | null;
+    /** {@inheritDoc IProtectedRange.setPassword} */
+    setPassword(password: string | null, options?: IProtectedRange.SetPasswordOptions): Promise<this>;
+    /** {@inheritDoc IProtectedRange.isUnlocked} */
+    isUnlocked(): boolean;
+    /** {@inheritDoc IProtectedRange.unlock} */
+    unlock(password?: string): Promise<boolean>;
+    /** {@inheritDoc IProtectedRange.relock} */
+    relock(): this;
+    /** {@inheritDoc IProtectedRange.checkPassword} */
+    checkPassword(password?: string): Promise<boolean>;
+    /** {@inheritDoc IProtectedRange.update} */
+    update(update: Partial<IProtectedRange.Properties> | IProtectedRange, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IListener.ISource.addListeners} */
+    addListeners(listeners: IProtectedRange.IListeners, options?: IListener.Options): IListener.Remove;
+    /** {@inheritDoc IProtectedRange.toJSON} */
+    toJSON(): IProtectedRange.JSON | null;
+    /** @internal */
+    protected _fromJSON(json?: IProtectedRange.JSON, options?: ITransaction.OperationOptions): void;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc IProtectedRange.isIProtectedRange} */
+    get isIProtectedRange(): true;
+}
+/**
+ * Interfaces for creating a {@link ProtectedRange}.
+ */
+export declare namespace ProtectedRange {
+    interface ConstructorOptions extends Anchored.ConstructorOptions<IProtectedRange.JSON> {
+    }
+}
+/** @internal */
+interface State extends AbstractAnchored.State {
+    name: string;
+    securityDescriptor: string | null;
+    password: Partial<IProtection.EncryptedPassword> | null;
+}
+/** @internal */
+interface CommitView extends AbstractAnchored.CommitView {
+}
+export {};
+//# sourceMappingURL=ProtectedRange.d.ts.map

package/types/src/protectedRange/ProtectedRangeCollection.d.ts

@@ -0,0 +1,21 @@
+import { ICellRanges } from '../cellRange';
+import { IProtectedRangeCollection } from './IProtectedRangeCollection';
+import { IProtectedRange } from './IProtectedRange';
+export declare class ProtectedRangeCollection implements IProtectedRangeCollection {
+    private _add;
+    private _get;
+    private _getByName;
+    private _createItem;
+    constructor(add: (address: ICellRanges.Address | IProtectedRange, options?: IProtectedRangeCollection.AddOptions) => IProtectedRange, get: (address: ICellRanges.Address | null | undefined, ignoreHidden?: boolean, fullyContained?: boolean) => IProtectedRange[], getByName: (name: string) => IProtectedRange | null, createItem: (template?: IProtectedRange | null) => IProtectedRange);
+    /** {@inheritDoc IProtectedRangeCollection.add} */
+    add(address: ICellRanges.Address | IProtectedRange, options?: IProtectedRangeCollection.AddOptions): IProtectedRange;
+    /** {@inheritDoc ICollection.[Symbol.iterator]} */
+    [Symbol.iterator](): IterableIterator<IProtectedRange>;
+    /** {@inheritDoc IProtectedRangeCollection.getItems} */
+    getItems(options?: IProtectedRangeCollection.GetItemsOptions): IProtectedRange[];
+    /** {@inheritDoc IProtectedRangeCollection.createItem} */
+    createItem(template?: IProtectedRange | null): IProtectedRange;
+    /** {@inheritDoc IProtectedRangeCollection.getCount} */
+    getCount(): number;
+}
+//# sourceMappingURL=ProtectedRangeCollection.d.ts.map

package/types/src/protectedRange/index.d.ts

@@ -0,0 +1,3 @@
+export * from './IProtectedRange';
+export * from './IProtectedRangeCollection';
+//# sourceMappingURL=index.d.ts.map

package/types/src/protection/DefaultProtection.d.ts

@@ -0,0 +1,43 @@
+import { IListener } from '../listener';
+import { IProtection } from './IProtection';
+import { ListenerEmitter } from '../listener/ListenerEmitter';
+export declare class DefaultProtection<T, P extends IProtection.Properties, J extends IProtection.JSON> implements IProtection<T, P, J> {
+    protected _emitter: ListenerEmitter<this, IProtection.IListeners>;
+    protected _isPaused: boolean;
+    protected _password: Partial<IProtection.EncryptedPassword> | null;
+    protected _identities: IProtection.IdentityProvider[] | null;
+    protected _properties: Partial<P> | null;
+    protected _isReadOnly: boolean;
+    constructor(json?: J, isReadOnly?: boolean);
+    /** {@inheritDoc IProtection.lock} */
+    lock(properties?: Partial<P>, password?: string, algorithm?: string, spinCount?: number): Promise<IProtection<T, P, J>>;
+    /** {@inheritDoc IProtection.unlock} */
+    unlock(password?: string): Promise<IProtection<T, P, J>>;
+    /** {@inheritDoc IProtection.checkPassword} */
+    checkPassword(password?: string): Promise<boolean>;
+    /** {@inheritDoc IProtection.hasPassword} */
+    hasPassword(): boolean;
+    /** {@inheritDoc IProtection.pause} */
+    pause(password?: string): Promise<IProtection<T, P, J>>;
+    /** {@inheritDoc IProtection.resume} */
+    resume(): IProtection<T, P, J>;
+    /** {@inheritDoc IProtection.isPaused} */
+    isPaused(): boolean;
+    /** {@inheritDoc IProtection.isLocked} */
+    isLocked(): boolean;
+    /** {@inheritDoc IProtection.isReadOnly} */
+    isReadOnly(): boolean;
+    protected _validatePassword(password?: string): Promise<boolean>;
+    getProperties(): Partial<P> | null;
+    protected _isPropertyAllowed(property: keyof P): boolean;
+    protected _updateProperties(properties: IProtection.Properties | null): void;
+    protected _clearProperties(): void;
+    /** {@inheritDoc IListener.ISource.addListeners} */
+    addListeners(listeners: IProtection.IListeners, options?: IListener.Options): IListener.Remove;
+    fromJSON(json?: J): void;
+    protected _fromJSON(_json: J | null): void;
+    protected _toJSON(json: Partial<J>): Partial<J>;
+    /** {@inheritDoc IWorkbookProtection.toJSON} */
+    toJSON(): J | null;
+}
+//# sourceMappingURL=DefaultProtection.d.ts.map

package/types/src/protection/IProtection.d.ts

@@ -0,0 +1,170 @@
+import { IListener } from '../listener';
+/**
+ * Interface representing the base protection functionality for both workbook and sheet protection.
+ * This interface provides methods for locking, unlocking, and managing the protection state.
+ */
+export interface IProtection<T, P extends IProtection.Properties, J extends IProtection.JSON> {
+    /**
+     * Locks the object (workbook or sheet or range) with the specified options and password.
+     *
+     * @param password The password required to unlock the object.
+     * @param properties The properties to allow to remain unlocked.
+     * @param algorithm The algorithm for encrypting the password.
+     * @param spinCount The spin count for encrypting the password.
+     * @returns The `IProtection` instance for method chaining.
+     *
+     * @remarks
+     * By default all properties are locked but you can specify which properties to remain unlocked.
+     */
+    lock(properties?: Partial<P>, password?: string, algorithm?: string, spinCount?: number): Promise<IProtection<T, P, J>>;
+    /**
+     * Unlocks the object (workbook or sheet) using the provided password.
+     *
+     * @param password The password required to unlock the object.
+     * @returns The `IProtection` instance for method chaining.
+     *
+     * @remarks
+     * If the correct password is provided, protection is removed from the object.
+     */
+    unlock(password?: string): Promise<IProtection<T, P, J>>;
+    /**
+     * Temporarily disables protection with the provided password.
+     *
+     * @param password The password required to pause protection.
+     * @returns The `IProtection` instance for method chaining.
+     *
+     * @remarks
+     * This method allows temporarily pausing protection without permanently unlocking the object.
+     * Use {@link resume} to restore protection.
+     */
+    pause(password?: string): Promise<IProtection<T, P, J>>;
+    /**
+     * Checks if the object is currently locked.
+     *
+     * @returns `true` if the object is locked, `false` otherwise.
+     *
+     * @remarks
+     * This method returns `true` If the lock is active.
+     */
+    isLocked(): boolean;
+    /**
+     * Verifies if the provided password matches the current protection password.
+     *
+     * @param password The password to check against the current protection.
+     * @returns `true` if the password is correct, `false` otherwise.
+     *
+     * @remarks
+     * Use this method to validate the password before unlocking or modifying the protection settings.
+     */
+    checkPassword(password?: string): Promise<boolean>;
+    /**
+     * Returns true if the protection has a password.
+     */
+    hasPassword(): boolean;
+    /**
+     * Resumes protection that was previously paused.
+     *
+     * @returns The `IProtection` instance for method chaining.
+     *
+     * @remarks
+     * This method restores protection after it was paused using the {@link pause} method.
+     */
+    resume(): IProtection<T, P, J>;
+    /**
+     * Checks if the object has a locked but is paused.
+     *
+     * @returns `true` if the object is locked but paused, `false` otherwise.
+     */
+    isPaused(): boolean;
+    /**
+     * If the element is protected as readonly.
+     *
+     * @remarks
+     * Readonly is set cannot be changed.
+     */
+    isReadOnly(): boolean;
+    /**
+     * Add Listeners.
+     *
+     * @see
+     * {@link IListener.ISource.addListeners}
+     */
+    addListeners(listeners: IProtection.IListeners, options?: IListener.Options): IListener.Remove;
+    toJSON(): IProtection.JSON | null;
+}
+/**
+ * {@inheritDoc IProtection}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IProtection}
+ */
+export declare namespace IProtection {
+    interface Events<T, P extends IProtection.Properties, J extends IProtection.JSON> {
+        /**
+         * Called when the protection has changed collections has changed have changed.
+         */
+        onChange?(source: IProtection<T, P, J>): void;
+        /**
+         * Called when the protection has changed collections has changed have changed.
+         */
+        onLockChange?(source: IProtection<T, P, J>): void;
+    }
+    interface IListeners extends IListener.Callbacks<IProtection<any, any, any>, IProtection.Events<any, any, any>> {
+    }
+    interface Properties {
+    }
+    interface JSON extends Properties {
+        /**
+         * If this is specified then a password will be requested to unlock.
+         * If this is an empty object this indicates the object has been locked but without a password
+         */
+        password?: Partial<IProtection.EncryptedPassword>;
+        identities?: IProtection.IdentityProvider[];
+    }
+    /**
+     * Represents a locally stored encrypted password.
+     *
+     * @see
+     * * {@link https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.presentation.modificationverifier?view=openxml-2.8.1}
+     */
+    interface EncryptedPassword {
+        /**
+         * The hashed value that was generated during the protection process.
+         * This value is typically derived from the combination of a password and a salt.
+         */
+        hash: string;
+        /**
+         * The salt value that was used during the protection process.
+         * The salt is combined with the password to produce the hash, adding an additional layer of security.
+         */
+        salt: string;
+        /**
+         * The name of the hash algorithm to be used.
+         * Common values include `SHA-256`, `SHA-384`, and `SHA-512`.
+         *
+         * @defaultValue `SHA-512`
+         */
+        algorithm?: string;
+        /**
+         * The number of iterations (also known as spin count) used during the hash computation process.
+         * A higher number increases the security by making brute-force attacks more difficult but also increases computation time.
+         *
+         * @defaultValue `100000`.
+         */
+        spinCount?: number;
+    }
+    /**
+     * **PLACEHOLDER** - Will integrate into the user identity system.
+     */
+    interface IdentityProvider {
+        /**
+         * Optional setting to specify the relative security descriptor.
+         *
+         * The descriptor defines user accounts who may edit this range without providing a password to access the range. Removing this attribute shall
+         * remove all permissions granted or denied to users for this range.
+         */
+        descriptor: string;
+    }
+}
+//# sourceMappingURL=IProtection.d.ts.map