bindings.rs

/* automatically generated by rust-bindgen */

pub use nsstring::{nsACString, nsAString, nsString, nsStringRepr};
use gecko_bindings::structs::nsStyleTransformMatrix;
use gecko_bindings::structs::nsTArray;
type nsACString_internal = nsACString;
type nsAString_internal = nsAString;
pub type ServoStyleContextBorrowed<'a> = &'a ::properties::ComputedValues;
pub type ServoStyleContextBorrowedOrNull<'a> = Option<&'a ::properties::ComputedValues>;
pub type ServoComputedDataBorrowed<'a> = &'a ServoComputedData;
pub type RawServoAnimationValueTableBorrowed<'a> = &'a ();
use gecko_bindings::structs::mozilla::css::GridTemplateAreasValue;
use gecko_bindings::structs::mozilla::css::ErrorReporter;
use gecko_bindings::structs::mozilla::css::ImageValue;
use gecko_bindings::structs::mozilla::css::URLValue;
use gecko_bindings::structs::mozilla::css::URLValueData;
use gecko_bindings::structs::mozilla::dom::CallerType;
use gecko_bindings::structs::mozilla::AnonymousCounterStyle;
use gecko_bindings::structs::mozilla::AtomArray;
use gecko_bindings::structs::mozilla::MallocSizeOf;
use gecko_bindings::structs::mozilla::ServoStyleSet;
use gecko_bindings::structs::mozilla::OriginFlags;
use gecko_bindings::structs::mozilla::UniquePtr;
use gecko_bindings::structs::ServoRawOffsetArc;
use gecko_bindings::structs::nsIContent;
use gecko_bindings::structs::nsIDocument;
use gecko_bindings::structs::nsIDocument_DocumentTheme;
use gecko_bindings::structs::nsSimpleContentList;
use gecko_bindings::structs::MediumFeaturesChangedResult;
use gecko_bindings::structs::RawGeckoAnimationPropertySegment;
use gecko_bindings::structs::RawGeckoComputedTiming;
use gecko_bindings::structs::RawGeckoCSSPropertyIDList;
use gecko_bindings::structs::RawGeckoDocument;
use gecko_bindings::structs::RawGeckoElement;
use gecko_bindings::structs::Element;
use gecko_bindings::structs::RawGeckoKeyframeList;
use gecko_bindings::structs::RawGeckoPropertyValuePairList;
use gecko_bindings::structs::RawGeckoComputedKeyframeValuesList;
use gecko_bindings::structs::RawGeckoFontFaceRuleList;
use gecko_bindings::structs::RawGeckoNode;
use gecko_bindings::structs::RawServoAnimationValue;
use gecko_bindings::structs::RawGeckoServoAnimationValueList;
use gecko_bindings::structs::RawServoMediaList;
use gecko_bindings::structs::RawServoStyleSheetContents;
use gecko_bindings::structs::RawServoDeclarationBlock;
use gecko_bindings::structs::RawServoStyleRule;
use gecko_bindings::structs::RawGeckoPresContext;
use gecko_bindings::structs::RawGeckoPresContextOwned;
use gecko_bindings::structs::RawGeckoStyleAnimationList;
use gecko_bindings::structs::RawGeckoStyleChildrenIterator;
use gecko_bindings::structs::RawGeckoServoStyleRuleList;
use gecko_bindings::structs::RawGeckoURLExtraData;
use gecko_bindings::structs::RawGeckoXBLBinding;
use gecko_bindings::structs::RawServoSelectorList;
use gecko_bindings::structs::RawServoSourceSizeList;
use gecko_bindings::structs::RefPtr;
use gecko_bindings::structs::RustString;
use gecko_bindings::structs::CSSPseudoClassType;
use gecko_bindings::structs::CSSPseudoElementType;
use gecko_bindings::structs::ServoTraversalFlags;
use gecko_bindings::structs::ComputedTimingFunction_BeforeFlag;
use gecko_bindings::structs::CounterStylePtr;
use gecko_bindings::structs::FontFamilyType;
use gecko_bindings::structs::FontSizePrefs;
use gecko_bindings::structs::GeckoFontMetrics;
use gecko_bindings::structs::IterationCompositeOperation;
use gecko_bindings::structs::Keyframe;
use gecko_bindings::structs::PropertyValuePair;
use gecko_bindings::structs::SeenPtrs;
use gecko_bindings::structs::ServoBundledURI;
use gecko_bindings::structs::ServoElementSnapshot;
use gecko_bindings::structs::ServoElementSnapshotTable;
use gecko_bindings::structs::ServoStyleSetSizes;
use gecko_bindings::structs::SheetParsingMode;
use gecko_bindings::structs::StyleBasicShapeType;
use gecko_bindings::structs::StyleShapeSource;
use gecko_bindings::structs::StyleTransition;
use gecko_bindings::structs::gfxFontFeatureValueSet;
use gecko_bindings::structs::nsCSSCounterDesc;
use gecko_bindings::structs::nsCSSCounterStyleRule;
use gecko_bindings::structs::nsCSSFontDesc;
use gecko_bindings::structs::nsCSSFontFaceRule;
use gecko_bindings::structs::nsCSSKeyword;
use gecko_bindings::structs::nsCSSPropertyID;
use gecko_bindings::structs::nsCSSPropertyIDSet;
use gecko_bindings::structs::nsCSSRect;
use gecko_bindings::structs::nsCSSShadowArray;
use gecko_bindings::structs::nsCSSUnit;
use gecko_bindings::structs::nsCSSValue;
use gecko_bindings::structs::nsCSSValueSharedList;
use gecko_bindings::structs::nsChangeHint;
use gecko_bindings::structs::nsCursorImage;
use gecko_bindings::structs::nsFont;
use gecko_bindings::structs::nsAtom;
use gecko_bindings::structs::nsIURI;
use gecko_bindings::structs::nsCompatibility;
use gecko_bindings::structs::nsRestyleHint;
use gecko_bindings::structs::nsStyleBackground;
unsafe impl Send for nsStyleBackground {}
unsafe impl Sync for nsStyleBackground {}
use gecko_bindings::structs::nsStyleBorder;
unsafe impl Send for nsStyleBorder {}
unsafe impl Sync for nsStyleBorder {}
use gecko_bindings::structs::nsStyleColor;
unsafe impl Send for nsStyleColor {}
unsafe impl Sync for nsStyleColor {}
use gecko_bindings::structs::nsStyleColumn;
unsafe impl Send for nsStyleColumn {}
unsafe impl Sync for nsStyleColumn {}
use gecko_bindings::structs::nsStyleContent;
unsafe impl Send for nsStyleContent {}
unsafe impl Sync for nsStyleContent {}
use gecko_bindings::structs::nsStyleContentData;
unsafe impl Send for nsStyleContentData {}
unsafe impl Sync for nsStyleContentData {}
use gecko_bindings::structs::nsStyleContentData_CounterFunction;
unsafe impl Send for nsStyleContentData_CounterFunction {}
unsafe impl Sync for nsStyleContentData_CounterFunction {}
use gecko_bindings::structs::nsStyleContentType;
unsafe impl Send for nsStyleContentType {}
unsafe impl Sync for nsStyleContentType {}
use gecko_bindings::structs::nsStyleContext;
unsafe impl Send for nsStyleContext {}
unsafe impl Sync for nsStyleContext {}
use gecko_bindings::structs::nsStyleCoord;
unsafe impl Send for nsStyleCoord {}
unsafe impl Sync for nsStyleCoord {}
use gecko_bindings::structs::nsStyleCoord_Calc;
unsafe impl Send for nsStyleCoord_Calc {}
unsafe impl Sync for nsStyleCoord_Calc {}
use gecko_bindings::structs::nsStyleCoord_CalcValue;
unsafe impl Send for nsStyleCoord_CalcValue {}
unsafe impl Sync for nsStyleCoord_CalcValue {}
use gecko_bindings::structs::nsStyleDisplay;
unsafe impl Send for nsStyleDisplay {}
unsafe impl Sync for nsStyleDisplay {}
use gecko_bindings::structs::nsStyleEffects;
unsafe impl Send for nsStyleEffects {}
unsafe impl Sync for nsStyleEffects {}
use gecko_bindings::structs::nsStyleFilter;
unsafe impl Send for nsStyleFilter {}
unsafe impl Sync for nsStyleFilter {}
use gecko_bindings::structs::nsStyleFont;
unsafe impl Send for nsStyleFont {}
unsafe impl Sync for nsStyleFont {}
use gecko_bindings::structs::nsStyleGradient;
unsafe impl Send for nsStyleGradient {}
unsafe impl Sync for nsStyleGradient {}
use gecko_bindings::structs::nsStyleGradientStop;
unsafe impl Send for nsStyleGradientStop {}
unsafe impl Sync for nsStyleGradientStop {}
use gecko_bindings::structs::nsStyleGridTemplate;
unsafe impl Send for nsStyleGridTemplate {}
unsafe impl Sync for nsStyleGridTemplate {}
use gecko_bindings::structs::nsStyleImage;
unsafe impl Send for nsStyleImage {}
unsafe impl Sync for nsStyleImage {}
use gecko_bindings::structs::nsStyleImageLayers;
unsafe impl Send for nsStyleImageLayers {}
unsafe impl Sync for nsStyleImageLayers {}
use gecko_bindings::structs::nsStyleImageLayers_Layer;
unsafe impl Send for nsStyleImageLayers_Layer {}
unsafe impl Sync for nsStyleImageLayers_Layer {}
use gecko_bindings::structs::nsStyleImageLayers_LayerType;
unsafe impl Send for nsStyleImageLayers_LayerType {}
unsafe impl Sync for nsStyleImageLayers_LayerType {}
use gecko_bindings::structs::nsStyleImageRequest;
unsafe impl Send for nsStyleImageRequest {}
unsafe impl Sync for nsStyleImageRequest {}
use gecko_bindings::structs::nsStyleList;
unsafe impl Send for nsStyleList {}
unsafe impl Sync for nsStyleList {}
use gecko_bindings::structs::nsStyleMargin;
unsafe impl Send for nsStyleMargin {}
unsafe impl Sync for nsStyleMargin {}
use gecko_bindings::structs::nsStyleOutline;
unsafe impl Send for nsStyleOutline {}
unsafe impl Sync for nsStyleOutline {}
use gecko_bindings::structs::nsStylePadding;
unsafe impl Send for nsStylePadding {}
unsafe impl Sync for nsStylePadding {}
use gecko_bindings::structs::nsStylePosition;
unsafe impl Send for nsStylePosition {}
unsafe impl Sync for nsStylePosition {}
use gecko_bindings::structs::nsStyleQuoteValues;
unsafe impl Send for nsStyleQuoteValues {}
unsafe impl Sync for nsStyleQuoteValues {}
use gecko_bindings::structs::nsStyleSVG;
unsafe impl Send for nsStyleSVG {}
unsafe impl Sync for nsStyleSVG {}
use gecko_bindings::structs::nsStyleSVGOpacitySource;
unsafe impl Send for nsStyleSVGOpacitySource {}
unsafe impl Sync for nsStyleSVGOpacitySource {}
use gecko_bindings::structs::nsStyleSVGPaint;
unsafe impl Send for nsStyleSVGPaint {}
unsafe impl Sync for nsStyleSVGPaint {}
use gecko_bindings::structs::nsStyleSVGReset;
unsafe impl Send for nsStyleSVGReset {}
unsafe impl Sync for nsStyleSVGReset {}
use gecko_bindings::structs::nsStyleTable;
unsafe impl Send for nsStyleTable {}
unsafe impl Sync for nsStyleTable {}
use gecko_bindings::structs::nsStyleTableBorder;
unsafe impl Send for nsStyleTableBorder {}
unsafe impl Sync for nsStyleTableBorder {}
use gecko_bindings::structs::nsStyleText;
unsafe impl Send for nsStyleText {}
unsafe impl Sync for nsStyleText {}
use gecko_bindings::structs::nsStyleTextReset;
unsafe impl Send for nsStyleTextReset {}
unsafe impl Sync for nsStyleTextReset {}
use gecko_bindings::structs::nsStyleUIReset;
unsafe impl Send for nsStyleUIReset {}
unsafe impl Sync for nsStyleUIReset {}
use gecko_bindings::structs::nsStyleUnion;
unsafe impl Send for nsStyleUnion {}
unsafe impl Sync for nsStyleUnion {}
use gecko_bindings::structs::nsStyleUnit;
unsafe impl Send for nsStyleUnit {}
unsafe impl Sync for nsStyleUnit {}
use gecko_bindings::structs::nsStyleUserInterface;
unsafe impl Send for nsStyleUserInterface {}
unsafe impl Sync for nsStyleUserInterface {}
use gecko_bindings::structs::nsStyleVariables;
unsafe impl Send for nsStyleVariables {}
unsafe impl Sync for nsStyleVariables {}
use gecko_bindings::structs::nsStyleVisibility;
unsafe impl Send for nsStyleVisibility {}
unsafe impl Sync for nsStyleVisibility {}
use gecko_bindings::structs::nsStyleXUL;
unsafe impl Send for nsStyleXUL {}
unsafe impl Sync for nsStyleXUL {}
use gecko_bindings::structs::nsTimingFunction;
use gecko_bindings::structs::nscolor;
use gecko_bindings::structs::nscoord;
use gecko_bindings::structs::nsresult;
use gecko_bindings::structs::Loader;
use gecko_bindings::structs::LoaderReusableStyleSheets;
use gecko_bindings::structs::ServoStyleSheet;
use gecko_bindings::structs::ServoComputedData;
use gecko_bindings::structs::ServoStyleContext;
use gecko_bindings::structs::ServoStyleContextStrong;
use gecko_bindings::structs::EffectCompositor_CascadeLevel;
use gecko_bindings::structs::UpdateAnimationsTasks;
use gecko_bindings::structs::ParsingMode;
use gecko_bindings::structs::InheritTarget;
use gecko_bindings::structs::URLMatchingFunction;
use gecko_bindings::structs::StyleAnimation;
use gecko_bindings::structs::StyleRuleInclusion;
use gecko_bindings::structs::nsStyleTransformMatrix::MatrixTransformOperator;
unsafe impl Send for nsStyleTransformMatrix::MatrixTransformOperator {}
unsafe impl Sync for nsStyleTransformMatrix::MatrixTransformOperator {}
use gecko_bindings::structs::RawGeckoGfxMatrix4x4;
use gecko_bindings::structs::FontFamilyName;
use gecko_bindings::structs::mozilla::SharedFontList;
pub type nsTArrayBorrowed_uintptr_t<'a> = &'a mut ::gecko_bindings::structs::nsTArray<usize>;
pub type RawServoStyleSetOwned = ::gecko_bindings::sugar::ownership::Owned<RawServoStyleSet>;
pub type RawServoStyleSetOwnedOrNull = ::gecko_bindings::sugar::ownership::OwnedOrNull<RawServoStyleSet>;
pub type RawServoStyleSetBorrowed<'a> = &'a RawServoStyleSet;
pub type RawServoStyleSetBorrowedOrNull<'a> = Option<&'a RawServoStyleSet>;
pub type RawServoStyleSetBorrowedMut<'a> = &'a mut RawServoStyleSet;
pub type RawServoStyleSetBorrowedMutOrNull<'a> = Option<&'a mut RawServoStyleSet>;
enum RawServoStyleSetVoid { }
pub struct RawServoStyleSet(RawServoStyleSetVoid);
pub type RawServoSelectorListOwned = ::gecko_bindings::sugar::ownership::Owned<RawServoSelectorList>;
pub type RawServoSelectorListOwnedOrNull = ::gecko_bindings::sugar::ownership::OwnedOrNull<RawServoSelectorList>;
pub type RawServoSelectorListBorrowed<'a> = &'a RawServoSelectorList;
pub type RawServoSelectorListBorrowedOrNull<'a> = Option<&'a RawServoSelectorList>;
pub type RawServoSelectorListBorrowedMut<'a> = &'a mut RawServoSelectorList;
pub type RawServoSelectorListBorrowedMutOrNull<'a> = Option<&'a mut RawServoSelectorList>;
pub type RawServoSourceSizeListOwned = ::gecko_bindings::sugar::ownership::Owned<RawServoSourceSizeList>;
pub type RawServoSourceSizeListOwnedOrNull = ::gecko_bindings::sugar::ownership::OwnedOrNull<RawServoSourceSizeList>;
pub type RawServoSourceSizeListBorrowed<'a> = &'a RawServoSourceSizeList;
pub type RawServoSourceSizeListBorrowedOrNull<'a> = Option<&'a RawServoSourceSizeList>;
pub type RawServoSourceSizeListBorrowedMut<'a> = &'a mut RawServoSourceSizeList;
pub type RawServoSourceSizeListBorrowedMutOrNull<'a> = Option<&'a mut RawServoSourceSizeList>;
pub type ServoElementSnapshotOwned = ::gecko_bindings::sugar::ownership::Owned<ServoElementSnapshot>;
pub type ServoElementSnapshotOwnedOrNull = ::gecko_bindings::sugar::ownership::OwnedOrNull<ServoElementSnapshot>;
pub type ServoElementSnapshotBorrowed<'a> = &'a ServoElementSnapshot;
pub type ServoElementSnapshotBorrowedOrNull<'a> = Option<&'a ServoElementSnapshot>;
pub type ServoElementSnapshotBorrowedMut<'a> = &'a mut ServoElementSnapshot;
pub type ServoElementSnapshotBorrowedMutOrNull<'a> = Option<&'a mut ServoElementSnapshot>;
pub type RawServoAnimationValueMapOwned = ::gecko_bindings::sugar::ownership::Owned<RawServoAnimationValueMap>;
pub type RawServoAnimationValueMapOwnedOrNull = ::gecko_bindings::sugar::ownership::OwnedOrNull<RawServoAnimationValueMap>;
pub type RawServoAnimationValueMapBorrowed<'a> = &'a RawServoAnimationValueMap;
pub type RawServoAnimationValueMapBorrowedOrNull<'a> = Option<&'a RawServoAnimationValueMap>;
pub type RawServoAnimationValueMapBorrowedMut<'a> = &'a mut RawServoAnimationValueMap;
pub type RawServoAnimationValueMapBorrowedMutOrNull<'a> = Option<&'a mut RawServoAnimationValueMap>;
enum RawServoAnimationValueMapVoid { }
pub struct RawServoAnimationValueMap(RawServoAnimationValueMapVoid);
pub type RawGeckoNodeBorrowed<'a> = &'a RawGeckoNode;
pub type RawGeckoNodeBorrowedOrNull<'a> = Option<&'a RawGeckoNode>;
pub type RawGeckoElementBorrowed<'a> = &'a RawGeckoElement;
pub type RawGeckoElementBorrowedOrNull<'a> = Option<&'a RawGeckoElement>;
pub type RawGeckoDocumentBorrowed<'a> = &'a RawGeckoDocument;
pub type RawGeckoDocumentBorrowedOrNull<'a> = Option<&'a RawGeckoDocument>;
pub type RawServoDeclarationBlockStrongBorrowed<'a> = &'a RawServoDeclarationBlockStrong;
pub type RawServoDeclarationBlockStrongBorrowedOrNull<'a> = Option<&'a RawServoDeclarationBlockStrong>;
pub type RawGeckoPresContextBorrowed<'a> = &'a RawGeckoPresContext;
pub type RawGeckoPresContextBorrowedOrNull<'a> = Option<&'a RawGeckoPresContext>;
pub type RawGeckoXBLBindingBorrowed<'a> = &'a RawGeckoXBLBinding;
pub type RawGeckoXBLBindingBorrowedOrNull<'a> = Option<&'a RawGeckoXBLBinding>;
pub type nsCSSPropertyIDSetBorrowed<'a> = &'a nsCSSPropertyIDSet;
pub type nsCSSPropertyIDSetBorrowedOrNull<'a> = Option<&'a nsCSSPropertyIDSet>;
pub type nsCSSPropertyIDSetBorrowedMut<'a> = &'a mut nsCSSPropertyIDSet;
pub type nsCSSPropertyIDSetBorrowedMutOrNull<'a> = Option<&'a mut nsCSSPropertyIDSet>;
pub type nsCSSValueBorrowed<'a> = &'a nsCSSValue;
pub type nsCSSValueBorrowedOrNull<'a> = Option<&'a nsCSSValue>;
pub type nsCSSValueBorrowedMut<'a> = &'a mut nsCSSValue;
pub type nsCSSValueBorrowedMutOrNull<'a> = Option<&'a mut nsCSSValue>;
pub type nsTimingFunctionBorrowed<'a> = &'a nsTimingFunction;
pub type nsTimingFunctionBorrowedOrNull<'a> = Option<&'a nsTimingFunction>;
pub type nsTimingFunctionBorrowedMut<'a> = &'a mut nsTimingFunction;
pub type nsTimingFunctionBorrowedMutOrNull<'a> = Option<&'a mut nsTimingFunction>;
pub type RawGeckoAnimationPropertySegmentBorrowed<'a> = &'a RawGeckoAnimationPropertySegment;
pub type RawGeckoAnimationPropertySegmentBorrowedOrNull<'a> = Option<&'a RawGeckoAnimationPropertySegment>;
pub type RawGeckoAnimationPropertySegmentBorrowedMut<'a> = &'a mut RawGeckoAnimationPropertySegment;
pub type RawGeckoAnimationPropertySegmentBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoAnimationPropertySegment>;
pub type RawGeckoComputedTimingBorrowed<'a> = &'a RawGeckoComputedTiming;
pub type RawGeckoComputedTimingBorrowedOrNull<'a> = Option<&'a RawGeckoComputedTiming>;
pub type RawGeckoComputedTimingBorrowedMut<'a> = &'a mut RawGeckoComputedTiming;
pub type RawGeckoComputedTimingBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoComputedTiming>;
pub type RawGeckoCSSPropertyIDListBorrowed<'a> = &'a RawGeckoCSSPropertyIDList;
pub type RawGeckoCSSPropertyIDListBorrowedOrNull<'a> = Option<&'a RawGeckoCSSPropertyIDList>;
pub type RawGeckoCSSPropertyIDListBorrowedMut<'a> = &'a mut RawGeckoCSSPropertyIDList;
pub type RawGeckoCSSPropertyIDListBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoCSSPropertyIDList>;
pub type RawGeckoKeyframeListBorrowed<'a> = &'a RawGeckoKeyframeList;
pub type RawGeckoKeyframeListBorrowedOrNull<'a> = Option<&'a RawGeckoKeyframeList>;
pub type RawGeckoKeyframeListBorrowedMut<'a> = &'a mut RawGeckoKeyframeList;
pub type RawGeckoKeyframeListBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoKeyframeList>;
pub type RawGeckoPropertyValuePairListBorrowed<'a> = &'a RawGeckoPropertyValuePairList;
pub type RawGeckoPropertyValuePairListBorrowedOrNull<'a> = Option<&'a RawGeckoPropertyValuePairList>;
pub type RawGeckoPropertyValuePairListBorrowedMut<'a> = &'a mut RawGeckoPropertyValuePairList;
pub type RawGeckoPropertyValuePairListBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoPropertyValuePairList>;
pub type RawGeckoComputedKeyframeValuesListBorrowed<'a> = &'a RawGeckoComputedKeyframeValuesList;
pub type RawGeckoComputedKeyframeValuesListBorrowedOrNull<'a> = Option<&'a RawGeckoComputedKeyframeValuesList>;
pub type RawGeckoComputedKeyframeValuesListBorrowedMut<'a> = &'a mut RawGeckoComputedKeyframeValuesList;
pub type RawGeckoComputedKeyframeValuesListBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoComputedKeyframeValuesList>;
pub type RawGeckoFontFaceRuleListBorrowed<'a> = &'a RawGeckoFontFaceRuleList;
pub type RawGeckoFontFaceRuleListBorrowedOrNull<'a> = Option<&'a RawGeckoFontFaceRuleList>;
pub type RawGeckoFontFaceRuleListBorrowedMut<'a> = &'a mut RawGeckoFontFaceRuleList;
pub type RawGeckoFontFaceRuleListBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoFontFaceRuleList>;
pub type RawGeckoServoStyleRuleListBorrowed<'a> = &'a RawGeckoServoStyleRuleList;
pub type RawGeckoServoStyleRuleListBorrowedOrNull<'a> = Option<&'a RawGeckoServoStyleRuleList>;
pub type RawGeckoServoStyleRuleListBorrowedMut<'a> = &'a mut RawGeckoServoStyleRuleList;
pub type RawGeckoServoStyleRuleListBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoServoStyleRuleList>;
pub type RawGeckoServoAnimationValueListBorrowed<'a> = &'a RawGeckoServoAnimationValueList;
pub type RawGeckoServoAnimationValueListBorrowedOrNull<'a> = Option<&'a RawGeckoServoAnimationValueList>;
pub type RawGeckoServoAnimationValueListBorrowedMut<'a> = &'a mut RawGeckoServoAnimationValueList;
pub type RawGeckoServoAnimationValueListBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoServoAnimationValueList>;
pub type RawGeckoStyleAnimationListBorrowed<'a> = &'a RawGeckoStyleAnimationList;
pub type RawGeckoStyleAnimationListBorrowedOrNull<'a> = Option<&'a RawGeckoStyleAnimationList>;
pub type RawGeckoStyleAnimationListBorrowedMut<'a> = &'a mut RawGeckoStyleAnimationList;
pub type RawGeckoStyleAnimationListBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoStyleAnimationList>;
pub type RawGeckoStyleChildrenIteratorBorrowed<'a> = &'a RawGeckoStyleChildrenIterator;
pub type RawGeckoStyleChildrenIteratorBorrowedOrNull<'a> = Option<&'a RawGeckoStyleChildrenIterator>;
pub type RawGeckoStyleChildrenIteratorBorrowedMut<'a> = &'a mut RawGeckoStyleChildrenIterator;
pub type RawGeckoStyleChildrenIteratorBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoStyleChildrenIterator>;
pub type ServoCssRulesStrong = ::gecko_bindings::sugar::ownership::Strong<ServoCssRules>;
pub type ServoCssRulesBorrowed<'a> = &'a ServoCssRules;
pub type ServoCssRulesBorrowedOrNull<'a> = Option<&'a ServoCssRules>;
enum ServoCssRulesVoid { }
pub struct ServoCssRules(ServoCssRulesVoid);
pub type RawServoStyleSheetContentsStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoStyleSheetContents>;
pub type RawServoStyleSheetContentsBorrowed<'a> = &'a RawServoStyleSheetContents;
pub type RawServoStyleSheetContentsBorrowedOrNull<'a> = Option<&'a RawServoStyleSheetContents>;
pub type RawServoDeclarationBlockStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoDeclarationBlock>;
pub type RawServoDeclarationBlockBorrowed<'a> = &'a RawServoDeclarationBlock;
pub type RawServoDeclarationBlockBorrowedOrNull<'a> = Option<&'a RawServoDeclarationBlock>;
pub type RawServoStyleRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoStyleRule>;
pub type RawServoStyleRuleBorrowed<'a> = &'a RawServoStyleRule;
pub type RawServoStyleRuleBorrowedOrNull<'a> = Option<&'a RawServoStyleRule>;
pub type RawServoImportRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoImportRule>;
pub type RawServoImportRuleBorrowed<'a> = &'a RawServoImportRule;
pub type RawServoImportRuleBorrowedOrNull<'a> = Option<&'a RawServoImportRule>;
enum RawServoImportRuleVoid { }
pub struct RawServoImportRule(RawServoImportRuleVoid);
pub type RawServoAnimationValueStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoAnimationValue>;
pub type RawServoAnimationValueBorrowed<'a> = &'a RawServoAnimationValue;
pub type RawServoAnimationValueBorrowedOrNull<'a> = Option<&'a RawServoAnimationValue>;
pub type RawServoKeyframeStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoKeyframe>;
pub type RawServoKeyframeBorrowed<'a> = &'a RawServoKeyframe;
pub type RawServoKeyframeBorrowedOrNull<'a> = Option<&'a RawServoKeyframe>;
enum RawServoKeyframeVoid { }
pub struct RawServoKeyframe(RawServoKeyframeVoid);
pub type RawServoKeyframesRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoKeyframesRule>;
pub type RawServoKeyframesRuleBorrowed<'a> = &'a RawServoKeyframesRule;
pub type RawServoKeyframesRuleBorrowedOrNull<'a> = Option<&'a RawServoKeyframesRule>;
enum RawServoKeyframesRuleVoid { }
pub struct RawServoKeyframesRule(RawServoKeyframesRuleVoid);
pub type RawServoMediaListStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoMediaList>;
pub type RawServoMediaListBorrowed<'a> = &'a RawServoMediaList;
pub type RawServoMediaListBorrowedOrNull<'a> = Option<&'a RawServoMediaList>;
pub type RawServoMediaRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoMediaRule>;
pub type RawServoMediaRuleBorrowed<'a> = &'a RawServoMediaRule;
pub type RawServoMediaRuleBorrowedOrNull<'a> = Option<&'a RawServoMediaRule>;
enum RawServoMediaRuleVoid { }
pub struct RawServoMediaRule(RawServoMediaRuleVoid);
pub type RawServoNamespaceRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoNamespaceRule>;
pub type RawServoNamespaceRuleBorrowed<'a> = &'a RawServoNamespaceRule;
pub type RawServoNamespaceRuleBorrowedOrNull<'a> = Option<&'a RawServoNamespaceRule>;
enum RawServoNamespaceRuleVoid { }
pub struct RawServoNamespaceRule(RawServoNamespaceRuleVoid);
pub type RawServoPageRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoPageRule>;
pub type RawServoPageRuleBorrowed<'a> = &'a RawServoPageRule;
pub type RawServoPageRuleBorrowedOrNull<'a> = Option<&'a RawServoPageRule>;
enum RawServoPageRuleVoid { }
pub struct RawServoPageRule(RawServoPageRuleVoid);
pub type RawServoSupportsRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoSupportsRule>;
pub type RawServoSupportsRuleBorrowed<'a> = &'a RawServoSupportsRule;
pub type RawServoSupportsRuleBorrowedOrNull<'a> = Option<&'a RawServoSupportsRule>;
enum RawServoSupportsRuleVoid { }
pub struct RawServoSupportsRule(RawServoSupportsRuleVoid);
pub type RawServoDocumentRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoDocumentRule>;
pub type RawServoDocumentRuleBorrowed<'a> = &'a RawServoDocumentRule;
pub type RawServoDocumentRuleBorrowedOrNull<'a> = Option<&'a RawServoDocumentRule>;
enum RawServoDocumentRuleVoid { }
pub struct RawServoDocumentRule(RawServoDocumentRuleVoid);
pub type RawServoFontFeatureValuesRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoFontFeatureValuesRule>;
pub type RawServoFontFeatureValuesRuleBorrowed<'a> = &'a RawServoFontFeatureValuesRule;
pub type RawServoFontFeatureValuesRuleBorrowedOrNull<'a> = Option<&'a RawServoFontFeatureValuesRule>;
enum RawServoFontFeatureValuesRuleVoid { }
pub struct RawServoFontFeatureValuesRule(RawServoFontFeatureValuesRuleVoid);
pub type RawServoRuleNodeStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoRuleNode>;
pub type RawServoRuleNodeBorrowed<'a> = &'a RawServoRuleNode;
pub type RawServoRuleNodeBorrowedOrNull<'a> = Option<&'a RawServoRuleNode>;
enum RawServoRuleNodeVoid { }
pub struct RawServoRuleNode(RawServoRuleNodeVoid);

extern "C" {
    pub fn Gecko_EnsureTArrayCapacity(
        aArray: *mut ::std::os::raw::c_void,
        aCapacity: usize,
        aElementSize: usize,
    );
}
extern "C" {
    pub fn Gecko_ClearPODTArray(
        aArray: *mut ::std::os::raw::c_void,
        aElementSize: usize,
        aElementAlign: usize,
    );
}
extern "C" {
    pub fn Servo_CssRules_AddRef(ptr: ServoCssRulesBorrowed);
}
extern "C" {
    pub fn Servo_CssRules_Release(ptr: ServoCssRulesBorrowed);
}
extern "C" {
    pub fn Servo_StyleSheetContents_AddRef(ptr: RawServoStyleSheetContentsBorrowed);
}
extern "C" {
    pub fn Servo_StyleSheetContents_Release(ptr: RawServoStyleSheetContentsBorrowed);
}
extern "C" {
    pub fn Servo_DeclarationBlock_AddRef(ptr: RawServoDeclarationBlockBorrowed);
}
extern "C" {
    pub fn Servo_DeclarationBlock_Release(ptr: RawServoDeclarationBlockBorrowed);
}
extern "C" {
    pub fn Servo_StyleRule_AddRef(ptr: RawServoStyleRuleBorrowed);
}
extern "C" {
    pub fn Servo_StyleRule_Release(ptr: RawServoStyleRuleBorrowed);
}
extern "C" {
    pub fn Servo_ImportRule_AddRef(ptr: RawServoImportRuleBorrowed);
}
extern "C" {
    pub fn Servo_ImportRule_Release(ptr: RawServoImportRuleBorrowed);
}
extern "C" {
    pub fn Servo_AnimationValue_AddRef(ptr: RawServoAnimationValueBorrowed);
}
extern "C" {
    pub fn Servo_AnimationValue_Release(ptr: RawServoAnimationValueBorrowed);
}
extern "C" {
    pub fn Servo_Keyframe_AddRef(ptr: RawServoKeyframeBorrowed);
}
extern "C" {
    pub fn Servo_Keyframe_Release(ptr: RawServoKeyframeBorrowed);
}
extern "C" {
    pub fn Servo_KeyframesRule_AddRef(ptr: RawServoKeyframesRuleBorrowed);
}
extern "C" {
    pub fn Servo_KeyframesRule_Release(ptr: RawServoKeyframesRuleBorrowed);
}
extern "C" {
    pub fn Servo_MediaList_AddRef(ptr: RawServoMediaListBorrowed);
}
extern "C" {
    pub fn Servo_MediaList_Release(ptr: RawServoMediaListBorrowed);
}
extern "C" {
    pub fn Servo_MediaRule_AddRef(ptr: RawServoMediaRuleBorrowed);
}
extern "C" {
    pub fn Servo_MediaRule_Release(ptr: RawServoMediaRuleBorrowed);
}
extern "C" {
    pub fn Servo_NamespaceRule_AddRef(ptr: RawServoNamespaceRuleBorrowed);
}
extern "C" {
    pub fn Servo_NamespaceRule_Release(ptr: RawServoNamespaceRuleBorrowed);
}
extern "C" {
    pub fn Servo_PageRule_AddRef(ptr: RawServoPageRuleBorrowed);
}
extern "C" {
    pub fn Servo_PageRule_Release(ptr: RawServoPageRuleBorrowed);
}
extern "C" {
    pub fn Servo_SupportsRule_AddRef(ptr: RawServoSupportsRuleBorrowed);
}
extern "C" {
    pub fn Servo_SupportsRule_Release(ptr: RawServoSupportsRuleBorrowed);
}
extern "C" {
    pub fn Servo_DocumentRule_AddRef(ptr: RawServoDocumentRuleBorrowed);
}
extern "C" {
    pub fn Servo_DocumentRule_Release(ptr: RawServoDocumentRuleBorrowed);
}
extern "C" {
    pub fn Servo_FontFeatureValuesRule_AddRef(ptr: RawServoFontFeatureValuesRuleBorrowed);
}
extern "C" {
    pub fn Servo_FontFeatureValuesRule_Release(ptr: RawServoFontFeatureValuesRuleBorrowed);
}
extern "C" {
    pub fn Servo_RuleNode_AddRef(ptr: RawServoRuleNodeBorrowed);
}
extern "C" {
    pub fn Servo_RuleNode_Release(ptr: RawServoRuleNodeBorrowed);
}
extern "C" {
    pub fn Servo_StyleSet_Drop(ptr: RawServoStyleSetOwned);
}
extern "C" {
    pub fn Servo_SelectorList_Drop(ptr: RawServoSelectorListOwned);
}
extern "C" {
    pub fn Servo_SourceSizeList_Drop(ptr: RawServoSourceSizeListOwned);
}
extern "C" {
    pub fn Gecko_IsSignificantChild(
        node: RawGeckoNodeBorrowed,
        text_is_significant: bool,
        whitespace_is_significant: bool,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_GetLastChild(node: RawGeckoNodeBorrowed) -> RawGeckoNodeBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetFlattenedTreeParentNode(
        node: RawGeckoNodeBorrowed,
    ) -> RawGeckoNodeBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetBeforeOrAfterPseudo(
        element: RawGeckoElementBorrowed,
        is_before: bool,
    ) -> RawGeckoElementBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetAnonymousContentForElement(
        element: RawGeckoElementBorrowed,
    ) -> *mut nsTArray<*mut nsIContent>;
}
extern "C" {
    pub fn Gecko_DestroyAnonymousContentList(anon_content: *mut nsTArray<*mut nsIContent>);
}
extern "C" {
    pub fn Gecko_ServoStyleContext_Init(
        context: *mut ServoStyleContext,
        parent_context: ServoStyleContextBorrowedOrNull,
        pres_context: RawGeckoPresContextBorrowed,
        values: ServoComputedDataBorrowed,
        pseudo_type: CSSPseudoElementType,
        pseudo_tag: *mut nsAtom,
    );
}
extern "C" {
    pub fn Gecko_ServoStyleContext_Destroy(context: *mut ServoStyleContext);
}
extern "C" {
    pub fn Gecko_ConstructStyleChildrenIterator(
        aElement: RawGeckoElementBorrowed,
        aIterator: RawGeckoStyleChildrenIteratorBorrowedMut,
    );
}
extern "C" {
    pub fn Gecko_DestroyStyleChildrenIterator(aIterator: RawGeckoStyleChildrenIteratorBorrowedMut);
}
extern "C" {
    pub fn Gecko_GetNextStyleChild(
        it: RawGeckoStyleChildrenIteratorBorrowedMut,
    ) -> RawGeckoNodeBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_LoadStyleSheet(
        loader: *mut Loader,
        parent: *mut ServoStyleSheet,
        reusable_sheets: *mut LoaderReusableStyleSheets,
        base_url_data: *mut RawGeckoURLExtraData,
        url_bytes: *const u8,
        url_length: u32,
        media_list: RawServoMediaListStrong,
    ) -> *mut ServoStyleSheet;
}
extern "C" {
    pub fn Gecko_ElementState(element: RawGeckoElementBorrowed) -> u64;
}
extern "C" {
    pub fn Gecko_IsRootElement(element: RawGeckoElementBorrowed) -> bool;
}
extern "C" {
    pub fn Gecko_MatchesElement(
        type_: CSSPseudoClassType,
        element: RawGeckoElementBorrowed,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_MatchLang(
        element: RawGeckoElementBorrowed,
        override_lang: *mut nsAtom,
        has_override_lang: bool,
        value: *const u16,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_GetXMLLangValue(element: RawGeckoElementBorrowed) -> *mut nsAtom;
}
extern "C" {
    pub fn Gecko_GetDocumentLWTheme(aDocument: *const nsIDocument) -> nsIDocument_DocumentTheme;
}
extern "C" {
    pub fn Gecko_AtomAttrValue(
        element: RawGeckoElementBorrowed,
        attribute: *mut nsAtom,
    ) -> *mut nsAtom;
}
extern "C" {
    pub fn Gecko_LangValue(element: RawGeckoElementBorrowed) -> *mut nsAtom;
}
extern "C" {
    pub fn Gecko_HasAttr(
        element: RawGeckoElementBorrowed,
        ns: *mut nsAtom,
        name: *mut nsAtom,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_AttrEquals(
        element: RawGeckoElementBorrowed,
        ns: *mut nsAtom,
        name: *mut nsAtom,
        str: *mut nsAtom,
        ignoreCase: bool,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_AttrDashEquals(
        element: RawGeckoElementBorrowed,
        ns: *mut nsAtom,
        name: *mut nsAtom,
        str: *mut nsAtom,
        ignore_case: bool,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_AttrIncludes(
        element: RawGeckoElementBorrowed,
        ns: *mut nsAtom,
        name: *mut nsAtom,
        str: *mut nsAtom,
        ignore_case: bool,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_AttrHasSubstring(
        element: RawGeckoElementBorrowed,
        ns: *mut nsAtom,
        name: *mut nsAtom,
        str: *mut nsAtom,
        ignore_case: bool,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_AttrHasPrefix(
        element: RawGeckoElementBorrowed,
        ns: *mut nsAtom,
        name: *mut nsAtom,
        str: *mut nsAtom,
        ignore_case: bool,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_AttrHasSuffix(
        element: RawGeckoElementBorrowed,
        ns: *mut nsAtom,
        name: *mut nsAtom,
        str: *mut nsAtom,
        ignore_case: bool,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_ClassOrClassList(
        element: RawGeckoElementBorrowed,
        class_: *mut *mut nsAtom,
        classList: *mut *mut *mut nsAtom,
    ) -> u32;
}
extern "C" {
    pub fn Gecko_HasClass(
        element: RawGeckoElementBorrowed,
        class_: *mut nsAtom,
        ignore_case: bool,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_SnapshotAtomAttrValue(
        element: *const ServoElementSnapshot,
        attribute: *mut nsAtom,
    ) -> *mut nsAtom;
}
extern "C" {
    pub fn Gecko_SnapshotLangValue(element: *const ServoElementSnapshot) -> *mut nsAtom;
}
extern "C" {
    pub fn Gecko_SnapshotHasAttr(
        element: *const ServoElementSnapshot,
        ns: *mut nsAtom,
        name: *mut nsAtom,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_SnapshotAttrEquals(
        element: *const ServoElementSnapshot,
        ns: *mut nsAtom,
        name: *mut nsAtom,
        str: *mut nsAtom,
        ignoreCase: bool,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_SnapshotAttrDashEquals(
        element: *const ServoElementSnapshot,
        ns: *mut nsAtom,
        name: *mut nsAtom,
        str: *mut nsAtom,
        ignore_case: bool,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_SnapshotAttrIncludes(
        element: *const ServoElementSnapshot,
        ns: *mut nsAtom,
        name: *mut nsAtom,
        str: *mut nsAtom,
        ignore_case: bool,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_SnapshotAttrHasSubstring(
        element: *const ServoElementSnapshot,
        ns: *mut nsAtom,
        name: *mut nsAtom,
        str: *mut nsAtom,
        ignore_case: bool,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_SnapshotAttrHasPrefix(
        element: *const ServoElementSnapshot,
        ns: *mut nsAtom,
        name: *mut nsAtom,
        str: *mut nsAtom,
        ignore_case: bool,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_SnapshotAttrHasSuffix(
        element: *const ServoElementSnapshot,
        ns: *mut nsAtom,
        name: *mut nsAtom,
        str: *mut nsAtom,
        ignore_case: bool,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_SnapshotClassOrClassList(
        element: *const ServoElementSnapshot,
        class_: *mut *mut nsAtom,
        classList: *mut *mut *mut nsAtom,
    ) -> u32;
}
extern "C" {
    pub fn Gecko_SnapshotHasClass(
        element: *const ServoElementSnapshot,
        class_: *mut nsAtom,
        ignore_case: bool,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_GetStyleAttrDeclarationBlock(
        element: RawGeckoElementBorrowed,
    ) -> RawServoDeclarationBlockStrongBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_UnsetDirtyStyleAttr(element: RawGeckoElementBorrowed);
}
extern "C" {
    pub fn Gecko_GetHTMLPresentationAttrDeclarationBlock(
        element: RawGeckoElementBorrowed,
    ) -> RawServoDeclarationBlockStrongBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetExtraContentStyleDeclarations(
        element: RawGeckoElementBorrowed,
    ) -> RawServoDeclarationBlockStrongBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetUnvisitedLinkAttrDeclarationBlock(
        element: RawGeckoElementBorrowed,
    ) -> RawServoDeclarationBlockStrongBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetVisitedLinkAttrDeclarationBlock(
        element: RawGeckoElementBorrowed,
    ) -> RawServoDeclarationBlockStrongBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetActiveLinkAttrDeclarationBlock(
        element: RawGeckoElementBorrowed,
    ) -> RawServoDeclarationBlockStrongBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_IsPrivateBrowsingEnabled(aDoc: *const nsIDocument) -> bool;
}
extern "C" {
    pub fn Gecko_GetAnimationRule(
        aElementOrPseudo: RawGeckoElementBorrowed,
        aCascadeLevel: EffectCompositor_CascadeLevel,
        aAnimationValues: RawServoAnimationValueMapBorrowedMut,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_StyleAnimationsEquals(
        arg1: RawGeckoStyleAnimationListBorrowed,
        arg2: RawGeckoStyleAnimationListBorrowed,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_CopyAnimationNames(
        aDest: RawGeckoStyleAnimationListBorrowedMut,
        aSrc: RawGeckoStyleAnimationListBorrowed,
    );
}
extern "C" {
    pub fn Gecko_SetAnimationName(aStyleAnimation: *mut StyleAnimation, aAtom: *mut nsAtom);
}
extern "C" {
    pub fn Gecko_UpdateAnimations(
        aElementOrPseudo: RawGeckoElementBorrowed,
        aOldComputedValues: ServoStyleContextBorrowedOrNull,
        aComputedValues: ServoStyleContextBorrowedOrNull,
        aTasks: UpdateAnimationsTasks,
    );
}
extern "C" {
    pub fn Gecko_ElementHasAnimations(aElementOrPseudo: RawGeckoElementBorrowed) -> bool;
}
extern "C" {
    pub fn Gecko_ElementHasCSSAnimations(aElementOrPseudo: RawGeckoElementBorrowed) -> bool;
}
extern "C" {
    pub fn Gecko_ElementHasCSSTransitions(aElementOrPseudo: RawGeckoElementBorrowed) -> bool;
}
extern "C" {
    pub fn Gecko_ElementTransitions_Length(aElementOrPseudo: RawGeckoElementBorrowed) -> usize;
}
extern "C" {
    pub fn Gecko_ElementTransitions_PropertyAt(
        aElementOrPseudo: RawGeckoElementBorrowed,
        aIndex: usize,
    ) -> nsCSSPropertyID;
}
extern "C" {
    pub fn Gecko_ElementTransitions_EndValueAt(
        aElementOrPseudo: RawGeckoElementBorrowed,
        aIndex: usize,
    ) -> RawServoAnimationValueBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetProgressFromComputedTiming(
        aComputedTiming: RawGeckoComputedTimingBorrowed,
    ) -> f64;
}
extern "C" {
    pub fn Gecko_GetPositionInSegment(
        aSegment: RawGeckoAnimationPropertySegmentBorrowed,
        aProgress: f64,
        aBeforeFlag: ComputedTimingFunction_BeforeFlag,
    ) -> f64;
}
extern "C" {
    pub fn Gecko_AnimationGetBaseStyle(
        aBaseStyles: RawServoAnimationValueTableBorrowed,
        aProperty: nsCSSPropertyID,
    ) -> RawServoAnimationValueBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_StyleTransition_SetUnsupportedProperty(
        aTransition: *mut StyleTransition,
        aAtom: *mut nsAtom,
    );
}
extern "C" {
    pub fn Gecko_Atomize(aString: *const ::std::os::raw::c_char, aLength: u32) -> *mut nsAtom;
}
extern "C" {
    pub fn Gecko_Atomize16(aString: *const nsAString) -> *mut nsAtom;
}
extern "C" {
    pub fn Gecko_AddRefAtom(aAtom: *mut nsAtom);
}
extern "C" {
    pub fn Gecko_ReleaseAtom(aAtom: *mut nsAtom);
}
extern "C" {
    pub fn Gecko_GetAtomAsUTF16(aAtom: *mut nsAtom, aLength: *mut u32) -> *const u16;
}
extern "C" {
    pub fn Gecko_AtomEqualsUTF8(
        aAtom: *mut nsAtom,
        aString: *const ::std::os::raw::c_char,
        aLength: u32,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_AtomEqualsUTF8IgnoreCase(
        aAtom: *mut nsAtom,
        aString: *const ::std::os::raw::c_char,
        aLength: u32,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_CopyFontFamilyFrom(dst: *mut nsFont, src: *const nsFont);
}
extern "C" {
    pub fn Gecko_nsTArray_FontFamilyName_AppendNamed(
        aNames: *mut nsTArray<FontFamilyName>,
        aName: *mut nsAtom,
        aQuoted: bool,
    );
}
extern "C" {
    pub fn Gecko_nsTArray_FontFamilyName_AppendGeneric(
        aNames: *mut nsTArray<FontFamilyName>,
        aType: FontFamilyType,
    );
}
extern "C" {
    pub fn Gecko_SharedFontList_Create() -> *mut SharedFontList;
}
extern "C" {
    pub fn Gecko_SharedFontList_SizeOfIncludingThis(fontlist: *mut SharedFontList) -> usize;
}
extern "C" {
    pub fn Gecko_SharedFontList_SizeOfIncludingThisIfUnshared(
        fontlist: *mut SharedFontList,
    ) -> usize;
}
extern "C" {
    pub fn Gecko_AddRefSharedFontListArbitraryThread(aPtr: *mut SharedFontList);
}
extern "C" {
    pub fn Gecko_ReleaseSharedFontListArbitraryThread(aPtr: *mut SharedFontList);
}
extern "C" {
    pub fn Gecko_nsFont_InitSystem(
        dst: *mut nsFont,
        font_id: i32,
        font: *const nsStyleFont,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_nsFont_Destroy(dst: *mut nsFont);
}
extern "C" {
    pub fn Gecko_ConstructFontFeatureValueSet() -> *mut gfxFontFeatureValueSet;
}
extern "C" {
    pub fn Gecko_AppendFeatureValueHashEntry(
        value_set: *mut gfxFontFeatureValueSet,
        family: *mut nsAtom,
        alternate: u32,
        name: *mut nsAtom,
    ) -> *mut nsTArray<::std::os::raw::c_uint>;
}
extern "C" {
    pub fn Gecko_nsFont_SetFontFeatureValuesLookup(
        font: *mut nsFont,
        pres_context: *const RawGeckoPresContext,
    );
}
extern "C" {
    pub fn Gecko_nsFont_ResetFontFeatureValuesLookup(font: *mut nsFont);
}
extern "C" {
    pub fn Gecko_ClearAlternateValues(font: *mut nsFont, length: usize);
}
extern "C" {
    pub fn Gecko_AppendAlternateValues(font: *mut nsFont, alternate_name: u32, atom: *mut nsAtom);
}
extern "C" {
    pub fn Gecko_CopyAlternateValuesFrom(dest: *mut nsFont, src: *const nsFont);
}
extern "C" {
    pub fn Gecko_SetImageOrientation(
        aVisibility: *mut nsStyleVisibility,
        aOrientation: u8,
        aFlip: bool,
    );
}
extern "C" {
    pub fn Gecko_SetImageOrientationAsFromImage(aVisibility: *mut nsStyleVisibility);
}
extern "C" {
    pub fn Gecko_CopyImageOrientationFrom(
        aDst: *mut nsStyleVisibility,
        aSrc: *const nsStyleVisibility,
    );
}
extern "C" {
    pub fn Gecko_SetCounterStyleToName(
        ptr: *mut CounterStylePtr,
        name: *mut nsAtom,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_SetCounterStyleToSymbols(
        ptr: *mut CounterStylePtr,
        symbols_type: u8,
        symbols: *const *const nsACString,
        symbols_count: u32,
    );
}
extern "C" {
    pub fn Gecko_SetCounterStyleToString(ptr: *mut CounterStylePtr, symbol: *const nsACString);
}
extern "C" {
    pub fn Gecko_CopyCounterStyle(dst: *mut CounterStylePtr, src: *const CounterStylePtr);
}
extern "C" {
    pub fn Gecko_CounterStyle_GetName(ptr: *const CounterStylePtr) -> *mut nsAtom;
}
extern "C" {
    pub fn Gecko_CounterStyle_GetAnonymous(
        ptr: *const CounterStylePtr,
    ) -> *const AnonymousCounterStyle;
}
extern "C" {
    pub fn Gecko_SetNullImageValue(image: *mut nsStyleImage);
}
extern "C" {
    pub fn Gecko_SetGradientImageValue(image: *mut nsStyleImage, gradient: *mut nsStyleGradient);
}
extern "C" {
    pub fn Gecko_AddRefImageValueArbitraryThread(aPtr: *mut ImageValue);
}
extern "C" {
    pub fn Gecko_ReleaseImageValueArbitraryThread(aPtr: *mut ImageValue);
}
extern "C" {
    pub fn Gecko_ImageValue_Create(
        aURI: ServoBundledURI,
        aURIString: ServoRawOffsetArc<RustString>,
    ) -> *mut ImageValue;
}
extern "C" {
    pub fn Gecko_ImageValue_SizeOfIncludingThis(aImageValue: *mut ImageValue) -> usize;
}
extern "C" {
    pub fn Gecko_SetLayerImageImageValue(image: *mut nsStyleImage, aImageValue: *mut ImageValue);
}
extern "C" {
    pub fn Gecko_SetImageElement(image: *mut nsStyleImage, atom: *mut nsAtom);
}
extern "C" {
    pub fn Gecko_CopyImageValueFrom(image: *mut nsStyleImage, other: *const nsStyleImage);
}
extern "C" {
    pub fn Gecko_InitializeImageCropRect(image: *mut nsStyleImage);
}
extern "C" {
    pub fn Gecko_CreateGradient(
        shape: u8,
        size: u8,
        repeating: bool,
        legacy_syntax: bool,
        moz_legacy_syntax: bool,
        stops: u32,
    ) -> *mut nsStyleGradient;
}
extern "C" {
    pub fn Gecko_GetURLValue(image: *const nsStyleImage) -> *const URLValueData;
}
extern "C" {
    pub fn Gecko_GetImageElement(image: *const nsStyleImage) -> *mut nsAtom;
}
extern "C" {
    pub fn Gecko_GetGradientImageValue(image: *const nsStyleImage) -> *const nsStyleGradient;
}
extern "C" {
    pub fn Gecko_SetListStyleImageNone(style_struct: *mut nsStyleList);
}
extern "C" {
    pub fn Gecko_SetListStyleImageImageValue(
        style_struct: *mut nsStyleList,
        aImageValue: *mut ImageValue,
    );
}
extern "C" {
    pub fn Gecko_CopyListStyleImageFrom(dest: *mut nsStyleList, src: *const nsStyleList);
}
extern "C" {
    pub fn Gecko_SetCursorArrayLength(ui: *mut nsStyleUserInterface, len: usize);
}
extern "C" {
    pub fn Gecko_SetCursorImageValue(aCursor: *mut nsCursorImage, aImageValue: *mut ImageValue);
}
extern "C" {
    pub fn Gecko_CopyCursorArrayFrom(
        dest: *mut nsStyleUserInterface,
        src: *const nsStyleUserInterface,
    );
}
extern "C" {
    pub fn Gecko_SetContentDataImageValue(
        aList: *mut nsStyleContentData,
        aImageValue: *mut ImageValue,
    );
}
extern "C" {
    pub fn Gecko_SetCounterFunction(
        content_data: *mut nsStyleContentData,
        type_: nsStyleContentType,
    ) -> *mut nsStyleContentData_CounterFunction;
}
extern "C" {
    pub fn Gecko_SetNodeFlags(node: RawGeckoNodeBorrowed, flags: u32);
}
extern "C" {
    pub fn Gecko_UnsetNodeFlags(node: RawGeckoNodeBorrowed, flags: u32);
}
extern "C" {
    pub fn Gecko_NoteDirtyElement(element: RawGeckoElementBorrowed);
}
extern "C" {
    pub fn Gecko_NoteDirtySubtreeForInvalidation(element: RawGeckoElementBorrowed);
}
extern "C" {
    pub fn Gecko_NoteAnimationOnlyDirtyElement(element: RawGeckoElementBorrowed);
}
extern "C" {
    pub fn Gecko_AnimationNameMayBeReferencedFromStyle(
        pres_context: RawGeckoPresContextBorrowed,
        name: *mut nsAtom,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_GetImplementedPseudo(element: RawGeckoElementBorrowed) -> CSSPseudoElementType;
}
extern "C" {
    pub fn Gecko_CalcStyleDifference(
        old_style: ServoStyleContextBorrowed,
        new_style: ServoStyleContextBorrowed,
        any_style_changed: *mut bool,
        reset_only_changed: *mut bool,
    ) -> u32;
}
extern "C" {
    pub fn Gecko_GetElementSnapshot(
        table: *const ServoElementSnapshotTable,
        element: RawGeckoElementBorrowed,
    ) -> *const ServoElementSnapshot;
}
extern "C" {
    pub fn Gecko_HaveSeenPtr(table: *mut SeenPtrs, ptr: *const ::std::os::raw::c_void) -> bool;
}
extern "C" {
    pub fn Gecko_ResizeTArrayForStrings(array: *mut nsTArray<nsStringRepr>, length: u32);
}
extern "C" {
    pub fn Gecko_SetStyleGridTemplate(
        grid_template: *mut UniquePtr<nsStyleGridTemplate>,
        value: *mut nsStyleGridTemplate,
    );
}
extern "C" {
    pub fn Gecko_CreateStyleGridTemplate(
        track_sizes: u32,
        name_size: u32,
    ) -> *mut nsStyleGridTemplate;
}
extern "C" {
    pub fn Gecko_CopyStyleGridTemplateValues(
        grid_template: *mut UniquePtr<nsStyleGridTemplate>,
        other: *const nsStyleGridTemplate,
    );
}
extern "C" {
    pub fn Gecko_NewGridTemplateAreasValue(
        areas: u32,
        templates: u32,
        columns: u32,
    ) -> *mut GridTemplateAreasValue;
}
extern "C" {
    pub fn Gecko_AddRefGridTemplateAreasValueArbitraryThread(aPtr: *mut GridTemplateAreasValue);
}
extern "C" {
    pub fn Gecko_ReleaseGridTemplateAreasValueArbitraryThread(aPtr: *mut GridTemplateAreasValue);
}
extern "C" {
    pub fn Gecko_ClearAndResizeStyleContents(content: *mut nsStyleContent, how_many: u32);
}
extern "C" {
    pub fn Gecko_ClearAndResizeCounterIncrements(content: *mut nsStyleContent, how_many: u32);
}
extern "C" {
    pub fn Gecko_ClearAndResizeCounterResets(content: *mut nsStyleContent, how_many: u32);
}
extern "C" {
    pub fn Gecko_CopyStyleContentsFrom(content: *mut nsStyleContent, other: *const nsStyleContent);
}
extern "C" {
    pub fn Gecko_CopyCounterResetsFrom(content: *mut nsStyleContent, other: *const nsStyleContent);
}
extern "C" {
    pub fn Gecko_CopyCounterIncrementsFrom(
        content: *mut nsStyleContent,
        other: *const nsStyleContent,
    );
}
extern "C" {
    pub fn Gecko_EnsureImageLayersLength(
        layers: *mut nsStyleImageLayers,
        len: usize,
        layer_type: nsStyleImageLayers_LayerType,
    );
}
extern "C" {
    pub fn Gecko_EnsureStyleAnimationArrayLength(array: *mut ::std::os::raw::c_void, len: usize);
}
extern "C" {
    pub fn Gecko_EnsureStyleTransitionArrayLength(array: *mut ::std::os::raw::c_void, len: usize);
}
extern "C" {
    pub fn Gecko_ClearWillChange(display: *mut nsStyleDisplay, length: usize);
}
extern "C" {
    pub fn Gecko_AppendWillChange(display: *mut nsStyleDisplay, atom: *mut nsAtom);
}
extern "C" {
    pub fn Gecko_CopyWillChangeFrom(dest: *mut nsStyleDisplay, src: *mut nsStyleDisplay);
}
extern "C" {
    pub fn Gecko_GetOrCreateKeyframeAtStart(
        keyframes: RawGeckoKeyframeListBorrowedMut,
        offset: f32,
        timingFunction: *const nsTimingFunction,
    ) -> *mut Keyframe;
}
extern "C" {
    pub fn Gecko_GetOrCreateInitialKeyframe(
        keyframes: RawGeckoKeyframeListBorrowedMut,
        timingFunction: *const nsTimingFunction,
    ) -> *mut Keyframe;
}
extern "C" {
    pub fn Gecko_GetOrCreateFinalKeyframe(
        keyframes: RawGeckoKeyframeListBorrowedMut,
        timingFunction: *const nsTimingFunction,
    ) -> *mut Keyframe;
}
extern "C" {
    pub fn Gecko_AppendPropertyValuePair(
        aProperties: RawGeckoPropertyValuePairListBorrowedMut,
        aProperty: nsCSSPropertyID,
    ) -> *mut PropertyValuePair;
}
extern "C" {
    pub fn Gecko_ResetStyleCoord(unit: *mut nsStyleUnit, value: *mut nsStyleUnion);
}
extern "C" {
    pub fn Gecko_SetStyleCoordCalcValue(
        unit: *mut nsStyleUnit,
        value: *mut nsStyleUnion,
        calc: nsStyleCoord_CalcValue,
    );
}
extern "C" {
    pub fn Gecko_CopyShapeSourceFrom(dst: *mut StyleShapeSource, src: *const StyleShapeSource);
}
extern "C" {
    pub fn Gecko_DestroyShapeSource(shape: *mut StyleShapeSource);
}
extern "C" {
    pub fn Gecko_NewBasicShape(shape: *mut StyleShapeSource, type_: StyleBasicShapeType);
}
extern "C" {
    pub fn Gecko_NewShapeImage(shape: *mut StyleShapeSource);
}
extern "C" {
    pub fn Gecko_StyleShapeSource_SetURLValue(shape: *mut StyleShapeSource, uri: ServoBundledURI);
}
extern "C" {
    pub fn Gecko_ResetFilters(effects: *mut nsStyleEffects, new_len: usize);
}
extern "C" {
    pub fn Gecko_CopyFiltersFrom(aSrc: *mut nsStyleEffects, aDest: *mut nsStyleEffects);
}
extern "C" {
    pub fn Gecko_nsStyleFilter_SetURLValue(effects: *mut nsStyleFilter, uri: ServoBundledURI);
}
extern "C" {
    pub fn Gecko_nsStyleSVGPaint_CopyFrom(dest: *mut nsStyleSVGPaint, src: *const nsStyleSVGPaint);
}
extern "C" {
    pub fn Gecko_nsStyleSVGPaint_SetURLValue(paint: *mut nsStyleSVGPaint, uri: ServoBundledURI);
}
extern "C" {
    pub fn Gecko_nsStyleSVGPaint_Reset(paint: *mut nsStyleSVGPaint);
}
extern "C" {
    pub fn Gecko_nsStyleSVG_SetDashArrayLength(svg: *mut nsStyleSVG, len: u32);
}
extern "C" {
    pub fn Gecko_nsStyleSVG_CopyDashArray(dst: *mut nsStyleSVG, src: *const nsStyleSVG);
}
extern "C" {
    pub fn Gecko_nsStyleSVG_SetContextPropertiesLength(svg: *mut nsStyleSVG, len: u32);
}
extern "C" {
    pub fn Gecko_nsStyleSVG_CopyContextProperties(dst: *mut nsStyleSVG, src: *const nsStyleSVG);
}
extern "C" {
    pub fn Gecko_NewURLValue(uri: ServoBundledURI) -> *mut URLValue;
}
extern "C" {
    pub fn Gecko_AddRefCSSURLValueArbitraryThread(aPtr: *mut URLValue);
}
extern "C" {
    pub fn Gecko_ReleaseCSSURLValueArbitraryThread(aPtr: *mut URLValue);
}
extern "C" {
    pub fn Gecko_AddRefURLExtraDataArbitraryThread(aPtr: *mut RawGeckoURLExtraData);
}
extern "C" {
    pub fn Gecko_ReleaseURLExtraDataArbitraryThread(aPtr: *mut RawGeckoURLExtraData);
}
extern "C" {
    pub fn Gecko_FillAllImageLayers(layers: *mut nsStyleImageLayers, max_len: u32);
}
extern "C" {
    pub fn Gecko_AddRefCalcArbitraryThread(aPtr: *mut nsStyleCoord_Calc);
}
extern "C" {
    pub fn Gecko_ReleaseCalcArbitraryThread(aPtr: *mut nsStyleCoord_Calc);
}
extern "C" {
    pub fn Gecko_NewCSSShadowArray(len: u32) -> *mut nsCSSShadowArray;
}
extern "C" {
    pub fn Gecko_AddRefCSSShadowArrayArbitraryThread(aPtr: *mut nsCSSShadowArray);
}
extern "C" {
    pub fn Gecko_ReleaseCSSShadowArrayArbitraryThread(aPtr: *mut nsCSSShadowArray);
}
extern "C" {
    pub fn Gecko_NewStyleQuoteValues(len: u32) -> *mut nsStyleQuoteValues;
}
extern "C" {
    pub fn Gecko_AddRefQuoteValuesArbitraryThread(aPtr: *mut nsStyleQuoteValues);
}
extern "C" {
    pub fn Gecko_ReleaseQuoteValuesArbitraryThread(aPtr: *mut nsStyleQuoteValues);
}
extern "C" {
    pub fn Gecko_NewCSSValueSharedList(len: u32) -> *mut nsCSSValueSharedList;
}
extern "C" {
    pub fn Gecko_NewNoneTransform() -> *mut nsCSSValueSharedList;
}
extern "C" {
    pub fn Gecko_CSSValue_GetArrayItem(
        css_value: nsCSSValueBorrowedMut,
        index: i32,
    ) -> nsCSSValueBorrowedMut;
}
extern "C" {
    pub fn Gecko_CSSValue_GetArrayItemConst(
        css_value: nsCSSValueBorrowed,
        index: i32,
    ) -> nsCSSValueBorrowed;
}
extern "C" {
    pub fn Gecko_CSSValue_GetKeyword(aCSSValue: nsCSSValueBorrowed) -> nsCSSKeyword;
}
extern "C" {
    pub fn Gecko_CSSValue_GetNumber(css_value: nsCSSValueBorrowed) -> f32;
}
extern "C" {
    pub fn Gecko_CSSValue_GetPercentage(css_value: nsCSSValueBorrowed) -> f32;
}
extern "C" {
    pub fn Gecko_CSSValue_GetCalc(aCSSValue: nsCSSValueBorrowed) -> nsStyleCoord_CalcValue;
}
extern "C" {
    pub fn Gecko_CSSValue_SetNumber(css_value: nsCSSValueBorrowedMut, number: f32);
}
extern "C" {
    pub fn Gecko_CSSValue_SetKeyword(css_value: nsCSSValueBorrowedMut, keyword: nsCSSKeyword);
}
extern "C" {
    pub fn Gecko_CSSValue_SetPercentage(css_value: nsCSSValueBorrowedMut, percent: f32);
}
extern "C" {
    pub fn Gecko_CSSValue_SetPixelLength(aCSSValue: nsCSSValueBorrowedMut, aLen: f32);
}
extern "C" {
    pub fn Gecko_CSSValue_SetCalc(css_value: nsCSSValueBorrowedMut, calc: nsStyleCoord_CalcValue);
}
extern "C" {
    pub fn Gecko_CSSValue_SetFunction(css_value: nsCSSValueBorrowedMut, len: i32);
}
extern "C" {
    pub fn Gecko_CSSValue_SetString(
        css_value: nsCSSValueBorrowedMut,
        string: *const u8,
        len: u32,
        unit: nsCSSUnit,
    );
}
extern "C" {
    pub fn Gecko_CSSValue_SetStringFromAtom(
        css_value: nsCSSValueBorrowedMut,
        atom: *mut nsAtom,
        unit: nsCSSUnit,
    );
}
extern "C" {
    pub fn Gecko_CSSValue_SetAtomIdent(css_value: nsCSSValueBorrowedMut, atom: *mut nsAtom);
}
extern "C" {
    pub fn Gecko_CSSValue_SetArray(css_value: nsCSSValueBorrowedMut, len: i32);
}
extern "C" {
    pub fn Gecko_CSSValue_SetURL(css_value: nsCSSValueBorrowedMut, uri: ServoBundledURI);
}
extern "C" {
    pub fn Gecko_CSSValue_SetInt(css_value: nsCSSValueBorrowedMut, integer: i32, unit: nsCSSUnit);
}
extern "C" {
    pub fn Gecko_CSSValue_SetFloat(css_value: nsCSSValueBorrowedMut, value: f32, unit: nsCSSUnit);
}
extern "C" {
    pub fn Gecko_CSSValue_SetPair(
        css_value: nsCSSValueBorrowedMut,
        xvalue: nsCSSValueBorrowed,
        yvalue: nsCSSValueBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CSSValue_SetList(css_value: nsCSSValueBorrowedMut, len: u32);
}
extern "C" {
    pub fn Gecko_CSSValue_SetPairList(css_value: nsCSSValueBorrowedMut, len: u32);
}
extern "C" {
    pub fn Gecko_CSSValue_InitSharedList(css_value: nsCSSValueBorrowedMut, len: u32);
}
extern "C" {
    pub fn Gecko_CSSValue_Drop(css_value: nsCSSValueBorrowedMut);
}
extern "C" {
    pub fn Gecko_AddRefCSSValueSharedListArbitraryThread(aPtr: *mut nsCSSValueSharedList);
}
extern "C" {
    pub fn Gecko_ReleaseCSSValueSharedListArbitraryThread(aPtr: *mut nsCSSValueSharedList);
}
extern "C" {
    pub fn Gecko_nsStyleFont_SetLang(font: *mut nsStyleFont, atom: *mut nsAtom);
}
extern "C" {
    pub fn Gecko_nsStyleFont_CopyLangFrom(aFont: *mut nsStyleFont, aSource: *const nsStyleFont);
}
extern "C" {
    pub fn Gecko_nsStyleFont_FixupNoneGeneric(
        font: *mut nsStyleFont,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_nsStyleFont_PrefillDefaultForGeneric(
        font: *mut nsStyleFont,
        pres_context: RawGeckoPresContextBorrowed,
        generic_id: u8,
    );
}
extern "C" {
    pub fn Gecko_nsStyleFont_FixupMinFontSize(
        font: *mut nsStyleFont,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_GetBaseSize(lang: *mut nsAtom) -> FontSizePrefs;
}
extern "C" {
    pub fn Gecko_GetBindingParent(
        aElement: RawGeckoElementBorrowed,
    ) -> RawGeckoElementBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetXBLBinding(
        aElement: RawGeckoElementBorrowed,
    ) -> RawGeckoXBLBindingBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_XBLBinding_GetRawServoStyleSet(
        aXBLBinding: RawGeckoXBLBindingBorrowed,
    ) -> RawServoStyleSetBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_XBLBinding_InheritsStyle(aXBLBinding: RawGeckoXBLBindingBorrowed) -> bool;
}
extern "C" {
    pub fn Gecko_GetFontMetrics(
        pres_context: RawGeckoPresContextBorrowed,
        is_vertical: bool,
        font: *const nsStyleFont,
        font_size: nscoord,
        use_user_font_set: bool,
    ) -> GeckoFontMetrics;
}
extern "C" {
    pub fn Gecko_GetAppUnitsPerPhysicalInch(pres_context: RawGeckoPresContextBorrowed) -> i32;
}
extern "C" {
    pub fn Gecko_StyleSheet_Clone(
        aSheet: *const ServoStyleSheet,
        aNewParentSheet: *const ServoStyleSheet,
    ) -> *mut ServoStyleSheet;
}
extern "C" {
    pub fn Gecko_StyleSheet_AddRef(aSheet: *const ServoStyleSheet);
}
extern "C" {
    pub fn Gecko_StyleSheet_Release(aSheet: *const ServoStyleSheet);
}
extern "C" {
    pub fn Gecko_LookupCSSKeyword(string: *const u8, len: u32) -> nsCSSKeyword;
}
extern "C" {
    pub fn Gecko_CSSKeywordString(
        keyword: nsCSSKeyword,
        len: *mut u32,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn Gecko_CSSFontFaceRule_Create(line: u32, column: u32) -> *mut nsCSSFontFaceRule;
}
extern "C" {
    pub fn Gecko_CSSFontFaceRule_Clone(rule: *const nsCSSFontFaceRule) -> *mut nsCSSFontFaceRule;
}
extern "C" {
    pub fn Gecko_CSSFontFaceRule_GetCssText(rule: *const nsCSSFontFaceRule, result: *mut nsAString);
}
extern "C" {
    pub fn Gecko_CSSFontFaceRule_AddRef(aPtr: *mut nsCSSFontFaceRule);
}
extern "C" {
    pub fn Gecko_CSSFontFaceRule_Release(aPtr: *mut nsCSSFontFaceRule);
}
extern "C" {
    pub fn Gecko_CSSCounterStyle_Create(name: *mut nsAtom) -> *mut nsCSSCounterStyleRule;
}
extern "C" {
    pub fn Gecko_CSSCounterStyle_Clone(
        rule: *const nsCSSCounterStyleRule,
    ) -> *mut nsCSSCounterStyleRule;
}
extern "C" {
    pub fn Gecko_CSSCounterStyle_GetCssText(
        rule: *const nsCSSCounterStyleRule,
        result: *mut nsAString,
    );
}
extern "C" {
    pub fn Gecko_CSSCounterStyleRule_AddRef(aPtr: *mut nsCSSCounterStyleRule);
}
extern "C" {
    pub fn Gecko_CSSCounterStyleRule_Release(aPtr: *mut nsCSSCounterStyleRule);
}
extern "C" {
    pub fn Gecko_IsDocumentBody(element: RawGeckoElementBorrowed) -> bool;
}
extern "C" {
    pub fn Gecko_GetLookAndFeelSystemColor(
        color_id: i32,
        pres_context: RawGeckoPresContextBorrowed,
    ) -> nscolor;
}
extern "C" {
    pub fn Gecko_AddPropertyToSet(arg1: nsCSSPropertyIDSetBorrowedMut, arg2: nsCSSPropertyID);
}
extern "C" {
    pub fn Gecko_RegisterNamespace(ns: *mut nsAtom) -> i32;
}
extern "C" {
    pub fn Gecko_ShouldCreateStyleThreadPool() -> bool;
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleFont(
        ptr: *mut nsStyleFont,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleFont(ptr: *mut nsStyleFont, other: *const nsStyleFont);
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleFont(ptr: *mut nsStyleFont);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleColor(
        ptr: *mut nsStyleColor,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleColor(ptr: *mut nsStyleColor, other: *const nsStyleColor);
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleColor(ptr: *mut nsStyleColor);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleList(
        ptr: *mut nsStyleList,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleList(ptr: *mut nsStyleList, other: *const nsStyleList);
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleList(ptr: *mut nsStyleList);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleText(
        ptr: *mut nsStyleText,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleText(ptr: *mut nsStyleText, other: *const nsStyleText);
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleText(ptr: *mut nsStyleText);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleVisibility(
        ptr: *mut nsStyleVisibility,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleVisibility(
        ptr: *mut nsStyleVisibility,
        other: *const nsStyleVisibility,
    );
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleVisibility(ptr: *mut nsStyleVisibility);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleUserInterface(
        ptr: *mut nsStyleUserInterface,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleUserInterface(
        ptr: *mut nsStyleUserInterface,
        other: *const nsStyleUserInterface,
    );
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleUserInterface(ptr: *mut nsStyleUserInterface);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleTableBorder(
        ptr: *mut nsStyleTableBorder,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleTableBorder(
        ptr: *mut nsStyleTableBorder,
        other: *const nsStyleTableBorder,
    );
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleTableBorder(ptr: *mut nsStyleTableBorder);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleSVG(
        ptr: *mut nsStyleSVG,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleSVG(ptr: *mut nsStyleSVG, other: *const nsStyleSVG);
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleSVG(ptr: *mut nsStyleSVG);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleVariables(
        ptr: *mut nsStyleVariables,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleVariables(
        ptr: *mut nsStyleVariables,
        other: *const nsStyleVariables,
    );
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleVariables(ptr: *mut nsStyleVariables);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleBackground(
        ptr: *mut nsStyleBackground,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleBackground(
        ptr: *mut nsStyleBackground,
        other: *const nsStyleBackground,
    );
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleBackground(ptr: *mut nsStyleBackground);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStylePosition(
        ptr: *mut nsStylePosition,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStylePosition(
        ptr: *mut nsStylePosition,
        other: *const nsStylePosition,
    );
}
extern "C" {
    pub fn Gecko_Destroy_nsStylePosition(ptr: *mut nsStylePosition);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleTextReset(
        ptr: *mut nsStyleTextReset,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleTextReset(
        ptr: *mut nsStyleTextReset,
        other: *const nsStyleTextReset,
    );
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleTextReset(ptr: *mut nsStyleTextReset);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleDisplay(
        ptr: *mut nsStyleDisplay,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleDisplay(
        ptr: *mut nsStyleDisplay,
        other: *const nsStyleDisplay,
    );
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleDisplay(ptr: *mut nsStyleDisplay);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleContent(
        ptr: *mut nsStyleContent,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleContent(
        ptr: *mut nsStyleContent,
        other: *const nsStyleContent,
    );
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleContent(ptr: *mut nsStyleContent);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleUIReset(
        ptr: *mut nsStyleUIReset,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleUIReset(
        ptr: *mut nsStyleUIReset,
        other: *const nsStyleUIReset,
    );
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleUIReset(ptr: *mut nsStyleUIReset);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleTable(
        ptr: *mut nsStyleTable,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleTable(ptr: *mut nsStyleTable, other: *const nsStyleTable);
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleTable(ptr: *mut nsStyleTable);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleMargin(
        ptr: *mut nsStyleMargin,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleMargin(ptr: *mut nsStyleMargin, other: *const nsStyleMargin);
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleMargin(ptr: *mut nsStyleMargin);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStylePadding(
        ptr: *mut nsStylePadding,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStylePadding(
        ptr: *mut nsStylePadding,
        other: *const nsStylePadding,
    );
}
extern "C" {
    pub fn Gecko_Destroy_nsStylePadding(ptr: *mut nsStylePadding);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleBorder(
        ptr: *mut nsStyleBorder,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleBorder(ptr: *mut nsStyleBorder, other: *const nsStyleBorder);
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleBorder(ptr: *mut nsStyleBorder);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleOutline(
        ptr: *mut nsStyleOutline,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleOutline(
        ptr: *mut nsStyleOutline,
        other: *const nsStyleOutline,
    );
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleOutline(ptr: *mut nsStyleOutline);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleXUL(
        ptr: *mut nsStyleXUL,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleXUL(ptr: *mut nsStyleXUL, other: *const nsStyleXUL);
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleXUL(ptr: *mut nsStyleXUL);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleSVGReset(
        ptr: *mut nsStyleSVGReset,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleSVGReset(
        ptr: *mut nsStyleSVGReset,
        other: *const nsStyleSVGReset,
    );
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleSVGReset(ptr: *mut nsStyleSVGReset);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleColumn(
        ptr: *mut nsStyleColumn,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleColumn(ptr: *mut nsStyleColumn, other: *const nsStyleColumn);
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleColumn(ptr: *mut nsStyleColumn);
}
extern "C" {
    pub fn Gecko_Construct_Default_nsStyleEffects(
        ptr: *mut nsStyleEffects,
        pres_context: RawGeckoPresContextBorrowed,
    );
}
extern "C" {
    pub fn Gecko_CopyConstruct_nsStyleEffects(
        ptr: *mut nsStyleEffects,
        other: *const nsStyleEffects,
    );
}
extern "C" {
    pub fn Gecko_Destroy_nsStyleEffects(ptr: *mut nsStyleEffects);
}
extern "C" {
    pub fn Gecko_RegisterProfilerThread(name: *const ::std::os::raw::c_char);
}
extern "C" {
    pub fn Gecko_UnregisterProfilerThread();
}
extern "C" {
    pub fn Gecko_DocumentRule_UseForPresentation(
        arg1: RawGeckoPresContextBorrowed,
        aPattern: *const nsACString,
        aURLMatchingFunction: URLMatchingFunction,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_SetJemallocThreadLocalArena(enabled: bool);
}
extern "C" {
    pub fn Gecko_AddBufferToCrashReport(addr: *const ::std::os::raw::c_void, len: usize);
}
extern "C" {
    pub fn Gecko_AnnotateCrashReport(
        key_str: *const ::std::os::raw::c_char,
        value_str: *const ::std::os::raw::c_char,
    );
}
extern "C" {
    pub fn Servo_Element_ClearData(node: RawGeckoElementBorrowed);
}
extern "C" {
    pub fn Servo_Element_SizeOfExcludingThisAndCVs(
        malloc_size_of: MallocSizeOf,
        malloc_enclosing_size_of: MallocSizeOf,
        seen_ptrs: *mut SeenPtrs,
        node: RawGeckoElementBorrowed,
    ) -> usize;
}
extern "C" {
    pub fn Servo_Element_HasPrimaryComputedValues(node: RawGeckoElementBorrowed) -> bool;
}
extern "C" {
    pub fn Servo_Element_GetPrimaryComputedValues(
        node: RawGeckoElementBorrowed,
    ) -> ServoStyleContextStrong;
}
extern "C" {
    pub fn Servo_Element_HasPseudoComputedValues(
        node: RawGeckoElementBorrowed,
        index: usize,
    ) -> bool;
}
extern "C" {
    pub fn Servo_Element_GetPseudoComputedValues(
        node: RawGeckoElementBorrowed,
        index: usize,
    ) -> ServoStyleContextStrong;
}
extern "C" {
    pub fn Servo_Element_IsDisplayNone(element: RawGeckoElementBorrowed) -> bool;
}
extern "C" {
    pub fn Servo_Element_IsPrimaryStyleReusedViaRuleNode(element: RawGeckoElementBorrowed) -> bool;
}
extern "C" {
    pub fn Servo_InvalidateStyleForDocStateChanges(
        root: RawGeckoElementBorrowed,
        sets: *const nsTArray<RawServoStyleSetBorrowed>,
        aStatesChanged: u64,
    );
}
extern "C" {
    pub fn Servo_StyleSheet_FromUTF8Bytes(
        loader: *mut Loader,
        gecko_stylesheet: *mut ServoStyleSheet,
        data: *const u8,
        data_len: usize,
        parsing_mode: SheetParsingMode,
        extra_data: *mut RawGeckoURLExtraData,
        line_number_offset: u32,
        quirks_mode: nsCompatibility,
        reusable_sheets: *mut LoaderReusableStyleSheets,
    ) -> RawServoStyleSheetContentsStrong;
}
extern "C" {
    pub fn Servo_StyleSheet_Empty(
        parsing_mode: SheetParsingMode,
    ) -> RawServoStyleSheetContentsStrong;
}
extern "C" {
    pub fn Servo_StyleSheet_HasRules(sheet: RawServoStyleSheetContentsBorrowed) -> bool;
}
extern "C" {
    pub fn Servo_StyleSheet_GetRules(
        sheet: RawServoStyleSheetContentsBorrowed,
    ) -> ServoCssRulesStrong;
}
extern "C" {
    pub fn Servo_StyleSheet_Clone(
        sheet: RawServoStyleSheetContentsBorrowed,
        reference_sheet: *const ServoStyleSheet,
    ) -> RawServoStyleSheetContentsStrong;
}
extern "C" {
    pub fn Servo_StyleSheet_SizeOfIncludingThis(
        malloc_size_of: MallocSizeOf,
        malloc_enclosing_size_of: MallocSizeOf,
        sheet: RawServoStyleSheetContentsBorrowed,
    ) -> usize;
}
extern "C" {
    pub fn Servo_StyleSheet_GetSourceMapURL(
        sheet: RawServoStyleSheetContentsBorrowed,
        result: *mut nsAString,
    );
}
extern "C" {
    pub fn Servo_StyleSheet_GetSourceURL(
        sheet: RawServoStyleSheetContentsBorrowed,
        result: *mut nsAString,
    );
}
extern "C" {
    pub fn Servo_StyleSheet_GetOrigin(sheet: RawServoStyleSheetContentsBorrowed) -> u8;
}
extern "C" {
    pub fn Servo_StyleSet_Init(pres_context: RawGeckoPresContextOwned) -> *mut RawServoStyleSet;
}
extern "C" {
    pub fn Servo_StyleSet_RebuildCachedData(set: RawServoStyleSetBorrowed);
}
extern "C" {
    pub fn Servo_StyleSet_MediumFeaturesChanged(
        document_set: RawServoStyleSetBorrowed,
        non_document_sets: *const nsTArray<*mut ServoStyleSet>,
        may_affect_default_style: bool,
    ) -> MediumFeaturesChangedResult;
}
extern "C" {
    pub fn Servo_StyleSet_CompatModeChanged(raw_data: RawServoStyleSetBorrowed);
}
extern "C" {
    pub fn Servo_StyleSet_AppendStyleSheet(
        set: RawServoStyleSetBorrowed,
        gecko_sheet: *const ServoStyleSheet,
    );
}
extern "C" {
    pub fn Servo_StyleSet_PrependStyleSheet(
        set: RawServoStyleSetBorrowed,
        gecko_sheet: *const ServoStyleSheet,
    );
}
extern "C" {
    pub fn Servo_StyleSet_RemoveStyleSheet(
        set: RawServoStyleSetBorrowed,
        gecko_sheet: *const ServoStyleSheet,
    );
}
extern "C" {
    pub fn Servo_StyleSet_InsertStyleSheetBefore(
        set: RawServoStyleSetBorrowed,
        gecko_sheet: *const ServoStyleSheet,
        before: *const ServoStyleSheet,
    );
}
extern "C" {
    pub fn Servo_StyleSet_FlushStyleSheets(
        set: RawServoStyleSetBorrowed,
        doc_elem: RawGeckoElementBorrowedOrNull,
        snapshots: *const ServoElementSnapshotTable,
    );
}
extern "C" {
    pub fn Servo_StyleSet_SetAuthorStyleDisabled(
        set: RawServoStyleSetBorrowed,
        author_style_disabled: bool,
    );
}
extern "C" {
    pub fn Servo_StyleSet_NoteStyleSheetsChanged(
        set: RawServoStyleSetBorrowed,
        changed_origins: OriginFlags,
    );
}
extern "C" {
    pub fn Servo_StyleSet_GetKeyframesForName(
        set: RawServoStyleSetBorrowed,
        name: *mut nsAtom,
        timing_function: nsTimingFunctionBorrowed,
        keyframe_list: RawGeckoKeyframeListBorrowedMut,
    ) -> bool;
}
extern "C" {
    pub fn Servo_StyleSet_GetFontFaceRules(
        set: RawServoStyleSetBorrowed,
        list: RawGeckoFontFaceRuleListBorrowedMut,
    );
}
extern "C" {
    pub fn Servo_StyleSet_GetCounterStyleRule(
        set: RawServoStyleSetBorrowed,
        name: *mut nsAtom,
    ) -> *mut nsCSSCounterStyleRule;
}
extern "C" {
    pub fn Servo_StyleSet_BuildFontFeatureValueSet(
        set: RawServoStyleSetBorrowed,
    ) -> *mut gfxFontFeatureValueSet;
}
extern "C" {
    pub fn Servo_StyleSet_ResolveForDeclarations(
        set: RawServoStyleSetBorrowed,
        parent_style: ServoStyleContextBorrowedOrNull,
        declarations: RawServoDeclarationBlockBorrowed,
    ) -> ServoStyleContextStrong;
}
extern "C" {
    pub fn Servo_SelectorList_Parse(selector_list: *const nsACString) -> *mut RawServoSelectorList;
}
extern "C" {
    pub fn Servo_SourceSizeList_Parse(value: *const nsACString) -> *mut RawServoSourceSizeList;
}
extern "C" {
    pub fn Servo_SourceSizeList_Evaluate(
        set: RawServoStyleSetBorrowed,
        arg1: RawServoSourceSizeListBorrowedOrNull,
    ) -> i32;
}
extern "C" {
    pub fn Servo_SelectorList_Matches(
        arg1: RawGeckoElementBorrowed,
        arg2: RawServoSelectorListBorrowed,
    ) -> bool;
}
extern "C" {
    pub fn Servo_SelectorList_Closest(
        arg1: RawGeckoElementBorrowed,
        arg2: RawServoSelectorListBorrowed,
    ) -> *const RawGeckoElement;
}
extern "C" {
    pub fn Servo_SelectorList_QueryFirst(
        arg1: RawGeckoNodeBorrowed,
        arg2: RawServoSelectorListBorrowed,
        may_use_invalidation: bool,
    ) -> *const RawGeckoElement;
}
extern "C" {
    pub fn Servo_SelectorList_QueryAll(
        arg1: RawGeckoNodeBorrowed,
        arg2: RawServoSelectorListBorrowed,
        content_list: *mut nsSimpleContentList,
        may_use_invalidation: bool,
    );
}
extern "C" {
    pub fn Servo_StyleSet_AddSizeOfExcludingThis(
        malloc_size_of: MallocSizeOf,
        malloc_enclosing_size_of: MallocSizeOf,
        sizes: *mut ServoStyleSetSizes,
        set: RawServoStyleSetBorrowed,
    );
}
extern "C" {
    pub fn Servo_UACache_AddSizeOf(
        malloc_size_of: MallocSizeOf,
        malloc_enclosing_size_of: MallocSizeOf,
        sizes: *mut ServoStyleSetSizes,
    );
}
extern "C" {
    pub fn Servo_StyleContext_AddRef(ctx: ServoStyleContextBorrowed);
}
extern "C" {
    pub fn Servo_StyleContext_Release(ctx: ServoStyleContextBorrowed);
}
extern "C" {
    pub fn Servo_StyleSet_MightHaveAttributeDependency(
        set: RawServoStyleSetBorrowed,
        element: RawGeckoElementBorrowed,
        local_name: *mut nsAtom,
    ) -> bool;
}
extern "C" {
    pub fn Servo_StyleSet_HasStateDependency(
        set: RawServoStyleSetBorrowed,
        element: RawGeckoElementBorrowed,
        state: u64,
    ) -> bool;
}
extern "C" {
    pub fn Servo_StyleSet_HasDocumentStateDependency(
        set: RawServoStyleSetBorrowed,
        state: u64,
    ) -> bool;
}
extern "C" {
    pub fn Servo_CssRules_ListTypes(
        rules: ServoCssRulesBorrowed,
        result: nsTArrayBorrowed_uintptr_t,
    );
}
extern "C" {
    pub fn Servo_CssRules_InsertRule(
        rules: ServoCssRulesBorrowed,
        sheet: RawServoStyleSheetContentsBorrowed,
        rule: *const nsACString,
        index: u32,
        nested: bool,
        loader: *mut Loader,
        gecko_stylesheet: *mut ServoStyleSheet,
        rule_type: *mut u16,
    ) -> nsresult;
}
extern "C" {
    pub fn Servo_CssRules_DeleteRule(rules: ServoCssRulesBorrowed, index: u32) -> nsresult;
}
extern "C" {
    pub fn Servo_CssRules_GetStyleRuleAt(
        rules: ServoCssRulesBorrowed,
        index: u32,
        line: *mut u32,
        column: *mut u32,
    ) -> RawServoStyleRuleStrong;
}
extern "C" {
    pub fn Servo_StyleRule_Debug(rule: RawServoStyleRuleBorrowed, result: *mut nsACString);
}
extern "C" {
    pub fn Servo_StyleRule_GetCssText(rule: RawServoStyleRuleBorrowed, result: *mut nsAString);
}
extern "C" {
    pub fn Servo_CssRules_GetImportRuleAt(
        rules: ServoCssRulesBorrowed,
        index: u32,
        line: *mut u32,
        column: *mut u32,
    ) -> RawServoImportRuleStrong;
}
extern "C" {
    pub fn Servo_ImportRule_Debug(rule: RawServoImportRuleBorrowed, result: *mut nsACString);
}
extern "C" {
    pub fn Servo_ImportRule_GetCssText(rule: RawServoImportRuleBorrowed, result: *mut nsAString);
}
extern "C" {
    pub fn Servo_Keyframe_Debug(rule: RawServoKeyframeBorrowed, result: *mut nsACString);
}
extern "C" {
    pub fn Servo_Keyframe_GetCssText(rule: RawServoKeyframeBorrowed, result: *mut nsAString);
}
extern "C" {
    pub fn Servo_CssRules_GetKeyframesRuleAt(
        rules: ServoCssRulesBorrowed,
        index: u32,
        line: *mut u32,
        column: *mut u32,
    ) -> RawServoKeyframesRuleStrong;
}
extern "C" {
    pub fn Servo_KeyframesRule_Debug(rule: RawServoKeyframesRuleBorrowed, result: *mut nsACString);
}
extern "C" {
    pub fn Servo_KeyframesRule_GetCssText(
        rule: RawServoKeyframesRuleBorrowed,
        result: *mut nsAString,
    );
}
extern "C" {
    pub fn Servo_CssRules_GetMediaRuleAt(
        rules: ServoCssRulesBorrowed,
        index: u32,
        line: *mut u32,
        column: *mut u32,
    ) -> RawServoMediaRuleStrong;
}
extern "C" {
    pub fn Servo_MediaRule_Debug(rule: RawServoMediaRuleBorrowed, result: *mut nsACString);
}
extern "C" {
    pub fn Servo_MediaRule_GetCssText(rule: RawServoMediaRuleBorrowed, result: *mut nsAString);
}
extern "C" {
    pub fn Servo_MediaRule_GetRules(rule: RawServoMediaRuleBorrowed) -> ServoCssRulesStrong;
}
extern "C" {
    pub fn Servo_CssRules_GetNamespaceRuleAt(
        rules: ServoCssRulesBorrowed,
        index: u32,
        line: *mut u32,
        column: *mut u32,
    ) -> RawServoNamespaceRuleStrong;
}
extern "C" {
    pub fn Servo_NamespaceRule_Debug(rule: RawServoNamespaceRuleBorrowed, result: *mut nsACString);
}
extern "C" {
    pub fn Servo_NamespaceRule_GetCssText(
        rule: RawServoNamespaceRuleBorrowed,
        result: *mut nsAString,
    );
}
extern "C" {
    pub fn Servo_CssRules_GetPageRuleAt(
        rules: ServoCssRulesBorrowed,
        index: u32,
        line: *mut u32,
        column: *mut u32,
    ) -> RawServoPageRuleStrong;
}
extern "C" {
    pub fn Servo_PageRule_Debug(rule: RawServoPageRuleBorrowed, result: *mut nsACString);
}
extern "C" {
    pub fn Servo_PageRule_GetCssText(rule: RawServoPageRuleBorrowed, result: *mut nsAString);
}
extern "C" {
    pub fn Servo_CssRules_GetSupportsRuleAt(
        rules: ServoCssRulesBorrowed,
        index: u32,
        line: *mut u32,
        column: *mut u32,
    ) -> RawServoSupportsRuleStrong;
}
extern "C" {
    pub fn Servo_SupportsRule_Debug(rule: RawServoSupportsRuleBorrowed, result: *mut nsACString);
}
extern "C" {
    pub fn Servo_SupportsRule_GetCssText(
        rule: RawServoSupportsRuleBorrowed,
        result: *mut nsAString,
    );
}
extern "C" {
    pub fn Servo_SupportsRule_GetRules(rule: RawServoSupportsRuleBorrowed) -> ServoCssRulesStrong;
}
extern "C" {
    pub fn Servo_CssRules_GetDocumentRuleAt(
        rules: ServoCssRulesBorrowed,
        index: u32,
        line: *mut u32,
        column: *mut u32,
    ) -> RawServoDocumentRuleStrong;
}
extern "C" {
    pub fn Servo_DocumentRule_Debug(rule: RawServoDocumentRuleBorrowed, result: *mut nsACString);
}
extern "C" {
    pub fn Servo_DocumentRule_GetCssText(
        rule: RawServoDocumentRuleBorrowed,
        result: *mut nsAString,
    );
}
extern "C" {
    pub fn Servo_DocumentRule_GetRules(rule: RawServoDocumentRuleBorrowed) -> ServoCssRulesStrong;
}
extern "C" {
    pub fn Servo_CssRules_GetFontFeatureValuesRuleAt(
        rules: ServoCssRulesBorrowed,
        index: u32,
        line: *mut u32,
        column: *mut u32,
    ) -> RawServoFontFeatureValuesRuleStrong;
}
extern "C" {
    pub fn Servo_FontFeatureValuesRule_Debug(
        rule: RawServoFontFeatureValuesRuleBorrowed,
        result: *mut nsACString,
    );
}
extern "C" {
    pub fn Servo_FontFeatureValuesRule_GetCssText(
        rule: RawServoFontFeatureValuesRuleBorrowed,
        result: *mut nsAString,
    );
}
extern "C" {
    pub fn Servo_CssRules_GetFontFaceRuleAt(
        rules: ServoCssRulesBorrowed,
        index: u32,
    ) -> *mut nsCSSFontFaceRule;
}
extern "C" {
    pub fn Servo_CssRules_GetCounterStyleRuleAt(
        rules: ServoCssRulesBorrowed,
        index: u32,
    ) -> *mut nsCSSCounterStyleRule;
}
extern "C" {
    pub fn Servo_StyleRule_GetStyle(
        rule: RawServoStyleRuleBorrowed,
    ) -> RawServoDeclarationBlockStrong;
}
extern "C" {
    pub fn Servo_StyleRule_SetStyle(
        rule: RawServoStyleRuleBorrowed,
        declarations: RawServoDeclarationBlockBorrowed,
    );
}
extern "C" {
    pub fn Servo_StyleRule_GetSelectorText(rule: RawServoStyleRuleBorrowed, result: *mut nsAString);
}
extern "C" {
    pub fn Servo_StyleRule_GetSelectorTextAtIndex(
        rule: RawServoStyleRuleBorrowed,
        index: u32,
        result: *mut nsAString,
    );
}
extern "C" {
    pub fn Servo_StyleRule_GetSpecificityAtIndex(
        rule: RawServoStyleRuleBorrowed,
        index: u32,
        specificity: *mut u64,
    );
}
extern "C" {
    pub fn Servo_StyleRule_GetSelectorCount(rule: RawServoStyleRuleBorrowed, count: *mut u32);
}
extern "C" {
    pub fn Servo_StyleRule_SelectorMatchesElement(
        arg1: RawServoStyleRuleBorrowed,
        arg2: RawGeckoElementBorrowed,
        index: u32,
        pseudo_type: CSSPseudoElementType,
    ) -> bool;
}
extern "C" {
    pub fn Servo_ImportRule_GetHref(rule: RawServoImportRuleBorrowed, result: *mut nsAString);
}
extern "C" {
    pub fn Servo_ImportRule_GetSheet(rule: RawServoImportRuleBorrowed) -> *const ServoStyleSheet;
}
extern "C" {
    pub fn Servo_Keyframe_GetKeyText(keyframe: RawServoKeyframeBorrowed, result: *mut nsAString);
}
extern "C" {
    pub fn Servo_Keyframe_SetKeyText(
        keyframe: RawServoKeyframeBorrowed,
        text: *const nsACString,
    ) -> bool;
}
extern "C" {
    pub fn Servo_Keyframe_GetStyle(
        keyframe: RawServoKeyframeBorrowed,
    ) -> RawServoDeclarationBlockStrong;
}
extern "C" {
    pub fn Servo_Keyframe_SetStyle(
        keyframe: RawServoKeyframeBorrowed,
        declarations: RawServoDeclarationBlockBorrowed,
    );
}
extern "C" {
    pub fn Servo_KeyframesRule_GetName(rule: RawServoKeyframesRuleBorrowed) -> *mut nsAtom;
}
extern "C" {
    pub fn Servo_KeyframesRule_SetName(rule: RawServoKeyframesRuleBorrowed, name: *mut nsAtom);
}
extern "C" {
    pub fn Servo_KeyframesRule_GetCount(rule: RawServoKeyframesRuleBorrowed) -> u32;
}
extern "C" {
    pub fn Servo_KeyframesRule_GetKeyframeAt(
        rule: RawServoKeyframesRuleBorrowed,
        index: u32,
        line: *mut u32,
        column: *mut u32,
    ) -> RawServoKeyframeStrong;
}
extern "C" {
    pub fn Servo_KeyframesRule_FindRule(
        rule: RawServoKeyframesRuleBorrowed,
        key: *const nsACString,
    ) -> u32;
}
extern "C" {
    pub fn Servo_KeyframesRule_AppendRule(
        rule: RawServoKeyframesRuleBorrowed,
        sheet: RawServoStyleSheetContentsBorrowed,
        css: *const nsACString,
    ) -> bool;
}
extern "C" {
    pub fn Servo_KeyframesRule_DeleteRule(rule: RawServoKeyframesRuleBorrowed, index: u32);
}
extern "C" {
    pub fn Servo_MediaRule_GetMedia(rule: RawServoMediaRuleBorrowed) -> RawServoMediaListStrong;
}
extern "C" {
    pub fn Servo_NamespaceRule_GetPrefix(rule: RawServoNamespaceRuleBorrowed) -> *mut nsAtom;
}
extern "C" {
    pub fn Servo_NamespaceRule_GetURI(rule: RawServoNamespaceRuleBorrowed) -> *mut nsAtom;
}
extern "C" {
    pub fn Servo_PageRule_GetStyle(
        rule: RawServoPageRuleBorrowed,
    ) -> RawServoDeclarationBlockStrong;
}
extern "C" {
    pub fn Servo_PageRule_SetStyle(
        rule: RawServoPageRuleBorrowed,
        declarations: RawServoDeclarationBlockBorrowed,
    );
}
extern "C" {
    pub fn Servo_SupportsRule_GetConditionText(
        rule: RawServoSupportsRuleBorrowed,
        result: *mut nsAString,
    );
}
extern "C" {
    pub fn Servo_DocumentRule_GetConditionText(
        rule: RawServoDocumentRuleBorrowed,
        result: *mut nsAString,
    );
}
extern "C" {
    pub fn Servo_FontFeatureValuesRule_GetFontFamily(
        rule: RawServoFontFeatureValuesRuleBorrowed,
        result: *mut nsAString,
    );
}
extern "C" {
    pub fn Servo_FontFeatureValuesRule_GetValueText(
        rule: RawServoFontFeatureValuesRuleBorrowed,
        result: *mut nsAString,
    );
}
extern "C" {
    pub fn Servo_ParseProperty(
        property: nsCSSPropertyID,
        value: *const nsACString,
        data: *mut RawGeckoURLExtraData,
        parsing_mode: ParsingMode,
        quirks_mode: nsCompatibility,
        loader: *mut Loader,
    ) -> RawServoDeclarationBlockStrong;
}
extern "C" {
    pub fn Servo_ParseEasing(
        easing: *const nsAString,
        data: *mut RawGeckoURLExtraData,
        output: nsTimingFunctionBorrowedMut,
    ) -> bool;
}
extern "C" {
    pub fn Servo_GetComputedKeyframeValues(
        keyframes: RawGeckoKeyframeListBorrowed,
        element: RawGeckoElementBorrowed,
        style: ServoStyleContextBorrowed,
        set: RawServoStyleSetBorrowed,
        result: RawGeckoComputedKeyframeValuesListBorrowedMut,
    );
}
extern "C" {
    pub fn Servo_ComputedValues_ExtractAnimationValue(
        computed_values: ServoStyleContextBorrowed,
        property: nsCSSPropertyID,
    ) -> RawServoAnimationValueStrong;
}
extern "C" {
    pub fn Servo_ComputedValues_SpecifiesAnimationsOrTransitions(
        computed_values: ServoStyleContextBorrowed,
    ) -> bool;
}
extern "C" {
    pub fn Servo_Property_IsAnimatable(property: nsCSSPropertyID) -> bool;
}
extern "C" {
    pub fn Servo_Property_IsTransitionable(property: nsCSSPropertyID) -> bool;
}
extern "C" {
    pub fn Servo_Property_IsDiscreteAnimatable(property: nsCSSPropertyID) -> bool;
}
extern "C" {
    pub fn Servo_GetProperties_Overriding_Animation(
        arg1: RawGeckoElementBorrowed,
        arg2: RawGeckoCSSPropertyIDListBorrowed,
        arg3: nsCSSPropertyIDSetBorrowedMut,
    );
}
extern "C" {
    pub fn Servo_MatrixTransform_Operate(
        matrix_operator: MatrixTransformOperator,
        from: *const RawGeckoGfxMatrix4x4,
        to: *const RawGeckoGfxMatrix4x4,
        progress: f64,
        result: *mut RawGeckoGfxMatrix4x4,
    );
}
extern "C" {
    pub fn Servo_GetAnimationValues(
        declarations: RawServoDeclarationBlockBorrowed,
        element: RawGeckoElementBorrowed,
        style: ServoStyleContextBorrowed,
        style_set: RawServoStyleSetBorrowed,
        animation_values: RawGeckoServoAnimationValueListBorrowedMut,
    );
}
extern "C" {
    pub fn Servo_AnimationValues_Interpolate(
        from: RawServoAnimationValueBorrowed,
        to: RawServoAnimationValueBorrowed,
        progress: f64,
    ) -> RawServoAnimationValueStrong;
}
extern "C" {
    pub fn Servo_AnimationValues_IsInterpolable(
        from: RawServoAnimationValueBorrowed,
        to: RawServoAnimationValueBorrowed,
    ) -> bool;
}
extern "C" {
    pub fn Servo_AnimationValues_Add(
        a: RawServoAnimationValueBorrowed,
        b: RawServoAnimationValueBorrowed,
    ) -> RawServoAnimationValueStrong;
}
extern "C" {
    pub fn Servo_AnimationValues_Accumulate(
        a: RawServoAnimationValueBorrowed,
        b: RawServoAnimationValueBorrowed,
        count: u64,
    ) -> RawServoAnimationValueStrong;
}
extern "C" {
    pub fn Servo_AnimationValues_GetZeroValue(
        value_to_match: RawServoAnimationValueBorrowed,
    ) -> RawServoAnimationValueStrong;
}
extern "C" {
    pub fn Servo_AnimationValues_ComputeDistance(
        from: RawServoAnimationValueBorrowed,
        to: RawServoAnimationValueBorrowed,
    ) -> f64;
}
extern "C" {
    pub fn Servo_AnimationValue_Serialize(
        value: RawServoAnimationValueBorrowed,
        property: nsCSSPropertyID,
        buffer: *mut nsAString,
    );
}
extern "C" {
    pub fn Servo_Shorthand_AnimationValues_Serialize(
        shorthand_property: nsCSSPropertyID,
        values: RawGeckoServoAnimationValueListBorrowed,
        buffer: *mut nsAString,
    );
}
extern "C" {
    pub fn Servo_AnimationValue_GetOpacity(value: RawServoAnimationValueBorrowed) -> f32;
}
extern "C" {
    pub fn Servo_AnimationValue_Opacity(arg1: f32) -> RawServoAnimationValueStrong;
}
extern "C" {
    pub fn Servo_AnimationValue_GetTransform(
        value: RawServoAnimationValueBorrowed,
        list: *mut RefPtr<nsCSSValueSharedList>,
    );
}
extern "C" {
    pub fn Servo_AnimationValue_Transform(
        list: *const nsCSSValueSharedList,
    ) -> RawServoAnimationValueStrong;
}
extern "C" {
    pub fn Servo_AnimationValue_DeepEqual(
        arg1: RawServoAnimationValueBorrowed,
        arg2: RawServoAnimationValueBorrowed,
    ) -> bool;
}
extern "C" {
    pub fn Servo_AnimationValue_Uncompute(
        value: RawServoAnimationValueBorrowed,
    ) -> RawServoDeclarationBlockStrong;
}
extern "C" {
    pub fn Servo_AnimationValue_Compute(
        element: RawGeckoElementBorrowed,
        declarations: RawServoDeclarationBlockBorrowed,
        style: ServoStyleContextBorrowed,
        raw_data: RawServoStyleSetBorrowed,
    ) -> RawServoAnimationValueStrong;
}
extern "C" {
    pub fn Servo_ParseStyleAttribute(
        data: *const nsACString,
        extra_data: *mut RawGeckoURLExtraData,
        quirks_mode: nsCompatibility,
        loader: *mut Loader,
    ) -> RawServoDeclarationBlockStrong;
}
extern "C" {
    pub fn Servo_DeclarationBlock_CreateEmpty() -> RawServoDeclarationBlockStrong;
}
extern "C" {
    pub fn Servo_DeclarationBlock_Clone(
        declarations: RawServoDeclarationBlockBorrowed,
    ) -> RawServoDeclarationBlockStrong;
}
extern "C" {
    pub fn Servo_DeclarationBlock_Equals(
        a: RawServoDeclarationBlockBorrowed,
        b: RawServoDeclarationBlockBorrowed,
    ) -> bool;
}
extern "C" {
    pub fn Servo_DeclarationBlock_GetCssText(
        declarations: RawServoDeclarationBlockBorrowed,
        result: *mut nsAString,
    );
}
extern "C" {
    pub fn Servo_DeclarationBlock_SerializeOneValue(
        declarations: RawServoDeclarationBlockBorrowed,
        property: nsCSSPropertyID,
        buffer: *mut nsAString,
        computed_values: ServoStyleContextBorrowedOrNull,
        custom_properties: RawServoDeclarationBlockBorrowedOrNull,
    );
}
extern "C" {
    pub fn Servo_DeclarationBlock_Count(declarations: RawServoDeclarationBlockBorrowed) -> u32;
}
extern "C" {
    pub fn Servo_DeclarationBlock_GetNthProperty(
        declarations: RawServoDeclarationBlockBorrowed,
        index: u32,
        result: *mut nsAString,
    ) -> bool;
}
extern "C" {
    pub fn Servo_DeclarationBlock_GetPropertyValue(
        declarations: RawServoDeclarationBlockBorrowed,
        property: *const nsACString,
        value: *mut nsAString,
    );
}
extern "C" {
    pub fn Servo_DeclarationBlock_GetPropertyValueById(
        declarations: RawServoDeclarationBlockBorrowed,
        property: nsCSSPropertyID,
        value: *mut nsAString,
    );
}
extern "C" {
    pub fn Servo_DeclarationBlock_GetPropertyIsImportant(
        declarations: RawServoDeclarationBlockBorrowed,
        property: *const nsACString,
    ) -> bool;
}
extern "C" {
    pub fn Servo_DeclarationBlock_SetProperty(
        declarations: RawServoDeclarationBlockBorrowed,
        property: *const nsACString,
        value: *const nsACString,
        is_important: bool,
        data: *mut RawGeckoURLExtraData,
        parsing_mode: ParsingMode,
        quirks_mode: nsCompatibility,
        loader: *mut Loader,
    ) -> bool;
}
extern "C" {
    pub fn Servo_DeclarationBlock_SetPropertyById(
        declarations: RawServoDeclarationBlockBorrowed,
        property: nsCSSPropertyID,
        value: *const nsACString,
        is_important: bool,
        data: *mut RawGeckoURLExtraData,
        parsing_mode: ParsingMode,
        quirks_mode: nsCompatibility,
        loader: *mut Loader,
    ) -> bool;
}
extern "C" {
    pub fn Servo_DeclarationBlock_RemoveProperty(
        declarations: RawServoDeclarationBlockBorrowed,
        property: *const nsACString,
    ) -> bool;
}
extern "C" {
    pub fn Servo_DeclarationBlock_RemovePropertyById(
        declarations: RawServoDeclarationBlockBorrowed,
        property: nsCSSPropertyID,
    ) -> bool;
}
extern "C" {
    pub fn Servo_DeclarationBlock_HasCSSWideKeyword(
        declarations: RawServoDeclarationBlockBorrowed,
        property: nsCSSPropertyID,
    ) -> bool;
}
extern "C" {
    pub fn Servo_AnimationCompose(
        animation_values: RawServoAnimationValueMapBorrowedMut,
        base_values: RawServoAnimationValueTableBorrowed,
        property: nsCSSPropertyID,
        animation_segment: RawGeckoAnimationPropertySegmentBorrowed,
        last_segment: RawGeckoAnimationPropertySegmentBorrowed,
        computed_timing: RawGeckoComputedTimingBorrowed,
        iter_composite: IterationCompositeOperation,
    );
}
extern "C" {
    pub fn Servo_ComposeAnimationSegment(
        animation_segment: RawGeckoAnimationPropertySegmentBorrowed,
        underlying_value: RawServoAnimationValueBorrowedOrNull,
        last_value: RawServoAnimationValueBorrowedOrNull,
        iter_composite: IterationCompositeOperation,
        progress: f64,
        current_iteration: u64,
    ) -> RawServoAnimationValueStrong;
}
extern "C" {
    pub fn Servo_DeclarationBlock_PropertyIsSet(
        declarations: RawServoDeclarationBlockBorrowed,
        property: nsCSSPropertyID,
    ) -> bool;
}
extern "C" {
    pub fn Servo_DeclarationBlock_SetIdentStringValue(
        declarations: RawServoDeclarationBlockBorrowed,
        property: nsCSSPropertyID,
        value: *mut nsAtom,
    );
}
extern "C" {
    pub fn Servo_DeclarationBlock_SetKeywordValue(
        declarations: RawServoDeclarationBlockBorrowed,
        property: nsCSSPropertyID,
        value: i32,
    );
}
extern "C" {
    pub fn Servo_DeclarationBlock_SetIntValue(
        declarations: RawServoDeclarationBlockBorrowed,
        property: nsCSSPropertyID,
        value: i32,
    );
}
extern "C" {
    pub fn Servo_DeclarationBlock_SetPixelValue(
        declarations: RawServoDeclarationBlockBorrowed,
        property: nsCSSPropertyID,
        value: f32,
    );
}
extern "C" {
    pub fn Servo_DeclarationBlock_SetLengthValue(
        declarations: RawServoDeclarationBlockBorrowed,
        property: nsCSSPropertyID,
        value: f32,
        unit: nsCSSUnit,
    );
}
extern "C" {
    pub fn Servo_DeclarationBlock_SetNumberValue(
        declarations: RawServoDeclarationBlockBorrowed,
        property: nsCSSPropertyID,
        value: f32,
    );
}
extern "C" {
    pub fn Servo_DeclarationBlock_SetPercentValue(
        declarations: RawServoDeclarationBlockBorrowed,
        property: nsCSSPropertyID,
        value: f32,
    );
}
extern "C" {
    pub fn Servo_DeclarationBlock_SetAutoValue(
        declarations: RawServoDeclarationBlockBorrowed,
        property: nsCSSPropertyID,
    );
}
extern "C" {
    pub fn Servo_DeclarationBlock_SetCurrentColor(
        declarations: RawServoDeclarationBlockBorrowed,
        property: nsCSSPropertyID,
    );
}
extern "C" {
    pub fn Servo_DeclarationBlock_SetColorValue(
        declarations: RawServoDeclarationBlockBorrowed,
        property: nsCSSPropertyID,
        value: nscolor,
    );
}
extern "C" {
    pub fn Servo_DeclarationBlock_SetFontFamily(
        declarations: RawServoDeclarationBlockBorrowed,
        value: *const nsAString,
    );
}
extern "C" {
    pub fn Servo_DeclarationBlock_SetTextDecorationColorOverride(
        declarations: RawServoDeclarationBlockBorrowed,
    );
}
extern "C" {
    pub fn Servo_DeclarationBlock_SetBackgroundImage(
        declarations: RawServoDeclarationBlockBorrowed,
        value: *const nsAString,
        extra_data: *mut RawGeckoURLExtraData,
    );
}
extern "C" {
    pub fn Servo_MediaList_Create() -> RawServoMediaListStrong;
}
extern "C" {
    pub fn Servo_MediaList_DeepClone(list: RawServoMediaListBorrowed) -> RawServoMediaListStrong;
}
extern "C" {
    pub fn Servo_MediaList_Matches(
        list: RawServoMediaListBorrowed,
        set: RawServoStyleSetBorrowed,
    ) -> bool;
}
extern "C" {
    pub fn Servo_MediaList_GetText(list: RawServoMediaListBorrowed, result: *mut nsAString);
}
extern "C" {
    pub fn Servo_MediaList_SetText(
        list: RawServoMediaListBorrowed,
        text: *const nsACString,
        aCallerType: CallerType,
    );
}
extern "C" {
    pub fn Servo_MediaList_GetLength(list: RawServoMediaListBorrowed) -> u32;
}
extern "C" {
    pub fn Servo_MediaList_GetMediumAt(
        list: RawServoMediaListBorrowed,
        index: u32,
        result: *mut nsAString,
    ) -> bool;
}
extern "C" {
    pub fn Servo_MediaList_AppendMedium(
        list: RawServoMediaListBorrowed,
        new_medium: *const nsACString,
    );
}
extern "C" {
    pub fn Servo_MediaList_DeleteMedium(
        list: RawServoMediaListBorrowed,
        old_medium: *const nsACString,
    ) -> bool;
}
extern "C" {
    pub fn Servo_CSSSupports2(name: *const nsACString, value: *const nsACString) -> bool;
}
extern "C" {
    pub fn Servo_CSSSupports(cond: *const nsACString) -> bool;
}
extern "C" {
    pub fn Servo_ComputedValues_GetForAnonymousBox(
        parent_style_or_null: ServoStyleContextBorrowedOrNull,
        pseudo_tag: *mut nsAtom,
        set: RawServoStyleSetBorrowed,
    ) -> ServoStyleContextStrong;
}
extern "C" {
    pub fn Servo_ComputedValues_Inherit(
        set: RawServoStyleSetBorrowed,
        pseudo_tag: *mut nsAtom,
        parent_style: ServoStyleContextBorrowedOrNull,
        target: InheritTarget,
    ) -> ServoStyleContextStrong;
}
extern "C" {
    pub fn Servo_ComputedValues_GetStyleBits(values: ServoStyleContextBorrowed) -> u64;
}
extern "C" {
    pub fn Servo_ComputedValues_EqualCustomProperties(
        first: ServoComputedDataBorrowed,
        second: ServoComputedDataBorrowed,
    ) -> bool;
}
extern "C" {
    pub fn Servo_ComputedValues_GetStyleRuleList(
        values: ServoStyleContextBorrowed,
        rules: RawGeckoServoStyleRuleListBorrowedMut,
    );
}
extern "C" {
    pub fn Servo_Initialize(dummy_url_data: *mut RawGeckoURLExtraData);
}
extern "C" {
    pub fn Servo_InitializeCooperativeThread();
}
extern "C" {
    pub fn Servo_Shutdown();
}
extern "C" {
    pub fn Servo_NoteExplicitHints(
        element: RawGeckoElementBorrowed,
        restyle_hint: nsRestyleHint,
        change_hint: nsChangeHint,
    );
}
extern "C" {
    pub fn Servo_TakeChangeHint(element: RawGeckoElementBorrowed, was_restyled: *mut bool) -> u32;
}
extern "C" {
    pub fn Servo_ResolveStyle(
        element: RawGeckoElementBorrowed,
        set: RawServoStyleSetBorrowed,
    ) -> ServoStyleContextStrong;
}
extern "C" {
    pub fn Servo_ResolvePseudoStyle(
        element: RawGeckoElementBorrowed,
        pseudo_type: CSSPseudoElementType,
        is_probe: bool,
        inherited_style: ServoStyleContextBorrowedOrNull,
        set: RawServoStyleSetBorrowed,
    ) -> ServoStyleContextStrong;
}
extern "C" {
    pub fn Servo_ComputedValues_ResolveXULTreePseudoStyle(
        element: RawGeckoElementBorrowed,
        pseudo_tag: *mut nsAtom,
        inherited_style: ServoStyleContextBorrowed,
        input_word: *const AtomArray,
        set: RawServoStyleSetBorrowed,
    ) -> ServoStyleContextStrong;
}
extern "C" {
    pub fn Servo_SetExplicitStyle(
        element: RawGeckoElementBorrowed,
        primary_style: ServoStyleContextBorrowed,
    );
}
extern "C" {
    pub fn Servo_HasAuthorSpecifiedRules(
        style: ServoStyleContextBorrowed,
        element: RawGeckoElementBorrowed,
        pseudo_type: CSSPseudoElementType,
        rule_type_mask: u32,
        author_colors_allowed: bool,
    ) -> bool;
}
extern "C" {
    pub fn Servo_ResolveStyleLazily(
        element: RawGeckoElementBorrowed,
        pseudo_type: CSSPseudoElementType,
        rule_inclusion: StyleRuleInclusion,
        snapshots: *const ServoElementSnapshotTable,
        set: RawServoStyleSetBorrowed,
        ignore_existing_styles: bool,
    ) -> ServoStyleContextStrong;
}
extern "C" {
    pub fn Servo_ReparentStyle(
        style_to_reparent: ServoStyleContextBorrowed,
        parent_style: ServoStyleContextBorrowed,
        parent_style_ignoring_first_line: ServoStyleContextBorrowed,
        layout_parent_style: ServoStyleContextBorrowed,
        element: RawGeckoElementBorrowedOrNull,
        set: RawServoStyleSetBorrowed,
    ) -> ServoStyleContextStrong;
}
extern "C" {
    pub fn Servo_TraverseSubtree(
        root: RawGeckoElementBorrowed,
        set: RawServoStyleSetBorrowed,
        snapshots: *const ServoElementSnapshotTable,
        flags: ServoTraversalFlags,
    ) -> bool;
}
extern "C" {
    pub fn Servo_AssertTreeIsClean(root: RawGeckoElementBorrowed);
}
extern "C" {
    pub fn Servo_IsWorkerThread() -> bool;
}
extern "C" {
    pub fn Servo_MaybeGCRuleTree(set: RawServoStyleSetBorrowed);
}
extern "C" {
    pub fn Servo_StyleSet_GetBaseComputedValuesForElement(
        set: RawServoStyleSetBorrowed,
        element: RawGeckoElementBorrowed,
        existing_style: ServoStyleContextBorrowed,
        snapshots: *const ServoElementSnapshotTable,
    ) -> ServoStyleContextStrong;
}
extern "C" {
    pub fn Servo_StyleSet_GetComputedValuesByAddingAnimation(
        set: RawServoStyleSetBorrowed,
        element: RawGeckoElementBorrowed,
        existing_style: ServoStyleContextBorrowed,
        snapshots: *const ServoElementSnapshotTable,
        animation: RawServoAnimationValueBorrowed,
    ) -> ServoStyleContextStrong;
}
extern "C" {
    pub fn Servo_SerializeFontValueForCanvas(
        declarations: RawServoDeclarationBlockBorrowed,
        buffer: *mut nsAString,
    );
}
extern "C" {
    pub fn Servo_GetCustomPropertyValue(
        computed_values: ServoStyleContextBorrowed,
        name: *const nsAString,
        value: *mut nsAString,
    ) -> bool;
}
extern "C" {
    pub fn Servo_GetCustomPropertiesCount(computed_values: ServoStyleContextBorrowed) -> u32;
}
extern "C" {
    pub fn Servo_GetCustomPropertyNameAt(
        arg1: ServoStyleContextBorrowed,
        index: u32,
        name: *mut nsAString,
    ) -> bool;
}
extern "C" {
    pub fn Servo_ProcessInvalidations(
        set: RawServoStyleSetBorrowed,
        element: RawGeckoElementBorrowed,
        snapshots: *const ServoElementSnapshotTable,
    );
}
extern "C" {
    pub fn Servo_HasPendingRestyleAncestor(element: RawGeckoElementBorrowed) -> bool;
}
extern "C" {
    pub fn Servo_GetArcStringData(arg1: *const RustString, chars: *mut *const u8, len: *mut u32);
}
extern "C" {
    pub fn Servo_ReleaseArcStringData(string: *const ServoRawOffsetArc<RustString>);
}
extern "C" {
    pub fn Servo_CloneArcStringData(
        string: *const ServoRawOffsetArc<RustString>,
    ) -> ServoRawOffsetArc<RustString>;
}
extern "C" {
    pub fn Servo_IsValidCSSColor(value: *const nsAString) -> bool;
}
extern "C" {
    pub fn Servo_ComputeColor(
        set: RawServoStyleSetBorrowedOrNull,
        current_color: nscolor,
        value: *const nsAString,
        result_color: *mut nscolor,
        was_current_color: *mut bool,
        loader: *mut Loader,
    ) -> bool;
}
extern "C" {
    pub fn Servo_ParseIntersectionObserverRootMargin(
        value: *const nsAString,
        result: *mut nsCSSRect,
    ) -> bool;
}
extern "C" {
    pub fn Servo_ParseTransformIntoMatrix(
        value: *const nsAString,
        contains_3d_transform: *mut bool,
        result: *mut RawGeckoGfxMatrix4x4,
    ) -> bool;
}
extern "C" {
    pub fn Servo_ParseCounterStyleName(value: *const nsACString) -> *mut nsAtom;
}
extern "C" {
    pub fn Servo_ParseCounterStyleDescriptor(
        aDescriptor: nsCSSCounterDesc,
        aValue: *const nsACString,
        aURLExtraData: *mut RawGeckoURLExtraData,
        aResult: *mut nsCSSValue,
    ) -> bool;
}
extern "C" {
    pub fn Servo_ParseFontDescriptor(
        desc_id: nsCSSFontDesc,
        value: *const nsAString,
        data: *mut RawGeckoURLExtraData,
        arg1: nsCSSValueBorrowedMut,
    ) -> bool;
}
extern "C" {
    pub fn Servo_ParseFontShorthandForMatching(
        value: *const nsAString,
        data: *mut RawGeckoURLExtraData,
        family: *mut RefPtr<SharedFontList>,
        style: nsCSSValueBorrowedMut,
        stretch: nsCSSValueBorrowedMut,
        weight: nsCSSValueBorrowedMut,
    ) -> bool;
}
extern "C" {
    pub fn Gecko_CreateCSSErrorReporter(
        sheet: *mut ServoStyleSheet,
        loader: *mut Loader,
        uri: *mut nsIURI,
    ) -> *mut ErrorReporter;
}
extern "C" {
    pub fn Gecko_DestroyCSSErrorReporter(reporter: *mut ErrorReporter);
}
extern "C" {
    pub fn Gecko_ReportUnexpectedCSSError(
        reporter: *mut ErrorReporter,
        message: *const ::std::os::raw::c_char,
        param: *const ::std::os::raw::c_char,
        paramLen: u32,
        prefix: *const ::std::os::raw::c_char,
        prefixParam: *const ::std::os::raw::c_char,
        prefixParamLen: u32,
        suffix: *const ::std::os::raw::c_char,
        source: *const ::std::os::raw::c_char,
        sourceLen: u32,
        lineNumber: u32,
        colNumber: u32,
    );
}
extern "C" {
    pub fn Gecko_ContentList_AppendAll(
        aContentList: *mut nsSimpleContentList,
        aElements: *mut *const RawGeckoElement,
        aLength: usize,
    );
}
extern "C" {
    pub fn Gecko_GetElementsWithId(
        aDocument: *const nsIDocument,
        aId: *mut nsAtom,
    ) -> *const nsTArray<*mut Element>;
}
extern "C" {
    pub fn Gecko_GetBoolPrefValue(pref_name: *const ::std::os::raw::c_char) -> bool;
}
extern "C" {
    pub fn Gecko_IsInServoTraversal() -> bool;
}
extern "C" {
    pub fn Gecko_IsMainThread() -> bool;
}