pub suberror EncodeError {
  EmptyInput
  UnrepresentableChar(Int)
  TooManyCodewords(Int)
  InvalidErrorCorrectionLevel(Int)
  InvalidColumnCount(Int)
  LayoutImpossible(Int, Int)
  TooManyErasures(Int, Int)
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum Compaction {
  Text
  Numeric
  Byte
  Auto
}

pub(all) struct Geometry {
  width_modules : Int
  height_rows : Int
  data_columns : Int
  data_rows : Int
  ec_level : Int
}

pub(all) struct HighLevel {
  codewords : Array[Int]
  modes : Array[Compaction]
  segments : Array[Int]
}

pub(all) struct Symbol {
  codewords : Array[Int]
  columns : Int
  rows : Int
  ec_level : Int
  data_count : Int
  pad_count : Int
}

pub(all) enum TextSubmode {
  Alpha
  Lower
  Mixed
  Punctuation
}

fn base900_to_bytes(words : Array[Int]) -> Array[Int] raise EncodeError

fn base900_to_decimal(base900 : Array[Int]) -> Array[Int]

fn berlekamp_massey(sequence : Array[Int]) -> Array[Int]

fn byte_capacity(count : Int) -> Int

fn byte_count_codewords(count : Int) -> Int

let byte_group_codewords : Int

let byte_group_size : Int

fn bytes_to_base900(bytes : Array[Int]) -> Array[Int] raise EncodeError

let cluster0_patterns : Array[Int]

let cluster1_patterns : Array[Int]

let cluster2_patterns : Array[Int]

fn cluster_pattern(cluster : Int, codeword : Int) -> Int?

fn column_box(column : Int, columns : Int, rows : Int, scale : Int, quiet : Int) -> (Int, Int, Int, Int)

fn consecutive_binary(input : Array[Int], start : Int) -> Int

fn consecutive_digits(input : Array[Int], start : Int) -> Int

fn consecutive_text(input : Array[Int], start : Int) -> Int

fn correct_errors(words : Array[Int], parity_count : Int, erasures : Array[Int]) -> (Array[Int], Array[Int]) raise EncodeError

fn correct_errors_opt(words : Array[Int], parity_count : Int, erasures : Array[Int]) -> (Array[Int], Array[Int])?

fn data_capacity(columns : Int, level : Int) -> Int

fn decimal_chunk_to_base900(digits : Array[Int]) -> Array[Int]

fn decode_byte(words : Array[Int]) -> Array[Int] raise EncodeError

fn decode_high_level(words : Array[Int]) -> Array[Int] raise EncodeError

fn decode_high_level_opt(words : Array[Int]) -> Array[Int]?

fn decode_numeric(words : Array[Int]) -> Array[Int] raise EncodeError

fn decode_text(words : Array[Int]) -> Array[Int] raise EncodeError

fn decode_text_values(values : Array[Int]) -> Array[Int] raise EncodeError

fn encode_byte(input : Array[Int]) -> Array[Int] raise EncodeError

fn encode_byte_segment(input : Array[Int], start : Int, count : Int) -> Array[Int] raise EncodeError

fn encode_bytes_only(input : Array[Int]) -> Array[Int] raise EncodeError

fn encode_high_level(input : Array[Int]) -> HighLevel raise EncodeError

fn encode_high_level_opt(input : Array[Int]) -> HighLevel?

fn encode_numeric(input : Array[Int]) -> Array[Int] raise EncodeError

fn encode_numeric_only(input : Array[Int]) -> Array[Int] raise EncodeError

fn encode_numeric_opt(input : Array[Int]) -> Array[Int]?

fn encode_numeric_segment(input : Array[Int], start : Int, count : Int) -> Array[Int] raise EncodeError

fn encode_text(input : Array[Int]) -> Array[Int] raise EncodeError

fn encode_text_from(input : Array[Int], initial : TextSubmode) -> Array[Int] raise EncodeError

fn encode_text_only(input : Array[Int]) -> Array[Int] raise EncodeError

fn encode_text_opt(input : Array[Int]) -> Array[Int]?

fn encode_text_segment(input : Array[Int], start : Int, count : Int, initial : TextSubmode) -> (Array[Int], TextSubmode) raise EncodeError

fn error_correction(data : Array[Int], level : Int) -> Array[Int] raise EncodeError

fn error_correction_codeword_count(level : Int) -> Int

fn error_locator_of(position : Int, length : Int) -> Int

fn finalize(data : Array[Int], level : Int, columns : Int) -> Symbol raise EncodeError

fn finalize_opt(data : Array[Int], level : Int, columns : Int) -> Symbol?

fn generator_polynomial(degree : Int) -> Array[Int] raise EncodeError

fn geometry_of(symbol : Symbol) -> Geometry

fn inverse929(value : Int) -> Int

fn is_alpha_lower(code : Int) -> Bool

fn is_alpha_upper(code : Int) -> Bool

fn is_byte_group_multiple(count : Int) -> Bool

fn is_digit(code : Int) -> Bool

fn is_error_free(words : Array[Int], parity_count : Int) -> Bool

fn is_mixed(code : Int) -> Bool

fn is_numeric_input(input : Array[Int]) -> Bool

fn is_punctuation(code : Int) -> Bool

fn is_structurally_valid(codewords : Array[Int]) -> Bool

fn is_text_byte(code : Int) -> Bool

fn is_text_code(code : Int) -> Bool

fn is_text_input(input : Array[Int]) -> Bool

fn is_valid_layout(columns : Int, rows : Int) -> Bool

fn is_valid_pattern(pattern : Int, modules : Int) -> Bool

let latch_byte : Int

let latch_byte_padded : Int

let latch_numeric : Int

let latch_text : Int

fn left_row_indicator(row : Int, rows : Int, columns : Int, ec_level : Int) -> Int

fn matrix_row_width(matrix : Array[Array[Int]]) -> Int

fn matrix_to_ascii(matrix : Array[Array[Int]], scale : Int, quiet : Int) -> String

fn matrix_to_svg(matrix : Array[Array[Int]], scale : Int, quiet : Int) -> String

let max_byte_value : Int

let max_codewords : Int

let max_columns : Int

let max_error_correction_level : Int

let max_rows : Int

let min_columns : Int

let min_rows : Int

let mixed_char : Array[Int]

let mixed_value : Array[Int]

fn module_is_bar(pattern : Int, modules : Int, index : Int) -> Bool

let numeric_chunk_size : Int

let pad_codeword : Int

fn pad_codewords(source_codewords : Int, ec_codewords : Int, columns : Int, rows : Int) -> Int?

fn pattern_widths(pattern : Int, modules : Int) -> Array[Int]

fn plan_columns(source_codewords : Int, ec_codewords : Int, min_cols : Int, max_cols : Int, min_r : Int, max_r : Int) -> (Int, Int)?

fn plan_rows(source_codewords : Int, ec_codewords : Int, columns : Int, min_rows : Int) -> Int

fn pow_mod929(base : Int, exponent : Int) -> Int

let punctuation_char : Array[Int]

let punctuation_value : Array[Int]

fn recommended_level(n : Int) -> Int?

fn right_row_indicator(row : Int, rows : Int, columns : Int, ec_level : Int) -> Int

fn round_trip_matches(input : Array[Int], words : Array[Int]) -> Bool

fn row_cluster(row : Int) -> Int

fn row_codeword_count(columns : Int) -> Int

fn row_codewords(codewords : Array[Int], row : Int, columns : Int, rows : Int, ec_level : Int) -> Array[Int]

fn rows_for(source_codewords : Int, ec_codewords : Int, columns : Int) -> Int

let shift_byte : Int

fn smallest_symbol(codewords : Int, ec_level : Int) -> (Int, Int)?

let start_modules : Int

let start_pattern : Int

let start_pattern_modules : Int

let stop_modules : Int

let stop_pattern : Int

let stop_pattern_modules : Int

fn symbol_codeword_capacity(columns : Int, rows : Int) -> Int

fn symbol_matrix(symbol : Symbol) -> Array[Array[Int]] raise EncodeError

fn symbol_modules(columns : Int) -> Int

fn symbol_row_modules(codewords : Array[Int], row : Int, columns : Int, rows : Int, ec_level : Int) -> Array[Int] raise EncodeError

fn symbol_rows(symbol : Symbol) -> Array[Array[Int]]?

fn syndrome_weight(words : Array[Int], parity_count : Int) -> Int

fn syndromes(words : Array[Int], parity_count : Int) -> Array[Int]

let tc_alpha_to_lower : Int

let tc_alpha_to_mixed : Int

let tc_alpha_to_punct : Int

let tc_lower_to_alpha : Int

let tc_lower_to_mixed : Int

let tc_lower_to_punct : Int

let tc_mixed_to_alpha : Int

let tc_mixed_to_lower : Int

let tc_mixed_to_punct_latch : Int

let tc_mixed_to_punct_shift : Int

let tc_punct_to_alpha : Int

let tc_text_pad : Int

fn text_automaton(input : Array[Int], start : Int, count : Int, initial : TextSubmode) -> (Array[Int], TextSubmode) raise EncodeError

fn unpack_text_values(words : Array[Int]) -> Array[Int]

fn utf8_bytes(text : String) -> Array[Int]

fn verify_matrix(matrix : Array[Array[Int]], columns : Int) -> Bool

fn verify_symbol(symbol : Symbol) -> Bool