/**
 * 指定した1要素に対してガードを適用し、Guard API を返す
 * @param {HTMLInputElement|HTMLTextAreaElement} element
 * @param {AttachOptions} [options]
 * @returns {Guard}
 */
declare function attach(element: HTMLInputElement | HTMLTextAreaElement, options?: AttachOptions): Guard;
/**
 * @typedef {Object} GuardGroup
 * @property {() => void} detach - 全部 detach
 * @property {() => boolean} isValid - 全部 valid なら true
 * @property {() => TigError[]} getErrors - 全部のエラーを集約
 * @property {() => Guard[]} getGuards - 個別Guard配列
 */
/**
 * @param {Iterable<HTMLInputElement|HTMLTextAreaElement>} elements
 * @param {AttachOptions} [options]
 * @returns {GuardGroup}
 */
declare function attachAll(elements: Iterable<HTMLInputElement | HTMLTextAreaElement>, options?: AttachOptions): GuardGroup;
type GuardGroup = {
    /**
     * - 全部 detach
     */
    detach: () => void;
    /**
     * - 全部 valid なら true
     */
    isValid: () => boolean;
    /**
     * - 全部のエラーを集約
     */
    getErrors: () => TigError[];
    /**
     * - 個別Guard配列
     */
    getGuards: () => Guard[];
};
/**
 * 対象要素の種別（現在は input と textarea のみ対応）
 */
type ElementKind = "input" | "textarea";
/**
 * ルール実行フェーズ名（パイプラインの固定順）
 * normalize.char → normalize.structure → validate → fix → format
 */
type PhaseName = "normalize.char" | "normalize.structure" | "validate" | "fix" | "format";
/**
 * バリデーションエラー情報を表すオブジェクト
 */
type TigError = {
    /**
     * - エラー識別子（例: "digits.int_overflow"）
     */
    code: string;
    /**
     * - エラーを発生させたルール名
     */
    rule: string;
    /**
     * - 発生したフェーズ
     */
    phase: PhaseName;
    /**
     * - 追加情報（制限値など）
     */
    detail?: any;
};
/**
 * バリデーションがどの評価タイミングから呼び出されたかを表す識別子
 *
 * - "input"  : 入力中の評価（inputイベントなど）
 * - "commit" : 確定時の評価（blurなど）
 */
type ValidateSource = "input" | "commit";
/**
 * バリデーション結果を表すオブジェクト
 * - 各ルールの評価が完了したタイミングでコールバックに渡される
 */
type ValidateResult = {
    /**
     * - この結果を発生させた Guard インスタンス
     */
    guard: Guard;
    /**
     * - 評価が実行されたタイミング（input / commit）
     */
    source: ValidateSource;
    /**
     * - 発生したエラー一覧
     */
    errors: TigError[];
    /**
     * - エラーが存在しない場合は true
     */
    isValid: boolean;
};
/**
 * setValue で設定できる値型
 * - number は String に変換して設定する
 * - null/undefined は空文字として扱う
 */
type SetValueInput = string | number | null | undefined;
/**
 * setValue 実行モード
 * - "commit"  確定評価まで実行 normalize→validate→fix→format
 * - "input"   入力中評価のみ実行 normalize→validate
 * - "none"    評価は実行しない 値だけを反映
 *
 * 既定値は "commit"
 */
type SetValueMode = "none" | "input" | "commit";
/**
 * attach() が返す公開API（利用者が触れる最小インターフェース）
 */
type Guard = {
    /**
     * - ガード解除（イベント削除・swap復元）
     */
    detach: () => void;
    /**
     * - 現在エラーが無いかどうか
     */
    isValid: () => boolean;
    /**
     * - エラー一覧を取得
     */
    getErrors: () => TigError[];
    /**
     * - 送信用の正規化済み値を取得
     */
    getRawValue: () => string;
    /**
     * - ユーザーが実際に操作している要素の値を取得
     */
    getDisplayValue: () => string;
    /**
     * - 送信用の正規化済み値の要素
     */
    getRawElement: () => HTMLInputElement | HTMLTextAreaElement;
    /**
     * - ユーザーが実際に操作している要素（swap時はdisplay専用）
     */
    getDisplayElement: () => HTMLInputElement | HTMLTextAreaElement;
    /**
     * 入力中評価を手動実行 normalize→validate
     */
    evaluate: () => void;
    /**
     * 確定評価を手動実行 normalize→validate→fix→format
     */
    commit: () => void;
    setValue: (value: SetValueInput, mode?: SetValueMode) => void;
};
/**
 * 各ルールに渡される実行コンテキスト
 * - DOM参照や状態、エラー登録用関数などをまとめたもの
 */
type GuardContext = {
    /**
     * - 元の要素（swap時はraw側）
     */
    hostElement: HTMLElement;
    /**
     * - ユーザーが操作する表示要素
     */
    displayElement: HTMLElement;
    /**
     * - 送信用hidden要素（swap時のみ）
     */
    rawElement: HTMLInputElement | HTMLTextAreaElement | null;
    /**
     * - 要素種別（input / textarea）
     */
    kind: ElementKind;
    /**
     * - warnログを出すかどうか
     */
    warn: boolean;
    /**
     * - エラー時に付与するclass名
     */
    invalidClass: string;
    /**
     * - IME変換中かどうか
     */
    composing: boolean;
    /**
     * - 直前の入力操作種別（insertText / insertFromPaste / insertCompositionText 等）
     */
    inputType: string | null;
    /**
     * - 挿入前の全文字列（置換範囲は除去済み）
     */
    beforeText: string;
    /**
     * - 挿入位置/置換開始位置（selectionStart）
     */
    replaceStart: number;
    /**
     * - 置換終了位置（selectionEnd）
     */
    replaceEnd: number;
    /**
     * - 挿入された文字列
     */
    insertedText: string;
    /**
     * - 挿入後の全文字列（後で代入する）
     */
    afterText: string;
    /**
     * - エラーを登録する関数
     */
    pushError: (e: TigError) => void;
    /**
     * - 入力を直前の受理値へ巻き戻す要求
     */
    requestRevert: (req: RevertRequest) => void;
};
/**
 * 1つの入力制御ルール定義
 * - 各フェーズの処理を必要に応じて実装する
 */
type Rule = {
    /**
     * - ルール名（識別用）
     */
    name: string;
    /**
     * - 適用可能な要素種別
     */
    targets: ("input" | "textarea")[];
    /**
     * - 文字単位の正規化（全角→半角など）
     */
    normalizeChar?: (value: string, ctx: GuardContext) => string;
    /**
     * - 構造の正規化（-位置修正など）
     */
    normalizeStructure?: (value: string, ctx: GuardContext) => string;
    /**
     * - エラー判定（値は変更しない）
     */
    validate?: (value: string, ctx: GuardContext) => void;
    /**
     * - 確定時の穏やか補正（切り捨て等）
     */
    fix?: (value: string, ctx: GuardContext) => string;
    /**
     * - 表示整形（カンマ付与など）
     */
    format?: (value: string, ctx: GuardContext) => string;
};
/**
 * 表示値(display)と内部値(raw)の分離設定
 */
type SeparateValueOptions = {
    /**
     * - "auto": format系ルールがある場合のみ自動でswapする（既定）
     * - "swap": 常にswapする（inputのみ対応）
     * - "off": 分離しない（displayとrawを同一に扱う）
     */
    mode?: "auto" | "swap" | "off";
};
/**
 * attach() に渡す設定オプション
 */
type AttachOptions = {
    /**
     * - 適用するルール配列（順番がフェーズ内実行順になる）
     */
    rules?: Rule[];
    /**
     * - 非対応ルールなどを console.warn するか
     */
    warn?: boolean;
    /**
     * - エラー時に付けるclass名
     */
    invalidClass?: string;
    /**
     * - 表示値と内部値の分離設定
     */
    separateValue?: SeparateValueOptions;
    /**
     * - 記録する履歴の最大件数
     */
    historySize?: number;
    /**
     * - 評価完了時の通知（input/commitごと）
     */
    onValidate?: (result: ValidateResult) => void;
    /**
     * - 入力時に値が変更されていた場合の通知
     */
    onInput?: (result: Guard) => void;
    /**
     * - フォーカスが外れた値が変更されていた場合の通知
     */
    onChange?: (result: Guard) => void;
};
/**
 * revert要求（入力を巻き戻す指示）
 */
type RevertRequest = {
    /**
     * - ルール名や理由（例: "digits.int_overflow"）
     */
    reason: string;
    /**
     * - デバッグ用の詳細
     */
    detail?: any;
};

/**
 * numeric ルールのオプション
 * @typedef {Object} NumericRuleOptions
 * @property {boolean} [allowFullWidth=true] - 全角数字/記号を許可して半角へ正規化する
 * @property {boolean} [allowMinus=false] - マイナス記号を許可する（先頭のみ）
 * @property {boolean} [allowDecimal=false] - 小数点を許可する（1つだけ）
 * @property {boolean} [allowEmpty=true] - 空文字を許可するか
 */
/**
 * 数値入力向けルールを生成する
 * - normalize.char: 全角→半角、記号統一、不要文字の除去
 * - normalize.structure: 「-は先頭のみ」「.は1つだけ」など構造を整える
 * - fix: 確定時（blur）に「-」「.」「-.」や末尾の「.」を空/削除にする
 *
 * @param {NumericRuleOptions} [options]
 * @returns {Rule}
 */
declare function numeric(options?: NumericRuleOptions): Rule;
declare namespace numeric {
    /**
     * datasetから numeric ルールを生成する
     * - data-tig-rules-numeric が無ければ null
     * - オプションは data-tig-rules-numeric-xxx から読む
     *
     * 対応する data 属性（dataset 名）
     * - data-tig-rules-numeric                       -> dataset.tigRulesNumeric
     * - data-tig-rules-numeric-allow-full-width      -> dataset.tigRulesNumericAllowFullWidth
     * - data-tig-rules-numeric-allow-minus           -> dataset.tigRulesNumericAllowMinus
     * - data-tig-rules-numeric-allow-decimal         -> dataset.tigRulesNumericAllowDecimal
     * - data-tig-rules-numeric-allow-empty           -> dataset.tigRulesNumericAllowEmpty
     *
     * @param {DOMStringMap} dataset
     * @param {HTMLInputElement|HTMLTextAreaElement} _el
     * @returns {Rule|null}
     */
    function fromDataset(dataset: DOMStringMap, _el: HTMLInputElement | HTMLTextAreaElement): Rule | null;
}
/**
 * numeric ルールのオプション
 */
type NumericRuleOptions = {
    /**
     * - 全角数字/記号を許可して半角へ正規化する
     */
    allowFullWidth?: boolean;
    /**
     * - マイナス記号を許可する（先頭のみ）
     */
    allowMinus?: boolean;
    /**
     * - 小数点を許可する（1つだけ）
     */
    allowDecimal?: boolean;
    /**
     * - 空文字を許可するか
     */
    allowEmpty?: boolean;
};

/**
 * digits ルールを生成する
 * @param {DigitsRuleOptions} [options]
 * @returns {Rule}
 */
declare function digits(options?: DigitsRuleOptions): Rule;
declare namespace digits {
    /**
     * datasetから digits ルールを生成する
     * - data-tig-rules-digits が無ければ null
     * - オプションは data-tig-rules-digits-xxx から読む
     *
     * 対応する data 属性（dataset 名）
     * - data-tig-rules-digits                          -> dataset.tigRulesDigits
     * - data-tig-rules-digits-int                      -> dataset.tigRulesDigitsInt
     * - data-tig-rules-digits-frac                     -> dataset.tigRulesDigitsFrac
     * - data-tig-rules-digits-count-leading-zeros      -> dataset.tigRulesDigitsCountLeadingZeros
     * - data-tig-rules-digits-fix-int-on-blur          -> dataset.tigRulesDigitsFixIntOnBlur
     * - data-tig-rules-digits-fix-frac-on-blur         -> dataset.tigRulesDigitsFixFracOnBlur
     * - data-tig-rules-digits-mode-int                 -> dataset.tigRulesDigitsModeInt
     * - data-tig-rules-digits-mode-frac                -> dataset.tigRulesDigitsModeFrac
     * - data-tig-rules-digits-force-frac-on-blur       -> dataset.tigRulesDigitsForceFracOnBlur
     *
     * @param {DOMStringMap} dataset
     * @param {HTMLInputElement|HTMLTextAreaElement} _el
     * @returns {Rule|null}
     */
    function fromDataset(dataset: DOMStringMap, _el: HTMLInputElement | HTMLTextAreaElement): Rule | null;
}
/**
 * digits ルールのオプション
 */
type DigitsRuleOptions = {
    /**
     * - 整数部の最大桁数（省略可）
     */
    int?: number;
    /**
     * - 小数部の最大桁数（省略可）
     */
    frac?: number;
    /**
     * - 整数部の先頭ゼロを桁数に含める
     */
    countLeadingZeros?: boolean;
    /**
     * - blur時の整数部補正
     */
    fixIntOnBlur?: "none" | "truncateLeft" | "truncateRight" | "clamp";
    /**
     * - blur時の小数部補正
     */
    fixFracOnBlur?: "none" | "truncate" | "round";
    /**
     * - 整数部が最大桁を超える入力の挙動
     */
    modeInt?: "block" | "error";
    /**
     * - 小数部が最大桁を超える入力の挙動
     */
    modeFrac?: "block" | "error";
    /**
     * - blur時に小数部を必ず表示（frac桁まで0埋め）
     */
    forceFracOnBlur?: boolean;
};

/**
 * The script is part of TextInputGuard.
 *
 * AUTHOR:
 *  natade-jp (https://github.com/natade-jp)
 *
 * LICENSE:
 *  The MIT license https://opensource.org/licenses/MIT
 */
/**
 * カンマ付与ルール
 * - blur時のみ整数部に3桁区切りカンマを付与する
 * @returns {Rule}
 */
declare function comma(): Rule;
declare namespace comma {
    /**
     * datasetから comma ルールを生成する
     * - data-tig-rules-comma が無ければ null
     *
     * 対応する data 属性（dataset 名）
     * - data-tig-rules-comma -> dataset.tigRulesComma
     *
     * @param {DOMStringMap} dataset
     * @param {HTMLInputElement|HTMLTextAreaElement} _el
     * @returns {Rule|null}
     */
    function fromDataset(dataset: DOMStringMap, _el: HTMLInputElement | HTMLTextAreaElement): Rule | null;
}

/**
 * ASCII入力欄に日本語IMEで入った文字をASCIIへ矯正する
 *
 * 注意:
 * - これは「半角化」ではなく「IMEオフ入力相当への寄せ」
 * - ascii() とは責務が異なる
 *
 * @returns {Rule}
 */
declare function imeOff(): Rule;
declare namespace imeOff {
    /**
     * dataset から imeOff ルールを生成する
     *
     * 対応する data 属性
     * - data-tig-rules-ime-off
     *
     * @param {DOMStringMap} dataset
     * @param {HTMLInputElement|HTMLTextAreaElement} _el
     * @returns {Rule|null}
     */
    function fromDataset(dataset: DOMStringMap, _el: HTMLInputElement | HTMLTextAreaElement): Rule | null;
}

/**
 * kana ルールのオプション
 * @typedef {Object} KanaRuleOptions
 * @property {"katakana-full"|"katakana-half"|"hiragana"} [target="katakana-full"] - 統一先
 * @property {boolean} [nfkc=true] - 事前に Unicode NFKC 正規化を行う（合体文字などを正規化）
 */
/**
 * kana ルールを生成する
 * @param {KanaRuleOptions} [options]
 * @returns {Rule}
 */
declare function kana(options?: KanaRuleOptions): Rule;
declare namespace kana {
    /**
     * datasetから kana ルールを生成する
     * - data-tig-rules-kana が無ければ null
     * - オプションは data-tig-rules-kana-xxx から読む
     *
     * 対応する data 属性（dataset 名）
     * - data-tig-rules-kana               -> dataset.tigRulesKana
     * - data-tig-rules-kana-target        -> dataset.tigRulesKanaTarget
     * - data-tig-rules-kana-nfkc          -> dataset.tigRulesKanaNfkc
     *
     * @param {DOMStringMap} dataset
     * @param {HTMLInputElement|HTMLTextAreaElement} _el
     * @returns {Rule|null}
     */
    function fromDataset(dataset: DOMStringMap, _el: HTMLInputElement | HTMLTextAreaElement): Rule | null;
}
/**
 * kana ルールのオプション
 */
type KanaRuleOptions = {
    /**
     * - 統一先
     */
    target?: "katakana-full" | "katakana-half" | "hiragana";
    /**
     * - 事前に Unicode NFKC 正規化を行う（合体文字などを正規化）
     */
    nfkc?: boolean;
};

/**
 * ascii ルールのオプション
 * @typedef {Object} AsciiRuleOptions
 * @property {"none"|"upper"|"lower"} [case] - 英字の大文字/小文字統一
 */
/**
 * ascii ルールを生成する
 * - 全角英数字・記号・全角スペースを半角へ正規化する
 * - 必要に応じて英字を大文字/小文字へ統一
 *
 * @param {AsciiRuleOptions} [options]
 * @returns {Rule}
 */
declare function ascii(options?: AsciiRuleOptions): Rule;
declare namespace ascii {
    /**
     * datasetから ascii ルールを生成する
     *
     * 対応する data 属性
     * - data-tig-rules-ascii
     * - data-tig-rules-ascii-case   ("none" | "upper" | "lower")
     *
     * @param {DOMStringMap} dataset
     * @param {HTMLInputElement|HTMLTextAreaElement} _el
     * @returns {Rule|null}
     */
    function fromDataset(dataset: DOMStringMap, _el: HTMLInputElement | HTMLTextAreaElement): Rule | null;
}
/**
 * ascii ルールのオプション
 */
type AsciiRuleOptions = {
    /**
     * - 英字の大文字/小文字統一
     */
    case?: "none" | "upper" | "lower";
};

/**
 * filter ルールを生成する
 * @param {FilterRuleOptions} [options]
 * @returns {Rule}
 */
declare function filter(options?: FilterRuleOptions): Rule;
declare namespace filter {
    /**
     * datasetから filter ルールを生成する
     * - data-tig-rules-filter が無ければ null
     *
     * 対応する data 属性（dataset 名）
     * - data-tig-rules-filter               -> dataset.tigRulesFilter
     * - data-tig-rules-filter-mode          -> dataset.tigRulesFilterMode
     * - data-tig-rules-filter-category      -> dataset.tigRulesFilterCategory ("a,b,c")
     * - data-tig-rules-filter-allow         -> dataset.tigRulesFilterAllow
     * - data-tig-rules-filter-allow-flags   -> dataset.tigRulesFilterAllowFlags
     * - data-tig-rules-filter-deny          -> dataset.tigRulesFilterDeny
     * - data-tig-rules-filter-deny-flags    -> dataset.tigRulesFilterDenyFlags
     *
     * @param {DOMStringMap} dataset
     * @param {HTMLInputElement|HTMLTextAreaElement} _el
     * @returns {Rule|null}
     */
    function fromDataset(dataset: DOMStringMap, _el: HTMLInputElement | HTMLTextAreaElement): Rule | null;
}
/**
 * filter ルールのオプション
 * - category は和集合で扱う（複数指定OK）
 * - allow は追加許可（和集合）
 * - deny は除外（差集合）
 *
 * allowed = (category の和集合 ∪ allow) − deny
 */
type FilterRuleOptions = {
    /**
     * - 不要文字を入力中した場合の挙動
     */
    mode?: "block" | "error";
    /**
     * - カテゴリ（配列）
     */
    category?: FilterCategory[];
    /**
     * - 追加で許可する正規表現（1文字にマッチさせる想定）
     */
    allow?: RegExp | string;
    /**
     * - allow が文字列のときの flags（"iu" など。g/y は無視）
     */
    allowFlags?: string;
    /**
     * - 除外する正規表現（1文字にマッチさせる想定）
     */
    deny?: RegExp | string;
    /**
     * - deny が文字列のときの flags（"iu" など。g/y は無視）
     */
    denyFlags?: string;
};
/**
 * filter ルールのカテゴリ名
 *
 * - "digits"         : ASCII 数字 (0-9)
 * - "alpha-upper"    : ASCII 英字大文字 (A-Z)
 * - "alpha-lower"    : ASCII 英字小文字 (a-z)
 * - "ascii"          : ASCII 可視文字 + スペース含む (U+0020–U+007E)
 * - "hiragana"       : ひらがな (U+3040–U+309F)
 * - "katakana-full"  : 全角カタカナ (U+30A0–U+30FF)
 * - "katakana-half"  : 半角カタカナ (U+FF65–U+FF9F)
 * - "bmp-only"       : BMP のみ許可（U+0000–U+FFFF、サロゲートペア、補助平面禁止）
 * - "sjis-only"      : 正規 Shift_JIS（JIS X 0208 + 1バイト領域）のみ許可
 * - "cp932-only"     : Windows-31J (CP932) でエンコード可能な文字のみ許可
 * - "single-codepoint-only" : 単一コードポイントのみ許可（結合文字や異体字セレクタを含まない）
 */
type FilterCategory = "digits" | "alpha-upper" | "alpha-lower" | "ascii" | "hiragana" | "katakana-full" | "katakana-half" | "bmp-only" | "sjis-only" | "cp932-only" | "single-codepoint-only";

/**
 * length ルールを生成する
 * @param {LengthRuleOptions} [options]
 * @returns {Rule}
 */
declare function length(options?: LengthRuleOptions): Rule;
declare namespace length {
    /**
     * datasetから length ルールを生成する
     * - data-tig-rules-length が無ければ null
     * - オプションは data-tig-rules-length-xxx から読む
     *
     * 対応する data 属性（dataset 名）
     * - data-tig-rules-length                     -> dataset.tigRulesLength
     * - data-tig-rules-length-max                 -> dataset.tigRulesLengthMax
     * - data-tig-rules-length-mode                -> dataset.tigRulesLengthMode
     * - data-tig-rules-length-unit                -> dataset.tigRulesLengthUnit
     *
     * @param {DOMStringMap} dataset
     * @param {HTMLInputElement|HTMLTextAreaElement} _el
     * @returns {Rule|null}
     */
    function fromDataset(dataset: DOMStringMap, _el: HTMLInputElement | HTMLTextAreaElement): Rule | null;
}
/**
 * length ルールのオプション
 */
type LengthRuleOptions = {
    /**
     * - 最大長（グラフェム数）。未指定なら制限なし
     */
    max?: number;
    /**
     * - 入力中に最大長を超えたときの挙動
     */
    mode?: "block" | "error";
    /**
     * - 長さの単位
     */
    unit?: "grapheme" | "utf-16" | "utf-32";
};

/**
 * width ルールのオプション
 * @typedef {Object} WidthRuleOptions
 * @property {number} [max] - 最大長（全角は2, 半角は1）
 * @property {"block"|"error"} [mode="block"] - 入力中に最大長を超えたときの挙動
 */
/**
 * width ルールを生成する
 * @param {WidthRuleOptions} [options]
 * @returns {Rule}
 */
declare function width(options?: WidthRuleOptions): Rule;
declare namespace width {
    /**
     * datasetから length ルールを生成する
     * - data-tig-rules-length が無ければ null
     * - オプションは data-tig-rules-length-xxx から読む
     *
     * 対応する data 属性（dataset 名）
     * - data-tig-rules-length                     -> dataset.tigRulesWidth
     * - data-tig-rules-length-max                 -> dataset.tigRulesWidthMax
     * - data-tig-rules-length-mode                -> dataset.tigRulesWidthMode
     *
     * @param {DOMStringMap} dataset
     * @param {HTMLInputElement|HTMLTextAreaElement} _el
     * @returns {Rule|null}
     */
    function fromDataset(dataset: DOMStringMap, _el: HTMLInputElement | HTMLTextAreaElement): Rule | null;
}
/**
 * width ルールのオプション
 */
type WidthRuleOptions = {
    /**
     * - 最大長（全角は2, 半角は1）
     */
    max?: number;
    /**
     * - 入力中に最大長を超えたときの挙動
     */
    mode?: "block" | "error";
};

/**
 * bytes ルールを生成する
 * @param {BytesRuleOptions} [options]
 * @returns {Rule}
 */
declare function bytes(options?: BytesRuleOptions): Rule;
declare namespace bytes {
    /**
     * datasetから bytes ルールを生成する
     * - data-tig-rules-bytes が無ければ null
     * - オプションは data-tig-rules-bytes-xxx から読む
     *
     * 対応する data 属性（dataset 名）
     * - data-tig-rules-bytes                     -> dataset.tigRulesBytes
     * - data-tig-rules-bytes-max                 -> dataset.tigRulesBytesMax
     * - data-tig-rules-bytes-mode                -> dataset.tigRulesBytesMode
     * - data-tig-rules-bytes-unit                -> dataset.tigRulesBytesUnit
     * - data-tig-rules-bytes-newline             -> dataset.tigRulesBytesNewline
     *
     * @param {DOMStringMap} dataset
     * @param {HTMLInputElement|HTMLTextAreaElement} _el
     * @returns {Rule|null}
     */
    function fromDataset(dataset: DOMStringMap, _el: HTMLInputElement | HTMLTextAreaElement): Rule | null;
}
/**
 * bytes ルールのオプション
 */
type BytesRuleOptions = {
    /**
     * - バイト数。未指定なら制限なし
     */
    max?: number;
    /**
     * - 入力中に最大長を超えたときの挙動
     */
    mode?: "block" | "error";
    /**
     * - サイズの単位(sjis系を使用する場合はfilterも必須)
     */
    unit?: "utf-8" | "utf-16" | "utf-32" | "sjis" | "cp932";
    /**
     * - 改行の扱い(バイト数計算に影響あり)
     */
    newline?: "\n" | "\r" | "\r\n";
};

/**
 * The script is part of TextInputGuard.
 *
 * AUTHOR:
 *  natade-jp (https://github.com/natade-jp)
 *
 * LICENSE:
 *  The MIT license https://opensource.org/licenses/MIT
 */
/**
 * prefix ルールのオプション
 * @typedef {Object} PrefixRuleOptions
 * @property {string} text - 先頭に付ける文字列
 * @property {boolean} [showWhenEmpty=false] - 値が空でも表示するか
 */
/**
 * 先頭装飾（prefix）ルール
 * - 表示用として先頭に文字列を付与する
 * - 手動入力された同文字列は normalizeStructure で除去する
 *
 * @param {PrefixRuleOptions} options
 * @returns {Rule}
 */
declare function prefix(options: PrefixRuleOptions): Rule;
declare namespace prefix {
    /**
     * datasetから prefix ルールを生成する
     * - data-tig-rules-prefix が無ければ null
     *
     * 対応する data 属性（dataset 名）
     * - data-tig-rules-prefix                  -> dataset.tigRulesPrefix
     * - data-tig-rules-prefix-text             -> dataset.tigRulesPrefixText
     * - data-tig-rules-prefix-show-when-empty  -> dataset.tigRulesPrefixShowWhenEmpty
     *
     * @param {DOMStringMap} dataset
     * @param {HTMLInputElement|HTMLTextAreaElement} _el
     * @returns {Rule|null}
     */
    function fromDataset(dataset: DOMStringMap, _el: HTMLInputElement | HTMLTextAreaElement): Rule | null;
}
/**
 * prefix ルールのオプション
 */
type PrefixRuleOptions = {
    /**
     * - 先頭に付ける文字列
     */
    text: string;
    /**
     * - 値が空でも表示するか
     */
    showWhenEmpty?: boolean;
};

/**
 * The script is part of TextInputGuard.
 *
 * AUTHOR:
 *  natade-jp (https://github.com/natade-jp)
 *
 * LICENSE:
 *  The MIT license https://opensource.org/licenses/MIT
 */
/**
 * suffix ルールのオプション
 * @typedef {Object} SuffixRuleOptions
 * @property {string} text - 末尾に付ける文字列
 * @property {boolean} [showWhenEmpty=false] - 値が空でも表示するか
 */
/**
 * 末尾装飾（suffix）ルール
 * - 表示用として末尾に文字列を付与する
 * - 手動入力された同文字列は normalizeStructure で除去する
 *
 * @param {SuffixRuleOptions} options
 * @returns {Rule}
 */
declare function suffix(options: SuffixRuleOptions): Rule;
declare namespace suffix {
    /**
     * datasetから suffix ルールを生成する
     * - data-tig-rules-suffix が無ければ null
     *
     * 対応する data 属性（dataset 名）
     * - data-tig-rules-suffix                  -> dataset.tigRulesSuffix
     * - data-tig-rules-suffix-text             -> dataset.tigRulesSuffixText
     * - data-tig-rules-suffix-show-when-empty  -> dataset.tigRulesSuffixShowWhenEmpty
     *
     * @param {DOMStringMap} dataset
     * @param {HTMLInputElement|HTMLTextAreaElement} _el
     * @returns {Rule|null}
     */
    function fromDataset(dataset: DOMStringMap, _el: HTMLInputElement | HTMLTextAreaElement): Rule | null;
}
/**
 * suffix ルールのオプション
 */
type SuffixRuleOptions = {
    /**
     * - 末尾に付ける文字列
     */
    text: string;
    /**
     * - 値が空でも表示するか
     */
    showWhenEmpty?: boolean;
};

/**
 * The script is part of TextInputGuard.
 *
 * AUTHOR:
 *  natade-jp (https://github.com/natade-jp)
 *
 * LICENSE:
 *  The MIT license https://opensource.org/licenses/MIT
 */
/**
 * トリムするルール
 * @returns {Rule}
 */
declare function trim(): Rule;
declare namespace trim {
    /**
     * datasetから trim ルールを生成する
     * - data-tig-rules-trim が無ければ null
     *
     * 対応する data 属性（dataset 名）
     * - data-tig-rules-trim -> dataset.tigRulesTrim
     *
     * @param {DOMStringMap} dataset
     * @param {HTMLInputElement|HTMLTextAreaElement} _el
     * @returns {Rule|null}
     */
    function fromDataset(dataset: DOMStringMap, _el: HTMLInputElement | HTMLTextAreaElement): Rule | null;
}

declare function autoAttach(root?: Document | DocumentFragment | ShadowRoot | Element): GuardGroup;
declare namespace rules {
    export { numeric };
    export { digits };
    export { comma };
    export { imeOff };
    export { kana };
    export { ascii };
    export { filter };
    export { length };
    export { width };
    export { bytes };
    export { prefix };
    export { suffix };
    export { trim };
}
/**
 * バージョン（ビルド時に置換したいならここを差し替える）
 * 例: rollup replace で "__VERSION__" を package.json の version に置換
 */
declare const version: any;
declare namespace TextInputGuard {
    export { attach };
    export { attachAll };
    export { autoAttach };
    export { rules };
    export { numeric };
    export { digits };
    export { comma };
    export { imeOff };
    export { kana };
    export { ascii };
    export { filter };
    export { length };
    export { width };
    export { bytes };
    export { prefix };
    export { suffix };
    export { trim };
    export { version };
}

export { TextInputGuard, ascii, attach, attachAll, autoAttach, bytes, comma, digits, filter, imeOff, kana, length, numeric, prefix, rules, suffix, trim, version, width };