Quelle api.txt

Sprache: Text

import android.app.Activity;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.content.res.Configuration;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Point;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Region;
import android.net.Uri;
import android.os.Bundle;
import android.os.CancellationSignal;
import android.os.Handler;
import android.os.Looper;
import android.os.Parcel;
import android.os.ParcelFileDescriptor;
import android.os.Parcelable;
import android.print.PageRange;
import android.print.PrintAttributes;
import android.print.PrintDocumentAdapter;
import android.util.AttributeSet;
import android.util.SparseArray;
import android.view.ActionMode;
import android.view.DragEvent;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.PointerIcon;
import android.view.Surface;
import android.view.SurfaceControl;
import android.view.View;
import android.view.ViewStructure;
import android.view.autofill.AutofillValue;
import android.view.inputmethod.CursorAnchorInfo;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.ExtractedText;
import android.view.inputmethod.ExtractedTextRequest;
import android.view.inputmethod.InputConnection;
import android.widget.FrameLayout;
import androidx.annotation.AnyThread;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.UiThread;
import androidx.annotation.VisibleForTesting;
import androidx.core.view.OnApplyWindowInsetsListener;
import androidx.core.view.WindowInsetsCompat;
import java.io.File;
import java.io.InputStream;
import java.lang.Boolean;
import java.lang.CharSequence;
import java.lang.Class;
import java.lang.Comparable;
import java.lang.Deprecated;
import java.lang.Double;
import java.lang.Exception;
import java.lang.Float;
import java.lang.FunctionalInterface;
import java.lang.Integer;
import java.lang.Long;
import java.lang.Object;
import java.lang.Runnable;
import java.lang.RuntimeException;
import java.lang.SafeVarargs;
import java.lang.String;
import java.lang.Thread;
import java.lang.Throwable;
import java.lang.Void;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.net.InetAddress;
import java.nio.ByteBuffer;
import java.security.Principal;
import java.security.cert.X509Certificate;
import java.util.AbstractSequentialList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import org.json.JSONObject;
import org.mozilla.gecko.util.GeckoBundle;
import org.mozilla.geckoview.AIFeaturesController;
import org.mozilla.geckoview.AllowOrDeny;
import org.mozilla.geckoview.Autocomplete;
import org.mozilla.geckoview.Autofill;
import org.mozilla.geckoview.CompositorController;
import org.mozilla.geckoview.ContentBlocking;
import org.mozilla.geckoview.ContentBlockingController;
import org.mozilla.geckoview.CrashHandler;
import org.mozilla.geckoview.CrashPullController;
import org.mozilla.geckoview.DeprecationSchedule;
import org.mozilla.geckoview.ExperimentDelegate;
import org.mozilla.geckoview.GeckoDisplay;
import org.mozilla.geckoview.GeckoPreferenceController;
import org.mozilla.geckoview.GeckoResult;
import org.mozilla.geckoview.GeckoRuntime;
import org.mozilla.geckoview.GeckoRuntimeSettings;
import org.mozilla.geckoview.GeckoSession;
import org.mozilla.geckoview.GeckoSessionSettings;
import org.mozilla.geckoview.GeckoView;
import org.mozilla.geckoview.HandlerThread;
import org.mozilla.geckoview.IPProtectionController;
import org.mozilla.geckoview.Image;
import org.mozilla.geckoview.MediaSession;
import org.mozilla.geckoview.OrientationController;
import org.mozilla.geckoview.OverscrollEdgeEffect;
import org.mozilla.geckoview.PageExtractionController;
import org.mozilla.geckoview.PanZoomController;
import org.mozilla.geckoview.RuntimeSettings;
import org.mozilla.geckoview.ScreenLength;
import org.mozilla.geckoview.SessionAccessibility;
import org.mozilla.geckoview.SessionFinder;
import org.mozilla.geckoview.SessionPdfFileSaver;
import org.mozilla.geckoview.SessionTextInput;
import org.mozilla.geckoview.SlowScriptResponse;
import org.mozilla.geckoview.StorageController;
import org.mozilla.geckoview.TranslationsController;
import org.mozilla.geckoview.WebExtension;
import org.mozilla.geckoview.WebExtensionController;
import org.mozilla.geckoview.WebMessage;
import org.mozilla.geckoview.WebNotification;
import org.mozilla.geckoview.WebNotificationAction;
import org.mozilla.geckoview.WebNotificationDelegate;
import org.mozilla.geckoview.WebPushController;
import org.mozilla.geckoview.WebPushDelegate;
import org.mozilla.geckoview.WebPushSubscription;
import org.mozilla.geckoview.WebRequest;
import org.mozilla.geckoview.WebRequestError;
import org.mozilla.geckoview.WebResponse;

package org.mozilla.geckoview {

 public class AIFeaturesController {
 ctor public AIFeaturesController();
 }

 public static class AIFeaturesController.AIFeature {
 ctor @VisibleForTesting protected AIFeature();
 field @NonNull public final String id;
 field public final boolean isAllowed;
 field public final boolean isBlocked;
 field public final boolean isEnabled;
 }

 public static class AIFeaturesController.AIFeaturesException extends Exception {
 ctor public AIFeaturesException(int);
 field public static final int ERROR_COULD_NOT_MAKE_AVAILABLE = -5;
 field public static final int ERROR_COULD_NOT_PARSE = -2;
 field public static final int ERROR_COULD_NOT_SET = -4;
 field public static final int ERROR_UNKNOWN = -1;
 field public static final int ERROR_UNKNOWN_FEATURE = -3;
 field public final int code;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface AIFeaturesController.AIFeaturesException.Code {
 }

 public static class AIFeaturesController.RuntimeAIFeatures {
 ctor public RuntimeAIFeatures();
 method @HandlerThread @NonNull public static GeckoResult<Map<String,AIFeaturesController.AIFeature>> listFeatures();
 method @HandlerThread @NonNull public static GeckoResult<Void> makeFeatureAvailable(@NonNull String);
 method @HandlerThread @NonNull public static GeckoResult<Void> setFeatureEnablement(@NonNull String, boolean);
 }

 @AnyThread public final enum AllowOrDeny {
 method public static AllowOrDeny valueOf(String);
 method public static AllowOrDeny[] values();
 enum_constant public static final AllowOrDeny ALLOW;
 enum_constant public static final AllowOrDeny DENY;
 }

 public class Autocomplete {
 ctor protected Autocomplete();
 }

 public static class Autocomplete.Address {
 ctor @AnyThread protected Address();
 field @NonNull public final String additionalName;
 field @NonNull public final String addressLevel1;
 field @NonNull public final String addressLevel2;
 field @NonNull public final String addressLevel3;
 field @NonNull public final String country;
 field @NonNull public final String email;
 field @NonNull public final String familyName;
 field @NonNull public final String givenName;
 field @Nullable public final String guid;
 field @NonNull public final String name;
 field @NonNull public final String organization;
 field @NonNull public final String postalCode;
 field @NonNull public final String streetAddress;
 field @NonNull public final String tel;
 }

 public static class Autocomplete.Address.Builder {
 ctor @AnyThread public Builder();
 method @AnyThread @NonNull public Autocomplete.Address.Builder additionalName(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.Address.Builder addressLevel1(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.Address.Builder addressLevel2(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.Address.Builder addressLevel3(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.Address build();
 method @AnyThread @NonNull public Autocomplete.Address.Builder country(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.Address.Builder email(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.Address.Builder familyName(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.Address.Builder givenName(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.Address.Builder guid(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.Address.Builder name(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.Address.Builder organization(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.Address.Builder postalCode(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.Address.Builder streetAddress(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.Address.Builder tel(@Nullable String);
 }

 public static class Autocomplete.AddressSaveOption extends Autocomplete.SaveOption<Autocomplete.Address> {
 ctor public AddressSaveOption(@NonNull Autocomplete.Address);
 }

 public static class Autocomplete.AddressSelectOption extends Autocomplete.SelectOption<Autocomplete.Address> {
 ctor public AddressSelectOption(@NonNull Autocomplete.Address);
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface Autocomplete.AddressSelectOption.AddressSelectHint {
 }

 public static class Autocomplete.AddressSelectOption.Hint {
 ctor public Hint();
 field public static final int INSECURE_FORM = 2;
 field public static final int NONE = 0;
 }

 public static class Autocomplete.AddressStructure {
 method @HandlerThread @NonNull public static GeckoResult<List<Autocomplete.AddressStructure.Field>> getAddressStructure(@NonNull String);
 }

 public static interface Autocomplete.AddressStructure.Field {
 method @AnyThread @NonNull default public String getId();
 method @AnyThread @NonNull default public String getLocalizationKey();
 }

 public static class Autocomplete.AddressStructure.Field.SelectField implements Autocomplete.AddressStructure.Field {
 ctor public SelectField(String, String, @NonNull String, @NonNull List<Autocomplete.AddressStructure.Field.SelectField.Option>);
 field @NonNull public final String defaultValue;
 field @NonNull public final List<Autocomplete.AddressStructure.Field.SelectField.Option> options;
 }

 public static class Autocomplete.AddressStructure.Field.SelectField.Option {
 ctor public Option(@NonNull String, @NonNull String);
 field @NonNull public final String key;
 field @NonNull public final String value;
 }

 public static final class Autocomplete.AddressStructure.Field.TextField implements Autocomplete.AddressStructure.Field {
 ctor public TextField(String, String);
 }

 public static class Autocomplete.CreditCard {
 ctor @AnyThread protected CreditCard();
 field @NonNull public final String expirationMonth;
 field @NonNull public final String expirationYear;
 field @Nullable public final String guid;
 field @NonNull public final String name;
 field @NonNull public final String number;
 }

 public static class Autocomplete.CreditCard.Builder {
 ctor @AnyThread public Builder();
 method @AnyThread @NonNull public Autocomplete.CreditCard build();
 method @AnyThread @NonNull public Autocomplete.CreditCard.Builder expirationMonth(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.CreditCard.Builder expirationYear(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.CreditCard.Builder guid(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.CreditCard.Builder name(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.CreditCard.Builder number(@Nullable String);
 }

 public static class Autocomplete.CreditCardSaveOption extends Autocomplete.SaveOption<Autocomplete.CreditCard> {
 ctor public CreditCardSaveOption(@NonNull Autocomplete.CreditCard);
 }

 public static class Autocomplete.CreditCardSelectOption extends Autocomplete.SelectOption<Autocomplete.CreditCard> {
 ctor public CreditCardSelectOption(@NonNull Autocomplete.CreditCard);
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface Autocomplete.CreditCardSelectOption.CreditCardSelectHint {
 }

 public static class Autocomplete.CreditCardSelectOption.Hint {
 ctor public Hint();
 field public static final int INSECURE_FORM = 2;
 field public static final int NONE = 0;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface Autocomplete.LSUsedField {
 }

 public static class Autocomplete.LoginEntry {
 ctor @AnyThread protected LoginEntry();
 field @Nullable public final String formActionOrigin;
 field @Nullable public final String guid;
 field @Nullable public final String httpRealm;
 field @NonNull public final String origin;
 field @NonNull public final String password;
 field @NonNull public final String username;
 }

 public static class Autocomplete.LoginEntry.Builder {
 ctor @AnyThread public Builder();
 method @AnyThread @NonNull public Autocomplete.LoginEntry build();
 method @AnyThread @NonNull public Autocomplete.LoginEntry.Builder formActionOrigin(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.LoginEntry.Builder guid(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.LoginEntry.Builder httpRealm(@Nullable String);
 method @AnyThread @NonNull public Autocomplete.LoginEntry.Builder origin(@NonNull String);
 method @AnyThread @NonNull public Autocomplete.LoginEntry.Builder password(@NonNull String);
 method @AnyThread @NonNull public Autocomplete.LoginEntry.Builder username(@NonNull String);
 }

 public static class Autocomplete.LoginSaveOption extends Autocomplete.SaveOption<Autocomplete.LoginEntry> {
 ctor public LoginSaveOption(@NonNull Autocomplete.LoginEntry);
 }

 public static class Autocomplete.LoginSelectOption extends Autocomplete.SelectOption<Autocomplete.LoginEntry> {
 ctor public LoginSelectOption(@NonNull Autocomplete.LoginEntry, int);
 ctor public LoginSelectOption(@NonNull Autocomplete.LoginEntry);
 }

 public abstract static class Autocomplete.Option<T> {
 ctor public Option(@NonNull T, int);
 field public final int hint;
 field @NonNull public final T value;
 }

 public abstract static class Autocomplete.SaveOption<T> extends Autocomplete.Option<T> {
 ctor public SaveOption(@NonNull T, int);
 }

 public static class Autocomplete.SaveOption.Hint {
 ctor protected Hint();
 field public static final int GENERATED = 1;
 field public static final int LOW_CONFIDENCE = 2;
 field public static final int NONE = 0;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface Autocomplete.SaveOption.SaveOptionHint {
 }

 public abstract static class Autocomplete.SelectOption<T> extends Autocomplete.Option<T> {
 ctor public SelectOption(@NonNull T, int);
 }

 public static class Autocomplete.SelectOption.Hint {
 ctor public Hint();
 field public static final int DUPLICATE_USERNAME = 4;
 field public static final @org.mozilla.geckoview.ExperimentalGeckoViewApi int FIREFOX_RELAY = 16;
 field public static final int GENERATED = 1;
 field public static final int INSECURE_FORM = 2;
 field public static final int MATCHING_ORIGIN = 8;
 field public static final int NONE = 0;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface Autocomplete.SelectOption.SelectOptionHint {
 }

 public static interface Autocomplete.StorageDelegate {
 method @Nullable @UiThread default public GeckoResult<Autocomplete.Address[]> onAddressFetch();
 method @UiThread default public void onAddressSave(@NonNull Autocomplete.Address);
 method @Nullable @UiThread default public GeckoResult<Autocomplete.CreditCard[]> onCreditCardFetch();
 method @UiThread default public void onCreditCardSave(@NonNull Autocomplete.CreditCard);
 method @Nullable @UiThread default public GeckoResult<Autocomplete.LoginEntry[]> onLoginFetch(@NonNull String);
 method @Nullable @UiThread default public GeckoResult<Autocomplete.LoginEntry[]> onLoginFetch();
 method @UiThread default public void onLoginSave(@NonNull Autocomplete.LoginEntry);
 method @UiThread default public void onLoginUsed(@NonNull Autocomplete.LoginEntry, int);
 }

 public static class Autocomplete.UsedField {
 ctor protected UsedField();
 field public static final int PASSWORD = 1;
 }

 public class Autofill {
 ctor public Autofill();
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface Autofill.AutofillHint {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface Autofill.AutofillInputType {
 }

 public static interface Autofill.AutofillNotify {
 }

 public static interface Autofill.Delegate {
 method @UiThread default public void onNodeAdd(@NonNull GeckoSession, @NonNull Autofill.Node, @NonNull Autofill.NodeData);
 method @UiThread default public void onNodeBlur(@NonNull GeckoSession, @NonNull Autofill.Node, @NonNull Autofill.NodeData);
 method @UiThread default public void onNodeFocus(@NonNull GeckoSession, @NonNull Autofill.Node, @NonNull Autofill.NodeData);
 method @UiThread default public void onNodeRemove(@NonNull GeckoSession, @NonNull Autofill.Node, @NonNull Autofill.NodeData);
 method @UiThread default public void onNodeUpdate(@NonNull GeckoSession, @NonNull Autofill.Node, @NonNull Autofill.NodeData);
 method @UiThread default public void onSessionCancel(@NonNull GeckoSession);
 method @UiThread default public void onSessionCommit(@NonNull GeckoSession, @NonNull Autofill.Node, @NonNull Autofill.NodeData);
 method @UiThread default public void onSessionStart(@NonNull GeckoSession);
 }

 public static final class Autofill.Hint {
 method @AnyThread @Nullable public static String toString(int);
 field public static final int EMAIL_ADDRESS = 0;
 field public static final int NONE = -1;
 field public static final int PASSWORD = 1;
 field public static final int URI = 2;
 field public static final int USERNAME = 3;
 }

 public static final class Autofill.InputType {
 method @AnyThread @Nullable public static String toString(int);
 field public static final int NONE = -1;
 field public static final int NUMBER = 1;
 field public static final int PHONE = 2;
 field public static final int TEXT = 0;
 }

 public static final class Autofill.Node {
 method @AnyThread @Nullable public String getAttribute(@NonNull String);
 method @AnyThread @NonNull public Map<String,String> getAttributes();
 method @AnyThread @NonNull public Collection<Autofill.Node> getChildren();
 method @AnyThread @NonNull public String getDomain();
 method @AnyThread public boolean getEnabled();
 method @AnyThread public boolean getFocusable();
 method @AnyThread public int getHint();
 method @AnyThread public int getInputType();
 method @AnyThread @NonNull public Rect getScreenRect();
 method @AnyThread @NonNull public String getTag();
 }

 public static class Autofill.NodeData {
 method @AnyThread public int getId();
 method @AnyThread @Nullable public String getValue();
 }

 public static final class Autofill.Session {
 method @UiThread public void autofill(@NonNull SparseArray<CharSequence>);
 method @NonNull @UiThread public Autofill.NodeData dataFor(@NonNull Autofill.Node);
 method @UiThread public void fillViewStructure(@NonNull View, @NonNull ViewStructure, int);
 method @UiThread public void fillViewStructure(@NonNull Autofill.Node, @NonNull View, @NonNull ViewStructure, int);
 method @NonNull @UiThread public Rect getDefaultDimensions();
 method @Nullable @UiThread public Autofill.Node getFocused();
 method @Nullable @UiThread public Autofill.NodeData getFocusedData();
 method @AnyThread @NonNull public Autofill.Node getRoot();
 method @UiThread public boolean isVisible(@NonNull Autofill.Node);
 }

 @UiThread public class BasicSelectionActionDelegate implements ActionMode.Callback GeckoSession.SelectionActionDelegate {
 ctor public BasicSelectionActionDelegate(@NonNull Activity);
 ctor public BasicSelectionActionDelegate(@NonNull Activity, boolean);
 method public boolean areExternalActionsEnabled();
 method public void clearSelection();
 method public void enableExternalActions(boolean);
 method @Nullable public GeckoSession.SelectionActionDelegate.Selection getSelection();
 method public boolean isActionAvailable();
 method public void onGetContentRect(@Nullable ActionMode, @Nullable View, @NonNull Rect);
 method @NonNull protected String[] getAllActions();
 method protected boolean isActionAvailable(@NonNull String);
 method protected boolean performAction(@NonNull String, @NonNull MenuItem);
 method protected void prepareAction(@NonNull String, @NonNull MenuItem);
 field protected static final String ACTION_PROCESS_TEXT = "android.intent.action.PROCESS_TEXT";
 field @Nullable protected ActionMode mActionMode;
 field @NonNull protected final Activity mActivity;
 field protected boolean mRepopulatedMenu;
 field @Nullable protected GeckoSession.SelectionActionDelegate.Selection mSelection;
 field @Nullable protected GeckoSession mSession;
 field protected final boolean mUseFloatingToolbar;
 }

 @UiThread public final class CompositorController {
 method public void addDrawCallback(@NonNull Runnable);
 method public int getClearColor();
 method @Nullable public Runnable getFirstPaintCallback();
 method public void onPipModeChanged(boolean);
 method public void removeDrawCallback(@NonNull Runnable);
 method public void setClearColor(int);
 method public void setFirstPaintCallback(@Nullable Runnable);
 }

 @AnyThread public class ContentBlocking {
 ctor protected ContentBlocking();
 field public static final ContentBlocking.SafeBrowsingProvider GOOGLE_LEGACY_SAFE_BROWSING_PROVIDER;
 field public static final ContentBlocking.SafeBrowsingProvider GOOGLE_SAFE_BROWSING_PROVIDER;
 field public static final ContentBlocking.SafeBrowsingProvider GOOGLE_SAFE_BROWSING_V5_PROVIDER;
 }

 public static class ContentBlocking.AntiTracking {
 ctor protected AntiTracking();
 field public static final int AD = 2;
 field public static final int ANALYTIC = 4;
 field public static final int CONTENT = 16;
 field public static final int CRYPTOMINING = 64;
 field public static final int DEFAULT = 46;
 field public static final int EMAIL = 512;
 field public static final int FINGERPRINTING = 128;
 field public static final int NONE = 0;
 field public static final int SOCIAL = 8;
 field public static final int STP = 256;
 field public static final int STRICT = 766;
 field public static final int TEST = 32;
 }

 public static class ContentBlocking.BlockEvent {
 ctor public BlockEvent(@NonNull String, int, int, int, boolean);
 method @UiThread public int getAntiTrackingCategory();
 method @UiThread public int getCookieBehaviorCategory();
 method @UiThread public int getSafeBrowsingCategory();
 method @UiThread public boolean isBlocking();
 field @NonNull public final String uri;
 }

 public static class ContentBlocking.BounceTrackingProtectionMode {
 ctor protected BounceTrackingProtectionMode();
 field public static final int BOUNCE_TRACKING_PROTECTION_MODE_DISABLED = 0;
 field public static final int BOUNCE_TRACKING_PROTECTION_MODE_ENABLED = 1;
 field public static final int BOUNCE_TRACKING_PROTECTION_MODE_ENABLED_DRY_RUN = 3;
 field public static final int BOUNCE_TRACKING_PROTECTION_MODE_ENABLED_STANDBY = 2;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface ContentBlocking.CBAntiTracking {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface ContentBlocking.CBCBounceTrackingProtectionMode {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface ContentBlocking.CBCookieBannerMode {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface ContentBlocking.CBCookieBehavior {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface ContentBlocking.CBEtpCategory {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface ContentBlocking.CBEtpLevel {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface ContentBlocking.CBSafeBrowsing {
 }

 public static class ContentBlocking.CookieBannerMode {
 ctor protected CookieBannerMode();
 field public static final int COOKIE_BANNER_MODE_DISABLED = 0;
 field public static final int COOKIE_BANNER_MODE_REJECT = 1;
 field public static final int COOKIE_BANNER_MODE_REJECT_OR_ACCEPT = 2;
 }

 public static class ContentBlocking.CookieBehavior {
 ctor protected CookieBehavior();
 field public static final int ACCEPT_ALL = 0;
 field public static final int ACCEPT_FIRST_PARTY = 1;
 field public static final int ACCEPT_FIRST_PARTY_AND_ISOLATE_OTHERS = 5;
 field public static final int ACCEPT_NONE = 2;
 field public static final int ACCEPT_NON_TRACKERS = 4;
 field public static final int ACCEPT_VISITED = 3;
 }

 public static interface ContentBlocking.Delegate {
 method @UiThread default public void onContentBlocked(@NonNull GeckoSession, @NonNull ContentBlocking.BlockEvent);
 method @UiThread default public void onContentLoaded(@NonNull GeckoSession, @NonNull ContentBlocking.BlockEvent);
 }

 public static class ContentBlocking.EtpCategory {
 ctor public EtpCategory();
 field public static final int CUSTOM = 2;
 field public static final int STANDARD = 0;
 field public static final int STRICT = 1;
 }

 public static class ContentBlocking.EtpLevel {
 ctor public EtpLevel();
 field public static final int DEFAULT = 1;
 field public static final int NONE = 0;
 field public static final int STRICT = 2;
 }

 public static class ContentBlocking.SafeBrowsing {
 ctor protected SafeBrowsing();
 field public static final int DEFAULT = 31744;
 field public static final int HARMFUL = 4096;
 field public static final int HARMFULADDON = 16384;
 field public static final int MALWARE = 1024;
 field public static final int NONE = 0;
 field public static final int PHISHING = 8192;
 field public static final int UNWANTED = 2048;
 }

 @AnyThread public static class ContentBlocking.SafeBrowsingProvider extends RuntimeSettings {
 method @NonNull public static ContentBlocking.SafeBrowsingProvider.Builder from(@NonNull ContentBlocking.SafeBrowsingProvider);
 method @Nullable public String getAdvisoryName();
 method @Nullable public String getAdvisoryUrl();
 method @Nullable public Boolean getDataSharingEnabled();
 method @Nullable public String getDataSharingUrl();
 method @Nullable public Boolean getEnabled();
 method @Nullable public String getGetHashUrl();
 method @NonNull public String[] getLists();
 method @NonNull public String getName();
 method @Nullable public String getReportMalwareMistakeUrl();
 method @Nullable public String getReportPhishingMistakeUrl();
 method @Nullable public String getReportUrl();
 method @Nullable public String getUpdateUrl();
 method @Nullable public String getVersion();
 method @NonNull public static ContentBlocking.SafeBrowsingProvider.Builder withName(@NonNull String);
 field public static final Parcelable.Creator<ContentBlocking.SafeBrowsingProvider> CREATOR;
 }

 @AnyThread public static class ContentBlocking.SafeBrowsingProvider.Builder {
 method @NonNull public ContentBlocking.SafeBrowsingProvider.Builder advisoryName(@NonNull String);
 method @NonNull public ContentBlocking.SafeBrowsingProvider.Builder advisoryUrl(@NonNull String);
 method @NonNull public ContentBlocking.SafeBrowsingProvider build();
 method @NonNull public ContentBlocking.SafeBrowsingProvider.Builder dataSharingEnabled(boolean);
 method @NonNull public ContentBlocking.SafeBrowsingProvider.Builder dataSharingUrl(@NonNull String);
 method @NonNull public ContentBlocking.SafeBrowsingProvider.Builder enabled(boolean);
 method @NonNull public ContentBlocking.SafeBrowsingProvider.Builder getHashUrl(@NonNull String);
 method @NonNull public ContentBlocking.SafeBrowsingProvider.Builder lists(@NonNull String...);
 method @NonNull public ContentBlocking.SafeBrowsingProvider.Builder reportMalwareMistakeUrl(@NonNull String);
 method @NonNull public ContentBlocking.SafeBrowsingProvider.Builder reportPhishingMistakeUrl(@NonNull String);
 method @NonNull public ContentBlocking.SafeBrowsingProvider.Builder reportUrl(@NonNull String);
 method @NonNull public ContentBlocking.SafeBrowsingProvider.Builder updateUrl(@NonNull String);
 method @NonNull public ContentBlocking.SafeBrowsingProvider.Builder version(@NonNull String);
 }

 @AnyThread public static class ContentBlocking.Settings extends RuntimeSettings {
 method public boolean getAllowListBaselineTrackingProtection();
 method public boolean getAllowListConvenienceTrackingProtection();
 method public int getAntiTrackingCategories();
 method public int getBounceTrackingProtectionMode();
 method public boolean getContentBlockingDatabaseStatus();
 method public boolean getCookieBannerDetectOnlyMode();
 method public boolean getCookieBannerGlobalRulesEnabled();
 method public boolean getCookieBannerGlobalRulesSubFramesEnabled();
 method public int getCookieBannerMode();
 method public int getCookieBannerModePrivateBrowsing();
 method public int getCookieBehavior();
 method public int getCookieBehaviorPrivateMode();
 method public boolean getCookiePurging();
 method @NonNull public Boolean getEmailTrackerBlockingPrivateBrowsingEnabled();
 method public int getEnhancedTrackingProtectionCategory();
 method public int getEnhancedTrackingProtectionLevel();
 method @NonNull public String[] getQueryParameterStrippingAllowList();
 method public boolean getQueryParameterStrippingEnabled();
 method public boolean getQueryParameterStrippingPrivateBrowsingEnabled();
 method @NonNull public String[] getQueryParameterStrippingStripList();
 method public int getSafeBrowsingCategories();
 method public boolean getSafeBrowsingGlobalCacheEnabled();
 method @NonNull public String[] getSafeBrowsingMalwareTable();
 method @NonNull public String[] getSafeBrowsingPhishingTable();
 method @NonNull public Collection<ContentBlocking.SafeBrowsingProvider> getSafeBrowsingProviders();
 method public boolean getSafeBrowsingRealTimeEnabled();
 method public @org.mozilla.geckoview.ExperimentalGeckoViewApi int getSafeBrowsingRealTimeSimulationCacheTTLSec();
 method public @org.mozilla.geckoview.ExperimentalGeckoViewApi boolean getSafeBrowsingRealTimeSimulationEnabled();
 method public @org.mozilla.geckoview.ExperimentalGeckoViewApi int getSafeBrowsingRealTimeSimulationHitProbability();
 method public @org.mozilla.geckoview.ExperimentalGeckoViewApi boolean getSafeBrowsingRealTimeSimulationNegativeCacheEnabled();
 method public @org.mozilla.geckoview.ExperimentalGeckoViewApi int getSafeBrowsingRealTimeSimulationNegativeCacheTTLSec();
 method @NonNull public Boolean getSafeBrowsingV5Enabled();
 method public boolean getStrictSocialTrackingProtection();
 method @NonNull public ContentBlocking.Settings setAllowListBaselineTrackingProtection(boolean);
 method @NonNull public ContentBlocking.Settings setAllowListConvenienceTrackingProtection(boolean);
 method @NonNull public ContentBlocking.Settings setAntiTracking(int);
 method @NonNull public ContentBlocking.Settings setBounceTrackingProtectionMode(int);
 method @NonNull public ContentBlocking.Settings setContentBlockingDatabaseStatus(boolean);
 method @NonNull public ContentBlocking.Settings setCookieBannerDetectOnlyMode(boolean);
 method @NonNull public ContentBlocking.Settings setCookieBannerGlobalRulesEnabled(boolean);
 method @NonNull public ContentBlocking.Settings setCookieBannerGlobalRulesSubFramesEnabled(boolean);
 method @NonNull public ContentBlocking.Settings setCookieBannerMode(int);
 method @NonNull public ContentBlocking.Settings setCookieBannerModePrivateBrowsing(int);
 method @NonNull public ContentBlocking.Settings setCookieBehavior(int);
 method @NonNull public ContentBlocking.Settings setCookieBehaviorPrivateMode(int);
 method @NonNull public ContentBlocking.Settings setCookiePurging(boolean);
 method @NonNull public ContentBlocking.Settings setEmailTrackerBlockingPrivateBrowsing(boolean);
 method @NonNull public ContentBlocking.Settings setEnhancedTrackingProtectionCategory(int);
 method @NonNull public ContentBlocking.Settings setEnhancedTrackingProtectionLevel(int);
 method @NonNull public ContentBlocking.Settings setQueryParameterStrippingAllowList(@NonNull String...);
 method @NonNull public ContentBlocking.Settings setQueryParameterStrippingEnabled(boolean);
 method @NonNull public ContentBlocking.Settings setQueryParameterStrippingPrivateBrowsingEnabled(boolean);
 method @NonNull public ContentBlocking.Settings setQueryParameterStrippingStripList(@NonNull String...);
 method @NonNull public ContentBlocking.Settings setSafeBrowsing(int);
 method @NonNull public ContentBlocking.Settings setSafeBrowsingGlobalCacheEnabled(boolean);
 method @NonNull public ContentBlocking.Settings setSafeBrowsingMalwareTable(@NonNull String...);
 method @NonNull public ContentBlocking.Settings setSafeBrowsingPhishingTable(@NonNull String...);
 method @NonNull public ContentBlocking.Settings setSafeBrowsingProviders(@NonNull ContentBlocking.SafeBrowsingProvider...);
 method @NonNull public ContentBlocking.Settings setSafeBrowsingRealTimeEnabled(boolean);
 method @NonNull public ContentBlocking.Settings setSafeBrowsingRealTimeSimulationCacheTTLSec(int);
 method @NonNull public ContentBlocking.Settings setSafeBrowsingRealTimeSimulationEnabled(boolean);
 method @NonNull public ContentBlocking.Settings setSafeBrowsingRealTimeSimulationHitProbability(int);
 method @NonNull public ContentBlocking.Settings setSafeBrowsingRealTimeSimulationNegativeCacheEnabled(boolean);
 method @NonNull public ContentBlocking.Settings setSafeBrowsingRealTimeSimulationNegativeCacheTTLSec(int);
 method @NonNull public ContentBlocking.Settings setSafeBrowsingV5Enabled(boolean);
 method @NonNull public ContentBlocking.Settings setStrictSocialTrackingProtection(boolean);
 field public static final Parcelable.Creator<ContentBlocking.Settings> CREATOR;
 }

 @AnyThread public static class ContentBlocking.Settings.Builder extends RuntimeSettings.Builder<ContentBlocking.Settings> {
 ctor public Builder();
 method @NonNull public ContentBlocking.Settings.Builder allowListBaselineTrackingProtection(boolean);
 method @NonNull public ContentBlocking.Settings.Builder allowListConvenienceTrackingProtection(boolean);
 method @NonNull public ContentBlocking.Settings.Builder antiTracking(int);
 method @NonNull public ContentBlocking.Settings.Builder bounceTrackingProtectionMode(int);
 method @NonNull public ContentBlocking.Settings.Builder contentBlockingDatabase(boolean);
 method @NonNull public ContentBlocking.Settings.Builder cookieBannerGlobalRulesEnabled(boolean);
 method @NonNull public ContentBlocking.Settings.Builder cookieBannerGlobalRulesSubFramesEnabled(boolean);
 method @NonNull public ContentBlocking.Settings.Builder cookieBannerHandlingDetectOnlyMode(boolean);
 method @NonNull public ContentBlocking.Settings.Builder cookieBannerHandlingMode(int);
 method @NonNull public ContentBlocking.Settings.Builder cookieBannerHandlingModePrivateBrowsing(int);
 method @NonNull public ContentBlocking.Settings.Builder cookieBehavior(int);
 method @NonNull public ContentBlocking.Settings.Builder cookieBehaviorPrivateMode(int);
 method @NonNull public ContentBlocking.Settings.Builder cookiePurging(boolean);
 method @NonNull public ContentBlocking.Settings.Builder emailTrackerBlockingPrivateMode(boolean);
 method @NonNull public ContentBlocking.Settings.Builder enhancedTrackingProtectionCategory(int);
 method @NonNull public ContentBlocking.Settings.Builder enhancedTrackingProtectionLevel(int);
 method @NonNull public ContentBlocking.Settings.Builder queryParameterStrippingAllowList(@NonNull String...);
 method @NonNull public ContentBlocking.Settings.Builder queryParameterStrippingEnabled(boolean);
 method @NonNull public ContentBlocking.Settings.Builder queryParameterStrippingPrivateBrowsingEnabled(boolean);
 method @NonNull public ContentBlocking.Settings.Builder queryParameterStrippingStripList(@NonNull String...);
 method @NonNull public ContentBlocking.Settings.Builder safeBrowsing(int);
 method @NonNull public ContentBlocking.Settings.Builder safeBrowsingGlobalCacheEnabled(boolean);
 method @NonNull public ContentBlocking.Settings.Builder safeBrowsingMalwareTable(@NonNull String[]);
 method @NonNull public ContentBlocking.Settings.Builder safeBrowsingPhishingTable(@NonNull String[]);
 method @NonNull public ContentBlocking.Settings.Builder safeBrowsingProviders(@NonNull ContentBlocking.SafeBrowsingProvider...);
 method @NonNull public ContentBlocking.Settings.Builder safeBrowsingRealTimeEnabled(boolean);
 method @NonNull public ContentBlocking.Settings.Builder safeBrowsingRealTimeSimulationCacheTTLSec(int);
 method @NonNull public ContentBlocking.Settings.Builder safeBrowsingRealTimeSimulationEnabled(boolean);
 method @NonNull public ContentBlocking.Settings.Builder safeBrowsingRealTimeSimulationHitProbability(int);
 method @NonNull public ContentBlocking.Settings.Builder safeBrowsingRealTimeSimulationNegativeCacheEnabled(boolean);
 method @NonNull public ContentBlocking.Settings.Builder safeBrowsingRealTimeSimulationNegativeCacheTTLSec(int);
 method @NonNull public ContentBlocking.Settings.Builder strictSocialTrackingProtection(boolean);
 method @NonNull protected ContentBlocking.Settings newSettings(@Nullable ContentBlocking.Settings);
 }

 @AnyThread public class ContentBlockingController {
 ctor public ContentBlockingController();
 method @HandlerThread @NonNull public GeckoResult<Void> clearTrackingDb();
 method @NonNull @UiThread public GeckoResult<List<ContentBlockingController.LogEntry>> getLog(@NonNull GeckoSession);
 method @HandlerThread @NonNull public GeckoResult<Long> getTrackingDbEarliestRecordedDate();
 method @HandlerThread @NonNull public GeckoResult<List<ContentBlockingController.TrackingDbEvent>> getTrackingDbEventsByDateRange(long, long);
 method @HandlerThread @NonNull public GeckoResult<Integer> sumAllTrackingDbEvents();
 }

 public static class ContentBlockingController.Event {
 ctor protected Event();
 field public static final int ALLOWED_TRACKING_CONTENT = 32;
 field public static final int BLOCKED_CRYPTOMINING_CONTENT = 2048;
 field public static final int BLOCKED_EMAILTRACKING_CONTENT = 4194304;
 field public static final int BLOCKED_FINGERPRINTING_CONTENT = 64;
 field public static final int BLOCKED_SOCIALTRACKING_CONTENT = 65536;
 field public static final int BLOCKED_SUSPICIOUS_FINGERPRINTING = 4;
 field public static final int BLOCKED_TRACKING_CONTENT = 4096;
 field public static final int BLOCKED_UNSAFE_CONTENT = 16384;
 field public static final int COOKIES_BLOCKED_ALL = 1073741824;
 field public static final int COOKIES_BLOCKED_BY_PERMISSION = 268435456;
 field public static final int COOKIES_BLOCKED_FOREIGN = 128;
 field public static final int COOKIES_BLOCKED_SOCIALTRACKER = 16777216;
 field public static final int COOKIES_BLOCKED_TRACKER = 536870912;
 field public static final int COOKIES_LOADED = 32768;
 field public static final int COOKIES_LOADED_SOCIALTRACKER = 524288;
 field public static final int COOKIES_LOADED_TRACKER = 262144;
 field public static final int COOKIES_PARTITIONED_FOREIGN = -2147483648;
 field public static final int COOKIES_PARTITIONED_TRACKER = 2;
 field public static final int LOADED_CRYPTOMINING_CONTENT = 2097152;
 field public static final int LOADED_EMAILTRACKING_LEVEL_1_CONTENT = 8388608;
 field public static final int LOADED_EMAILTRACKING_LEVEL_2_CONTENT = 256;
 field public static final int LOADED_FINGERPRINTING_CONTENT = 1024;
 field public static final int LOADED_LEVEL_1_TRACKING_CONTENT = 8192;
 field public static final int LOADED_LEVEL_2_TRACKING_CONTENT = 1048576;
 field public static final int LOADED_SOCIALTRACKING_CONTENT = 131072;
 field public static final int PURGED_BOUNCETRACKER = 8;
 field public static final int REPLACED_FINGERPRINTING_CONTENT = 134217728;
 field public static final int REPLACED_TRACKING_CONTENT = 16;
 }

 @AnyThread public static class ContentBlockingController.LogEntry {
 ctor protected LogEntry();
 field @NonNull public final List<ContentBlockingController.LogEntry.BlockingData> blockingData;
 field @NonNull public final String origin;
 }

 public static class ContentBlockingController.LogEntry.BlockingData {
 ctor protected BlockingData();
 field public final boolean blocked;
 field public final int category;
 field public final int count;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface ContentBlockingController.LogEntry.BlockingData.LogEvent {
 }

 @AnyThread public static class ContentBlockingController.TrackingDbEvent {
 ctor protected TrackingDbEvent();
 field public static final int BOUNCETRACKERS_ID = 7;
 field public static final int CRYPTOMINERS_ID = 3;
 field public static final int FINGERPRINTERS_ID = 4;
 field public static final int OTHER_COOKIES_BLOCKED_ID = 0;
 field public static final int SOCIAL_ID = 5;
 field public static final int SUSPICIOUS_FINGERPRINTERS_ID = 6;
 field public static final int TRACKERS_ID = 1;
 field public static final int TRACKING_COOKIES_ID = 2;
 field public final int count;
 field @Nullable public final String date;
 field public final int type;
 }

 @FunctionalInterface public class CrashHandler implements Thread.UncaughtExceptionHandler {
 ctor public CrashHandler(@Nullable Class<? extends android.app.Service>);
 ctor public CrashHandler(@Nullable Context, @Nullable Class<? extends android.app.Service>);
 ctor public CrashHandler(Thread, Class<? extends android.app.Service>);
 ctor public CrashHandler(@Nullable Thread, Context, Class<? extends android.app.Service>);
 method @AnyThread @NonNull public static CrashHandler createDefaultCrashHandler(@NonNull Context);
 method @AnyThread @Nullable public Context getAppContext();
 method @AnyThread @Nullable public String getAppPackageName();
 method @AnyThread @NonNull public byte[] getCrashDump(@Nullable Thread, @Nullable Throwable);
 method @AnyThread @NonNull public Bundle getCrashExtras(@NonNull Thread, @NonNull Throwable);
 method @AnyThread @NonNull public static String getExceptionStackTrace(@NonNull Throwable);
 method @AnyThread @NonNull public static Throwable getRootException(@NonNull Throwable);
 method @AnyThread @NonNull public String getServerUrl(@NonNull Bundle);
 method @AnyThread public boolean launchCrashReporter(@NonNull String, @NonNull String);
 method @AnyThread public static void logException(@NonNull Thread, @NonNull Throwable);
 method @AnyThread public boolean reportException(@NonNull Thread, @NonNull Throwable);
 method @AnyThread public static void terminateProcess();
 method @AnyThread public void unregister();
 }

 public class CrashPullController {
 ctor public CrashPullController();
 }

 public static interface CrashPullController.Delegate {
 method @UiThread default public void onCrashPull(@NonNull String[]);
 }

 public class CrashReporter {
 ctor public CrashReporter();
 method @AnyThread @NonNull public static GeckoResult<String> sendCrashReport(@NonNull Context, @NonNull Intent, @NonNull String);
 method @AnyThread @NonNull public static GeckoResult<String> sendCrashReport(@NonNull Context, @NonNull Bundle, @NonNull String);
 method @AnyThread @NonNull public static GeckoResult<String> sendCrashReport(@NonNull Context, @NonNull File, @NonNull File, @NonNull String);
 }

 @Documented @Retention(value=RetentionPolicy.RUNTIME) @Target(value={ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.LOCAL_VARIABLE, ElementType.METHOD, ElementType.PACKAGE, ElementType.PARAMETER, ElementType.TYPE}) public interface DeprecationSchedule {
 element public String id();
 element public int version();
 }

 public interface ExperimentDelegate {
 method @HandlerThread @NonNull default public GeckoResult<JSONObject> onGetExperimentFeature(@NonNull String);
 method @HandlerThread @NonNull default public GeckoResult<Void> onRecordExperimentExposureEvent(@NonNull String, @NonNull String);
 method @HandlerThread @NonNull default public GeckoResult<Void> onRecordExposureEvent(@NonNull String);
 method @HandlerThread @NonNull default public GeckoResult<Void> onRecordMalformedConfigurationEvent(@NonNull String, @NonNull String);
 }

 public static class ExperimentDelegate.ExperimentException extends Exception {
 ctor public ExperimentException(int);
 field public static final int ERROR_EXPERIMENT_DELEGATE_NOT_IMPLEMENTED = -4;
 field public static final int ERROR_EXPERIMENT_SLUG_NOT_FOUND = -3;
 field public static final int ERROR_FEATURE_NOT_FOUND = -2;
 field public static final int ERROR_UNKNOWN = -1;
 field public final int code;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface ExperimentDelegate.ExperimentException.Codes {
 }

 @Retention(value=RetentionPolicy.CLASS) @Target(value={ElementType.TYPE, ElementType.TYPE_USE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.PACKAGE}) public interface ExperimentalGeckoViewApi {
 }

 public class GeckoDisplay {
 ctor protected GeckoDisplay(GeckoSession);
 method @NonNull @UiThread public GeckoResult<Bitmap> capturePixels();
 method @UiThread public void safeAreaInsetsChanged(int, int, int, int);
 method @UiThread public void screenOriginChanged(int, int);
 method @NonNull @UiThread public GeckoDisplay.ScreenshotBuilder screenshot();
 method @UiThread public void setDynamicToolbarMaxHeight(int);
 method @UiThread public void setVerticalClipping(int);
 method @UiThread public boolean shouldPinOnScreen();
 method @UiThread public void surfaceChanged(@NonNull GeckoDisplay.SurfaceInfo);
 method @UiThread public void surfaceDestroyed();
 method @UiThread public void windowInsetsChanged(@NonNull WindowInsetsCompat);
 }

 public static interface GeckoDisplay.NewSurfaceProvider {
 method @UiThread public void requestNewSurface();
 }

 public static final class GeckoDisplay.ScreenshotBuilder {
 method @AnyThread @NonNull public GeckoDisplay.ScreenshotBuilder aspectPreservingSize(int);
 method @AnyThread @NonNull public GeckoDisplay.ScreenshotBuilder bitmap(@Nullable Bitmap);
 method @NonNull @UiThread public GeckoResult<Bitmap> capture();
 method @AnyThread @NonNull public GeckoDisplay.ScreenshotBuilder scale(float);
 method @AnyThread @NonNull public GeckoDisplay.ScreenshotBuilder size(int, int);
 method @AnyThread @NonNull public GeckoDisplay.ScreenshotBuilder source(int, int, int, int);
 method @AnyThread @NonNull public GeckoDisplay.ScreenshotBuilder source(@NonNull Rect);
 }

 public static class GeckoDisplay.SurfaceInfo {
 }

 public static class GeckoDisplay.SurfaceInfo.Builder {
 ctor public Builder(@NonNull Surface);
 method @NonNull @UiThread public GeckoDisplay.SurfaceInfo build();
 method @NonNull @UiThread public GeckoDisplay.SurfaceInfo.Builder newSurfaceProvider(@Nullable GeckoDisplay.NewSurfaceProvider);
 method @NonNull @UiThread public GeckoDisplay.SurfaceInfo.Builder offset(int, int);
 method @NonNull @UiThread public GeckoDisplay.SurfaceInfo.Builder size(int, int);
 method @NonNull @UiThread public GeckoDisplay.SurfaceInfo.Builder surfaceControl(@Nullable SurfaceControl);
 }

 public class GeckoPreferenceController {
 ctor public GeckoPreferenceController();
 method @HandlerThread @NonNull public static GeckoResult<Void> clearGeckoUserPref(@NonNull String);
 method @HandlerThread @NonNull public static GeckoResult<GeckoPreferenceController.GeckoPreference<?>> getGeckoPref(@NonNull String);
 method @HandlerThread @NonNull public static GeckoResult<List<GeckoPreferenceController.GeckoPreference<?>>> getGeckoPrefs(@NonNull List<String>);
 method @HandlerThread @NonNull public static GeckoResult<Void> setGeckoPref(@NonNull String, @NonNull String, int);
 method @HandlerThread @NonNull public static GeckoResult<Void> setGeckoPref(@NonNull String, @NonNull Integer, int);
 method @HandlerThread @NonNull public static GeckoResult<Void> setGeckoPref(@NonNull String, @NonNull Boolean, int);
 method @HandlerThread @NonNull public static GeckoResult<Map<String,Boolean>> setGeckoPrefs(@NonNull List<GeckoPreferenceController.SetGeckoPreference<?>>);
 field public static final int PREF_BRANCH_DEFAULT = 1;
 field public static final int PREF_BRANCH_USER = 0;
 field public static final int PREF_TYPE_BOOL = 128;
 field public static final int PREF_TYPE_INT = 64;
 field public static final int PREF_TYPE_INVALID = 0;
 field public static final int PREF_TYPE_STRING = 32;
 }

 public static class GeckoPreferenceController.GeckoPreference<T> {
 method @AnyThread public boolean getHasUserChangedValue();
 method @AnyThread @Nullable public T getValue();
 field @Nullable public final T defaultValue;
 field @NonNull public final String pref;
 field public final int type;
 field @Nullable public final T userValue;
 }

 public static final class GeckoPreferenceController.Observer {
 ctor public Observer();
 method @HandlerThread @NonNull public static GeckoResult<Void> registerPreference(@NonNull String);
 method @HandlerThread @NonNull public static GeckoResult<Void> registerPreferences(@NonNull List<String>);
 method @NonNull @UiThread public static GeckoResult<Void> unregisterPreference(@NonNull String);
 method @NonNull @UiThread public static GeckoResult<Void> unregisterPreferences(@NonNull List<String>);
 }

 public static interface GeckoPreferenceController.Observer.Delegate {
 method @HandlerThread default public void onGeckoPreferenceChange(@NonNull GeckoPreferenceController.GeckoPreference<?>);
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoPreferenceController.PrefBranch {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoPreferenceController.PrefType {
 }

 public static class GeckoPreferenceController.SetGeckoPreference<T> {
 method @AnyThread @NonNull public static GeckoPreferenceController.SetGeckoPreference<Boolean> setBoolPref(@NonNull String, @NonNull Boolean, int);
 method @AnyThread @NonNull public static GeckoPreferenceController.SetGeckoPreference<Integer> setIntPref(@NonNull String, @NonNull Integer, int);
 method @AnyThread @NonNull public static GeckoPreferenceController.SetGeckoPreference<String> setStringPref(@NonNull String, @NonNull String, int);
 field public final int branch;
 field @NonNull public final String pref;
 field public final int type;
 field @NonNull public final T value;
 }

 @AnyThread public class GeckoResult<T> {
 ctor public GeckoResult();
 ctor public GeckoResult(Handler);
 ctor public GeckoResult(GeckoResult<T>);
 method @NonNull public GeckoResult<Void> accept(@Nullable GeckoResult.Consumer<T>);
 method @NonNull public GeckoResult<Void> accept(@Nullable GeckoResult.Consumer<T>, @Nullable GeckoResult.Consumer<Throwable>);
 method @NonNull @SafeVarargs public static <V> GeckoResult<List<V>> allOf(@NonNull GeckoResult<V>...);
 method @NonNull public static <V> GeckoResult<List<V>> allOf(@Nullable List<GeckoResult<V>>);
 method @AnyThread @NonNull public static GeckoResult<AllowOrDeny> allow();
 method @NonNull public synchronized GeckoResult<Boolean> cancel();
 method public synchronized void complete(@Nullable T);
 method public synchronized void completeExceptionally(@NonNull Throwable);
 method public void completeFrom(@Nullable GeckoResult<T>);
 method @AnyThread @NonNull public static GeckoResult<AllowOrDeny> deny();
 method @NonNull public GeckoResult exceptionally(@NonNull GeckoResult.OnExceptionListener);
 method @NonNull public GeckoResult<Void> finally_(@NonNull Runnable);
 method @NonNull public static <T> GeckoResult<T> fromException(@NonNull Throwable);
 method @NonNull public static GeckoResult fromValue(@Nullable U);
 method @Nullable public Looper getLooper();
 method @NonNull public GeckoResult map(@Nullable GeckoResult.OnValueMapper<T,U>);
 method @NonNull public GeckoResult map(@Nullable GeckoResult.OnValueMapper<T,U>, @Nullable GeckoResult.OnExceptionMapper);
 method @Nullable public synchronized T poll();
 method @Nullable public synchronized T poll(long);
 method public void setCancellationDelegate(@Nullable GeckoResult.CancellationDelegate);
 method @NonNull public GeckoResult then(@NonNull GeckoResult.OnValueListener<T,U>);
 method @NonNull public GeckoResult then(@Nullable GeckoResult.OnValueListener<T,U>, @Nullable GeckoResult.OnExceptionListener);
 method @NonNull public GeckoResult<T> withHandler(@Nullable Handler);
 }

 @AnyThread public static interface GeckoResult.CancellationDelegate {
 method @NonNull default public GeckoResult<Boolean> cancel();
 }

 public static interface GeckoResult.Consumer<T> {
 method @AnyThread public void accept(@Nullable T);
 }

 public static interface GeckoResult.OnExceptionListener<V> {
 method @AnyThread @Nullable public GeckoResult<V> onException(@NonNull Throwable);
 }

 public static interface GeckoResult.OnExceptionMapper {
 method @AnyThread @Nullable public Throwable onException(@NonNull Throwable);
 }

 public static interface GeckoResult.OnValueListener<T,U> {
 method @AnyThread @Nullable public GeckoResult onValue(@Nullable T);
 }

 public static interface GeckoResult.OnValueMapper<T,U> {
 method @AnyThread @Nullable public U onValue(@Nullable T);
 }

 public static final class GeckoResult.UncaughtException extends RuntimeException {
 ctor public UncaughtException(Throwable);
 }

 public final class GeckoRuntime implements Parcelable {
 method @AnyThread public void appendAppNotesToCrashReport(@NonNull String);
 method @UiThread public void attachTo(@NonNull Context);
 method @UiThread public void configurationChanged(@NonNull Configuration);
 method @NonNull @UiThread public static GeckoRuntime create(@NonNull Context);
 method @NonNull @UiThread public static GeckoRuntime create(@NonNull Context, @NonNull GeckoRuntimeSettings);
 method @Nullable @UiThread public GeckoRuntime.ActivityDelegate getActivityDelegate();
 method @Nullable @UiThread public Autocomplete.StorageDelegate getAutocompleteStorageDelegate();
 method @NonNull @UiThread public ContentBlockingController getContentBlockingController();
 method @Nullable @UiThread public CrashPullController.Delegate getCrashPullDelegate();
 method @NonNull @UiThread public static synchronized GeckoRuntime getDefault(@NonNull Context);
 method @Nullable @UiThread public GeckoRuntime.Delegate getDelegate();
 method @NonNull @UiThread public IPProtectionController getIPProtectionController();
 method @NonNull @UiThread public OrientationController getOrientationController();
 method @AnyThread @Nullable public GeckoPreferenceController.Observer.Delegate getPreferencesObserverDelegate();
 method @Nullable @UiThread public GeckoRuntime.ServiceWorkerDelegate getServiceWorkerDelegate();
 method @AnyThread @NonNull public GeckoRuntimeSettings getSettings();
 method @NonNull @UiThread public StorageController getStorageController();
 method @NonNull @UiThread public WebExtensionController getWebExtensionController();
 method @Nullable @UiThread public WebNotificationDelegate getWebNotificationDelegate();
 method @NonNull @UiThread public WebPushController getWebPushController();
 method @AnyThread public boolean isInteractiveWidgetDefaultResizesVisual();
 method @AnyThread public void notifyTelemetryPrefChanged(boolean);
 method @UiThread public void orientationChanged();
 method @UiThread public void orientationChanged(int);
 method @AnyThread public void readFromParcel(@NonNull Parcel);
 method @UiThread public void setActivityDelegate(@Nullable GeckoRuntime.ActivityDelegate);
 method @UiThread public void setAutocompleteStorageDelegate(@Nullable Autocomplete.StorageDelegate);
 method @UiThread public void setCrashPullDelegate(@Nullable CrashPullController.Delegate);
 method @UiThread public void setDelegate(@Nullable GeckoRuntime.Delegate);
 method @AnyThread public void setPreferencesObserverDelegate(@Nullable GeckoPreferenceController.Observer.Delegate);
 method @UiThread public void setServiceWorkerDelegate(@Nullable GeckoRuntime.ServiceWorkerDelegate);
 method @UiThread public void setWebNotificationDelegate(@Nullable WebNotificationDelegate);
 method @AnyThread public void shutdown();
 method @UiThread public void warmUp();
 field public static final String ACTION_CRASHED = "org.mozilla.gecko.ACTION_CRASHED";
 field public static final String CRASHED_PROCESS_VISIBILITY_BACKGROUND_CHILD = "BACKGROUND_CHILD";
 field public static final String CRASHED_PROCESS_VISIBILITY_FOREGROUND_CHILD = "FOREGROUND_CHILD";
 field public static final String CRASHED_PROCESS_VISIBILITY_MAIN = "MAIN";
 field public static final Parcelable.Creator<GeckoRuntime> CREATOR;
 field public static final String EXTRA_CRASH_PROCESS_TYPE = "processType";
 field public static final String EXTRA_CRASH_PROCESS_VISIBILITY = "processVisibility";
 field public static final String EXTRA_CRASH_REMOTE_TYPE = "remoteType";
 field public static final String EXTRA_EXTRAS_PATH = "extrasPath";
 field public static final String EXTRA_MINIDUMP_PATH = "minidumpPath";
 }

 public static interface GeckoRuntime.ActivityDelegate {
 method @Nullable @UiThread public GeckoResult<Intent> onStartActivityForResult(@NonNull PendingIntent);
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoRuntime.CrashedProcessVisibility {
 }

 public static interface GeckoRuntime.Delegate {
 method @UiThread public void onShutdown();
 }

 @UiThread public static interface GeckoRuntime.ServiceWorkerDelegate {
 method @NonNull @UiThread public GeckoResult<GeckoSession> onOpenWindow(@NonNull String);
 }

 @AnyThread public final class GeckoRuntimeSettings extends RuntimeSettings {
 method public boolean getAboutConfigEnabled();
 method public int getAllowInsecureConnections();
 method public boolean getAppZygoteProcessEnabled();
 method @NonNull public String[] getArguments();
 method public boolean getAutomaticFontSizeAdjustment();
 method @NonNull public String getBannedPorts();
 method @Nullable public Boolean getBaselineFingerprintingProtection();
 method @Nullable public String getBaselineFingerprintingProtectionOverrides();
 method @NonNull public int getCertificateTransparencyMode();
 method @Nullable public String getConfigFilePath();
 method public boolean getConsoleOutputEnabled();
 method @NonNull public ContentBlocking.Settings getContentBlocking();
 method public boolean getCookieBehaviorOptInPartitioning();
 method public boolean getCookieBehaviorOptInPartitioningPBM();
 method @Nullable public Class<? extends android.app.Service> getCrashHandler();
 method @NonNull public String getCrliteChannel();
 method @Nullable public String getDefaultRecursiveResolverUri();
 method @Deprecated @DeprecationSchedule(id="disable-ship-removal",version=153) @Nullable public Boolean getDisableShip();
 method @Nullable public Float getDisplayDensityOverride();
 method @Nullable public Integer getDisplayDpiOverride();
 method public boolean getDohAutoselectEnabled();
 method public boolean getDoubleTapZoomingEnabled();
 method public boolean getEnterpriseRootsEnabled();
 method @AnyThread @Nullable public ExperimentDelegate getExperimentDelegate();
 method @Nullable public Integer getExtensionsProcessCrashThreshold();
 method @Nullable public Long getExtensionsProcessCrashTimeframe();
 method @Nullable public Boolean getExtensionsProcessEnabled();
 method public boolean getExtensionsWebAPIEnabled();
 method @NonNull public Bundle getExtras();
 method public boolean getFdlibmMathEnabled();
 method public boolean getFetchPriorityEnabled();
 method @Nullable public Boolean getFingerprintingProtection();
 method @NonNull public String getFingerprintingProtectionOverrides();
 method @Nullable public Boolean getFingerprintingProtectionPrivateBrowsing();
 method @Nullable public String getFirefoxRelay();
 method @Nullable public Boolean getFissionEnabled();
 method public boolean getFontInflationEnabled();
 method public float getFontSizeFactor();
 method public boolean getForceEnableAccessibility();
 method public boolean getForceUserScalableEnabled();
 method public int getGlMsaaLevel();
 method public boolean getGlobalPrivacyControl();
 method public boolean getGlobalPrivacyControlPrivateMode();
 method public boolean getInputAutoZoomEnabled();
 method public boolean getIsolatedProcessEnabled();
 method public boolean getJavaScriptEnabled();
 method @NonNull public int getLargeKeepaliveFactor();
 method @Nullable public Boolean getLnaBlockTrackers();
 method @Nullable public Boolean getLnaBlocking();
 method @Nullable public Boolean getLnaEnabled();
 method @Nullable public String[] getLocales();
 method public boolean getLoginAutofillEnabled();
 method public boolean getLowMemoryDetection();
 method public boolean getParallelMarkingEnabled();
 method public boolean getPauseForDebuggerEnabled();
 method @NonNull public boolean getPostQuantumKeyExchangeEnabled();
 method public int getPreferredColorScheme();
 method public boolean getRemoteDebuggingEnabled();
 method @Nullable public GeckoRuntime getRuntime();
 method @NonNull public boolean getSameDocumentNavigationOverridesLoadType();
 method @NonNull public String getSameDocumentNavigationOverridesLoadTypeForceDisable();
 method @Nullable public Rect getScreenSizeOverride();
 method public boolean getTranslationsOfferPopup();
 method @NonNull public List<String> getTrustedRecursiveResolverExcludedDomains();
 method @NonNull public String getTrustedRecursiveResolverUri();
 method public int getTrustedRecusiveResolverMode();
 method public boolean getUseMaxScreenDepth();
 method @NonNull public int getUserCharacteristicPingCurrentVersion();
 method @Nullable public Integer getWebContentIsolationStrategy();
 method public boolean getWebFontsEnabled();
 method public boolean getWebManifestEnabled();
 method @NonNull public GeckoRuntimeSettings setAboutConfigEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings setAllowInsecureConnections(int);
 method @NonNull public GeckoRuntimeSettings setAutomaticFontSizeAdjustment(boolean);
 method @NonNull public GeckoRuntimeSettings setBannedPorts(@NonNull String);
 method @NonNull public GeckoRuntimeSettings setBaselineFingerprintingProtection(boolean);
 method @NonNull public GeckoRuntimeSettings setBaselineFingerprintingProtectionOverrides(@NonNull String);
 method @NonNull public GeckoRuntimeSettings setCertificateTransparencyMode(int);
 method @NonNull public GeckoRuntimeSettings setConsoleOutputEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings setCookieBehaviorOptInPartitioning(boolean);
 method @NonNull public GeckoRuntimeSettings setCookieBehaviorOptInPartitioningPBM(boolean);
 method @NonNull public GeckoRuntimeSettings setCrliteChannel(@NonNull String);
 method @NonNull public GeckoRuntimeSettings setDefaultRecursiveResolverUri(@NonNull String);
 method @NonNull public GeckoRuntimeSettings setDohAutoselectEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings setDoubleTapZoomingEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings setEnterpriseRootsEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings setExtensionsProcessCrashThreshold(@NonNull Integer);
 method @NonNull public GeckoRuntimeSettings setExtensionsProcessCrashTimeframe(@NonNull Long);
 method @NonNull public GeckoRuntimeSettings setExtensionsProcessEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings setExtensionsWebAPIEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings setFdlibmMathEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings setFetchPriorityEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings setFingerprintingProtection(boolean);
 method @NonNull public GeckoRuntimeSettings setFingerprintingProtectionOverrides(@NonNull String);
 method @NonNull public GeckoRuntimeSettings setFingerprintingProtectionPrivateBrowsing(boolean);
 method @NonNull public GeckoRuntimeSettings setFirefoxRelay(@NonNull String);
 method @NonNull public GeckoRuntimeSettings setFontInflationEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings setFontSizeFactor(float);
 method @NonNull public GeckoRuntimeSettings setForceEnableAccessibility(boolean);
 method @NonNull public GeckoRuntimeSettings setForceUserScalableEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings setGlMsaaLevel(int);
 method @NonNull public GeckoRuntimeSettings setGlobalPrivacyControl(boolean);
 method @NonNull public GeckoRuntimeSettings setInputAutoZoomEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings setJavaScriptEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings setLargeKeepaliveFactor(int);
 method @NonNull public GeckoRuntimeSettings setLnaBlockTrackers(boolean);
 method @NonNull public GeckoRuntimeSettings setLnaBlocking(boolean);
 method @NonNull public GeckoRuntimeSettings setLnaEnabled(boolean);
 method public void setLocales(@Nullable String[]);
 method @NonNull public GeckoRuntimeSettings setLoginAutofillEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings setParallelMarkingEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings setPostQuantumKeyExchangeEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings setPreferredColorScheme(int);
 method @NonNull public GeckoRuntimeSettings setRemoteDebuggingEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings setRemoteSettingCrashPullNeverShowAgain(boolean);
 method @NonNull public GeckoRuntimeSettings setSameDocumentNavigationOverridesLoadType(boolean);
 method @NonNull public GeckoRuntimeSettings setSameDocumentNavigationOverridesLoadTypeForceDisable(@NonNull String);
 method @NonNull public GeckoRuntimeSettings setTranslationsOfferPopup(boolean);
 method @NonNull public GeckoRuntimeSettings setTrustedRecursiveResolverExcludedDomains(@NonNull List<String>);
 method @NonNull public GeckoRuntimeSettings setTrustedRecursiveResolverMode(int);
 method @NonNull public GeckoRuntimeSettings setTrustedRecursiveResolverUri(@NonNull String);
 method @NonNull public GeckoRuntimeSettings setUserCharacteristicPingCurrentVersion(int);
 method @NonNull public GeckoRuntimeSettings setWebContentIsolationStrategy(@NonNull Integer);
 method @NonNull public GeckoRuntimeSettings setWebFontsEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings setWebManifestEnabled(boolean);
 field public static final int ALLOW_ALL = 0;
 field public static final int COLOR_SCHEME_DARK = 1;
 field public static final int COLOR_SCHEME_LIGHT = 0;
 field public static final int COLOR_SCHEME_SYSTEM = -1;
 field public static final Parcelable.Creator<GeckoRuntimeSettings> CREATOR;
 field public static final String FIREFOX_RELAY_AVAILABLE = "available";
 field public static final String FIREFOX_RELAY_DISABLED = "disabled";
 field public static final String FIREFOX_RELAY_ENABLED = "enabled";
 field public static final String FIREFOX_RELAY_OFFERED = "offered";
 field public static final int HTTPS_ONLY = 2;
 field public static final int HTTPS_ONLY_PRIVATE = 1;
 field public static final int STRATEGY_ISOLATE_EVERYTHING = 1;
 field public static final int STRATEGY_ISOLATE_HIGH_VALUE = 2;
 field public static final int STRATEGY_ISOLATE_NOTHING = 0;
 field public static final int TRR_MODE_DISABLED = 5;
 field public static final int TRR_MODE_FIRST = 2;
 field public static final int TRR_MODE_OFF = 0;
 field public static final int TRR_MODE_ONLY = 3;
 }

 @AnyThread public static final class GeckoRuntimeSettings.Builder extends RuntimeSettings.Builder<GeckoRuntimeSettings> {
 ctor public Builder();
 method @NonNull public GeckoRuntimeSettings.Builder aboutConfigEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder allowInsecureConnections(int);
 method @NonNull public GeckoRuntimeSettings.Builder appZygoteProcessEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder arguments(@NonNull String[]);
 method @NonNull public GeckoRuntimeSettings.Builder automaticFontSizeAdjustment(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder configFilePath(@Nullable String);
 method @NonNull public GeckoRuntimeSettings.Builder consoleOutput(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder contentBlocking(@NonNull ContentBlocking.Settings);
 method @NonNull public GeckoRuntimeSettings.Builder crashHandler(@Nullable Class<? extends android.app.Service>);
 method @NonNull public GeckoRuntimeSettings.Builder crashPullNeverShowAgain(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder debugLogging(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder defaultRecursiveResolverUri(@NonNull String);
 method @Deprecated @DeprecationSchedule(id="disable-ship-removal",version=153) @NonNull public GeckoRuntimeSettings.Builder disableShip(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder displayDensityOverride(float);
 method @NonNull public GeckoRuntimeSettings.Builder displayDpiOverride(int);
 method @NonNull public GeckoRuntimeSettings.Builder doubleTapZoomingEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder enterpriseRootsEnabled(boolean);
 method @AnyThread @NonNull public GeckoRuntimeSettings.Builder experimentDelegate(@Nullable ExperimentDelegate);
 method @NonNull public GeckoRuntimeSettings.Builder extensionsProcessCrashThreshold(@NonNull Integer);
 method @NonNull public GeckoRuntimeSettings.Builder extensionsProcessCrashTimeframe(@NonNull Long);
 method @NonNull public GeckoRuntimeSettings.Builder extensionsProcessEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder extensionsWebAPIEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder extras(@NonNull Bundle);
 method @NonNull public GeckoRuntimeSettings.Builder fissionEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder fontInflation(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder fontSizeFactor(float);
 method @NonNull public GeckoRuntimeSettings.Builder forceUserScalableEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder glMsaaLevel(int);
 method @NonNull public GeckoRuntimeSettings.Builder globalPrivacyControlEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder inputAutoZoomEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder isolatedProcessEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder javaScriptEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder largeKeepaliveFactor(int);
 method @NonNull public GeckoRuntimeSettings.Builder locales(@Nullable String[]);
 method @NonNull public GeckoRuntimeSettings.Builder loginAutofillEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder lowMemoryDetection(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder pauseForDebugger(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder preferredColorScheme(int);
 method @NonNull public GeckoRuntimeSettings.Builder remoteDebuggingEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder screenSizeOverride(int, int);
 method @NonNull public GeckoRuntimeSettings.Builder setLnaBlockTrackers(@NonNull Boolean);
 method @NonNull public GeckoRuntimeSettings.Builder setLnaBlocking(@NonNull Boolean);
 method @NonNull public GeckoRuntimeSettings.Builder setLnaEnabled(@NonNull Boolean);
 method @NonNull public GeckoRuntimeSettings.Builder setSameDocumentNavigationOverridesLoadType(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder setSameDocumentNavigationOverridesLoadTypeForceDisable(@NonNull String);
 method @NonNull public GeckoRuntimeSettings.Builder translationsOfferPopup(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder trustedRecursiveResolverMode(int);
 method @NonNull public GeckoRuntimeSettings.Builder trustedRecursiveResolverUri(@NonNull String);
 method @NonNull public GeckoRuntimeSettings.Builder useMaxScreenDepth(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder webFontsEnabled(boolean);
 method @NonNull public GeckoRuntimeSettings.Builder webManifest(boolean);
 method @NonNull protected GeckoRuntimeSettings newSettings(@Nullable GeckoRuntimeSettings);
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoRuntimeSettings.ColorScheme {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoRuntimeSettings.FirefoxRelayMode {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoRuntimeSettings.HttpsOnlyMode {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoRuntimeSettings.TrustedRecursiveResolverMode {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoRuntimeSettings.WebContentIsolationStrategy {
 }

 public class GeckoSession {
 ctor public GeckoSession();
 ctor public GeckoSession(@Nullable GeckoSessionSettings);
 method @NonNull @UiThread public GeckoDisplay acquireDisplay();
 method @UiThread public void close();
 method @HandlerThread @NonNull public GeckoResult<Boolean> containsFormData();
 method @HandlerThread @NonNull public GeckoResult<Boolean> didPrintPageContent();
 method @AnyThread public void exitFullScreen();
 method @AnyThread public void flushSessionState();
 method @NonNull @UiThread public SessionAccessibility getAccessibility();
 method @Nullable @UiThread public Autofill.Delegate getAutofillDelegate();
 method @NonNull @UiThread public Autofill.Session getAutofillSession();
 method @UiThread public void getClientBounds(@NonNull RectF);
 method @UiThread public void getClientToScreenMatrix(@NonNull Matrix);
 method @UiThread public void getClientToSurfaceMatrix(@NonNull Matrix);
 method @NonNull @UiThread public CompositorController getCompositorController();
 method @Nullable @UiThread public GeckoSession.CompositorScrollDelegate getCompositorScrollDelegate();
 method @AnyThread @Nullable public ContentBlocking.Delegate getContentBlockingDelegate();
 method @Nullable @UiThread public GeckoSession.ContentDelegate getContentDelegate();
 method @AnyThread @NonNull public static String getDefaultUserAgent();
 method @AnyThread @Nullable public ExperimentDelegate getExperimentDelegate();
 method @AnyThread @NonNull public SessionFinder getFinder();
 method @AnyThread @Nullable public GeckoSession.HistoryDelegate getHistoryDelegate();
 method @AnyThread @Nullable public GeckoSession.MediaDelegate getMediaDelegate();
 method @AnyThread @Nullable public MediaSession.Delegate getMediaSessionDelegate();
 method @Nullable @UiThread public GeckoSession.NavigationDelegate getNavigationDelegate();
 method @NonNull @UiThread public OverscrollEdgeEffect getOverscrollEdgeEffect();
 method @UiThread public void getPageToScreenMatrix(@NonNull Matrix);
 method @UiThread public void getPageToSurfaceMatrix(@NonNull Matrix);
 method @NonNull @UiThread public PanZoomController getPanZoomController();
 method @AnyThread @NonNull public SessionPdfFileSaver getPdfFileSaver();
 method @Nullable @UiThread public GeckoSession.PermissionDelegate getPermissionDelegate();
 method @AnyThread @Nullable public GeckoSession.PrintDelegate getPrintDelegate();
 method @Nullable @UiThread public GeckoSession.ProgressDelegate getProgressDelegate();
 method @AnyThread @Nullable public GeckoSession.PromptDelegate getPromptDelegate();
 method @Nullable @UiThread public GeckoSession.ScrollDelegate getScrollDelegate();
 method @AnyThread @Nullable public GeckoSession.SelectionActionDelegate getSelectionActionDelegate();
 method @AnyThread @NonNull public PageExtractionController.SessionPageExtractor getSessionPageExtractor();
 method @AnyThread @Nullable public TranslationsController.SessionTranslation getSessionTranslation();
 method @AnyThread @NonNull public GeckoSessionSettings getSettings();
 method @UiThread public void getSurfaceBounds(@NonNull Rect);
 method @AnyThread @NonNull public SessionTextInput getTextInput();
 method @AnyThread @Nullable public TranslationsController.SessionTranslation.Delegate getTranslationsSessionDelegate();
 method @HandlerThread @NonNull public GeckoResult<String> getUserAgent();
 method @HandlerThread @NonNull public GeckoResult<JSONObject> getWebCompatInfo();
 method @NonNull @UiThread public WebExtension.SessionController getWebExtensionController();
 method @AnyThread public void goBack();
 method @AnyThread public void goBack(boolean);
 method @AnyThread public void goForward();
 method @AnyThread public void goForward(boolean);
 method @AnyThread public void gotoHistoryIndex(int);
 method @HandlerThread @NonNull public GeckoResult<Boolean> hasCookieBannerRuleForBrowsingContextTree();
 method @UiThread public boolean isOpen();
 method @HandlerThread @NonNull public GeckoResult<Boolean> isPdfJs();
 method @AnyThread public void load(@NonNull GeckoSession.Loader);
 method @AnyThread public void loadUri(@NonNull String);
 method @UiThread public void open(@NonNull GeckoRuntime);
 method @AnyThread public void printPageContent();
 method @NonNull @UiThread public GeckoResult<Boolean> processBackPressed();
 method @AnyThread public void purgeHistory();
 method @NonNull @UiThread public GeckoResult<X509Certificate> qwacStatus();
 method @UiThread public void releaseDisplay(@NonNull GeckoDisplay);
 method @AnyThread public void reload();
 method @AnyThread public void reload(int);
 method @AnyThread public void restoreState(@NonNull GeckoSession.SessionState);
 method @HandlerThread @NonNull public GeckoResult<InputStream> saveAsPdf();
 method @HandlerThread @NonNull public GeckoResult<Void> sendMoreWebCompatInfo(@NonNull JSONObject);
 method @AnyThread public void setActive(boolean);
 method @UiThread public void setAutofillDelegate(@Nullable Autofill.Delegate);
 method @UiThread public void setCompositorScrollDelegate(@Nullable GeckoSession.CompositorScrollDelegate);
 method @AnyThread public void setContentBlockingDelegate(@Nullable ContentBlocking.Delegate);
 method @UiThread public void setContentDelegate(@Nullable GeckoSession.ContentDelegate);
 method @AnyThread public void setExperimentDelegate(@Nullable ExperimentDelegate);
 method @AnyThread public void setFocused(boolean);
 method @AnyThread public void setHistoryDelegate(@Nullable GeckoSession.HistoryDelegate);
 method @AnyThread public void setMediaDelegate(@Nullable GeckoSession.MediaDelegate);
 method @AnyThread public void setMediaSessionDelegate(@Nullable MediaSession.Delegate);
 method @UiThread public void setNavigationDelegate(@Nullable GeckoSession.NavigationDelegate);
 method @UiThread public void setPermissionDelegate(@Nullable GeckoSession.PermissionDelegate);
 method @AnyThread public void setPrintDelegate(@Nullable GeckoSession.PrintDelegate);
 method @AnyThread public void setPriorityHint(int);
 method @UiThread public void setProgressDelegate(@Nullable GeckoSession.ProgressDelegate);
 method @AnyThread public void setPromptDelegate(@Nullable GeckoSession.PromptDelegate);
 method @UiThread public void setScrollDelegate(@Nullable GeckoSession.ScrollDelegate);
 method @UiThread public void setSelectionActionDelegate(@Nullable GeckoSession.SelectionActionDelegate);
 method @AnyThread public void setTranslationsSessionDelegate(@Nullable TranslationsController.SessionTranslation.Delegate);
 method @AnyThread public void stop();
 method @UiThread protected void setShouldPinOnScreen(boolean);
 field public static final int APP_LINK_LAUNCH_TYPE_COLD = 1;
 field public static final int APP_LINK_LAUNCH_TYPE_HOT = 3;
 field public static final int APP_LINK_LAUNCH_TYPE_UNKNOWN = 0;
 field public static final int APP_LINK_LAUNCH_TYPE_WARM = 2;
 field public static final int FINDER_DISPLAY_DIM_PAGE = 2;
 field public static final int FINDER_DISPLAY_DRAW_LINK_OUTLINE = 4;
 field public static final int FINDER_DISPLAY_HIGHLIGHT_ALL = 1;
 field public static final int FINDER_FIND_BACKWARDS = 1;
 field public static final int FINDER_FIND_FORWARD = 0;
 field public static final int FINDER_FIND_LINKS_ONLY = 8;
 field public static final int FINDER_FIND_MATCH_CASE = 2;
 field public static final int FINDER_FIND_WHOLE_WORD = 4;
 field public static final int HEADER_FILTER_CORS_SAFELISTED = 1;
 field public static final int HEADER_FILTER_UNRESTRICTED_UNSAFE = 2;
 field public static final int LOAD_FLAGS_ALLOW_POPUPS = 8;
 field public static final int LOAD_FLAGS_BYPASS_CACHE = 1;
 field public static final int LOAD_FLAGS_BYPASS_CLASSIFIER = 16;
 field public static final int LOAD_FLAGS_BYPASS_LOAD_URI_DELEGATE = 128;
 field public static final int LOAD_FLAGS_BYPASS_PROXY = 2;
 field public static final int LOAD_FLAGS_EXTERNAL = 4;
 field public static final int LOAD_FLAGS_FORCE_ALLOW_DATA_URI = 32;
 field public static final int LOAD_FLAGS_NONE = 0;
 field public static final int LOAD_FLAGS_REPLACE_HISTORY = 64;
 field public static final int PRIORITY_DEFAULT = 0;
 field public static final int PRIORITY_HIGH = 1;
 field @Nullable protected GeckoSession.Window mWindow;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.AppLinkLaunchType {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.ClipboardPermissionType {
 }

 public static interface GeckoSession.CompositorScrollDelegate {
 method @UiThread default public void onScrollChanged(@NonNull GeckoSession, @NonNull GeckoSession.ScrollPositionUpdate);
 }

 public static interface GeckoSession.ContentDelegate {
 method @UiThread default public void onCloseRequest(@NonNull GeckoSession);
 method @UiThread default public void onContextMenu(@NonNull GeckoSession, int, int, @NonNull GeckoSession.ContentDelegate.ContextElement);
 method @AnyThread default public void onCookieBannerDetected(@NonNull GeckoSession);
 method @AnyThread default public void onCookieBannerHandled(@NonNull GeckoSession);
 method @UiThread default public void onCrash(@NonNull GeckoSession);
 method @UiThread default public void onExternalResponse(@NonNull GeckoSession, @NonNull WebResponse);
 method @UiThread default public void onFirstComposite(@NonNull GeckoSession);
 method @UiThread default public void onFirstContentfulPaint(@NonNull GeckoSession);
 method @UiThread default public void onFocusRequest(@NonNull GeckoSession);
 method @UiThread default public void onFullScreen(@NonNull GeckoSession, boolean);
 method @UiThread default public void onHideDynamicToolbar(@NonNull GeckoSession);
 method @UiThread default public void onKill(@NonNull GeckoSession);
 method @UiThread default public void onMetaViewportFitChange(@NonNull GeckoSession, @NonNull String);
 method @UiThread default public void onPaintStatusReset(@NonNull GeckoSession);
 method @UiThread default public void onPointerIconChange(@NonNull GeckoSession, @NonNull PointerIcon);
 method @UiThread default public void onPreviewImage(@NonNull GeckoSession, @NonNull String);
 method @UiThread default public void onShowDynamicToolbar(@NonNull GeckoSession);
 method @Nullable @UiThread default public GeckoResult<SlowScriptResponse> onSlowScript(@NonNull GeckoSession, @NonNull String);
 method @UiThread default public void onTitleChange(@NonNull GeckoSession, @Nullable String);
 method @UiThread default public void onWebAppManifest(@NonNull GeckoSession, @NonNull JSONObject);
 }

 public static class GeckoSession.ContentDelegate.ContextElement {
 ctor protected ContextElement(@Nullable String, @Nullable String, @Nullable String, @Nullable String, @NonNull String, @Nullable String, @Nullable String);
 field public static final int TYPE_AUDIO = 3;
 field public static final int TYPE_IMAGE = 1;
 field public static final int TYPE_NONE = 0;
 field public static final int TYPE_VIDEO = 2;
 field @Nullable public final String altText;
 field @Nullable public final String baseUri;
 field @Nullable public final String linkText;
 field @Nullable public final String linkUri;
 field @Nullable public final String srcUri;
 field @Nullable public final String title;
 field public final int type;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.ContentDelegate.ContextElement.Type {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.FinderDisplayFlags {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.FinderFindFlags {
 }

 @AnyThread public static class GeckoSession.FinderResult {
 ctor protected FinderResult();
 field @Nullable public final RectF clientRect;
 field public final int current;
 field public final int flags;
 field public final boolean found;
 field @Nullable public final String linkUri;
 field @NonNull public final String searchString;
 field public final int total;
 field public final boolean wrapped;
 }

 public static class GeckoSession.GeckoPrintException extends Exception {
 ctor protected GeckoPrintException();
 field public static final int ERROR_NO_ACTIVITY_CONTEXT = -5;
 field public static final int ERROR_NO_ACTIVITY_CONTEXT_DELEGATE = -4;
 field public static final int ERROR_NO_PRINT_DELEGATE = -6;
 field public static final int ERROR_PRINT_SETTINGS_SERVICE_NOT_AVAILABLE = -1;
 field public static final int ERROR_UNABLE_TO_CREATE_PRINT_SETTINGS = -2;
 field public static final int ERROR_UNABLE_TO_RETRIEVE_CANONICAL_BROWSING_CONTEXT = -3;
 field public final int code;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.GeckoPrintException.Codes {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.HeaderFilter {
 }

 public static interface GeckoSession.HistoryDelegate {
 method @Nullable @UiThread default public GeckoResult<boolean[]> getVisited(@NonNull GeckoSession, @NonNull String[]);
 method @UiThread default public void onHistoryStateChange(@NonNull GeckoSession, @NonNull GeckoSession.HistoryDelegate.HistoryList);
 method @Nullable @UiThread default public GeckoResult<Boolean> onVisited(@NonNull GeckoSession, @NonNull String, @Nullable String, int);
 field public static final int VISIT_REDIRECT_PERMANENT = 4;
 field public static final int VISIT_REDIRECT_SOURCE = 8;
 field public static final int VISIT_REDIRECT_SOURCE_PERMANENT = 16;
 field public static final int VISIT_REDIRECT_TEMPORARY = 2;
 field public static final int VISIT_TOP_LEVEL = 1;
 field public static final int VISIT_UNRECOVERABLE_ERROR = 32;
 }

 public static interface GeckoSession.HistoryDelegate.HistoryItem {
 method @AnyThread @NonNull default public String getTitle();
 method @AnyThread @NonNull default public String getUri();
 }

 public static interface GeckoSession.HistoryDelegate.HistoryList implements List<GeckoSession.HistoryDelegate.HistoryItem> {
 method @AnyThread default public int getCurrentIndex();
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.LoadFlags {
 }

 @AnyThread public static class GeckoSession.Loader {
 ctor public Loader();
 method @NonNull public GeckoSession.Loader additionalHeaders(@NonNull Map<String,String>);
 method @NonNull public GeckoSession.Loader appLinkLaunchType(int);
 method @NonNull public GeckoSession.Loader data(@NonNull byte[], @Nullable String);
 method @NonNull public GeckoSession.Loader data(@NonNull String, @Nullable String);
 method @NonNull public GeckoSession.Loader flags(int);
 method @NonNull public GeckoSession.Loader headerFilter(int);
 method @NonNull public GeckoSession.Loader originalInput(@Nullable String);
 method @NonNull public GeckoSession.Loader referrer(@NonNull GeckoSession);
 method @NonNull public GeckoSession.Loader referrer(@NonNull Uri);
 method @NonNull public GeckoSession.Loader referrer(@NonNull String);
 method @NonNull public GeckoSession.Loader textDirectiveUserActivation(boolean);
 method @NonNull public GeckoSession.Loader uri(@NonNull String);
 method @NonNull public GeckoSession.Loader uri(@NonNull Uri);
 }

 public static interface GeckoSession.MediaDelegate {
 method @UiThread default public void onRecordingStatusChanged(@NonNull GeckoSession, @NonNull GeckoSession.MediaDelegate.RecordingDevice[]);
 }

 public static class GeckoSession.MediaDelegate.RecordingDevice {
 ctor protected RecordingDevice();
 field public final long status;
 field public final long type;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.MediaDelegate.RecordingDevice.DeviceType {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.MediaDelegate.RecordingDevice.RecordingStatus {
 }

 public static class GeckoSession.MediaDelegate.RecordingDevice.Status {
 ctor protected Status();
 field public static final long INACTIVE = 1L;
 field public static final long RECORDING = 0L;
 }

 public static class GeckoSession.MediaDelegate.RecordingDevice.Type {
 ctor protected Type();
 field public static final long CAMERA = 0L;
 field public static final long MICROPHONE = 1L;
 }

 public static interface GeckoSession.NavigationDelegate {
 method @UiThread default public void onCanGoBack(@NonNull GeckoSession, boolean);
 method @UiThread default public void onCanGoForward(@NonNull GeckoSession, boolean);
 method @Nullable @UiThread default public GeckoResult<String> onLoadError(@NonNull GeckoSession, @Nullable String, @NonNull WebRequestError);
 method @Nullable @UiThread default public GeckoResult<AllowOrDeny> onLoadRequest(@NonNull GeckoSession, @NonNull GeckoSession.NavigationDelegate.LoadRequest);
 method @UiThread default public void onLocationChange(@NonNull GeckoSession, @Nullable String, @NonNull List<GeckoSession.PermissionDelegate.ContentPermission>, @NonNull Boolean);
 method @Nullable @UiThread default public GeckoResult<GeckoSession> onNewSession(@NonNull GeckoSession, @NonNull String);
 method @Nullable @UiThread default public GeckoResult<AllowOrDeny> onSubframeLoadRequest(@NonNull GeckoSession, @NonNull GeckoSession.NavigationDelegate.LoadRequest);
 field public static final int LOAD_REQUEST_IS_REDIRECT = 8388608;
 field public static final int TARGET_WINDOW_CURRENT = 1;
 field public static final int TARGET_WINDOW_NEW = 2;
 field public static final int TARGET_WINDOW_NONE = 0;
 }

 public static class GeckoSession.NavigationDelegate.LoadRequest {
 ctor protected LoadRequest();
 field public final boolean hasUserGesture;
 field public final boolean isDirectNavigation;
 field public final boolean isRedirect;
 field public final int target;
 field @Nullable public final String triggerUri;
 field @NonNull public final String uri;
 }

 @AnyThread public static class GeckoSession.PdfSaveResult {
 ctor protected PdfSaveResult();
 field @NonNull public final byte[] bytes;
 field @NonNull public final String filename;
 field public final boolean isPrivate;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.Permission {
 }

 public static interface GeckoSession.PermissionDelegate {
 method @UiThread default public void onAndroidPermissionsRequest(@NonNull GeckoSession, @Nullable String[], @NonNull GeckoSession.PermissionDelegate.Callback);
 method @Nullable @UiThread default public GeckoResult<Integer> onContentPermissionRequest(@NonNull GeckoSession, @NonNull GeckoSession.PermissionDelegate.ContentPermission);
 method @UiThread default public void onMediaPermissionRequest(@NonNull GeckoSession, @NonNull String, @Nullable GeckoSession.PermissionDelegate.MediaSource[], @Nullable GeckoSession.PermissionDelegate.MediaSource[], @NonNull GeckoSession.PermissionDelegate.MediaCallback);
 field public static final int PERMISSION_AUTOPLAY_AUDIBLE = 5;
 field public static final int PERMISSION_AUTOPLAY_INAUDIBLE = 4;
 field public static final int PERMISSION_DESKTOP_NOTIFICATION = 1;
 field public static final int PERMISSION_GEOLOCATION = 0;
 field public static final int PERMISSION_LOCAL_DEVICE_ACCESS = 9;
 field public static final int PERMISSION_LOCAL_NETWORK_ACCESS = 10;
 field public static final int PERMISSION_MEDIA_KEY_SYSTEM_ACCESS = 6;
 field public static final int PERMISSION_PERSISTENT_STORAGE = 2;
 field public static final int PERMISSION_STORAGE_ACCESS = 8;
 field public static final int PERMISSION_TRACKING = 7;
 field public static final int PERMISSION_XR = 3;
 }

 public static interface GeckoSession.PermissionDelegate.Callback {
 method @UiThread default public void grant();
 method @UiThread default public void reject();
 }

 public static class GeckoSession.PermissionDelegate.ContentPermission {
 ctor protected ContentPermission();
 method @AnyThread @Nullable public static GeckoSession.PermissionDelegate.ContentPermission fromJson(@NonNull JSONObject);
 method @AnyThread public void notifyShown();
 method @AnyThread @NonNull public JSONObject toJson();
 field public static final int VALUE_ALLOW = 1;
 field public static final int VALUE_DENY = 2;
 field public static final int VALUE_PROMPT = 3;
 field @Nullable public final String contextId;
 field public final int permission;
 field public final boolean privateMode;
 field @Nullable public final String thirdPartyOrigin;
 field @NonNull public final String uri;
 field public final int value;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.PermissionDelegate.ContentPermission.Value {
 }

 public static interface GeckoSession.PermissionDelegate.MediaCallback {
 method @UiThread default public void grant(@Nullable String, @Nullable String);
 method @UiThread default public void grant(@Nullable GeckoSession.PermissionDelegate.MediaSource, @Nullable GeckoSession.PermissionDelegate.MediaSource);
 method @UiThread default public void reject();
 }

 public static class GeckoSession.PermissionDelegate.MediaSource {
 ctor protected MediaSource();
 field public static final int SOURCE_AUDIOCAPTURE = 3;
 field public static final int SOURCE_CAMERA = 0;
 field public static final int SOURCE_MICROPHONE = 2;
 field public static final int SOURCE_OTHER = 4;
 field public static final int SOURCE_SCREEN = 1;
 field public static final int TYPE_AUDIO = 1;
 field public static final int TYPE_VIDEO = 0;
 field @NonNull public final String id;
 field @Nullable public final String name;
 field public final int source;
 field public final int type;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.PermissionDelegate.MediaSource.Source {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.PermissionDelegate.MediaSource.Type {
 }

 @AnyThread public static interface GeckoSession.PrintDelegate {
 method default public void onPrint(@NonNull GeckoSession);
 method default public void onPrint(@NonNull InputStream);
 method @Nullable default public GeckoResult<Boolean> onPrintWithStatus(@NonNull InputStream);
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.Priority {
 }

 public static interface GeckoSession.ProgressDelegate {
 method @UiThread default public void onPageStart(@NonNull GeckoSession, @NonNull String);
 method @UiThread default public void onPageStop(@NonNull GeckoSession, boolean);
 method @UiThread default public void onProgressChange(@NonNull GeckoSession, int);
 method @UiThread default public void onSecurityChange(@NonNull GeckoSession, @NonNull GeckoSession.ProgressDelegate.SecurityInformation);
 method @UiThread default public void onSessionStateChange(@NonNull GeckoSession, @NonNull GeckoSession.SessionState);
 }

 public static class GeckoSession.ProgressDelegate.SecurityInformation {
 ctor protected SecurityInformation();
 field public static final int CONTENT_BLOCKED = 1;
 field public static final int CONTENT_LOADED = 2;
 field public static final int CONTENT_UNKNOWN = 0;
 field public static final int SECURITY_MODE_IDENTIFIED = 1;
 field public static final int SECURITY_MODE_UNKNOWN = 0;
 field public static final int SECURITY_MODE_VERIFIED = 2;
 field @Nullable public final X509Certificate certificate;
 field @NonNull public final String host;
 field public final boolean isException;
 field public final boolean isSecure;
 field public final int mixedModeActive;
 field public final int mixedModePassive;
 field @Nullable public final String origin;
 field public final int securityMode;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.ProgressDelegate.SecurityInformation.ContentType {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.ProgressDelegate.SecurityInformation.SecurityMode {
 }

 public static interface GeckoSession.PromptDelegate {
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onAddressSave(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.AutocompleteRequest<Autocomplete.AddressSaveOption>);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onAddressSelect(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.AutocompleteRequest<Autocomplete.AddressSelectOption>);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onAlertPrompt(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.AlertPrompt);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onAuthPrompt(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.AuthPrompt);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onBeforeUnloadPrompt(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.BeforeUnloadPrompt);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onButtonPrompt(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.ButtonPrompt);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onChoicePrompt(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.ChoicePrompt);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onColorPrompt(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.ColorPrompt);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onCreditCardSave(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.AutocompleteRequest<Autocomplete.CreditCardSaveOption>);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onCreditCardSelect(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.AutocompleteRequest<Autocomplete.CreditCardSelectOption>);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onDateTimePrompt(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.DateTimePrompt);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onFilePrompt(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.FilePrompt);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onFolderUploadPrompt(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.FolderUploadPrompt);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onLoginSave(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.AutocompleteRequest<Autocomplete.LoginSaveOption>);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onLoginSelect(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.AutocompleteRequest<Autocomplete.LoginSelectOption>);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onPopupPrompt(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.PopupPrompt);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onRedirectPrompt(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.RedirectPrompt);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onRepostConfirmPrompt(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.RepostConfirmPrompt);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onRequestCertificate(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.CertificateRequest);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onSelectIdentityCredentialAccount(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.IdentityCredential.AccountSelectorPrompt);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onSelectIdentityCredentialProvider(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.IdentityCredential.ProviderSelectorPrompt);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onSharePrompt(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.SharePrompt);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onShowPrivacyPolicyIdentityCredential(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.IdentityCredential.PrivacyPolicyPrompt);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onTextPrompt(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.TextPrompt);
 method @Nullable @UiThread default public GeckoResult<GeckoSession.PromptDelegate.PromptResponse> onWebAuthnRelatedOriginPrompt(@NonNull GeckoSession, @NonNull GeckoSession.PromptDelegate.WebAuthnRelatedOriginPrompt);
 }

 public static class GeckoSession.PromptDelegate.AlertPrompt extends GeckoSession.PromptDelegate.BasePrompt {
 ctor protected AlertPrompt(@NonNull String, @Nullable String, @Nullable String, @NonNull GeckoSession.PromptDelegate.BasePrompt.Observer);
 field @Nullable public final String message;
 }

 public static class GeckoSession.PromptDelegate.AuthPrompt extends GeckoSession.PromptDelegate.BasePrompt {
 ctor protected AuthPrompt(@NonNull String, @Nullable String, @Nullable String, @NonNull GeckoSession.PromptDelegate.AuthPrompt.AuthOptions, @NonNull GeckoSession.PromptDelegate.BasePrompt.Observer);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@NonNull String);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@NonNull String, @NonNull String);
 field @NonNull public final GeckoSession.PromptDelegate.AuthPrompt.AuthOptions authOptions;
 field @Nullable public final String message;
 }

 public static class GeckoSession.PromptDelegate.AuthPrompt.AuthOptions {
 ctor protected AuthOptions();
 field public final int flags;
 field public final int level;
 field @Nullable public final String password;
 field @Nullable public final String uri;
 field @Nullable public final String username;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.PromptDelegate.AuthPrompt.AuthOptions.AuthFlag {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.PromptDelegate.AuthPrompt.AuthOptions.AuthLevel {
 }

 public static class GeckoSession.PromptDelegate.AuthPrompt.AuthOptions.Flags {
 ctor protected Flags();
 field public static final int CROSS_ORIGIN_SUB_RESOURCE = 32;
 field public static final int HOST = 1;
 field public static final int ONLY_PASSWORD = 8;
 field public static final int PREVIOUS_FAILED = 16;
 field public static final int PROXY = 2;
 }

 public static class GeckoSession.PromptDelegate.AuthPrompt.AuthOptions.Level {
 ctor protected Level();
 field public static final int NONE = 0;
 field public static final int PW_ENCRYPTED = 1;
 field public static final int SECURE = 2;
 }

 public static class GeckoSession.PromptDelegate.AutocompleteRequest<T extends Autocomplete.Option<?>> extends GeckoSession.PromptDelegate.BasePrompt {
 ctor protected AutocompleteRequest(@NonNull String, @NonNull T[], GeckoSession.PromptDelegate.BasePrompt.Observer);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@NonNull Autocomplete.Option<?>);
 field @NonNull public final T[] options;
 }

 public static class GeckoSession.PromptDelegate.BasePrompt {
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse dismiss();
 method @Nullable @UiThread public GeckoSession.PromptDelegate.PromptInstanceDelegate getDelegate();
 method @UiThread public boolean isComplete();
 method @UiThread public void setDelegate(@Nullable GeckoSession.PromptDelegate.PromptInstanceDelegate);
 method @NonNull @UiThread protected GeckoSession.PromptDelegate.PromptResponse confirm();
 field @Nullable public final String title;
 }

 protected static interface GeckoSession.PromptDelegate.BasePrompt.Observer {
 method @AnyThread default public void onPromptCompleted(@NonNull GeckoSession.PromptDelegate.BasePrompt);
 }

 public static class GeckoSession.PromptDelegate.BeforeUnloadPrompt extends GeckoSession.PromptDelegate.BasePrompt {
 ctor protected BeforeUnloadPrompt(@NonNull String, @NonNull GeckoSession.PromptDelegate.BasePrompt.Observer);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@Nullable AllowOrDeny);
 }

 public static class GeckoSession.PromptDelegate.ButtonPrompt extends GeckoSession.PromptDelegate.BasePrompt {
 ctor protected ButtonPrompt(@NonNull String, @Nullable String, @Nullable String, @NonNull GeckoSession.PromptDelegate.BasePrompt.Observer);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(int);
 field @Nullable public final String message;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.PromptDelegate.ButtonPrompt.ButtonType {
 }

 public static class GeckoSession.PromptDelegate.ButtonPrompt.Type {
 ctor protected Type();
 field public static final int NEGATIVE = 2;
 field public static final int POSITIVE = 0;
 }

 public static class GeckoSession.PromptDelegate.CertificateRequest extends GeckoSession.PromptDelegate.BasePrompt {
 ctor protected CertificateRequest(@NonNull String, GeckoSession.PromptDelegate.BasePrompt.Observer, String, Principal[]);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@Nullable String);
 field @NonNull public final String host;
 field @Nullable public final Principal[] issuers;
 }

 public static class GeckoSession.PromptDelegate.ChoicePrompt extends GeckoSession.PromptDelegate.BasePrompt {
 ctor protected ChoicePrompt(@NonNull String, @Nullable String, @Nullable String, int, @NonNull GeckoSession.PromptDelegate.ChoicePrompt.Choice[], @NonNull GeckoSession.PromptDelegate.BasePrompt.Observer);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@NonNull String);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@NonNull String[]);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@NonNull GeckoSession.PromptDelegate.ChoicePrompt.Choice);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@NonNull GeckoSession.PromptDelegate.ChoicePrompt.Choice[]);
 field @NonNull public final GeckoSession.PromptDelegate.ChoicePrompt.Choice[] choices;
 field @Nullable public final String message;
 field public final int type;
 }

 public static class GeckoSession.PromptDelegate.ChoicePrompt.Choice {
 ctor protected Choice();
 field public final boolean disabled;
 field @Nullable public final String icon;
 field @NonNull public final String id;
 field @Nullable public final GeckoSession.PromptDelegate.ChoicePrompt.Choice[] items;
 field @NonNull public final String label;
 field public final boolean selected;
 field public final boolean separator;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.PromptDelegate.ChoicePrompt.ChoiceType {
 }

 public static class GeckoSession.PromptDelegate.ChoicePrompt.Type {
 ctor protected Type();
 field public static final int MENU = 1;
 field public static final int MULTIPLE = 3;
 field public static final int SINGLE = 2;
 }

 public static class GeckoSession.PromptDelegate.ColorPrompt extends GeckoSession.PromptDelegate.BasePrompt {
 ctor protected ColorPrompt(@NonNull String, @Nullable String, @Nullable String, @Nullable String[], @NonNull GeckoSession.PromptDelegate.BasePrompt.Observer);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@NonNull String);
 field @Nullable public final String defaultValue;
 field @Nullable public final String[] predefinedValues;
 }

 public static class GeckoSession.PromptDelegate.DateTimePrompt extends GeckoSession.PromptDelegate.BasePrompt {
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@NonNull String);
 field @Nullable public final String defaultValue;
 field @Nullable public final String maxValue;
 field @Nullable public final String minValue;
 field @Nullable public final String stepValue;
 field public final int type;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.PromptDelegate.DateTimePrompt.DatetimeType {
 }

 public static class GeckoSession.PromptDelegate.DateTimePrompt.Type {
 ctor protected Type();
 field public static final int DATE = 1;
 field public static final int DATETIME_LOCAL = 5;
 field public static final int MONTH = 2;
 field public static final int TIME = 4;
 field public static final int WEEK = 3;
 }

 public static class GeckoSession.PromptDelegate.FilePrompt extends GeckoSession.PromptDelegate.BasePrompt {
 ctor protected FilePrompt(@NonNull String, @Nullable String, int, int, @Nullable String[], @NonNull GeckoSession.PromptDelegate.BasePrompt.Observer);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@NonNull Context, @NonNull Uri);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@NonNull Context, @NonNull Uri[]);
 field public final int capture;
 field @Nullable public final String[] mimeTypes;
 field public final int type;
 }

 public static class GeckoSession.PromptDelegate.FilePrompt.Capture {
 ctor protected Capture();
 field public static final int ANY = 1;
 field public static final int ENVIRONMENT = 3;
 field public static final int NONE = 0;
 field public static final int USER = 2;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.PromptDelegate.FilePrompt.CaptureType {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.PromptDelegate.FilePrompt.FileType {
 }

 public static class GeckoSession.PromptDelegate.FilePrompt.Type {
 ctor protected Type();
 field public static final int FOLDER = 3;
 field public static final int MULTIPLE = 2;
 field public static final int SINGLE = 1;
 }

 public static class GeckoSession.PromptDelegate.FolderUploadPrompt extends GeckoSession.PromptDelegate.BasePrompt {
 ctor protected FolderUploadPrompt(@NonNull String, @Nullable String, @NonNull GeckoSession.PromptDelegate.BasePrompt.Observer);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@Nullable AllowOrDeny);
 field @Nullable public final String directoryName;
 }

 public static final class GeckoSession.PromptDelegate.IdentityCredential {
 ctor public IdentityCredential();
 }

 public static class GeckoSession.PromptDelegate.IdentityCredential.AccountSelectorPrompt extends GeckoSession.PromptDelegate.BasePrompt {
 ctor public AccountSelectorPrompt(@NonNull String, @NonNull GeckoSession.PromptDelegate.IdentityCredential.AccountSelectorPrompt.Account[], @NonNull GeckoSession.PromptDelegate.IdentityCredential.AccountSelectorPrompt.Provider, GeckoSession.PromptDelegate.BasePrompt.Observer);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@NonNull int);
 field @NonNull public final GeckoSession.PromptDelegate.IdentityCredential.AccountSelectorPrompt.Account[] accounts;
 field @NonNull public final GeckoSession.PromptDelegate.IdentityCredential.AccountSelectorPrompt.Provider provider;
 }

 public static class GeckoSession.PromptDelegate.IdentityCredential.AccountSelectorPrompt.Account {
 ctor public Account(int, @NonNull String, @NonNull String, @Nullable String);
 field @NonNull public final String email;
 field @Nullable public final String icon;
 field public final int id;
 field @NonNull public final String name;
 }

 public static class GeckoSession.PromptDelegate.IdentityCredential.AccountSelectorPrompt.Provider {
 ctor public Provider(@NonNull String, @NonNull String, @Nullable String);
 field @NonNull public final String domain;
 field @Nullable public final String icon;
 field @NonNull public final String name;
 }

 public static class GeckoSession.PromptDelegate.IdentityCredential.AccountSelectorPrompt.ProviderAccounts {
 ctor public ProviderAccounts(int, @Nullable GeckoSession.PromptDelegate.IdentityCredential.AccountSelectorPrompt.Provider, @NonNull GeckoSession.PromptDelegate.IdentityCredential.AccountSelectorPrompt.Account[]);
 field @NonNull public final GeckoSession.PromptDelegate.IdentityCredential.AccountSelectorPrompt.Account[] accounts;
 field public final int id;
 field @Nullable public final GeckoSession.PromptDelegate.IdentityCredential.AccountSelectorPrompt.Provider provider;
 }

 public static class GeckoSession.PromptDelegate.IdentityCredential.PrivacyPolicyPrompt extends GeckoSession.PromptDelegate.BasePrompt {
 ctor protected PrivacyPolicyPrompt(@NonNull String, @NonNull String, @NonNull String, @NonNull String, @NonNull String, @Nullable String, @NonNull GeckoSession.PromptDelegate.BasePrompt.Observer);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(boolean);
 field @NonNull public final String host;
 field @Nullable public final String icon;
 field @NonNull public final String privacyPolicyUrl;
 field @NonNull public final String providerDomain;
 field @NonNull public final String termsOfServiceUrl;
 }

 public static class GeckoSession.PromptDelegate.IdentityCredential.ProviderSelectorPrompt extends GeckoSession.PromptDelegate.BasePrompt {
 ctor protected ProviderSelectorPrompt(@NonNull String, @NonNull GeckoSession.PromptDelegate.IdentityCredential.ProviderSelectorPrompt.Provider[], @NonNull GeckoSession.PromptDelegate.BasePrompt.Observer);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(int);
 field @NonNull public final GeckoSession.PromptDelegate.IdentityCredential.ProviderSelectorPrompt.Provider[] providers;
 }

 public static class GeckoSession.PromptDelegate.IdentityCredential.ProviderSelectorPrompt.Provider {
 ctor public Provider(int, @NonNull String, @Nullable String, @NonNull String);
 field @NonNull public final String domain;
 field @Nullable public final String icon;
 field public final int id;
 field @NonNull public final String name;
 }

 public static class GeckoSession.PromptDelegate.PopupPrompt extends GeckoSession.PromptDelegate.BasePrompt {
 ctor protected PopupPrompt(@NonNull String, @Nullable String, @NonNull GeckoSession.PromptDelegate.BasePrompt.Observer);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@NonNull AllowOrDeny);
 field @Nullable public final String targetUri;
 }

 public static interface GeckoSession.PromptDelegate.PromptInstanceDelegate {
 method @UiThread default public void onPromptDismiss(@NonNull GeckoSession.PromptDelegate.BasePrompt);
 method @UiThread default public void onPromptUpdate(@NonNull GeckoSession.PromptDelegate.BasePrompt);
 }

 public static class GeckoSession.PromptDelegate.PromptResponse {
 }

 public static class GeckoSession.PromptDelegate.RedirectPrompt extends GeckoSession.PromptDelegate.BasePrompt {
 ctor protected RedirectPrompt(@NonNull String, @Nullable String, @NonNull GeckoSession.PromptDelegate.BasePrompt.Observer);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@NonNull AllowOrDeny);
 field @Nullable public final String targetUri;
 }

 public static class GeckoSession.PromptDelegate.RepostConfirmPrompt extends GeckoSession.PromptDelegate.BasePrompt {
 ctor protected RepostConfirmPrompt(@NonNull String, @NonNull GeckoSession.PromptDelegate.BasePrompt.Observer);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@Nullable AllowOrDeny);
 }

 public static class GeckoSession.PromptDelegate.SharePrompt extends GeckoSession.PromptDelegate.BasePrompt {
 ctor protected SharePrompt(@NonNull String, @Nullable String, @Nullable String, @Nullable String, @NonNull GeckoSession.PromptDelegate.BasePrompt.Observer);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(int);
 field @Nullable public final String text;
 field @Nullable public final String uri;
 }

 public static class GeckoSession.PromptDelegate.SharePrompt.Result {
 ctor protected Result();
 field public static final int ABORT = 2;
 field public static final int FAILURE = 1;
 field public static final int SUCCESS = 0;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.PromptDelegate.SharePrompt.ShareResult {
 }

 public static class GeckoSession.PromptDelegate.TextPrompt extends GeckoSession.PromptDelegate.BasePrompt {
 ctor protected TextPrompt(@NonNull String, @Nullable String, @Nullable String, @Nullable String, @NonNull GeckoSession.PromptDelegate.BasePrompt.Observer);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@NonNull String);
 field @Nullable public final String defaultValue;
 field @Nullable public final String message;
 }

 public static class GeckoSession.PromptDelegate.WebAuthnRelatedOriginPrompt extends GeckoSession.PromptDelegate.BasePrompt {
 ctor protected WebAuthnRelatedOriginPrompt(@NonNull String, @Nullable String, @Nullable String, boolean, @NonNull GeckoSession.PromptDelegate.BasePrompt.Observer);
 method @NonNull @UiThread public GeckoSession.PromptDelegate.PromptResponse confirm(@Nullable AllowOrDeny);
 field public final boolean isCreate;
 field @Nullable public final String origin;
 field @Nullable public final String rpId;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.RestartReason {
 }

 public static interface GeckoSession.ScrollDelegate {
 method @UiThread default public void onScrollChanged(@NonNull GeckoSession, int, int);
 }

 public class GeckoSession.ScrollPositionUpdate {
 ctor public ScrollPositionUpdate();
 field public static final int SOURCE_OTHER = 1;
 field public static final int SOURCE_USER_INTERACTION = 0;
 field public float scrollX;
 field public float scrollY;
 field public int source;
 field public float zoom;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.ScrollPositionUpdate.SourceType {
 }

 public static interface GeckoSession.SelectionActionDelegate {
 method @UiThread default public void onDismissClipboardPermissionRequest(@NonNull GeckoSession);
 method @UiThread default public void onHideAction(@NonNull GeckoSession, int);
 method @UiThread default public void onShowActionRequest(@NonNull GeckoSession, @NonNull GeckoSession.SelectionActionDelegate.Selection);
 method @Nullable @UiThread default public GeckoResult<AllowOrDeny> onShowClipboardPermissionRequest(@NonNull GeckoSession, @NonNull GeckoSession.SelectionActionDelegate.ClipboardPermission);
 field public static final String ACTION_COLLAPSE_TO_END = "org.mozilla.geckoview.COLLAPSE_TO_END";
 field public static final String ACTION_COLLAPSE_TO_START = "org.mozilla.geckoview.COLLAPSE_TO_START";
 field public static final String ACTION_COPY = "org.mozilla.geckoview.COPY";
 field public static final String ACTION_CUT = "org.mozilla.geckoview.CUT";
 field public static final String ACTION_DELETE = "org.mozilla.geckoview.DELETE";
 field public static final String ACTION_HIDE = "org.mozilla.geckoview.HIDE";
 field public static final String ACTION_PASTE = "org.mozilla.geckoview.PASTE";
 field public static final String ACTION_PASTE_AS_PLAIN_TEXT = "org.mozilla.geckoview.PASTE_AS_PLAIN_TEXT";
 field public static final String ACTION_SELECT_ALL = "org.mozilla.geckoview.SELECT_ALL";
 field public static final String ACTION_UNSELECT = "org.mozilla.geckoview.UNSELECT";
 field public static final int FLAG_IS_COLLAPSED = 1;
 field public static final int FLAG_IS_EDITABLE = 2;
 field public static final int FLAG_IS_PASSWORD = 4;
 field public static final int HIDE_REASON_ACTIVE_SCROLL = 3;
 field public static final int HIDE_REASON_ACTIVE_SELECTION = 2;
 field public static final int HIDE_REASON_INVISIBLE_SELECTION = 1;
 field public static final int HIDE_REASON_NO_SELECTION = 0;
 field public static final int PERMISSION_CLIPBOARD_READ = 1;
 }

 public static class GeckoSession.SelectionActionDelegate.ClipboardPermission {
 ctor protected ClipboardPermission();
 field @Nullable public final Point screenPoint;
 field public final int type;
 field @NonNull public final String uri;
 }

 public static class GeckoSession.SelectionActionDelegate.Selection {
 ctor protected Selection();
 method @AnyThread public void collapseToEnd();
 method @AnyThread public void collapseToStart();
 method @AnyThread public void copy();
 method @AnyThread public void cut();
 method @AnyThread public void delete();
 method @AnyThread public void execute(@NonNull String);
 method @AnyThread public void hide();
 method @AnyThread public boolean isActionAvailable(@NonNull String);
 method @AnyThread public void paste();
 method @AnyThread public void pasteAsPlainText();
 method @AnyThread public void selectAll();
 method @AnyThread public void unselect();
 field @NonNull public final Collection<String> availableActions;
 field public final int flags;
 field @Nullable public final RectF screenRect;
 field @NonNull public final String text;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.SelectionActionDelegateAction {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.SelectionActionDelegateFlag {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.SelectionActionDelegateHideReason {
 }

 @AnyThread public static class GeckoSession.SessionState extends AbstractSequentialList<GeckoSession.HistoryDelegate.HistoryItem> implements Parcelable GeckoSession.HistoryDelegate.HistoryList {
 ctor public SessionState(@NonNull GeckoSession.SessionState);
 method @Nullable public static GeckoSession.SessionState fromString(@Nullable String);
 method public void readFromParcel(@NonNull Parcel);
 field public static final Parcelable.Creator<GeckoSession.SessionState> CREATOR;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.TargetWindow {
 }

 public static interface GeckoSession.TextInputDelegate {
 method @UiThread default public void hideSoftInput(@NonNull GeckoSession);
 method @UiThread default public void restartInput(@NonNull GeckoSession, int);
 method @UiThread default public void showSoftInput(@NonNull GeckoSession);
 method @UiThread default public void updateCursorAnchorInfo(@NonNull GeckoSession, @NonNull CursorAnchorInfo);
 method @UiThread default public void updateExtractedText(@NonNull GeckoSession, @NonNull ExtractedTextRequest, @NonNull ExtractedText);
 method @UiThread default public void updateSelection(@NonNull GeckoSession, int, int, int, int);
 field public static final int RESTART_REASON_BLUR = 1;
 field public static final int RESTART_REASON_CONTENT_CHANGE = 2;
 field public static final int RESTART_REASON_FOCUS = 0;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSession.VisitFlags {
 }

 @AnyThread public static class GeckoSession.WebResponseInfo {
 ctor protected WebResponseInfo();
 field @Nullable public final long contentLength;
 field @Nullable public final String contentType;
 field @Nullable public final String filename;
 field @NonNull public final String uri;
 }

 @AnyThread public final class GeckoSessionSettings implements Parcelable {
 ctor public GeckoSessionSettings();
 ctor public GeckoSessionSettings(@NonNull GeckoSessionSettings);
 method public boolean getAllowJavascript();
 method @Nullable public String getChromeUri();
 method @Nullable public String getContextId();
 method public int getDisplayMode();
 method public boolean getFullAccessibilityTree();
 method public int getScreenId();
 method public boolean getSuspendMediaWhenInactive();
 method public boolean getUsePrivateMode();
 method public boolean getUseTrackingProtection();
 method public int getUserAgentMode();
 method @Nullable public String getUserAgentOverride();
 method public int getViewportMode();
 method public void readFromParcel(@NonNull Parcel);
 method public void setAllowJavascript(boolean);
 method public void setDisplayMode(int);
 method public void setFullAccessibilityTree(boolean);
 method public void setSuspendMediaWhenInactive(boolean);
 method public void setUseTrackingProtection(boolean);
 method public void setUserAgentMode(int);
 method public void setUserAgentOverride(@Nullable String);
 method public void setViewportMode(int);
 field public static final Parcelable.Creator<GeckoSessionSettings> CREATOR;
 field public static final int DISPLAY_MODE_BROWSER = 0;
 field public static final int DISPLAY_MODE_FULLSCREEN = 3;
 field public static final int DISPLAY_MODE_MINIMAL_UI = 1;
 field public static final int DISPLAY_MODE_STANDALONE = 2;
 field public static final int USER_AGENT_MODE_DESKTOP = 1;
 field public static final int USER_AGENT_MODE_MOBILE = 0;
 field public static final int USER_AGENT_MODE_VR = 2;
 field public static final int VIEWPORT_MODE_DESKTOP = 1;
 field public static final int VIEWPORT_MODE_MOBILE = 0;
 }

 @AnyThread public static final class GeckoSessionSettings.Builder {
 ctor public Builder();
 ctor public Builder(GeckoSessionSettings);
 method @NonNull public GeckoSessionSettings.Builder allowJavascript(boolean);
 method @NonNull public GeckoSessionSettings build();
 method @NonNull public GeckoSessionSettings.Builder chromeUri(@NonNull String);
 method @NonNull public GeckoSessionSettings.Builder contextId(@Nullable String);
 method @NonNull public GeckoSessionSettings.Builder displayMode(int);
 method @NonNull public GeckoSessionSettings.Builder fullAccessibilityTree(boolean);
 method @NonNull public GeckoSessionSettings.Builder screenId(int);
 method @NonNull public GeckoSessionSettings.Builder suspendMediaWhenInactive(boolean);
 method @NonNull public GeckoSessionSettings.Builder usePrivateMode(boolean);
 method @NonNull public GeckoSessionSettings.Builder useTrackingProtection(boolean);
 method @NonNull public GeckoSessionSettings.Builder userAgentMode(int);
 method @NonNull public GeckoSessionSettings.Builder userAgentOverride(@NonNull String);
 method @NonNull public GeckoSessionSettings.Builder viewportMode(int);
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSessionSettings.DisplayMode {
 }

 public static class GeckoSessionSettings.Key<T> {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSessionSettings.UserAgentMode {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoSessionSettings.ViewportMode {
 }

 public class GeckoVRManager {
 method @AnyThread public static synchronized void setExternalContext(long);
 }

 @UiThread public class GeckoView extends FrameLayout implements GeckoDisplay.NewSurfaceProvider {
 ctor public GeckoView(Context);
 ctor public GeckoView(Context, AttributeSet);
 method @UiThread public void addWindowInsetsListener(@NonNull String, @Nullable OnApplyWindowInsetsListener);
 method @NonNull @UiThread public GeckoResult<Bitmap> capturePixels();
 method public void coverUntilFirstPaint(int);
 method public void dispatchDraw(@Nullable Canvas);
 method @Nullable public GeckoView.ActivityContextDelegate getActivityContextDelegate();
 method public boolean getAutofillEnabled();
 method @NonNull public PanZoomController getPanZoomController();
 method @Nullable public GeckoSession.PrintDelegate getPrintDelegate();
 method public void getPrintDelegate(@Nullable GeckoSession.PrintDelegate);
 method @AnyThread @Nullable public GeckoSession getSession();
 method public void onAttachedToWindow();
 method public void onDetachedFromWindow();
 method @NonNull public GeckoResult<PanZoomController.InputResultDetail> onTouchEventForDetailResult(@NonNull MotionEvent);
 method @Nullable @UiThread public GeckoSession releaseSession();
 method @UiThread public void removeWindowInsetsListener(@NonNull String);
 method public void setActivityContextDelegate(@Nullable GeckoView.ActivityContextDelegate);
 method public void setAutofillEnabled(boolean);
 method public void setDynamicToolbarMaxHeight(int);
 method @UiThread public void setSession(@NonNull GeckoSession);
 method public void setVerticalClipping(int);
 method public void setViewBackend(int);
 method public boolean shouldPinOnScreen();
 field public static final int BACKEND_SURFACE_VIEW = 1;
 field public static final int BACKEND_TEXTURE_VIEW = 2;
 field @NonNull protected final GeckoView.Display mDisplay;
 field @Nullable protected GeckoSession mSession;
 }

 @AnyThread public static interface GeckoView.ActivityContextDelegate {
 method @Nullable public Context getActivityContext();
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoView.ViewBackend {
 }

 public class GeckoViewPrintDocumentAdapter extends PrintDocumentAdapter {
 ctor public GeckoViewPrintDocumentAdapter(@NonNull InputStream, @NonNull Context);
 ctor public GeckoViewPrintDocumentAdapter(@NonNull InputStream, @NonNull Context, @Nullable GeckoResult<Boolean>);
 ctor public GeckoViewPrintDocumentAdapter(@NonNull File);
 method @AnyThread @Nullable public static File makeTempPdfFile(@NonNull InputStream, @NonNull Context);
 }

 @AnyThread public class GeckoWebExecutor {
 ctor public GeckoWebExecutor(@NonNull GeckoRuntime);
 method @NonNull public GeckoResult<WebResponse> fetch(@NonNull WebRequest);
 method @NonNull public GeckoResult<WebResponse> fetch(@NonNull WebRequest, int);
 method @NonNull public GeckoResult<InetAddress[]> resolve(@NonNull String);
 method public void speculativeConnect(@NonNull String);
 field public static final int FETCH_FLAGS_ANONYMOUS = 1;
 field public static final int FETCH_FLAGS_NONE = 0;
 field public static final int FETCH_FLAGS_NO_REDIRECTS = 2;
 field public static final int FETCH_FLAGS_OHTTP = 2048;
 field public static final int FETCH_FLAGS_PRIVATE = 8;
 field public static final int FETCH_FLAGS_STREAM_FAILURE_TEST = 1024;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface GeckoWebExecutor.FetchFlags {
 }

 @Documented @Retention(value=RetentionPolicy.CLASS) @Target(value={ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.TYPE, ElementType.PARAMETER}) public interface HandlerThread {
 }

 public class IPProtectionController {
 method @HandlerThread @NonNull public GeckoResult<Void> activate();
 method @HandlerThread @NonNull public GeckoResult<Void> deactivate();
 method @HandlerThread @NonNull public GeckoResult<IPProtectionController.EnrollResult> enroll();
 method @Nullable @UiThread public IPProtectionController.AuthProvider getAuthProvider();
 method @Nullable @UiThread public IPProtectionController.Delegate getDelegate();
 method @HandlerThread @NonNull public GeckoResult<IPProtectionController.ProxyState> getProxyState();
 method @HandlerThread @NonNull public GeckoResult<Integer> getServiceState();
 method @HandlerThread @NonNull public GeckoResult<Void> init();
 method @NonNull @UiThread public GeckoResult<Void> notifySignInStateChanged(boolean);
 method @UiThread public void setAuthProvider(@Nullable IPProtectionController.AuthProvider);
 method @UiThread public void setDelegate(@Nullable IPProtectionController.Delegate);
 method @HandlerThread @NonNull public GeckoResult<Void> uninit();
 field public static final int SERVICE_STATE_OPTED_OUT = 3;
 field public static final int SERVICE_STATE_READY = 4;
 field public static final int SERVICE_STATE_UNAUTHENTICATED = 2;
 field public static final int SERVICE_STATE_UNAVAILABLE = 1;
 field public static final int SERVICE_STATE_UNINITIALIZED = 0;
 }

 public static interface IPProtectionController.AuthProvider {
 method @NonNull @UiThread default public GeckoResult<String> getToken();
 }

 public static interface IPProtectionController.Delegate {
 method @UiThread default public void onProxyStateChanged(@NonNull IPProtectionController.ProxyState);
 method @UiThread default public void onServiceStateChanged(int);
 method @UiThread default public void onUsageChanged(@NonNull IPProtectionController.UsageInfo);
 }

 public static class IPProtectionController.EnrollResult {
 ctor protected EnrollResult();
 field @Nullable public final String error;
 field public final boolean isEnrolledAndEntitled;
 }

 public static class IPProtectionController.IPProxyException extends RuntimeException {
 method @AnyThread @NonNull public static IPProtectionController.IPProxyException fromErrorString(@Nullable String);
 field public static final int ERROR_ACTIVATION_CANCELED = -6;
 field public static final int ERROR_NETWORK = -2;
 field public static final int ERROR_PASS_UNAVAILABLE = -4;
 field public static final int ERROR_SERVER_NOT_FOUND = -5;
 field public static final int ERROR_TIMEOUT = -3;
 field public static final int ERROR_UNKNOWN = -1;
 field public final int code;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface IPProtectionController.IPProxyException.Code {
 }

 public static class IPProtectionController.ProxyState {
 ctor protected ProxyState();
 field public static final int ACTIVATING = 2;
 field public static final int ACTIVE = 3;
 field public static final int ERROR = 4;
 field public static final int NOT_READY = 0;
 field public static final int PAUSED = 5;
 field public static final int READY = 1;
 field @Nullable public final String errorType;
 field public final int state;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface IPProtectionController.ProxyState.Code {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface IPProtectionController.ServiceState {
 }

 public static class IPProtectionController.UsageInfo {
 ctor protected UsageInfo();
 field public final long max;
 field public final long remaining;
 field @Nullable public final String resetTime;
 }

 @AnyThread public class Image {
 method @NonNull public GeckoResult<Bitmap> getBitmap(int);
 }

 public static class Image.ImageProcessingException extends RuntimeException {
 ctor public ImageProcessingException(String);
 }

 @UiThread public class MediaSession {
 ctor protected MediaSession(GeckoSession);
 method public boolean isActive();
 method public void muteAudio(boolean);
 method public void nextTrack();
 method public void pause();
 method public void play();
 method public void previousTrack();
 method public void seekBackward();
 method public void seekForward();
 method public void seekTo(double, boolean);
 method public void skipAd();
 method public void stop();
 }

 @UiThread public static interface MediaSession.Delegate {
 method default public void onActivated(@NonNull GeckoSession, @NonNull MediaSession);
 method default public void onDeactivated(@NonNull GeckoSession, @NonNull MediaSession);
 method default public void onFeatures(@NonNull GeckoSession, @NonNull MediaSession, long);
 method default public void onFullscreen(@NonNull GeckoSession, @NonNull MediaSession, boolean, @Nullable MediaSession.ElementMetadata);
 method default public void onMetadata(@NonNull GeckoSession, @NonNull MediaSession, @NonNull MediaSession.Metadata);
 method default public void onPause(@NonNull GeckoSession, @NonNull MediaSession);
 method default public void onPlay(@NonNull GeckoSession, @NonNull MediaSession);
 method default public void onPositionState(@NonNull GeckoSession, @NonNull MediaSession, @NonNull MediaSession.PositionState);
 method default public void onStop(@NonNull GeckoSession, @NonNull MediaSession);
 }

 public static class MediaSession.ElementMetadata {
 ctor public ElementMetadata(@Nullable String, double, long, long, int, int);
 field public final int audioTrackCount;
 field public final double duration;
 field public final long height;
 field @Nullable public final String source;
 field public final int videoTrackCount;
 field public final long width;
 }

 public static class MediaSession.Feature {
 ctor public Feature();
 field public static final long FOCUS = 512L;
 field public static final long NEXT_TRACK = 128L;
 field public static final long NONE = 0L;
 field public static final long PAUSE = 2L;
 field public static final long PLAY = 1L;
 field public static final long PREVIOUS_TRACK = 256L;
 field public static final long SEEK_BACKWARD = 32L;
 field public static final long SEEK_FORWARD = 16L;
 field public static final long SEEK_TO = 8L;
 field public static final long SKIP_AD = 64L;
 field public static final long STOP = 4L;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface MediaSession.MSFeature {
 }

 public static class MediaSession.Metadata {
 ctor protected Metadata(@Nullable String, @Nullable String, @Nullable String, @Nullable Image);
 field @Nullable public final String album;
 field @Nullable public final String artist;
 field @Nullable public final Image artwork;
 field @Nullable public final String title;
 }

 public static class MediaSession.PositionState {
 ctor protected PositionState(double, double, double);
 field public final double duration;
 field public final double playbackRate;
 field public final double position;
 }

 public class OrientationController {
 method @Nullable @UiThread public OrientationController.OrientationDelegate getDelegate();
 method @UiThread public void setDelegate(@Nullable OrientationController.OrientationDelegate);
 }

 @UiThread public static interface OrientationController.OrientationDelegate {
 method @Nullable default public GeckoResult<AllowOrDeny> onOrientationLock(@NonNull int);
 method @Nullable default public void onOrientationUnlock();
 }

 @UiThread public final class OverscrollEdgeEffect {
 method public void draw(@NonNull Canvas);
 method @Nullable public Runnable getInvalidationCallback();
 method public void setInvalidationCallback(@Nullable Runnable);
 method public void setTheme(@NonNull Context);
 }

 public class PageExtractionController {
 ctor public PageExtractionController();
 }

 public static class PageExtractionController.ContentParams {
 ctor public ContentParams(boolean);
 field public final boolean removeBoilerplate;
 }

 public static class PageExtractionController.PageExtractionException extends Exception {
 ctor public PageExtractionException(@NonNull String);
 ctor public PageExtractionException(@NonNull String, Throwable);
 field public static final String ERROR_MALFORMED_RESULT = "MALFORMED_RESULT";
 field public static final String ERROR_NULL_RESULT = "NULL_RESULT";
 field public static final String ERROR_UNKNOWN = "UNKNOWN_ERROR";
 field @NonNull public final String errorType;
 }

 public static class PageExtractionController.PageMetadata {
 ctor public PageMetadata(@NonNull String[], int, @NonNull String, boolean);
 field public final boolean isReaderable;
 field @NonNull public final String language;
 field @NonNull public final String[] structuredDataTypes;
 field public final int wordCount;
 }

 public static class PageExtractionController.SessionPageExtractor {
 ctor public SessionPageExtractor(GeckoSession);
 method @HandlerThread @NonNull public GeckoResult<String> getPageContent();
 method @HandlerThread @NonNull public GeckoResult<String> getPageContent(@NonNull PageExtractionController.ContentParams);
 method @HandlerThread @NonNull public GeckoResult<PageExtractionController.PageMetadata> getPageMetadata();
 }

 @UiThread public class PanZoomController {
 ctor protected PanZoomController(GeckoSession);
 method public float getScrollFactor();
 method public boolean onDragEvent(@NonNull DragEvent);
 method public void onMotionEvent(@NonNull MotionEvent);
 method public void onMouseEvent(@NonNull MotionEvent);
 method public void onTouchEvent(@NonNull MotionEvent);
 method @NonNull public GeckoResult<PanZoomController.InputResultDetail> onTouchEventForDetailResult(@NonNull MotionEvent);
 method @UiThread public void scrollBy(@NonNull ScreenLength, @NonNull ScreenLength);
 method @UiThread public void scrollBy(@NonNull ScreenLength, @NonNull ScreenLength, int);
 method @UiThread public void scrollTo(@NonNull ScreenLength, @NonNull ScreenLength);
 method @UiThread public void scrollTo(@NonNull ScreenLength, @NonNull ScreenLength, int);
 method @UiThread public void scrollToBottom();
 method @UiThread public void scrollToTop();
 method public void setIsLongpressEnabled(boolean);
 method public void setScrollFactor(float);
 field public static final int INPUT_RESULT_HANDLED = 1;
 field public static final int INPUT_RESULT_HANDLED_CONTENT = 2;
 field public static final int INPUT_RESULT_IGNORED = 3;
 field public static final int INPUT_RESULT_UNHANDLED = 0;
 field public static final int OVERSCROLL_FLAG_HORIZONTAL = 1;
 field public static final int OVERSCROLL_FLAG_NONE = 0;
 field public static final int OVERSCROLL_FLAG_VERTICAL = 2;
 field public static final int SCROLLABLE_FLAG_BOTTOM = 4;
 field public static final int SCROLLABLE_FLAG_LEFT = 8;
 field public static final int SCROLLABLE_FLAG_NONE = 0;
 field public static final int SCROLLABLE_FLAG_RIGHT = 2;
 field public static final int SCROLLABLE_FLAG_TOP = 1;
 field public static final int SCROLL_BEHAVIOR_AUTO = 1;
 field public static final int SCROLL_BEHAVIOR_SMOOTH = 0;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface PanZoomController.InputResult {
 }

 public static class PanZoomController.InputResultDetail {
 ctor protected InputResultDetail(int, int, int);
 method @AnyThread public int handledResult();
 method @AnyThread public int overscrollDirections();
 method @AnyThread public int scrollableDirections();
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface PanZoomController.OverscrollDirections {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface PanZoomController.ScrollBehaviorType {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface PanZoomController.ScrollableDirections {
 }

 @UiThread public class ProfilerController {
 ctor public ProfilerController();
 method public static void addMarker(@NonNull String, @Nullable Double, @Nullable Double, @Nullable String);
 method public static void addMarker(@NonNull String, @Nullable Double, @Nullable String);
 method public static void addMarker(@NonNull String, @Nullable Double);
 method public static void addMarker(@NonNull String, @Nullable String);
 method public static void addMarker(@NonNull String);
 method @Nullable public static Double getProfilerTime();
 method public static boolean isProfilerActive();
 method public static void startProfiler(@NonNull String[], @NonNull String[]);
 method @NonNull public static GeckoResult<byte[]> stopProfiler();
 }

 public abstract class RuntimeSettings implements Parcelable {
 ctor protected RuntimeSettings();
 ctor protected RuntimeSettings(@Nullable RuntimeSettings);
 method @AnyThread public void readFromParcel(@NonNull Parcel);
 method @AnyThread protected void updatePrefs(@NonNull RuntimeSettings);
 }

 public abstract static class RuntimeSettings.Builder<Settings extends RuntimeSettings> {
 ctor public Builder();
 method @AnyThread @NonNull public Settings build();
 method @AnyThread @NonNull protected Settings getSettings();
 method @AnyThread @NonNull protected abstract Settings newSettings(@Nullable Settings);
 }

 public class ScreenLength {
 method @AnyThread @NonNull public static ScreenLength bottom();
 method @AnyThread @NonNull public static ScreenLength fromPixels(double);
 method @AnyThread @NonNull public static ScreenLength fromVisualViewportHeight(double);
 method @AnyThread @NonNull public static ScreenLength fromVisualViewportWidth(double);
 method @AnyThread public int getType();
 method @AnyThread public double getValue();
 method @AnyThread @NonNull public static ScreenLength top();
 method @AnyThread @NonNull public static ScreenLength zero();
 field public static final int DOCUMENT_HEIGHT = 4;
 field public static final int DOCUMENT_WIDTH = 3;
 field public static final int PIXEL = 0;
 field public static final int VISUAL_VIEWPORT_HEIGHT = 2;
 field public static final int VISUAL_VIEWPORT_WIDTH = 1;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface ScreenLength.ScreenLengthType {
 }

 @UiThread public class SessionAccessibility {
 method @Nullable public View getView();
 method public boolean onMotionEvent(@NonNull MotionEvent);
 method @UiThread public void setView(@Nullable View);
 }

 @AnyThread public final class SessionFinder {
 method public void clear();
 method @NonNull public GeckoResult<GeckoSession.FinderResult> find(@Nullable String, int);
 method public int getDisplayFlags();
 method public void setDisplayFlags(int);
 }

 @AnyThread public final class SessionPdfFileSaver {
 method @Nullable public static GeckoResult<WebResponse> createResponse(@NonNull GeckoSession, @NonNull String, @NonNull String, @NonNull String, boolean, boolean);
 method @NonNull public GeckoResult<WebResponse> save();
 }

 public final class SessionTextInput {
 method @NonNull @UiThread public GeckoSession.TextInputDelegate getDelegate();
 method @AnyThread @NonNull public synchronized Handler getHandler(@NonNull Handler);
 method @Nullable @UiThread public View getView();
 method @AnyThread @Nullable public synchronized InputConnection onCreateInputConnection(@NonNull EditorInfo);
 method @UiThread public boolean onKeyDown(int, @NonNull KeyEvent);
 method @UiThread public boolean onKeyLongPress(int, @NonNull KeyEvent);
 method @UiThread public boolean onKeyMultiple(int, int, @NonNull KeyEvent);
 method @UiThread public boolean onKeyPreIme(int, @NonNull KeyEvent);
 method @UiThread public boolean onKeyUp(int, @NonNull KeyEvent);
 method @UiThread public void setDelegate(@Nullable GeckoSession.TextInputDelegate);
 method @UiThread public synchronized void setView(@Nullable View);
 }

 @AnyThread public final enum SlowScriptResponse {
 method public static SlowScriptResponse valueOf(String);
 method public static SlowScriptResponse[] values();
 enum_constant public static final SlowScriptResponse CONTINUE;
 enum_constant public static final SlowScriptResponse STOP;
 }

 public final class StorageController {
 ctor public StorageController();
 method @HandlerThread @NonNull public GeckoResult<Void> clearData(long);
 method @AnyThread public void clearDataForSessionContext(@NonNull String);
 method @HandlerThread @NonNull public GeckoResult<Void> clearDataFromBaseDomain(@NonNull String, long);
 method @HandlerThread @NonNull public GeckoResult<Void> clearDataFromHost(@NonNull String, long);
 method @HandlerThread @NonNull public GeckoResult<List<GeckoSession.PermissionDelegate.ContentPermission>> getAllPermissions();
 method @AnyThread @NonNull public GeckoResult<Integer> getCookieBannerModeForDomain(@NonNull String, boolean);
 method @HandlerThread @NonNull public GeckoResult<List<GeckoSession.PermissionDelegate.ContentPermission>> getPermissions(@NonNull String);
 method @HandlerThread @NonNull public GeckoResult<List<GeckoSession.PermissionDelegate.ContentPermission>> getPermissions(@NonNull String, boolean);
 method @HandlerThread @NonNull public GeckoResult<List<GeckoSession.PermissionDelegate.ContentPermission>> getPermissions(@NonNull String, @Nullable String, boolean);
 method @HandlerThread @NonNull public GeckoResult<Void> removeCookieBannerModeForDomain(@NonNull String, boolean);
 method @HandlerThread @NonNull public GeckoResult<Void> setCookieBannerModeAndPersistInPrivateBrowsingForDomain(@NonNull String, int);
 method @HandlerThread @NonNull public GeckoResult<Void> setCookieBannerModeForDomain(@NonNull String, int, boolean);
 method @AnyThread public void setPermission(@NonNull GeckoSession.PermissionDelegate.ContentPermission, int);
 method @AnyThread public void setPrivateBrowsingPermanentPermission(@NonNull GeckoSession.PermissionDelegate.ContentPermission, int);
 }

 public static class StorageController.ClearFlags {
 ctor public ClearFlags();
 field public static final long ALL = 512L;
 field public static final long ALL_CACHES = 6L;
 field public static final long AUTH_SESSIONS = 32L;
 field public static final long COOKIES = 1L;
 field public static final long DOM_STORAGES = 16L;
 field public static final long IMAGE_CACHE = 4L;
 field public static final long NETWORK_CACHE = 2L;
 field public static final long PERMISSIONS = 64L;
 field public static final long SITE_DATA = 471L;
 field public static final long SITE_SETTINGS = 192L;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface StorageController.StorageControllerClearFlags {
 }

 public class TranslationsController {
 ctor public TranslationsController();
 }

 public static class TranslationsController.Language implements Comparable<TranslationsController.Language> {
 ctor public Language(@NonNull String, @Nullable String);
 method @AnyThread public int compareTo(@Nullable TranslationsController.Language);
 field @NonNull public final String code;
 field @Nullable public final String localizedDisplayName;
 }

 public static class TranslationsController.RuntimeTranslation {
 ctor public RuntimeTranslation();
 method @HandlerThread @NonNull public static GeckoResult<Long> checkPairDownloadSize(@NonNull String, @NonNull String);
 method @HandlerThread @NonNull public static GeckoResult<Long> checkPairDownloadSize(@NonNull TranslationsController.SessionTranslation.TranslationPair);
 method @HandlerThread @NonNull public static GeckoResult<String> getLanguageSetting(@NonNull String);
 method @HandlerThread @NonNull public static GeckoResult<Map<String,String>> getLanguageSettings();
 method @HandlerThread @NonNull public static GeckoResult<List<String>> getNeverTranslateSiteList();
 method @HandlerThread @NonNull public static GeckoResult<Boolean> isTranslationsEngineSupported();
 method @HandlerThread @NonNull public static GeckoResult<List<TranslationsController.RuntimeTranslation.LanguageModel>> listModelDownloadStates();
 method @HandlerThread @NonNull public static GeckoResult<TranslationsController.RuntimeTranslation.TranslationSupport> listSupportedLanguages();
 method @HandlerThread @NonNull public static GeckoResult<Void> manageLanguageModel(@NonNull TranslationsController.RuntimeTranslation.ModelManagementOptions);
 method @HandlerThread @NonNull public static GeckoResult<List<String>> preferredLanguages();
 method @HandlerThread @NonNull public static GeckoResult<Void> setLanguageSettings(@NonNull String, @NonNull String);
 method @HandlerThread @NonNull public static GeckoResult<Void> setNeverTranslateSpecifiedSite(@NonNull Boolean, @NonNull String);
 field public static final String ALL = "all";
 field public static final String ALWAYS = "always";
 field public static final String CACHE = "cache";
 field public static final String DELETE = "delete";
 field public static final String DOWNLOAD = "download";
 field public static final String LANGUAGE = "language";
 field public static final String NEVER = "never";
 field public static final String OFFER = "offer";
 }

 public static class TranslationsController.RuntimeTranslation.LanguageModel {
 ctor public LanguageModel(@Nullable TranslationsController.Language, Boolean, long);
 field @NonNull public final Boolean isDownloaded;
 field @Nullable public final TranslationsController.Language language;
 field public final long size;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface TranslationsController.RuntimeTranslation.LanguageSetting {
 }

 @AnyThread public static class TranslationsController.RuntimeTranslation.ModelManagementOptions {
 ctor protected ModelManagementOptions(@NonNull TranslationsController.RuntimeTranslation.ModelManagementOptions.Builder);
 field @Nullable public final String language;
 field @NonNull public final String operation;
 field @NonNull public final String operationLevel;
 }

 @AnyThread public static class TranslationsController.RuntimeTranslation.ModelManagementOptions.Builder {
 ctor public Builder();
 method @AnyThread @NonNull public TranslationsController.RuntimeTranslation.ModelManagementOptions build();
 method @NonNull public TranslationsController.RuntimeTranslation.ModelManagementOptions.Builder languageToManage(@NonNull String);
 method @NonNull public TranslationsController.RuntimeTranslation.ModelManagementOptions.Builder operation(@NonNull String);
 method @NonNull public TranslationsController.RuntimeTranslation.ModelManagementOptions.Builder operationLevel(@NonNull String);
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface TranslationsController.RuntimeTranslation.ModelOperation {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface TranslationsController.RuntimeTranslation.OperationLevel {
 }

 public static class TranslationsController.RuntimeTranslation.TranslationSupport {
 ctor public TranslationSupport(@Nullable List<TranslationsController.Language>, @Nullable List<TranslationsController.Language>);
 field @Nullable public final List<TranslationsController.Language> fromLanguages;
 field @Nullable public final List<TranslationsController.Language> toLanguages;
 }

 public static class TranslationsController.SessionTranslation {
 ctor public SessionTranslation(GeckoSession);
 method @AnyThread @NonNull public TranslationsController.SessionTranslation.Handler getHandler();
 method @HandlerThread @NonNull public GeckoResult<Boolean> getNeverTranslateSiteSetting();
 method @HandlerThread @NonNull public GeckoResult<Void> restoreOriginalPage();
 method @HandlerThread @NonNull public GeckoResult<Void> setNeverTranslateSiteSetting(@NonNull Boolean);
 method @HandlerThread @NonNull public GeckoResult<Void> translate(@NonNull String, @NonNull String, @Nullable TranslationsController.SessionTranslation.TranslationOptions);
 method @HandlerThread @NonNull public GeckoResult<Void> translate(@NonNull TranslationsController.SessionTranslation.TranslationPair, @Nullable TranslationsController.SessionTranslation.TranslationOptions);
 }

 @AnyThread public static interface TranslationsController.SessionTranslation.Delegate {
 method default public void onExpectedTranslate(@NonNull GeckoSession);
 method default public void onOfferTranslate(@NonNull GeckoSession);
 method default public void onTranslationStateChange(@NonNull GeckoSession, @Nullable TranslationsController.SessionTranslation.TranslationState);
 }

 public static class TranslationsController.SessionTranslation.DetectedLanguages {
 ctor public DetectedLanguages(@Nullable String, @NonNull Boolean, @Nullable String);
 field @Nullable public final String docLangTag;
 field @NonNull public final Boolean isDocLangTagSupported;
 field @Nullable public final String userLangTag;
 }

 @AnyThread public static class TranslationsController.SessionTranslation.TranslationOptions {
 ctor protected TranslationOptions(@NonNull TranslationsController.SessionTranslation.TranslationOptions.Builder);
 field @NonNull public final boolean downloadModel;
 }

 @AnyThread public static class TranslationsController.SessionTranslation.TranslationOptions.Builder {
 ctor public Builder();
 method @AnyThread @NonNull public TranslationsController.SessionTranslation.TranslationOptions build();
 method @NonNull public TranslationsController.SessionTranslation.TranslationOptions.Builder downloadModel(@NonNull boolean);
 }

 public static class TranslationsController.SessionTranslation.TranslationPair {
 ctor public TranslationPair(@Nullable String, @Nullable String);
 field @Nullable public final String fromLanguage;
 field @Nullable public final String toLanguage;
 }

 public static class TranslationsController.SessionTranslation.TranslationState {
 ctor public TranslationState(@Nullable TranslationsController.SessionTranslation.TranslationPair, @Nullable String, @Nullable TranslationsController.SessionTranslation.DetectedLanguages, @NonNull Boolean, @NonNull Boolean);
 field @Nullable public final TranslationsController.SessionTranslation.DetectedLanguages detectedLanguages;
 field @Nullable public final String error;
 field @NonNull public final Boolean hasVisibleChange;
 field @NonNull public final Boolean isEngineReady;
 field @Nullable public final TranslationsController.SessionTranslation.TranslationPair requestedTranslationPair;
 }

 public static class TranslationsController.TranslationsException extends Exception {
 ctor public TranslationsException(int);
 field public static final int ERROR_COULD_NOT_LOAD_LANGUAGES = -5;
 field public static final int ERROR_COULD_NOT_RESTORE = -4;
 field public static final int ERROR_COULD_NOT_TRANSLATE = -3;
 field public static final int ERROR_ENGINE_DEACTIVATED = -12;
 field public static final int ERROR_ENGINE_NOT_SUPPORTED = -2;
 field public static final int ERROR_LANGUAGE_NOT_SUPPORTED = -6;
 field public static final int ERROR_MODEL_COULD_NOT_DELETE = -8;
 field public static final int ERROR_MODEL_COULD_NOT_DOWNLOAD = -9;
 field public static final int ERROR_MODEL_COULD_NOT_RETRIEVE = -7;
 field public static final int ERROR_MODEL_DOWNLOAD_REQUIRED = -11;
 field public static final int ERROR_MODEL_LANGUAGE_REQUIRED = -10;
 field public static final int ERROR_UNKNOWN = -1;
 field public final int code;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface TranslationsController.TranslationsException.Code {
 }

 public class WebExtension {
 method @Nullable @UiThread public WebExtension.BrowsingDataDelegate getBrowsingDataDelegate();
 method @Nullable @UiThread public WebExtension.DownloadDelegate getDownloadDelegate();
 method @Nullable @UiThread public WebExtension.TabDelegate getTabDelegate();
 method @AnyThread public void setActionDelegate(@Nullable WebExtension.ActionDelegate);
 method @UiThread public void setBrowsingDataDelegate(@Nullable WebExtension.BrowsingDataDelegate);
 method @UiThread public void setDownloadDelegate(@Nullable WebExtension.DownloadDelegate);
 method @UiThread public void setMessageDelegate(@Nullable WebExtension.MessageDelegate, @NonNull String);
 method @UiThread public void setTabDelegate(@Nullable WebExtension.TabDelegate);
 field public static final List<String> DATA_COLLECTION_PERMISSIONS;
 field public final long flags;
 field @NonNull public final String id;
 field public final boolean isBuiltIn;
 field @NonNull public final String location;
 field @NonNull public final WebExtension.MetaData metaData;
 }

 @AnyThread public static class WebExtension.Action {
 ctor protected Action();
 method @UiThread public void click();
 method @NonNull public WebExtension.Action withDefault(@NonNull WebExtension.Action);
 field @Nullable public final Integer badgeBackgroundColor;
 field @Nullable public final String badgeText;
 field @Nullable public final Integer badgeTextColor;
 field @Nullable public final Boolean enabled;
 field @Nullable public final Image icon;
 field @Nullable public final String title;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface WebExtension.Action.ActionType {
 }

 public static interface WebExtension.ActionDelegate {
 method @UiThread default public void onBrowserAction(@NonNull WebExtension, @Nullable GeckoSession, @NonNull WebExtension.Action);
 method @Nullable @UiThread default public GeckoResult<GeckoSession> onOpenPopup(@NonNull WebExtension, @NonNull WebExtension.Action);
 method @UiThread default public void onPageAction(@NonNull WebExtension, @Nullable GeckoSession, @NonNull WebExtension.Action);
 method @Nullable @UiThread default public GeckoResult<GeckoSession> onTogglePopup(@NonNull WebExtension, @NonNull WebExtension.Action);
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface WebExtension.BlocklistState {
 }

 public static class WebExtension.BlocklistStateFlags {
 ctor public BlocklistStateFlags();
 field public static final int BLOCKED = 2;
 field public static final int NOT_BLOCKED = 0;
 field public static final int OUTDATED = 3;
 field public static final int SOFTBLOCKED = 1;
 field public static final int VULNERABLE_NO_UPDATE = 5;
 field public static final int VULNERABLE_UPDATE_AVAILABLE = 4;
 }

 @UiThread public static interface WebExtension.BrowsingDataDelegate {
 method @Nullable default public GeckoResult<Void> onClearDownloads(long);
 method @Nullable default public GeckoResult<Void> onClearFormData(long);
 method @Nullable default public GeckoResult<Void> onClearHistory(long);
 method @Nullable default public GeckoResult<Void> onClearPasswords(long);
 method @Nullable default public GeckoResult<WebExtension.BrowsingDataDelegate.Settings> onGetSettings();
 }

 @UiThread public static class WebExtension.BrowsingDataDelegate.Settings {
 ctor @UiThread public Settings(int, long, long);
 field public final long selectedTypes;
 field public final int sinceUnixTimestamp;
 field public final long toggleableTypes;
 }

 public static class WebExtension.BrowsingDataDelegate.Type {
 ctor protected Type();
 field public static final long CACHE = 1L;
 field public static final long COOKIES = 2L;
 field public static final long DOWNLOADS = 4L;
 field public static final long FORM_DATA = 8L;
 field public static final long HISTORY = 16L;
 field public static final long LOCAL_STORAGE = 32L;
 field public static final long PASSWORDS = 64L;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface WebExtension.BrowsingDataTypes {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface WebExtension.ContextFlags {
 }

 public static class WebExtension.CreateTabDetails {
 ctor protected CreateTabDetails();
 field @Nullable public final Boolean active;
 field @Nullable public final String cookieStoreId;
 field @Nullable public final Boolean discarded;
 field @Nullable public final Integer index;
 field @Nullable public final Boolean openInReaderMode;
 field @Nullable public final Boolean pinned;
 field @Nullable public final String url;
 }

 public static class WebExtension.DisabledFlags {
 ctor public DisabledFlags();
 field public static final int APP = 8;
 field public static final int APP_VERSION = 32;
 field public static final int BLOCKLIST = 4;
 field public static final int SIGNATURE = 16;
 field public static final int SOFT_BLOCKLIST = 64;
 field public static final int USER = 2;
 }

 public static class WebExtension.Download {
 ctor protected Download(int);
 method @Nullable @UiThread public GeckoResult<Void> update(@NonNull WebExtension.Download.Info);
 field public static final int INTERRUPT_REASON_CRASH = 24;
 field public static final int INTERRUPT_REASON_FILE_ACCESS_DENIED = 2;
 field public static final int INTERRUPT_REASON_FILE_BLOCKED = 8;
 field public static final int INTERRUPT_REASON_FILE_FAILED = 1;
 field public static final int INTERRUPT_REASON_FILE_NAME_TOO_LONG = 4;
 field public static final int INTERRUPT_REASON_FILE_NO_SPACE = 3;
 field public static final int INTERRUPT_REASON_FILE_SECURITY_CHECK_FAILED = 9;
 field public static final int INTERRUPT_REASON_FILE_TOO_LARGE = 5;
 field public static final int INTERRUPT_REASON_FILE_TOO_SHORT = 10;
 field public static final int INTERRUPT_REASON_FILE_TRANSIENT_ERROR = 7;
 field public static final int INTERRUPT_REASON_FILE_VIRUS_INFECTED = 6;
 field public static final int INTERRUPT_REASON_NETWORK_DISCONNECTED = 13;
 field public static final int INTERRUPT_REASON_NETWORK_FAILED = 11;
 field public static final int INTERRUPT_REASON_NETWORK_INVALID_REQUEST = 15;
 field public static final int INTERRUPT_REASON_NETWORK_SERVER_DOWN = 14;
 field public static final int INTERRUPT_REASON_NETWORK_TIMEOUT = 12;
 field public static final int INTERRUPT_REASON_NO_INTERRUPT = 0;
 field public static final int INTERRUPT_REASON_SERVER_BAD_CONTENT = 18;
 field public static final int INTERRUPT_REASON_SERVER_CERT_PROBLEM = 20;
 field public static final int INTERRUPT_REASON_SERVER_FAILED = 16;
 field public static final int INTERRUPT_REASON_SERVER_FORBIDDEN = 21;
 field public static final int INTERRUPT_REASON_SERVER_NO_RANGE = 17;
 field public static final int INTERRUPT_REASON_SERVER_UNAUTHORIZED = 19;
 field public static final int INTERRUPT_REASON_USER_CANCELED = 22;
 field public static final int INTERRUPT_REASON_USER_SHUTDOWN = 23;
 field public static final int STATE_COMPLETE = 2;
 field public static final int STATE_INTERRUPTED = 1;
 field public static final int STATE_IN_PROGRESS = 0;
 field public final int id;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface WebExtension.Download.DownloadInterruptReason {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface WebExtension.Download.DownloadState {
 }

 public static interface WebExtension.Download.Info {
 method @UiThread default public long bytesReceived();
 method @UiThread default public boolean canResume();
 method @Nullable @UiThread default public Long endTime();
 method @Nullable @UiThread default public Integer error();
 method @Nullable @UiThread default public Long estimatedEndTime();
 method @UiThread default public boolean fileExists();
 method @UiThread default public long fileSize();
 method @NonNull @UiThread default public String filename();
 method @NonNull @UiThread default public String mime();
 method @UiThread default public boolean paused();
 method @NonNull @UiThread default public String referrer();
 method @UiThread default public long startTime();
 method @UiThread default public int state();
 method @UiThread default public long totalBytes();
 }

 public static interface WebExtension.DownloadDelegate {
 method @AnyThread @Nullable default public GeckoResult<WebExtension.DownloadInitData> onDownload(@NonNull WebExtension, @NonNull WebExtension.DownloadRequest);
 }

 public static class WebExtension.DownloadInitData {
 ctor public DownloadInitData(WebExtension.Download, WebExtension.Download.Info);
 field @NonNull public final WebExtension.Download download;
 field @NonNull public final WebExtension.Download.Info initData;
 }

 public static class WebExtension.DownloadRequest {
 ctor protected DownloadRequest(WebExtension.DownloadRequest.Builder);
 field public static final int CONFLICT_ACTION_OVERWRITE = 1;
 field public static final int CONFLICT_ACTION_PROMPT = 2;
 field public static final int CONFLICT_ACTION_UNIQUIFY = 0;
 field public final boolean allowHttpErrors;
 field public final int conflictActionFlag;
 field public final int downloadFlags;
 field @Nullable public final String filename;
 field @NonNull public final WebRequest request;
 field public final boolean saveAs;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface WebExtension.DownloadRequest.ConflictActionFlags {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface WebExtension.EnabledFlags {
 }

 public static class WebExtension.Flags {
 ctor protected Flags();
 field public static final long ALLOW_CONTENT_MESSAGING = 1L;
 field public static final long NONE = 0L;
 }

 public static class WebExtension.InstallException extends Exception {
 ctor protected InstallException();
 field public final int code;
 field @Nullable public final String extensionId;
 field @Nullable public final String extensionName;
 field @Nullable public final String extensionVersion;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface WebExtension.InstallException.Codes {
 }

 public static class WebExtension.InstallException.ErrorCodes {
 ctor protected ErrorCodes();
 field public static final int ERROR_ADMIN_INSTALL_ONLY = -13;
 field public static final int ERROR_BLOCKLISTED = -10;
 field public static final int ERROR_CORRUPT_FILE = -3;
 field public static final int ERROR_FILE_ACCESS = -4;
 field public static final int ERROR_INCOMPATIBLE = -11;
 field public static final int ERROR_INCORRECT_HASH = -2;
 field public static final int ERROR_INCORRECT_ID = -7;
 field public static final int ERROR_INVALID_DOMAIN = -8;
 field public static final int ERROR_NETWORK_FAILURE = -1;
 field public static final int ERROR_POSTPONED = -101;
 field public static final int ERROR_SIGNEDSTATE_REQUIRED = -5;
 field public static final int ERROR_SOFT_BLOCKED = -14;
 field public static final int ERROR_UNEXPECTED_ADDON_TYPE = -6;
 field public static final int ERROR_UNEXPECTED_ADDON_VERSION = -9;
 field public static final int ERROR_UNSUPPORTED_ADDON_TYPE = -12;
 field public static final int ERROR_USER_CANCELED = -100;
 }

 public static class WebExtension.InvalidMetaDataException extends RuntimeException {
 ctor protected InvalidMetaDataException();
 }

 @UiThread public static interface WebExtension.MessageDelegate {
 method @Nullable default public void onConnect(@NonNull WebExtension.Port);
 method @Nullable default public GeckoResult<Object> onMessage(@NonNull String, @NonNull Object, @NonNull WebExtension.MessageSender);
 }

 @UiThread public static class WebExtension.MessageSender {
 ctor protected MessageSender();
 method public boolean isTopLevel();
 field public static final int ENV_TYPE_CONTENT_SCRIPT = 2;
 field public static final int ENV_TYPE_EXTENSION = 1;
 field public final int environmentType;
 field @Nullable public final GeckoSession session;
 field @NonNull public final String url;
 field @NonNull public final WebExtension webExtension;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface WebExtension.MessageSender.EnvType {
 }

 public class WebExtension.MetaData {
 ctor protected MetaData();
 field public final boolean allowedInPrivateBrowsing;
 field @Nullable public final String amoListingUrl;
 field public final double averageRating;
 field @NonNull public final String baseUrl;
 field public final int blocklistState;
 field @Nullable public final String creatorName;
 field @Nullable public final String creatorUrl;
 field @Nullable public final String description;
 field public final int disabledFlags;
 field @Nullable public final String downloadUrl;
 field public final boolean enabled;
 field @Nullable public final String fullDescription;
 field @NonNull public final String[] grantedOptionalDataCollectionPermissions;
 field @NonNull public final String[] grantedOptionalOrigins;
 field @NonNull public final String[] grantedOptionalPermissions;
 field @Nullable public final String homepageUrl;
 field @NonNull public final Image icon;
 field @Nullable public final String incognito;
 field public final boolean isRecommended;
 field @Nullable public final String name;
 field public final boolean openOptionsPageInTab;
 field @NonNull public final String[] optionalDataCollectionPermissions;
 field @NonNull public final String[] optionalOrigins;
 field @NonNull public final String[] optionalPermissions;
 field @Nullable public final String optionsPageUrl;
 field @NonNull public final String[] requiredDataCollectionPermissions;
 field @NonNull public final String[] requiredOrigins;
 field @NonNull public final String[] requiredPermissions;
 field public final int reviewCount;
 field @Nullable public final String reviewUrl;
 field public final int signedState;
 field public final boolean temporary;
 field @Nullable public final String updateDate;
 field @NonNull public final String version;
 }

 public static class WebExtension.PermissionPromptResponse {
 ctor public PermissionPromptResponse(Boolean, Boolean, Boolean);
 field @Nullable public final Boolean isPermissionsGranted;
 field @Nullable public final Boolean isPrivateModeGranted;
 field @Nullable public final Boolean isTechnicalAndInteractionDataGranted;
 }

 @UiThread public static class WebExtension.Port {
 ctor protected Port();
 method public void disconnect();
 method public void postMessage(@NonNull JSONObject);
 method public void setDelegate(@Nullable WebExtension.PortDelegate);
 field @NonNull public final String name;
 field @NonNull public final WebExtension.MessageSender sender;
 }

 @UiThread public static interface WebExtension.PortDelegate {
 method @NonNull default public void onDisconnect(@NonNull WebExtension.Port);
 method default public void onPortMessage(@NonNull Object, @NonNull WebExtension.Port);
 }

 public static class WebExtension.SessionController {
 method @AnyThread @Nullable public WebExtension.ActionDelegate getActionDelegate(@NonNull WebExtension);
 method @AnyThread @Nullable public WebExtension.MessageDelegate getMessageDelegate(@NonNull WebExtension, @NonNull String);
 method @AnyThread @Nullable public WebExtension.SessionTabDelegate getTabDelegate(@NonNull WebExtension);
 method @AnyThread public void setActionDelegate(@NonNull WebExtension, @Nullable WebExtension.ActionDelegate);
 method @AnyThread public void setMessageDelegate(@NonNull WebExtension, @Nullable WebExtension.MessageDelegate, @NonNull String);
 method @AnyThread public void setTabDelegate(@NonNull WebExtension, @Nullable WebExtension.SessionTabDelegate);
 }

 public static interface WebExtension.SessionTabDelegate {
 method @NonNull @UiThread default public GeckoResult<AllowOrDeny> onCloseTab(@Nullable WebExtension, @NonNull GeckoSession);
 method @NonNull @UiThread default public GeckoResult<AllowOrDeny> onUpdateTab(@NonNull WebExtension, @NonNull GeckoSession, @NonNull WebExtension.UpdateTabDetails);
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface WebExtension.SignedState {
 }

 public static class WebExtension.SignedStateFlags {
 ctor public SignedStateFlags();
 field public static final int MISSING = 0;
 field public static final int PRELIMINARY = 1;
 field public static final int PRIVILEGED = 4;
 field public static final int SIGNED = 2;
 field public static final int SYSTEM = 3;
 field public static final int UNKNOWN = -1;
 }

 public static interface WebExtension.TabDelegate {
 method @Nullable @UiThread default public GeckoResult<GeckoSession> onNewTab(@NonNull WebExtension, @NonNull WebExtension.CreateTabDetails);
 method @UiThread default public void onOpenOptionsPage(@NonNull WebExtension);
 }

 public static class WebExtension.UpdateTabDetails {
 ctor protected UpdateTabDetails();
 field @Nullable public final Boolean active;
 field @Nullable public final Boolean autoDiscardable;
 field @Nullable public final Boolean highlighted;
 field @Nullable public final Boolean muted;
 field @Nullable public final Boolean pinned;
 field @Nullable public final String url;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface WebExtension.WebExtensionFlags {
 }

 public class WebExtensionController {
 method @HandlerThread @NonNull public GeckoResult<WebExtension> addOptionalPermissions(@NonNull String, @NonNull String[], @NonNull String[], @NonNull String[]);
 method @Nullable @UiThread public WebExtension.Download createDownload(int);
 method @HandlerThread @NonNull public GeckoResult<WebExtension> disable(@NonNull WebExtension, int);
 method @AnyThread public void disableExtensionProcessSpawning();
 method @HandlerThread @NonNull public GeckoResult<WebExtension> enable(@NonNull WebExtension, int);
 method @AnyThread public void enableExtensionProcessSpawning();
 method @HandlerThread @NonNull public GeckoResult<WebExtension> ensureBuiltIn(@NonNull String, @Nullable String);
 method @Nullable @UiThread public WebExtensionController.PromptDelegate getPromptDelegate();
 method @HandlerThread @NonNull public GeckoResult<WebExtension> install(@NonNull String, @Nullable String);
 method @HandlerThread @NonNull public GeckoResult<WebExtension> install(@NonNull String);
 method @HandlerThread @NonNull public GeckoResult<WebExtension> installBuiltIn(@NonNull String);
 method @HandlerThread @NonNull public GeckoResult<List<WebExtension>> list();
 method @HandlerThread @NonNull public GeckoResult<WebExtension> removeOptionalPermissions(@NonNull String, @NonNull String[], @NonNull String[], @NonNull String[]);
 method @UiThread public void setAddonManagerDelegate(@Nullable WebExtensionController.AddonManagerDelegate);
 method @HandlerThread @NonNull public GeckoResult<WebExtension> setAllowedInPrivateBrowsing(@NonNull WebExtension, boolean);
 method @UiThread public void setDebuggerDelegate(@NonNull WebExtensionController.DebuggerDelegate);
 method @UiThread public void setExtensionProcessDelegate(@Nullable WebExtensionController.ExtensionProcessDelegate);
 method @UiThread public void setPromptDelegate(@Nullable WebExtensionController.PromptDelegate);
 method @AnyThread public void setTabActive(@NonNull GeckoSession, boolean);
 method @HandlerThread @NonNull public GeckoResult<Void> uninstall(@NonNull WebExtension);
 method @HandlerThread @NonNull public GeckoResult<WebExtension> update(@NonNull WebExtension);
 field public static final String INSTALLATION_METHOD_FROM_FILE = "install-from-file";
 field public static final String INSTALLATION_METHOD_MANAGER = "manager";
 field public static final String INSTALLATION_METHOD_ONBOARDING = "onboarding";
 field public static final String INSTALLATION_METHOD_RTAMO = "rtamo";
 }

 public static interface WebExtensionController.AddonManagerDelegate {
 method @UiThread default public void onDisabled(@NonNull WebExtension);
 method @UiThread default public void onDisabling(@NonNull WebExtension);
 method @UiThread default public void onEnabled(@NonNull WebExtension);
 method @UiThread default public void onEnabling(@NonNull WebExtension);
 method @UiThread default public void onInstallationFailed(@Nullable WebExtension, @NonNull WebExtension.InstallException);
 method @UiThread default public void onInstalled(@NonNull WebExtension);
 method @UiThread default public void onInstalling(@NonNull WebExtension);
 method @UiThread default public void onOptionalPermissionsChanged(@NonNull WebExtension);
 method @UiThread default public void onReady(@NonNull WebExtension);
 method @UiThread default public void onUninstalled(@NonNull WebExtension);
 method @UiThread default public void onUninstalling(@NonNull WebExtension);
 }

 public static interface WebExtensionController.DebuggerDelegate {
 method @UiThread default public void onExtensionListUpdated();
 }

 public static class WebExtensionController.EnableSource {
 ctor public EnableSource();
 field public static final int APP = 2;
 field public static final int USER = 1;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface WebExtensionController.EnableSources {
 }

 public static interface WebExtensionController.ExtensionProcessDelegate {
 method @UiThread default public void onDisabledProcessSpawning();
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface WebExtensionController.InstallationMethod {
 }

 @UiThread public static interface WebExtensionController.PromptDelegate {
 method @Nullable default public GeckoResult<WebExtension.PermissionPromptResponse> onInstallPromptRequest(@NonNull WebExtension, @NonNull String[], @NonNull String[], @NonNull String[]);
 method @Nullable default public GeckoResult<AllowOrDeny> onOptionalPrompt(@NonNull WebExtension, @NonNull String[], @NonNull String[], @NonNull String[]);
 method @Nullable default public GeckoResult<AllowOrDeny> onUpdatePrompt(@NonNull WebExtension, @NonNull String[], @NonNull String[], @NonNull String[]);
 }

 @AnyThread public abstract class WebMessage {
 ctor protected WebMessage(@NonNull WebMessage.Builder);
 field @NonNull public final Map<String,String> headers;
 field @NonNull public final String uri;
 }

 @AnyThread public abstract static class WebMessage.Builder {
 method @NonNull public WebMessage.Builder addHeader(@NonNull String, @NonNull String);
 method @NonNull public WebMessage.Builder header(@NonNull String, @NonNull String);
 method @NonNull public WebMessage.Builder uri(@NonNull String);
 }

 public class WebNotification implements Parcelable {
 method @UiThread public void click();
 method @UiThread public void click(@NonNull String);
 method @UiThread public void dismiss();
 method @UiThread public void show();
 field public static final Parcelable.Creator<WebNotification> CREATOR;
 field @NonNull public final WebNotificationAction[] actions;
 field @Nullable public final String imageUrl;
 field @Nullable public final String lang;
 field @NonNull public final String origin;
 field public final boolean privateBrowsing;
 field public final boolean requireInteraction;
 field public final boolean silent;
 field @Nullable public final String source;
 field @NonNull public final String tag;
 field @Nullable public final String text;
 field @Nullable public final String textDirection;
 field @Nullable public final String title;
 field @NonNull public final int[] vibrate;
 }

 public class WebNotificationAction implements Parcelable {
 ctor public WebNotificationAction(@NonNull String, @NonNull String);
 field public static final Parcelable.Creator<WebNotificationAction> CREATOR;
 field @NonNull public final String name;
 field @NonNull public final String title;
 }

 public interface WebNotificationDelegate {
 method @AnyThread default public void onCloseNotification(@NonNull WebNotification);
 method @AnyThread default public void onShowNotification(@NonNull WebNotification);
 }

 public class WebPushController {
 method @Nullable @UiThread public WebPushDelegate getDelegate();
 method @UiThread public void onPushEvent(@NonNull String);
 method @UiThread public void onPushEvent(@NonNull String, @Nullable byte[]);
 method @UiThread public void onSubscriptionChanged(@NonNull String);
 method @UiThread public void setDelegate(@Nullable WebPushDelegate);
 }

 public interface WebPushDelegate {
 method @Nullable @UiThread default public GeckoResult<WebPushSubscription> onGetSubscription(@NonNull String);
 method @Nullable @UiThread default public GeckoResult<WebPushSubscription> onSubscribe(@NonNull String, @Nullable byte[]);
 method @Nullable @UiThread default public GeckoResult<Void> onUnsubscribe(@NonNull String);
 }

 public class WebPushSubscription implements Parcelable {
 ctor public WebPushSubscription(@NonNull String, @NonNull String, @Nullable byte[], @NonNull byte[], @NonNull byte[]);
 field public static final Parcelable.Creator<WebPushSubscription> CREATOR;
 field @Nullable public final byte[] appServerKey;
 field @NonNull public final byte[] authSecret;
 field @NonNull public final byte[] browserPublicKey;
 field @NonNull public final String endpoint;
 field @NonNull public final String scope;
 }

 @AnyThread public class WebRequest extends WebMessage {
 ctor public WebRequest(@NonNull String);
 field public static final int CACHE_MODE_DEFAULT = 1;
 field public static final int CACHE_MODE_FORCE_CACHE = 5;
 field public static final int CACHE_MODE_NO_CACHE = 4;
 field public static final int CACHE_MODE_NO_STORE = 2;
 field public static final int CACHE_MODE_ONLY_IF_CACHED = 6;
 field public static final int CACHE_MODE_RELOAD = 3;
 field public final boolean beConservative;
 field @Nullable public final ByteBuffer body;
 field public final int cacheMode;
 field @NonNull public final String method;
 field @Nullable public final String referrer;
 }

 @AnyThread public static class WebRequest.Builder extends WebMessage.Builder {
 ctor public Builder(@NonNull String);
 method @NonNull public WebRequest.Builder beConservative(boolean);
 method @NonNull public WebRequest.Builder body(@Nullable ByteBuffer);
 method @NonNull public WebRequest.Builder body(@Nullable String);
 method @NonNull public WebRequest build();
 method @NonNull public WebRequest.Builder cacheMode(int);
 method @NonNull public WebRequest.Builder method(@NonNull String);
 method @NonNull public WebRequest.Builder referrer(@Nullable String);
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface WebRequest.CacheMode {
 }

 @AnyThread public class WebRequestError extends Exception {
 ctor public WebRequestError(int, int);
 ctor public WebRequestError(int, int, X509Certificate);
 field public static final int ERROR_BAD_HSTS_CERT = 179;
 field public static final int ERROR_CATEGORY_CONTENT = 4;
 field public static final int ERROR_CATEGORY_NETWORK = 3;
 field public static final int ERROR_CATEGORY_PROXY = 6;
 field public static final int ERROR_CATEGORY_SAFEBROWSING = 7;
 field public static final int ERROR_CATEGORY_SECURITY = 2;
 field public static final int ERROR_CATEGORY_UNKNOWN = 1;
 field public static final int ERROR_CATEGORY_URI = 5;
 field public static final int ERROR_CONNECTION_REFUSED = 67;
 field public static final int ERROR_CONTENT_CRASHED = 68;
 field public static final int ERROR_CORRUPTED_CONTENT = 52;
 field public static final int ERROR_DATA_URI_TOO_LONG = 117;
 field public static final int ERROR_FILE_ACCESS_DENIED = 101;
 field public static final int ERROR_FILE_NOT_FOUND = 85;
 field public static final int ERROR_HARMFULADDON_URI = 103;
 field public static final int ERROR_HTTPS_ONLY = 163;
 field public static final int ERROR_INVALID_CONTENT_ENCODING = 84;
 field public static final int ERROR_MALFORMED_URI = 53;
 field public static final int ERROR_NET_INTERRUPT = 35;
 field public static final int ERROR_NET_RESET = 147;
 field public static final int ERROR_NET_TIMEOUT = 51;
 field public static final int ERROR_OFFLINE = 115;
 field public static final int ERROR_PORT_BLOCKED = 131;
 field public static final int ERROR_PROXY_CONNECTION_REFUSED = 38;
 field public static final int ERROR_REDIRECT_LOOP = 99;
 field public static final int ERROR_SAFEBROWSING_HARMFUL_URI = 71;
 field public static final int ERROR_SAFEBROWSING_MALWARE_URI = 39;
 field public static final int ERROR_SAFEBROWSING_PHISHING_URI = 87;
 field public static final int ERROR_SAFEBROWSING_UNWANTED_URI = 55;
 field public static final int ERROR_SECURITY_BAD_CERT = 50;
 field public static final int ERROR_SECURITY_SSL = 34;
 field public static final int ERROR_UNKNOWN = 17;
 field public static final int ERROR_UNKNOWN_HOST = 37;
 field public static final int ERROR_UNKNOWN_PROTOCOL = 69;
 field public static final int ERROR_UNKNOWN_PROXY_HOST = 54;
 field public static final int ERROR_UNKNOWN_SOCKET_TYPE = 83;
 field public static final int ERROR_UNSAFE_CONTENT_TYPE = 36;
 field public final int category;
 field @Nullable public final X509Certificate certificate;
 field public final int code;
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface WebRequestError.Error {
 }

 @Retention(value=RetentionPolicy.SOURCE) public static interface WebRequestError.ErrorCategory {
 }

 @AnyThread public class WebResponse extends WebMessage {
 ctor protected WebResponse(@NonNull WebResponse.Builder);
 method public void setReadTimeoutMillis(long);
 field public static final long DEFAULT_READ_TIMEOUT_MS = 30000L;
 field @Nullable public final InputStream body;
 field @Nullable public final X509Certificate certificate;
 field public final boolean isSecure;
 field public final boolean redirected;
 field @Nullable public final boolean requestExternalApp;
 field @Nullable public final boolean skipConfirmation;
 field public final int statusCode;
 }

 @AnyThread public static class WebResponse.Builder extends WebMessage.Builder {
 ctor public Builder(@NonNull String);
 method @NonNull public WebResponse.Builder body(@NonNull InputStream);
 method @NonNull public WebResponse build();
 method @NonNull public WebResponse.Builder certificate(@NonNull X509Certificate);
 method @NonNull public WebResponse.Builder isSecure(boolean);
 method @NonNull public WebResponse.Builder redirected(boolean);
 method @NonNull public WebResponse.Builder requestExternalApp(boolean);
 method @NonNull public WebResponse.Builder skipConfirmation(boolean);
 method @NonNull public WebResponse.Builder statusCode(int);
 }

}

Messung V0.5 in Prozent

¤ Dauer der Verarbeitung: 0.50 Sekunden (vorverarbeitet am 2026-08-25) ¤

Wurzel

Suchen

PVS Prover

Isabelle Prover

NIST Cobol Testsuite

Cephes Mathematical Library

Vienna Development Method

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.