import type { CSSResultArray, PropertyDeclarations, TemplateResult } from 'lit-element';
import { InternalEditableControl } from '../../../../internal/InternalEditableControl/InternalEditableControl';
import { BooleanSelector } from '@foxy.io/sdk/core';
/**
 * Lets an admin choose which scopes an invitation grants, offering only what the granting
 * user already holds.
 *
 * Bound to the invitation's `scope` string through `infer="scope"`. The server is the real
 * enforcement boundary; this control exists so the UI
 * never offers a grant that would be rejected.
 *
 * @element foxy-internal-user-invitation-form-scope-control
 */
export declare class InternalUserInvitationFormScopeControl extends InternalEditableControl {
    static get properties(): PropertyDeclarations;
    static get styles(): CSSResultArray;
    /** Space-separated scope of the user creating or editing the invitation. */
    granterScope: string | null;
    /**
     * Set when the admin picks `Custom` explicitly. Needed because an empty scope parses to a
     * `null` preset, so without this the radio would snap back to nothing selected the moment
     * `Custom` was chosen but before any row was set.
     */
    private __customSelected;
    /**
     * Cached outcome of `__hasUnreachableGrant` from the most recently completed `renderControl()`
     * pass. Read by `updated()` below -- see its doc comment for why the lock needs to land on
     * `this.readonly` itself rather than staying a `renderControl()`-local variable.
     */
    private __isLocked;
    renderControl(): TemplateResult;
    /**
     * Reflects a lock onto the real `readonly` property (in addition to whatever `updated()`
     * itself, e.g. `renderControl()`'s own `?readonly=` bindings, already did with the local
     * variable) once the initial render has committed.
     *
     * This exists because each row is now a nested `foxy-internal-select-control`.
     * `ConfigurableMixin` makes every such control infer its own `readonly` from the nearest
     * ancestor that has one (this control), by reading `this.readonly` directly during an async
     * walk (`InferrableMixin.inferFromElement`'s `key in element` check) -- not from whatever a
     * template attribute happened to bind on the row. That walk re-runs on every one of this
     * control's own updates (`InferrableMixin.updated()` calls `inferPropertiesInDescendants()`
     * unconditionally), so a row bound only via `?readonly=${this.readonly || isLocked}` in
     * `renderControl()` is overwritten back to whatever `this.readonly` was moments later --
     * confirmed empirically by a probe test, see this task's report. Setting `this.readonly`
     * itself is what the row's own inference actually reads, so this is not a workaround so much
     * as the property meaning what it says: locked really does mean the whole control, including
     * everything nested inside it, is readonly.
     *
     * Assigning inside `updated()` rather than `renderControl()`/`render()` matters too: mutating
     * a reactive property mid-render is what triggers lit's "scheduled an update... during
     * update" warning (and the `does not warn on a fresh empty-scope render` test would catch
     * it); `updated()` is the lifecycle hook lit itself documents for deriving follow-up state
     * from a completed render, and setting a property there does not warn.
     *
     * Never resets `this.readonly` back to `false` on its own -- the externally-imposed half
     * (e.g. the form's own `readonlycontrols` selector matching `scope`) is owned entirely by
     * `ConfigurableMixin`'s own inheritance, which keeps re-asserting its own value on every
     * update independently of this method.
     */
    updated(changes: Map<keyof this, unknown>): void;
    get readonlySelector(): BooleanSelector;
    /**
     * `true` when the invitation already holds something this granter could not themselves
     * grant: the current preset isn't among the ones offered, a collection's current level
     * isn't grantable at that level, or a collection currently has a resend grant the granter
     * cannot extend. Reuses `canGrantLevel` / `canGrantResend` rather than reimplementing
     * grantability -- see `renderControl` for why this forces the whole control readonly.
     */
    private __hasUnreachableGrant;
    /**
     * Renders one collection's level picker as a self-contained `foxy-internal-select-control`
     * in `summary-item` layout: a native `<select>` with a real `<label for="select">` (the
     * collection name, passed via `label`, replacing both the old sibling `foxy-i18n` and the
     * `aria-label` workaround that stood in for a proper accessible name before this control had
     * one) plus the current value shown as compact text. `data-collection` moves onto this
     * element directly -- there's no separate row wrapper left to carry it (see the control's
     * `styles` for why one output element per collection, not a wrapper `<div>` per row, is what
     * lets this control own its own two-column grid).
     */
    private __renderLevelControl;
    /**
     * Renders the three resendable collections' resend grants as `foxy-internal-switch-control`s,
     * one per line, in their own `foxy-internal-summary-control` -- not folded into the level
     * grid above. Resend is a secondary axis (below Full, a collection's level and its resend
     * grant are unrelated tokens -- see `parseScope`/`serializeScope`; Full includes resend, so the
     * switch then shows as on and readonly), covers only 3 of the 20
     * collections, and doesn't need the level grid's two-column treatment; keeping it as its own
     * section also means the grid's CSS (sized for 20 short rows) never has to accommodate a
     * structurally different kind of row. Renders nothing at all if the granter can't grant (and
     * the invitation doesn't already hold) any resend permission, rather than an empty section.
     */
    private __renderResendSwitches;
    private __setLevel;
    private __setResend;
    /**
     * The scope currently in the form. Undefined before the first edit on a new invitation.
     * An existing invitation saved without a scope grants full store access in the API, so it
     * reads as the wildcard here instead of as "nothing chosen".
     */
    private get __scope();
    private __preset;
    private __selectPreset;
}