// Autogenerated by jnigen. DO NOT EDIT!

// ignore_for_file: annotate_overrides
// ignore_for_file: camel_case_extensions
// ignore_for_file: camel_case_types
// ignore_for_file: constant_identifier_names
// ignore_for_file: doc_directive_unknown
// ignore_for_file: file_names
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: no_leading_underscores_for_local_identifiers
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: overridden_fields
// ignore_for_file: unnecessary_cast
// ignore_for_file: unused_element
// ignore_for_file: unused_field
// ignore_for_file: unused_import
// ignore_for_file: unused_local_variable
// ignore_for_file: unused_shown_name

import "dart:isolate" show ReceivePort;
import "dart:ffi" as ffi;
import "package:jni/internal_helpers_for_jnigen.dart";
import "package:jni/jni.dart" as jni;

// Auto-generated initialization code.

final ffi.Pointer<T> Function<T extends ffi.NativeType>(String sym) jniLookup =
    ProtectedJniExtensions.initGeneratedLibrary("android_utils");

/// from: androidx.emoji2.text.EmojiCompat$CodepointSequenceMatchResult
class EmojiCompat_CodepointSequenceMatchResult extends jni.JObject {
  @override
  late final jni.JObjType<EmojiCompat_CodepointSequenceMatchResult> $type =
      type;

  EmojiCompat_CodepointSequenceMatchResult.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type = $EmojiCompat_CodepointSequenceMatchResultType();
}

final class $EmojiCompat_CodepointSequenceMatchResultType
    extends jni.JObjType<EmojiCompat_CodepointSequenceMatchResult> {
  const $EmojiCompat_CodepointSequenceMatchResultType();

  @override
  String get signature =>
      r"Landroidx/emoji2/text/EmojiCompat$CodepointSequenceMatchResult;";

  @override
  EmojiCompat_CodepointSequenceMatchResult fromReference(
          jni.JReference reference) =>
      EmojiCompat_CodepointSequenceMatchResult.fromReference(reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode => ($EmojiCompat_CodepointSequenceMatchResultType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType ==
            ($EmojiCompat_CodepointSequenceMatchResultType) &&
        other is $EmojiCompat_CodepointSequenceMatchResultType;
  }
}

/// from: androidx.emoji2.text.EmojiCompat$Config
///
/// Configuration class for EmojiCompat. Changes to the values will be ignored after
/// \#init(Config) is called.
///@see \#init(EmojiCompat.Config)
class EmojiCompat_Config extends jni.JObject {
  @override
  late final jni.JObjType<EmojiCompat_Config> $type = type;

  EmojiCompat_Config.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type = $EmojiCompat_ConfigType();
  static final _new0 = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat_Config__new0")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: protected void <init>(androidx.emoji2.text.EmojiCompat.MetadataRepoLoader metadataLoader)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Default constructor.
  ///@param metadataLoader MetadataRepoLoader instance, cannot be {@code null}
  factory EmojiCompat_Config(
    EmojiCompat_MetadataRepoLoader metadataLoader,
  ) {
    return EmojiCompat_Config.fromReference(
        _new0(metadataLoader.reference.pointer).reference);
  }

  static final _registerInitCallback = jniLookup<
              ffi.NativeFunction<
                  jni.JniResult Function(
                      ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat_Config__registerInitCallback")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public androidx.emoji2.text.EmojiCompat.Config registerInitCallback(androidx.emoji2.text.EmojiCompat.InitCallback initCallback)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Registers an initialization callback.
  ///@param initCallback the initialization callback to register, cannot be {@code null}
  ///@return EmojiCompat.Config instance
  EmojiCompat_Config registerInitCallback(
    EmojiCompat_InitCallback initCallback,
  ) {
    return _registerInitCallback(
            reference.pointer, initCallback.reference.pointer)
        .object(const $EmojiCompat_ConfigType());
  }

  static final _unregisterInitCallback = jniLookup<
              ffi.NativeFunction<
                  jni.JniResult Function(
                      ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat_Config__unregisterInitCallback")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public androidx.emoji2.text.EmojiCompat.Config unregisterInitCallback(androidx.emoji2.text.EmojiCompat.InitCallback initCallback)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Unregisters a callback that was added before.
  ///@param initCallback the initialization callback to be removed, cannot be {@code null}
  ///@return EmojiCompat.Config instance
  EmojiCompat_Config unregisterInitCallback(
    EmojiCompat_InitCallback initCallback,
  ) {
    return _unregisterInitCallback(
            reference.pointer, initCallback.reference.pointer)
        .object(const $EmojiCompat_ConfigType());
  }

  static final _setReplaceAll = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Uint8)>>("EmojiCompat_Config__setReplaceAll")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>, int)>();

  /// from: public androidx.emoji2.text.EmojiCompat.Config setReplaceAll(boolean replaceAll)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Determines whether EmojiCompat should replace all the emojis it finds with the
  /// EmojiSpans. By default EmojiCompat tries its best to understand if the system already
  /// can render an emoji and do not replace those emojis.
  ///@param replaceAll replace all emojis found with EmojiSpans
  ///@return EmojiCompat.Config instance
  EmojiCompat_Config setReplaceAll(
    bool replaceAll,
  ) {
    return _setReplaceAll(reference.pointer, replaceAll ? 1 : 0)
        .object(const $EmojiCompat_ConfigType());
  }

  static final _setUseEmojiAsDefaultStyle = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Uint8)>>("EmojiCompat_Config__setUseEmojiAsDefaultStyle")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>, int)>();

  /// from: public androidx.emoji2.text.EmojiCompat.Config setUseEmojiAsDefaultStyle(boolean useEmojiAsDefaultStyle)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Determines whether EmojiCompat should use the emoji presentation style for emojis
  /// that have text style as default. By default, the text style would be used, unless these
  /// are followed by the U+FE0F variation selector.
  /// Details about emoji presentation and text presentation styles can be found here:
  /// http://unicode.org/reports/tr51/\#Presentation_Style
  /// If useEmojiAsDefaultStyle is true, the emoji presentation style will be used for all
  /// emojis, including potentially unexpected ones (such as digits or other keycap emojis). If
  /// this is not the expected behaviour, method
  /// \#setUseEmojiAsDefaultStyle(boolean, List) can be used to specify the
  /// exception emojis that should be still presented as text style.
  ///@param useEmojiAsDefaultStyle whether to use the emoji style presentation for all emojis
  ///                               that would be presented as text style by default
  EmojiCompat_Config setUseEmojiAsDefaultStyle(
    bool useEmojiAsDefaultStyle,
  ) {
    return _setUseEmojiAsDefaultStyle(
            reference.pointer, useEmojiAsDefaultStyle ? 1 : 0)
        .object(const $EmojiCompat_ConfigType());
  }

  static final _setUseEmojiAsDefaultStyle1 = jniLookup<
              ffi.NativeFunction<
                  jni.JniResult Function(ffi.Pointer<ffi.Void>, ffi.Uint8,
                      ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat_Config__setUseEmojiAsDefaultStyle1")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Void>)>();

  /// from: public androidx.emoji2.text.EmojiCompat.Config setUseEmojiAsDefaultStyle(boolean useEmojiAsDefaultStyle, java.util.List<java.lang.Integer> emojiAsDefaultStyleExceptions)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// @see \#setUseEmojiAsDefaultStyle(boolean)
  ///@param emojiAsDefaultStyleExceptions Contains the exception emojis which will be still
  ///                                      presented as text style even if the
  ///                                      useEmojiAsDefaultStyle flag is set to {@code true}.
  ///                                      This list will be ignored if useEmojiAsDefaultStyle
  ///                                      is {@code false}. Note that emojis with default
  ///                                      emoji style presentation will remain emoji style
  ///                                      regardless the value of useEmojiAsDefaultStyle or
  ///                                      whether they are included in the exceptions list or
  ///                                      not. When no exception is wanted, the method
  ///                                      \#setUseEmojiAsDefaultStyle(boolean) should
  ///                                      be used instead.
  EmojiCompat_Config setUseEmojiAsDefaultStyle1(
    bool useEmojiAsDefaultStyle,
    jni.JList<jni.JInteger> emojiAsDefaultStyleExceptions,
  ) {
    return _setUseEmojiAsDefaultStyle1(
            reference.pointer,
            useEmojiAsDefaultStyle ? 1 : 0,
            emojiAsDefaultStyleExceptions.reference.pointer)
        .object(const $EmojiCompat_ConfigType());
  }

  static final _setEmojiSpanIndicatorEnabled = jniLookup<
              ffi.NativeFunction<
                  jni.JniResult Function(ffi.Pointer<ffi.Void>, ffi.Uint8)>>(
          "EmojiCompat_Config__setEmojiSpanIndicatorEnabled")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>, int)>();

  /// from: public androidx.emoji2.text.EmojiCompat.Config setEmojiSpanIndicatorEnabled(boolean emojiSpanIndicatorEnabled)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Determines whether a background will be drawn for the emojis that are found and
  /// replaced by EmojiCompat. Should be used only for debugging purposes. The indicator color
  /// can be set using \#setEmojiSpanIndicatorColor(int).
  ///@param emojiSpanIndicatorEnabled when {@code true} a background is drawn for each emoji
  ///                                  that is replaced
  EmojiCompat_Config setEmojiSpanIndicatorEnabled(
    bool emojiSpanIndicatorEnabled,
  ) {
    return _setEmojiSpanIndicatorEnabled(
            reference.pointer, emojiSpanIndicatorEnabled ? 1 : 0)
        .object(const $EmojiCompat_ConfigType());
  }

  static final _setEmojiSpanIndicatorColor = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Int32)>>("EmojiCompat_Config__setEmojiSpanIndicatorColor")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>, int)>();

  /// from: public androidx.emoji2.text.EmojiCompat.Config setEmojiSpanIndicatorColor(int color)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Sets the color used as emoji span indicator. The default value is
  /// Color\#GREEN Color.GREEN.
  ///@see \#setEmojiSpanIndicatorEnabled(boolean)
  EmojiCompat_Config setEmojiSpanIndicatorColor(
    int color,
  ) {
    return _setEmojiSpanIndicatorColor(reference.pointer, color)
        .object(const $EmojiCompat_ConfigType());
  }

  static final _setMetadataLoadStrategy = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Int32)>>("EmojiCompat_Config__setMetadataLoadStrategy")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>, int)>();

  /// from: public androidx.emoji2.text.EmojiCompat.Config setMetadataLoadStrategy(int strategy)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Determines the strategy to start loading the metadata. By default EmojiCompat
  /// will start loading the metadata during EmojiCompat\#init(Config). When set to
  /// EmojiCompat\#LOAD_STRATEGY_MANUAL, you should call EmojiCompat\#load() to
  /// initiate metadata loading.
  /// <p/>
  /// Default implementations of EmojiCompat.MetadataRepoLoader start a thread
  /// during their EmojiCompat.MetadataRepoLoader\#load functions. Just instantiating
  /// and starting a thread might take time especially in older devices. Since
  /// EmojiCompat\#init(Config) has to be called before any EmojiCompat widgets are
  /// inflated, this results in time spent either on your Application.onCreate or Activity
  /// .onCreate. If you'd like to gain more control on when to start loading the metadata
  /// and be able to call EmojiCompat\#init(Config) with absolute minimum time cost you
  /// can use EmojiCompat\#LOAD_STRATEGY_MANUAL.
  /// <p/>
  /// When set to EmojiCompat\#LOAD_STRATEGY_MANUAL, EmojiCompat will wait
  /// for \#load() to be called by the developer in order to start loading metadata,
  /// therefore you should call EmojiCompat\#load() to initiate metadata loading.
  /// \#load() can be called from any thread.
  /// <pre>
  /// EmojiCompat.Config config = new FontRequestEmojiCompatConfig(context, fontRequest)
  ///         .setMetadataLoadStrategy(EmojiCompat.LOAD_STRATEGY_MANUAL);
  ///
  /// // EmojiCompat will not start loading metadata and MetadataRepoLoader\#load(...)
  /// // will not be called
  /// EmojiCompat.init(config);
  ///
  /// // At any time (i.e. idle time or executorService is ready)
  /// // call EmojiCompat\#load() to start loading metadata.
  /// executorService.execute(() -> EmojiCompat.get().load());
  /// </pre>
  ///@param strategy one of EmojiCompat\#LOAD_STRATEGY_DEFAULT,
  ///                  EmojiCompat\#LOAD_STRATEGY_MANUAL
  EmojiCompat_Config setMetadataLoadStrategy(
    int strategy,
  ) {
    return _setMetadataLoadStrategy(reference.pointer, strategy)
        .object(const $EmojiCompat_ConfigType());
  }

  static final _setSpanFactory = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("EmojiCompat_Config__setSpanFactory")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public androidx.emoji2.text.EmojiCompat.Config setSpanFactory(androidx.emoji2.text.EmojiCompat.SpanFactory factory)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Set the span factory used to actually draw emoji replacements.
  ///@param factory custum span factory that can draw the emoji replacements
  ///@return this
  EmojiCompat_Config setSpanFactory(
    EmojiCompat_SpanFactory factory0,
  ) {
    return _setSpanFactory(reference.pointer, factory0.reference.pointer)
        .object(const $EmojiCompat_ConfigType());
  }

  static final _setGlyphChecker = jniLookup<
              ffi.NativeFunction<
                  jni.JniResult Function(
                      ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat_Config__setGlyphChecker")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public androidx.emoji2.text.EmojiCompat.Config setGlyphChecker(androidx.emoji2.text.EmojiCompat.GlyphChecker glyphChecker)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// The interface that is used by EmojiCompat in order to check if a given emoji can be
  /// rendered by the system.
  ///@param glyphChecker GlyphChecker instance to be used.
  EmojiCompat_Config setGlyphChecker(
    EmojiCompat_GlyphChecker glyphChecker,
  ) {
    return _setGlyphChecker(reference.pointer, glyphChecker.reference.pointer)
        .object(const $EmojiCompat_ConfigType());
  }

  static final _getMetadataRepoLoader = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat_Config__getMetadataRepoLoader")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: protected final androidx.emoji2.text.EmojiCompat.MetadataRepoLoader getMetadataRepoLoader()
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Returns the MetadataRepoLoader.
  EmojiCompat_MetadataRepoLoader getMetadataRepoLoader() {
    return _getMetadataRepoLoader(reference.pointer)
        .object(const $EmojiCompat_MetadataRepoLoaderType());
  }
}

final class $EmojiCompat_ConfigType extends jni.JObjType<EmojiCompat_Config> {
  const $EmojiCompat_ConfigType();

  @override
  String get signature => r"Landroidx/emoji2/text/EmojiCompat$Config;";

  @override
  EmojiCompat_Config fromReference(jni.JReference reference) =>
      EmojiCompat_Config.fromReference(reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode => ($EmojiCompat_ConfigType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType == ($EmojiCompat_ConfigType) &&
        other is $EmojiCompat_ConfigType;
  }
}

/// from: androidx.emoji2.text.EmojiCompat$DefaultSpanFactory
///
/// @hide
class EmojiCompat_DefaultSpanFactory extends jni.JObject {
  @override
  late final jni.JObjType<EmojiCompat_DefaultSpanFactory> $type = type;

  EmojiCompat_DefaultSpanFactory.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type = $EmojiCompat_DefaultSpanFactoryType();
  static final _new0 = jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
          "EmojiCompat_DefaultSpanFactory__new0")
      .asFunction<jni.JniResult Function()>();

  /// from: public void <init>()
  /// The returned object must be released after use, by calling the [release] method.
  factory EmojiCompat_DefaultSpanFactory() {
    return EmojiCompat_DefaultSpanFactory.fromReference(_new0().reference);
  }

  static final _createSpan = jniLookup<
              ffi.NativeFunction<
                  jni.JniResult Function(
                      ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat_DefaultSpanFactory__createSpan")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public androidx.emoji2.text.EmojiSpan createSpan(androidx.emoji2.text.TypefaceEmojiRasterizer rasterizer)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Returns a TypefaceEmojiSpan.
  ///@param rasterizer TypefaceEmojiRasterizer instance, which can draw the emoji onto a
  ///                   Canvas.
  ///@return TypefaceEmojiSpan
  jni.JObject createSpan(
    jni.JObject rasterizer,
  ) {
    return _createSpan(reference.pointer, rasterizer.reference.pointer)
        .object(const jni.JObjectType());
  }
}

final class $EmojiCompat_DefaultSpanFactoryType
    extends jni.JObjType<EmojiCompat_DefaultSpanFactory> {
  const $EmojiCompat_DefaultSpanFactoryType();

  @override
  String get signature =>
      r"Landroidx/emoji2/text/EmojiCompat$DefaultSpanFactory;";

  @override
  EmojiCompat_DefaultSpanFactory fromReference(jni.JReference reference) =>
      EmojiCompat_DefaultSpanFactory.fromReference(reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode => ($EmojiCompat_DefaultSpanFactoryType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType == ($EmojiCompat_DefaultSpanFactoryType) &&
        other is $EmojiCompat_DefaultSpanFactoryType;
  }
}

/// from: androidx.emoji2.text.EmojiCompat$GlyphChecker
///
/// Interface to check if a given emoji exists on the system.
class EmojiCompat_GlyphChecker extends jni.JObject {
  @override
  late final jni.JObjType<EmojiCompat_GlyphChecker> $type = type;

  EmojiCompat_GlyphChecker.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type = $EmojiCompat_GlyphCheckerType();
  static final _hasGlyph = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Int32,
                  ffi.Int32,
                  ffi.Int32)>>("EmojiCompat_GlyphChecker__hasGlyph")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, int, int, int)>();

  /// from: public abstract boolean hasGlyph(java.lang.CharSequence charSequence, int start, int end, int sdkAdded)
  ///
  /// Return {@code true} if the emoji that is in {@code charSequence} between
  /// {@code start}(inclusive) and {@code end}(exclusive) can be rendered on the system
  /// using the default Typeface.
  ///
  /// This function is called after an emoji is identified in the given {@code charSequence}
  /// and EmojiCompat wants to know if that emoji can be rendered on the system. The result
  /// of this call will be cached and the same emoji sequence won't be asked for the same
  /// EmojiCompat instance.
  ///
  /// When the function returns {@code true}, it will mean that the system can render the
  /// emoji. In that case if Config\#setReplaceAll is set to {@code false}, then no
  /// EmojiSpan will be added in the final emoji processing result.
  ///
  /// When the function returns {@code false}, it will mean that the system cannot render
  /// the given emoji, therefore an EmojiSpan will be added to the final emoji
  /// processing result.
  ///
  /// The default implementation of this class uses
  /// androidx.core.graphics.PaintCompat\#hasGlyph(Paint, String) function to check
  /// if the emoji can be rendered on the system. This is required even if EmojiCompat
  /// knows about the SDK Version that the emoji was added on AOSP. Just the {@code sdkAdded}
  /// information is not enough to reliably decide if emoji can be rendered since this
  /// information may not be consistent across all the OEMs and all the Android versions.
  ///
  /// With this interface you can apply your own heuristics to check if the emoji can be
  /// rendered on the system. For example, if you'd like to rely on the {@code sdkAdded}
  /// information, and some predefined OEMs, it is possible to write the following code
  /// snippet.
  ///
  /// {@sample frameworks/support/samples/SupportEmojiDemos/src/main/java/com/example/android/support/text/emoji/sample/GlyphCheckerSample.java glyphchecker}
  ///@param charSequence the CharSequence that is being processed
  ///@param start the inclusive starting offset for the emoji in the {@code charSequence}
  ///@param end the exclusive end offset for the emoji in the {@code charSequence}
  ///@param sdkAdded the API version that the emoji was added in AOSP
  ///@return true if the given sequence can be rendered as a single glyph, otherwise false.
  bool hasGlyph(
    jni.JObject charSequence,
    int start,
    int end,
    int sdkAdded,
  ) {
    return _hasGlyph(reference.pointer, charSequence.reference.pointer, start,
            end, sdkAdded)
        .boolean;
  }
}

final class $EmojiCompat_GlyphCheckerType
    extends jni.JObjType<EmojiCompat_GlyphChecker> {
  const $EmojiCompat_GlyphCheckerType();

  @override
  String get signature => r"Landroidx/emoji2/text/EmojiCompat$GlyphChecker;";

  @override
  EmojiCompat_GlyphChecker fromReference(jni.JReference reference) =>
      EmojiCompat_GlyphChecker.fromReference(reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode => ($EmojiCompat_GlyphCheckerType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType == ($EmojiCompat_GlyphCheckerType) &&
        other is $EmojiCompat_GlyphCheckerType;
  }
}

/// from: androidx.emoji2.text.EmojiCompat$InitCallback
///
/// Listener class for the initialization of the EmojiCompat.
class EmojiCompat_InitCallback extends jni.JObject {
  @override
  late final jni.JObjType<EmojiCompat_InitCallback> $type = type;

  EmojiCompat_InitCallback.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type = $EmojiCompat_InitCallbackType();
  static final _new0 = jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
          "EmojiCompat_InitCallback__new0")
      .asFunction<jni.JniResult Function()>();

  /// from: public void <init>()
  /// The returned object must be released after use, by calling the [release] method.
  factory EmojiCompat_InitCallback() {
    return EmojiCompat_InitCallback.fromReference(_new0().reference);
  }

  static final _onInitialized = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat_InitCallback__onInitialized")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public void onInitialized()
  ///
  /// Called when EmojiCompat is initialized and the emoji data is loaded. When used on devices
  /// running API 18 or below, this function is always called.
  void onInitialized() {
    _onInitialized(reference.pointer).check();
  }

  static final _onFailed = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("EmojiCompat_InitCallback__onFailed")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public void onFailed(java.lang.Throwable throwable)
  ///
  /// Called when an unrecoverable error occurs during EmojiCompat initialization. When used on
  /// devices running API 18 or below, this function is never called.
  void onFailed(
    jni.JObject throwable,
  ) {
    _onFailed(reference.pointer, throwable.reference.pointer).check();
  }
}

final class $EmojiCompat_InitCallbackType
    extends jni.JObjType<EmojiCompat_InitCallback> {
  const $EmojiCompat_InitCallbackType();

  @override
  String get signature => r"Landroidx/emoji2/text/EmojiCompat$InitCallback;";

  @override
  EmojiCompat_InitCallback fromReference(jni.JReference reference) =>
      EmojiCompat_InitCallback.fromReference(reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode => ($EmojiCompat_InitCallbackType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType == ($EmojiCompat_InitCallbackType) &&
        other is $EmojiCompat_InitCallbackType;
  }
}

/// from: androidx.emoji2.text.EmojiCompat$LoadStrategy
class EmojiCompat_LoadStrategy extends jni.JObject {
  @override
  late final jni.JObjType<EmojiCompat_LoadStrategy> $type = type;

  EmojiCompat_LoadStrategy.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type = $EmojiCompat_LoadStrategyType();
}

final class $EmojiCompat_LoadStrategyType
    extends jni.JObjType<EmojiCompat_LoadStrategy> {
  const $EmojiCompat_LoadStrategyType();

  @override
  String get signature => r"Landroidx/emoji2/text/EmojiCompat$LoadStrategy;";

  @override
  EmojiCompat_LoadStrategy fromReference(jni.JReference reference) =>
      EmojiCompat_LoadStrategy.fromReference(reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode => ($EmojiCompat_LoadStrategyType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType == ($EmojiCompat_LoadStrategyType) &&
        other is $EmojiCompat_LoadStrategyType;
  }
}

/// from: androidx.emoji2.text.EmojiCompat$MetadataRepoLoader
///
/// Interface to load emoji metadata.
class EmojiCompat_MetadataRepoLoader extends jni.JObject {
  @override
  late final jni.JObjType<EmojiCompat_MetadataRepoLoader> $type = type;

  EmojiCompat_MetadataRepoLoader.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type = $EmojiCompat_MetadataRepoLoaderType();
  static final _load = jniLookup<
              ffi.NativeFunction<
                  jni.JniResult Function(
                      ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat_MetadataRepoLoader__load")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public abstract void load(androidx.emoji2.text.EmojiCompat.MetadataRepoLoaderCallback loaderCallback)
  ///
  /// Start loading the metadata. When the loading operation is finished MetadataRepoLoaderCallback\#onLoaded(MetadataRepo) or
  /// MetadataRepoLoaderCallback\#onFailed(Throwable) should be called. When used on
  /// devices running API 18 or below, this function is never called.
  ///@param loaderCallback callback to signal the loading state
  void load(
    EmojiCompat_MetadataRepoLoaderCallback loaderCallback,
  ) {
    _load(reference.pointer, loaderCallback.reference.pointer).check();
  }
}

final class $EmojiCompat_MetadataRepoLoaderType
    extends jni.JObjType<EmojiCompat_MetadataRepoLoader> {
  const $EmojiCompat_MetadataRepoLoaderType();

  @override
  String get signature =>
      r"Landroidx/emoji2/text/EmojiCompat$MetadataRepoLoader;";

  @override
  EmojiCompat_MetadataRepoLoader fromReference(jni.JReference reference) =>
      EmojiCompat_MetadataRepoLoader.fromReference(reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode => ($EmojiCompat_MetadataRepoLoaderType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType == ($EmojiCompat_MetadataRepoLoaderType) &&
        other is $EmojiCompat_MetadataRepoLoaderType;
  }
}

/// from: androidx.emoji2.text.EmojiCompat$MetadataRepoLoaderCallback
///
/// Callback to inform EmojiCompat about the state of the metadata load. Passed to
/// MetadataRepoLoader during MetadataRepoLoader\#load(MetadataRepoLoaderCallback) call.
class EmojiCompat_MetadataRepoLoaderCallback extends jni.JObject {
  @override
  late final jni.JObjType<EmojiCompat_MetadataRepoLoaderCallback> $type = type;

  EmojiCompat_MetadataRepoLoaderCallback.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type = $EmojiCompat_MetadataRepoLoaderCallbackType();
  static final _new0 = jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
          "EmojiCompat_MetadataRepoLoaderCallback__new0")
      .asFunction<jni.JniResult Function()>();

  /// from: public void <init>()
  /// The returned object must be released after use, by calling the [release] method.
  factory EmojiCompat_MetadataRepoLoaderCallback() {
    return EmojiCompat_MetadataRepoLoaderCallback.fromReference(
        _new0().reference);
  }

  static final _onLoaded = jniLookup<
              ffi.NativeFunction<
                  jni.JniResult Function(
                      ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat_MetadataRepoLoaderCallback__onLoaded")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public abstract void onLoaded(androidx.emoji2.text.MetadataRepo metadataRepo)
  ///
  /// Called by MetadataRepoLoader when metadata is loaded successfully.
  ///@param metadataRepo MetadataRepo instance, cannot be {@code null}
  void onLoaded(
    jni.JObject metadataRepo,
  ) {
    _onLoaded(reference.pointer, metadataRepo.reference.pointer).check();
  }

  static final _onFailed = jniLookup<
              ffi.NativeFunction<
                  jni.JniResult Function(
                      ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat_MetadataRepoLoaderCallback__onFailed")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public abstract void onFailed(java.lang.Throwable throwable)
  ///
  /// Called by MetadataRepoLoader if an error occurs while loading the metadata.
  ///@param throwable the exception that caused the failure, {@code nullable}
  void onFailed(
    jni.JObject throwable,
  ) {
    _onFailed(reference.pointer, throwable.reference.pointer).check();
  }
}

final class $EmojiCompat_MetadataRepoLoaderCallbackType
    extends jni.JObjType<EmojiCompat_MetadataRepoLoaderCallback> {
  const $EmojiCompat_MetadataRepoLoaderCallbackType();

  @override
  String get signature =>
      r"Landroidx/emoji2/text/EmojiCompat$MetadataRepoLoaderCallback;";

  @override
  EmojiCompat_MetadataRepoLoaderCallback fromReference(
          jni.JReference reference) =>
      EmojiCompat_MetadataRepoLoaderCallback.fromReference(reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode => ($EmojiCompat_MetadataRepoLoaderCallbackType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType == ($EmojiCompat_MetadataRepoLoaderCallbackType) &&
        other is $EmojiCompat_MetadataRepoLoaderCallbackType;
  }
}

/// from: androidx.emoji2.text.EmojiCompat$ReplaceStrategy
class EmojiCompat_ReplaceStrategy extends jni.JObject {
  @override
  late final jni.JObjType<EmojiCompat_ReplaceStrategy> $type = type;

  EmojiCompat_ReplaceStrategy.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type = $EmojiCompat_ReplaceStrategyType();
}

final class $EmojiCompat_ReplaceStrategyType
    extends jni.JObjType<EmojiCompat_ReplaceStrategy> {
  const $EmojiCompat_ReplaceStrategyType();

  @override
  String get signature => r"Landroidx/emoji2/text/EmojiCompat$ReplaceStrategy;";

  @override
  EmojiCompat_ReplaceStrategy fromReference(jni.JReference reference) =>
      EmojiCompat_ReplaceStrategy.fromReference(reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode => ($EmojiCompat_ReplaceStrategyType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType == ($EmojiCompat_ReplaceStrategyType) &&
        other is $EmojiCompat_ReplaceStrategyType;
  }
}

/// from: androidx.emoji2.text.EmojiCompat$SpanFactory
///
/// Factory class that creates the EmojiSpans.
///
/// By default it creates TypefaceEmojiSpan.
///
/// Apps should use this only if they want to control the drawing of EmojiSpans for non-standard
/// emoji display (for example, resizing or repositioning emoji).
class EmojiCompat_SpanFactory extends jni.JObject {
  @override
  late final jni.JObjType<EmojiCompat_SpanFactory> $type = type;

  EmojiCompat_SpanFactory.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type = $EmojiCompat_SpanFactoryType();
  static final _createSpan = jniLookup<
              ffi.NativeFunction<
                  jni.JniResult Function(
                      ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat_SpanFactory__createSpan")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public abstract androidx.emoji2.text.EmojiSpan createSpan(androidx.emoji2.text.TypefaceEmojiRasterizer rasterizer)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Create EmojiSpan instance.
  ///@param rasterizer TypefaceEmojiRasterizer instance, which can draw the emoji onto a
  ///                   Canvas.
  ///@return EmojiSpan instance that can use TypefaceEmojiRasterizer to draw emoji.
  jni.JObject createSpan(
    jni.JObject rasterizer,
  ) {
    return _createSpan(reference.pointer, rasterizer.reference.pointer)
        .object(const jni.JObjectType());
  }
}

final class $EmojiCompat_SpanFactoryType
    extends jni.JObjType<EmojiCompat_SpanFactory> {
  const $EmojiCompat_SpanFactoryType();

  @override
  String get signature => r"Landroidx/emoji2/text/EmojiCompat$SpanFactory;";

  @override
  EmojiCompat_SpanFactory fromReference(jni.JReference reference) =>
      EmojiCompat_SpanFactory.fromReference(reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode => ($EmojiCompat_SpanFactoryType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType == ($EmojiCompat_SpanFactoryType) &&
        other is $EmojiCompat_SpanFactoryType;
  }
}

/// from: androidx.emoji2.text.EmojiCompat
///
/// Main class to keep Android devices up to date with the newest emojis by adding EmojiSpans
/// to a given CharSequence.
/// <p/>
/// By default, EmojiCompat is initialized by EmojiCompatInitializer, which performs
/// deferred font loading to avoid potential app startup delays. The default behavior is to load
/// the font shortly after the first Activity resumes. EmojiCompatInitializer will configure
/// EmojiCompat to use the system emoji font provider via DefaultEmojiCompatConfig and
/// always creates a new background thread for font loading.
/// <p/>
/// EmojiCompat will only allow one instance to be initialized and any calls to
/// \#init(Config) after the first one will have no effect. As a result, configuration options
/// may not be provided when using EmojiCompatInitializer. To provide a custom configuration,
/// disable EmojiCompatInitializer in the manifest with:
///
/// <pre>
///     &lt;provider
///         android:name="androidx.startup.InitializationProvider"
///         android:authorities="${applicationId}.androidx-startup"
///         android:exported="false"
///         tools:node="merge"&gt;
///         &lt;meta-data android:name="androidx.emoji2.text.EmojiCompatInitializer"
///                   tools:node="remove" /&gt;
///     &lt;/provider&gt;
/// </pre>
///
/// When not using EmojiCompatInitializer, EmojiCompat must to be initialized manually using
/// \#init(EmojiCompat.Config). It is recommended to make the initialization as early as
/// possible in your app, such as from Application\#onCreate().
/// <p/>
/// \#init(Config) is fast and may be called from the main thread on the path to
/// displaying the first activity. However, loading the emoji font takes significant resources on a
/// background thread, so it is suggested to use \#LOAD_STRATEGY_MANUAL in all manual
/// configurations to defer font loading until after the first screen displays. Font loading may
/// be started by calling \#load()}. See the implementation EmojiCompatInitializer
/// for ideas when building a manual configuration.
/// <p/>
/// After initialization the \#get() function can be used to get the configured instance and
/// the \#process(CharSequence) function can be used to update a CharSequence with emoji
/// EmojiSpans.
/// <p/>
/// <pre><code>CharSequence processedSequence = EmojiCompat.get().process("some string")</pre>
/// <p/>
/// During loading information about emojis is not available. Before the
/// EmojiCompat instance has finished loading, calls to functions such as EmojiCompat\#process(CharSequence) will throw an exception. It is safe to call process when
/// \#getLoadState() returns \#LOAD_STATE_SUCCEEDED. To register a callback when
/// loading completes use InitCallback.
/// <p/>
class EmojiCompat extends jni.JObject {
  @override
  late final jni.JObjType<EmojiCompat> $type = type;

  EmojiCompat.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type = $EmojiCompatType();
  static final _get_EDITOR_INFO_METAVERSION_KEY =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_EmojiCompat__EDITOR_INFO_METAVERSION_KEY")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String EDITOR_INFO_METAVERSION_KEY
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Key in EditorInfo\#extras that represents the emoji metadata version used by the
  /// widget. The existence of the value means that the widget is using EmojiCompat.
  /// <p/>
  /// If exists, the value for the key is an {@code int} and can be used to query EmojiCompat to
  /// see whether the widget has the ability to display a certain emoji using
  /// \#hasEmojiGlyph(CharSequence, int).
  static jni.JString get EDITOR_INFO_METAVERSION_KEY =>
      _get_EDITOR_INFO_METAVERSION_KEY().object(const jni.JStringType());

  static final _get_EDITOR_INFO_REPLACE_ALL_KEY =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_EmojiCompat__EDITOR_INFO_REPLACE_ALL_KEY")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String EDITOR_INFO_REPLACE_ALL_KEY
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Key in EditorInfo\#extras that represents EmojiCompat.Config\#setReplaceAll(boolean) configuration parameter. The key is added only if
  /// EmojiCompat is used by the widget. If exists, the value is a boolean.
  static jni.JString get EDITOR_INFO_REPLACE_ALL_KEY =>
      _get_EDITOR_INFO_REPLACE_ALL_KEY().object(const jni.JStringType());

  /// from: static public final int LOAD_STATE_DEFAULT
  ///
  /// EmojiCompat instance is constructed, however the initialization did not start yet.
  ///@see \#getLoadState()
  static const LOAD_STATE_DEFAULT = 3;

  /// from: static public final int LOAD_STATE_LOADING
  ///
  /// EmojiCompat is initializing.
  ///@see \#getLoadState()
  static const LOAD_STATE_LOADING = 0;

  /// from: static public final int LOAD_STATE_SUCCEEDED
  ///
  /// EmojiCompat successfully initialized.
  ///@see \#getLoadState()
  static const LOAD_STATE_SUCCEEDED = 1;

  /// from: static public final int LOAD_STATE_FAILED
  ///
  /// An unrecoverable error occurred during initialization of EmojiCompat. Calls to functions
  /// such as \#process(CharSequence) will fail.
  ///@see \#getLoadState()
  static const LOAD_STATE_FAILED = 2;

  /// from: static public final int REPLACE_STRATEGY_DEFAULT
  ///
  /// Replace strategy that uses the value given in EmojiCompat.Config.
  ///@see \#process(CharSequence, int, int, int, int)
  static const REPLACE_STRATEGY_DEFAULT = 0;

  /// from: static public final int REPLACE_STRATEGY_ALL
  ///
  /// Replace strategy to add EmojiSpans for all emoji that were found.
  ///@see \#process(CharSequence, int, int, int, int)
  static const REPLACE_STRATEGY_ALL = 1;

  /// from: static public final int REPLACE_STRATEGY_NON_EXISTENT
  ///
  /// Replace strategy to add EmojiSpans only for emoji that do not exist in the system.
  static const REPLACE_STRATEGY_NON_EXISTENT = 2;

  /// from: static public final int LOAD_STRATEGY_DEFAULT
  ///
  /// EmojiCompat will start loading metadata when \#init(Config) is called.
  ///@see Config\#setMetadataLoadStrategy(int)
  static const LOAD_STRATEGY_DEFAULT = 0;

  /// from: static public final int LOAD_STRATEGY_MANUAL
  ///
  /// EmojiCompat will wait for \#load() to be called by developer in order to
  /// start loading metadata.
  ///@see Config\#setMetadataLoadStrategy(int)
  static const LOAD_STRATEGY_MANUAL = 1;

  /// from: static public final int EMOJI_UNSUPPORTED
  ///
  /// Result of \#getEmojiMatch(CharSequence, int) that means no part of this codepoint
  /// sequence will ever generate an EmojiSpan at the requested metadata level.
  ///
  /// This return value implies:
  /// - EmojiCompat will always defer to system emoji font
  /// - System emoji font may or may not support this emoji
  /// - This application MAY render this emoji
  ///
  /// This can be used by keyboards to learn that EmojiCompat does not support this codepoint
  /// sequence at this metadata version. The system emoji font is not checked by this method,
  /// and this result will be returned even if the system emoji font supports the emoji. This may
  /// happen if the application is using an older version of the emoji compat font than the
  /// system emoji font.
  ///
  /// Keyboards may optionally determine that the system emoji font will support the emoji, for
  /// example by building a internal lookup table or calling
  /// androidx.core.graphics.PaintCompat\#hasGlyph(Paint, String) to query the system
  /// emoji font. Keyboards may use a lookup table to optimize this check, however they should be
  /// aware that OEMs may add or remove emoji from the system emoji font.
  ///
  /// Keyboards may finally decide:
  /// - If the system emoji font DOES NOT support the emoji, then the emoji IS NOT supported by
  /// this application.
  /// - If the system emoji font DOES support the emoji, then the emoji IS supported by this
  /// application.
  /// - If system emoji font is support is UNKNOWN, then assume the emoji IS NOT supported by
  /// this application.
  static const EMOJI_UNSUPPORTED = 0;

  /// from: static public final int EMOJI_SUPPORTED
  ///
  /// Result of \#getEmojiMatch(CharSequence, int) that means this codepoint can be drawn
  /// by an EmojiSpan at this metadata level.
  ///
  /// No further checks are required by keyboards for this result. The emoji is always supported
  /// by this application.
  ///
  /// This return value implies:
  /// - EmojiCompat can draw this emoji
  /// - System emoji font may or may not support this emoji
  /// - This application WILL render this emoji
  ///
  /// This result implies that EmojiCompat can successfully display this emoji. The system emoji
  /// font is not checked by this method, and this result may be returned even if the platform
  /// also supports the emoji sequence.
  ///
  /// If the application passes EmojiCompat\#REPLACE_STRATEGY_ALL of true, then an
  /// EmojiSpan will always be generated for this emoji.
  ///
  /// If the application passes EmojiCompat\#REPLACE_STRATEGY_ALL of false, then an
  /// EmojiSpan will only be generated if
  /// androidx.core.graphics.PaintCompat\#hasGlyph(Paint, String)
  /// returns false for this emoji.
  static const EMOJI_SUPPORTED = 1;

  /// from: static public final int EMOJI_FALLBACK
  ///
  /// Result of \#getEmojiMatch(CharSequence, int) that means the full codepoint sequence
  /// is not known to emojicompat, but at least one subsequence is an emoji that is known at
  /// this metadata level.
  ///
  /// Keyboards may decide that this emoji is not supported by the application when this result is
  /// returned, with no further processing.
  ///
  /// This return value implies:
  /// - EmojiCompat will decompose this ZWJ sequence into multiple glyphs when replaceAll=true
  /// - EmojiCompat MAY defer to platform when replaceAll=false
  /// - System emoji font may or may not support this emoji
  /// - This application MAY render this emoji
  ///
  /// This return value is only ever returned for ZWJ sequences. To understand this result
  /// consider when it may be returned for the multi-skin-tone handshake introduced in emoji 14.
  ///
  /// <pre>
  ///     U+1FAF1 // unknown @ requested metadata level
  ///     U+1F3FB // metadata level 1
  ///     U+200D  // not displayed (ZWJ)
  ///     U+1FAF2 // unknown @ requested metadata level
  ///     U+1F3FD // metadata level 1
  /// </pre>
  ///
  /// In this codepoint sequence, U+1F3FB and U+1F3FD are known from metadata level 1. When an
  /// application is using a metadata level that doesn't understand this ZWJ and provides
  /// EmojiCompat\#REPLACE_STRATEGY_ALL true, the color emoji are matched and replaced
  /// with EmojiSpan. The system emoji font, even if it supports this ZWJ sequence, is
  /// never queried and the added EmojiSpans force fallback rendering for the ZWJ sequence.
  ///
  /// The glyph will only display correctly for this application if ALL of the following
  /// requirements are met:
  /// - EmojiCompat\#REPLACE_STRATEGY_ALL is false
  /// - androidx.core.graphics.PaintCompat\#hasGlyph(Paint, String) returns true for each
  /// emoji subsequence known at this metadata level
  /// - androidx.core.graphics.PaintCompat\#hasGlyph(Paint, String) returns true for the
  /// full sequence
  ///
  /// Given this return value for the multi-skin-tone handshake above, if
  /// EmojiCompat\#REPLACE_STRATEGY_ALL is false then the emoji will display if the
  /// entire emoji sequence is matched by
  /// androidx.core.graphics.PaintCompat\#hasGlyph(Paint, String) because U+1F3FB and
  /// U+1F3FD are both in the system emoji font.
  ///
  /// Keyboards that wish to determine if the glyph will display correctly by the application in
  /// response to this return value should consider building an internal lookup for new ZWJ
  /// sequences instead of repeatedly calling
  /// androidx.core.graphics.PaintCompat\#hasGlyph(Paint, String) for each emoji
  /// subsequence.
  static const EMOJI_FALLBACK = 2;
  static final _init = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat__init")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: static public androidx.emoji2.text.EmojiCompat init(android.content.Context context)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Initialize the singleton instance with the default system-provided configuration.
  ///
  /// This is the recommended configuration for most applications. For more details see
  /// DefaultEmojiCompatConfig.
  ///
  ///
  /// This call will use DefaultEmojiCompatConfig to lookup the default emoji font
  /// provider installed on the system and use that, if present. If there is no default font
  /// provider onthe system, this call will have no effect.
  ///
  ///
  /// Note: EmojiCompat may only be initialized once, and will return the same instance
  /// afterwords.
  ///
  ///@return Default EmojiCompat for this device, or null if there is no provider on the system.
  static EmojiCompat init(
    jni.JObject context,
  ) {
    return _init(context.reference.pointer).object(const $EmojiCompatType());
  }

  static final _init1 = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("EmojiCompat__init1")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: static public androidx.emoji2.text.EmojiCompat init(android.content.Context context, androidx.emoji2.text.DefaultEmojiCompatConfig.DefaultEmojiCompatConfigFactory defaultFactory)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// @hide
  static EmojiCompat init1(
    jni.JObject context,
    DefaultEmojiCompatConfig_DefaultEmojiCompatConfigFactory defaultFactory,
  ) {
    return _init1(context.reference.pointer, defaultFactory.reference.pointer)
        .object(const $EmojiCompatType());
  }

  static final _init2 = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat__init2")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: static public androidx.emoji2.text.EmojiCompat init(androidx.emoji2.text.EmojiCompat.Config config)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Initialize the singleton instance with a configuration. When used on devices running API 18
  /// or below, the singleton instance is immediately moved into \#LOAD_STATE_SUCCEEDED
  /// state without loading any metadata. When called for the first time, the library will create
  /// the singleton instance and any call after that will not create a new instance and return
  /// immediately.
  ///@see EmojiCompat.Config
  static EmojiCompat init2(
    EmojiCompat_Config config,
  ) {
    return _init2(config.reference.pointer).object(const $EmojiCompatType());
  }

  static final _isConfigured =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "EmojiCompat__isConfigured")
          .asFunction<jni.JniResult Function()>();

  /// from: static public boolean isConfigured()
  ///
  /// Return true if EmojiCompat has been configured by a successful call to
  /// EmojiCompat\#init.
  ///
  /// You can use this to check if EmojiCompat\#get() will return a valid EmojiCompat
  /// instance.
  ///
  /// This function does not check the \#getLoadState() and will return true even if the
  /// font is still loading, or has failed to load.
  ///@return true if EmojiCompat has been successfully initialized.
  static bool isConfigured() {
    return _isConfigured().boolean;
  }

  static final _reset = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat__reset")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: static public androidx.emoji2.text.EmojiCompat reset(androidx.emoji2.text.EmojiCompat.Config config)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Used by the tests to reset EmojiCompat with a new configuration. Every time it is called a
  /// new instance is created with the new configuration.
  ///@hide
  static EmojiCompat reset(
    EmojiCompat_Config config,
  ) {
    return _reset(config.reference.pointer).object(const $EmojiCompatType());
  }

  static final _reset1 = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat__reset1")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: static public androidx.emoji2.text.EmojiCompat reset(androidx.emoji2.text.EmojiCompat emojiCompat)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Used by the tests to reset EmojiCompat with a new singleton instance.
  ///@hide
  static EmojiCompat reset1(
    EmojiCompat emojiCompat,
  ) {
    return _reset1(emojiCompat.reference.pointer)
        .object(const $EmojiCompatType());
  }

  static final _skipDefaultConfigurationLookup =
      jniLookup<ffi.NativeFunction<jni.JniResult Function(ffi.Uint8)>>(
              "EmojiCompat__skipDefaultConfigurationLookup")
          .asFunction<jni.JniResult Function(int)>();

  /// from: static public void skipDefaultConfigurationLookup(boolean shouldSkip)
  ///
  /// Reset default configuration lookup flag, for tests.
  ///@hide
  static void skipDefaultConfigurationLookup(
    bool shouldSkip,
  ) {
    _skipDefaultConfigurationLookup(shouldSkip ? 1 : 0).check();
  }

  static final _get0 = jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
          "EmojiCompat__get0")
      .asFunction<jni.JniResult Function()>();

  /// from: static public androidx.emoji2.text.EmojiCompat get()
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Return singleton EmojiCompat instance. Should be called after
  /// \#init(EmojiCompat.Config) is called to initialize the singleton instance.
  ///@return EmojiCompat instance
  ///@throws IllegalStateException if called before \#init(EmojiCompat.Config)
  static EmojiCompat get0() {
    return _get0().object(const $EmojiCompatType());
  }

  static final _load = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat__load")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public void load()
  ///
  /// When Config\#setMetadataLoadStrategy(int) is set to \#LOAD_STRATEGY_MANUAL,
  /// this function starts loading the metadata. Calling the function when
  /// Config\#setMetadataLoadStrategy(int) is {@code not} set to
  /// \#LOAD_STRATEGY_MANUAL will throw an exception. The load will {@code not} start if:
  /// <ul>
  ///     <li>the metadata is already loaded successfully and \#getLoadState() is
  ///     \#LOAD_STATE_SUCCEEDED.
  ///     </li>
  ///      <li>a previous load attempt is not finished yet and \#getLoadState() is
  ///     \#LOAD_STATE_LOADING.</li>
  /// </ul>
  ///@throws IllegalStateException when Config\#setMetadataLoadStrategy(int) is not set
  /// to \#LOAD_STRATEGY_MANUAL
  void load() {
    _load(reference.pointer).check();
  }

  static final _registerInitCallback = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("EmojiCompat__registerInitCallback")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public void registerInitCallback(androidx.emoji2.text.EmojiCompat.InitCallback initCallback)
  ///
  /// Registers an initialization callback. If the initialization is already completed by the time
  /// the listener is added, the callback functions are called immediately. Callbacks are called on
  /// the main looper.
  /// <p/>
  /// When used on devices running API 18 or below, InitCallback\#onInitialized() is called
  /// without loading any metadata. In such cases InitCallback\#onFailed(Throwable) is never
  /// called.
  ///@param initCallback the initialization callback to register, cannot be {@code null}
  ///@see \#unregisterInitCallback(InitCallback)
  void registerInitCallback(
    EmojiCompat_InitCallback initCallback,
  ) {
    _registerInitCallback(reference.pointer, initCallback.reference.pointer)
        .check();
  }

  static final _unregisterInitCallback = jniLookup<
              ffi.NativeFunction<
                  jni.JniResult Function(
                      ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat__unregisterInitCallback")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public void unregisterInitCallback(androidx.emoji2.text.EmojiCompat.InitCallback initCallback)
  ///
  /// Unregisters a callback that was added before.
  ///@param initCallback the callback to be removed, cannot be {@code null}
  void unregisterInitCallback(
    EmojiCompat_InitCallback initCallback,
  ) {
    _unregisterInitCallback(reference.pointer, initCallback.reference.pointer)
        .check();
  }

  static final _getLoadState = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat__getLoadState")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public int getLoadState()
  ///
  /// Returns loading state of the EmojiCompat instance. When used on devices running API 18 or
  /// below always returns \#LOAD_STATE_SUCCEEDED.
  ///@return one of \#LOAD_STATE_DEFAULT, \#LOAD_STATE_LOADING,
  /// \#LOAD_STATE_SUCCEEDED, \#LOAD_STATE_FAILED
  int getLoadState() {
    return _getLoadState(reference.pointer).integer;
  }

  static final _isEmojiSpanIndicatorEnabled = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat__isEmojiSpanIndicatorEnabled")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public boolean isEmojiSpanIndicatorEnabled()
  ///
  /// @return whether a background should be drawn for the emoji for debugging
  ///@hide
  bool isEmojiSpanIndicatorEnabled() {
    return _isEmojiSpanIndicatorEnabled(reference.pointer).boolean;
  }

  static final _getEmojiSpanIndicatorColor = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat__getEmojiSpanIndicatorColor")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public int getEmojiSpanIndicatorColor()
  ///
  /// @return color of background drawn if EmojiCompat\#isEmojiSpanIndicatorEnabled is true
  ///@hide
  int getEmojiSpanIndicatorColor() {
    return _getEmojiSpanIndicatorColor(reference.pointer).integer;
  }

  static final _getEmojiStart = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Int32)>>("EmojiCompat__getEmojiStart")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, int)>();

  /// from: public int getEmojiStart(java.lang.CharSequence charSequence, int offset)
  ///
  /// Together with \#getEmojiEnd(CharSequence, int), if the character at {@code offset} is
  /// part of an emoji, returns the index range of that emoji, start index inclusively/end index
  /// exclusively so that {@code charSequence.subSequence(start, end)} will return that emoji.
  /// E.g., getEmojiStart/End("AB\ud83d\ude00", 1) will return (-1,-1) since 'B' is not part an emoji;
  ///       getEmojiStart/End("AB\ud83d\ude00", 3) will return [2,4), note that "\ud83d\ude00" contains 2 Chars.
  /// Returns -1 otherwise.
  ///@param charSequence the whole sequence
  ///@param offset index of the emoji to look up
  ///@return the start index inclusively/end index exclusively
  int getEmojiStart(
    jni.JObject charSequence,
    int offset,
  ) {
    return _getEmojiStart(
            reference.pointer, charSequence.reference.pointer, offset)
        .integer;
  }

  static final _getEmojiEnd = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Int32)>>("EmojiCompat__getEmojiEnd")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, int)>();

  /// from: public int getEmojiEnd(java.lang.CharSequence charSequence, int offset)
  ///
  /// see \#getEmojiStart(CharSequence, int).
  int getEmojiEnd(
    jni.JObject charSequence,
    int offset,
  ) {
    return _getEmojiEnd(
            reference.pointer, charSequence.reference.pointer, offset)
        .integer;
  }

  static final _handleOnKeyDown = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>, ffi.Int32,
                  ffi.Pointer<ffi.Void>)>>("EmojiCompat__handleOnKeyDown")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Void>)>();

  /// from: static public boolean handleOnKeyDown(android.text.Editable editable, int keyCode, android.view.KeyEvent event)
  ///
  /// Handles onKeyDown commands from a KeyListener and if {@code keyCode} is one of
  /// KeyEvent\#KEYCODE_DEL or KeyEvent\#KEYCODE_FORWARD_DEL it tries to delete an
  /// EmojiSpan from an Editable. Returns {@code true} if an EmojiSpan is
  /// deleted with the characters it covers.
  /// <p/>
  /// If there is a selection where selection start is not equal to selection end, does not
  /// delete.
  /// <p/>
  /// When used on devices running API 18 or below, always returns {@code false}.
  ///@param editable Editable instance passed to KeyListener\#onKeyDown(android.view.View,
  ///                 Editable, int, KeyEvent)
  ///@param keyCode keyCode passed to KeyListener\#onKeyDown(android.view.View, Editable,
  ///                int, KeyEvent)
  ///@param event KeyEvent passed to KeyListener\#onKeyDown(android.view.View, Editable,
  ///              int, KeyEvent)
  ///@return {@code true} if an EmojiSpan is deleted
  static bool handleOnKeyDown(
    jni.JObject editable,
    int keyCode,
    jni.JObject event,
  ) {
    return _handleOnKeyDown(
            editable.reference.pointer, keyCode, event.reference.pointer)
        .boolean;
  }

  static final _handleDeleteSurroundingText = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Int32,
                  ffi.Int32,
                  ffi.Uint8)>>("EmojiCompat__handleDeleteSurroundingText")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, int, int, int)>();

  /// from: static public boolean handleDeleteSurroundingText(android.view.inputmethod.InputConnection inputConnection, android.text.Editable editable, int beforeLength, int afterLength, boolean inCodePoints)
  ///
  /// Handles deleteSurroundingText commands from InputConnection and tries to delete an
  /// EmojiSpan from an Editable. Returns {@code true} if an EmojiSpan is
  /// deleted.
  /// <p/>
  /// If there is a selection where selection start is not equal to selection end, does not
  /// delete.
  /// <p/>
  /// When used on devices running API 18 or below, always returns {@code false}.
  ///@param inputConnection InputConnection instance
  ///@param editable TextView.Editable instance
  ///@param beforeLength the number of characters before the cursor to be deleted
  ///@param afterLength the number of characters after the cursor to be deleted
  ///@param inCodePoints {@code true} if length parameters are in codepoints
  ///@return {@code true} if an EmojiSpan is deleted
  static bool handleDeleteSurroundingText(
    jni.JObject inputConnection,
    jni.JObject editable,
    int beforeLength,
    int afterLength,
    bool inCodePoints,
  ) {
    return _handleDeleteSurroundingText(
            inputConnection.reference.pointer,
            editable.reference.pointer,
            beforeLength,
            afterLength,
            inCodePoints ? 1 : 0)
        .boolean;
  }

  static final _hasEmojiGlyph = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("EmojiCompat__hasEmojiGlyph")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public boolean hasEmojiGlyph(java.lang.CharSequence sequence)
  ///
  /// Returns {@code true} if EmojiCompat is capable of rendering an emoji. When used on devices
  /// running API 18 or below, always returns {@code false}.
  ///@deprecated use getEmojiMatch which returns more accurate lookup information.
  ///@param sequence CharSequence representing the emoji
  ///@return {@code true} if EmojiCompat can render given emoji, cannot be {@code null}
  ///@throws IllegalStateException if not initialized yet
  bool hasEmojiGlyph(
    jni.JObject sequence,
  ) {
    return _hasEmojiGlyph(reference.pointer, sequence.reference.pointer)
        .boolean;
  }

  static final _hasEmojiGlyph1 = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Int32)>>("EmojiCompat__hasEmojiGlyph1")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, int)>();

  /// from: public boolean hasEmojiGlyph(java.lang.CharSequence sequence, int metadataVersion)
  ///
  /// Returns {@code true} if EmojiCompat is capable of rendering an emoji at the given metadata
  /// version. When used on devices running API 18 or below, always returns {@code false}.
  ///@deprecated use getEmojiMatch which returns more accurate lookup information.
  ///@param sequence CharSequence representing the emoji
  ///@param metadataVersion the metadata version to check against, should be greater than or
  ///                        equal to {@code 0},
  ///@return {@code true} if EmojiCompat can render given emoji, cannot be {@code null}
  ///@throws IllegalStateException if not initialized yet
  bool hasEmojiGlyph1(
    jni.JObject sequence,
    int metadataVersion,
  ) {
    return _hasEmojiGlyph1(
            reference.pointer, sequence.reference.pointer, metadataVersion)
        .boolean;
  }

  static final _getEmojiMatch = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Int32)>>("EmojiCompat__getEmojiMatch")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, int)>();

  /// from: public int getEmojiMatch(java.lang.CharSequence sequence, int metadataVersion)
  ///
  /// Attempts to lookup the entire sequence at the specified metadata version and returns what
  /// the runtime match behavior would be.
  ///
  /// To be used by keyboards to show or hide emoji in response to specific metadata support.
  ///@see \#EMOJI_SUPPORTED
  ///@see \#EMOJI_UNSUPPORTED
  ///@see \#EMOJI_FALLBACK
  ///@param sequence CharSequence representing an emoji
  ///@param metadataVersion the metada version to check against, should be greater than or
  ///                        equal to {@code 0},
  ///@return A match result, or decomposes if replaceAll would cause partial subsequence matches.
  int getEmojiMatch(
    jni.JObject sequence,
    int metadataVersion,
  ) {
    return _getEmojiMatch(
            reference.pointer, sequence.reference.pointer, metadataVersion)
        .integer;
  }

  static final _process = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("EmojiCompat__process")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public java.lang.CharSequence process(java.lang.CharSequence charSequence)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Checks a given CharSequence for emojis, and adds EmojiSpans if any emojis are found. When
  /// used on devices running API 18 or below, returns the given {@code charSequence} without
  /// processing it.
  ///@param charSequence CharSequence to add the EmojiSpans
  ///@throws IllegalStateException if not initialized yet
  ///@see \#process(CharSequence, int, int)
  jni.JObject process(
    jni.JObject charSequence,
  ) {
    return _process(reference.pointer, charSequence.reference.pointer)
        .object(const jni.JObjectType());
  }

  static final _process1 = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Int32,
                  ffi.Int32)>>("EmojiCompat__process1")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, int, int)>();

  /// from: public java.lang.CharSequence process(java.lang.CharSequence charSequence, int start, int end)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Checks a given CharSequence for emojis, and adds EmojiSpans if any emojis are found.
  ///
  /// <ul>
  /// <li>If no emojis are found, {@code charSequence} given as the input is returned without
  /// any changes. i.e. charSequence is a String, and no emojis are found, the same String is
  /// returned.</li>
  /// <li>If the given input is not a Spannable (such as String), and at least one emoji is found
  /// a new android.text.Spannable instance is returned. </li>
  /// <li>If the given input is a Spannable, the same instance is returned. </li>
  /// </ul>
  /// When used on devices running API 18 or below, returns the given {@code charSequence} without
  /// processing it.
  ///@param charSequence CharSequence to add the EmojiSpans, cannot be {@code null}
  ///@param start start index in the charSequence to look for emojis, should be greater than or
  ///              equal to {@code 0}, also less than or equal to {@code charSequence.length()}
  ///@param end end index in the charSequence to look for emojis, should be greater than or equal
  ///              to {@code start} parameter, also less than or equal to
  ///              {@code charSequence.length()}
  ///@throws IllegalStateException if not initialized yet
  ///@throws IllegalArgumentException in the following cases:
  ///                                  {@code start < 0}, {@code end < 0}, {@code end < start},
  ///                                  {@code start > charSequence.length()},
  ///                                  {@code end > charSequence.length()}
  jni.JObject process1(
    jni.JObject charSequence,
    int start,
    int end,
  ) {
    return _process1(
            reference.pointer, charSequence.reference.pointer, start, end)
        .object(const jni.JObjectType());
  }

  static final _process2 = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Int32,
                  ffi.Int32,
                  ffi.Int32)>>("EmojiCompat__process2")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, int, int, int)>();

  /// from: public java.lang.CharSequence process(java.lang.CharSequence charSequence, int start, int end, int maxEmojiCount)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Checks a given CharSequence for emojis, and adds EmojiSpans if any emojis are found.
  ///
  /// <ul>
  /// <li>If no emojis are found, {@code charSequence} given as the input is returned without
  /// any changes. i.e. charSequence is a String, and no emojis are found, the same String is
  /// returned.</li>
  /// <li>If the given input is not a Spannable (such as String), and at least one emoji is found
  /// a new android.text.Spannable instance is returned. </li>
  /// <li>If the given input is a Spannable, the same instance is returned. </li>
  /// </ul>
  /// When used on devices running API 18 or below, returns the given {@code charSequence} without
  /// processing it.
  ///@param charSequence CharSequence to add the EmojiSpans, cannot be {@code null}
  ///@param start start index in the charSequence to look for emojis, should be greater than or
  ///              equal to {@code 0}, also less than or equal to {@code charSequence.length()}
  ///@param end end index in the charSequence to look for emojis, should be greater than or
  ///            equal to {@code start} parameter, also less than or equal to
  ///            {@code charSequence.length()}
  ///@param maxEmojiCount maximum number of emojis in the {@code charSequence}, should be greater
  ///                      than or equal to {@code 0}
  ///@throws IllegalStateException if not initialized yet
  ///@throws IllegalArgumentException in the following cases:
  ///                                  {@code start < 0}, {@code end < 0}, {@code end < start},
  ///                                  {@code start > charSequence.length()},
  ///                                  {@code end > charSequence.length()}
  ///                                  {@code maxEmojiCount < 0}
  jni.JObject process2(
    jni.JObject charSequence,
    int start,
    int end,
    int maxEmojiCount,
  ) {
    return _process2(reference.pointer, charSequence.reference.pointer, start,
            end, maxEmojiCount)
        .object(const jni.JObjectType());
  }

  static final _process3 = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Int32,
                  ffi.Int32,
                  ffi.Int32,
                  ffi.Int32)>>("EmojiCompat__process3")
      .asFunction<
          jni.JniResult Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              int, int, int, int)>();

  /// from: public java.lang.CharSequence process(java.lang.CharSequence charSequence, int start, int end, int maxEmojiCount, int replaceStrategy)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Checks a given CharSequence for emojis, and adds EmojiSpans if any emojis are found.
  ///
  /// <ul>
  /// <li>If no emojis are found, {@code charSequence} given as the input is returned without
  /// any changes. i.e. charSequence is a String, and no emojis are found, the same String is
  /// returned.</li>
  /// <li>If the given input is not a Spannable (such as String), and at least one emoji is found
  /// a new android.text.Spannable instance is returned. </li>
  /// <li>If the given input is a Spannable, the same instance is returned. </li>
  /// </ul>
  /// When used on devices running API 18 or below, returns the given {@code charSequence} without
  /// processing it.
  ///@param charSequence CharSequence to add the EmojiSpans, cannot be {@code null}
  ///@param start start index in the charSequence to look for emojis, should be greater than or
  ///              equal to {@code 0}, also less than or equal to {@code charSequence.length()}
  ///@param end end index in the charSequence to look for emojis, should be greater than or
  ///            equal to {@code start} parameter, also less than or equal to
  ///            {@code charSequence.length()}
  ///@param maxEmojiCount maximum number of emojis in the {@code charSequence}, should be greater
  ///                      than or equal to {@code 0}
  ///@param replaceStrategy whether to replace all emoji with EmojiSpans, should be one of
  ///                        \#REPLACE_STRATEGY_DEFAULT,
  ///                        \#REPLACE_STRATEGY_NON_EXISTENT,
  ///                        \#REPLACE_STRATEGY_ALL
  ///@throws IllegalStateException if not initialized yet
  ///@throws IllegalArgumentException in the following cases:
  ///                                  {@code start < 0}, {@code end < 0}, {@code end < start},
  ///                                  {@code start > charSequence.length()},
  ///                                  {@code end > charSequence.length()}
  ///                                  {@code maxEmojiCount < 0}
  jni.JObject process3(
    jni.JObject charSequence,
    int start,
    int end,
    int maxEmojiCount,
    int replaceStrategy,
  ) {
    return _process3(reference.pointer, charSequence.reference.pointer, start,
            end, maxEmojiCount, replaceStrategy)
        .object(const jni.JObjectType());
  }

  static final _getAssetSignature = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "EmojiCompat__getAssetSignature")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public java.lang.String getAssetSignature()
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Returns signature for the currently loaded emoji assets. The signature is a SHA that is
  /// constructed using emoji assets. Can be used to detect if currently loaded asset is different
  /// then previous executions. When used on devices running API 18 or below, returns empty string.
  ///@throws IllegalStateException if not initialized yet
  jni.JString getAssetSignature() {
    return _getAssetSignature(reference.pointer)
        .object(const jni.JStringType());
  }

  static final _updateEditorInfo = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("EmojiCompat__updateEditorInfo")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public void updateEditorInfo(android.view.inputmethod.EditorInfo outAttrs)
  ///
  /// Updates the EditorInfo attributes in order to communicate information to Keyboards. When
  /// used on devices running API 18 or below, does not update EditorInfo attributes.
  ///
  /// This is called from EditText integrations that use EmojiEditTextHelper. Custom
  /// widgets that allow IME not subclassing EditText should call this method when creating an
  /// input connection.
  ///
  /// When EmojiCompat is not in \#LOAD_STATE_SUCCEEDED, this method has no effect.
  ///
  /// Calling this method on API levels below API 19 will have no effect, as EmojiCompat may
  /// never be configured. However, it is always safe to call, even on older API levels.
  ///@param outAttrs EditorInfo instance passed to
  ///                 android.widget.TextView\#onCreateInputConnection(EditorInfo)
  ///@see \#EDITOR_INFO_METAVERSION_KEY
  ///@see \#EDITOR_INFO_REPLACE_ALL_KEY
  void updateEditorInfo(
    jni.JObject outAttrs,
  ) {
    _updateEditorInfo(reference.pointer, outAttrs.reference.pointer).check();
  }
}

final class $EmojiCompatType extends jni.JObjType<EmojiCompat> {
  const $EmojiCompatType();

  @override
  String get signature => r"Landroidx/emoji2/text/EmojiCompat;";

  @override
  EmojiCompat fromReference(jni.JReference reference) =>
      EmojiCompat.fromReference(reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode => ($EmojiCompatType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType == ($EmojiCompatType) && other is $EmojiCompatType;
  }
}

/// from: androidx.emoji2.text.DefaultEmojiCompatConfig$DefaultEmojiCompatConfigFactory
///
/// Actual factory for generating default emoji configs, does service locator lookup internally.
///@see DefaultEmojiCompatConfig\#create
///@hide
class DefaultEmojiCompatConfig_DefaultEmojiCompatConfigFactory
    extends jni.JObject {
  @override
  late final jni
      .JObjType<DefaultEmojiCompatConfig_DefaultEmojiCompatConfigFactory>
      $type = type;

  DefaultEmojiCompatConfig_DefaultEmojiCompatConfigFactory.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type =
      $DefaultEmojiCompatConfig_DefaultEmojiCompatConfigFactoryType();
  static final _new0 = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "DefaultEmojiCompatConfig_DefaultEmojiCompatConfigFactory__new0")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public void <init>(androidx.emoji2.text.DefaultEmojiCompatConfig.DefaultEmojiCompatConfigHelper helper)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// @hide
  factory DefaultEmojiCompatConfig_DefaultEmojiCompatConfigFactory(
    DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper helper,
  ) {
    return DefaultEmojiCompatConfig_DefaultEmojiCompatConfigFactory
        .fromReference(_new0(helper.reference.pointer).reference);
  }

  static final _create = jniLookup<
              ffi.NativeFunction<
                  jni.JniResult Function(
                      ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>>(
          "DefaultEmojiCompatConfig_DefaultEmojiCompatConfigFactory__create")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public androidx.emoji2.text.EmojiCompat.Config create(android.content.Context context)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// @see DefaultEmojiCompatConfig\#create
  ///@hide
  EmojiCompat_Config create(
    jni.JObject context,
  ) {
    return _create(reference.pointer, context.reference.pointer)
        .object(const $EmojiCompat_ConfigType());
  }
}

final class $DefaultEmojiCompatConfig_DefaultEmojiCompatConfigFactoryType
    extends jni
    .JObjType<DefaultEmojiCompatConfig_DefaultEmojiCompatConfigFactory> {
  const $DefaultEmojiCompatConfig_DefaultEmojiCompatConfigFactoryType();

  @override
  String get signature =>
      r"Landroidx/emoji2/text/DefaultEmojiCompatConfig$DefaultEmojiCompatConfigFactory;";

  @override
  DefaultEmojiCompatConfig_DefaultEmojiCompatConfigFactory fromReference(
          jni.JReference reference) =>
      DefaultEmojiCompatConfig_DefaultEmojiCompatConfigFactory.fromReference(
          reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode =>
      ($DefaultEmojiCompatConfig_DefaultEmojiCompatConfigFactoryType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType ==
            ($DefaultEmojiCompatConfig_DefaultEmojiCompatConfigFactoryType) &&
        other is $DefaultEmojiCompatConfig_DefaultEmojiCompatConfigFactoryType;
  }
}

/// from: androidx.emoji2.text.DefaultEmojiCompatConfig$DefaultEmojiCompatConfigHelper
///
/// Helper to lookup signatures in package manager.
///@hide
class DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper
    extends jni.JObject {
  @override
  late final jni
      .JObjType<DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper> $type =
      type;

  DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type =
      $DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelperType();
  static final _new0 = jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
          "DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper__new0")
      .asFunction<jni.JniResult Function()>();

  /// from: public void <init>()
  /// The returned object must be released after use, by calling the [release] method.
  factory DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper() {
    return DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper
        .fromReference(_new0().reference);
  }

  static final _getSigningSignatures = jniLookup<
              ffi.NativeFunction<
                  jni.JniResult Function(ffi.Pointer<ffi.Void>,
                      ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>>(
          "DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper__getSigningSignatures")
      .asFunction<
          jni.JniResult Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Void>)>();

  /// from: public android.content.pm.Signature[] getSigningSignatures(android.content.pm.PackageManager packageManager, java.lang.String providerPackage)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Get the signing signatures for a package in package manager.
  jni.JArray<jni.JObject> getSigningSignatures(
    jni.JObject packageManager,
    jni.JString providerPackage,
  ) {
    return _getSigningSignatures(reference.pointer,
            packageManager.reference.pointer, providerPackage.reference.pointer)
        .object(const jni.JArrayType(jni.JObjectType()));
  }

  static final _queryIntentContentProviders = jniLookup<
              ffi.NativeFunction<
                  jni.JniResult Function(
                      ffi.Pointer<ffi.Void>,
                      ffi.Pointer<ffi.Void>,
                      ffi.Pointer<ffi.Void>,
                      ffi.Int32)>>(
          "DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper__queryIntentContentProviders")
      .asFunction<
          jni.JniResult Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Void>, int)>();

  /// from: public java.util.List<android.content.pm.ResolveInfo> queryIntentContentProviders(android.content.pm.PackageManager packageManager, android.content.Intent intent, int flags)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Get the content provider by intent.
  jni.JList<jni.JObject> queryIntentContentProviders(
    jni.JObject packageManager,
    jni.JObject intent,
    int flags,
  ) {
    return _queryIntentContentProviders(reference.pointer,
            packageManager.reference.pointer, intent.reference.pointer, flags)
        .object(const jni.JListType(jni.JObjectType()));
  }

  static final _getProviderInfo = jniLookup<
              ffi.NativeFunction<
                  jni.JniResult Function(
                      ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>>(
          "DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper__getProviderInfo")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public android.content.pm.ProviderInfo getProviderInfo(android.content.pm.ResolveInfo resolveInfo)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Get a ProviderInfo, if present, from a ResolveInfo
  ///@param resolveInfo the subject
  ///@return resolveInfo.providerInfo above API 19
  jni.JObject getProviderInfo(
    jni.JObject resolveInfo,
  ) {
    return _getProviderInfo(reference.pointer, resolveInfo.reference.pointer)
        .object(const jni.JObjectType());
  }
}

final class $DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelperType
    extends jni
    .JObjType<DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper> {
  const $DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelperType();

  @override
  String get signature =>
      r"Landroidx/emoji2/text/DefaultEmojiCompatConfig$DefaultEmojiCompatConfigHelper;";

  @override
  DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper fromReference(
          jni.JReference reference) =>
      DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper.fromReference(
          reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode =>
      ($DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelperType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType ==
            ($DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelperType) &&
        other is $DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelperType;
  }
}

/// from: androidx.emoji2.text.DefaultEmojiCompatConfig$DefaultEmojiCompatConfigHelper_API19
///
/// Actually do lookups > API 19
///@hide
class DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19
    extends DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper {
  @override
  late final jni
      .JObjType<DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19>
      $type = type;

  DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type =
      $DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19Type();
  static final _new0 = jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
          "DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19__new0")
      .asFunction<jni.JniResult Function()>();

  /// from: public void <init>()
  /// The returned object must be released after use, by calling the [release] method.
  factory DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19() {
    return DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19
        .fromReference(_new0().reference);
  }

  static final _queryIntentContentProviders = jniLookup<
              ffi.NativeFunction<
                  jni.JniResult Function(
                      ffi.Pointer<ffi.Void>,
                      ffi.Pointer<ffi.Void>,
                      ffi.Pointer<ffi.Void>,
                      ffi.Int32)>>(
          "DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19__queryIntentContentProviders")
      .asFunction<
          jni.JniResult Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Void>, int)>();

  /// from: public java.util.List<android.content.pm.ResolveInfo> queryIntentContentProviders(android.content.pm.PackageManager packageManager, android.content.Intent intent, int flags)
  /// The returned object must be released after use, by calling the [release] method.
  jni.JList<jni.JObject> queryIntentContentProviders(
    jni.JObject packageManager,
    jni.JObject intent,
    int flags,
  ) {
    return _queryIntentContentProviders(reference.pointer,
            packageManager.reference.pointer, intent.reference.pointer, flags)
        .object(const jni.JListType(jni.JObjectType()));
  }

  static final _getProviderInfo = jniLookup<
              ffi.NativeFunction<
                  jni.JniResult Function(
                      ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>>(
          "DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19__getProviderInfo")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public android.content.pm.ProviderInfo getProviderInfo(android.content.pm.ResolveInfo resolveInfo)
  /// The returned object must be released after use, by calling the [release] method.
  jni.JObject getProviderInfo(
    jni.JObject resolveInfo,
  ) {
    return _getProviderInfo(reference.pointer, resolveInfo.reference.pointer)
        .object(const jni.JObjectType());
  }
}

final class $DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19Type
    extends jni
    .JObjType<DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19> {
  const $DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19Type();

  @override
  String get signature =>
      r"Landroidx/emoji2/text/DefaultEmojiCompatConfig$DefaultEmojiCompatConfigHelper_API19;";

  @override
  DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19 fromReference(
          jni.JReference reference) =>
      DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19
          .fromReference(reference);

  @override
  jni.JObjType get superType =>
      const $DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelperType();

  @override
  final superCount = 2;

  @override
  int get hashCode =>
      ($DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19Type)
          .hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType ==
            ($DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19Type) &&
        other
            is $DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19Type;
  }
}

/// from: androidx.emoji2.text.DefaultEmojiCompatConfig$DefaultEmojiCompatConfigHelper_API28
///
/// Helper to lookup signatures in package manager > API 28
///@hide
class DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API28
    extends DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19 {
  @override
  late final jni
      .JObjType<DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API28>
      $type = type;

  DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API28.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type =
      $DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API28Type();
  static final _new0 = jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
          "DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API28__new0")
      .asFunction<jni.JniResult Function()>();

  /// from: public void <init>()
  /// The returned object must be released after use, by calling the [release] method.
  factory DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API28() {
    return DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API28
        .fromReference(_new0().reference);
  }

  static final _getSigningSignatures1 = jniLookup<
              ffi.NativeFunction<
                  jni.JniResult Function(ffi.Pointer<ffi.Void>,
                      ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>>(
          "DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API28__getSigningSignatures1")
      .asFunction<
          jni.JniResult Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Void>)>();

  /// from: public android.content.pm.Signature[] getSigningSignatures(android.content.pm.PackageManager packageManager, java.lang.String providerPackage)
  /// The returned object must be released after use, by calling the [release] method.
  jni.JArray<jni.JObject> getSigningSignatures1(
    jni.JObject packageManager,
    jni.JString providerPackage,
  ) {
    return _getSigningSignatures1(reference.pointer,
            packageManager.reference.pointer, providerPackage.reference.pointer)
        .object(const jni.JArrayType(jni.JObjectType()));
  }
}

final class $DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API28Type
    extends jni
    .JObjType<DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API28> {
  const $DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API28Type();

  @override
  String get signature =>
      r"Landroidx/emoji2/text/DefaultEmojiCompatConfig$DefaultEmojiCompatConfigHelper_API28;";

  @override
  DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API28 fromReference(
          jni.JReference reference) =>
      DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API28
          .fromReference(reference);

  @override
  jni.JObjType get superType =>
      const $DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API19Type();

  @override
  final superCount = 3;

  @override
  int get hashCode =>
      ($DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API28Type)
          .hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType ==
            ($DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API28Type) &&
        other
            is $DefaultEmojiCompatConfig_DefaultEmojiCompatConfigHelper_API28Type;
  }
}

/// from: androidx.emoji2.text.DefaultEmojiCompatConfig
///
/// The default config will use downloadable fonts to fetch the emoji compat font file.
///
/// It will automatically fetch the emoji compat font from a {@code ContentProvider} that is
/// installed on the devices system image, if present.
///
///
/// You should use this if you want the default emoji font from a system installed
/// downloadable fonts provider. This is the recommended behavior for all applications unless
/// they install a custom emoji font.
///
///
/// You may need to specialize the configuration beyond this default config in some
/// situations:
///
/// <ul>
///  <li>If you are trying to install a custom emoji font through downloadable fonts use
///  FontRequestEmojiCompatConfig instead of this method.</li>
///  <li>If you're trying to bundle an emoji font with your APK use {@code
///  BundledEmojiCompatConfig} in the {@code emoji2-bundled} artifact.</li>
///  <li>If you are building an APK that will be installed on devices that won't have a
///  downloadable fonts provider, use {@code BundledEmojiCompatConfig}.</li>
/// </ul>
///
/// The downloadable font provider used by {@code DefaultEmojiCompatConfig} always satisfies
/// the following contract:
///
/// <ol>
///  <li>It <i>MUST</i> provide an intent filter for {@code androidx.content.action.LOAD_EMOJI_FONT}.
///  </li>
///  <li>It <i>MUST</i> respond to the query {@code emojicompat-emoji-font} with a valid emoji compat
///  font file including metadata.</li>
///  <li>It <i>MUST</i> provide fonts via the same contract as downloadable fonts.</li>
///  <li>It <i>MUST</i> be installed in the system image.</li>
/// </ol>
class DefaultEmojiCompatConfig extends jni.JObject {
  @override
  late final jni.JObjType<DefaultEmojiCompatConfig> $type = type;

  DefaultEmojiCompatConfig.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type = $DefaultEmojiCompatConfigType();
  static final _create = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "DefaultEmojiCompatConfig__create")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: static public androidx.emoji2.text.FontRequestEmojiCompatConfig create(android.content.Context context)
  /// The returned object must be released after use, by calling the [release] method.
  ///
  /// Get the default emoji compat config for this device.
  ///
  /// You may further configure the returned config before passing it to EmojiCompat\#init.
  ///
  /// Each call to this method will return a new EmojiCompat.Config, so changes to the returned
  /// object will not modify future return values.
  ///@param context context for lookup
  ///@return A valid config for downloading the emoji compat font, or null if no font provider
  /// could be found.
  static jni.JObject create(
    jni.JObject context,
  ) {
    return _create(context.reference.pointer).object(const jni.JObjectType());
  }
}

final class $DefaultEmojiCompatConfigType
    extends jni.JObjType<DefaultEmojiCompatConfig> {
  const $DefaultEmojiCompatConfigType();

  @override
  String get signature => r"Landroidx/emoji2/text/DefaultEmojiCompatConfig;";

  @override
  DefaultEmojiCompatConfig fromReference(jni.JReference reference) =>
      DefaultEmojiCompatConfig.fromReference(reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode => ($DefaultEmojiCompatConfigType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType == ($DefaultEmojiCompatConfigType) &&
        other is $DefaultEmojiCompatConfigType;
  }
}

/// from: android.os.Build$Partition
class Build_Partition extends jni.JObject {
  @override
  late final jni.JObjType<Build_Partition> $type = type;

  Build_Partition.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type = $Build_PartitionType();
  static final _get_PARTITION_NAME_SYSTEM =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build_Partition__PARTITION_NAME_SYSTEM")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String PARTITION_NAME_SYSTEM
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get PARTITION_NAME_SYSTEM =>
      _get_PARTITION_NAME_SYSTEM().object(const jni.JStringType());

  static final _getName = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "Build_Partition__getName")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public java.lang.String getName()
  /// The returned object must be released after use, by calling the [release] method.
  jni.JString getName() {
    return _getName(reference.pointer).object(const jni.JStringType());
  }

  static final _getFingerprint = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "Build_Partition__getFingerprint")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public java.lang.String getFingerprint()
  /// The returned object must be released after use, by calling the [release] method.
  jni.JString getFingerprint() {
    return _getFingerprint(reference.pointer).object(const jni.JStringType());
  }

  static final _getBuildTimeMillis = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "Build_Partition__getBuildTimeMillis")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public long getBuildTimeMillis()
  int getBuildTimeMillis() {
    return _getBuildTimeMillis(reference.pointer).long;
  }

  static final _equals = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("Build_Partition__equals")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public boolean equals(java.lang.Object object)
  bool equals(
    jni.JObject object,
  ) {
    return _equals(reference.pointer, object.reference.pointer).boolean;
  }

  static final _hashCode1 = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "Build_Partition__hashCode1")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public int hashCode()
  int hashCode1() {
    return _hashCode1(reference.pointer).integer;
  }
}

final class $Build_PartitionType extends jni.JObjType<Build_Partition> {
  const $Build_PartitionType();

  @override
  String get signature => r"Landroid/os/Build$Partition;";

  @override
  Build_Partition fromReference(jni.JReference reference) =>
      Build_Partition.fromReference(reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode => ($Build_PartitionType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType == ($Build_PartitionType) &&
        other is $Build_PartitionType;
  }
}

/// from: android.os.Build$VERSION
class Build_VERSION extends jni.JObject {
  @override
  late final jni.JObjType<Build_VERSION> $type = type;

  Build_VERSION.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type = $Build_VERSIONType();
  static final _get_BASE_OS =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build_VERSION__BASE_OS")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String BASE_OS
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get BASE_OS =>
      _get_BASE_OS().object(const jni.JStringType());

  static final _get_CODENAME =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build_VERSION__CODENAME")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String CODENAME
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get CODENAME =>
      _get_CODENAME().object(const jni.JStringType());

  static final _get_INCREMENTAL =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build_VERSION__INCREMENTAL")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String INCREMENTAL
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get INCREMENTAL =>
      _get_INCREMENTAL().object(const jni.JStringType());

  static final _get_MEDIA_PERFORMANCE_CLASS =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build_VERSION__MEDIA_PERFORMANCE_CLASS")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final int MEDIA_PERFORMANCE_CLASS
  static int get MEDIA_PERFORMANCE_CLASS =>
      _get_MEDIA_PERFORMANCE_CLASS().integer;

  static final _get_PREVIEW_SDK_INT =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build_VERSION__PREVIEW_SDK_INT")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final int PREVIEW_SDK_INT
  static int get PREVIEW_SDK_INT => _get_PREVIEW_SDK_INT().integer;

  static final _get_RELEASE =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build_VERSION__RELEASE")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String RELEASE
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get RELEASE =>
      _get_RELEASE().object(const jni.JStringType());

  static final _get_RELEASE_OR_CODENAME =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build_VERSION__RELEASE_OR_CODENAME")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String RELEASE_OR_CODENAME
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get RELEASE_OR_CODENAME =>
      _get_RELEASE_OR_CODENAME().object(const jni.JStringType());

  static final _get_RELEASE_OR_PREVIEW_DISPLAY =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build_VERSION__RELEASE_OR_PREVIEW_DISPLAY")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String RELEASE_OR_PREVIEW_DISPLAY
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get RELEASE_OR_PREVIEW_DISPLAY =>
      _get_RELEASE_OR_PREVIEW_DISPLAY().object(const jni.JStringType());

  static final _get_SDK =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build_VERSION__SDK")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String SDK
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get SDK => _get_SDK().object(const jni.JStringType());

  static final _get_SDK_INT =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build_VERSION__SDK_INT")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final int SDK_INT
  static int get SDK_INT => _get_SDK_INT().integer;

  static final _get_SECURITY_PATCH =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build_VERSION__SECURITY_PATCH")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String SECURITY_PATCH
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get SECURITY_PATCH =>
      _get_SECURITY_PATCH().object(const jni.JStringType());

  static final _new0 = jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
          "Build_VERSION__new0")
      .asFunction<jni.JniResult Function()>();

  /// from: public void <init>()
  /// The returned object must be released after use, by calling the [release] method.
  factory Build_VERSION() {
    return Build_VERSION.fromReference(_new0().reference);
  }
}

final class $Build_VERSIONType extends jni.JObjType<Build_VERSION> {
  const $Build_VERSIONType();

  @override
  String get signature => r"Landroid/os/Build$VERSION;";

  @override
  Build_VERSION fromReference(jni.JReference reference) =>
      Build_VERSION.fromReference(reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode => ($Build_VERSIONType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType == ($Build_VERSIONType) &&
        other is $Build_VERSIONType;
  }
}

/// from: android.os.Build$VERSION_CODES
class Build_VERSION_CODES extends jni.JObject {
  @override
  late final jni.JObjType<Build_VERSION_CODES> $type = type;

  Build_VERSION_CODES.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type = $Build_VERSION_CODESType();

  /// from: static public final int BASE
  static const BASE = 1;

  /// from: static public final int BASE_1_1
  static const BASE_1_1 = 2;

  /// from: static public final int CUPCAKE
  static const CUPCAKE = 3;

  /// from: static public final int CUR_DEVELOPMENT
  static const CUR_DEVELOPMENT = 10000;

  /// from: static public final int DONUT
  static const DONUT = 4;

  /// from: static public final int ECLAIR
  static const ECLAIR = 5;

  /// from: static public final int ECLAIR_0_1
  static const ECLAIR_0_1 = 6;

  /// from: static public final int ECLAIR_MR1
  static const ECLAIR_MR1 = 7;

  /// from: static public final int FROYO
  static const FROYO = 8;

  /// from: static public final int GINGERBREAD
  static const GINGERBREAD = 9;

  /// from: static public final int GINGERBREAD_MR1
  static const GINGERBREAD_MR1 = 10;

  /// from: static public final int HONEYCOMB
  static const HONEYCOMB = 11;

  /// from: static public final int HONEYCOMB_MR1
  static const HONEYCOMB_MR1 = 12;

  /// from: static public final int HONEYCOMB_MR2
  static const HONEYCOMB_MR2 = 13;

  /// from: static public final int ICE_CREAM_SANDWICH
  static const ICE_CREAM_SANDWICH = 14;

  /// from: static public final int ICE_CREAM_SANDWICH_MR1
  static const ICE_CREAM_SANDWICH_MR1 = 15;

  /// from: static public final int JELLY_BEAN
  static const JELLY_BEAN = 16;

  /// from: static public final int JELLY_BEAN_MR1
  static const JELLY_BEAN_MR1 = 17;

  /// from: static public final int JELLY_BEAN_MR2
  static const JELLY_BEAN_MR2 = 18;

  /// from: static public final int KITKAT
  static const KITKAT = 19;

  /// from: static public final int KITKAT_WATCH
  static const KITKAT_WATCH = 20;

  /// from: static public final int LOLLIPOP
  static const LOLLIPOP = 21;

  /// from: static public final int LOLLIPOP_MR1
  static const LOLLIPOP_MR1 = 22;

  /// from: static public final int M
  static const M = 23;

  /// from: static public final int N
  static const N = 24;

  /// from: static public final int N_MR1
  static const N_MR1 = 25;

  /// from: static public final int O
  static const O = 26;

  /// from: static public final int O_MR1
  static const O_MR1 = 27;

  /// from: static public final int P
  static const P = 28;

  /// from: static public final int Q
  static const Q = 29;

  /// from: static public final int R
  static const R = 30;

  /// from: static public final int S
  static const S = 31;

  /// from: static public final int S_V2
  static const S_V2 = 32;

  /// from: static public final int TIRAMISU
  static const TIRAMISU = 33;
  static final _new0 = jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
          "Build_VERSION_CODES__new0")
      .asFunction<jni.JniResult Function()>();

  /// from: public void <init>()
  /// The returned object must be released after use, by calling the [release] method.
  factory Build_VERSION_CODES() {
    return Build_VERSION_CODES.fromReference(_new0().reference);
  }
}

final class $Build_VERSION_CODESType extends jni.JObjType<Build_VERSION_CODES> {
  const $Build_VERSION_CODESType();

  @override
  String get signature => r"Landroid/os/Build$VERSION_CODES;";

  @override
  Build_VERSION_CODES fromReference(jni.JReference reference) =>
      Build_VERSION_CODES.fromReference(reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode => ($Build_VERSION_CODESType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType == ($Build_VERSION_CODESType) &&
        other is $Build_VERSION_CODESType;
  }
}

/// from: android.os.Build
class Build extends jni.JObject {
  @override
  late final jni.JObjType<Build> $type = type;

  Build.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type = $BuildType();
  static final _get_BOARD =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__BOARD")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String BOARD
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get BOARD => _get_BOARD().object(const jni.JStringType());

  static final _get_BOOTLOADER =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__BOOTLOADER")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String BOOTLOADER
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get BOOTLOADER =>
      _get_BOOTLOADER().object(const jni.JStringType());

  static final _get_BRAND =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__BRAND")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String BRAND
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get BRAND => _get_BRAND().object(const jni.JStringType());

  static final _get_CPU_ABI =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__CPU_ABI")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String CPU_ABI
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get CPU_ABI =>
      _get_CPU_ABI().object(const jni.JStringType());

  static final _get_CPU_ABI2 =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__CPU_ABI2")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String CPU_ABI2
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get CPU_ABI2 =>
      _get_CPU_ABI2().object(const jni.JStringType());

  static final _get_DEVICE =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__DEVICE")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String DEVICE
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get DEVICE =>
      _get_DEVICE().object(const jni.JStringType());

  static final _get_DISPLAY =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__DISPLAY")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String DISPLAY
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get DISPLAY =>
      _get_DISPLAY().object(const jni.JStringType());

  static final _get_FINGERPRINT =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__FINGERPRINT")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String FINGERPRINT
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get FINGERPRINT =>
      _get_FINGERPRINT().object(const jni.JStringType());

  static final _get_HARDWARE =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__HARDWARE")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String HARDWARE
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get HARDWARE =>
      _get_HARDWARE().object(const jni.JStringType());

  static final _get_HOST =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>("get_Build__HOST")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String HOST
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get HOST => _get_HOST().object(const jni.JStringType());

  static final _get_ID =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>("get_Build__ID")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String ID
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get ID => _get_ID().object(const jni.JStringType());

  static final _get_MANUFACTURER =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__MANUFACTURER")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String MANUFACTURER
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get MANUFACTURER =>
      _get_MANUFACTURER().object(const jni.JStringType());

  static final _get_MODEL =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__MODEL")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String MODEL
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get MODEL => _get_MODEL().object(const jni.JStringType());

  static final _get_ODM_SKU =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__ODM_SKU")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String ODM_SKU
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get ODM_SKU =>
      _get_ODM_SKU().object(const jni.JStringType());

  static final _get_PRODUCT =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__PRODUCT")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String PRODUCT
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get PRODUCT =>
      _get_PRODUCT().object(const jni.JStringType());

  static final _get_RADIO =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__RADIO")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String RADIO
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get RADIO => _get_RADIO().object(const jni.JStringType());

  static final _get_SERIAL =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__SERIAL")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String SERIAL
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get SERIAL =>
      _get_SERIAL().object(const jni.JStringType());

  static final _get_SKU =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>("get_Build__SKU")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String SKU
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get SKU => _get_SKU().object(const jni.JStringType());

  static final _get_SOC_MANUFACTURER =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__SOC_MANUFACTURER")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String SOC_MANUFACTURER
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get SOC_MANUFACTURER =>
      _get_SOC_MANUFACTURER().object(const jni.JStringType());

  static final _get_SOC_MODEL =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__SOC_MODEL")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String SOC_MODEL
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get SOC_MODEL =>
      _get_SOC_MODEL().object(const jni.JStringType());

  static final _get_SUPPORTED_32_BIT_ABIS =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__SUPPORTED_32_BIT_ABIS")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String[] SUPPORTED_32_BIT_ABIS
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JArray<jni.JString> get SUPPORTED_32_BIT_ABIS =>
      _get_SUPPORTED_32_BIT_ABIS()
          .object(const jni.JArrayType(jni.JStringType()));

  static final _get_SUPPORTED_64_BIT_ABIS =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__SUPPORTED_64_BIT_ABIS")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String[] SUPPORTED_64_BIT_ABIS
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JArray<jni.JString> get SUPPORTED_64_BIT_ABIS =>
      _get_SUPPORTED_64_BIT_ABIS()
          .object(const jni.JArrayType(jni.JStringType()));

  static final _get_SUPPORTED_ABIS =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__SUPPORTED_ABIS")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String[] SUPPORTED_ABIS
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JArray<jni.JString> get SUPPORTED_ABIS =>
      _get_SUPPORTED_ABIS().object(const jni.JArrayType(jni.JStringType()));

  static final _get_TAGS =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>("get_Build__TAGS")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String TAGS
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get TAGS => _get_TAGS().object(const jni.JStringType());

  static final _get_TIME =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>("get_Build__TIME")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final long TIME
  static int get TIME => _get_TIME().long;

  static final _get_TYPE =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>("get_Build__TYPE")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String TYPE
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get TYPE => _get_TYPE().object(const jni.JStringType());

  static final _get_UNKNOWN =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "get_Build__UNKNOWN")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String UNKNOWN
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get UNKNOWN =>
      _get_UNKNOWN().object(const jni.JStringType());

  static final _get_USER =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>("get_Build__USER")
          .asFunction<jni.JniResult Function()>();

  /// from: static public final java.lang.String USER
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString get USER => _get_USER().object(const jni.JStringType());

  static final _new0 =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>("Build__new0")
          .asFunction<jni.JniResult Function()>();

  /// from: public void <init>()
  /// The returned object must be released after use, by calling the [release] method.
  factory Build() {
    return Build.fromReference(_new0().reference);
  }

  static final _getSerial =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "Build__getSerial")
          .asFunction<jni.JniResult Function()>();

  /// from: static public java.lang.String getSerial()
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString getSerial() {
    return _getSerial().object(const jni.JStringType());
  }

  static final _getFingerprintedPartitions =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "Build__getFingerprintedPartitions")
          .asFunction<jni.JniResult Function()>();

  /// from: static public java.util.List getFingerprintedPartitions()
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JList<Build_Partition> getFingerprintedPartitions() {
    return _getFingerprintedPartitions()
        .object(const jni.JListType($Build_PartitionType()));
  }

  static final _getRadioVersion =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>(
              "Build__getRadioVersion")
          .asFunction<jni.JniResult Function()>();

  /// from: static public java.lang.String getRadioVersion()
  /// The returned object must be released after use, by calling the [release] method.
  static jni.JString getRadioVersion() {
    return _getRadioVersion().object(const jni.JStringType());
  }
}

final class $BuildType extends jni.JObjType<Build> {
  const $BuildType();

  @override
  String get signature => r"Landroid/os/Build;";

  @override
  Build fromReference(jni.JReference reference) =>
      Build.fromReference(reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode => ($BuildType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType == ($BuildType) && other is $BuildType;
  }
}

/// from: java.util.HashMap
class HashMap<$K extends jni.JObject, $V extends jni.JObject>
    extends jni.JObject {
  @override
  late final jni.JObjType<HashMap<$K, $V>> $type = type(K, V);

  final jni.JObjType<$K> K;
  final jni.JObjType<$V> V;

  HashMap.fromReference(
    this.K,
    this.V,
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static $HashMapType<$K, $V>
      type<$K extends jni.JObject, $V extends jni.JObject>(
    jni.JObjType<$K> K,
    jni.JObjType<$V> V,
  ) {
    return $HashMapType(
      K,
      V,
    );
  }

  static final _new0 = jniLookup<
              ffi.NativeFunction<jni.JniResult Function(ffi.Int32, ffi.Float)>>(
          "HashMap__new0")
      .asFunction<jni.JniResult Function(int, double)>();

  /// from: public void <init>(int i, float f)
  /// The returned object must be released after use, by calling the [release] method.
  factory HashMap(
    int i,
    double f, {
    required jni.JObjType<$K> K,
    required jni.JObjType<$V> V,
  }) {
    return HashMap.fromReference(K, V, _new0(i, f).reference);
  }

  static final _new1 =
      jniLookup<ffi.NativeFunction<jni.JniResult Function(ffi.Int32)>>(
              "HashMap__new1")
          .asFunction<jni.JniResult Function(int)>();

  /// from: public void <init>(int i)
  /// The returned object must be released after use, by calling the [release] method.
  factory HashMap.new1(
    int i, {
    required jni.JObjType<$K> K,
    required jni.JObjType<$V> V,
  }) {
    return HashMap.fromReference(K, V, _new1(i).reference);
  }

  static final _new2 =
      jniLookup<ffi.NativeFunction<jni.JniResult Function()>>("HashMap__new2")
          .asFunction<jni.JniResult Function()>();

  /// from: public void <init>()
  /// The returned object must be released after use, by calling the [release] method.
  factory HashMap.new2({
    required jni.JObjType<$K> K,
    required jni.JObjType<$V> V,
  }) {
    return HashMap.fromReference(K, V, _new2().reference);
  }

  static final _new3 = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>)>>("HashMap__new3")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public void <init>(java.util.Map map)
  /// The returned object must be released after use, by calling the [release] method.
  factory HashMap.new3(
    jni.JMap<$K, $V> map, {
    jni.JObjType<$K>? K,
    jni.JObjType<$V>? V,
  }) {
    K ??= jni.lowestCommonSuperType([
      (map.$type as jni.JMapType).K,
    ]) as jni.JObjType<$K>;
    V ??= jni.lowestCommonSuperType([
      (map.$type as jni.JMapType).V,
    ]) as jni.JObjType<$V>;
    return HashMap.fromReference(K, V, _new3(map.reference.pointer).reference);
  }

  static final _size = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>)>>("HashMap__size")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public int size()
  int size() {
    return _size(reference.pointer).integer;
  }

  static final _isEmpty = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "HashMap__isEmpty")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public boolean isEmpty()
  bool isEmpty() {
    return _isEmpty(reference.pointer).boolean;
  }

  static final _get0 = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("HashMap__get0")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public V get(java.lang.Object object)
  /// The returned object must be released after use, by calling the [release] method.
  $V get0(
    jni.JObject object,
  ) {
    return _get0(reference.pointer, object.reference.pointer).object(V);
  }

  static final _containsKey = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("HashMap__containsKey")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public boolean containsKey(java.lang.Object object)
  bool containsKey(
    jni.JObject object,
  ) {
    return _containsKey(reference.pointer, object.reference.pointer).boolean;
  }

  static final _put = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("HashMap__put")
      .asFunction<
          jni.JniResult Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Void>)>();

  /// from: public V put(K object, V object1)
  /// The returned object must be released after use, by calling the [release] method.
  $V put(
    $K object,
    $V object1,
  ) {
    return _put(reference.pointer, object.reference.pointer,
            object1.reference.pointer)
        .object(V);
  }

  static final _putAll = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("HashMap__putAll")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public void putAll(java.util.Map map)
  void putAll(
    jni.JMap<$K, $V> map,
  ) {
    _putAll(reference.pointer, map.reference.pointer).check();
  }

  static final _remove = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("HashMap__remove")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public V remove(java.lang.Object object)
  /// The returned object must be released after use, by calling the [release] method.
  $V remove(
    jni.JObject object,
  ) {
    return _remove(reference.pointer, object.reference.pointer).object(V);
  }

  static final _clear = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>)>>("HashMap__clear")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public void clear()
  void clear() {
    _clear(reference.pointer).check();
  }

  static final _containsValue = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("HashMap__containsValue")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public boolean containsValue(java.lang.Object object)
  bool containsValue(
    jni.JObject object,
  ) {
    return _containsValue(reference.pointer, object.reference.pointer).boolean;
  }

  static final _keySet = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>)>>("HashMap__keySet")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public java.util.Set keySet()
  /// The returned object must be released after use, by calling the [release] method.
  jni.JSet<$K> keySet() {
    return _keySet(reference.pointer).object(jni.JSetType(K));
  }

  static final _values = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>)>>("HashMap__values")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public java.util.Collection values()
  /// The returned object must be released after use, by calling the [release] method.
  jni.JObject values() {
    return _values(reference.pointer).object(const jni.JObjectType());
  }

  static final _entrySet = jniLookup<
              ffi
              .NativeFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>>(
          "HashMap__entrySet")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public java.util.Set entrySet()
  /// The returned object must be released after use, by calling the [release] method.
  jni.JSet<jni.JObject> entrySet() {
    return _entrySet(reference.pointer)
        .object(const jni.JSetType(jni.JObjectType()));
  }

  static final _getOrDefault = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("HashMap__getOrDefault")
      .asFunction<
          jni.JniResult Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Void>)>();

  /// from: public V getOrDefault(java.lang.Object object, V object1)
  /// The returned object must be released after use, by calling the [release] method.
  $V getOrDefault(
    jni.JObject object,
    $V object1,
  ) {
    return _getOrDefault(reference.pointer, object.reference.pointer,
            object1.reference.pointer)
        .object(V);
  }

  static final _putIfAbsent = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("HashMap__putIfAbsent")
      .asFunction<
          jni.JniResult Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Void>)>();

  /// from: public V putIfAbsent(K object, V object1)
  /// The returned object must be released after use, by calling the [release] method.
  $V putIfAbsent(
    $K object,
    $V object1,
  ) {
    return _putIfAbsent(reference.pointer, object.reference.pointer,
            object1.reference.pointer)
        .object(V);
  }

  static final _remove1 = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("HashMap__remove1")
      .asFunction<
          jni.JniResult Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Void>)>();

  /// from: public boolean remove(java.lang.Object object, java.lang.Object object1)
  bool remove1(
    jni.JObject object,
    jni.JObject object1,
  ) {
    return _remove1(reference.pointer, object.reference.pointer,
            object1.reference.pointer)
        .boolean;
  }

  static final _replace = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("HashMap__replace")
      .asFunction<
          jni.JniResult Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public boolean replace(K object, V object1, V object2)
  bool replace(
    $K object,
    $V object1,
    $V object2,
  ) {
    return _replace(reference.pointer, object.reference.pointer,
            object1.reference.pointer, object2.reference.pointer)
        .boolean;
  }

  static final _replace1 = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("HashMap__replace1")
      .asFunction<
          jni.JniResult Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Void>)>();

  /// from: public V replace(K object, V object1)
  /// The returned object must be released after use, by calling the [release] method.
  $V replace1(
    $K object,
    $V object1,
  ) {
    return _replace1(reference.pointer, object.reference.pointer,
            object1.reference.pointer)
        .object(V);
  }

  static final _computeIfAbsent = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("HashMap__computeIfAbsent")
      .asFunction<
          jni.JniResult Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Void>)>();

  /// from: public V computeIfAbsent(K object, java.util.function.Function function)
  /// The returned object must be released after use, by calling the [release] method.
  $V computeIfAbsent(
    $K object,
    jni.JObject function,
  ) {
    return _computeIfAbsent(reference.pointer, object.reference.pointer,
            function.reference.pointer)
        .object(V);
  }

  static final _computeIfPresent = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("HashMap__computeIfPresent")
      .asFunction<
          jni.JniResult Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Void>)>();

  /// from: public V computeIfPresent(K object, java.util.function.BiFunction biFunction)
  /// The returned object must be released after use, by calling the [release] method.
  $V computeIfPresent(
    $K object,
    jni.JObject biFunction,
  ) {
    return _computeIfPresent(reference.pointer, object.reference.pointer,
            biFunction.reference.pointer)
        .object(V);
  }

  static final _compute = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("HashMap__compute")
      .asFunction<
          jni.JniResult Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Void>)>();

  /// from: public V compute(K object, java.util.function.BiFunction biFunction)
  /// The returned object must be released after use, by calling the [release] method.
  $V compute(
    $K object,
    jni.JObject biFunction,
  ) {
    return _compute(reference.pointer, object.reference.pointer,
            biFunction.reference.pointer)
        .object(V);
  }

  static final _merge = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("HashMap__merge")
      .asFunction<
          jni.JniResult Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public V merge(K object, V object1, java.util.function.BiFunction biFunction)
  /// The returned object must be released after use, by calling the [release] method.
  $V merge(
    $K object,
    $V object1,
    jni.JObject biFunction,
  ) {
    return _merge(reference.pointer, object.reference.pointer,
            object1.reference.pointer, biFunction.reference.pointer)
        .object(V);
  }

  static final _forEach = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("HashMap__forEach")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public void forEach(java.util.function.BiConsumer biConsumer)
  void forEach(
    jni.JObject biConsumer,
  ) {
    _forEach(reference.pointer, biConsumer.reference.pointer).check();
  }

  static final _replaceAll = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>)>>("HashMap__replaceAll")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>)>();

  /// from: public void replaceAll(java.util.function.BiFunction biFunction)
  void replaceAll(
    jni.JObject biFunction,
  ) {
    _replaceAll(reference.pointer, biFunction.reference.pointer).check();
  }

  static final _clone = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>)>>("HashMap__clone")
      .asFunction<jni.JniResult Function(ffi.Pointer<ffi.Void>)>();

  /// from: public java.lang.Object clone()
  /// The returned object must be released after use, by calling the [release] method.
  jni.JObject clone() {
    return _clone(reference.pointer).object(const jni.JObjectType());
  }
}

final class $HashMapType<$K extends jni.JObject, $V extends jni.JObject>
    extends jni.JObjType<HashMap<$K, $V>> {
  final jni.JObjType<$K> K;
  final jni.JObjType<$V> V;

  const $HashMapType(
    this.K,
    this.V,
  );

  @override
  String get signature => r"Ljava/util/HashMap;";

  @override
  HashMap<$K, $V> fromReference(jni.JReference reference) =>
      HashMap.fromReference(K, V, reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode => Object.hash($HashMapType, K, V);

  @override
  bool operator ==(Object other) {
    return other.runtimeType == ($HashMapType<$K, $V>) &&
        other is $HashMapType<$K, $V> &&
        K == other.K &&
        V == other.V;
  }
}

/// from: com.example.in_app_java.AndroidUtils
class AndroidUtils extends jni.JObject {
  @override
  late final jni.JObjType<AndroidUtils> $type = type;

  AndroidUtils.fromReference(
    jni.JReference reference,
  ) : super.fromReference(reference);

  /// The type which includes information such as the signature of this class.
  static const type = $AndroidUtilsType();
  static final _showToast = jniLookup<
          ffi.NativeFunction<
              jni.JniResult Function(ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Void>, ffi.Int32)>>("AndroidUtils__showToast")
      .asFunction<
          jni.JniResult Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, int)>();

  /// from: static public void showToast(android.app.Activity mainActivity, java.lang.CharSequence text, int duration)
  static void showToast(
    jni.JObject mainActivity,
    jni.JObject text,
    int duration,
  ) {
    _showToast(mainActivity.reference.pointer, text.reference.pointer, duration)
        .check();
  }
}

final class $AndroidUtilsType extends jni.JObjType<AndroidUtils> {
  const $AndroidUtilsType();

  @override
  String get signature => r"Lcom/example/in_app_java/AndroidUtils;";

  @override
  AndroidUtils fromReference(jni.JReference reference) =>
      AndroidUtils.fromReference(reference);

  @override
  jni.JObjType get superType => const jni.JObjectType();

  @override
  final superCount = 1;

  @override
  int get hashCode => ($AndroidUtilsType).hashCode;

  @override
  bool operator ==(Object other) {
    return other.runtimeType == ($AndroidUtilsType) &&
        other is $AndroidUtilsType;
  }
}