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;
use gecko_bindings::structs::mozilla::css::GridTemplateAreasValue;
use gecko_bindings::structs::mozilla::css::ImageValue;
use gecko_bindings::structs::mozilla::css::URLValue;
use gecko_bindings::structs::mozilla::MallocSizeOf;
use gecko_bindings::structs::mozilla::Side;
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::RawGeckoKeyframeList;
use gecko_bindings::structs::RawGeckoComputedKeyframeValuesList;
use gecko_bindings::structs::RawGeckoFontFaceRuleList;
use gecko_bindings::structs::RawGeckoNode;
use gecko_bindings::structs::RawGeckoAnimationValueList;
use gecko_bindings::structs::RawServoAnimationValue;
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::RawGeckoServoStyleRuleList;
use gecko_bindings::structs::RawGeckoURLExtraData;
use gecko_bindings::structs::RefPtr;
use gecko_bindings::structs::CSSPseudoClassType;
use gecko_bindings::structs::CSSPseudoElementType;
use gecko_bindings::structs::TraversalRestyleBehavior;
use gecko_bindings::structs::TraversalRootBehavior;
use gecko_bindings::structs::ComputedTimingFunction_BeforeFlag;
use gecko_bindings::structs::CounterStylePtr;
use gecko_bindings::structs::FontFamilyList;
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::ServoBundledURI;
use gecko_bindings::structs::ServoElementSnapshot;
use gecko_bindings::structs::ServoElementSnapshotTable;
use gecko_bindings::structs::SheetParsingMode;
use gecko_bindings::structs::StyleBasicShape;
use gecko_bindings::structs::StyleBasicShapeType;
use gecko_bindings::structs::StyleShapeSource;
use gecko_bindings::structs::StyleTransition;
use gecko_bindings::structs::nsCSSCounterStyleRule;
use gecko_bindings::structs::nsCSSFontFaceRule;
use gecko_bindings::structs::nsCSSKeyword;
use gecko_bindings::structs::nsCSSPropertyID;
use gecko_bindings::structs::nsCSSPropertyIDSet;
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::nsIAtom;
use gecko_bindings::structs::nsCompatibility;
use gecko_bindings::structs::nsMediaFeature;
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::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::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::StyleRuleInclusion;
use gecko_bindings::structs::nsStyleTransformMatrix::MatrixTransformOperator;
unsafe impl Send for nsStyleTransformMatrix::MatrixTransformOperator {}
unsafe impl Sync for nsStyleTransformMatrix::MatrixTransformOperator {}
use gecko_bindings::structs::RawGeckoGfxMatrix4x4;
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 StyleChildrenIteratorOwned = ::gecko_bindings::sugar::ownership::Owned<StyleChildrenIterator>;
pub type StyleChildrenIteratorOwnedOrNull = ::gecko_bindings::sugar::ownership::OwnedOrNull<StyleChildrenIterator>;
pub type StyleChildrenIteratorBorrowed<'a> = &'a StyleChildrenIterator;
pub type StyleChildrenIteratorBorrowedOrNull<'a> = Option<&'a StyleChildrenIterator>;
pub type StyleChildrenIteratorBorrowedMut<'a> = &'a mut StyleChildrenIterator;
pub type StyleChildrenIteratorBorrowedMutOrNull<'a> = Option<&'a mut StyleChildrenIterator>;
enum StyleChildrenIteratorVoid { }
pub struct StyleChildrenIterator(StyleChildrenIteratorVoid);
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 RawGeckoStyleAnimationListBorrowed<'a> = &'a RawGeckoStyleAnimationList;
pub type RawGeckoStyleAnimationListBorrowedOrNull<'a> = Option<&'a RawGeckoStyleAnimationList>;
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 RawGeckoAnimationValueListBorrowed<'a> = &'a RawGeckoAnimationValueList;
pub type RawGeckoAnimationValueListBorrowedOrNull<'a> = Option<&'a RawGeckoAnimationValueList>;
pub type RawGeckoAnimationValueListBorrowedMut<'a> = &'a mut RawGeckoAnimationValueList;
pub type RawGeckoAnimationValueListBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoAnimationValueList>;
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 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 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 RawServoStyleSheetStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoStyleSheet>;
pub type RawServoStyleSheetBorrowed<'a> = &'a RawServoStyleSheet;
pub type RawServoStyleSheetBorrowedOrNull<'a> = Option<&'a RawServoStyleSheet>;
enum RawServoStyleSheetVoid { }
pub struct RawServoStyleSheet(RawServoStyleSheetVoid);
pub type ServoComputedValuesStrong = ::gecko_bindings::sugar::ownership::Strong<ServoComputedValues>;
pub type ServoComputedValuesBorrowed<'a> = &'a ServoComputedValues;
pub type ServoComputedValuesBorrowedOrNull<'a> = Option<&'a ServoComputedValues>;
enum ServoComputedValuesVoid { }
pub struct ServoComputedValues(ServoComputedValuesVoid);
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>;
enum RawServoMediaListVoid { }
pub struct RawServoMediaList(RawServoMediaListVoid);
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 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_StyleSheet_AddRef(ptr: RawServoStyleSheetBorrowed);
}
extern "C" {
    pub fn Servo_StyleSheet_Release(ptr: RawServoStyleSheetBorrowed);
}
extern "C" {
    pub fn Servo_ComputedValues_AddRef(ptr: ServoComputedValuesBorrowed);
}
extern "C" {
    pub fn Servo_ComputedValues_Release(ptr: ServoComputedValuesBorrowed);
}
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_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 Gecko_ChildrenCount(node: RawGeckoNodeBorrowed) -> u32;
}
extern "C" {
    pub fn Gecko_NodeIsElement(node: RawGeckoNodeBorrowed) -> bool;
}
extern "C" {
    pub fn Gecko_IsInDocument(node: RawGeckoNodeBorrowed) -> bool;
}
extern "C" {
    pub fn Gecko_FlattenedTreeParentIsParent(node: RawGeckoNodeBorrowed)
     -> bool;
}
extern "C" {
    pub fn Gecko_IsSignificantChild(node: RawGeckoNodeBorrowed,
                                    text_is_significant: bool,
                                    whitespace_is_significant: bool) -> bool;
}
extern "C" {
    pub fn Gecko_GetParentNode(node: RawGeckoNodeBorrowed)
     -> RawGeckoNodeBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetFirstChild(node: RawGeckoNodeBorrowed)
     -> RawGeckoNodeBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetLastChild(node: RawGeckoNodeBorrowed)
     -> RawGeckoNodeBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetPrevSibling(node: RawGeckoNodeBorrowed)
     -> RawGeckoNodeBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetNextSibling(node: RawGeckoNodeBorrowed)
     -> RawGeckoNodeBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetFirstChildElement(element: RawGeckoElementBorrowed)
     -> RawGeckoElementBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetLastChildElement(element: RawGeckoElementBorrowed)
     -> RawGeckoElementBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetPrevSiblingElement(element: RawGeckoElementBorrowed)
     -> RawGeckoElementBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetNextSiblingElement(element: RawGeckoElementBorrowed)
     -> RawGeckoElementBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetDocumentElement(document: RawGeckoDocumentBorrowed)
     -> RawGeckoElementBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_LoadStyleSheet(loader: *mut Loader,
                                parent: *mut ServoStyleSheet,
                                reusable_sheets:
                                    *mut LoaderReusableStyleSheets,
                                child_sheet: RawServoStyleSheetBorrowed,
                                base_url_data: *mut RawGeckoURLExtraData,
                                url_bytes: *const u8, url_length: u32,
                                media_list: RawServoMediaListStrong);
}
extern "C" {
    pub fn Gecko_MaybeCreateStyleChildrenIterator(node: RawGeckoNodeBorrowed)
     -> StyleChildrenIteratorOwnedOrNull;
}
extern "C" {
    pub fn Gecko_DropStyleChildrenIterator(it: StyleChildrenIteratorOwned);
}
extern "C" {
    pub fn Gecko_GetNextStyleChild(it: StyleChildrenIteratorBorrowedMut)
     -> RawGeckoNodeBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_ElementState(element: RawGeckoElementBorrowed) -> u64;
}
extern "C" {
    pub fn Gecko_IsTextNode(node: RawGeckoNodeBorrowed) -> bool;
}
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_LocalName(element: RawGeckoElementBorrowed) -> *mut nsIAtom;
}
extern "C" {
    pub fn Gecko_Namespace(element: RawGeckoElementBorrowed) -> *mut nsIAtom;
}
extern "C" {
    pub fn Gecko_GetElementId(element: RawGeckoElementBorrowed)
     -> *mut nsIAtom;
}
extern "C" {
    pub fn Gecko_GetXMLLangValue(element: RawGeckoElementBorrowed)
     -> *mut nsIAtom;
}
extern "C" {
    pub fn Gecko_AtomAttrValue(element: RawGeckoElementBorrowed,
                               attribute: *mut nsIAtom) -> *mut nsIAtom;
}
extern "C" {
    pub fn Gecko_HasAttr(element: RawGeckoElementBorrowed, ns: *mut nsIAtom,
                         name: *mut nsIAtom) -> bool;
}
extern "C" {
    pub fn Gecko_AttrEquals(element: RawGeckoElementBorrowed,
                            ns: *mut nsIAtom, name: *mut nsIAtom,
                            str: *mut nsIAtom, ignoreCase: bool) -> bool;
}
extern "C" {
    pub fn Gecko_AttrDashEquals(element: RawGeckoElementBorrowed,
                                ns: *mut nsIAtom, name: *mut nsIAtom,
                                str: *mut nsIAtom) -> bool;
}
extern "C" {
    pub fn Gecko_AttrIncludes(element: RawGeckoElementBorrowed,
                              ns: *mut nsIAtom, name: *mut nsIAtom,
                              str: *mut nsIAtom) -> bool;
}
extern "C" {
    pub fn Gecko_AttrHasSubstring(element: RawGeckoElementBorrowed,
                                  ns: *mut nsIAtom, name: *mut nsIAtom,
                                  str: *mut nsIAtom) -> bool;
}
extern "C" {
    pub fn Gecko_AttrHasPrefix(element: RawGeckoElementBorrowed,
                               ns: *mut nsIAtom, name: *mut nsIAtom,
                               str: *mut nsIAtom) -> bool;
}
extern "C" {
    pub fn Gecko_AttrHasSuffix(element: RawGeckoElementBorrowed,
                               ns: *mut nsIAtom, name: *mut nsIAtom,
                               str: *mut nsIAtom) -> bool;
}
extern "C" {
    pub fn Gecko_ClassOrClassList(element: RawGeckoElementBorrowed,
                                  class_: *mut *mut nsIAtom,
                                  classList: *mut *mut *mut nsIAtom) -> u32;
}
extern "C" {
    pub fn Gecko_SnapshotAtomAttrValue(element: *const ServoElementSnapshot,
                                       attribute: *mut nsIAtom)
     -> *mut nsIAtom;
}
extern "C" {
    pub fn Gecko_SnapshotHasAttr(element: *const ServoElementSnapshot,
                                 ns: *mut nsIAtom, name: *mut nsIAtom)
     -> bool;
}
extern "C" {
    pub fn Gecko_SnapshotAttrEquals(element: *const ServoElementSnapshot,
                                    ns: *mut nsIAtom, name: *mut nsIAtom,
                                    str: *mut nsIAtom, ignoreCase: bool)
     -> bool;
}
extern "C" {
    pub fn Gecko_SnapshotAttrDashEquals(element: *const ServoElementSnapshot,
                                        ns: *mut nsIAtom, name: *mut nsIAtom,
                                        str: *mut nsIAtom) -> bool;
}
extern "C" {
    pub fn Gecko_SnapshotAttrIncludes(element: *const ServoElementSnapshot,
                                      ns: *mut nsIAtom, name: *mut nsIAtom,
                                      str: *mut nsIAtom) -> bool;
}
extern "C" {
    pub fn Gecko_SnapshotAttrHasSubstring(element:
                                              *const ServoElementSnapshot,
                                          ns: *mut nsIAtom,
                                          name: *mut nsIAtom,
                                          str: *mut nsIAtom) -> bool;
}
extern "C" {
    pub fn Gecko_SnapshotAttrHasPrefix(element: *const ServoElementSnapshot,
                                       ns: *mut nsIAtom, name: *mut nsIAtom,
                                       str: *mut nsIAtom) -> bool;
}
extern "C" {
    pub fn Gecko_SnapshotAttrHasSuffix(element: *const ServoElementSnapshot,
                                       ns: *mut nsIAtom, name: *mut nsIAtom,
                                       str: *mut nsIAtom) -> bool;
}
extern "C" {
    pub fn Gecko_SnapshotClassOrClassList(element:
                                              *const ServoElementSnapshot,
                                          class_: *mut *mut nsIAtom,
                                          classList: *mut *mut *mut nsIAtom)
     -> u32;
}
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_GetAnimationRule(aElementOrPseudo: RawGeckoElementBorrowed,
                                  aCascadeLevel:
                                      EffectCompositor_CascadeLevel,
                                  aAnimationValues:
                                      RawServoAnimationValueMapBorrowedMut)
     -> bool;
}
extern "C" {
    pub fn Gecko_GetSMILOverrideDeclarationBlock(element:
                                                     RawGeckoElementBorrowed)
     -> RawServoDeclarationBlockStrongBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_StyleAnimationsEquals(arg1:
                                           RawGeckoStyleAnimationListBorrowed,
                                       arg2:
                                           RawGeckoStyleAnimationListBorrowed)
     -> bool;
}
extern "C" {
    pub fn Gecko_UpdateAnimations(aElementOrPseudo: RawGeckoElementBorrowed,
                                  aOldComputedValues:
                                      ServoComputedValuesBorrowedOrNull,
                                  aComputedValues:
                                      ServoComputedValuesBorrowedOrNull,
                                  aParentComputedValues:
                                      ServoComputedValuesBorrowedOrNull,
                                  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:
                                           *mut ::std::os::raw::c_void,
                                       aProperty: nsCSSPropertyID)
     -> RawServoAnimationValueBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_StyleTransition_SetUnsupportedProperty(aTransition:
                                                            *mut StyleTransition,
                                                        aAtom: *mut nsIAtom);
}
extern "C" {
    pub fn Gecko_Atomize(aString: *const ::std::os::raw::c_char, aLength: u32)
     -> *mut nsIAtom;
}
extern "C" {
    pub fn Gecko_Atomize16(aString: *const nsAString) -> *mut nsIAtom;
}
extern "C" {
    pub fn Gecko_AddRefAtom(aAtom: *mut nsIAtom);
}
extern "C" {
    pub fn Gecko_ReleaseAtom(aAtom: *mut nsIAtom);
}
extern "C" {
    pub fn Gecko_GetAtomAsUTF16(aAtom: *mut nsIAtom, aLength: *mut u32)
     -> *const u16;
}
extern "C" {
    pub fn Gecko_AtomEqualsUTF8(aAtom: *mut nsIAtom,
                                aString: *const ::std::os::raw::c_char,
                                aLength: u32) -> bool;
}
extern "C" {
    pub fn Gecko_AtomEqualsUTF8IgnoreCase(aAtom: *mut nsIAtom,
                                          aString:
                                              *const ::std::os::raw::c_char,
                                          aLength: u32) -> bool;
}
extern "C" {
    pub fn Gecko_EnsureMozBorderColors(aBorder: *mut nsStyleBorder);
}
extern "C" {
    pub fn Gecko_ClearMozBorderColors(aBorder: *mut nsStyleBorder,
                                      aSide: Side);
}
extern "C" {
    pub fn Gecko_AppendMozBorderColors(aBorder: *mut nsStyleBorder,
                                       aSide: Side, aColor: nscolor);
}
extern "C" {
    pub fn Gecko_CopyMozBorderColors(aDest: *mut nsStyleBorder,
                                     aSrc: *const nsStyleBorder, aSide: Side);
}
extern "C" {
    pub fn Gecko_FontFamilyList_Clear(aList: *mut FontFamilyList);
}
extern "C" {
    pub fn Gecko_FontFamilyList_AppendNamed(aList: *mut FontFamilyList,
                                            aName: *mut nsIAtom,
                                            aQuoted: bool);
}
extern "C" {
    pub fn Gecko_FontFamilyList_AppendGeneric(list: *mut FontFamilyList,
                                              familyType: FontFamilyType);
}
extern "C" {
    pub fn Gecko_CopyFontFamilyFrom(dst: *mut nsFont, src: *const nsFont);
}
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_SetImageOrientation(aVisibility: *mut nsStyleVisibility,
                                     aRadians: f64, 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 nsIAtom);
}
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_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) -> *mut ImageValue;
}
extern "C" {
    pub fn Gecko_SetLayerImageImageValue(image: *mut nsStyleImage,
                                         aImageValue: *mut ImageValue);
}
extern "C" {
    pub fn Gecko_SetImageElement(image: *mut nsStyleImage,
                                 atom: *mut nsIAtom);
}
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, stops: u32)
     -> *mut 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_GetNodeFlags(node: RawGeckoNodeBorrowed) -> u32;
}
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_SetOwnerDocumentNeedsStyleFlush(element:
                                                     RawGeckoElementBorrowed);
}
extern "C" {
    pub fn Gecko_GetStyleContext(element: RawGeckoElementBorrowed,
                                 aPseudoTagOrNull: *mut nsIAtom)
     -> *mut nsStyleContext;
}
extern "C" {
    pub fn Gecko_GetImplementedPseudo(element: RawGeckoElementBorrowed)
     -> CSSPseudoElementType;
}
extern "C" {
    pub fn Gecko_CalcStyleDifference(oldstyle: *mut nsStyleContext,
                                     newstyle: ServoComputedValuesBorrowed,
                                     any_style_changed: *mut bool)
     -> nsChangeHint;
}
extern "C" {
    pub fn Gecko_HintsHandledForDescendants(aHint: nsChangeHint)
     -> nsChangeHint;
}
extern "C" {
    pub fn Gecko_GetElementSnapshot(table: *const ServoElementSnapshotTable,
                                    element: RawGeckoElementBorrowed)
     -> *const ServoElementSnapshot;
}
extern "C" {
    pub fn Gecko_DropElementSnapshot(snapshot: ServoElementSnapshotOwned);
}
extern "C" {
    pub fn Gecko_ResizeTArrayForStrings(array: *mut nsTArray<nsStringRepr>,
                                        length: u32);
}
extern "C" {
    pub fn Gecko_SetStyleGridTemplateArrayLengths(grid_template:
                                                      *mut nsStyleGridTemplate,
                                                  track_sizes: u32);
}
extern "C" {
    pub fn Gecko_CopyStyleGridTemplateValues(grid_template:
                                                 *mut 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 nsIAtom);
}
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_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(type_: StyleBasicShapeType)
     -> *mut StyleBasicShape;
}
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_FillAllBackgroundLists(layers: *mut nsStyleImageLayers,
                                        max_len: u32);
}
extern "C" {
    pub fn Gecko_FillAllMaskLists(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_GetAbsoluteLength(css_value: nsCSSValueBorrowed)
     -> nscoord;
}
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_SetAbsoluteLength(css_value: nsCSSValueBorrowedMut,
                                            len: nscoord);
}
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_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 nsIAtom,
                                            unit: nsCSSUnit);
}
extern "C" {
    pub fn Gecko_CSSValue_SetAtomIdent(css_value: nsCSSValueBorrowedMut,
                                       atom: *mut nsIAtom);
}
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_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_PropertyId_IsPrefEnabled(id: nsCSSPropertyID) -> bool;
}
extern "C" {
    pub fn Gecko_nsStyleFont_SetLang(font: *mut nsStyleFont,
                                     atom: *mut nsIAtom);
}
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_FixupMinFontSize(font: *mut nsStyleFont,
                                              pres_context:
                                                  RawGeckoPresContextBorrowed);
}
extern "C" {
    pub fn Gecko_GetBaseSize(lang: *mut nsIAtom) -> FontSizePrefs;
}
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_GetMediaFeatures() -> *const nsMediaFeature;
}
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_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 nsIAtom)
     -> *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_GetBody(pres_context: RawGeckoPresContextBorrowed)
     -> RawGeckoElementBorrowedOrNull;
}
extern "C" {
    pub fn Gecko_GetLookAndFeelSystemColor(color_id: i32,
                                           pres_context:
                                               RawGeckoPresContextBorrowed)
     -> nscolor;
}
extern "C" {
    pub fn Gecko_MatchStringArgPseudo(element: RawGeckoElementBorrowed,
                                      type_: CSSPseudoClassType,
                                      ident: *const u16,
                                      set_slow_selector: *mut bool) -> bool;
}
extern "C" {
    pub fn Gecko_AddPropertyToSet(arg1: nsCSSPropertyIDSetBorrowedMut,
                                  arg2: nsCSSPropertyID);
}
extern "C" {
    pub fn Gecko_RegisterNamespace(ns: *mut nsIAtom) -> i32;
}
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_Construct_nsStyleVariables(ptr: *mut nsStyleVariables);
}
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 Servo_Element_ClearData(node: RawGeckoElementBorrowed);
}
extern "C" {
    pub fn Servo_StyleSheet_Empty(parsing_mode: SheetParsingMode)
     -> RawServoStyleSheetStrong;
}
extern "C" {
    pub fn Servo_StyleSheet_FromUTF8Bytes(loader: *mut Loader,
                                          gecko_stylesheet:
                                              *mut ServoStyleSheet,
                                          data: *const nsACString,
                                          parsing_mode: SheetParsingMode,
                                          media_list:
                                              *const RawServoMediaList,
                                          extra_data:
                                              *mut RawGeckoURLExtraData,
                                          line_number_offset: u32,
                                          quirks_mode: nsCompatibility)
     -> RawServoStyleSheetStrong;
}
extern "C" {
    pub fn Servo_StyleSheet_ClearAndUpdate(stylesheet:
                                               RawServoStyleSheetBorrowed,
                                           loader: *mut Loader,
                                           gecko_stylesheet:
                                               *mut ServoStyleSheet,
                                           data: *const nsACString,
                                           extra_data:
                                               *mut RawGeckoURLExtraData,
                                           line_number_offset: u32,
                                           reusable_sheets:
                                               *mut LoaderReusableStyleSheets);
}
extern "C" {
    pub fn Servo_StyleSheet_HasRules(sheet: RawServoStyleSheetBorrowed)
     -> bool;
}
extern "C" {
    pub fn Servo_StyleSheet_GetRules(sheet: RawServoStyleSheetBorrowed)
     -> ServoCssRulesStrong;
}
extern "C" {
    pub fn Servo_StyleSheet_Clone(sheet: RawServoStyleSheetBorrowed)
     -> RawServoStyleSheetStrong;
}
extern "C" {
    pub fn Servo_StyleSheet_SizeOfIncludingThis(malloc_size_of: MallocSizeOf,
                                                sheet:
                                                    RawServoStyleSheetBorrowed)
     -> usize;
}
extern "C" {
    pub fn Servo_StyleSet_Init(pres_context: RawGeckoPresContextOwned)
     -> RawServoStyleSetOwned;
}
extern "C" {
    pub fn Servo_StyleSet_Clear(set: RawServoStyleSetBorrowed);
}
extern "C" {
    pub fn Servo_StyleSet_RebuildData(set: RawServoStyleSetBorrowed);
}
extern "C" {
    pub fn Servo_StyleSet_MediumFeaturesChanged(set: RawServoStyleSetBorrowed)
     -> bool;
}
extern "C" {
    pub fn Servo_StyleSet_AppendStyleSheet(set: RawServoStyleSetBorrowed,
                                           sheet: RawServoStyleSheetBorrowed,
                                           unique_id: u64);
}
extern "C" {
    pub fn Servo_StyleSet_PrependStyleSheet(set: RawServoStyleSetBorrowed,
                                            sheet: RawServoStyleSheetBorrowed,
                                            unique_id: u64);
}
extern "C" {
    pub fn Servo_StyleSet_RemoveStyleSheet(set: RawServoStyleSetBorrowed,
                                           unique_id: u64);
}
extern "C" {
    pub fn Servo_StyleSet_InsertStyleSheetBefore(set:
                                                     RawServoStyleSetBorrowed,
                                                 sheet:
                                                     RawServoStyleSheetBorrowed,
                                                 unique_id: u64,
                                                 before_unique_id: u64);
}
extern "C" {
    pub fn Servo_StyleSet_FlushStyleSheets(set: RawServoStyleSetBorrowed,
                                           doc_elem:
                                               RawGeckoElementBorrowedOrNull);
}
extern "C" {
    pub fn Servo_StyleSet_NoteStyleSheetsChanged(set:
                                                     RawServoStyleSetBorrowed,
                                                 author_style_disabled: bool);
}
extern "C" {
    pub fn Servo_StyleSet_GetKeyframesForName(set: RawServoStyleSetBorrowed,
                                              property: *const nsACString,
                                              timing_function:
                                                  nsTimingFunctionBorrowed,
                                              computed_values:
                                                  ServoComputedValuesBorrowed,
                                              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 nsIAtom)
     -> *mut nsCSSCounterStyleRule;
}
extern "C" {
    pub fn Servo_StyleSet_ResolveForDeclarations(set:
                                                     RawServoStyleSetBorrowed,
                                                 parent_style:
                                                     ServoComputedValuesBorrowedOrNull,
                                                 declarations:
                                                     RawServoDeclarationBlockBorrowed)
     -> ServoComputedValuesStrong;
}
extern "C" {
    pub fn Servo_CssRules_ListTypes(rules: ServoCssRulesBorrowed,
                                    result: nsTArrayBorrowed_uintptr_t);
}
extern "C" {
    pub fn Servo_CssRules_InsertRule(rules: ServoCssRulesBorrowed,
                                     sheet: RawServoStyleSheetBorrowed,
                                     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_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_GetSelectorTextFromIndex(rule:
                                                        RawServoStyleRuleBorrowed,
                                                    index: u32,
                                                    result: *mut nsAString);
}
extern "C" {
    pub fn Servo_StyleRule_GetSelectorCount(rule: RawServoStyleRuleBorrowed,
                                            count: *mut u32);
}
extern "C" {
    pub fn Servo_ImportRule_GetHref(rule: RawServoImportRuleBorrowed,
                                    result: *mut nsAString);
}
extern "C" {
    pub fn Servo_ImportRule_GetSheet(rule: RawServoImportRuleBorrowed)
     -> *const RawServoStyleSheet;
}
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 nsIAtom;
}
extern "C" {
    pub fn Servo_KeyframesRule_SetName(rule: RawServoKeyframesRuleBorrowed,
                                       name: *mut nsIAtom);
}
extern "C" {
    pub fn Servo_KeyframesRule_GetCount(rule: RawServoKeyframesRuleBorrowed)
     -> u32;
}
extern "C" {
    pub fn Servo_KeyframesRule_GetKeyframe(rule:
                                               RawServoKeyframesRuleBorrowed,
                                           index: 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: RawServoStyleSheetBorrowed,
                                          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 nsIAtom;
}
extern "C" {
    pub fn Servo_NamespaceRule_GetURI(rule: RawServoNamespaceRuleBorrowed)
     -> *mut nsIAtom;
}
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_ParseProperty(property: nsCSSPropertyID,
                               value: *const nsACString,
                               data: *mut RawGeckoURLExtraData,
                               parsing_mode: ParsingMode,
                               quirks_mode: nsCompatibility)
     -> 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: ServoComputedValuesBorrowed,
                                           set: RawServoStyleSetBorrowed,
                                           result:
                                               RawGeckoComputedKeyframeValuesListBorrowedMut);
}
extern "C" {
    pub fn Servo_AnimationValueMap_Push(arg1:
                                            RawServoAnimationValueMapBorrowedMut,
                                        property: nsCSSPropertyID,
                                        value:
                                            RawServoAnimationValueBorrowed);
}
extern "C" {
    pub fn Servo_ComputedValues_ExtractAnimationValue(computed_values:
                                                          ServoComputedValuesBorrowed,
                                                      property:
                                                          nsCSSPropertyID)
     -> RawServoAnimationValueStrong;
}
extern "C" {
    pub fn Servo_Property_IsAnimatable(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_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_AnimationValue_GetOpacity(value:
                                               RawServoAnimationValueBorrowed)
     -> f32;
}
extern "C" {
    pub fn Servo_AnimationValue_GetTransform(value:
                                                 RawServoAnimationValueBorrowed,
                                             list:
                                                 *mut RefPtr<nsCSSValueSharedList>);
}
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: ServoComputedValuesBorrowed,
                                        raw_data: RawServoStyleSetBorrowed)
     -> RawServoAnimationValueStrong;
}
extern "C" {
    pub fn Servo_ParseStyleAttribute(data: *const nsACString,
                                     extra_data: *mut RawGeckoURLExtraData,
                                     quirks_mode: nsCompatibility)
     -> 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);
}
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)
     -> 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)
     -> bool;
}
extern "C" {
    pub fn Servo_DeclarationBlock_RemoveProperty(declarations:
                                                     RawServoDeclarationBlockBorrowed,
                                                 property: *const nsACString);
}
extern "C" {
    pub fn Servo_DeclarationBlock_RemovePropertyById(declarations:
                                                         RawServoDeclarationBlockBorrowed,
                                                     property:
                                                         nsCSSPropertyID);
}
extern "C" {
    pub fn Servo_DeclarationBlock_HasCSSWideKeyword(declarations:
                                                        RawServoDeclarationBlockBorrowed,
                                                    property: nsCSSPropertyID)
     -> bool;
}
extern "C" {
    pub fn Servo_AnimationCompose(animation_values:
                                      RawServoAnimationValueMapBorrowedMut,
                                  base_values: *mut ::std::os::raw::c_void,
                                  property: nsCSSPropertyID,
                                  animation_segment:
                                      RawGeckoAnimationPropertySegmentBorrowed,
                                  last_segment:
                                      RawGeckoAnimationPropertySegmentBorrowed,
                                  computed_timing:
                                      RawGeckoComputedTimingBorrowed,
                                  iteration_composite:
                                      IterationCompositeOperation);
}
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 nsIAtom);
}
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);
}
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:
                                                       ServoComputedValuesBorrowedOrNull,
                                                   pseudo_tag: *mut nsIAtom,
                                                   skip_display_fixup: bool,
                                                   set:
                                                       RawServoStyleSetBorrowed)
     -> ServoComputedValuesStrong;
}
extern "C" {
    pub fn Servo_ComputedValues_Inherit(set: RawServoStyleSetBorrowed,
                                        parent_style:
                                            ServoComputedValuesBorrowedOrNull,
                                        target: InheritTarget)
     -> ServoComputedValuesStrong;
}
extern "C" {
    pub fn Servo_ComputedValues_GetVisitedStyle(values:
                                                    ServoComputedValuesBorrowed)
     -> ServoComputedValuesStrong;
}
extern "C" {
    pub fn Servo_Initialize(dummy_url_data: *mut RawGeckoURLExtraData);
}
extern "C" {
    pub fn Servo_Shutdown();
}
extern "C" {
    pub fn Servo_Element_GetStyleRuleList(element: RawGeckoElementBorrowed,
                                          rules:
                                              RawGeckoServoStyleRuleListBorrowedMut);
}
extern "C" {
    pub fn Servo_NoteExplicitHints(element: RawGeckoElementBorrowed,
                                   restyle_hint: nsRestyleHint,
                                   change_hint: nsChangeHint);
}
extern "C" {
    pub fn Servo_TakeChangeHint(element: RawGeckoElementBorrowed)
     -> nsChangeHint;
}
extern "C" {
    pub fn Servo_ResolveStyle(element: RawGeckoElementBorrowed,
                              set: RawServoStyleSetBorrowed,
                              allow_stale: bool) -> ServoComputedValuesStrong;
}
extern "C" {
    pub fn Servo_ResolvePseudoStyle(element: RawGeckoElementBorrowed,
                                    pseudo_type: CSSPseudoElementType,
                                    is_probe: bool,
                                    set: RawServoStyleSetBorrowed)
     -> ServoComputedValuesStrong;
}
extern "C" {
    pub fn Servo_HasAuthorSpecifiedRules(element: RawGeckoElementBorrowed,
                                         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)
     -> ServoComputedValuesStrong;
}
extern "C" {
    pub fn Servo_TraverseSubtree(root: RawGeckoElementBorrowed,
                                 set: RawServoStyleSetBorrowed,
                                 snapshots: *const ServoElementSnapshotTable,
                                 root_behavior: TraversalRootBehavior,
                                 restyle_behavior: TraversalRestyleBehavior)
     -> bool;
}
extern "C" {
    pub fn Servo_AssertTreeIsClean(root: RawGeckoElementBorrowed);
}
extern "C" {
    pub fn Servo_StyleSet_GetBaseComputedValuesForElement(set:
                                                              RawServoStyleSetBorrowed,
                                                          element:
                                                              RawGeckoElementBorrowed,
                                                          snapshots:
                                                              *const ServoElementSnapshotTable,
                                                          pseudo_type:
                                                              CSSPseudoElementType)
     -> ServoComputedValuesStrong;
}
extern "C" {
    pub fn Servo_SerializeFontValueForCanvas(declarations:
                                                 RawServoDeclarationBlockBorrowed,
                                             buffer: *mut nsAString);
}
extern "C" {
    pub fn Servo_GetStyleFont(computed_values:
                                  ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleFont;
}
extern "C" {
    pub fn Servo_GetStyleColor(computed_values:
                                   ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleColor;
}
extern "C" {
    pub fn Servo_GetStyleList(computed_values:
                                  ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleList;
}
extern "C" {
    pub fn Servo_GetStyleText(computed_values:
                                  ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleText;
}
extern "C" {
    pub fn Servo_GetStyleVisibility(computed_values:
                                        ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleVisibility;
}
extern "C" {
    pub fn Servo_GetStyleUserInterface(computed_values:
                                           ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleUserInterface;
}
extern "C" {
    pub fn Servo_GetStyleTableBorder(computed_values:
                                         ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleTableBorder;
}
extern "C" {
    pub fn Servo_GetStyleSVG(computed_values:
                                 ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleSVG;
}
extern "C" {
    pub fn Servo_GetStyleVariables(computed_values:
                                       ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleVariables;
}
extern "C" {
    pub fn Servo_GetStyleBackground(computed_values:
                                        ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleBackground;
}
extern "C" {
    pub fn Servo_GetStylePosition(computed_values:
                                      ServoComputedValuesBorrowedOrNull)
     -> *const nsStylePosition;
}
extern "C" {
    pub fn Servo_GetStyleTextReset(computed_values:
                                       ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleTextReset;
}
extern "C" {
    pub fn Servo_GetStyleDisplay(computed_values:
                                     ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleDisplay;
}
extern "C" {
    pub fn Servo_GetStyleContent(computed_values:
                                     ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleContent;
}
extern "C" {
    pub fn Servo_GetStyleUIReset(computed_values:
                                     ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleUIReset;
}
extern "C" {
    pub fn Servo_GetStyleTable(computed_values:
                                   ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleTable;
}
extern "C" {
    pub fn Servo_GetStyleMargin(computed_values:
                                    ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleMargin;
}
extern "C" {
    pub fn Servo_GetStylePadding(computed_values:
                                     ServoComputedValuesBorrowedOrNull)
     -> *const nsStylePadding;
}
extern "C" {
    pub fn Servo_GetStyleBorder(computed_values:
                                    ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleBorder;
}
extern "C" {
    pub fn Servo_GetStyleOutline(computed_values:
                                     ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleOutline;
}
extern "C" {
    pub fn Servo_GetStyleXUL(computed_values:
                                 ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleXUL;
}
extern "C" {
    pub fn Servo_GetStyleSVGReset(computed_values:
                                      ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleSVGReset;
}
extern "C" {
    pub fn Servo_GetStyleColumn(computed_values:
                                    ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleColumn;
}
extern "C" {
    pub fn Servo_GetStyleEffects(computed_values:
                                     ServoComputedValuesBorrowedOrNull)
     -> *const nsStyleEffects;
}