//#region src/BitList.d.ts
declare class BitList {
  words: Uint32Array;
  size: number;
  constructor(size?: number);
  add(value: boolean): void;
  set(pos: number, value: boolean): void;
  get(pos: number): boolean;
}
//#endregion
//#region src/BitVector.d.ts
declare class BitVector {
  words: Uint32Array;
  sizeInBits: number;
  lb: Uint32Array;
  sb: Uint16Array;
  constructor(words: Uint32Array, sizeInBits: number);
  rank(pos: number, b: boolean): number;
  select(count: number, b: boolean): number;
  private lowerBoundBinarySearchLB;
  private lowerBoundBinarySearchSB;
  nextClearBit(fromIndex: number): number;
  size(): number;
  get(pos: number): boolean;
  toString(): string;
}
//#endregion
//#region src/CharacterConverter.d.ts
declare function han2zen_conv(source: string): string;
declare function zen2han_conv(source: string): string;
declare function hira2kata_conv(source: string): string;
//#endregion
//#region src/LOUDSTrie.d.ts
declare class LOUDSTrie {
  bitVector: BitVector;
  edges: Uint16Array;
  constructor(bitVector: BitVector, edges: Uint16Array);
  reverseLookup(index: number): string;
  parent(x: number): number;
  firstChild(x: number): number;
  traverse(index: number, c: number): number;
  lookup(key: string): number;
  predictiveSearch(index: number): IterableIterator<number>;
  size(): number;
}
//#endregion
//#region src/CompactDictionary.d.ts
declare class CompactDictionary {
  keyTrie: LOUDSTrie;
  valueTrie: LOUDSTrie;
  mappingBitVector: BitVector;
  mapping: Int32Array;
  hasMappingBitList: BitList;
  constructor(buffer: ArrayBuffer);
  private static readTrie;
  private static decode;
  private static createHasMappingBitList;
  search(key: string): IterableIterator<string>;
  predictiveSearch(key: string): IterableIterator<string>;
}
//#endregion
//#region src/CompactDictionaryBuilder.d.ts
declare class CompactDictionaryBuilder {
  static build(dict: Map<string, string[]>): ArrayBuffer;
}
//#endregion
//#region src/CompactHiraganaString.d.ts
declare class CompactHiraganaString {
  static decodeBytes(bytes: Uint8Array): string;
  static decodeByte(c: number): number;
  static encodeString(str: string): Uint8Array;
  static encodeChar(b: number): number;
}
//#endregion
//#region src/DoubleArray.d.ts
declare class DoubleArray {
  base: Int16Array;
  check: Int16Array;
  charConverter: (arg: number) => number;
  charSize: number;
  constructor(base: Int16Array, check: Int16Array, charConverter: (arg: number) => number, charSize: number);
  traverse(n: number, k: number): number;
  lookup(str: string): number;
  commonPrefixSearch(key: string): IterableIterator<number>;
  predictiveSearch(key: string): IterableIterator<number>;
  visitRecursive(n: number): IterableIterator<number>;
}
//#endregion
//#region src/LOUDSTrieBuilder.d.ts
declare class LOUDSTrieBuilder {
  static build(keys: string[]): [LOUDSTrie, Uint32Array];
}
//#endregion
//#region src/RomajiProcessor.d.ts
declare class RomajiPredictiveResult {
  prefix: string;
  suffixes: string[];
  constructor(prefix: string, suffixes: string[]);
}
interface RomajiProcessor {
  romajiToHiragana(romaji: string): string;
  romajiToHiraganaPredictively(romaji: string): RomajiPredictiveResult;
}
//#endregion
//#region src/Migemo.d.ts
type Rxop = [string, string, string, string, string, string, string];
declare class Migemo {
  dict: CompactDictionary | null;
  rxop: Rxop | null;
  processor: RomajiProcessor;
  constructor();
  queryAWord(word: string): string;
  query(word: string): string;
  setDict(dict: CompactDictionary | null): void;
  setRxop(rxop: Rxop | null): void;
  setRomajiProcessor(processor: RomajiProcessor): void;
  parseQuery(query: string): IterableIterator<string>;
}
//#endregion
//#region src/RomajiProcessor1.d.ts
declare class RomanEntry {
  roman: string;
  hiragana: string;
  remain: number;
  index: number;
  constructor(roman: string, hiragana: string, remain: number);
  static _calculateIndex(roman: string, start: number, end: number): number;
  static calculateIndex(roman: string): number;
}
declare class RomajiProcessor1 implements RomajiProcessor {
  private roman_indexes;
  private roman_entries;
  constructor(entries: RomanEntry[]);
  static build(): RomajiProcessor1;
  romajiToHiragana(romaji: string): string;
  findRomanEntryPredicatively(roman: string, offset: number): Set<RomanEntry>;
  romajiToHiraganaPredictively(romaji: string): RomajiPredictiveResult;
}
//#endregion
//#region src/RomajiProcessor2.d.ts
declare class RomajiProcessor2 implements RomajiProcessor {
  trie: DoubleArray;
  hiraganaList: Array<string>;
  remainList: Int8Array;
  constructor(trie: DoubleArray, hiraganaList: string[], remainList: Int8Array);
  static build(): RomajiProcessor2;
  romajiToHiragana(romaji: string): string;
  romajiToHiraganaPredictively(romaji: string): RomajiPredictiveResult;
}
//#endregion
//#region src/TernaryRegexGenerator.d.ts
declare class TernaryRegexNode {
  value: number;
  child: TernaryRegexNode | null;
  left: TernaryRegexNode | null;
  right: TernaryRegexNode | null;
  level: number;
  successor(): TernaryRegexNode;
  predecessor(): TernaryRegexNode;
}
declare class TernaryRegexGenerator {
  or: string;
  beginGroup: string;
  endGroup: string;
  beginClass: string;
  endClass: string;
  newline: string;
  root: TernaryRegexNode | null;
  escapedCharacters: BitList;
  constructor(or: string, beginGroup: string, endGroup: string, beginClass: string, endClass: string, newline: string, escape: string);
  static getDEFAULT(): TernaryRegexGenerator;
  static initializeEscapeCharacters(escape: string): BitList;
  add(word: string): void;
  generateStub(node: TernaryRegexNode | null): string;
  generate(): string;
}
//#endregion
//#region src/utils.d.ts
/**
 * 配列ライクな構造に対して二分探索を実行します。
 * @param a 検索対象の配列ライクな構造
 * @param fromIndex 開始インデックス（含む）
 * @param toIndex 終了インデックス（含まない）
 * @param key 検索する値
 * @returns キーが見つかった場合はそのインデックス、見つからなかった場合は-(挿入位置 + 1)
 */
declare function binarySearch<T>(a: ArrayLike<T>, fromIndex: number, toIndex: number, key: T): number;
/**
 * 32ビット整数内のセットされたビット数を数えます。
 * 効率的なカウントのためにビット操作技術を使用します。
 * @param i ビットを数える対象の整数
 * @returns セットされたビット数（0-32）
 */
declare function bitCount(i: number): number;
/**
 * 32ビット整数内の末尾の0ビット数を返します。
 * 入力が0の場合は64を返します。
 * @param i 分析する整数
 * @returns 末尾の0の数
 */
declare function numberOfTrailingZeros(i: number): number;
//#endregion
export { BitList, BitVector, CompactDictionary, CompactDictionaryBuilder, CompactHiraganaString, DoubleArray, LOUDSTrie, LOUDSTrieBuilder, Migemo, RomajiPredictiveResult, RomajiProcessor, RomajiProcessor1, RomajiProcessor2, RomanEntry, Rxop, TernaryRegexGenerator, binarySearch, bitCount, han2zen_conv, hira2kata_conv, numberOfTrailingZeros, zen2han_conv };
//# sourceMappingURL=jsmigemo.d.cts.map