import { Enhancer as Enhancer_2 } from './enhance';

/**
 * 属性評価結果の詳細です。
 */
declare interface AttributeEvaluationDetail {
    /** 評価済みの値 */
    value: string | false | unknown | null;
    /** 未解決参照が含まれていたかどうか */
    hasUnresolvedReference: boolean;
}

/**
 * コメントフラグメント。
 * コメントノードを表現します。
 */
declare class CommentFragment extends Fragment {
    /** コメント文字列 */
    private text;
    /** 更新スキップフラグ（オブザーバーによる無限ループ対応） */
    private skipMutation;
    /**
     * コメントフラグメントのコンストラクタ。
     * 対象コメントノードの内容を初期化します。
     *
     * @param target 対象コメントノード
     */
    constructor(target: Comment);
    /**
     * フラグメントをクローンします。
     *
     * @returns クローンされたフラグメント
     */
    clone(): Fragment;
    /**
     * フラグメントの対象ノードを取得します。
     *
     * @returns フラグメントの対象ノード
     */
    getTarget(): Comment;
    /**
     * コンテンツを更新します。
     *
     * @param text テキスト
     * @return 更新のPromise
     */
    setContent(text: string): Promise<void>;
}

/**
 * アプリケーションの中心的な制御を行うクラスです。
 * Fragment の初期化、属性変化の処理、条件分岐・繰り返し処理を管理します。
 */
export declare class Core {
    /** 属性エイリアスのサフィックス */
    private static readonly ATTRIBUTE_ALIAS_SUFFIX;
    /** 優先処理する属性のサフィックス（処理順序で定義） */
    private static readonly PRIORITY_ATTRIBUTE_SUFFIXES;
    /** 遅延処理する属性のサフィックス */
    private static readonly DEFERRED_ATTRIBUTE_SUFFIXES;
    /**
     * 走査中の「初期値の反映が終わるまで」を表す Promise。
     *
     * フォームを収集する取得（`data-{event}-fetch-form`）は、初期値が入力欄へ載る
     * 前に走ると空の条件で送ってしまうため、これを待ってから起動します（課題 52）。
     * 走査が終わると `null` に戻り、後から追加した要素は待ちません。
     */
    private static initialValueRestore;
    /** evaluateAll で再評価対象から除外する特殊属性のサフィックス */
    private static readonly EVALUATE_ALL_EXCLUDED_ATTRIBUTE_SUFFIXES;
    /** 属性内プレースホルダ検出用の正規表現 */
    private static readonly ATTRIBUTE_PLACEHOLDER_REGEX;
    /**
     * 行スコープ判定で「属性値そのものが式」とみなす `data-*` 属性のサフィックス。
     * `{{...}}` を伴わずに式を書く属性だけを列挙する。
     */
    private static readonly ROW_LOCAL_EXPRESSION_ATTRIBUTES;
    /**
     * 行スコープ判定で「属性値が式ではない」とみなす `data-*` 属性のサフィックス。
     * ここに無い `data-*` 属性は、行の外を参照し得るものとして安全側に扱う。
     */
    private static readonly ROW_LOCAL_STATIC_ATTRIBUTES;
    /**
     * 行スコープ判定で「属性値が式ではない」とみなす行操作の宣言。
     *
     * `data-{event}-row-next` のようにイベント名を含むため、サフィックスの後半で
     * 判定します。値は空またはセレクタで、描画のたびに評価する式ではありません
     * （`{{...}}` を含む値は先に別の分岐で行スコープと照合しています）。
     *
     * 列挙しないと、行操作のボタンを置いただけで「行の外を参照している」と判定され、
     * 要素データが同値の行でも子孫の再評価を省略できなくなります。行操作は一覧の
     * 並べ替えそのものなので、除外すると並べ替えのたびに全行を再評価します。
     */
    private static readonly ROW_LOCAL_ROW_OPERATIONS;
    /** data-fetch の自動再評価状態 */
    private static readonly REACTIVE_FETCH_STATES;
    /** data-import の自動再評価状態 */
    private static readonly REACTIVE_IMPORT_STATES;
    /** data-derive subtree skip の開発用プロファイル */
    private static readonly DERIVE_SUBTREE_PROFILES;
    /** data-each の差分更新の再入制御状態 */
    private static readonly EACH_UPDATE_STATES;
    /**
     * data-each-rendered-change（既定の `once` モード）で change を発火済みの要素。
     * 再帰的な発火ループを避けるため、要素ごとに一度だけ発火させるために使用します。
     */
    private static readonly EACH_RENDERED_CHANGE_FIRED;
    /**
     * data-each-rendered-change の不正な属性値を警告済みの要素。
     * 描画確定ごとに同じ警告を出し続けないために使用します。
     */
    private static readonly EACH_RENDERED_CHANGE_WARNED;
    /**
     * `data-each-key` の重複を警告済みの項目名。
     * 描画のたびに同じ警告を出し続けないために使用します。
     */
    private static readonly WARNED_DUPLICATE_EACH_KEYS;
    /**
     * 遅延属性かどうか（完全名で判定）を判定します。
     *
     * @param name 属性名
     * @returns 遅延属性かどうか
     */
    private static isDeferredAttributeName;
    /**
     * evaluateAll で再評価対象から除外する特殊属性かどうかを判定します。
     *
     * @param name 属性名
     * @returns 除外対象かどうか
     */
    private static isEvaluateAllExcludedAttributeName;
    /**
     * evaluateAll で通常属性を再評価すべきかを判定します。
     *
     * @param name 属性名
     * @param value 属性の生値
     * @returns 再評価する場合は true
     */
    private static shouldReevaluateAttribute;
    /**
     * data-attr-* 形式の属性名から実際に更新する属性名を取得します。
     *
     * @param name 属性名
     * @returns 実際の属性名。data-attr-* でない場合は null
     */
    private static getAliasedAttributeName;
    /**
     * 実属性の変更が data-attr-* の内部反映かどうかを判定します。
     *
     * @param element 対象要素
     * @param name 変更された属性名
     * @returns data-attr-* の内部反映なら true
     */
    static isAliasedAttributeReflection(element: HTMLElement, name: string): boolean;
    /**
     * プレースホルダを含む通常属性を再評価します。
     * 内部状態の更新は同期的に行い、DOM 反映は fragment 側の非同期更新に委ねます。
     *
     * @param fragment 対象フラグメント
     * @returns 再評価完了の Promise
     */
    private static reevaluateInterpolatedAttributes;
    /**
     * 指定フラグメントの直下の子孫評価を再実行します。
     *
     * @param fragment 対象フラグメント
     * @returns 再評価完了の Promise
     */
    private static reevaluateChildren;
    /**
     * 配下の入力欄からユーザー編集の印を解除します。
     *
     * 明示的に値を供給する操作（フェッチ応答とそれに伴う `data-{event}-bind` の反映、
     * `data-{event}-reset`、`data-{event}-copy`、`data-each` の行データ差し替え）から
     * 呼び出します。解除後の再評価では宣言バインドの評価結果が入力欄へ再適用され、
     * 「再取得したのに古い入力が残る」状態になりません。
     *
     * 逆に、`change` / `input` の双方向コミットや `data-url-param` の再評価のような
     * 「値の供給ではない更新」からは呼び出しません。呼び出すと編集値が評価結果へ
     * 巻き戻ります。フェッチを伴わない `change` / `input` の `data-{event}-bind` も
     * 双方向コミットに含みます（`Procedure` の `twoWayCommitBind` を参照）。
     *
     * @param fragment 対象フラグメント（配下すべてが対象）
     * @param upTo この通し番号までの編集を解除対象とする（既定は現在の最新）
     * @return 戻り値はありません。
     */
    static clearUserEditMarks(fragment: ElementFragment, upTo?: number): void;
    /**
     * data-fetch の再評価状態を取得します。
     *
     * @param element 対象要素
     * @returns 再評価状態
     */
    private static getReactiveFetchState;
    /**
     * data-import の再評価状態を取得します。
     *
     * @param element 対象要素
     * @returns 再評価状態
     */
    private static getReactiveImportState;
    /**
     * bind 更新時に data-fetch / data-import を専用ルートで再評価します。
     *
     * @param fragment 対象フラグメント
     * @param skipFragments 再評価をスキップするフラグメント集合
     * @returns 再評価完了の Promise
     */
    private static reevaluateReactiveSpecialAttributes;
    /**
     * data-fetch をシグネチャ比較付きで実行します。
     *
     * @param fragment 対象フラグメント
     * @returns 実行完了の Promise
     */
    private static executeManagedFetch;
    /**
     * data-import を URL 比較付きで実行します。
     *
     * @param fragment 対象フラグメント
     * @returns 実行完了の Promise
     */
    private static executeManagedImport;
    /**
     * 取り込んだ断片を取り込み先のフラグメントの子として繋ぎます。
     *
     * `data-import` は `innerHTML` で子を差し替えるため、フラグメント木は自動では
     * 追従しません。繋がないまま評価すると、断片の要素は親を持たないフラグメントに
     * なり、祖先をたどれないため評価スコープが空になります（`{{...}}` が空表示に
     * なり、`data-if` が常に偽になる）。DOM 上は取り込み先の子なので、通常の子要素と
     * 同じスコープ解決になるように繋ぎ直します。
     *
     * @param fragment 取り込み先のフラグメント
     * @return 戻り値はありません。
     */
    private static adoptImportedChildren;
    /**
     * 指定された要素と、その子要素をスキャンし、Fragmentを生成します。
     *
     * @param element スキャン対象の要素
     * @returns Promise (スキャンが完了したときに解決される)
     */
    static scan(element: HTMLElement): Promise<void>;
    /**
     * 指定された要素と、その子要素をスキャンします。
     *
     * `applyEnhancers` が false のときは、走査の最後に外部ライブラリ連携を適用しません。
     * `data-if` の分岐の子を走査するときに使います。適用は、分岐の外の初期値の反映
     * （外側の走査の最後）や、揃った選択肢への値の載せ直しの後に行います（課題 55）。
     *
     * @param element スキャン対象の要素
     * @param applyEnhancers 走査の最後に外部ライブラリ連携を適用するかどうか
     * @returns Promise (スキャンが完了したときに解決される)
     */
    private static scanElement;
    /**
     * 非表示から表示へ切り替わった分岐へ、外部ライブラリ連携を適用します。
     *
     * 表示と同じ更新で与えた値は、`data-each` の行が揃った後に載せ直されます
     * （`Core.setBindingData()` の載せ直しの段）。その前に `init` を呼ぶと、`<option>` を
     * 引き取る連携が値を受け取れないため、分岐の中の載せ直しを先に行います（仕様
     * 「`data-enhance`」の「表示と同じ更新で与えた値も、`data-each` が描いた選択肢へ
     * 載ってから呼びます」、課題 55）。
     *
     * @param fragment 表示へ切り替わった `data-if` のフラグメント
     * @param sequence 表示の評価を始めた時点の初期化の通番。これより後に初期化された
     *     入力欄へは載せ直しません
     * @returns 適用の完了 Promise
     */
    private static applyEnhancersOnShow;
    /**
     * 新規 each 行を局所初期化します。
     * 既存 scan の属性順序を保ちつつ、Fragment 木を直接たどります。
     *
     * @param fragment 新規挿入された行フラグメント
     * @returns 初期化完了の Promise
     */
    private static initializeFreshEachRow;
    /**
     * ElementFragment とその子孫を初期化します。
     *
     * @param fragment 対象フラグメント
     * @param stopAtEach true の場合、data-each 要素では通常再帰を止める
     * @returns 初期化完了の Promise
     */
    private static initializeElementFragment;
    /**
     * 要素初期化時の mounted 状態を同期します。
     *
     * @param fragment 対象フラグメント
     */
    private static syncMountedState;
    /**
     * scan と fresh clone 初期化で共有する属性初期化を行います。
     *
     * @param fragment 対象フラグメント
     * @returns 属性初期化完了の Promise
     */
    private static initializeElementAttributes;
    /**
     * 子孫初期化をスキップすべきかどうかを返します。
     *
     * @param fragment 対象フラグメント
     * @param stopAtEach true の場合、data-each 要素で通常再帰を止める
     * @returns 子孫初期化をスキップするなら true
     */
    private static shouldSkipChildInitialization;
    /**
     * エレメントに属性を設定します。
     * 属性固有の処理も行います。
     *
     * @param element エレメント
     * @param name 属性名
     * @param value 属性値
     * @param fromObserver 外部（他スクリプト）による書き換えの取り込みかどうか
     * @param originSequence 外部の書き換えを検知した時点の通番。`Observer` が保留中の
     *     変更を同期的に引き取ったときだけ渡します（`Observer.flushPendingMutations()`
     *     を参照）。渡さない場合は取り込みの時点で発番します
     * @returns Promise (DOM操作が完了したときに解決される)
     */
    static setAttribute(element: HTMLElement, name: string, value: string | null, fromObserver?: boolean, originSequence?: number): Promise<void>;
    /**
     * 要素のバインドデータを更新し、配下を再評価します。
     *
     * `reflectToAttribute` を `false` にすると `data-bind` 属性へのミラー
     * （`JSON.stringify` による全データ直列化）を抑止します。スクロール追従の
     * 可視範囲のように高頻度で更新される一時的なエンジン管理変数では、属性ミラーの
     * 直列化コスト（保持データ量に比例）が支配的になるため、これを省いて in-memory
     * 更新と再評価だけを行います。属性は次回の通常更新時に最新の in-memory から
     * 反映されます。あわせて外部向けの `haori:bindchange` イベントも発火しません
     * （非ミラーの一時更新は外部通知もしない、という方針で意味を揃えるため）。
     *
     * データの設定は既定で「明示的な値の供給」として扱い、配下の入力欄からユーザー
     * 編集の印を解除します（`clearUserEditMarks`）。これにより、利用者が編集した欄も
     * 供給された値へ更新されます。値の供給ではない内部更新（`change` の双方向コミット、
     * `data-url-param` の再評価、`_poll` / `_fetch` などのエンジン管理変数）は
     * `options.kind` に `'nonSupply'` を渡します。
     *
     * 解除の範囲は呼び出し側が選びません。**供給はその操作の通番までの編集を解除し、
     * それより後の編集は残します**（仕様「ユーザー編集と宣言バインドの権威」）。飛行中の通信の応答が、送出後に
     * 行われた編集を消さないのはこの規則によるものです。
     *
     * @param element 対象要素
     * @param data 設定するバインドデータ
     * @param options 由来と反映方法の指定（`SetBindingDataOptions`）
     * @returns Promise (DOM操作が完了したときに解決される)
     */
    static setBindingData(element: HTMLElement, data: Record<string, unknown>, options?: SetBindingDataOptions): Promise<void>;
    /**
     * 経路が存在しないことを表す番兵。`undefined` を値として持つ経路と区別します。
     */
    private static readonly ABSENT_PATH;
    /**
     * 宣言データとして外へ出すデータから予約キーを取り除きます。
     *
     * `_fetch` / `_poll` は内部バインディングデータにのみ持つ実行時の値で、宣言
     * データとしては外へ出しません（仕様「`data-bind`」）。内部データ側は予約キーを
     * 引き継ぐため（`ElementFragment.setBindingData()`）、出口の側で取り除かないと、
     * `data-bind` 属性が数秒ごとの状態遷移で書き換わり続け、`data-{event}-copy` は
     * 別の要素のフェッチ状態をコピー先へ運びます。
     *
     * @param data 外へ出すバインドデータ
     * @returns 予約キーを除いたデータ
     */
    static withoutReservedBindingKeys(data: Record<string, unknown>): Record<string, unknown>;
    /**
     * 変化した経路ごとに適用可否を判定し、棄却した経路を前の値のまま残したデータを
     * 返します。
     *
     * バインドデータの宛先は**経路単位**です（`docs/ja/値の供給と権威解決の設計書.md`）。
     * 更新はオブジェクト全体を差し替える形で届くため、前の値と突き合わせて「実際に
     * 変化した経路」を求め、その経路ごとに宛先の台帳と照合します。変化していない経路
     * には触らないため、絶えず走る再評価が台帳を汚しません。
     *
     * @param fragment 対象のフラグメント
     * @param previous 更新前のバインドデータ（初回は null）
     * @param next 更新で与えられたバインドデータ
     * @param origin この更新の由来（通番・種別・編集された経路）
     * @returns 適用を許した経路だけが `next` の値になったバインドデータ
     */
    private static resolveByPathAuthority;
    /**
     * 経路をたどりながら、変化した葉ごとに適用可否を判定します。
     *
     * @param fragment 対象のフラグメント
     * @param previous その経路の更新前の値（存在しない場合は `ABSENT_PATH`）
     * @param next その経路の更新後の値（存在しない場合は `ABSENT_PATH`）
     * @param origin この更新の由来
     * @param path その経路（ルートは空文字）
     * @returns 採用した値。その経路を持たせない場合は `ABSENT_PATH`
     */
    private static mergePathAuthority;
    /**
     * 配列を要素ごとの宛先として扱えるかを判定し、扱える場合は各要素のリストキーを
     * 返します。
     *
     * 行の追加・削除・並べ替えが起きている場合は要素の対応が取れないため、配列全体を
     * 1 つの宛先として扱います（`null` を返す）。対応が取れる場合だけ要素へ降り、
     * 経路の要素にはリストキーを使います。添字は行の挿入・削除で意味が変わるため、
     * `data-each-key` の宣言があればそれを優先します（`Core.createListKey()`）。
     *
     * @param fragment 対象のフラグメント
     * @param previous 更新前の値
     * @param next 更新後の値
     * @param path その経路
     * @returns 要素ごとのリストキー。要素へ降りない場合は null
     */
    private static resolveArrayPairing;
    /**
     * 配列の経路に対応する `data-each-key` の指定を探します。
     *
     * `data-each` の属性値は**式**なので、経路とそのまま文字列比較はできません。入れ子の
     * `data-each` は上位の行スコープの名前で書かれるためです（`data-each-arg="r"` の
     * 配下では `r.items`）。そこで宣言の側を絶対経路へ直してから比べます
     * （`Core.resolveEachDeclarationPath()`）。経路の側は配列要素の区間（`[キー]`）を
     * 取り除いた形にします。宣言は「どの階層の配列か」しか表さないためです。
     *
     * @param fragment 対象のフラグメント
     * @param path 配列の経路（`rows[7].items` のような形）
     * @returns リストキーに使うプロパティ名。宣言が無ければ null
     */
    private static resolveEachKeyArg;
    /**
     * `data-each` の宣言を、起点の要素から見た絶対経路へ直します。
     *
     * 上位の `data-each` を遡り、`data-each-arg` で公開された名前を上位の宣言へ
     * 置き換えます。`data-each-arg` が無い構成では要素データのキーがそのまま行スコープ
     * へ広がるため、上位の宣言を接頭に付けます。
     *
     * **`null` を返す 3 つの分岐は、振る舞いとしては観測できません。** 空の宣言や前置の
     * 不一致では、`null` を返さずに組み立てを続けても `rows.` や `.items` のような経路に
     * ならない文字列ができるだけで、呼び出し側の照合はどちらでも一致しません。意図を
     * 明示するために残していますが、**これらを対象にした回帰テストは書けません**
     * （`docs/ja/testing.md` の規則 2 に照らして、落ちないテストは足さない）。
     *
     * @param element `data-each` を持つ要素
     * @param root 起点の要素（経路の基準）
     * @returns 絶対経路。式が空、または経路として扱えない場合は null
     */
    private static resolveEachDeclarationPath;
    /**
     * 素のオブジェクト（配列でも null でもないオブジェクト）かどうかを返します。
     *
     * @param value 判定する値
     * @returns 素のオブジェクトなら true
     */
    private static isPlainRecord;
    /**
     * バインドデータの 2 つの値が同じ内容かどうかを返します。
     *
     * 直列化できない値（`File` など）は参照の同一性で比べます。
     *
     * @param a 比較する値
     * @param b 比較する値
     * @returns 同じ内容なら true
     */
    private static isSameBindingValue;
    /**
     * 指定要素のバインディングデータを取得します。`setBindingData` の対となる
     * 公式の読み取り API です。
     *
     * 既定では、その要素自身に設定された生のバインディングデータ（`data-bind` で
     * 宣言・更新された値そのもの）を返します。`resolved` を `true` にすると、DOM の
     * ネストをたどって解決済みのスコープ（内側が外側を上書きし、`data-each` の
     * 行データや派生データを含む、式評価で実際に見える値）を返します。
     *
     * 返されるオブジェクトは内部状態のコピーではなく参照のため、呼び出し側で
     * 直接書き換えないでください（更新は `setBindingData` を使用します）。
     *
     * @param element 対象要素
     * @param options 取得オプション。`resolved` が `true` なら解決済みスコープを返す
     * @return 既定はその要素の生バインディングデータ（無ければ `null`）。
     *     `resolved: true` のときは解決済みスコープ（常にオブジェクト）。
     */
    static getBindingData(element: HTMLElement, options?: {
        resolved?: boolean;
    }): Record<string, unknown> | null;
    /**
     * 指定要素の式評価で見えるバインディングスコープをダンプします（デバッグ用）。
     *
     * 式（`data-if` / `{{...}}` など）の識別子は、その要素を起点に DOM のネストを
     * たどって解決されます（内側のスコープが外側を上書き）。本メソッドは解決済みの
     * スコープ（`resolved`）と、各キーがどの要素・どの種類（`bind` または `derive`）に
     * 由来するか（`sources`）を返します。開発モード時はコンソールにも出力します。
     *
     * 注意: フォームの入力値（`name` 属性）は、変更（change）や明示的な同期が行われる
     * までフォームの binding data に反映されません。したがって初期表示時点では、入力名と
     * 同名の識別子は**外側のスコープ**にフォールバックして解決されます。
     *
     * @param element 対象要素
     * @return 解決済みスコープと各キーの由来情報
     */
    static dumpScope(element: HTMLElement): {
        resolved: Record<string, unknown>;
        sources: Record<string, {
            value: unknown;
            source: string;
            kind: 'bind' | 'derive';
            depth: number;
        }>;
    };
    /**
     * スコープの解決結果と由来を収集します。
     *
     * `dumpScope()` の本体です。こちらは出力しません。診断（`data-if` の falsy 報告）は
     * 自分で 1 行だけ出すため、ここで出すと同じ内容が二重に出て、再描画のたびに
     * コンソールへ積み上がります。
     *
     * @param element 対象要素
     * @return 解決済みスコープと各キーの由来情報
     */
    private static collectScope;
    /**
     * data-bind 属性の値をパースします。
     *
     * @param data data-bind 属性の値
     * @returns パースされたデータオブジェクト
     */
    static parseDataBind(data: string): Record<string, unknown>;
    /**
     * ノードを親要素に追加し評価を行います。
     *
     * @param parentElement 親エレメント
     * @param node 追加するノード
     * @returns 追加したノードの走査（評価）の Promise。走査しない場合は解決済みの Promise
     */
    static addNode(parentElement: HTMLElement, node: Node): Promise<void>;
    /**
     * ノードを親要素から削除します。
     *
     * @param node 削除するノード
     */
    static removeNode(node: Node): void;
    /**
     * ノードのテキストを変更します。
     *
     * @param node 変更するノード
     * @param text 新しいテキスト
     */
    static changeText(node: Text | Comment, text: string): void;
    /**
     * エレメントの値を変更します。
     * フォームの双方向バインディングを考慮し、フォームのバインドデータも更新します。
     *
     * @param element 変更するエレメント
     * @param value 新しい値
     * @returns Promise (DOM操作が完了したときに解決される)
     */
    static changeValue(element: HTMLElement, value: string): Promise<void>;
    /**
     * フォームフラグメントを取得します。
     *
     * @param fragment フラグメント
     * @returns フォームフラグメントまたはnull
     */
    private static getFormFragment;
    /**
     * フラグメントとその子要素を評価します。
     *
     * @param fragment 対象フラグメント
     * @return Promise (DOM操作が完了したときに解決される)
     */
    static evaluateAll(fragment: ElementFragment, skipFragments?: ReadonlySet<ElementFragment>): Promise<void>;
    /**
     * data-derive / data-derive-name を評価し、子孫要素向けの派生値を更新します。
     *
     * @param fragment 対象フラグメント
     * @param deriveExpression 上書きする導出式
     * @param deriveName 上書きする導出名
     * @returns Promise (評価完了時に解決)
     */
    static evaluateDerive(fragment: ElementFragment, deriveExpression?: string | null, deriveName?: string | null): Promise<boolean>;
    /**
     * テキストフラグメントを評価します。
     *
     * @param fragment 対象フラグメント
     * @returns Promise (DOM操作が完了したときに解決される)
     */
    static evaluateText(fragment: TextFragment): Promise<void>;
    /**
     * data-if の評価値が「非表示」とみなされるかどうかを判定します。
     *
     * JavaScript の falsy 判定に準拠し、`false`・`null`・`undefined`・`NaN` に加えて
     * `0`・空文字列 `''` も非表示とします（例: `data-if="items.length"` は要素数 0 で
     * 非表示）。空配列 `[]` や空オブジェクト `{}` は JavaScript 同様 truthy なので表示されます。
     *
     * @param condition data-if の評価結果
     * @return 非表示とみなす場合は true
     */
    private static isHiddenIfCondition;
    /**
     * 開発モードで、falsy により非表示になった `data-if` 式の診断情報を出力します。
     *
     * 式が参照するトップレベル識別子について、解決値と由来要素（`dumpScope` の
     * `sources`）を併記します。フォームの `name` 由来の値が想定外のスコープから
     * 解決される等のスコープ競合をデバッグするための補助です。
     *
     * @param fragment data-if フラグメント
     * @return 戻り値はありません。
     */
    private static logFalsyIfDiagnostics;
    /**
     * `data-each` コンテナの子のうち、行にならない固定要素かどうかを返します。
     *
     * 仕様「`data-each`」の `data-each-before` / `data-each-after`（「ループ前に表示
     * する要素をマーク」「ループ後に表示する要素をマーク」）です。テンプレートの選定
     * （`performEachUpdate`）でも同じ属性で除いています。
     *
     * @param fragment 判定する子フラグメント
     * @returns 行にならない固定要素なら true
     */
    private static isEachFixedChild;
    /**
     * `data-each` コンテナが固定要素を持つかどうかを返します。
     *
     * 固定要素（`data-each-before` / `data-each-after`）はコンテナのスコープで評価する
     * ため、配列が同値でも一覧の外のデータの更新で描画が変わります。行と行テンプレートは
     * 行スコープで評価するため数えません。
     *
     * コンテナ直下のテキストノードは数えません。式を含むテキストは
     * `hasNonEachDynamicElementState()` がすでに拾っており、ここで重ねても落ちるテストが
     * 無いためです（`docs/ja/testing.md` の規則 3）。
     *
     * @param fragment `data-each` コンテナのフラグメント
     * @returns 固定要素があれば true
     */
    private static hasEachFixedChildren;
    /**
     * `data-each` コンテナの固定要素とテキストノードを再評価します。
     *
     * 行と行テンプレートは `data-each` が管理するため `evaluateAll` は each コンテナの
     * 子へ降りません。しかし固定要素（`data-each-before` / `data-each-after`）と
     * コンテナ直下のテキストノードは行ではなく、仕様「`data-each`」の「固定要素と
     * コンテナ直下のテキストノードは、行と違いコンテナのスコープで、バインドデータの
     * 更新のたびに再評価します」に従ってコンテナのスコープで再評価します。
     *
     * これが無いと、ガイドが案内している「空のリストの場合のメッセージ」
     * （`data-each-after` に `data-if="items.length === 0"` を書く形）が、配列が
     * 変わっても初期の判定のまま固定されます。
     *
     * @param fragment `data-each` コンテナのフラグメント
     * @returns 再評価完了の Promise
     */
    private static evaluateEachFixedChildren;
    /**
     * if要素を評価します。
     * 値が falsy（false・null・undefined・NaN・0・空文字列）の場合は非表示にし、
     * それ以外の場合は表示します。
     *
     * @param fragment 対象フラグメント
     * @return Promise (DOM操作が完了したときに解決される)
     */
    static evaluateIf(fragment: ElementFragment): Promise<void>;
    /**
     * data-if 表示時に data-load-* 手続きを発火します。
     *
     * 対象要素が data-load-* 属性を持つ場合のみ、load 種別の Procedure を1回実行します。
     * 結果は待機せず（fire-and-forget）、表示処理の完了をブロックしません。
     *
     * @param fragment 対象フラグメント
     * @return 戻り値はありません。
     */
    private static triggerLoadOnShow;
    /**
     * data-each フラグメントの差分更新の再入制御状態を取得します。
     *
     * @param fragment 対象フラグメント
     * @return 再入制御状態
     */
    private static getEachUpdateState;
    /**
     * each要素を評価します。
     * 非表示または未マウントの場合は処理をスキップします。
     *
     * 同一フラグメントに対する差分更新が並行・再入しないように直列化します。
     * 実行中に再度呼び出された場合は再評価要求を記録し、現在進行中の更新の完了
     * Promise（後続の再実行も含む）を返します。これにより、bind 直後のリアクティブ
     * 再評価が重なっても data-each の描画が破壊されず、かつ呼び出し元（`evaluateAll`→
     * `setBindingData`→`haori:bindcomplete`）が**最終的な DOM 反映まで確実に待機**できます。
     *
     * @param fragment 対象フラグメント
     * @return 差分更新（再実行を含む）の完了 Promise
     */
    static evaluateEach(fragment: ElementFragment): Promise<void>;
    /**
     * `data-each` が行スコープへ公開する名前を返します。
     *
     * @param fragment `data-each` コンテナのフラグメント
     * @param suffix 参照する属性のサフィックス（`each-arg` または `each-index`）
     * @returns 公開される名前。指定が無い場合は null
     */
    private static getRowScopeName;
    /**
     * `data-each` の差分更新が実行中かどうかを返します。
     *
     * 行の描画中に起動された処理（行の中の `data-fetch` など）が、その行の要素データ
     * を書き換えて所有者へ書き戻すとき、完了を待つべきかの判定に使います。実行中の
     * 描画ループの完了を待つと、ループ側は行の初期化（= その処理）の完了を待っている
     * ため相互に待ち合って止まります。
     *
     * @param fragment `data-each` コンテナのフラグメント
     * @returns 差分更新が実行中なら true
     */
    static isEachUpdateRunning(fragment: ElementFragment): boolean;
    /**
     * data-each の差分更新を、再評価要求が無くなるまで直列に繰り返し実行します。
     * 進行中・後続の再実行を含む完了 Promise を state に保持し、再入した呼び出し元が
     * 同じ Promise を待てるようにします。
     *
     * @param fragment 対象フラグメント
     * @param state 再入制御状態
     * @return すべての差分更新が安定するまでの完了 Promise
     */
    private static runEachUpdateLoop;
    /**
     * data-each-rendered-run 属性に指定された JS を、描画確定後に一度実行します。
     *
     * data-each の再描画が安定し `data-each-done` が付与されるたびに呼び出され、
     * 再 fetch・再バインドのたびに確実な再同期契機を提供します。本体内の `this`
     * は対象コンテナ要素に束縛され、外部の select 拡張ライブラリ（Choices.js 等）
     * の再同期フック（例: `window.__choicesRefresh(this)`）として利用できます。
     *
     * @param target data-each コンテナ要素
     */
    private static runEachRenderedScript;
    /**
     * data-each-rendered-change 属性に従い、描画確定後に対象要素へ `change`
     * イベント（バブリングあり）を発火します。
     *
     * API から取得した候補を `data-each` で流し込んだ `<select>` について、
     * 「既定選択を確定して初期データを取得する」パターンをインライン JS なしで
     * 宣言できるようにするための属性です。`<select>` はブラウザが先頭 option を
     * 自動選択するため、描画確定後の `change` がそのまま既定選択の確定になります。
     *
     * 描画行が 0 件のときは発火しません（確定すべき既定値が存在しないため）。
     * この場合は初回発火の判定も消費しないため、行が入った最初の描画で発火します。
     *
     * 属性値による動作の違い:
     * - 省略または `once`: 行が 1 件以上ある最初の描画確定時のみ発火する（既定）。
     * - `always`: 描画確定ごとに毎回発火する。
     *
     * 既定を `once` にしているのは、`change` の手続きが `data-each` の取得元を
     * 再バインドする構成（候補取得 → 選択確定 → 明細取得 → 再描画）で、毎回発火
     * させると再帰的な発火ループになり得るためです。
     *
     * @param fragment data-each コンテナのフラグメント
     */
    private static runEachRenderedChange;
    /**
     * data-each コンテナに描画されている行数を返します。
     *
     * 行は差分更新で `data-row` 属性が付与されるため、それを数えます。
     * `data-each-before` / `data-each-after` の固定要素や、テンプレート以外の
     * 静的な子要素（`data-each-before` の付け忘れを含む）は行数に含めません。
     *
     * @param fragment data-each コンテナのフラグメント
     * @returns 描画済みの行数
     */
    private static countEachRenderedRows;
    /**
     * data-each の差分更新本体を実行します（再入制御は呼び出し側で行います）。
     *
     * @param fragment 対象フラグメント
     * @return 差分更新完了の Promise
     */
    private static performEachUpdate;
    /**
     * 差分更新が不要な `data-each` の既存行について、子孫の再評価だけを行います。
     *
     * 行スコープの値だけで描画が決まるテンプレートでは、行の要素データが同値である
     * 限り描画結果も変わらないため何もしません。
     *
     * @param fragment `data-each` コンテナのフラグメント
     * @returns 再評価完了の Promise
     */
    private static reevaluateEachRows;
    /**
     * data-each 属性値を仕様に従って配列へ正規化します。
     *
     * @param fragment 対象フラグメント
     * @returns 配列。無効な場合は null
     */
    private static resolveEachItems;
    /**
     * nested data-each の入力が同値で、要素自身に他の動的要素が無い場合は
     * evaluateAll の子走査を省略できるかどうかを返します。
     *
     * @param fragment 判定対象フラグメント
     * @returns 省略可能なら true
     */
    private static canSkipUnchangedNestedEach;
    /**
     * `data-each` のテンプレートが行スコープの値だけで描画できるかどうかを返します。
     *
     * 行スコープとは `data-each-arg` と `data-each-index` で公開される名前です。
     * テンプレート内の式がこの名前だけを参照している場合、要素データが同値なら
     * 描画結果も変わらないため、行の子孫の再評価を省略できます。逆に行の外にある
     * 名前（別の一覧や親スコープの値）を参照している場合は、要素データが同値でも
     * 再評価が必要です。
     *
     * 判定できない場合はすべて「行スコープ外」（= 再評価が必要）へ倒します。
     * 具体的には、テンプレート未確定、`data-each-arg` の無い構成（要素データのキーが
     * 行スコープへ直接展開されるため参照名を静的に決められない）、解析できない式、
     * 既知でない `data-*` 属性が該当します。
     *
     * 判定結果はテンプレート単位で不変なのでフラグメントへ保存して再利用します。
     *
     * @param fragment `data-each` コンテナのフラグメント
     * @returns 行スコープの値だけで描画できるなら true
     */
    private static isRowLocalEachTemplate;
    /**
     * フラグメントとその子孫の式が、指定した名前だけを参照しているかを判定します。
     *
     * @param fragment 判定対象フラグメント
     * @param scopeNames 参照してよい名前の集合
     * @returns 指定した名前だけを参照しているなら true
     */
    private static isRowLocalSubtree;
    /**
     * 式の集合が、指定した名前だけを参照しているかを判定します。
     *
     * 参照名を取り出せなかった式は安全側（= 指定外を参照している）として扱います。
     *
     * @param expressions 判定対象の式
     * @param scopeNames 参照してよい名前の集合
     * @returns 指定した名前だけを参照しているなら true
     */
    private static areExpressionsRowLocal;
    /**
     * 文字列から `{{式}}` の中身を取り出します。
     *
     * @param raw 評価前の文字列
     * @returns 式の一覧（出現順）
     */
    private static extractInterpolations;
    /**
     * data-derive subtree の入力が同値で、保守条件も満たす場合に
     * 子走査を省略できるかどうかを返します。
     *
     * @param fragment 判定対象フラグメント
     * @returns 省略可能なら true
     */
    private static canSkipStableDerivedSubtree;
    /**
     * data-derive subtree skip の初期 PoC で扱わない子孫要素を含むかを返します。
     *
     * @param fragment 判定対象フラグメント
     * @returns 含むなら true
     */
    private static hasDisallowedDerivedSubtreeDescendant;
    /**
     * data-derive host が子孫要素へ公開している binding の署名を返します。
     *
     * @param fragment 対象フラグメント
     * @returns binding 署名
     */
    private static createDescendantBindingSignature;
    /**
     * data-derive 実行前の入力署名を返します。
     *
     * @param fragment 対象フラグメント
     * @param deriveExpression 導出式
     * @param deriveName 導出名
     * @returns 入力署名。導出が無効なら null
     */
    private static createDeriveInputSignature;
    /**
     * URL が変わったときに `data-url-param` の取り込みをやり直します。
     *
     * 対象は、宣言を持つ要素のうち**すでに走査済み**のものだけです。未走査の要素は
     * 走査したときに読むため、ここで触ると宣言を持たないフラグメントを作ってしまい
     * ます。再評価では呼びません（仕様「`data-url-param`」の「取り込みの契機」）。
     *
     * @returns 読み直しの完了 Promise
     */
    static refreshUrlParams(): Promise<void>;
    /**
     * `data-derive` の「配下の再評価を省く」記録を破棄します。
     *
     * この記録は「配下へ公開するデータが前回と同じなら、配下の DOM も前回の評価結果
     * のまま」という前提に立ちます。リセットのように DOM を直接書き換えた場合は前提が
     * 崩れるため、書き換えた側が破棄します。破棄しないと、入れ直しの再評価が配下へ
     * 届かず、空へ揃えた入力欄がそのまま残ります（仕様「`data-{event}-reset`」）。
     *
     * 破棄の範囲は、書き換えた範囲の配下と、その範囲を覆う祖先です。
     *
     * @param root 書き換えた範囲の根フラグメント
     * @returns 戻り値はありません。
     */
    static invalidateDerivedSubtreeSignatures(root: ElementFragment): void;
    /**
     * data-derive subtree skip 用の署名を現在状態で更新します。
     *
     * @param fragment 対象フラグメント
     */
    private static refreshDerivedSubtreeSignature;
    /**
     * data-derive subtree skip のプロファイルを取得または初期化します。
     *
     * @param fragment 対象フラグメント
     * @returns プロファイル
     */
    private static getOrCreateDerivedSubtreeProfile;
    /**
     * 要素の `id` 属性を安全に取得します。
     *
     * `<form>` は配下の入力要素の `name` が同名の組み込みプロパティを上書きします
     * （HTML 仕様の named access）。そのため `<input name="id">` を含むフォームでは
     * `form.id` が文字列ではなく input 要素を返し、文字列として扱うと
     * `[object HTMLInputElement]` になったり `.trim()` で TypeError になります。
     * 属性から直接読み取ってこの上書きを避けます。
     *
     * @param element 対象要素
     * @returns `id` 属性の値。指定が無ければ空文字
     */
    private static resolveElementId;
    /**
     * data-derive subtree host の識別子を作成します。
     *
     * @param fragment 対象フラグメント
     * @returns host 識別子
     */
    private static createDerivedSubtreeHostId;
    /**
     * data-derive subtree の署名計算回数を記録します。
     *
     * @param fragment 対象フラグメント
     * @param source 計算元
     */
    private static recordDerivedSubtreeSignatureComputation;
    /**
     * data-derive subtree の現在プロファイルをログ出力します。
     *
     * @param fragment 対象フラグメント
     * @param reason ログ理由
     */
    private static logDerivedSubtreeProfileSnapshot;
    /**
     * data-each 以外の動的要素状態を持つかどうかを返します。
     *
     * @param fragment 判定対象フラグメント
     * @returns 該当するなら true
     */
    private static hasNonEachDynamicElementState;
    /**
     * fresh clone 初期化を subtree ごと省略できるかどうかを事前計算します。
     *
     * @param fragment 判定対象フラグメント
     * @returns subtree 全体を省略可能なら true
     */
    private static markFreshInitializationSkippable;
    /**
     * fresh clone 初期化で再評価が必要な属性かどうかを返します。
     *
     * @param fragment 判定対象フラグメント
     * @param name 属性名
     * @returns 再評価が必要なら true
     */
    private static isFreshInitializationDynamicAttribute;
    /**
     * 差分を更新します。
     *
     * @param parent 親フラグメント
     * @param newList 新しいリスト
     */
    private static updateDiff;
    /**
     * `data-each` コンテナに要素の子が 2 つ以上あることを開発モードで警告します。
     *
     * 仕様「`data-each`」の配置ルールは、最初の要素の子だけをテンプレートとし、
     * 2 つめ以降は行に入りません。残った子はコンテナへそのまま留まるため、行スコープ
     * の名前を参照している式は解決できず（テキスト補間が展開されないまま表示され）、
     * 行操作のボタンは行に属さないため失敗します。どちらも例外にはならないので、
     * 気づけるようコンテナごとに一度だけ知らせます。
     *
     * テンプレート化の直後に呼ぶ前提です。この時点で残っている子はテンプレート化
     * されなかった残りだけなので、そのまま数えられます。テンプレート化はコンテナ
     * ごとに 1 回だけ通るため（`setTemplate()` を null へ戻す経路はありません）、
     * 警告済みの記録は持ちません。開発モード以外へ出さないのは `Log.warn()` 側の
     * 判定です。
     *
     * 数えるのは DOM の子ではなくフラグメントの子です。DOM を数えると、フラグメント木
     * と DOM の子が同期しない経路（テンプレート復旧のフォールバックが対象にしている
     * 状況）で残った未管理の要素まで数えてしまい、利用者が書いていない構成を指して
     * 警告することになります。
     *
     * @param fragment `data-each` コンテナのフラグメント
     * @returns 戻り値はありません。
     */
    private static warnExtraEachChildren;
    /**
     * `data-each-key` の値が重複していることを開発モードで警告します。
     *
     * 仕様「`data-each`」は `data-each-key` を一意なキーの項目名と定めています。
     * 重複しても行は出現順で対応付けるため描画は崩れませんが、キーによる行の識別
     * （差分更新での再利用、`data-form-list` の行の対応付け、行イベントのキー）は
     * 意図した働きをしません。指定漏れに気づけるよう、項目名ごとに一度だけ知らせます。
     *
     * @param keyArg `data-each-key` に指定された項目名
     * @returns 戻り値はありません。
     */
    private static warnDuplicateEachKey;
    /**
     * 再利用した `data-each` の行を、新しい並び順の位置へ移動します。
     *
     * `insertTargets` は現在の子並びを表す作業用配列で、移動に合わせて更新します。
     * すでに目的の位置にある場合は何もしません。
     *
     * @param parent `data-each` コンテナのフラグメント
     * @param row 移動対象の行フラグメント
     * @param insertTargets 現在の子並び（この呼び出しで更新される）
     * @param targetIndex 移動先のインデックス
     * @returns 移動した場合は移動前のインデックス、移動していない場合は null で
     *   解決される Promise（`haori:rowmove` の発火判定に使う）
     */
    private static repositionEachRow;
    /**
     * `data-each` の行の入力欄へ、その行の要素データを反映します。
     *
     * `data-each` と `data-form-list` を同一要素へ指定した「編集可能な繰り返し行」では、
     * 行内の入力欄は要素データのキーと `name` で対応します。`Core.setBindingData()` の
     * 逆方向同期（`Form.syncValues`）は `Core.evaluateAll`（= 行生成）より**前**に走る
     * ため、その更新で生成・更新された行には値が入りません。ここで行単位に補います。
     *
     * 呼び出すのは「新規生成した行」と「要素データが変化した再利用行」だけです。
     * 変化していない行へ再適用すると、描画の待ち時間中に利用者が編集した入力欄を
     * 古い値で巻き戻す競合になります（0.26.1 で修正した問題と同種）。行の途中へ要素を
     * 挿入すると以降の行は別の要素データを担当することになるため、変化した再利用行への
     * 適用は必要です（これを省くと挿入位置以降の入力値が前の行のまま残ります）。
     *
     * 取得元（`data-each`）と収集先（`data-form-list`）が**別の配列**を指す構成では
     * 反映しません。要素データが権威なのは「行の入力欄が集まって配列要素になる」
     * 場合だけで、別の配列を繰り返している行では、要素データは入力欄を表しません。
     * 反映すると、要素データに無い `name` の欄（選択のチェックボックスなど）が
     * 空になります（`Form.isCollectedListFromEachSource()`）。
     *
     * @param parent `data-each` コンテナのフラグメント
     * @param row 行のフラグメント
     * @param item 行の要素データ
     * @returns 反映完了の Promise
     */
    private static applyRowFormValues;
    /**
     * リスト比較用のキーを生成します。
     *
     * `data-each` の差分更新で行と要素データを対応付けるキーです。行を指した書き込み
     * （`Procedure` の行への copy / bind）でも、`data-each-key` 指定時に「どの配列
     * 要素がその行か」をキーで特定するために使うため公開しています。生成規則を
     * 呼び出し側で作り直すと差分更新との対応が崩れるためです。
     *
     * @param item 対象オブジェクト
     * @param keyArg リストキーに使用するプロパティ名
     * @param index 配列のインデックス
     * @returns リストキー
     */
    static createListKey(item: Record<string, unknown> | string | number, keyArg: string | null, index: number): string;
    /**
     * 行フラグメントにデータを設定します。
     *
     * @param rowFragment 行フラグメント
     * @param data 行データ
     * @param indexKey インデックスキー
     * @param index インデックス番号
     * @param arg バインドデータパラメータ名
     * @param listKey リストキー
     * @returns 行メタデータの更新完了 Promise
     */
    private static updateRowFragment;
    /**
     * 新規挿入行に遅延再評価が必要かどうかを判定します。
     *
     * @param fragment 判定対象の行フラグメント
     * @returns 遅延再評価が必要なら true
     */
    private static needsScheduledEvaluateAll;
    /**
     * mounted 状態に依存して再評価が必要になりやすい属性を持つかどうかを返します。
     *
     * @param fragment 判定対象フラグメント
     * @returns 該当属性を持つなら true
     */
    private static hasMountSensitiveAttribute;
    /**
     * バインド値が同一かどうかを再帰的に判定します。
     *
     * @param left 比較元の値
     * @param right 比較先の値
     * @param visited 循環参照対策用の訪問済みペア
     * @returns 同一なら true
     */
    private static createBindingSignature;
    /**
     * フラグメントの再評価を次のイベントループで実行します。
     *
     * @param fragment 再評価対象のフラグメント
     */
    private static scheduleEvaluateAll;
}

/**
 * エレメントフラグメント。
 * DOM要素を表現し、子ノードを持つことができます。
 */
declare class ElementFragment extends Fragment {
    /**
     * `<input type="number">` が値として受け付ける文字列の形。
     *
     * 省略可の `-`、数字列、省略可の小数部、省略可の指数部で、先頭が `.` の小数も
     * 受け付けます（Chromium で実測した受理範囲）。`+5` / `5.` / `0x10` / `1_000` /
     * 前後に空白のある数字 / `Infinity` はブラウザが空表示にするため受け付けません。
     * ここを緩めると、画面に出ていない値が収集・送信されます（仕様「収集は DOM を
     * 真とする」）。
     */
    private static readonly NUMBER_INPUT_PATTERN;
    /** `data-value-type` で宣言できる収集値の型（仕様「`data-value-type`」） */
    private static readonly VALUE_TYPE_NAMES;
    /** `data-value-type` の宣言について警告済みのキー（同じ宣言で繰り返さない） */
    private static readonly loggedValueTypeDeclarations;
    /** HTML 真偽属性名のセット */
    private static readonly BOOLEAN_ATTRIBUTES;
    /** inputイベントを発生させるタイプ */
    private static readonly INPUT_EVENT_TYPES;
    /** 子フラグメントのリスト */
    private readonly children;
    /** 属性名に対する属性情報のマップ */
    private readonly attributeMap;
    /** バインドデータ */
    private bindingData;
    /**
     * バインドデータ更新（DOM 反映・再評価）を呼出順（FIFO）で直列化するための
     * チェーン。同一フラグメントへの並行呼出による適用順の逆転を防ぐ。
     */
    private bindingWorkChain;
    /**
     * 実行中のバインドワーク（`Core.setBindingData` の work）の入れ子数。
     * await をまたぐワークの全期間にわたって 0 より大きくなる。`> 0` の間は、
     * このフラグメントのバインドワークが（配下の `data-fetch` 等を）await しながら
     * 実行中であることを表す。マネージド fetch の bind-back が同一フラグメントを
     * 指す場合に、FIFO キューへ積むと自己デッドロックするため、この状態を見て
     * 即時実行（reentrant）へ切り替える判定に使う。
     */
    private bindingWorkActive;
    /**
     * このフラグメントへ最後に適用された明示的な値の供給の通番（未適用は 0）。
     *
     * 供給同士は後勝ちです（仕様「反映待ちの間に起きた変化」）。古い供給が後から届いた供給を上書きしない
     * よう、供給を起こした操作の通番と比べて判定します。初期化も 1 つの供給として
     * 同じ列で数えます（`isSupplyStale()`）。
     */
    private lastSupplySequence;
    /**
     * このフラグメントが最後に初期化された時点の通番（未初期化は 0）。
     *
     * バインドデータ更新（`Core.setBindingData()`）は「data-bind 属性の反映 → 入力欄
     * への書き戻し → 再評価（行生成）→ 載らなかった書き込みの載せ直し」を非同期に
     * 行うため、呼び出しの後もしばらく DOM を書き換え続けます。この途中で初期化が
     * 始まると、初期化でクリアした値が後段で書き戻され、クリアが効かなくなります。
     * 更新の開始時点の通番と比べて「その後に初期化されたか」を判定するために使います。
     */
    private lastResetSequence;
    /** 生成時点の data-bind 属性の生値（リセット時の初期状態復元用） */
    private readonly initialBindAttribute;
    /** 子孫要素へ公開する派生バインドデータ */
    private derivedBindingData;
    /** バインドデータのキャッシュ */
    private bindingDataCache;
    /** 子孫要素向けバインドデータのキャッシュ */
    private descendantBindingDataCache;
    /** 表示状態 */
    private visible;
    /** 元の display 値 */
    private display;
    /** 元の display の優先度 */
    private displayPriority;
    /** each用のテンプレート */
    private template;
    /**
     * each テンプレートが行スコープの値だけで描画できるかどうか（未判定は null）。
     * テンプレートは差し替えられるまで不変なので、判定結果を保持して再利用する。
     */
    private rowLocalTemplate;
    /** each比較用のキー */
    private listKey;
    /** 直近に描画した each 行の入力署名 */
    private renderSignature;
    /** 直近に描画した data-each 全体の入力署名 */
    private eachInputSignature;
    /** 直近に公開した data-derive subtree の入力署名 */
    private deriveSubtreeSignature;
    /** 直近に評価した data-derive の入力署名 */
    private deriveInputSignature;
    /** fresh clone 初期化を subtree ごと省略できるかどうか */
    private freshInitializationSkippable;
    /** valueプロパティの値（複数選択 select は文字列配列を保持する） */
    private value;
    /**
     * 自身が書き込み中の属性名（オブザーバーによる無限ループ対応）。
     *
     * Haori が属性へ書き込むと `MutationObserver` がその変化を観測し、同じ属性へ
     * 書き戻そうとします。書き込みが完了するまで**その属性名**を記録しておき、記録に
     * ある属性への書き込みは行いません。
     *
     * **属性名ごとに持ちます。** 要素ごとの真偽値 1 つにすると、キュー待ちの書き込みが
     * ある間はその要素の**別の属性**への書き込みまで捨ててしまいます（`data-fetch` の
     * 評価結果を属性へ書いている最中に、応答の self-bind が `data-bind` 属性へ
     * ミラーできず、属性と in-memory が食い違って残る不具合になっていました）。
     *
     * 値は書き込みの完了 Promise です。**同じ属性へ内部から届いた書き込みは捨てず**、
     * この Promise を待ってから改めて反映します（後勝ち、仕様「反映待ちの間に起きた変化」）。捨てるのは
     * オブザーバー由来の書き戻し（＝自分の書き込みのエコー。ここがループの断ち口）と
     * 削除だけです。
     */
    private readonly selfWritingAttributes;
    /** 値変更スキップフラグ（更新イベントによる無限ループ対応） */
    private skipChangeValue;
    /**
     * 直近に Haori 自身が書き込んだ値を DOM が受け付けられなかったかどうか。
     *
     * `<select>` は該当する `<option>` が無いと値の代入が無視され、空のままになります
     * （候補を `data-each` で流し込む構成では、入力欄への書き戻しが行生成より前に走る
     * ため起こり得ます）。この状態では DOM が内部値を表現できていないため、収集時に
     * DOM を真として読むと、供給された値が画面に見えている別の値へ化けます。
     * DOM を読んでよいかを判断するために記録します（`getValueForCollection()` を参照）。
     */
    private valueWriteUnapplied;
    /**
     * 直近の書き込みを DOM が受け付けなかったフラグメントの集合。
     *
     * 候補が揃った後に載せ直せるよう、再試行の対象として控えます
     * （`retryUnappliedValueWrites()` を参照）。載った時点、および DOM から値を
     * 取り込んだ時点で外します。
     */
    private static readonly UNAPPLIED_VALUE_WRITES;
    /**
     * 描画キュー待ちの値の書き込み（無い場合は null）。
     *
     * 待っている間に別の値が要求されたとき、その完了を待ってから改めて反映するために
     * 保持します。捨ててしまうと、最後に供給された値が画面にもバインドにも載りません。
     */
    private pendingValueWrite;
    /**
     * 値に影響する事象の通番の発番元（全フラグメント共通、単調増加）。
     *
     * ユーザー編集と明示的な値の供給（初期化を含む）を**同じ 1 本の列**で数えます。
     * 系統を分けると「編集と初期化のどちらが先か」を比較できず、互いを見られない
     * まま別々に判定することになります（`docs/ja/値の供給と権威解決の設計書.md`）。
     */
    private static sequenceCounter;
    /**
     * この入力欄を最後にユーザーが編集したときの通し番号（未編集は 0）。
     * 「ある時点より後に編集されたか」を比較するために使う。
     */
    private userEditSequence;
    /**
     * 明示的な値の供給を最後に受けた時点のユーザー編集通し番号（未受領は 0）。
     * これより大きい `userEditSequence` を持つ入力欄は「まだ供給で上書きされて
     * いない編集を抱えている」とみなし、宣言バインドの再適用対象から外す。
     */
    private authoritativeValueSequence;
    /**
     * この入力欄へ最後に適用した権威ある値の通番（未適用は 0）。
     *
     * 「権威ある値」は供給と編集だけです（`ValueChangeKind`）。非供給更新は台帳を
     * 更新しません。更新させると、絶えず走る宣言バインドの再評価が最新の通番を
     * 記録してしまい、後から届く正当な供給を古いと誤判定します。
     */
    private lastValueSequence;
    /**
     * この入力欄へ最後に適用した権威ある値の種別。
     * `edit` のあいだは「まだ供給で上書きされていない編集を抱えている」状態です。
     */
    private lastValueKind;
    /**
     * エレメントフラグメントのコンストラクタ。
     * アトリビュートや子フラグメントの作成も行います。
     *
     * @param target 対象エレメント
     */
    constructor(target: HTMLElement);
    /**
     * 取り込んだ子が元の親で占めていた位置を、この断片が引き継ぎます。
     *
     * 外部ライブラリが既存の要素を生成コンテナで包むと、その生成コンテナの断片が
     * 作られたときに、既知の子（包まれた入力欄）の断片を取り込みます。元の親の子の
     * 一覧を直さないと、入力欄の親はどの木にも繋がらない生成コンテナになり、祖先の
     * バインドデータが見えなくなります（双方向バインディングと属性の再評価が働かな
     * くなる。課題 46）。元の親の一覧では、取り込んだ子をこの断片で置き換えます。
     *
     * @param previousParent 取り込んだ子が属していた親
     * @param adopted 取り込んだ子
     * @returns 戻り値はありません。
     */
    private takeOverPlaceOf;
    /**
     * ノードの断片が、同じ `data-external` の要素の内側で既に別の親に属しているかを返します。
     *
     * 外部ライブラリが `data-external` の配下に生成したコンテナの断片が、内部の走査
     * （全要素に `Fragment.get()` を呼ぶ処理など）で作られると、そのコンストラクタが
     * 既知の子（書いた `<select>` など）の断片を奪い、元の親の子の一覧と親の指す先が
     * 食い違います。その後の移動で、書いた入力が収集から落ちます（仕様「`data-external`」、
     * 課題 #43）。`data-external` の外では従来どおり奪います（移動の処理がこの付け替えに
     * 依存しているため）。親がその子を一覧に載せているかは確かめません（`data-external`
     * の内側で断片の親が古くなる経路は無く、確かめる行を外しても結果が変わらないことを
     * 確認済み）。
     *
     * @param node 子ノード
     * @returns 取り込まない場合 true
     */
    private static isOwnedWithinExternal;
    /**
     * 子フラグメントのリストを取得します。
     *
     * @returns 子フラグメントのリスト
     */
    getChildren(): Fragment[];
    /**
     * 子エレメントフラグメントのリストを取得します。
     *
     * @returns 子エレメントフラグメントのリスト
     */
    getChildElementFragments(): ElementFragment[];
    /**
     * 子フラグメントをリストに追加します。
     * DOMの追加は行いません。
     *
     * @param child 追加する子フラグメント
     */
    pushChild(child: Fragment): void;
    /**
     * 子フラグメントをリストから削除します。
     * DOMからの削除は行いません。
     *
     * @param child 削除する子フラグメント
     */
    removeChild(child: Fragment): void;
    /**
     * フラグメントをクローンします。
     *
     * @returns クローンされたフラグメント
     */
    clone(): ElementFragment;
    /**
     * エンジンが判定の結果として DOM へ書いた属性（追随結果）を落とします。
     *
     * 追随結果は宣言ではないため、内部状態を持たない要素（フラグメントを作る時点の
     * 要素、複製した要素）に残っていても取り込みません（仕様「data-if の動作」の
     * 「追随結果を取り込まない範囲は、DOM の監視だけでなく**要素の内部状態を作る
     * 時点**（走査・複製）にも及びます」）。Haori が出力した HTML を保存して再配信
     * する構成、`innerHTML` でコピーした断片、`data-import` で取り込む断片が該当
     * します。
     *
     * @param target 対象エレメント
     * @returns 戻り値はありません。
     */
    private static dropFollowUpArtifacts;
    /**
     * `data-if` の非表示化が DOM へ書いた追随結果を落とします。
     *
     * 仕様「data-if の動作」の「判定の基準は内部状態であり、`style.display` や
     * `data-if-false` は追随結果として扱う」に従います。内部状態を持たない要素
     * （フラグメントを作る時点の要素、複製した要素）に追随結果が残っていると、
     * 内部状態は「表示」なのに DOM は非表示という食い違いになり、`show()` は内部状態を
     * 基準に何もしないため**表示に戻れません**。
     *
     * @param target 対象エレメント
     * @returns 戻り値はありません。
     */
    private static dropIfVisibilityArtifacts;
    /**
     * フラグメントとノードを削除します。
     *
     * @param unmount DOMからの除去を行うかどうか（内部の子呼び出しの場合のみfalseとする）
     * @return 除去のPromise
     */
    remove(unmount?: boolean): Promise<void>;
    /**
     * `data-external` の要素を、内部のフラグメント木を保ったまま親から外します。
     *
     * 外した木を捨てると、付け直し（移動を含む）で DOM から組み立て直すことになり、
     * 外部ライブラリが配下に生成した DOM ごと取り込んでフォーム値の収集に載せます
     * （仕様「`data-external`」の「付け直した場合も、配下は走査した時点の構成のまま
     * 扱う」、課題 #42）。子の断片・属性・キャッシュ登録は保ち、付け直しでは
     * `Core.addNode()` がこの断片をそのまま挿入して走査します。バインドデータの
     * キャッシュは、付け直しで親を設定するとき（`setParent()`）に部分木ごと捨てられる
     * ため、ここでは捨てません（捨てる行を外しても結果が変わらないことを確認済み）。
     *
     * @param unmount DOM からの除去を行うかどうか
     * @returns 除去の Promise
     */
    private detachPreservingSubtree;
    /**
     * フラグメントの対象エレメントを取得します。
     *
     * @returns フラグメントの対象エレメント
     */
    getTarget(): HTMLElement;
    /**
     * 継承を考慮したバインドデータを取得します。
     *
     * @returns バインドデータのオブジェクト
     */
    getBindingData(): Record<string, unknown>;
    /**
     * 子孫要素向けのバインドデータを取得します。
     *
     * @returns 子孫要素向けのバインドデータ
     */
    getDescendantBindingData(): Record<string, unknown>;
    /**
     * 生のバインドデータを取得します。
     *
     * @returns 生のバインドデータ
     */
    getRawBindingData(): Record<string, unknown> | null;
    /**
     * Haori 自身が `data-bind` 属性へ書き込んだ値の多重集合。MutationObserver が
     * 自身の書き込みのエコーを in-memory へ再取り込みして、並行更新時に古い値へ
     * 巻き戻すのを防ぐために使う。外部からの `data-bind` 変更（記録に無い値）は
     * 従来どおり取り込む。
     */
    private readonly selfWrittenBind;
    /**
     * `data-bind` 属性への自己書き込みを記録します（DOM へ実際に書き込んだ時に呼ぶ）。
     *
     * @param value 書き込んだ属性値
     */
    recordSelfWrittenBind(value: string): void;
    /**
     * 指定値が Haori 自身の `data-bind` 書き込みのエコーかどうかを判定し、該当すれば
     * 記録を 1 つ消費します。
     *
     * @param value MutationObserver が観測した属性値
     * @returns 自己書き込みのエコーであれば true（再取り込みをスキップしてよい）
     */
    consumeSelfWrittenBind(value: string): boolean;
    /**
     * 生の派生バインドデータを取得します。
     *
     * @returns 生の派生バインドデータ
     */
    getRawDerivedBindingData(): Record<string, unknown> | null;
    /**
     * バインドデータを設定します。
     *
     * 予約キー（`_` 始まりのエンジン管理変数）は、新しいデータが同じキーを持たない
     * 限り引き継ぎます（仕様「`data-bind`」）。予約キーは `data-bind` 属性へ書き出さ
     * ないため、宣言を取り込む側も外部から属性を書き換える側もこの値を運べません。
     * 引き継がないと、`data-if` が真になったときの子の初期化や外部からの書き換えの
     * たびに `_fetch` / `_poll` が消え、注入した状態が「まだ何も起きていない」状態と
     * 区別できなくなります。明示的に落とす場合はキー自体を持たせてください
     * （`{_fetch: undefined}`）。
     *
     * @param data バインドデータ
     */
    setBindingData(data: Record<string, unknown>): void;
    /**
     * 新しいバインドデータへ、現在の予約キーのうち引き継ぐものを足します。
     *
     * @param data 新しいバインドデータ
     * @returns 予約キーを引き継いだバインドデータ
     */
    private withRetainedReservedKeys;
    /**
     * 予約キー（エンジン管理変数）かどうかを判定します。
     *
     * `_fetch` / `_poll` など、Haori が実行時に注入し、`data-bind` 属性へ書き出さない
     * 値が対象です（仕様「`data-bind`」）。`data-bind` 属性へのミラー
     * （`Core.setBindingData()`）も同じ判定で対象から外します。
     *
     * @param key 判定対象のキー
     * @returns 予約キーなら true
     */
    static isReservedBindingKey(key: string): boolean;
    /**
     * バインドデータ更新に伴う DOM 反映・再評価を、同一フラグメントでは呼出順
     * （FIFO）で直列実行します。並行呼出による適用順の逆転（古いデータが後から
     * 適用されて新しい値を上書きする現象）を防ぎます。
     *
     * 純粋な FIFO（並行呼出を決して即時インライン実行しない）です。以前は実行中
     * フラグでの「再入即時実行」を行っていましたが、await をまたいで届く**独立した
     * 並行呼出**まで再入扱いしてインライン実行し、書き込み中の属性として記録されて
     * いる間の `data-bind` 書き込みが破棄されて古い値が後勝ちする競合の原因に
     * なっていました（記録は `selfWritingAttributes` で属性名ごとに持つようになり、
     * 別の属性の書き込みに巻き込まれることは無くなっています）。真の再入
     * （`data-url-param` の再評価、マネージド `data-fetch` の同一フラグメントへの
     * bind-back）は呼出側が `reentrant=true` でキューを介さず実行するため、ここでは
     * 一律にチェーンへ積みます。
     *
     * @param work 直列化したいバインドデータ更新処理
     * @returns work の完了 Promise
     */
    /**
     * このフラグメントのバインドワークが実行中（await をまたぐ期間を含む）かどうかを
     * 返します。マネージド `data-fetch` の bind-back を reentrant 実行へ切り替えるべきか
     * の判定に使います。
     *
     * @return 実行中なら true
     */
    isExecutingBindingWork(): boolean;
    /**
     * 全フラグメントで実行中のバインドワークの数。
     *
     * `nextOperationSequence()` が保留中の外部変更を同期的に取り込んでよいかの判定に
     * 使います（`ElementFragment.isExecutingAnyBindingWork()`）。
     */
    private static bindingWorkActiveCount;
    /**
     * どこかでバインドワークが実行中かどうかを返します。
     *
     * @returns 実行中なら true
     */
    static isExecutingAnyBindingWork(): boolean;
    /**
     * バインドワークの実行開始を記録します（`Core.setBindingData` の work 開始時に呼ぶ）。
     */
    markBindingWorkStart(): void;
    /**
     * バインドワークの実行終了を記録します（work 完了時に呼ぶ）。
     */
    markBindingWorkEnd(): void;
    /**
     * このフラグメントへ供給が適用されたことを記録します。
     *
     * すでに新しい供給が記録されている場合は下げません（単調増加）。
     *
     * @param sequence その供給を起こした操作の通番（`nextSequence()` で発番したもの）
     * @returns 戻り値はありません。
     */
    markSupplyApplied(sequence: number): void;
    /**
     * 指定した通番の供給がすでに古くなっているかを返します。
     *
     * 真の場合、その供給より後の供給がこの宛先へ適用済みです。古い供給を載せると
     * 「最後に供給された値が残る」（仕様「反映待ちの間に起きた変化」）が崩れるため、適用してはいけません。
     *
     * @param sequence 判定したい供給の通番
     * @returns より新しい供給が適用済みなら true
     */
    isSupplyStale(sequence: number): boolean;
    /**
     * このフラグメントが初期化されたことを記録します。
     *
     * @param sequence `nextSequence()` で発番した、初期化を要求した操作の通番
     * @returns 戻り値はありません。
     */
    markResetAt(sequence: number): void;
    /**
     * 指定した時点より後にこのフラグメントが初期化されたかを返します。
     *
     * 真の場合、その時点で始まったバインドデータ更新が運ぶ値は初期化前の状態なので、
     * 入力欄へ書き戻してはいけません（クリアしたはずの値が復活するため）。
     *
     * @param sequence 比較する時点の初期化の通番
     * @returns その後に初期化されていれば true
     */
    wasResetAfter(sequence: number): boolean;
    /**
     * バインドデータ更新のワークを FIFO で直列化して実行します。
     *
     * @param work 実行するワーク
     * @returns ワークの完了 Promise（失敗した場合は reject する）
     */
    enqueueBindingWork(work: () => Promise<void>): Promise<void>;
    /**
     * 生成時点の data-bind 属性の生値を取得します。
     * 実行時のバインドデータ更新で data-bind 属性が書き換えられた後も、
     * 宣言時の初期状態（リセット時の復元先）を参照できます。
     *
     * @returns 生成時点の data-bind 属性値。宣言がない場合は null。
     */
    getInitialBindAttribute(): string | null;
    /**
     * 子孫要素向けの派生バインドデータを設定します。
     *
     * @param data 派生バインドデータ。解除する場合は null
     */
    setDerivedBindingData(data: Record<string, unknown> | null): void;
    /**
     * 親フラグメントを設定します。バインドデータキャッシュをクリアします。
     *
     * @param parent 親フラグメント
     */
    setParent(parent: ElementFragment | null): void;
    /**
     * バインドデータのキャッシュをクリアします。
     */
    clearBindingDataCache(): void;
    /**
     * フラグメントのテンプレートを取得します。
     *
     * @returns テンプレート
     */
    getTemplate(): ElementFragment | null;
    /**
     * フラグメントのテンプレートを設定します。
     *
     * @param template フラグメントのテンプレート
     */
    setTemplate(template: ElementFragment | null): void;
    /**
     * `data-each` テンプレートが行スコープの値だけで描画できるかの判定結果を返します。
     *
     * @returns 判定済みなら真偽値、未判定なら null
     */
    getRowLocalTemplate(): boolean | null;
    /**
     * `data-each` テンプレートが行スコープの値だけで描画できるかの判定結果を保存します。
     *
     * @param rowLocal 行スコープだけで描画できるなら true
     */
    setRowLocalTemplate(rowLocal: boolean | null): void;
    /**
     * 比較用リストキーを設定します。
     *
     * @param key 比較用リストキー
     */
    setListKey(key: string): void;
    /**
     * 比較用リストキーを取得します。
     *
     * @returns 比較用リストキー
     */
    getListKey(): string | null;
    /**
     * 直近に描画した each 行の入力署名を取得します。
     *
     * @returns 入力署名
     */
    getRenderSignature(): string | null;
    /**
     * 直近に描画した each 行の入力署名を設定します。
     *
     * @param signature 入力署名
     */
    setRenderSignature(signature: string | null): void;
    /**
     * 直近に描画した data-each 全体の入力署名を取得します。
     *
     * @returns 入力署名
     */
    getEachInputSignature(): string | null;
    /**
     * 直近に描画した data-each 全体の入力署名を設定します。
     *
     * @param signature 入力署名
     */
    setEachInputSignature(signature: string | null): void;
    /**
     * 直近に公開した data-derive subtree の入力署名を取得します。
     *
     * @returns 入力署名
     */
    getDeriveSubtreeSignature(): string | null;
    /**
     * 直近に公開した data-derive subtree の入力署名を設定します。
     *
     * @param signature 入力署名
     */
    setDeriveSubtreeSignature(signature: string | null): void;
    /**
     * 直近に評価した data-derive の入力署名を取得します。
     *
     * @returns 入力署名
     */
    getDeriveInputSignature(): string | null;
    /**
     * 直近に評価した data-derive の入力署名を設定します。
     *
     * @param signature 入力署名
     */
    setDeriveInputSignature(signature: string | null): void;
    /**
     * fresh clone 初期化を subtree ごと省略できるかどうかを返します。
     *
     * @returns 省略可能なら true
     */
    isFreshInitializationSkippable(): boolean;
    /**
     * fresh clone 初期化を subtree ごと省略できるかどうかを設定します。
     *
     * @param skippable 省略可能なら true
     */
    setFreshInitializationSkippable(skippable: boolean): void;
    /**
     * 入力エレメントに値を設定します。
     * チェックボックとラジオボタンの場合は値に一致するかどうかでチェック状態を変更します。
     *
     * @param value 値
     * @param origin 値の由来（通番と種別）。渡すと宛先の台帳で適用可否を判定します。
     *     省略した場合は判定せず、従来どおり「要求後の編集だけ」を守ります
     * @returns エレメントの更新のPromise
     */
    setValue(value: string | number | boolean | null | Array<string | number | boolean | null>, origin?: ValueChangeOrigin | null): Promise<void>;
    /**
     * 入力エレメントに値をイベントなしで設定します。
     * フォームの bindingData 反映時に内部同期として利用します。
     *
     * @param value 値
     * @param origin 値の由来（通番と種別）。渡すと宛先の台帳で適用可否を判定します
     * @returns エレメントの更新のPromise
     */
    syncBindingValue(value: string | number | boolean | null | Array<string | number | boolean | null>, origin?: ValueChangeOrigin | null): Promise<void>;
    /**
     * 入力エレメントに値を設定します。
     * 必要に応じて入力系イベントも発火します。
     * 配列はチェックボックスグループ用で、自身の value が配列に含まれるかで
     * チェック状態を決定します。
     *
     * @param value 値
     * @param dispatchEvents input/change イベントを発火するかどうか
     * @param origin 値の由来（通番と種別）。渡すと宛先の台帳で適用可否を判定します
     * @returns エレメントの更新のPromise
     */
    private applyValue;
    /**
     * 値を持つ入力エレメント（テキスト系 / textarea / 単一選択 select）へ値を反映します。
     *
     * 内部値は同期的に確定し、DOM への書き込みは描画キューへ積みます。
     *
     * @param scalarValue 反映する値
     * @param dispatchEvents input/change イベントを発火するかどうか
     * @param origin 値の由来（通番と種別）。書き込み直前にも適用可否を判定します
     * @returns 反映完了の Promise
     */
    private writeScalarValue;
    /**
     * 複数選択 `<select>` へ選択状態を反映します。
     *
     * `option` を都度走査して冪等に適用し、実際に選択が変化した場合のみ change を
     * 発火します（バインド反映ループでの不要な再発火を防ぐため）。
     *
     * @param selectedValues 選択したい値（文字列）の配列
     * @param dispatchEvents change イベントを発火するかどうか
     * @param origin 値の由来（通番と種別）。書き込み直前にも適用可否を判定します
     * @returns 反映完了の Promise
     */
    private writeSelectedValues;
    /**
     * 値の DOM 書き込みを描画キューへ積み、反映待ちの状態を記録します。
     *
     * 書き込みの間は `skipChangeValue` を立て、自分が起こした変更を利用者の操作と
     * 取り違えないようにします。
     *
     * @param task DOM への書き込み
     * @returns 反映完了の Promise
     */
    private enqueueValueWrite;
    /**
     * 反映を要求した後に利用者が編集したかを返します。
     *
     * 描画キュー待ちの間に確定した入力を、待っていた書き込みが上書きすると、利用者
     * には「入力した値が勝手に消える」現象として現れます。要求時点の通し番号と比べて
     * 判定します（要求より前の編集は、明示的な値の供給が権威なので上書きします）。
     *
     * @param requestedSequence 反映を要求した時点のユーザー編集の通し番号
     * @returns 要求後に編集されていた場合 true
     */
    private isSupersededByUserEdit;
    /**
     * DOM が受け付けられなかった値の書き込みを再試行します。
     *
     * 候補を `data-each` で流し込む `<select>` では、入力欄への書き戻しが行生成より
     * 前に走るため、代入した時点で該当する `<option>` がまだありません。`<select>` は
     * 候補に無い値の代入を無視するので、供給された値が画面に載らないまま（ブラウザが
     * 先頭の候補を自動選択したまま）になります。行生成の後に呼び出して、載せられる
     * ようになった値を載せ直します。
     *
     * 対象は `<select>` だけです。テキスト系の入力は同じ値を書き直しても結果が変わり
     * ません。候補がまだ揃っていない場合は書き込まず、次の機会に持ち越します（現在の
     * 選択を消さないため）。
     *
     * 呼び出し元の更新が始まった後に初期化された入力欄は対象外とし、記録も破棄します。
     * 載せ直すと、クリアしたはずの値が初期化の後に復活してしまうためです。
     *
     * @param root 再試行の対象とする部分木の起点エレメント
     * @param resetSequence 呼び出し元の更新が始まった時点の初期化の通番
     * @returns 再試行の完了 Promise
     */
    static retryUnappliedValueWrites(root: HTMLElement, resetSequence: number): Promise<void>;
    /**
     * この入力欄で、載らなかった値の書き込みを再試行します。
     *
     * @returns 再試行の完了 Promise
     */
    private retryValueWrite;
    /**
     * Haori が値を書いた入力欄を、適用済みの外部ライブラリ連携へ知らせます。
     *
     * `init` の後に Haori が値を変えた場合（宣言バインドやフェッチ応答の反映など）、
     * `init` の時点の選択を自分の管理へ取り込む連携（`<option>` を移すものなど）は、
     * 知らせないと新しい値を画面に出せません（仕様「`data-enhance`」の契機の表、
     * 課題 44）。
     *
     * 未適用の要素では何もしません（`init` は走査の最後に呼ばれ、その時点の値を読む
     * ため。課題 54）。
     *
     * @param element 値を書いた入力エレメント
     * @returns 戻り値はありません。
     */
    private static notifyValueToEnhancers;
    /**
     * 「載らなかった書き込み」の記録を解除します。
     *
     * @returns 戻り値はありません。
     */
    private clearUnappliedValueWrite;
    /**
     * 入力エレメントの値を取得します。
     * DOM要素の現在の値と同期します。
     *
     * @returns 入力エレメントの値
     */
    getValue(): string | number | boolean | string[] | null;
    /**
     * 現在のユーザー編集の通し番号を返します。
     *
     * 通信を開始した時点の番号を控えておき、応答が届いたときに各入力欄の
     * `getUserEditSequence()` と比べることで「リクエスト送出後に編集されたか」を
     * 判定できます。
     *
     * @returns 直近に発番した通番（未発番なら 0）
     */
    static currentSequence(): number;
    /**
     * 新しい通番を発番します。
     *
     * **操作が起きた時点で呼び出してください。** 非同期の処理が宛先へ到達した時点で
     * 発番すると、先に起きた操作が後の番号を得て、権威の判定が逆転します。
     *
     * 利用者の操作を起点に発番する場合は `nextOperationSequence()` を使ってください。
     *
     * @returns 発番した通番
     */
    static nextSequence(): number;
    /**
     * 保留中の外部 DOM 変更を同期的に取り込む処理（`Observer` が登録する）。
     *
     * `Observer` を直接参照すると循環参照になるため、フックとして受け取ります。
     */
    private static pendingMutationFlusher;
    /**
     * 保留中の外部 DOM 変更を取り込む処理を登録します。
     *
     * @param flusher 取り込み処理。解除する場合は `null`
     * @returns 戻り値はありません。
     */
    static setPendingMutationFlusher(flusher: (() => void) | null): void;
    /**
     * 利用者の操作を起点とする通番を発番します。
     *
     * 発番の前に、保留中の外部 DOM 変更を同期的に取り込んで**先に**番号付けします。
     * `MutationObserver` は非同期にしか通知しないため、これを行わないと「属性を書き
     * 換えた直後にクリックした」場合に、先に起きた外部の書き換えが後の番号を得て
     * 権威が逆転します（`docs/ja/値の供給と権威解決の設計書.md`「段構成の訂正」）。
     *
     * **バインドワークが実行中のときは取り込みを行いません。** 取り込みは
     * `Core.setAttribute()` → `Core.setBindingData()` を同期的に呼ぶため、ワークの
     * 内部で行うと実行中のワークへ再入します。以前はこれを「イベント起点からだけ
     * 呼ぶ」という呼び出し側の規約で守っていましたが、規約は強制されないため
     * 構造で防ぐようにしました（`isExecutingAnyBindingWork()`）。順序の逆転が問題に
     * なるのは「外部が書き換えた直後に利用者が操作した」場合だけで、その時点で
     * バインドワークが走っていることはありません。
     *
     * @returns 発番した通番
     */
    static nextOperationSequence(): number;
    /**
     * この入力欄へ値を適用してよいかを返します。
     *
     * 入力欄フラグメントは値の宛先の 1 つで、適用可否の判定はここに集約します
     * （`docs/ja/値の供給と権威解決の設計書.md`）。判定の規則は 1 文です。
     *
     * > 各宛先には、最後に適用された通番より新しい書き込みだけを適用する。ただし
     * > 非供給更新は、その宛先に編集が確定していれば通番によらず適用しない。
     * > 同じ通番では編集が勝つ。
     *
     * 同じ通番の供給を再度受け付けるのは、1 つの供給が同じ入力欄へ二度書くことが
     * あるためです（`Form.syncValues()` の後に `retryUnappliedValueWrites()` が
     * `<select>` の候補が揃ってから載せ直す）。二度目を弾くと供給された値が画面に
     * 載りません。
     *
     * **双方向コミットが運ぶ値は、この入力欄が自身の編集より後に初期化されていれば
     * 適用しません。** コミット（`change` / `input`）はフォーム全体の収集値を運びますが、
     * その値を読んだのは編集の時点です。`change` はフォーカスを外した時点で発火する
     * ため、読んだ後・書き戻す前に初期化が挟まることがあります。呼び出しの時点だけで
     * 比べると「初期化より後に始まった更新」と見なされ、クリアした値が復活します
     * （仕様「`data-{event}-reset`」の「進行中のバインドデータ更新は書き戻しません」）。
     * 初期化より後に行われた編集（`userEditSequence` の方が新しい欄）は対象外なので、
     * クリアの途中に打った文字はそのまま残ります。
     *
     * @param origin 適用しようとしている値の由来
     * @returns 適用してよい場合は true
     */
    canApplyValue(origin: ValueChangeOrigin): boolean;
    /**
     * 宛先の判定規則そのものです。入力欄と経路のどちらの宛先でも同じ規則を使います。
     *
     * @param last その宛先へ最後に適用された値の由来（未適用なら null）
     * @param origin 適用しようとしている値の由来
     * @returns 適用してよい場合は true
     */
    private static isApplicable;
    /**
     * バインドデータの経路ごとの最終適用記録。
     *
     * 宛先をキー単位ではなく**経路単位**（`a.b.c`、配列は `rows[#id=3].title`）に
     * するのは、`data-form-arg` フォームが配下だけを所有する構成と、行配列の要素の
     * 競合を同じ仕組みで扱うためです（`docs/ja/値の供給と権威解決の設計書.md` の
     * 決定済みの論点 2）。変化した経路だけを記録し、変化しなかった経路には触りません。
     */
    private readonly lastPathApplied;
    /**
     * このフラグメントのバインドデータの、指定した経路へ値を適用してよいかを返します。
     *
     * @param path 対象の経路（`a.b.c`）
     * @param origin 適用しようとしている値の由来
     * @returns 適用してよい場合は true
     */
    canApplyPath(path: string, origin: ValueChangeOrigin): boolean;
    /**
     * このフラグメントのバインドデータの、指定した経路へ値を適用したことを記録します。
     *
     * 非供給更新は記録しません（入力欄の台帳と同じ理由。絶えず走る再評価が最新の
     * 通番を記録すると、後から届く正当な供給を古いと誤判定します）。
     *
     * @param path 対象の経路
     * @param origin 適用した値の由来
     * @returns 戻り値はありません。
     */
    markPathApplied(path: string, origin: ValueChangeOrigin): void;
    /**
     * この入力欄へ値を適用したことを記録します。
     *
     * 非供給更新は記録しません（`lastValueSequence` の説明を参照）。
     *
     * @param origin 適用した値の由来
     * @returns 戻り値はありません。
     */
    markValueApplied(origin: ValueChangeOrigin): void;
    /**
     * この入力欄がユーザーに編集されたことを記録します。
     *
     * DOM で `change` / `input` が発火した時点に呼び出します。イベントを伴って値を
     * 反映した場合（`Form.setValues()` など）も、その発火を通じて呼ばれます。
     * イベントを伴わない反映（`syncBindingValue()` や `Core.setBindingData()` 由来の
     * 書き戻し）では呼び出しません。
     *
     * 内部値の同期（`syncValue()`）とは独立です。手続きを起動しない `input` では
     * 発番だけを行い、内部値は同期しません（`EventDispatcher.recordUserEdit()`）。
     *
     * @returns 発番した編集の通番
     */
    markUserEdit(): number;
    /**
     * 直前の `change` による編集の記録で使った通番。
     *
     * その後に打鍵（`input`）があったかどうかを `markUserEditOnChange()` で判定します。
     */
    private lastChangeSequence;
    /**
     * `change` によるユーザー編集を記録します。
     *
     * **`change` の発火そのものは編集の時点になりません。** 編集の時点は値が変わった
     * 時点で、打鍵なら `input` が記録しています（仕様「ユーザー編集と宣言バインドの
     * 権威」の「印は打鍵ごと（`input`）に付きます」）。`change` はフォーカスを外した
     * 時点でしか発火しないため、そこで打ち直すと、打鍵の後・`change` の前に要求された
     * 供給（`data-{event}-reset` など）よりも新しい編集に見え、その供給が「要求より後の
     * 編集」として棄却されてしまいます（仕様「反映待ちの間に起きた変化」）。
     *
     * したがって直前の `change` より後に打鍵があれば、**その打鍵の時点**を編集の時点
     * とします。打鍵が無い場合（外部ライブラリが `<select>` の値を差し替えたときなど）
     * は、値が変わったことをここで初めて知るため、この時点を編集として記録します。
     *
     * @returns この編集の通番
     */
    markUserEditOnChange(): number;
    /**
     * この入力欄を最後にユーザーが編集したときの通し番号を返します。
     *
     * @returns ユーザー編集の通し番号（未編集なら 0）
     */
    getUserEditSequence(): number;
    /**
     * 宣言バインドの再適用を抑止すべきユーザー編集を抱えているかを返します。
     *
     * `change` / `input` で確定した値は、明示的な値の供給（フェッチ応答や
     * `data-{event}-bind` の反映、`data-{event}-reset`、`data-{event}-copy`、
     * `data-each` の行データ差し替え）を受けるまで権威を持ちます。評価結果が
     * 変わらない再評価で書き戻すと、利用者には「別の欄を触ったら入力が元へ戻る」
     * 現象として現れるため、その再適用を抑止します。
     *
     * @returns 未確定のユーザー編集がある場合は true
     */
    hasPendingUserEdit(): boolean;
    /**
     * ユーザー編集の印を解除します。
     *
     * 解除後の再評価では宣言バインドの評価結果が入力欄へ再適用されます。
     * フェッチ応答の反映ではリクエスト送出時点の通し番号を渡します。応答より後に
     * 行われた編集の印は残るため、飛行中の通信の応答で新しい編集が消えることは
     * ありません。
     *
     * @param upTo この通し番号までの編集を解除対象とする（既定は現在の最新）
     * @return 戻り値はありません。
     */
    clearUserEditMark(upTo?: number): void;
    /**
     * 未解決参照により属性の反映を見送ったことを報告済みの宣言。
     * 再評価ごとに警告すると開発コンソールが埋まるため、同じ宣言は一度だけ報告する。
     */
    private static readonly loggedUnresolvedAttributes;
    /**
     * 未解決参照により属性の反映を見送ったことを開発モードで警告します。
     *
     * 未解決参照のときは属性を削除し、値の同期対象では値も空へ揃えます。式の書き
     * 間違いやバインドキーの供給漏れが原因の場合、画面上は「なぜか空になる」ように
     * しか見えず、原因の宣言に辿り着けません。そのため原因の属性とテンプレートを
     * 名指しで報告します。`Log.warn` は開発モードでのみ出力します。
     *
     * @param rawName 生の属性名
     * @param targetName 反映先の属性名
     * @param template 宣言されたテンプレート
     * @param element 対象エレメント
     * @return 戻り値はありません。
     */
    private static warnUnresolvedAttribute;
    /**
     * 型の食い違う厳密比較を報告済みの宣言。
     * 再評価ごとに警告すると開発コンソールが埋まるため、同じ宣言は一度だけ報告する。
     */
    private static readonly loggedTypeMismatchedComparisons;
    /**
     * 開発モードで、型の食い違う厳密比較を警告します。
     *
     * `===` / `!==` の両辺の型が違うと、値が同じでも比較は必ず偽になります。API 由来
     * の数値の `id` と、フォームの収集値（文字列）を比べる宣言で起きやすく、
     * `data-attr-selected` / `data-attr-checked` では「選択やチェックが付かない」、
     * その他の `data-attr-*` では「属性が消える」という形でしか現れません。原因の
     * 属性とテンプレート、両辺の型を名指しで報告します。
     *
     * @param rawName 生の属性名
     * @param template 宣言されたテンプレート
     * @param types 両辺の型
     * @param element 対象エレメント
     * @return 戻り値はありません。
     */
    private static warnTypeMismatchedComparison;
    /**
     * チェック状態の宣言バインドについて、再適用を抑止すべきかを判定します。
     *
     * `option` の `selected` はユーザー操作で変化するのが所属する `<select>` の
     * 値なので、印も `<select>` 側で判定します。
     *
     * @param forSelectedOption `option` の `selected` を反映する場合に true
     * @returns 未確定のユーザー編集がある場合は true
     */
    private hasPendingCheckableUserEdit;
    /**
     * 内部の値をクリアします。エレメントのvalue値は変化しません。
     *
     * 載せ直し待ちの書き込みも破棄します。クリアした値を後から載せ直すと、初期化
     * したはずの入力欄がクリア前の値へ戻ってしまうためです。
     */
    clearValue(): void;
    /**
     * 入力要素の種別と `data-value-type` の宣言に応じて値を正規化します。
     *
     * `type="number"` の input では、文字列の入力値・バインド値を数値へ変換します
     * （DTO が数値型を期待する場合に文字列で送られるのを防ぐため）。数値として採用
     * するのは、ブラウザが `<input type="number">` の値として受け付ける文字列だけで
     * す（`NUMBER_INPUT_PATTERN`）。空文字・`null`・受け付けない文字列・有限でない数値
     * は `null` を返します。
     *
     * `data-value-type` を宣言した入力欄では、宣言した型へ正規化します（仕様
     * 「`data-value-type`」）。宣言は `type` より優先するため、`type="number"` へ
     * `string` を宣言した場合は文字列になります。それ以外の要素では値をそのまま
     * 返します。
     *
     * @param element 対象の入力要素
     * @param value 正規化する値
     * @returns 正規化後の値（宣言または `type="number"` に従う）
     */
    private normalizeValueForElement;
    /**
     * 値を数値へ正規化します。
     *
     * 数値として採用するのは、ブラウザが `<input type="number">` の値として受け付ける
     * 文字列だけです（`NUMBER_INPUT_PATTERN`）。空文字・`null`・受け付けない文字列・
     * 有限でない数値は `null` になります（仕様「収集は DOM を真とする」）。
     *
     * @param value 正規化する値
     * @returns 数値。数値として採用できない場合は null
     */
    private static normalizeNumberValue;
    /**
     * 値を真偽値へ正規化します。
     *
     * `"true"` / `"false"` を大文字小文字の区別なく判定します。空文字・`null`・それ以外
     * の文字列（`"1"` / `"on"` など）は `null` です。未入力を `false` として送らない
     * ため、また画面に出ていない値を送らないためで、真偽値がそのまま渡された場合は
     * その値を使います（仕様「`data-value-type`」）。
     *
     * @param value 正規化する値
     * @returns 真偽値。判定できない場合は null
     */
    private static normalizeBooleanValue;
    /**
     * 入力欄に宣言された収集値の型（`data-value-type`）を解決します。
     *
     * 宣言は静的なものとして扱い、DOM の属性から直接読みます。宣言できるのは
     * `boolean` / `number` / `string` で、対象は値を持つ入力（`<input>` のうち
     * `checkbox` / `radio` / `file` を除くもの、`<textarea>`、単一選択の `<select>`）
     * です。対象外の要素や未知の型は宣言が無いものとして扱い、開発モードで警告します
     * （仕様「`data-value-type`」）。
     *
     * @param element 対象の要素
     * @returns 宣言された型。宣言が無い場合と無視する場合は null
     */
    private static resolveDeclaredValueType;
    /**
     * `data-value-type` の宣言を受け付ける要素かどうかを判定します。
     *
     * チェック状態を収集する `checkbox` / `radio`、ファイルを収集する `file`、値を配列
     * で収集する複数選択の `<select>` は、宣言した型へ正規化する対象になりません
     * （仕様「`data-value-type`」）。
     *
     * @param element 対象の要素
     * @returns 受け付ける場合は true
     */
    private static acceptsDeclaredValueType;
    /**
     * `data-value-type` の宣言を無視したことを開発モードで警告します。
     *
     * 値の読み取りごとに解決するため、同じ宣言では一度だけ報告します。
     *
     * @param element 宣言した要素
     * @param declared 宣言された値
     * @param reason 無視した理由
     * @returns 戻り値はありません。
     */
    private static warnValueTypeDeclaration;
    /**
     * `value` の宣言バインド（テンプレート式・`data-attr-value`）で DOM プロパティと
     * 内部値を同期する対象要素かどうかを判定します。
     *
     * `value` 属性の反映だけでは `element.value` や内部値（値収集や式評価が参照する値）が
     * 更新されないため、これらの要素では属性に加えてプロパティも揃えます。
     * `type="hidden"` は利用者が編集できず送信される値を持つため対象に含めます
     * （`INPUT_EVENT_TYPES` は `input` イベント発火の可否を決める別目的の一覧なので、
     * そちらへは追加しません）。checkbox / radio の `value` は送信値であってチェック
     * 状態ではないため対象外です（状態は `checked` の同期で扱います）。
     *
     * @param element 判定対象のエレメント
     * @returns 同期対象の場合true
     */
    static isValuePropertyTarget(element: Element): element is HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;
    /**
     * 利用者が打鍵で値を変えられる入力欄かどうかを判定します。
     *
     * `readonly` の欄は打鍵で値が変わらないため、宣言バインドの再適用から守るべき
     * 未コミットの入力を持ちません。それでいて `disabled` と違いタブ移動の対象には
     * なるため、フォーカスを保護の条件にすると「算出値を入れた欄がタブ移動の行き先に
     * なっただけで評価結果に追従しなくなる」ことになります。そこで `readonly` の欄は
     * 保護の対象外とします（仕様「`data-attr-*`」）。
     *
     * `<select>` に `readonly` はないため常に編集できる扱いです。`disabled` も対象に
     * しません。`disabled` の要素はフォーカスされないため保護に掛かる経路が無く、
     * 「編集した欄を送信中だけ `disabled` にする」使い方で入力を評価結果へ巻き戻して
     * しまう恐れがあるためです。
     *
     * @param element 判定対象のエレメント
     * @returns 利用者が打鍵で値を変えられる場合 true
     */
    private static isUserEditableValue;
    /**
     * 内部の値をDOMの値と同期します。
     * changeイベント時など、DOM値が変更された後に呼び出されます。
     */
    syncValue(): void;
    /**
     * DOM の状態から、内部値として保持すべき値を読み取ります。
     *
     * 内部状態は変更しません。`syncValue()`（DOM → 内部値の取り込み）と、値収集で
     * DOM を真として読む経路（`getValueForCollection()`）の双方から使います。
     *
     * @returns DOM から読み取った値。値を持たない要素では現在の内部値
     */
    private readValueFromDom;
    /**
     * 直近の値の書き込みが DOM に載ったかを記録します。
     *
     * 「載らなかった」と記録するのは、内部値が空でない場合だけです。DOM が受け付け
     * なかった結果として双方が空になる場合（`type="number"` へ数値化できない値を
     * 書いた場合など）は、DOM が内部値を表現できているため取り込みを妨げません。
     *
     * @param applied 書き込んだ値が DOM に載った場合 true
     * @returns 戻り値はありません。
     */
    private recordValueWriteResult;
    /**
     * 値収集で使う値を返します。
     *
     * 外部ライブラリ（住所補完・select 拡張など）やブラウザの自動入力は
     * `element.value` へ直接代入するため、`change` / `input` が発火せず内部値が
     * 更新されません。収集が内部値だけを見ると、画面に表示されている値が送信・保存
     * されないまま欠落します。チェック状態（checkbox / radio）と `input[type=file]`
     * がすでに DOM を真として収集しているのと扱いを揃え、値も画面の見たままを
     * 収集できるようにします。
     *
     * ただし次の場合は DOM を読まず内部値を返します。DOM が内部値より古い、または
     * 内部値を表現できない状態で読むと、供給された値を失うためです。
     *
     * - Haori 自身の書き込みが描画キュー待ちの間（`skipChangeValue`）
     * - 直近の書き込みを DOM が受け付けなかった場合（`valueWriteUnapplied`）
     *
     * 内部値は**更新しません**。収集は読み取りであり、ここで内部値を書き換えると
     * 「バインドデータには載っていないのに内部値だけが新しい」状態が生まれ、次の
     * 逆方向同期（`Form.syncValues`）が古いバインドデータで入力欄を上書きして値を
     * 失います（`data-validity` の条件評価のように、バインドへ反映しない収集が
     * あるため）。DOM の値がバインドデータへ載るのは収集結果を通じてだけです。
     *
     * @returns 収集する値
     */
    getValueForCollection(): string | number | boolean | string[] | null;
    /**
     * チェック状態の DOM 反映に合わせて内部値を DOM から同期します。
     *
     * `checked` を反映した場合は自身の内部値を、`option` の `selected` を反映した
     * 場合は所属する `<select>` の内部値を同期します（option 自身は値収集の対象では
     * なく、選択によって変化するのは select の値のため）。
     *
     * @param forSelectedOption `option` の `selected` を反映した場合に true
     */
    private syncCheckableValueFromDom;
    /**
     * 指定した属性のいずれかを自身が書き込み中なら、その完了 Promise を返します。
     *
     * @param names 対象の属性名
     * @returns 書き込み中ならその完了 Promise。書き込み中でなければ null
     */
    private getSelfWritingAttribute;
    /**
     * 指定した属性を「自身が書き込み中」として記録します。
     *
     * @param names 対象の属性名
     * @param write 書き込みの完了 Promise（解放まで含めて完了するもの）
     */
    private holdSelfWritingAttributes;
    /**
     * 「自身が書き込み中」の記録を外します。
     *
     * @param names 対象の属性名
     */
    private releaseSelfWritingAttributes;
    /**
     * 属性の値を評価して設定します。
     * 評価値がfalseの場合は属性を削除します。
     * 矯正評価属性の場合は元の値を設定します。
     *
     * @param name 属性名
     * @param value 属性値
     * @returns 属性の更新のPromise
     */
    setAttribute(name: string, value: string | null, fromObserver?: boolean): Promise<void>;
    /**
     * data-attr-* の生値を保持しつつ、別名の属性へ評価結果を反映します。
     *
     * @param rawName 生の属性名
     * @param targetName 反映先の属性名
     * @param value 生の属性値
     * @param fromObserver MutationObserver 経由の書き戻しかどうか
     * @returns 属性更新の Promise
     */
    setAliasedAttribute(rawName: string, targetName: string, value: string | null, fromObserver?: boolean): Promise<void>;
    /**
     * data-attr-* の生属性と反映先属性を同時に削除します。
     *
     * DOM に残っている属性だけを削除対象にします。すでに無い属性はキューへ積まず、
     * 内部の属性マップの更新だけを行います（後続の書き込みを消さないため）。
     *
     * @param rawName 生の属性名
     * @param targetName 反映先の属性名
     * @returns 属性削除の Promise
     */
    removeAliasedAttribute(rawName: string, targetName: string): Promise<void>;
    /**
     * 生の属性値を保持しつつ、必要に応じて別名属性へ評価結果を反映します。
     *
     * @param rawName 生の属性名
     * @param targetName 反映先の属性名
     * @param value 生の属性値
     * @param syncValueProperty value 属性更新時に DOM property も同期するかどうか
     * @param fromObserver MutationObserver 経由の書き戻しかどうか
     * @returns 属性更新の Promise
     */
    private setAttributeInternal;
    /**
     * 属性の値を削除します。
     *
     * DOM に属性が無い場合はキューへ削除タスクを積まず、内部の属性マップの更新だけを
     * 行います。キュー待ちの削除が、その間に他の経路（優先実行の直接書き込みなど）で
     * 書き込まれた値を消してしまうのを防ぐためです。
     *
     * @param name 属性名
     * @returns 属性の削除のPromise
     */
    removeAttribute(name: string): Promise<void>;
    /**
     * 属性の評価された値を取得します。
     * 複数の評価値がある場合は結合して返します。
     *
     * @param name 属性名
     * @returns 評価された値
     */
    getAttribute(name: string): string | false | unknown | null;
    /**
     * 属性の評価値と未解決参照の有無を取得します。
     *
     * @param name 属性名
     * @returns 属性評価の詳細。属性が存在しない場合は null
     */
    getAttributeEvaluation(name: string): AttributeEvaluationDetail | null;
    /**
     * 属性の生の値を取得します。
     *
     * @param name 属性名
     * @returns 生の属性値
     */
    getRawAttribute(name: string): string | null;
    /**
     * 属性名のリストを取得します。
     *
     * @return 属性名のリスト
     */
    getAttributeNames(): string[];
    /**
     * 属性の有無を確認します。
     *
     * @param name 属性名
     * @returns 属性の有無
     */
    hasAttribute(name: string): boolean;
    /**
     * DOM上の順序から、参照フラグメントに対応する children 配列の挿入位置を推定します。
     *
     * @param referenceChild 参照フラグメント
     * @param insertAfter 参照位置の後ろに挿入するかどうか
     * @returns 挿入位置。解決できない場合はnull
     */
    private resolveInsertionPointFromDom;
    /**
     * 子ノードを参照ノードの前に挿入します。
     * 参照ノードがnullの場合、親の最後に追加されます。
     *
     * @param newChild 新しい子ノード
     * @param referenceChild 参照ノード
     * @return 挿入のPromise
     */
    insertBefore(newChild: Fragment, referenceChild: Fragment | null, referenceNodeOverride?: Node | null): Promise<void>;
    /**
     * 指定した参照ノードの後に子ノードを挿入します。
     *
     * @param newChild 子ノード
     * @param referenceChild 参照ノード
     * @returns 挿入のPromise
     */
    insertAfter(newChild: Fragment, referenceChild: Fragment | null): Promise<void>;
    /**
     * 前のエレメントフラグメントを取得します。
     * 存在しない場合はnullを返します。
     *
     * @return 前のエレメントフラグメントまたはnull
     */
    getPrevious(): ElementFragment | null;
    /**
     * 次のエレメントフラグメントを取得します。
     * 存在しない場合はnullを返します。
     *
     * @return 次のエレメントフラグメントまたはnull
     */
    getNext(): ElementFragment | null;
    /**
     * 表示状態を返します。
     *
     * @returns 表示状態
     */
    isVisible(): boolean;
    /**
     * 宣言の `display` を控えて、非表示の追随結果を書きます。
     *
     * 非表示化の不変条件（控えを取る → `display: none !important` を書く）は、
     * ここ 1 か所に置きます。`hide()` と `style` の再適用の両方から呼ぶため、
     * 分けて持つと片方だけ直したときに食い違います（再適用側で控えを取り直して
     * いなかったのが課題 37 です）。表示中の要素には触りません（利用者の
     * `display` の宣言が権威です）。
     *
     * `style` 属性の再適用は属性ごと置き換わるため、書いた追随結果
     * （`display: none !important`）は宣言の内容にかかわらず捨てられます（空の
     * 宣言でも同じです）。内部状態が非表示のあいだは追随結果を宣言より優先する
     * ため、書き直します。
     *
     * 控え（`display` / `displayPriority`）は、書くたびに**そのときの宣言から
     * 取り直します**。`hide()` の時点で固定すると、非表示のあいだに宣言が変わって
     * も控えが古いまま残り、表示へ戻したときに宣言が失われます（初期走査で
     * `hide()` が宣言の書き込みより先に走る構成では、控えが空のままになります）。
     * `show()` が戻すべきは「隠す直前の宣言」ではなく「最新の宣言」です。呼び出し
     * 時点の DOM は宣言をそのまま書いた直後なので、読み取る値は宣言の内容です。
     *
     * 対になる `hideDisplayWithoutCapture()` は、DOM にあるのが宣言でない場合
     * （外部のスクリプトによる書き換え）に使います。2 つの違いは控えを取るかどうかで、
     * 「DOM にいま入っている値が宣言かどうか」で選びます。
     *
     * @returns 戻り値はありません。
     */
    private captureAndHideDisplay;
    /**
     * 外部が書き換えた `display` を、非表示の追随結果へ戻します。
     *
     * DOM の監視は、非表示のあいだの `style` を宣言として取り込みません（取り込むと
     * `display: none` が宣言として焼き付き、表示へ戻した分岐を引き戻します）。ただし
     * 取り込まないだけでは、外部のスクリプトが `display` を直接書き換えたときに
     * `data-if-false` が付いたまま要素が見えてしまいます。判定の基準は内部状態なので、
     * 追随結果を書き直します（仕様「data-if の動作」の「非表示のあいだに外部から
     * `style.display` を書き換えた場合は、追随結果を書き直して非表示へ戻します」）。
     *
     * 控え（`display` / `displayPriority`）は**取り直しません**。外部の書き換えは宣言
     * ではないため、取り直すと表示へ戻したときに宣言でない値が復元されます。
     *
     * すでに追随結果どおりなら何もしません。エンジン自身の書き込みもこの監視に乗る
     * ため、無条件に書くと書き込みが次の監視を呼ぶ繰り返しになります（この判定を
     * 外して測ると、テストが完走しなくなります）。
     *
     * @returns 戻り値はありません。
     */
    private hideDisplayWithoutCapture;
    /**
     * 要素の非表示の追随結果を書き直します。
     *
     * 監視側から呼びます。内部状態を持たない要素や表示中の要素では何もしません。
     *
     * @param target 対象エレメント
     * @returns 戻り値はありません。
     */
    static reassertHiddenDisplay(target: HTMLElement): void;
    /**
     * エレメントを非表示にします。
     *
     * @returns エレメントの非表示のPromise
     */
    hide(): Promise<void>;
    /**
     * 分岐配下のフォームコントロールを順に処理します。
     *
     * 入れ子の `data-if` が偽の分岐には踏み込みません。その分岐の入力は、内側の
     * `hide()` / `show()` が管理します（外側の表示で一括復帰させると、内側が偽の
     * ままでも `disabled` が外れてしまいます）。
     *
     * @param root 分岐の根要素
     * @param visit 各フォームコントロールへの処理
     * @returns 戻り値はありません。
     */
    private static forEachFormControlInBranch;
    /**
     * 非表示分岐配下のフォームコントロールを検証対象から外します。
     *
     * すでに `disabled` が付いている要素（利用者が指定したもの、`data-attr-disabled`
     * の評価結果を含む）には印を付けません。表示へ戻すときに復帰させないためです。
     *
     * 逆に、非表示になった後でその `disabled` が外れた要素（クリック実行ロックの解除、
     * 外部管理 DOM の作り替えなど）は無効化されないまま残ります。`data-{event}-validate`
     * は走査側でも `data-if-false` 配下を除外するため影響しませんが、ネイティブの
     * `checkValidity()` では検証対象に戻ります。ボタンは制約検証の対象外のため、
     * 実際に問題になるのは非表示中に入力の `disabled` を外した場合に限られます。
     *
     * @param root 分岐の根要素
     * @returns 戻り値はありません。
     */
    private static disableFormControlsInBranch;
    /**
     * 非表示分岐で外した検証対象を復帰させます。
     *
     * `show()` から呼ぶほか、表示へ戻す評価が始まる前にも呼びます（`Core.evaluateIf`）。
     * 子の評価より後に復帰させると、`data-attr-disabled` の適用と競合します。
     * 印が無い要素には触れないため、何度呼んでも結果は変わりません。
     *
     * @returns 戻り値はありません。
     */
    restoreFormControlsDisabledByIf(): void;
    /**
     * エレメントを表示します。
     *
     * @return エレメントの表示のPromise
     */
    show(): Promise<void>;
    /**
     * 指定した属性名を持つ最も近い親要素を返します。
     * 見つからない場合はnullを返します。
     *
     * @param name 属性名
     * @returns 最も近い親要素またはnull
     */
    closestByAttribute(name: string): ElementFragment | null;
}

/**
 * 外部ライブラリ連携の適用を管理します。
 */
export declare class Enhance {
    /** 登録済みの連携（名前 → 定義） */
    private static readonly enhancers;
    /** 要素ごとの適用状況（要素 → キー → インスタンス） */
    private static readonly instances;
    /** 未登録の名前として警告済みの連携名 */
    private static readonly warnedUnknownNames;
    /** 解決できないグローバル参照として警告済みの値 */
    private static readonly warnedMissingGlobals;
    /**
     * Haori 自身の適用処理（`applySubtree()`）が通った要素。
     *
     * `register()` の遡りの適用は、この要素（適用を保留した要素）だけを対象にします。
     * まだ通っていない要素（`<body>` 内のスクリプトで登録した時点で、初期スキャンの
     * 前にある要素など）へその場で `init` を呼ぶと、描画前の DOM に対して走るうえ、
     * 連携が生成した DOM が走査でフラグメント木へ載り、`data-external` の配下でも
     * フォーム値の収集に載ります（仕様「`data-enhance`」、課題 #42）。
     *
     * 非表示の分岐（`data-if` が偽）の中の要素も、走査の最後にこの集合へ入りますが、
     * 描画と初期値の反映はまだ済んでいません。`applyElement()` が非表示の分岐の中では
     * 適用を止めるため、遡りの適用でも表示の前に `init` は呼ばれません（課題 55）。
     */
    private static readonly visited;
    /**
     * 連携の呼び出しを包み、呼び出しが起こした DOM 変更を取り込む処理。
     *
     * `Observer` が登録します（`Observer` を直接参照すると循環参照になるため、
     * フックとして受け取ります）。未登録の場合はそのまま呼び出します。
     */
    private static mutationCapture;
    /**
     * 外部ライブラリ連携を登録します。
     *
     * 適用を保留していた要素（Haori の適用処理が一度通った要素）へ遡って適用する
     * ため、スクリプトの読み込み順に依存しません（登録の時点で `document.body` 配下を
     * 走査します）。まだ Haori が走査していない要素には、走査の最後に適用します。
     *
     * @param name `data-enhance` に書く名前
     * @param enhancer 連携の定義
     * @returns 戻り値はありません。
     */
    static register(name: string, enhancer: Enhancer): void;
    /* Excluded from this release type: setMutationCapture */
    /**
     * 登録済みの連携かどうかを返します。
     *
     * @param name 連携名
     * @returns 登録済みなら true
     */
    static has(name: string): boolean;
    /**
     * 対象要素とその子孫へ、まだ適用していない連携を適用します。
     *
     * 初期スキャン・新規ノードの追加・`data-each` の新規行・`data-if` の表示から
     * 呼び出します。非表示の分岐の中の要素には適用しません（`applyElement()`）。
     *
     * @param root 走査の起点となる要素
     * @returns 戻り値はありません。
     */
    static applySubtree(root: HTMLElement): void;
    /**
     * 要素へ連携を適用済みかどうかを返します。
     *
     * @param element 対象要素
     * @returns 1 つでも適用済みの連携があれば true
     */
    static isApplied(element: HTMLElement): boolean;
    /**
     * 対象要素とその子孫の連携を再同期します。
     *
     * 適用済みの要素では `refresh` を呼びます。未適用の要素では、`applyPending` が
     * true なら `init` を呼びます（非表示の分岐の中は除きます）。`data-each` の描画
     * 確定、`data-if` の再表示、フォームのリセット、Haori が値を書いた入力欄の通知から
     * 呼び出します。
     *
     * @param root 走査の起点となる要素
     * @param applyPending 未適用の要素へ `init` を呼ぶかどうか
     * @returns 戻り値はありません。
     */
    static refreshSubtree(root: HTMLElement, applyPending?: boolean): void;
    /**
     * 対象要素とその子孫の連携を破棄します。
     *
     * 要素が DOM から外れるとき（`data-each` の行削除など）に呼び出します。
     *
     * @param root 走査の起点となる要素
     * @returns 戻り値はありません。
     */
    static destroySubtree(root: HTMLElement): void;
    /**
     * 走査対象（連携を宣言した要素）を列挙します。
     *
     * @param root 走査の起点となる要素
     * @param callback 各要素に対する処理
     * @returns 戻り値はありません。
     */
    private static forEachTarget;
    /**
     * 1 要素へ、まだ適用していない連携を適用します。
     *
     * @param element 対象要素
     * @returns 戻り値はありません。
     */
    private static applyElement;
    /**
     * 1 要素の連携を再同期します（`applyPending` が true なら、未適用の連携も適用します）。
     *
     * @param element 対象要素
     * @param applyPending 未適用の連携へ `init` を呼ぶかどうか
     * @returns 戻り値はありません。
     */
    private static refreshElement;
    /**
     * 1 要素の連携を破棄します。
     *
     * @param element 対象要素
     * @returns 戻り値はありません。
     */
    private static destroyElement;
    /**
     * 要素の適用状況を返します（無ければ作成します）。
     *
     * @param element 対象要素
     * @returns キー → インスタンスの対応
     */
    private static appliedKeys;
    /**
     * 空白区切りの属性値を名前の一覧へ分解します。
     *
     * @param element 対象要素
     * @param attributeName 属性名
     * @returns 名前の一覧（重複は除去）
     */
    private static names;
    /**
     * ドット区切りのグローバル参照を解決します。
     *
     * 値は識別子とドットだけを許します。式やコードは受け付けません（属性値をコード
     * として実行しないため）。
     *
     * @param reference `data-enhance-new` の値
     * @returns 解決した値。解決できない場合は null
     */
    private static resolveGlobal;
    /**
     * 未登録の連携名を開発モードで一度だけ警告します。
     *
     * @param name 連携名
     * @returns 戻り値はありません。
     */
    private static warnUnknownName;
    /**
     * 連携の呼び出しを例外から保護して実行します。
     *
     * 1 つの連携の失敗で他の要素の適用や描画を止めないため、例外は記録して続行します。
     * 取り込みの処理（`setMutationCapture()`）が登録されていれば、それで包んで呼び出します。
     *
     * @param label ログに出す処理名
     * @param callback 実行する処理
     * @returns 戻り値はありません。
     */
    private static run;
}

/**
 * @fileoverview 外部ライブラリ連携（`data-enhance` / `data-enhance-new`）
 *
 * DOM を走査して機能を付加する外部ライブラリ（Choices.js・YubinBango など）は、
 * `data-each` の行追加や `data-if` の再表示で DOM が入れ替わるたびに再適用が必要に
 * なります。適用対象・冪等性・インスタンスの保持を画面側の JavaScript に持たせずに
 * 済むよう、宣言で契機を与える仕組みです。
 *
 * - `data-enhance="名前"`: `Haori.enhancers.register()` で登録した連携を適用します。
 *   要素ごと・名前ごとに `init` は一度だけ実行し、以後の再描画では `refresh` を
 *   呼びます。要素が DOM から外れたときは `destroy` を呼びます。
 * - `data-enhance-new="Global.Ctor"`: 登録なしで、グローバル参照を `new` するだけの
 *   簡易形です。値はドット区切りのグローバル参照だけを許し、引数には対象要素を
 *   渡します。要素ごとに一度だけ実行します。
 */
/**
 * 外部ライブラリ連携の定義。
 *
 * `init` の戻り値はインスタンスとして保持し、`refresh` と `destroy` へ渡します。
 */
export declare interface Enhancer {
    /**
     * 対象要素へ外部ライブラリを適用します。
     *
     * @param element 対象要素
     * @returns 保持するインスタンス（不要なら戻り値なし）
     */
    init(element: HTMLElement): unknown;
    /**
     * 適用済みの要素を再同期します（`data-each` の再描画後など）。
     *
     * @param element 対象要素
     * @param instance `init` が返したインスタンス
     * @returns 戻り値はありません。
     */
    refresh?(element: HTMLElement, instance: unknown): void;
    /**
     * 要素が DOM から外れるときに後始末します。
     *
     * @param element 対象要素
     * @param instance `init` が返したインスタンス
     * @returns 戻り値はありません。
     */
    destroy?(element: HTMLElement, instance: unknown): void;
}

/**
 * 外部ライブラリ連携（`data-enhance`）の登録窓口です。
 *
 * iife グローバルからは `Haori.enhancers.register(名前, 定義)`、ESM では
 * `import {enhancers} from 'haori'` で利用できます。
 */
export declare const enhancers: {
    register(name: string, enhancer: Enhancer_2): void;
    has(name: string): boolean;
};

/**
 * 実行環境を管理するクラスです。
 */
export declare class Env {
    private static _prefix;
    private static _runtime;
    private static _strictBind;
    /**
     * 厳格バインドモードが有効かどうかを取得します。
     *
     * 有効な場合、バインドに無いキーの参照を検出した時点で `error` ログを出力します。
     * 無効（既定）の場合は正常系として扱い、開発モードで集約警告のみを出します。
     *
     * @returns 厳格バインドモードなら true。
     */
    static get strictBind(): boolean;
    /**
     * 厳格バインドモードを設定します。
     *
     * @param enabled 有効にする場合は true。
     * @return 戻り値はありません。
     */
    static setStrictBind(enabled: boolean): void;
    /**
     * 実行モードを取得します。
     *
     * @returns 実行モード。
     */
    static get runtime(): HaoriRuntime;
    /**
     * 実行モードを設定します。
     *
     * @param runtime 設定する実行モード。
     * @return 戻り値はありません。
     */
    static setRuntime(runtime: string): void;
    /**
     * 実行環境からプレフィックスと開発モードかどうかを自動検出します。
     * scriptタグにdata-prefixがある場合は、その値+"-"をプレフィックスとして使用します。
     * scriptタグにdata-dev属性がある場合、
     * もしくはローカルホスト系ドメインであれば開発モードを有効化します。
     */
    static detect(): void;
    /**
     * プレフィックスを取得します。
     *
     * @returns プレフィックス
     */
    static get prefix(): string;
}

/**
 * Formクラスは、フォームの双方向バインディングを提供します。
 * 入力要素の値をフォームにバインドし、フォームのバインド値を入力要素に反映します。
 */
export declare class Form {
    /**
     * 初期 `data-bind` からの入力欄復元を適用済みのフォーム要素。
     *
     * 復元は「そのフォームを初めてスキャンしたとき」の一度だけ行います。再スキャン
     * （`data-if` の表示切替など）で繰り返すと、利用者が編集した入力欄を初期値へ
     * 巻き戻してしまうためです。
     */
    private static readonly INITIAL_RESTORED_FORMS;
    /**
     * `data-form-arg` のキーを祖先から流し込んだ最後の内容（JSON 文字列）。
     *
     * 祖先のバインド更新は、当該キーの値が実際に変わったときだけ入力欄へ反映します。
     * 変わっていない更新（同じ祖先の別キーの更新など）でも反映すると、利用者が
     * 確定した編集を同じ値で上書きし直して巻き戻してしまうためです。
     */
    private static readonly LAST_ANCESTOR_ARG_VALUES;
    /**
     * フォーム内にある入力エレメントの値をオブジェクトとして取得します。
     * data-form-object属性があると、そのエレメント内の値はオブジェクトとして処理されます。
     * 入力エレメントにdata-form-list属性があると、そのエレメントの値はリストとして処理されます。
     * 入力エレメント以外にdata-form-list属性があると、そのエレメントの値はオブジェクトのリストとして処理されます。
     *
     * @param form フォームのElementFragment
     */
    static getValues(form: ElementFragment): Record<string, unknown>;
    /**
     * 入力エレメントから収集する値を解決します。
     *
     * `input[type=file]` は選択されたファイルを File オブジェクトとして返します
     * （内部値は `C:\fakepath\...` の擬似パス文字列にしかならず送信に使えないため、
     * DOM の `files` から直接取得する）。`multiple` 指定時は File の配列、単一選択時は
     * File または未選択を表す null を返します。それ以外の要素は内部値を返します。
     *
     * 値を持つ入力（テキスト系 input / `type="hidden"` / textarea / select）は DOM の値を
     * 読んで返します（`ElementFragment.getValueForCollection()`）。外部ライブラリや
     * ブラウザの自動入力はイベントを伴わずに `element.value` へ代入するため、内部値
     * だけを見ると画面に見えている値が収集から欠落します。収集は読み取りに徹し、
     * 内部値は書き換えません（理由は同メソッドのコメントを参照）。
     *
     * @param fragment 対象のElementFragment
     * @returns 収集する値
     */
    private static resolveCollectedValue;
    /**
     * boolean 値として扱うチェックボックスかどうかを判定します。
     *
     * `value="true"` は「チェック時に `true`」、`value="false"` は「チェック時に
     * `false`」を表す単一の真偽値入力で、同名グループとしては扱いません。
     *
     * @param fragment 対象フラグメント
     * @returns boolean チェックボックスの場合 true
     */
    private static isBooleanCheckbox;
    /** ラジオグループのスコープへ割り当てた識別番号 */
    private static readonly GROUP_SCOPE_IDS;
    /** ラジオグループのスコープ識別番号の連番 */
    private static groupScopeSequence;
    /**
     * 入力要素の収集キーを解決します。
     *
     * `data-form-name` があればそれを収集キーとし、無ければ `name` 属性を使います。
     * ラジオボタンのように DOM の `name` がグループ化の意味を持つ場合に、収集キーと
     * DOM の `name` を分けるために使います。
     *
     * @param fragment 対象フラグメント
     * @returns 収集キー。どちらも無い場合は null
     */
    static resolveFieldName(fragment: ElementFragment): unknown;
    /**
     * 行の入力欄のうち、新しい要素データと値が食い違う収集キーに属するものだけ、
     * ユーザー編集の印を解除します。
     *
     * 行への `data-{event}-copy` で使います。コピーが優先するのは**コピーしたキー**
     * なので（仕様「編集可能な行への書き込み」）、行の印を丸ごと解除すると、コピー
     * していないキーの編集まで宣言バインドの評価結果へ明け渡してしまいます。評価が
     * 要素データと食い違う構成（数値の `id` と文字列の収集値を厳密比較する
     * `data-attr-selected` など）では、その欄の確定した編集が静かに消えます。
     *
     * 判定は**行の収集値と新しい要素データの突き合わせ**で行います。コピーしたキーは
     * 値が変わるため食い違い、コピーしていないキーは編集がすでに要素データへ確定して
     * いるため一致します。要素データが変わらない書き戻し（入力欄の状態が要素データへ
     * 確定していない構成）でも、画面と食い違うキーだけが対象になります。
     *
     * @param row 行のフラグメント
     * @param item 新しい要素データ
     * @returns 戻り値はありません。
     */
    static clearRowUserEditMarksForChangedKeys(row: ElementFragment, item: Record<string, unknown>): void;
    /**
     * 収集値と要素データの値が同じ内容かどうかを判定します。
     *
     * 直列化できない値（循環参照など）は「違う」と扱います。
     *
     * @param left 比較元の値
     * @param right 比較先の値
     * @returns 同じ内容なら true
     */
    private static isSameCollectedValue;
    /**
     * 指定した収集キーに属する部分木のユーザー編集の印を解除します。
     *
     * @param fragment 走査中のフラグメント
     * @param row 行のフラグメント（収集キーの起点）
     * @param keys 対象の収集キー
     * @returns 戻り値はありません。
     */
    private static clearUserEditMarksForKeys;
    /**
     * 行の中の要素が属する、収集値の**最上位**キーを返します。
     *
     * 行から要素までの間にある `data-form-object` / `data-form-list` と `name`
     * （`data-form-name`）のうち、行に最も近いものが最上位キーです。
     *
     * @param fragment 対象フラグメント
     * @param row 行のフラグメント
     * @returns 最上位の収集キー。無い場合は null
     */
    private static resolveRowTopLevelKey;
    /**
     * `data-form-name` の初期化を行います。
     *
     * 収集キーが空になる指定を開発モードで警告し、ラジオボタンにはグループ用の
     * DOM `name` を生成します。
     *
     * HTML のラジオグループは「同じフォームオーナー内の同名要素」で構成されるため、
     * `data-form-list` の行内で同じ `name` を使うと行をまたいで排他になり、1 行しか
     * 選択を保持できません。収集キーを `data-form-name` で宣言した場合は、DOM の
     * `name` を行ごとにユニークな値へ生成してグループを行単位に分けます。
     *
     * 作者が `name` を書いている場合は尊重して生成しません（行をまたぐグループを
     * 意図している場合があるため）。自動生成した `name` は内部マーカーで区別し、
     * 行の複製で引き継がれたものは作り直します。
     *
     * 処理が不要な場合は Promise を返しません。要素初期化の共通経路から呼ばれるため、
     * 対象外の要素で Promise を挟むと初期化の非同期段数が全要素で増えてしまいます。
     *
     * @param fragment 対象フラグメント
     * @returns 属性設定の Promise。処理が不要な場合は undefined
     */
    static prepareFormName(fragment: ElementFragment): Promise<void> | void;
    /**
     * ラジオグループのスコープとなるフラグメントを解決します。
     *
     * `data-form-list` のコンテナ直下の要素（= 行）が祖先にあればその行を、無ければ
     * 最近傍のフォーム（`<form>` または `data-form`）をスコープとします。行の外では
     * 通常の HTML と同じくフォーム単位のグループになります。
     *
     * @param fragment 対象フラグメント
     * @returns スコープとなるフラグメント
     */
    private static resolveGroupScope;
    /**
     * ラジオグループのスコープへ識別番号を割り当てます。
     *
     * @param scope スコープとなるフラグメント
     * @returns スコープの識別番号
     */
    private static resolveGroupScopeId;
    /**
     * 宣言バインドで値・状態が決まり、その評価が解決している入力かどうかを判定します。
     *
     * `data-each` の行へ値を反映するとき、この判定が真の入力は行データで上書きしま
     * せん。上書きすると、直前の再評価で入れた値を収集値（多くは空文字）で潰し、その
     * 空値が次の収集で行データへ焼き付いて以後ずっと空になります（行の中で候補から
     * 選択中の 1 件を引いて hidden へ載せる構成が該当します）。
     *
     * 評価が未解決のときは偽を返し、従来どおり行データを反映します。保存済みレコード
     * からの復元では、候補が届くまで式が解決しないため、ここで宣言バインドを権威に
     * すると復元した値を失います。
     *
     * @param fragment 対象フラグメント
     * @returns 宣言バインドで値・状態が決まり、その評価が解決している場合 true
     */
    private static hasResolvedDeclarativeState;
    /**
     * 宣言バインドの評価が解決しているかどうかを判定します。
     *
     * `data-attr-{name}` と `{name}="{{式}}"` のどちらの書き方でも、実際に評価して
     * 未解決参照が無いことを確認します。
     *
     * @param fragment 対象フラグメント
     * @param name 判定する属性名（`value` / `checked` / `selected`）
     * @returns 未解決参照が無い場合 true
     */
    private static isDeclarationResolved;
    /**
     * 値または状態が宣言バインドで決まる入力かどうかを判定します。
     *
     * 属性にテンプレート式を書いた場合、または対応する `data-attr-*` を持つ場合は、
     * その値・状態の権威はバインドの評価結果にあります。値収集側から空で上書きして
     * はいけません。
     *
     * 判定する属性は要素の種類で変わります。checkbox / radio の `value` は送信値で
     * あってチェック状態ではないため、`value` ではなく `checked` を見ます（`value` で
     * 判定すると、送信値をテンプレート式で決めているだけのチェックボックスが解除
     * されなくなり、前の行のチェック状態が残る）。`<select>` は自身の `value` に加えて、
     * 配下の `<option>` が `selected` を宣言している場合も対象とします。
     *
     * @param fragment 対象フラグメント
     * @returns 宣言バインドで値または状態が決まる場合 true
     */
    private static isDeclarativeStateBound;
    /**
     * 対象の部分木にある入力欄を、ネイティブのフォームリセットと同じ既定値へ戻します。
     *
     * `<form>` でない要素を初期化する場合に使います。`form.reset()` は「フォームに属する
     * 入力欄」しか戻せないため、以前は対象の要素を一時的な `<form>` へ移して呼び出して
     * いましたが、**要素を DOM から外すとフラグメントと実行時のバインドデータが破棄され**、
     * 同じ操作の後段の書き込みが空のバインドデータを土台にしてしまいます
     * （`data-fetch-bind` で寄せたキーが消える。仕様「`data-{event}-reset`」）。
     * そこで DOM の構造は変えず、HTML 仕様のリセットアルゴリズムと同じ既定値
     * （`defaultValue` / `defaultChecked` / `defaultSelected`）へ戻します。
     *
     * @param root 対象の要素（自身と配下すべてが対象）
     * @return 戻り値はありません。
     */
    private static restoreDefaultValues;
    /**
     * `<select>` の選択状態を既定の選択（`defaultSelected`）へ戻します。
     *
     * 既定の選択が無い単一選択では、ブラウザのリセットと同じく先頭の選択できる
     * `<option>` を選びます（HTML 仕様のリセットアルゴリズム）。
     *
     * @param select 対象の select エレメント
     * @return 戻り値はありません。
     */
    private static restoreDefaultSelection;
    /**
     * 宣言バインドで値・状態が決まる入力について、DOM 側の値を空へ揃えます。
     *
     * `Form.reset()` から `form.reset()` の直後に呼び出します。評価結果の入れ直しは
     * 呼び出し元の再評価（`Core.evaluateAll`）が行うため、ここでは空へ揃えるだけです。
     *
     * @param fragment 対象フラグメント（配下すべてが対象）
     * @return 戻り値はありません。
     */
    private static clearDeclarativeStateFromDom;
    /**
     * 指定した属性が宣言バインド（テンプレート式または `data-attr-*`）かどうかを
     * 判定します。
     *
     * @param fragment 対象フラグメント
     * @param name 属性名
     * @returns 宣言バインドの場合 true
     */
    private static hasDeclarativeBinding;
    /**
     * `<select>` 配下の `<option>` が選択状態を宣言バインドしているかどうかを
     * 判定します。
     *
     * `name` を持つ select の選択状態を `data-attr-selected` などで宣言している場合、
     * 選択の権威は option 側の式にあります。
     *
     * @param element 対象の select エレメント
     * @returns いずれかの option が selected を宣言している場合 true
     */
    private static hasDeclarativeSelectedOption;
    /**
     * `input[type=file]` かどうかを判定します。
     *
     * @param fragment 対象フラグメント
     * @returns `input[type=file]` の場合 true
     */
    private static isFileInput;
    /**
     * 指定した基準より後にユーザーが編集した入力欄の値だけを収集します。
     *
     * 収集結果は `getValues()` と同じ入れ子構造になりますが、編集されていない
     * 入力欄のキーは含みません。`data-form-list` の行は位置がずれないよう、編集の
     * 無い行も空オブジェクトで場所を確保します。
     *
     * 飛行中の通信の応答をバインドする直前に、その通信を開始した後の編集だけを
     * 上書きし直す用途で使います。`data-poll` の応答では、利用者が要求していない
     * 自動取得なので基準に 0 を渡し、これまでの編集すべてを対象にします。
     *
     * @param fragment 対象のElementFragment
     * @param baseline ユーザー編集の通し番号の基準（これより大きいものが対象）
     * @returns 編集された入力欄だけを含む値のオブジェクト
     */
    static getValuesEditedAfter(fragment: ElementFragment, baseline: number): Record<string, unknown>;
    /**
     * 利用者が編集した入力欄に対応するバインドデータの経路を集めます。
     *
     * 双方向コミットはフォーム全体の収集値を運ぶため、更新全体を「編集」として扱うと
     * 未編集の欄まで編集の権威を得てしまいます。編集された経路だけを示すために使います
     * （`ValueChangeOrigin.editedPaths`）。
     *
     * `data-if` が偽の分岐で収集から**除外された**キーの経路も含めます。除外は
     * 「その入力欄がフォームから外れた」ことを意味するため、以前その欄で行われた編集が
     * その経路の権威を持ち続けてはいけません。含めないと、非供給更新は「編集が確定した
     * 宛先へは適用しない」規則（仕様「ユーザー編集と宣言バインドの権威」）で棄却され、
     * 除外したキーが土台の値のまま
     * 残ります（表示条件から外れた項目が保存値・送信データに残る）。除外を引き起こした
     * のは利用者の編集（分岐の条件を変える操作）そのものです。
     *
     * 配列（`data-form-list` の行）は対象外です。行と配列要素の対応はリストキーで
     * 決まり、収集値からは同じ規則で経路を組み立てられません。行の編集は応答の反映側
     * （`Procedure` の `reconcileRowUserEdits()`）で保護します。
     *
     * 経路には**その編集が起きた時点**の通番を持たせます。コミットの通番で主張すると、
     * 編集の後・コミットの前に要求された供給（`data-{event}-reset` など）が「編集の方が
     * 新しい」と判定されて棄却されます（`ValueChangeOrigin.editedPaths`）。
     *
     * 走査は「編集の通番の種類数」だけ繰り返します（＝編集された欄の数が上限）。経路の
     * 組み立ては収集値の形に合わせる必要があり、収集は基準の通番で絞り込めるためこの形
     * にしています。呼び出しは `change` / `input` の確定ごとで、走査 1 回はフォーム配下の
     * 走査に相当します。
     *
     * @param form 対象のフォームフラグメント
     * @param updateSequence この更新（双方向コミット）の通番。編集そのものではなく
     *     「この更新が引き起こした」経路（非表示分岐で除外されたキー）に使います
     * @param prefix 経路の接頭辞（`data-form-arg` のキーなど。無い場合は空文字）
     * @param collected この更新が運ぶ収集値。除外されたキーの判定に使います。
     *     **重ね合わせへ渡すものと同じオブジェクトを渡してください**（明示的に与えた
     *     値が収集値へ重なっている場合、そのキーは除外の対象外になります）。省略時は
     *     ここで収集し直します
     * @returns 編集された経路と、その編集が起きた時点の通番
     */
    static collectEditedPaths(form: ElementFragment, updateSequence: number, prefix?: string, collected?: Record<string, unknown> | null): ReadonlyMap<string, number>;
    /**
     * 部分木の入力欄が持つユーザー編集の通番を、大きい順の重複なしで返します。
     *
     * @param fragment 対象フラグメント（配下も辿る）
     * @returns 編集の通番の配列（降順）
     */
    private static collectUserEditSequences;
    /**
     * 部分木をたどってユーザー編集の通番を集めます。
     *
     * @param fragment 対象フラグメント
     * @param sequences 集める先
     * @returns 戻り値はありません。
     */
    private static walkUserEditSequences;
    /**
     * 収集値をたどって、除外されたキーの経路を集めます。
     *
     * 除外は階層ごとに控えてあります（`COLLECTED_EXCLUDED_KEYS`）。表示中の分岐にも
     * 同じキーがある場合は収集値に現れるため、経路には加えません。
     *
     * @param value たどる値
     * @param path ここまでの経路
     * @param paths 集める先
     */
    private static walkExcludedPaths;
    /**
     * 収集した編集値をたどって葉の経路を集めます。
     *
     * @param value たどる値
     * @param path ここまでの経路
     * @param paths 集める先
     */
    private static walkEditedPaths;
    /**
     * `Form.reset()` が起こしたネイティブのリセットかどうかの印。
     *
     * `data-{event}-reset` は内部で `form.reset()` を呼ぶため、ネイティブの
     * `reset` を監視する側と両方が再同期すると 2 度呼ばれます。こちらの経路では
     * すべての段が終わった時点で `Form.reset()` が呼ぶため、監視側は見送ります。
     */
    private static internalResetDepth;
    /**
     * `Form.reset()` が起こしたリセットの最中かどうかを返します。
     *
     * @returns 最中なら true
     */
    static isResettingInternally(): boolean;
    /**
     * フォーム内の各入力エレメントから値を取得し、オブジェクトとして返します。
     * 入力エレメントのname属性、data-form-object属性、data-form-list属性に基づいて値を整理します。
     *
     * @param fragment 対象のElementFragment
     * @param values オブジェクトに追加する値のオブジェクト
     * @param minUserEditSequence 指定した場合、この通し番号より後にユーザーが編集した
     *     入力欄だけを収集する（`data-form-list` の行位置は空オブジェクトで保持する）
     * @param excluded この階層で `data-if-false` により除外されたキーを集める先。
     *     null の場合は集めない（編集分だけの収集では使わない）
     * @returns values と同じオブジェクト
     */
    private static getPartValues;
    /**
     * フォーム内にある入力エレメントに値を設定します。
     * フォームのdata-bind属性に値が反映されます。
     *
     * @param form フォームのElementFragment
     * @param values フォームに設定する値のオブジェクト
     * @param force data-form-detach属性があるエレメントにも値を反映するかどうか
     * @returns Promise（DOMの更新が完了したら解決される）
     */
    static setValues(form: ElementFragment, values: Record<string, unknown>, force?: boolean): Promise<void>;
    /**
     * フォーム内にある入力エレメントに値をイベントなしで設定します。
     * フォーム bindingData からの内部同期に利用します。
     *
     * @param form フォームのElementFragment
     * @param values フォームに設定する値のオブジェクト
     * @param force data-form-detach属性があるエレメントにも値を反映するかどうか
     * @param origin 値の由来（通番と種別）。渡すと入力欄ごとに適用可否を判定します
     * @returns Promise（DOMの更新が完了したら解決される）
     */
    static syncValues(form: ElementFragment, values: Record<string, unknown>, force?: boolean, origin?: ValueChangeOrigin | null): Promise<void>;
    /**
     * `data-form-list` の 1 行分の入力欄へ、その行の値をイベントなしで反映します。
     *
     * `data-each` が新しく生成した行に対して呼び出します。フォーム全体への逆方向同期
     * （`syncValues()`）は `Core.setBindingData()` の中で `data-each` の行生成より**前**に
     * 走るため、その更新で生成された行には値が入りません。行単位でここを補います。
     *
     * @param row 行のElementFragment
     * @param values 行に設定する値のオブジェクト
     * @param origin 値の由来（通番と種別）。渡すと入力欄ごとに適用可否を判定します
     * @returns 反映完了の Promise
     */
    static syncRowValues(row: ElementFragment, values: Record<string, unknown>, origin?: ValueChangeOrigin | null): Promise<void>;
    /**
     * バインディングデータから、入力欄へ書き戻す対象の値を切り出します。
     *
     * `data-form-arg` が指定されている場合はそのキー配下だけを対象とし、キーが
     * オブジェクトでなければ空オブジェクトを返します（フォーム外のキーを入力欄へ
     * 書き戻さないため）。指定が無ければバインディングデータ全体が対象です。
     *
     * フォーム自身が当該キーを持たない場合は、祖先の `data-bind` が所有する同名の
     * キーへフォールバックします（`resolveAncestorArgOwner()` を参照）。祖先が
     * レコードを所有し、フォームがそのキーを編集する構成を成立させるためです。
     *
     * @param form フォームのElementFragment
     * @param data 対象のバインディングデータ
     * @returns 入力欄へ書き戻す値
     */
    static resolveSyncValues(form: ElementFragment, data: Record<string, unknown>): Record<string, unknown>;
    /**
     * キーを所有する祖先を、値の型を問わず解決します。
     *
     * 対象はフォームより外側の要素の**生バインドデータ**（`data-bind` で宣言・更新
     * された値）だけです。`data-derive` の派生データと `data-each` の行データは対象外
     * とします。どちらも描画のたびに作り直される仮想スコープで、行単位の書き戻しは
     * `data-form-list` が担うため、ここで扱うと反映が行生成と競合します。
     *
     * 最も近い所有者だけを見ます。所有者が `data-each` の行である場合は、より外側は
     * 探しません（近い方が権威というシャドーの規則に従うため）。
     *
     * 値の型を問わないのは、収集キーの土台を解決する用途があるためです
     * （仕様「祖先が所有する値の反映（`data-form-arg` なし）」の「土台に使う値の型は
     * 問いません」）。`data-form-list` の収集キーは配列になるので、レコード限定に
     * すると土台が解決できません。`data-form-arg` のキーはレコードに限るため、
     * そちらは `resolveAncestorArgOwner()` が絞り込みます。
     *
     * @param form フォームのElementFragment
     * @param key キー名
     * @returns 所有する祖先フラグメントとその値。見つからない場合は null
     */
    private static resolveAncestorKeyOwner;
    /**
     * `data-form-arg` のキーを所有する祖先を解決します。
     *
     * `data-form-arg` はフォームの入力欄が**そのキーの配下**に対応することを宣言する
     * ため、値はレコードに限ります。レコードでない値を所有している場合は所有者なしと
     * して扱い、開発モードで警告します。黙って退くと収集値がそのままそのキーへ入り、
     * 配列を宣言していた場合は**型がオブジェクトへ変わります**（一覧を描く式が壊れる）。
     *
     * @param form フォームのElementFragment
     * @param key `data-form-arg` で指定されたキー名
     * @returns 所有する祖先フラグメントとその値。見つからない場合は null
     */
    static resolveAncestorArgOwner(form: ElementFragment, key: string): {
        owner: ElementFragment;
        value: Record<string, unknown>;
    } | null;
    /**
     * 収集キーの土台を祖先から解決する関数を返します。
     *
     * `data-form-arg` を宣言しないフォームでも、収集キーを祖先が所有する構成では
     * その値が土台になります（仕様「祖先が所有する値の反映（`data-form-arg` なし）」の
     * 「コミット時は**収集したキーごとに、最も近い所有者の値を土台に収集値を
     * 重ねます**」）。`Form.mergeCollectedValues()` へ渡して使います。
     *
     * @param form フォームのElementFragment
     * @returns キーを受け取り、祖先が所有する値を返す関数（所有者が無ければ undefined）
     */
    static ancestorBaseResolver(form: ElementFragment): (key: string) => unknown;
    /**
     * `data-form-arg` のキーをレコード以外で所有している構成を、開発モードで知らせます。
     *
     * @param form フォームのElementFragment
     * @param key `data-form-arg` で指定されたキー名
     * @param value 祖先が所有している値
     */
    private static warnArgOwnerIsNotRecord;
    /**
     * `data-form-arg` の所有者がレコードでないことを警告済みのキー。
     *
     * 同じ構成で毎回の収集ごとに警告しないよう、要素とキーの組で控えます。
     */
    private static readonly warnedArgOwnerNotRecord;
    /**
     * 条件式（`data-validity` / `data-{event}-if`）の評価スコープを作ります。
     *
     * バインディングデータ（継承込み）を土台に、フォーム内で**宣言されている**収集
     * キーを収集値で置き換えます。クリック時点で最新なのは収集値だけです（属性の
     * 再描画は `requestAnimationFrame`、バインドデータへのコミットは非同期）。
     * 収集値に無いキーは未定義にします。土台の値を残すと、`data-if` で非表示に
     * なった入力欄の古い値で条件が誤判定されます。
     *
     * @param fragment 条件を宣言した要素のフラグメント
     * @param sourceOverride 収集値の取得元（`data-{event}-form` の指定など）。
     *     省略時は `data-form-list` の行、またはフォームコンテナから解決する
     * @returns 条件式の評価スコープ
     */
    static buildConditionScope(fragment: ElementFragment, sourceOverride?: ElementFragment | null): Record<string, unknown>;
    /**
     * 条件式で使う収集値の取得元を解決します。
     *
     * `data-form-list` の行の中では、その行の収集値が要素データに対応します。それ以外
     * はフォームコンテナ（`<form>` または `data-form`）を使います。`data-form-list` を
     * 伴わない `data-each` の行では入力欄と要素データが対応しないため、行を取得元には
     * しません（フォームコンテナへ遡ります）。
     *
     * @param fragment 条件を宣言した要素のフラグメント
     * @returns 取得元とキー名。取得元が無い場合は null
     */
    private static resolveConditionValueSource;
    /**
     * フォームコンテナの `data-form-arg` のキー名を返します。
     *
     * @param form フォームコンテナのフラグメント
     * @returns キー名。指定が無い場合は null
     */
    private static resolveFormArgKey;
    /**
     * 収集対象として**宣言されている**最上位のキー名を列挙します。
     *
     * `data-if` が偽の分岐配下も対象にします。値収集（`getValues()`）はそれらを除外
     * するため、宣言だけを見て「そのキーは収集値が権威」と判断できるようにするため
     * です。`data-form-object` / `data-form-list` に囲まれている場合はその名前だけを
     * 加えます（キー全体が収集値で置き換わります）。
     *
     * 起点自身の `data-form-object` / `data-form-list` も同じ扱いです。フォームコンテナ
     * へ直接宣言した場合、収集値はすべてそのキー配下に入るため、最上位の宣言キーは
     * その 1 つだけになります。配下の `name` を挙げると収集値と対応が取れず、条件式が
     * バインドデータ（コミット済みの 1 手前の値）で評価されてしまいます。
     *
     * 走査は実 DOM に対して行います。`data-if` が偽の分岐はフラグメントの子を保持
     * しないことがあり、フラグメントだけを辿ると隠れた欄の宣言を取りこぼします。
     *
     * @param root 走査の起点フラグメント
     * @returns 宣言されている最上位のキー名
     */
    static collectDeclaredFieldKeys(root: ElementFragment): Set<string>;
    /**
     * フラグメントの配下で収集対象として**宣言されている**最上位のキー名を列挙します。
     *
     * `collectDeclaredFieldKeys()` の実体です。収集で除外した部分木が宣言している
     * キーを知るために、除外側（`getPartValues()`）からも呼びます。
     *
     * @param root 走査の起点フラグメント
     * @returns 宣言されている最上位のキー名
     */
    private static collectDeclaredKeysInFragment;
    /**
     * `data-validity` の条件を評価し、`setCustomValidity()` へ反映します。
     *
     * 評価は呼び出し時点で**同期**に行います。属性の再描画を待つ実装にすると、
     * 「最後の欄を直してそのまま次へを押す」操作でクリック時点の状態が古くなり、
     * ブロックの判定を誤ります。
     *
     * @param root 走査の起点フラグメント
     * @returns 戻り値はありません。
     */
    static applyCustomValidity(root: ElementFragment): void;
    /**
     * 1 つの入力欄へ `data-validity` の評価結果を反映します。
     *
     * @param fragment 対象フラグメント
     * @param attribute 属性名
     * @returns 戻り値はありません。
     */
    private static applyOneCustomValidity;
    /**
     * `data-validity-message` の文言を解決します。
     *
     * @param fragment 対象フラグメント
     * @returns 表示する文言
     */
    private static resolveValidityMessage;
    /**
     * 条件属性の値から式を取り出します。
     *
     * `{{式}}` の形でも、波括弧なしの式でも受け付けます。
     *
     * @param raw 属性の生値
     * @returns 式文字列
     */
    static unwrapConditionExpression(raw: string): string;
    /**
     * 検証が走らない構成で `data-validity` が宣言されている場合に警告します。
     *
     * `data-validity` はネイティブ検証（`data-{event}-validate`）に相乗りするため、
     * 検証を行わない手続きでは無言で効かなくなります。開発モードでのみ知らせます。
     *
     * @param root 走査の起点フラグメント
     * @param reason 検証が行われない理由
     * @returns 戻り値はありません。
     */
    static warnUnvalidatedCustomValidity(root: ElementFragment | null, reason: string): void;
    /**
     * 配列でないプレーンなオブジェクトであれば、その値を返します。
     *
     * @param value 判定する値
     * @returns オブジェクトの場合はその値。それ以外は null
     */
    private static asPlainRecord;
    /**
     * 重ね合わせで無視する、プロトタイプ汚染につながるキー。
     *
     * 入力欄の `name` はサーバ側の値から組み立てられることがあるため、収集値に
     * これらのキーが現れる可能性を排除できません。
     */
    private static readonly UNSAFE_MERGE_KEYS;
    /**
     * 収集した行配列に対応する行の識別情報。
     *
     * 収集値は素の配列なので、それ単体では「どの配列要素から来た行か」が分かりません。
     * 収集の時点でしか分からない対応（`data-each` が行へ付けたリストキー）を、収集した
     * 配列そのものを鍵にして控えます。参照が失われた場合は出現順の対応へ退きます。
     */
    private static readonly COLLECTED_ROW_IDENTITY;
    /**
     * 「集合として完結した値」の印。
     *
     * 同名チェックボックス・ラジオの群の選択集合は、1 つのキーに対する完全な値です。
     * 応答データへ重ねるときに位置合わせで混ぜると壊れるため、丸ごと置き換える対象で
     * あることを配列そのものを鍵にして控えます（`markCompleteSet()`）。
     */
    private static readonly COMPLETE_SET_VALUES;
    /**
     * 収集値の各階層で、`data-if-false` により収集から除外されたキー。
     *
     * 収集値は素のオブジェクトなので、それ単体では「収集されなかったキー」と
     * 「そもそも宣言が無いキー」を区別できません。重ね合わせは前者を落とし後者を
     * 土台から引き継ぐ必要があるため、収集の時点でしか分からない除外を、階層ごとの
     * オブジェクトそのものを鍵にして控えます。
     */
    private static readonly COLLECTED_EXCLUDED_KEYS;
    /** 出現順への退避を知らせた理由（同じ理由を繰り返さないため） */
    private static readonly warnedPositionalRowFallbacks;
    /**
     * キーの無い派生一覧の収集を知らせた `data-each` の式。
     *
     * 収集は入力のたびに走るため、同じ宣言を繰り返し報告しないようにします。
     */
    private static readonly warnedDerivedRowsWithoutKey;
    /**
     * 収集した行配列に、行の識別情報を結び付けます。
     *
     * @param rows 収集した行配列
     * @param keyArg `data-each-key` の指定（無ければ null）
     * @param keys 行ごとのリストキー（`rows` と同じ並び）
     * @param identifiesItems リストキーで収集先の配列要素を識別できるかどうか
     */
    private static registerCollectedRowIdentity;
    /**
     * 収集値の階層に、除外されたキーの集合を結び付けます。
     *
     * @param values その階層の収集値
     * @param keys 除外されたキー
     */
    private static registerCollectedExcludedKeys;
    /**
     * 収集値に控えた情報を、複製した値へ引き継ぎます。
     *
     * 収集値をたどって作り直す処理（`File` の正規化など）は配列やオブジェクトを
     * 複製するため、引き継がないと重ね合わせが出現順の対応へ退いたり、非表示分岐で
     * 除外したキーが土台から復活したりします。
     *
     * @param from 元の値
     * @param to 複製した値
     */
    static carryCollectedRowIdentity(from: object, to: object): void;
    /**
     * 行の対応付けが出現順へ退いたことを、開発モードで一度だけ知らせます。
     *
     * 識別情報は収集した配列そのものを鍵に持つため、収集から重ね合わせまでの途中で
     * 配列を複製する処理が増えると、黙って出現順の対応へ退きます。退いたこと自体は
     * 動作を止めませんが、行の取り違えを招くため気付ける形にします。
     *
     * @param reason 退いた理由
     */
    private static warnPositionalRowFallback;
    /**
     * 派生一覧を `data-each-key` なしで収集する宣言を、開発モードで知らせます。
     *
     * `data-each-key` が無いとリストキーはインデックス由来（`__index_N`）になるため、
     * 行と配列要素の対応は出現順と同じになります。絞り込んだ一覧
     * （`data-each="rules.filter(...)"`）を `data-form-list="rules"` で収集する構成では
     * 画面の並びが配列の並びと一致しないため、画面の 2 行目の値が配列の 2 番目の要素
     * （絞り込みで除かれた要素）へ書き込まれます。収集値は画面のとおりに見えるので
     * 気づけません（仕様「行の対応付けと `data-each-key`」の「`data-each-key` なし」）。
     *
     * 素の経路（`rules` / `dialog.rules`）は配列そのものを描くため対象外です。
     *
     * @param container `data-form-list` を持つコンテナのフラグメント
     */
    private static warnDerivedRowsWithoutKey;
    /**
     * 収集値を、直前のバインドデータへ重ねます。
     *
     * 収集値は**入力欄が表す部分だけ**なので、そのまま置き換えるとレコードの他の
     * フィールド（`id` や表示専用のラベル、`data-attr-value` へ渡す送信値など）が
     * 失われます。失うと、行の表示が空になったり、保存に必要なキーが送られなく
     * なったりします。土台を敷いて、収集したキーだけを上書きします。
     *
     * `data-form-list` の行（配列）は、`data-each` が行へ付けたリストキーで配列要素へ
     * 対応付けます（`overlayIdentifiedRows()`）。配列に無いキーの行は取り込みません。
     * リストキーが無い行（`data-each` で描いていない静的な行）や、識別情報をたどれ
     * ない場合は**出現順**の対応へ退きます。要素数はこの対応付けの結果に従うため、
     * 行の追加・削除はそのまま反映されます。
     *
     * **`data-if` が偽の分岐で収集から除外されたキーは、土台からも落とします。**
     * 除外は「表示中の分岐の入力値だけが直列化され、非表示分岐の値との競合は発生
     * しません」（仕様の `data-if-false` 分岐とフォーム送信）を保証するためのもので、
     * 土台の値が残るとこの保証が崩れ、表示条件から外れた項目が保存値・送信データに
     * 残ります。引き継ぐのは**宣言の無いキー**だけです（`id` や表示専用のラベル
     * など、そもそもどの入力欄も表さないキー）。この区別は条件式の評価スコープ
     * （`buildConditionScope()`）が使うものと同じです。
     *
     * プロトタイプ汚染につながるキー（`__proto__` など）は読み飛ばします。式評価は
     * これらをバインドキーとして受け付けないため、載せても参照できず、`__proto__` に
     * 至っては代入でオブジェクトのプロトタイプが差し替わってしまいます。
     *
     * **土台に無いキーは `resolveBase` で解決します。** フォーム自身が収集キーを
     * 持たず祖先が持っている構成では、土台がここに無いためです（仕様「双方向
     * バインディングの自動更新」の「土台はフォーム自身のバインドデータに限りません」）。
     * 呼び出し側で土台を組み立ててから渡す形にしないのは、上のプロトタイプ汚染の
     * ガードを迂回させないためです（解決した値の代入もこのループの中で行います）。
     * 入れ子のレコードへ再帰する際は渡しません（解決するのはトップレベルの収集キー
     * だけで、入れ子のキーはバインドキーではないため）。
     *
     * @param previous 直前のバインドデータ（無い場合は null）
     * @param collected 収集値
     * @param resolveBase 土台に無いキーの土台を返す関数。省略時は解決しない
     * @returns 収集値を重ねたバインドデータ
     */
    static mergeCollectedValues(previous: Record<string, unknown> | null, collected: Record<string, unknown>, resolveBase?: ((key: string) => unknown) | null): Record<string, unknown>;
    /**
     * 収集値の 1 項目を、直前の値へ重ねます。
     *
     * @param previous 直前の値
     * @param collected 収集値
     * @returns 重ね合わせた値
     */
    private static overlayCollectedValue;
    /**
     * 式の先頭にある素の経路を切り出す正規表現。
     *
     * 1 つめの捕獲が経路、2 つめが残りです。`data-each` は式なので、経路として読める
     * ものだけを経路として扱います。
     */
    private static readonly LEADING_PATH_PATTERN;
    /**
     * 式の先頭にある素の経路を返します。
     *
     * `rows` や `candidates.content` のような素の経路と、既定値を添えただけの
     * `rows || []` / `rows ?? []` を経路として扱います。それ以外（関数呼び出しや
     * 添字など）は経路として読めないものとして null を返します。
     *
     * `null` を返す 2 つの分岐は、呼び出し側から見て同じ結論（判定できないので従来
     * どおりリストキーを使う）になるため、**振る舞いとしては区別できません**。回帰
     * テストで押さえられるのは「`|| []` を経路として読む」側だけです
     * （`tests/each-source-differs-from-form-list.test.ts`）。
     *
     * @param expression 対象の式
     * @returns 先頭の経路。経路として読めない場合は null
     */
    private static resolveLeadingPath;
    /**
     * `data-each` の取得元が `data-form-list` の収集先と同じ配列かを判定します。
     *
     * 行のリストキーは `data-each` の**取得元**の要素から作ります（`data-each-key` は
     * 取得元の項目名です）。そのキーで収集先の配列を引けるのは、取得元と収集先が同じ
     * 配列のときだけです。別の配列を指す構成（候補一覧を繰り返して、選択結果を別の
     * キーへ集める）では、どの行のキーも収集先には無いため、リストキーによる対応付け
     * は全滅します。収集では全行が「配列から消えた行」と判定されて収集値が空配列に
     * なり、書き戻しでは全行が「対応する要素なし」になります。同じ前提は要素データを
     * 行の入力欄へ反映する経路（`Core.applyRowFormValues()`）にもあり、取得元の要素
     * データで行の入力欄を上書きするため、取得元に無い `name` の欄が空になります。
     *
     * 判定は宣言だけで行います（実行時の値に依らせると、配列が一時的に空のときに
     * 判定が揺れます）。`data-each` の式の先頭の経路の**末尾の区間**を `data-form-list`
     * の名前と比べます。収集先の名前は収集構造の 1 区間なので、同じ配列であれば
     * 取得元の経路の末尾もその名前になります（`items` / `dialog.items` / `r.items`）。
     *
     * 経路として読めない式（関数呼び出しなど）は判定できないため true を返し、
     * 従来どおりリストキーで対応付けます。判定できないことを理由に対応付けを緩めると、
     * 行の挿入・削除で値がずれる問題（0.39.2 で修正）が戻ってしまいます。
     *
     * @param container `data-form-list` を持つコンテナのフラグメント
     * @returns 同じ配列を指す場合、または判定できない場合は true
     */
    static isCollectedListFromEachSource(container: ElementFragment): boolean;
    /**
     * 配列要素のリストキーと、その要素の位置の対応表を作ります。
     *
     * キーは `data-each` の差分更新と同じ規則（`Core.createListKey()`）で作ります。
     * 呼び出し側で作り直すと行の対応付けが差分更新とずれるためです。すべての要素に
     * 対してキーを作ります（`Core.createListKey()` は非オブジェクトも扱えます）。
     * 作らない要素を残すと、対応する行が「配列に無い行」と誤判定されます。
     *
     * 同じキーが重複する場合は位置を出現順に並べ、呼び出し側が順に消費します
     * （重複時は出現順の対応と同じ挙動になります）。
     *
     * @param items 対象の配列
     * @param keyArg `data-each-key` の指定（無ければ null）
     * @returns リストキーごとの位置の配列
     */
    private static createRowKeyIndexes;
    /**
     * 入力欄へ書き戻す行と配列要素を対応付けます。
     *
     * 逆方向同期（`syncValues()`）は `Core.setBindingData()` の中で `data-each` の行生成
     * より**前**に走るため、行を挿入・削除した直後は「配列の要素数と画面の行数が
     * 食い違う」状態で書き戻しが走ります。位置で組み合わせると、挿入・削除位置より
     * 後の行がひとつずつずれた値を受け取ります（挿入なら後続の行が手前の行の値に
     * なります）。`data-each` が行へ付けたリストキーで対応付けて防ぎます。
     *
     * 配列に無いキーの行は、これから取り除かれる古い行なので `null` を返します
     * （呼び出し側が「値を触らない」扱いにします）。逆に、行がまだ無い配列要素は
     * 行の生成時に `syncRowValues()` が拾います。
     *
     * @param rows 画面にある行のフラグメント
     * @param items 対象の配列
     * @param keyArg `data-each-key` の指定（無ければ null）
     * @returns 行ごとに対応する配列要素（対応が無い行は null）。
     *     対応付けができない場合は null（位置での組み合わせへ退く）
     */
    private static pairRowsWithItems;
    /**
     * 収集した行を、リストキーで配列要素へ対応付けて重ねます。
     *
     * 出現順の対応は「配列と画面の行数・並びが一致している」ことを前提にします。
     * 行の削除は配列を先に更新して画面を描き直すため、描き直しの前に収集が走ると
     * 前提が崩れ、残った行が消えた行の値を受け取ったり、`id` を持たない行が増えたり
     * します。`data-each` が行へ付けたリストキーで対応付ければ、この崩れを避けられます。
     *
     * 配列に無いリストキーの行は、配列から消えた行が画面に残っているものとして落とし
     * ます。行の増減は配列を先に更新するため、配列に無い行は常に古い画面です。
     *
     * 逆に、**収集した行に対応しない配列要素は元の位置に元の値のまま残します**（仕様
     * 「行の対応付けと `data-each-key`」の「収集した行に対応しない配列要素」）。収集は
     * 集められた行だけを集めるため、収集した行だけで組み立て直すと、絞り込んだ一覧
     * （`data-each="rules.filter(...)"`）を `data-form-list="rules"` で収集する構成で、
     * 絞り込みで除かれた要素が丸ごと失われます（行そのものを `data-if` で隠した場合も
     * 同様です）。並びも土台の配列に従うため、配列を先に入れ替えて画面を描き直す前に
     * 収集が走っても（`row-prev` の直後など）並びが巻き戻りません。
     *
     * @param previous 直前の配列（配列要素が権威）
     * @param collected 収集した行配列
     * @returns 重ね合わせた配列。対応付けができない場合は null（出現順へ退く）
     */
    private static overlayIdentifiedRows;
    /**
     * 祖先のバインドデータ更新を、配下のフォームへ反映します。
     *
     * `data-form-arg` を宣言したフォームへは入力欄まで流し込みます。対象は「当該キーを
     * 所有するのが更新された祖先自身」であるフォームだけです。間に同名キーを持つ要素が
     * あればそちらが権威なので対象外とします。
     *
     * `data-form-arg` の無い収集単位（`<form>` と `data-form` コンテナ）には、双方向
     * コミットが作ったコピーの解除だけを行います（仕様「祖先が所有する値の反映
     * （`data-form-arg` なし）」の「祖先が当該キーを更新したときに解除するため、以降の
     * 更新が届かなくなることはありません」）。解除しないと、一度でも入力した収集単位は
     * 以降どの再取得も受け付けません。入力欄へ流し込まないのは、どのキーが対応するかを
     * 宣言していないためです（同節の「入力欄への流し込みは `data-form-arg` を宣言した
     * 場合だけです」）。行の入力欄は解除後の再評価で `data-each` の行単位の反映が
     * 拾います。
     *
     * 更新が始まった後に初期化されたフォームも対象外です。祖先の更新は初期化前の
     * 状態を運んでいるため、流し込むとクリアしたはずの値が復活します。
     *
     * @param fragment 更新された祖先のフラグメント
     * @param resetSequence 更新が始まった時点の初期化の通番
     * @param origin 値の由来（通番と種別）。渡すと入力欄ごとに適用可否を判定します
     * @param previous 更新前の祖先の生バインドデータ。渡すと値が変わったキーだけ解除する
     * @returns 反映完了の Promise
     */
    static syncAncestorArgForms(fragment: ElementFragment, resetSequence: number, origin?: ValueChangeOrigin | null, previous?: Record<string, unknown> | null): Promise<void>;
    /**
     * 配下の収集単位のうち、祖先のキーをコピーでシャドーしているものを列挙します。
     *
     * 収集単位は `<form>` と `data-form` コンテナの両方です（`Form.getFormFragment()`
     * が対象にする範囲と揃えます）。どちらも双方向コミットの書き込み先になるため、
     * どちらもコピーを作って祖先をシャドーしえます。仕様「祖先が所有するレコードの
     * 反映（`data-form-arg`）」が `data-form` を対象外とするのは**入力欄への流し込み**
     * についてで、シャドーの解除には当てはまりません。
     *
     * `data-form-arg` を宣言した `<form>` は除きます。そちらは `collectArgForms()` が
     * 扱い、`pushAncestorArgValue()` が入力欄への流し込みまで行います。
     *
     * 列挙するキーは、収集単位自身の生バインドデータが持ち、かつ**初期 `data-bind`
     * 宣言に無い**キーに限ります。宣言のあるキーは双方向コミットが作ったコピーでは
     * なく自身の宣言なので、祖先が同名のキーを更新しても落としてはなりません。
     *
     * @param root 走査の起点フラグメント（更新された祖先）
     * @returns 収集単位のフラグメントと、それが `root` のキーをシャドーしているキー名の
     *     一覧。シャドーしているキーが無い収集単位は含みません
     */
    private static collectShadowingContainers;
    /**
     * 双方向コミットが作ったコピーを、フォーム自身のバインドデータから取り除きます。
     *
     * 取り除くと、フォーム内の式とフラグメントの継承は祖先の値を見るようになります。
     * 入力欄へは触りません（`data-each` の行は解除後の再評価で描き直され、行単位の
     * 反映が値を入れます）。
     *
     * @param form フォームのElementFragment
     * @param keys 取り除くキー名の一覧
     * @param origin 値の由来（通番と種別）。祖先の更新を起こした操作のものを引き継ぐ
     * @returns 反映完了の Promise
     */
    private static releaseOwnCopy;
    /**
     * 指定要素の配下にある `data-form-arg` 付きフォームを列挙します。
     *
     * @param root 走査の起点フラグメント
     * @returns フォームフラグメントと `data-form-arg` のキー名の組
     */
    static collectArgForms(root: ElementFragment): Array<{
        form: ElementFragment;
        key: string;
    }>;
    /**
     * 祖先が所有するレコードを、フォームの入力欄へ流し込みます。
     *
     * 前回流し込んだ内容と同じであれば何もしません。同じ値でも書き戻すと、利用者が
     * 確定した編集を巻き戻してしまうためです。
     *
     * フォーム自身が同名のキーを持っている場合（双方向コミットが書き込んだコピー）は
     * それを取り除きます。残したままにすると以降の祖先の更新がシャドーされ、
     * フォーム内の式が参照する値と入力欄の内容が食い違います。
     *
     * @param form フォームのElementFragment
     * @param key `data-form-arg` で指定されたキー名
     * @param value 祖先が所有する値
     * @param origin 値の由来（通番と種別）。渡すと入力欄ごとに適用可否を判定します
     * @returns 反映完了の Promise
     */
    private static pushAncestorArgValue;
    /**
     * 流し込み済み判定に使う値の署名を作ります。
     *
     * @param value 対象の値
     * @returns JSON 文字列。直列化できない場合は null（毎回反映する扱いにする）
     */
    private static createArgValueSignature;
    /**
     * 初期 `data-bind` の値を配下の入力欄へ反映します。
     *
     * `Core.setBindingData()` 経由の逆方向同期は `data-bind` 属性を**更新した**ときに
     * だけ走るため、初期スキャンで読み込んだ `data-bind` は入力欄へ反映されません。
     * その結果、`name` に対応する値を持つ `<select>` やチェックボックスが未選択のまま
     * 残り、最初の `change` で全項目を収集した際に空値として確定して他項目の値を失う
     * 問題がありました。本メソッドは初回スキャン時に一度だけ逆方向同期を適用します。
     *
     * 対象は `<form>` 要素のうち `data-bind` を持つもの、および `data-form-arg` の
     * キーを祖先の `data-bind` が所有するものです。`data-bind` に含まれないキーの
     * 入力欄は `setPartValues()` の規則により既存値が維持されるため、HTML の `value`
     * 属性で与えた初期値は保たれます。
     *
     * @param root 走査の起点要素
     * @returns 反映完了の Promise
     */
    static restoreInitialValues(root: HTMLElement): Promise<void>;
    /**
     * 同名チェックボックス・ラジオの群を、群単位で収集します。
     *
     * 仕様「反映待ちの間に起きた変化」の「**同名チェックボックス・ラジオの群は、欄ごと
     * ではなく群単位で保護します**」「群のいずれかの欄が要求より後に操作されていれば、
     * その群の現在の選択集合をそのまま保護します」に対応します。群の値は 1 つのキーに
     * 対する選択の集合なので、操作された欄だけを取り出すと集合が壊れます。
     *
     * 群の範囲は仕様「反映待ちの間に起きた変化」の「群の範囲は、収集値の同じ階層です」
     * に従い、`resolveCollectionScope()` が返す階層の中だけを数えます。収集の対象外の
     * 部分木（`data-form-detach`・非表示分岐）と、別の階層（入れ子の `data-form-object` /
     * `data-form-list` の行）は数えません。同じ群かどうかは「群の同一性は**収集キー**で
     * 判断します」のとおり `resolveFieldName()` の結果で判定します（DOM の `name` で
     * 判定すると、`data-form-name` だけを宣言した別のキーの群と混ざる）。
     *
     * 走査は DOM 検索ではなくフラグメントの木で行います。収集（`getPartValues()`）と
     * 同じ木をたどることで階層と除外の判定を一致させ、Haori が管理していない要素
     * （外部ウィジェットの内部の入力欄など）へフラグメントを生やさないためです。
     * チェック状態と送信値は仕様「収集は DOM を真とする」のとおり DOM から読みます。
     *
     * @param fragment 群のいずれかの入力欄のフラグメント
     * @param isValueList `data-form-list` を併記しているかどうか
     * @param minUserEditSequence 編集の基準となる通し番号
     * @returns 基準より後の操作があったかどうかと、現在の選択集合
     */
    private static collectGroupSelection;
    /**
     * 収集値の新しい階層を始める要素かどうかを判定します。
     *
     * `getPartValues()` の分岐と同じ規則です。収集キー（`name` / `data-form-name`）を
     * 持つ要素は値そのものを表すため階層を作らず、`data-form-object` /
     * `data-form-list` に**属性値がある**ときだけ階層が変わります（属性値の無い
     * `data-form-list` は入力要素の値を配列として集める印で、階層は作りません）。
     *
     * @param fragment 判定するフラグメント
     * @returns 新しい階層を始める場合は true
     */
    private static startsCollectionLevel;
    /**
     * 収集値の階層（同じキーの集まる範囲）となるフラグメントを解決します。
     *
     * 仕様「反映待ちの間に起きた変化」の「群の範囲は、収集値の同じ階層です」
     * 「`data-form-list` の**行**、`data-form-object`、最近傍のフォーム（`<form>` または
     * `data-form`）のうち最も内側の範囲です」に対応します。`data-form-object` は自身が
     * 階層、`data-form-list` はその直下の要素（= 行）が階層です。フォームの外（どの
     * 階層にも囲まれていない構成）では、たどり着いた最上位の要素を範囲とします。
     *
     * ラジオの排他制御の範囲（`resolveGroupScope()`）とは別の概念です。あちらは HTML の
     * グループの範囲で `data-form-object` を境界としませんが、こちらは収集値のキーの
     * 範囲なので `data-form-object` も境界になります。
     *
     * @param fragment 起点のフラグメント
     * @returns 階層となるフラグメント
     */
    private static resolveCollectionScope;
    /**
     * フォームの範囲の根（`<form>` または `data-form`）かどうかを判定します。
     *
     * @param fragment 判定するフラグメント
     * @returns フォームの範囲の根であれば true
     */
    private static isFormScopeRoot;
    /**
     * 階層の中から、同じ収集キーを持つ群の欄を集めます。
     *
     * 収集（`getPartValues()`）と同じ判定で部分木を刈ります。別の階層（入れ子の
     * `data-form-object` / `data-form-list`）と、収集の対象外の部分木
     * （`data-form-detach`・非表示分岐の `data-if-false`）へは入りません。仕様
     * 「反映待ちの間に起きた変化」の「収集の対象外である部分木の欄も群に含めません」
     * に対応します。
     *
     * 入れ子のフォームはここでは刈りません。範囲の解決（`resolveCollectionScope()`）が
     * 最近傍のフォームで止まるため、内側の欄は内側のフォームを範囲として数え直され、
     * 同じキーへの書き込みはそちらが後に来ます（刈っても結果は変わらない）。
     *
     * @param fragment 走査するフラグメント（最初の呼び出しでは階層の根）
     * @param key 群の収集キー
     * @param members 集める先
     */
    private static collectGroupMembers;
    /**
     * 「集合として完結した値」として印を付けます。
     *
     * 群の選択集合は 1 つのキーに対する完全な値なので、応答データへ重ねるときに
     * 位置合わせで要素ごとに混ぜてはいけません（`data-form-list` の行の配列とは
     * 意味が違います）。印は `Procedure` の `mergeUserEdits()` が見て、丸ごと
     * 置き換えます。
     *
     * @param value 印を付ける配列
     * @returns 同じ配列
     */
    private static markCompleteSet;
    /* Excluded from this release type: isCompleteSetValue */
    /**
     * 値による上書きをグループ単位で扱うべき入力要素（boolean 型でない
     * チェックボックス、またはラジオボタン）かどうかを判定します。
     *
     * @param fragment 対象フラグメント
     * @returns グループ扱いの場合 true
     */
    private static isGroupedCheckable;
    /**
     * 複数選択の select 要素かどうかを判定します。
     *
     * @param fragment 対象フラグメント
     * @returns `<select multiple>` の場合 true
     */
    private static isMultipleSelect;
    /**
     * 単一フラグメントへ値を設定します。
     *
     * @param fragment 対象フラグメント
     * @param value 設定する値
     * @param emitEvents input/change イベントを発火するかどうか
     * @param origin 値の由来（通番と種別）。渡すと宛先の台帳で適用可否を判定します
     * @returns Promise（DOMの更新が完了したら解決される）
     */
    private static applyFragmentValue;
    /**
     * フラグメント内にある各入力エレメントに値を設定します。
     *
     * @param fragment 対象フラグメント
     * @param values フラグメントに設定する値のオブジェクト
     * @param force data-form-detach属性があるエレメントにも値を反映するかどうか
     * @param emitEvents input/change イベントを発火するかどうか
     * @param clearMissing values に無いキーの入力欄を空にするかどうか
     * @param listCursors 同名リストの出現位置。同じ `values` を共有する範囲で
     *     収集キーごとに何件目かを数え、配列の対応する要素を配るために使う
     * @param origin 値の由来（通番と種別）。渡すと入力欄ごとに適用可否を判定します
     * @returns Promise（DOMの更新が完了したら解決される）
     */
    private static setPartValues;
    /**
     * 対象フラグメントとその子孫要素の値を初期化します。
     * 値の初期化とメッセージのクリアを行います。
     *
     * 初期化は「初期 `data-bind` 宣言の値を供給する 1 つの操作」です（仕様「`data-{event}-reset`」）。
     * したがって他の供給と同じ後勝ちの規則に従い、**この初期化より後に供給された値が
     * すでに載っている宛先へは書き込みません**（仕様「反映待ちの間に起きた変化」）。
     *
     * @param fragment 対象フラグメント
     * @param operationSequence 初期化を要求した操作の通番。**操作が起きた時点**
     *     （クリックのハンドラなど）で発番して渡すこと。既定は呼出時点で発番する。
     *     呼び出し時点で発番すると、クリックの後に届いた供給がこの初期化より小さい
     *     番号を持つことになり、後勝ちが逆転する
     * @returns すべての初期化処理が完了するPromise
     */
    static reset(fragment: ElementFragment, operationSequence?: number): Promise<void>;
    /**
     * 祖先が所有するキーを、リセットの書き込み対象から落とします。
     *
     * 落とすのは初期 `data-bind` 宣言に無いキーだけです。宣言のあるキーはフォーム
     * 自身が持つべき値で、祖先が同名のキーを持っていてもフォームの宣言が権威です。
     *
     * @param form フォームのElementFragment
     * @param initial 初期 `data-bind` 宣言（無い場合は null）
     * @param target リセットで書き込むバインドデータ（この場で書き換えます）
     */
    private static deleteAncestorOwnedKeys;
    /**
     * data-bind 属性で宣言された初期バインドデータを取得します。
     *
     * @param formFragment 対象のフォームフラグメント
     * @returns 初期バインドデータ。宣言がない場合は null。
     */
    private static getInitialBindingData;
    /**
     * フラグメント配下の入力要素について、内部値を現在の DOM 値と再同期します。
     *
     * @param fragment 対象フラグメント
     */
    private static syncValuesFromDom;
    /**
     * リセット後にバインドデータを更新すべきフォームフラグメントを収集します。
     * 対象がフォームの場合はそのフォーム、コンテナの場合は配下のすべての
     * フォームを対象とします。祖先フォームは対象外とします（行リセット等の
     * 部分リセットでフォーム全体のバインドデータを書き換えないため）。
     *
     * @param fragment 対象フラグメント
     * @returns フォームフラグメントのリスト
     */
    private static collectBindingTargetForms;
    /**
     * data-each によって生成された複製（テンプレート以外）を削除します。
     * 既存のテンプレートは保持し、その後の再評価で必要に応じて再生成されます。
     * 対象エレメント自体がdata-eachを持つ場合はその子の複製を削除しますが、
     * 対象エレメント自体は削除しません。
     */
    private static clearEachClones;
    /**
     * 再帰的に値を初期化します。
     *
     * @param fragment 対象フラグメント
     */
    private static clearValues;
    /**
     * 指定した通番より後に編集された入力欄の DOM の状態を控えます。
     *
     * ネイティブの `form.reset()` は DOM を直接書き戻すため、入力欄ごとの保護判定
     * （`ElementFragment` の編集の通番）を経由しません。リセットを要求した後に行われた
     * 編集を残すために、リセットの直前に控えて直後に戻します
     * （仕様「反映待ちの間に起きた変化」）。
     *
     * @param fragment 対象フラグメント（配下も辿る）
     * @param operationSequence この通番より後の編集を控える
     * @param collected 控えの蓄積先（再帰用）
     * @returns 控えた状態の配列
     */
    private static collectEditsAfter;
    /**
     * 控えた入力欄の状態を DOM へ戻します。
     *
     * 内部値は戻しません（`Form.reset()` の呼び出し箇所のコメントを参照）。
     *
     * @param snapshots `collectEditsAfter()` で控えた状態
     * @returns 戻り値はありません。
     */
    private static restoreEdits;
    /**
     * `data-form-arg` のキーを祖先が所有するフォームを、そのレコードの内容へ戻します。
     *
     * 自身のバインドデータを持たないフォームは、リセットで戻すべき初期状態を自分では
     * 持たず、参照している祖先のレコードが初期状態になります。編集済みのフォームは
     * 双方向コミットが作ったコピーを消す過程で祖先の値が書き戻されますが、一度も
     * 編集していないフォームにはそのコピーが無いため、ここで明示的に戻します。
     *
     * @param form 対象のフォームフラグメント
     * @param origin 値の由来（通番と種別）。渡すと入力欄ごとに適用可否を判定します
     * @returns 反映完了の Promise
     */
    private static restoreAncestorArgValues;
    /**
     * 初期化の通番を部分木のすべてのフラグメントへ記録します。
     *
     * 書き戻しの宛先はフォームだけとは限らず、祖先の更新から流し込まれるフォーム
     * （`syncAncestorArgForms()`）や、載せ直しの対象になる入力欄も宛先になります。
     * どの宛先でも「この初期化より前に始まった更新か」を判定できるよう、部分木へ
     * 一律に記録します。
     *
     * @param fragment 対象フラグメント
     * @param sequence 記録する初期化の通番
     */
    private static markResetSubtree;
    /**
     * フラグメントとその子要素のメッセージをクリアします。
     *
     * @param fragment 対象フラグメント
     * @returns Promise（メッセージのクリアが完了したら解決される）
     */
    static clearMessages(fragment: ElementFragment): Promise<void>;
    /**
     * キーに一致するフラグメントにエラーメッセージを追加します。
     * キーに一致するフラグメントが見つからない場合は、指定されたフラグメントにメッセージを追加します。
     *
     * @param fragment 対象フラグメント
     * @param key キー（ドット区切りの文字列）
     * @param message 追加するエラーメッセージ
     * @return Promise（メッセージの追加が完了したら解決される）
     */
    static addErrorMessage(fragment: ElementFragment, key: string, message: string): Promise<void>;
    /**
     * キーに一致するフラグメントにレベル付きメッセージを追加します。
     * キーに一致するフラグメントが見つからない場合は、指定されたフラグメントにメッセージを追加します。
     *
     * @param fragment 対象フラグメント
     * @param key キー（ドット区切りの文字列）
     * @param message 追加するメッセージ
     * @param level メッセージのレベル（省略可能）
     * @return Promise（メッセージの追加が完了したら解決される）
     */
    static addMessage(fragment: ElementFragment, key: string, message: string, level?: 'info' | 'warning' | 'error' | 'success'): Promise<void>;
    /**
     * 指定されたキーに一致するフラグメントを検索します。
     *
     * @param fragment 対象フラグメント
     * @param key キー（ドット区切りの文字列）
     * @returns 一致するフラグメントの配列
     */
    static findFragmentsByKey(fragment: ElementFragment, key: string): ElementFragment[];
    /**
     * 指定されたキーに一致するフラグメントを検索します。
     * data-form-list属性で指定された場合はdata-row属性を持つ子要素の位置と添字が一致するものを対象とします。
     *
     * @param fragment 対象フラグメント
     * @param parts キーのパーツ
     * @returns 一致するフラグメントの配列
     */
    private static findFragmentByKeyParts;
    /**
     * 対象のフラグメントがフォームコンテナであればそれを返し、
     * そうでなければ先祖要素をたどってフォームコンテナを探します。
     *
     * フォームコンテナは `<form>` 要素、または `data-form` 属性を持つ任意の要素です。
     * 後者は `<table>` 内など `<form>` を直接置けない箇所で、`<tr>` などを値収集の
     * コンテナとして扱うために使用します（`data-click-form` 等が対象を探す際に利用）。
     *
     * @param fragment 探索の起点フラグメント
     * @returns フォームコンテナのフラグメント。見つからなければ null
     */
    static getFormFragment(fragment: ElementFragment): ElementFragment | null;
}

/**
 * 仮想DOMのフラグメントの抽象クラス。
 */
export declare abstract class Fragment {
    /** フラグメントの対象ノードに対するキャッシュ */
    protected static readonly FRAGMENT_CACHE: WeakMap<Node, Fragment>;
    /**
     * フラグメントを取得もしくは作成します。
     *
     * @param node 対象ノード
     * @returns フラグメント
     */
    static get(node: HTMLElement): ElementFragment;
    static get(node: Text): TextFragment;
    static get(node: Comment): CommentFragment;
    static get(node: Node | null): Fragment | null;
    /* Excluded from this release type: peek */
    /** 親フラグメント */
    protected parent: ElementFragment | null;
    /** 対象ノード */
    protected readonly target: Node;
    /** フラグメントがDOMにマウントされているかどうか */
    protected mounted: boolean;
    /** ノード更新スキップフラグ（オブザーバーによる無限ループ対応） */
    protected skipMutationNodes: boolean;
    /** エンジン自身が出し入れしている最中の子ノード（観測の取り込み対象外） */
    private readonly skipMutationNodeSet;
    /**
     * フラグメントのコンストラクタ。
     *
     * @param target 対象ノード
     */
    protected constructor(target: Node);
    /**
     * 指定した子ノードを、エンジン自身が出し入れしている最中かどうかを返します。
     *
     * @param node 判定する子ノード
     * @returns エンジンが出し入れ中なら true
     */
    isSkipMutationNode(node: Node): boolean;
    /**
     * 子ノードを「エンジンが出し入れ中」として登録します。
     *
     * @param node 対象の子ノード
     * @returns 戻り値はありません。
     */
    protected holdSkipMutationNode(node: Node): void;
    /**
     * 子ノードの「エンジンが出し入れ中」の登録を外します。
     *
     * @param node 対象の子ノード
     * @returns 戻り値はありません。
     */
    protected releaseSkipMutationNode(node: Node): void;
    /**
     * フラグメントをDOMから除去します。
     *
     * @return 除去のPromise
     */
    unmount(): Promise<void>;
    /**
     * フラグメントをDOMに追加します。
     *
     * @return 追加のPromise
     */
    mount(): Promise<void>;
    /**
     * フラグメントのマウント状態を取得します。
     *
     * @returns マウント状態
     */
    isMounted(): boolean;
    /**
     * フラグメントのマウント状態を設定します。
     *
     * @param mounted マウント状態
     */
    setMounted(mounted: boolean): void;
    /**
     * フラグメントをクローンします。
     *
     * @returns クローンされたフラグメント
     */
    abstract clone(): Fragment;
    /**
     * フラグメントとノードを削除します。
     *
     * @param unmount DOMからの除去を行うかどうか（内部の子呼び出しの場合のみfalseとする）
     * @return 除去のPromise
     */
    remove(unmount?: boolean): Promise<void>;
    /**
     * 対象ノードを取得します。
     *
     * @returns 対象ノード
     */
    getTarget(): Node;
    /**
     * 親フラグメントを取得します。
     *
     * @returns 親フラグメント
     */
    getParent(): ElementFragment | null;
    /**
     * 親フラグメントを設定します。
     *
     * @param parent 親フラグメント
     */
    setParent(parent: ElementFragment | null): void;
}

/**
 * `groupBy()` が返す 1 グループ分の情報です。
 */
declare interface GroupItem {
    /** グループのキー（最初に出現した要素の `item[key]` の生値） */
    key: unknown;
    /** そのグループに属する要素（元の順序を保つ） */
    items: unknown[];
}

/**
 * Haoriクラスは、アプリケーション全体で使用されるユーティリティメソッドを提供します。
 * 挙動を変更する場合は必要に応じてオーバライドしてください。
 */
declare class Haori {
    /**
     * 実行モードを取得します。
     *
     * @return 実行モード。
     */
    static get runtime(): 'embedded' | 'demo';
    /**
     * 実行モードを設定します。
     *
     * @param runtime 設定する実行モード。
     * @return 戻り値はありません。
     */
    static setRuntime(runtime: string): void;
    /**
     * 外部ライブラリ連携（`data-enhance`）の登録窓口です。
     *
     * `register(名前, {init, refresh, destroy})` で登録すると、`data-enhance="名前"` を
     * 宣言した要素へ Haori が適用します。適用は要素ごと・名前ごとに一度だけで、
     * `data-each` の再描画や `data-if` の再表示では `refresh`、DOM から外れたときは
     * `destroy` が呼ばれます。登録より前に描画された要素へも遡って適用するため、
     * スクリプトの読み込み順に依存しません。
     *
     * 例:
     * ```js
     * Haori.enhancers.register('choices', {
     *   init: element => new Choices(element),
     *   refresh: (element, instance) => instance.refresh(),
     *   destroy: (element, instance) => instance.destroy(),
     * });
     * ```
     */
    static readonly enhancers: {
        /**
         * 外部ライブラリ連携を登録します。
         *
         * @param name `data-enhance` に書く名前
         * @param enhancer 連携の定義
         * @return 戻り値はありません。
         */
        register(name: string, enhancer: Enhancer): void;
        /**
         * 登録済みの連携かどうかを返します。
         *
         * @param name 連携名
         * @return 登録済みなら true
         */
        has(name: string): boolean;
    };
    /**
     * 進行中・追従して投入されるものを含め、すべてのレンダリングタスクの完了を待ちます。
     *
     * `data-each` の大量行のように複数フレームに分割される描画でも、安定して完了する
     * まで待機します。Playwright などの外部テストから、タブ切り替えやクリック後に
     * 描画完了を安全に待機するために利用できます。
     *
     * 例: `await page.evaluate(() => Haori.waitForRenders())`
     *
     * @return すべてのレンダリングが完了したら解決される Promise
     */
    static waitForRenders(): Promise<void>;
    /**
     * 通知ダイアログを表示します。
     *
     * @param message 表示メッセージ
     * @returns 通知が閉じられると解決されるPromise
     */
    static dialog(message: string): Promise<void>;
    /**
     * 通知トーストを表示します。
     *
     * @param message 表示メッセージ
     * @param level メッセージのレベル（省略時は 'info'）
     * @return 通知が表示されると解決されるPromise
     */
    static toast(message: string, level?: 'info' | 'warning' | 'error' | 'success'): Promise<void>;
    /**
     * 確認ダイアログを表示します。
     *
     * @param message 確認メッセージ
     * @returns ユーザーがOKをクリックした場合はtrue、キャンセルした場合はfalseが解決されるPromise
     */
    static confirm(message: string): Promise<boolean>;
    /**
     * ダイアログを開きます。
     *
     * @param element 開くダイアログのHTML要素
     */
    static openDialog(element: HTMLElement): Promise<void>;
    /**
     * ダイアログを閉じます。
     *
     * @param element 閉じるダイアログのHTML要素
     */
    static closeDialog(element: HTMLElement): Promise<void>;
    /**
     * エラーメッセージを追加します。
     *
     * @param target メッセージを表示する要素
     * @param message エラーメッセージ
     */
    static addErrorMessage(target: HTMLElement | HTMLFormElement, message: string): Promise<void>;
    /**
     * メッセージをレベル付きで追加します。
     *
     * @param target メッセージを表示する要素
     * @param message メッセージ
     * @param level メッセージのレベル（省略可能）
     */
    static addMessage(target: HTMLElement | HTMLFormElement, message: string, level?: 'info' | 'warning' | 'error' | 'success'): Promise<void>;
    /**
     * 対象のエレメントおよびその子要素のメッセージをクリアします。
     *
     * @param parent メッセージをクリアする親要素
     */
    static clearMessages(parent: HTMLElement): Promise<void>;
    /**
     * 対象のエレメントおよびその子要素のメッセージ属性を同期的に除去します。
     *
     * Queue を介さないため、別の enqueue ブロック内から実行順を保ったまま
     * 呼び出せます。{@link clearMessages} および {@link openDialog} の共通処理です。
     *
     * @param parent メッセージをクリアする親要素
     */
    private static clearMessagesSync;
    /**
     * 日時を指定フォーマットの文字列へ整形します。
     *
     * テンプレート式中の `haori.date(...)` と同じ実装です。
     *
     * @param value 整形対象の日時（ISO 文字列・エポックミリ秒・Date）
     * @param format フォーマット文字列（省略時は `yyyy/MM/dd HH:mm`）
     * @param timeZone IANA タイムゾーン名（例 `Asia/Tokyo`）。省略時はローカルタイムゾーン
     * @returns 整形済み文字列。整形できない場合は空文字
     */
    static date(value: string | number | Date | null | undefined, format?: string, timeZone?: string): string;
    /**
     * 現在日時を指定フォーマットの文字列へ整形します。
     *
     * テンプレート式中の `haori.now(...)` と同じ実装です。戻り値は呼び出し時刻に
     * 依存するため冪等ではありません。
     *
     * @param format フォーマット文字列（省略時は `yyyy/MM/dd HH:mm`）
     * @param timeZone IANA タイムゾーン名（例 `Asia/Tokyo`）。省略時はローカルタイムゾーン
     * @returns 整形済みの現在日時文字列
     */
    static now(format?: string, timeZone?: string): string;
    /**
     * 現在日付に日数を加減した日付を指定フォーマットの文字列へ整形します。
     *
     * テンプレート式中の `haori.today(...)` と同じ実装です。戻り値は呼び出し日に
     * 依存するため冪等ではありません。
     *
     * @param offsetDays 現在日付に加減する日数（負数で過去方向、省略時は 0）
     * @param format フォーマット文字列（省略時は `yyyy-MM-dd`）
     * @param timeZone IANA タイムゾーン名（例 `Asia/Tokyo`）。省略時はローカルタイムゾーン
     * @returns 整形済みの日付文字列。timeZone が不正な場合は空文字
     */
    static today(offsetDays?: number, format?: string, timeZone?: string): string;
    /**
     * 数値を桁区切り・小数桁付きの文字列へ整形します。
     *
     * テンプレート式中の `haori.number(...)` と同じ実装です。
     *
     * @param value 整形対象（数値または数値文字列）
     * @param decimals 小数桁数（省略可能）
     * @returns 整形済み文字列。整形できない場合は空文字
     */
    static number(value: number | string | null | undefined, decimals?: number): string;
    /**
     * 整数の配列を生成します（終端は排他）。
     *
     * テンプレート式中の `haori.range(...)` と同じ実装です。
     *
     * @param start `end` 省略時は終端、指定時は開始値
     * @param end 終端（排他）
     * @param step 刻み幅（省略時は 1）
     * @returns 整数配列
     */
    static range(start: number, end?: number, step?: number): number[];
    /**
     * 番号ページネーション用の表示要素列を生成します。
     *
     * テンプレート式中の `haori.pages(...)` と同じ実装です。
     *
     * @param totalPages 総ページ数
     * @param current 現在ページ（0 始まり）
     * @param options 表示調整オプション（window・boundary）
     * @returns 表示要素の配列
     */
    static pages(totalPages: number, current: number, options?: PagesOptions): PageItem[];
    /**
     * `YYYY-MM` 形式の年月文字列に月数を加算します。
     *
     * テンプレート式中の `haori.monthAdd(...)` と同じ実装です。
     *
     * @param value 基準となる年月（`YYYY-MM` 形式）
     * @param delta 加算する月数（負数で過去方向）
     * @returns 加算後の年月（`YYYY-MM` 形式）。不正な入力は空文字
     */
    static monthAdd(value: string | null | undefined, delta: number): string;
    /**
     * 基準月から過去方向へ `count + 1` 個の年月配列を降順で返します。
     *
     * テンプレート式中の `haori.monthRange(...)` と同じ実装です。
     *
     * @param count 基準月から遡る月数（戻り値の要素数は `count + 1`）
     * @param base 基準月（`YYYY-MM` 形式、省略時は現在月）
     * @returns 年月情報の降順配列。不正な入力は空配列
     */
    static monthRange(count: number, base?: string): MonthItem[];
    /**
     * ページレスポンスから表示用サマリーを作ります。
     *
     * テンプレート式中の `haori.pageSummary(...)` と同じ実装です。
     *
     * @param page ページ情報（`number`・`size`・`totalElements`／`totalCount` 等）
     * @param visibleCount 現在表示している件数（省略可）
     * @returns 表示サマリー
     */
    static pageSummary(page: Record<string, unknown> | null | undefined, visibleCount?: number): PageSummary;
    /**
     * 配列から `item[key]` が指定値に一致する最初の要素を返します。
     *
     * テンプレート式中の `haori.findBy(...)` と同じ実装です。比較は文字列化して
     * 行い、一致が無ければ null を返します。
     *
     * @param array 検索対象の配列
     * @param key 比較に使うプロパティ名
     * @param value 一致させたい値（文字列化して比較）
     * @returns 一致した最初の要素。無ければ null
     */
    static findBy(array: unknown, key: string, value: unknown): unknown;
    /**
     * 配列の数値合計を返します。
     *
     * テンプレート式中の `haori.sum(...)` と同じ実装です。`key` 省略時は要素自体を、
     * 指定時は `item[key]` を合計し、数値化できない値は無視します。
     *
     * @param array 集計対象の配列
     * @param key 合計するプロパティ名（省略時は要素自体）
     * @returns 数値の合計。対象が無ければ 0
     */
    static sum(array: unknown, key?: string): number;
    /**
     * 配列から重複を取り除いた新しい配列を返します。
     *
     * テンプレート式中の `haori.distinct(...)` と同じ実装です。`key` 省略時は要素
     * 自体で、指定時は `item[key]` で重複を判定します（比較は文字列化）。
     *
     * @param array 対象の配列
     * @param key 重複判定に使うプロパティ名（省略時は要素自体）
     * @returns 重複排除後の新しい配列。非配列は空配列
     */
    static distinct(array: unknown, key?: string): unknown[];
    /**
     * 配列を `item[key]` ごとのグループへ分けて返します。
     *
     * テンプレート式中の `haori.groupBy(...)` と同じ実装です。戻り値は
     * `{key, items}` の配列で、`data-each` で繰り返してグループ描画できます。
     *
     * @param array 対象の配列
     * @param key グループ分けに使うプロパティ名
     * @returns グループ情報の配列。非配列は空配列
     */
    static groupBy(array: unknown, key: string): GroupItem[];
}
export { Haori }
export default Haori;

/**
 * @fileoverview Haori環境検出機能
 *
 * 実行環境を管理します。
 */
/**
 * Haori.js の実行モードを表します。
 */
export declare type HaoriRuntime = 'embedded' | 'demo';

/**
 * @fileoverview Haori共通ログ機能
 *
 * 開発モード時のみログ出力を行います。
 */
/**
 * ログ出力を管理するクラス
 */
export declare class Log {
    /**
     * 開発モードでのみコンソールに情報を出力します。
     *
     * @param message 出力するメッセージ
     * @param args 追加の引数
     */
    static info(message: string, ...args: unknown[]): void;
    /**
     * 開発モードでのみコンソールに警告を出力します。
     *
     * @param message 出力するメッセージ
     * @param args 追加の引数
     */
    static warn(message: string, ...args: unknown[]): void;
    /**
     * モードに関係なくコンソールにエラーを出力します。
     *
     * @param message 出力するメッセージ
     * @param args 追加の引数
     */
    static error(message: string, ...args: unknown[]): void;
}

/**
 * `monthRange()` が返す1要素分の情報です。
 */
declare interface MonthItem {
    /** 年月（`YYYY-MM` 形式） */
    targetMonth: string;
    /** 表示用ラベル（`YYYY/MM` 形式） */
    label: string;
}

/**
 * `pages()` が返す1要素分の情報です。
 */
declare interface PageItem {
    /** 0 始まりのページ番号。省略記号のときは null */
    page: number | null;
    /** 表示用ラベル。ページ項目は 1 始まりの番号、省略記号は '…' */
    label: number | string;
    /** 現在ページであれば true */
    active: boolean;
    /** 省略記号（…）であれば true */
    ellipsis: boolean;
}

/**
 * @fileoverview テンプレート式から呼び出せる組み込みヘルパー
 *
 * 式中の予約名前空間 `haori` として注入される純粋関数群です。
 * 日時・数値の整形、整数レンジ、ページネーション補助を提供します。
 * いずれも副作用を持たず（DOM・通信・グローバル状態に触れない）、同じ入力に
 * 対して常に同じ結果を返す冪等な関数のため、式の再評価で安全に利用できます。
 */
/**
 * ページネーション補助 `pages()` の動作を調整するオプションです。
 */
declare interface PagesOptions {
    /** 現在ページの前後に表示するページ数（既定 2） */
    window?: number;
    /** 先頭・末尾に常に表示するページ数（既定 1） */
    boundary?: number;
}

/**
 * `pageSummary()` が返すページ表示サマリーです。
 */
declare interface PageSummary {
    /** 表示中の先頭要素の通し番号（1 始まり）。0 件のときは 0 */
    start: number;
    /** 表示中の末尾要素の通し番号（1 始まり）。0 件のときは 0 */
    end: number;
    /** 総件数 */
    total: number;
    /** 総件数が 0 のとき true */
    empty: boolean;
}

/**
 * @fileoverview 汎用非同期キュー機能
 *
 * 任意の処理を非同期でキューイングし、requestAnimationFrameを使用して順次実行します。
 * 各処理はPromiseを返し、完了時の処理を記述できます。
 * DOM操作などの非同期処理に適しています。
 */
/**
 * 非同期キューのデフォルトインスタンス。
 * このインスタンスを使用して、アプリケーション全体でタスクをキューイングできます。
 */
export declare class Queue {
    /** 非同期キューインスタンス */
    private static readonly ASYNC_QUEUE;
    /**
     * タスクをキューに追加します。
     *
     * @param task 実行する処理
     * @param prepend trueの場合はキューの先頭に追加、falseの場合は末尾に追加
     * @returns 処理完了Promise
     */
    static enqueue(task: () => unknown, prepend?: boolean): Promise<unknown>;
    /**
     * 全てのキュー処理が完了するまで待機します。
     */
    static wait(): Promise<void>;
    /**
     * レンダリング（追従して投入されるタスクを含む）が安定して完了するまで待機します。
     *
     * @param maxIterations 無限ループ防止の最大反復回数
     * @returns レンダリングが安定するまで解決されない Promise
     */
    static waitForIdle(maxIterations?: number): Promise<void>;
}

/**
 * `Core.setBindingData()` の任意指定。
 *
 * 値の由来（`kind` と `sequence`）は**呼び出し側が何をしているか**だけを表します。
 * 適用するかどうかの判定は宛先の側（`ElementFragment.canApplyValue()` と
 * `canApplyPath()`）に集約されており、呼び出し側が順序や基準の数値を選ぶことは
 * ありません（`docs/ja/値の供給と権威解決の設計書.md`）。
 */
declare interface SetBindingDataOptions {
    /** 再評価をスキップするフラグメント集合 */
    readonly skipFragments?: ReadonlySet<ElementFragment>;
    /**
     * 直列化中の再帰呼出で即時実行するか。
     *
     * FIFO キューへ積むと現在のワークの完了を待って自己デッドロックする経路
     * （`data-url-param` の再評価や、実行中のワークへ戻すマネージド fetch の bind）
     * だけで `true` にします。
     */
    readonly reentrant?: boolean;
    /**
     * `data-bind` 属性へミラーするか（既定 true）。
     *
     * `_fetch` / `_poll` / 可視範囲のようなエンジン管理変数の高頻度更新では `false` に
     * して全データ直列化を避けます。
     */
    readonly reflectToAttribute?: boolean;
    /**
     * この更新の種別（既定は供給）。
     *
     * 供給は前の編集を上書きし、後の編集に負けます。値の供給ではない内部更新
     * （双方向コミット、`data-url-param` の再評価、エンジン管理変数）は
     * `'nonSupply'` を渡します。
     */
    readonly kind?: ValueChangeKind;
    /**
     * この更新を起こした**操作の**通番。
     *
     * 操作と呼び出しが非同期に離れている経路（リセットの各段、フェッチ応答の反映、
     * 外部属性書き換えの取り込みなど）では、操作が起きた時点で発番した番号を渡します。
     * 呼び出し時点で発番すると、先に起きた操作が後の番号を得て権威が逆転します。
     *
     * **省略した場合は「呼び出し時点が操作の時点である」と解釈**し、保留中の外部
     * 書き換えを先に番号付けしてから発番します（`ElementFragment.nextOperationSequence()`）。
     * 公開 API の直接呼び出し向けの既定です。Haori 内部からの呼び出しは、操作と呼び
     * 出しが離れている以上いずれも明示すべきですが、省略しても安全です（取り込みは
     * バインドワークの実行中には行われないため、ワークの内部から省略しても再入しません）。
     */
    readonly sequence?: number;
    /**
     * この更新のうち、利用者が実際に編集したバインドデータの経路と、その編集が起きた
     * 時点の通番。
     *
     * フォーム全体の収集値を運ぶ双方向コミットが、未編集の欄まで編集の権威を得ない
     * ようにするために渡します（`Form.collectEditedPaths()`）。経路ごとに通番を持つ
     * 理由は `ValueChangeOrigin.editedPaths` を参照してください。
     */
    readonly editedPaths?: ReadonlyMap<string, number>;
    /**
     * 供給でユーザー編集の印を解除するか（既定は供給なら解除する）。
     *
     * 呼び出し側が独自の規則で編集を突き合わせ済みの経路だけ `false` にします
     * （フェッチ応答の反映は `Procedure.reconcileUserEditsForBind()` が、ポーリングと
     * 通常の再取得を区別して解除するため、ここで重ねて解除してはいけません）。
     */
    readonly clearUserEdits?: boolean;
}

/**
 * テキストフラグメント。
 * テキストノードを表現します。
 */
declare class TextFragment extends Fragment {
    /** 未評価のテキスト文字列 */
    private text;
    /** コンテンツ */
    private contents;
    /** 更新スキップフラグ（オブザーバーによる無限ループ対応） */
    private skipMutation;
    /** 直近に描画した文字列 */
    private renderedText;
    /**
     * テキストフラグメントのコンストラクタ。
     * 対象テキストノードの内容を初期化します。
     *
     * @param target 対象テキストノード
     */
    constructor(target: Text);
    /**
     * フラグメントをクローンします。
     *
     * @returns クローンされたフラグメント
     */
    clone(): TextFragment;
    /**
     * フラグメントの対象ノードを取得します。
     *
     * @returns フラグメントの対象ノード
     */
    getTarget(): Text;
    /**
     * テキストに評価式が含まれているかどうかを返します。
     *
     * @returns 評価式を含むなら true
     */
    hasDynamicContent(): boolean;
    /**
     * 評価前の生のテキストを返します。
     *
     * `{{式}}` を展開する前の宣言そのものです。テンプレートが参照している識別子を
     * 静的に調べる用途で使います。
     *
     * @returns 評価前のテキスト
     */
    getRawText(): string;
    /**
     * コンテンツを更新します。
     *
     * @param text テキスト
     * @returns 更新のPromise
     */
    setContent(text: string): Promise<void>;
    /**
     * フラグメントを評価します。
     *
     * @returns 評価結果のPromise
     */
    evaluate(): Promise<void>;
}

/**
 * 値の変化の種別。
 *
 * - `supply`（供給）: 明示的な値の供給。外部からの `data-bind` 書き換え、
 *   `Core.setBindingData()` の直接呼び出し、リセット、`data-{event}-fetch` の応答反映、
 *   コピー、行の要素データ入れ替え。前の編集を上書きし、後の編集に負ける
 * - `edit`（編集）: `change` / `input` による確定。同じ通番では勝つ
 * - `nonSupply`（非供給更新）: 宣言バインドの再評価、`data-url-param` の再評価、
 *   `data-poll` の応答反映、`_poll` / `_fetch` などのエンジン管理変数の更新。
 *   編集には通番によらず負ける
 *
 * 詳細は `docs/ja/値の供給と権威解決の設計書.md` の要件 R1〜R3 / R7 を参照してください。
 */
declare type ValueChangeKind = 'supply' | 'edit' | 'nonSupply';

/**
 * 値の変化の由来（発生順の通番と種別）。
 *
 * 各宛先には「最後に適用された通番より新しい書き込みだけ」を適用します。宛先は
 * 入力欄フラグメントと、要素のバインドデータの経路の 2 種類です。
 */
declare interface ValueChangeOrigin {
    /**
     * その変化を起こした**操作が起きた時点**の通番。
     * 非同期の処理が宛先へ到達した時点で発番すると権威の判定が逆転します。
     */
    readonly sequence: number;
    /** 変化の種別 */
    readonly kind: ValueChangeKind;
    /**
     * この更新のうち、**実際に利用者が編集した**バインドデータの経路と、**その編集が
     * 起きた時点**の通番。
     *
     * `change` / `input` の双方向コミットはフォーム全体の収集値を運ぶため、更新全体を
     * 「編集」として扱うと未編集の欄まで編集の権威を得てしまいます。編集された経路だけ
     * をここで示し、残りは `kind` の種別として判定します。
     *
     * 経路ごとに通番を持つのは、**コミットが起きた時点ではなく編集が起きた時点**で
     * 判定するためです。`change` はフォーカスを外した時点で発火するため、編集より
     * ずっと後になります。コミットの通番で主張すると、編集の後・コミットの前に要求
     * された供給（`data-{event}-reset` など）が「編集の方が新しい」と判定されて棄却
     * され、供給が無かったことになります（仕様「ユーザー編集と宣言バインドの権威」の
     * 「供給は、その供給を起こした操作が起きた時点までの編集を解除し、それより後の
     * 編集は残します」）。
     */
    readonly editedPaths?: ReadonlyMap<string, number>;
}

/**
 * ライブラリのバージョン。
 *
 * リリース時に `package.json` と揃えて更新します（`tests/version.test.ts` が
 * 一致を検査します）。
 */
export declare const version = "0.54.0";

/**
 * すべてのレンダリングタスク（追従投入分を含む）の完了を待ちます。
 *
 * iife グローバルからは `Haori.waitForRenders()`、ESM では
 * `import {waitForRenders} from 'haori'` で利用できます。
 *
 * @return すべてのレンダリングが完了したら解決される Promise
 */
export declare const waitForRenders: () => Promise<void>;

export { }