/* automatically generated by rust-bindgen */

pub type va_list = __builtin_va_list;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum YGAlign {
    YGAlignAuto = 0,
    YGAlignFlexStart = 1,
    YGAlignCenter = 2,
    YGAlignFlexEnd = 3,
    YGAlignStretch = 4,
    YGAlignBaseline = 5,
    YGAlignSpaceBetween = 6,
    YGAlignSpaceAround = 7,
}
extern "C" {
    pub fn YGAlignToString(value: YGAlign) -> *const ::std::os::raw::c_char;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum YGDimension {
    YGDimensionWidth = 0,
    YGDimensionHeight = 1,
}
extern "C" {
    pub fn YGDimensionToString(value: YGDimension) -> *const ::std::os::raw::c_char;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum YGDirection {
    YGDirectionInherit = 0,
    YGDirectionLTR = 1,
    YGDirectionRTL = 2,
}
extern "C" {
    pub fn YGDirectionToString(value: YGDirection) -> *const ::std::os::raw::c_char;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum YGDisplay {
    YGDisplayFlex = 0,
    YGDisplayNone = 1,
}
extern "C" {
    pub fn YGDisplayToString(value: YGDisplay) -> *const ::std::os::raw::c_char;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum YGEdge {
    YGEdgeLeft = 0,
    YGEdgeTop = 1,
    YGEdgeRight = 2,
    YGEdgeBottom = 3,
    YGEdgeStart = 4,
    YGEdgeEnd = 5,
    YGEdgeHorizontal = 6,
    YGEdgeVertical = 7,
    YGEdgeAll = 8,
}
extern "C" {
    pub fn YGEdgeToString(value: YGEdge) -> *const ::std::os::raw::c_char;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum YGExperimentalFeature {
    YGExperimentalFeatureWebFlexBasis = 0,
}
extern "C" {
    pub fn YGExperimentalFeatureToString(
        value: YGExperimentalFeature,
    ) -> *const ::std::os::raw::c_char;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum YGFlexDirection {
    YGFlexDirectionColumn = 0,
    YGFlexDirectionColumnReverse = 1,
    YGFlexDirectionRow = 2,
    YGFlexDirectionRowReverse = 3,
}
extern "C" {
    pub fn YGFlexDirectionToString(value: YGFlexDirection) -> *const ::std::os::raw::c_char;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum YGJustify {
    YGJustifyFlexStart = 0,
    YGJustifyCenter = 1,
    YGJustifyFlexEnd = 2,
    YGJustifySpaceBetween = 3,
    YGJustifySpaceAround = 4,
}
extern "C" {
    pub fn YGJustifyToString(value: YGJustify) -> *const ::std::os::raw::c_char;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum YGLogLevel {
    YGLogLevelError = 0,
    YGLogLevelWarn = 1,
    YGLogLevelInfo = 2,
    YGLogLevelDebug = 3,
    YGLogLevelVerbose = 4,
    YGLogLevelFatal = 5,
}
extern "C" {
    pub fn YGLogLevelToString(value: YGLogLevel) -> *const ::std::os::raw::c_char;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum YGMeasureMode {
    YGMeasureModeUndefined = 0,
    YGMeasureModeExactly = 1,
    YGMeasureModeAtMost = 2,
}
extern "C" {
    pub fn YGMeasureModeToString(value: YGMeasureMode) -> *const ::std::os::raw::c_char;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum YGNodeType {
    YGNodeTypeDefault = 0,
    YGNodeTypeText = 1,
}
extern "C" {
    pub fn YGNodeTypeToString(value: YGNodeType) -> *const ::std::os::raw::c_char;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum YGOverflow {
    YGOverflowVisible = 0,
    YGOverflowHidden = 1,
    YGOverflowScroll = 2,
}
extern "C" {
    pub fn YGOverflowToString(value: YGOverflow) -> *const ::std::os::raw::c_char;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum YGPositionType {
    YGPositionTypeRelative = 0,
    YGPositionTypeAbsolute = 1,
}
extern "C" {
    pub fn YGPositionTypeToString(value: YGPositionType) -> *const ::std::os::raw::c_char;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum YGPrintOptions {
    YGPrintOptionsLayout = 1,
    YGPrintOptionsStyle = 2,
    YGPrintOptionsChildren = 4,
}
extern "C" {
    pub fn YGPrintOptionsToString(value: YGPrintOptions) -> *const ::std::os::raw::c_char;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum YGUnit {
    YGUnitUndefined = 0,
    YGUnitPoint = 1,
    YGUnitPercent = 2,
    YGUnitAuto = 3,
}
extern "C" {
    pub fn YGUnitToString(value: YGUnit) -> *const ::std::os::raw::c_char;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum YGWrap {
    YGWrapNoWrap = 0,
    YGWrapWrap = 1,
    YGWrapWrapReverse = 2,
}
extern "C" {
    pub fn YGWrapToString(value: YGWrap) -> *const ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct YGSize {
    pub width: f32,
    pub height: f32,
}
#[test]
fn bindgen_test_layout_YGSize() {
    assert_eq!(
        ::std::mem::size_of::<YGSize>(),
        8usize,
        concat!("Size of: ", stringify!(YGSize))
    );
    assert_eq!(
        ::std::mem::align_of::<YGSize>(),
        4usize,
        concat!("Alignment of ", stringify!(YGSize))
    );
    assert_eq!(
        unsafe { &(*(0 as *const YGSize)).width as *const _ as usize },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(YGSize),
            "::",
            stringify!(width)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const YGSize)).height as *const _ as usize },
        4usize,
        concat!(
            "Alignment of field: ",
            stringify!(YGSize),
            "::",
            stringify!(height)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct YGValue {
    pub value: f32,
    pub unit: YGUnit,
}
#[test]
fn bindgen_test_layout_YGValue() {
    assert_eq!(
        ::std::mem::size_of::<YGValue>(),
        8usize,
        concat!("Size of: ", stringify!(YGValue))
    );
    assert_eq!(
        ::std::mem::align_of::<YGValue>(),
        4usize,
        concat!("Alignment of ", stringify!(YGValue))
    );
    assert_eq!(
        unsafe { &(*(0 as *const YGValue)).value as *const _ as usize },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(YGValue),
            "::",
            stringify!(value)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const YGValue)).unit as *const _ as usize },
        4usize,
        concat!(
            "Alignment of field: ",
            stringify!(YGValue),
            "::",
            stringify!(unit)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct YGConfig {
    _unused: [u8; 0],
}
pub type YGConfigRef = *mut YGConfig;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct YGNode {
    _unused: [u8; 0],
}
pub type YGNodeRef = *mut YGNode;
pub type YGMeasureFunc = ::std::option::Option<
    unsafe extern "C" fn(node: YGNodeRef,
                         width: f32,
                         widthMode: YGMeasureMode,
                         height: f32,
                         heightMode: YGMeasureMode)
                         -> YGSize,
>;
pub type YGBaselineFunc = ::std::option::Option<
    unsafe extern "C" fn(node: YGNodeRef,
                         width: f32,
                         height: f32)
                         -> f32,
>;
pub type YGPrintFunc = ::std::option::Option<unsafe extern "C" fn(node: YGNodeRef)>;
pub type YGLogger =
    ::std::option::Option<
        unsafe extern "C" fn(config: YGConfigRef,
                             node: YGNodeRef,
                             level: YGLogLevel,
                             format: *const ::std::os::raw::c_char,
                             args: *mut __va_list_tag)
                             -> ::std::os::raw::c_int,
    >;
pub type YGNodeClonedFunc =
    ::std::option::Option<
        unsafe extern "C" fn(oldNode: YGNodeRef,
                             newNode: YGNodeRef,
                             parent: YGNodeRef,
                             childIndex: ::std::os::raw::c_int),
    >;
extern "C" {
    pub fn YGNodeNew() -> YGNodeRef;
}
extern "C" {
    pub fn YGNodeNewWithConfig(config: YGConfigRef) -> YGNodeRef;
}
extern "C" {
    pub fn YGNodeClone(node: YGNodeRef) -> YGNodeRef;
}
extern "C" {
    pub fn YGNodeFree(node: YGNodeRef);
}
extern "C" {
    pub fn YGNodeFreeRecursive(node: YGNodeRef);
}
extern "C" {
    pub fn YGNodeReset(node: YGNodeRef);
}
extern "C" {
    pub fn YGNodeGetInstanceCount() -> i32;
}
extern "C" {
    pub fn YGNodeInsertChild(node: YGNodeRef, child: YGNodeRef, index: u32);
}
extern "C" {
    pub fn YGNodeRemoveChild(node: YGNodeRef, child: YGNodeRef);
}
extern "C" {
    pub fn YGNodeRemoveAllChildren(node: YGNodeRef);
}
extern "C" {
    pub fn YGNodeGetChild(node: YGNodeRef, index: u32) -> YGNodeRef;
}
extern "C" {
    pub fn YGNodeGetParent(node: YGNodeRef) -> YGNodeRef;
}
extern "C" {
    pub fn YGNodeGetChildCount(node: YGNodeRef) -> u32;
}
extern "C" {
    pub fn YGNodeCalculateLayout(
        node: YGNodeRef,
        availableWidth: f32,
        availableHeight: f32,
        parentDirection: YGDirection,
    );
}
extern "C" {
    pub fn YGNodeMarkDirty(node: YGNodeRef);
}
extern "C" {
    pub fn YGNodeIsDirty(node: YGNodeRef) -> bool;
}
extern "C" {
    pub fn YGNodePrint(node: YGNodeRef, options: YGPrintOptions);
}
extern "C" {
    pub fn YGFloatIsUndefined(value: f32) -> bool;
}
extern "C" {
    pub fn YGNodeCanUseCachedMeasurement(
        widthMode: YGMeasureMode,
        width: f32,
        heightMode: YGMeasureMode,
        height: f32,
        lastWidthMode: YGMeasureMode,
        lastWidth: f32,
        lastHeightMode: YGMeasureMode,
        lastHeight: f32,
        lastComputedWidth: f32,
        lastComputedHeight: f32,
        marginRow: f32,
        marginColumn: f32,
        config: YGConfigRef,
    ) -> bool;
}
extern "C" {
    pub fn YGNodeCopyStyle(dstNode: YGNodeRef, srcNode: YGNodeRef);
}
extern "C" {
    pub fn YGNodeSetContext(node: YGNodeRef, context: *mut ::std::os::raw::c_void);
}
extern "C" {
    pub fn YGNodeGetContext(node: YGNodeRef) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn YGNodeSetMeasureFunc(node: YGNodeRef, measureFunc: YGMeasureFunc);
}
extern "C" {
    pub fn YGNodeGetMeasureFunc(node: YGNodeRef) -> YGMeasureFunc;
}
extern "C" {
    pub fn YGNodeSetBaselineFunc(node: YGNodeRef, baselineFunc: YGBaselineFunc);
}
extern "C" {
    pub fn YGNodeGetBaselineFunc(node: YGNodeRef) -> YGBaselineFunc;
}
extern "C" {
    pub fn YGNodeSetPrintFunc(node: YGNodeRef, printFunc: YGPrintFunc);
}
extern "C" {
    pub fn YGNodeGetPrintFunc(node: YGNodeRef) -> YGPrintFunc;
}
extern "C" {
    pub fn YGNodeSetHasNewLayout(node: YGNodeRef, hasNewLayout: bool);
}
extern "C" {
    pub fn YGNodeGetHasNewLayout(node: YGNodeRef) -> bool;
}
extern "C" {
    pub fn YGNodeSetNodeType(node: YGNodeRef, nodeType: YGNodeType);
}
extern "C" {
    pub fn YGNodeGetNodeType(node: YGNodeRef) -> YGNodeType;
}
extern "C" {
    pub fn YGNodeStyleSetDirection(node: YGNodeRef, direction: YGDirection);
}
extern "C" {
    pub fn YGNodeStyleGetDirection(node: YGNodeRef) -> YGDirection;
}
extern "C" {
    pub fn YGNodeStyleSetFlexDirection(node: YGNodeRef, flexDirection: YGFlexDirection);
}
extern "C" {
    pub fn YGNodeStyleGetFlexDirection(node: YGNodeRef) -> YGFlexDirection;
}
extern "C" {
    pub fn YGNodeStyleSetJustifyContent(node: YGNodeRef, justifyContent: YGJustify);
}
extern "C" {
    pub fn YGNodeStyleGetJustifyContent(node: YGNodeRef) -> YGJustify;
}
extern "C" {
    pub fn YGNodeStyleSetAlignContent(node: YGNodeRef, alignContent: YGAlign);
}
extern "C" {
    pub fn YGNodeStyleGetAlignContent(node: YGNodeRef) -> YGAlign;
}
extern "C" {
    pub fn YGNodeStyleSetAlignItems(node: YGNodeRef, alignItems: YGAlign);
}
extern "C" {
    pub fn YGNodeStyleGetAlignItems(node: YGNodeRef) -> YGAlign;
}
extern "C" {
    pub fn YGNodeStyleSetAlignSelf(node: YGNodeRef, alignSelf: YGAlign);
}
extern "C" {
    pub fn YGNodeStyleGetAlignSelf(node: YGNodeRef) -> YGAlign;
}
extern "C" {
    pub fn YGNodeStyleSetPositionType(node: YGNodeRef, positionType: YGPositionType);
}
extern "C" {
    pub fn YGNodeStyleGetPositionType(node: YGNodeRef) -> YGPositionType;
}
extern "C" {
    pub fn YGNodeStyleSetFlexWrap(node: YGNodeRef, flexWrap: YGWrap);
}
extern "C" {
    pub fn YGNodeStyleGetFlexWrap(node: YGNodeRef) -> YGWrap;
}
extern "C" {
    pub fn YGNodeStyleSetOverflow(node: YGNodeRef, overflow: YGOverflow);
}
extern "C" {
    pub fn YGNodeStyleGetOverflow(node: YGNodeRef) -> YGOverflow;
}
extern "C" {
    pub fn YGNodeStyleSetDisplay(node: YGNodeRef, display: YGDisplay);
}
extern "C" {
    pub fn YGNodeStyleGetDisplay(node: YGNodeRef) -> YGDisplay;
}
extern "C" {
    pub fn YGNodeStyleSetFlex(node: YGNodeRef, flex: f32);
}
extern "C" {
    pub fn YGNodeStyleGetFlex(node: YGNodeRef) -> f32;
}
extern "C" {
    pub fn YGNodeStyleSetFlexGrow(node: YGNodeRef, flexGrow: f32);
}
extern "C" {
    pub fn YGNodeStyleGetFlexGrow(node: YGNodeRef) -> f32;
}
extern "C" {
    pub fn YGNodeStyleSetFlexShrink(node: YGNodeRef, flexShrink: f32);
}
extern "C" {
    pub fn YGNodeStyleGetFlexShrink(node: YGNodeRef) -> f32;
}
extern "C" {
    pub fn YGNodeStyleSetFlexBasis(node: YGNodeRef, flexBasis: f32);
}
extern "C" {
    pub fn YGNodeStyleSetFlexBasisPercent(node: YGNodeRef, flexBasis: f32);
}
extern "C" {
    pub fn YGNodeStyleGetFlexBasis(node: YGNodeRef) -> YGValue;
}
extern "C" {
    pub fn YGNodeStyleSetFlexBasisAuto(node: YGNodeRef);
}
extern "C" {
    pub fn YGNodeStyleSetPosition(node: YGNodeRef, edge: YGEdge, position: f32);
}
extern "C" {
    pub fn YGNodeStyleSetPositionPercent(node: YGNodeRef, edge: YGEdge, position: f32);
}
extern "C" {
    pub fn YGNodeStyleGetPosition(node: YGNodeRef, edge: YGEdge) -> YGValue;
}
extern "C" {
    pub fn YGNodeStyleSetMargin(node: YGNodeRef, edge: YGEdge, margin: f32);
}
extern "C" {
    pub fn YGNodeStyleSetMarginPercent(node: YGNodeRef, edge: YGEdge, margin: f32);
}
extern "C" {
    pub fn YGNodeStyleGetMargin(node: YGNodeRef, edge: YGEdge) -> YGValue;
}
extern "C" {
    pub fn YGNodeStyleSetMarginAuto(node: YGNodeRef, edge: YGEdge);
}
extern "C" {
    pub fn YGNodeStyleSetPadding(node: YGNodeRef, edge: YGEdge, padding: f32);
}
extern "C" {
    pub fn YGNodeStyleSetPaddingPercent(node: YGNodeRef, edge: YGEdge, padding: f32);
}
extern "C" {
    pub fn YGNodeStyleGetPadding(node: YGNodeRef, edge: YGEdge) -> YGValue;
}
extern "C" {
    pub fn YGNodeStyleSetBorder(node: YGNodeRef, edge: YGEdge, border: f32);
}
extern "C" {
    pub fn YGNodeStyleGetBorder(node: YGNodeRef, edge: YGEdge) -> f32;
}
extern "C" {
    pub fn YGNodeStyleSetWidth(node: YGNodeRef, width: f32);
}
extern "C" {
    pub fn YGNodeStyleSetWidthPercent(node: YGNodeRef, width: f32);
}
extern "C" {
    pub fn YGNodeStyleGetWidth(node: YGNodeRef) -> YGValue;
}
extern "C" {
    pub fn YGNodeStyleSetWidthAuto(node: YGNodeRef);
}
extern "C" {
    pub fn YGNodeStyleSetHeight(node: YGNodeRef, height: f32);
}
extern "C" {
    pub fn YGNodeStyleSetHeightPercent(node: YGNodeRef, height: f32);
}
extern "C" {
    pub fn YGNodeStyleGetHeight(node: YGNodeRef) -> YGValue;
}
extern "C" {
    pub fn YGNodeStyleSetHeightAuto(node: YGNodeRef);
}
extern "C" {
    pub fn YGNodeStyleSetMinWidth(node: YGNodeRef, minWidth: f32);
}
extern "C" {
    pub fn YGNodeStyleSetMinWidthPercent(node: YGNodeRef, minWidth: f32);
}
extern "C" {
    pub fn YGNodeStyleGetMinWidth(node: YGNodeRef) -> YGValue;
}
extern "C" {
    pub fn YGNodeStyleSetMinHeight(node: YGNodeRef, minHeight: f32);
}
extern "C" {
    pub fn YGNodeStyleSetMinHeightPercent(node: YGNodeRef, minHeight: f32);
}
extern "C" {
    pub fn YGNodeStyleGetMinHeight(node: YGNodeRef) -> YGValue;
}
extern "C" {
    pub fn YGNodeStyleSetMaxWidth(node: YGNodeRef, maxWidth: f32);
}
extern "C" {
    pub fn YGNodeStyleSetMaxWidthPercent(node: YGNodeRef, maxWidth: f32);
}
extern "C" {
    pub fn YGNodeStyleGetMaxWidth(node: YGNodeRef) -> YGValue;
}
extern "C" {
    pub fn YGNodeStyleSetMaxHeight(node: YGNodeRef, maxHeight: f32);
}
extern "C" {
    pub fn YGNodeStyleSetMaxHeightPercent(node: YGNodeRef, maxHeight: f32);
}
extern "C" {
    pub fn YGNodeStyleGetMaxHeight(node: YGNodeRef) -> YGValue;
}
extern "C" {
    pub fn YGNodeStyleSetAspectRatio(node: YGNodeRef, aspectRatio: f32);
}
extern "C" {
    pub fn YGNodeStyleGetAspectRatio(node: YGNodeRef) -> f32;
}
extern "C" {
    pub fn YGNodeLayoutGetLeft(node: YGNodeRef) -> f32;
}
extern "C" {
    pub fn YGNodeLayoutGetTop(node: YGNodeRef) -> f32;
}
extern "C" {
    pub fn YGNodeLayoutGetRight(node: YGNodeRef) -> f32;
}
extern "C" {
    pub fn YGNodeLayoutGetBottom(node: YGNodeRef) -> f32;
}
extern "C" {
    pub fn YGNodeLayoutGetWidth(node: YGNodeRef) -> f32;
}
extern "C" {
    pub fn YGNodeLayoutGetHeight(node: YGNodeRef) -> f32;
}
extern "C" {
    pub fn YGNodeLayoutGetDirection(node: YGNodeRef) -> YGDirection;
}
extern "C" {
    pub fn YGNodeLayoutGetHadOverflow(node: YGNodeRef) -> bool;
}
extern "C" {
    pub fn YGNodeLayoutGetMargin(node: YGNodeRef, edge: YGEdge) -> f32;
}
extern "C" {
    pub fn YGNodeLayoutGetBorder(node: YGNodeRef, edge: YGEdge) -> f32;
}
extern "C" {
    pub fn YGNodeLayoutGetPadding(node: YGNodeRef, edge: YGEdge) -> f32;
}
extern "C" {
    pub fn YGConfigSetLogger(config: YGConfigRef, logger: YGLogger);
}
extern "C" {
    pub fn YGLog(node: YGNodeRef, level: YGLogLevel, message: *const ::std::os::raw::c_char, ...);
}
extern "C" {
    pub fn YGLogWithConfig(
        config: YGConfigRef,
        level: YGLogLevel,
        format: *const ::std::os::raw::c_char,
        ...
    );
}
extern "C" {
    pub fn YGAssert(condition: bool, message: *const ::std::os::raw::c_char);
}
extern "C" {
    pub fn YGAssertWithNode(
        node: YGNodeRef,
        condition: bool,
        message: *const ::std::os::raw::c_char,
    );
}
extern "C" {
    pub fn YGAssertWithConfig(
        config: YGConfigRef,
        condition: bool,
        message: *const ::std::os::raw::c_char,
    );
}
extern "C" {
    pub fn YGConfigSetPointScaleFactor(config: YGConfigRef, pixelsInPoint: f32);
}
extern "C" {
    pub fn YGConfigSetUseLegacyStretchBehaviour(
        config: YGConfigRef,
        useLegacyStretchBehaviour: bool,
    );
}
extern "C" {
    pub fn YGConfigNew() -> YGConfigRef;
}
extern "C" {
    pub fn YGConfigFree(config: YGConfigRef);
}
extern "C" {
    pub fn YGConfigCopy(dest: YGConfigRef, src: YGConfigRef);
}
extern "C" {
    pub fn YGConfigGetInstanceCount() -> i32;
}
extern "C" {
    pub fn YGConfigSetExperimentalFeatureEnabled(
        config: YGConfigRef,
        feature: YGExperimentalFeature,
        enabled: bool,
    );
}
extern "C" {
    pub fn YGConfigIsExperimentalFeatureEnabled(
        config: YGConfigRef,
        feature: YGExperimentalFeature,
    ) -> bool;
}
extern "C" {
    pub fn YGConfigSetUseWebDefaults(config: YGConfigRef, enabled: bool);
}
extern "C" {
    pub fn YGConfigGetUseWebDefaults(config: YGConfigRef) -> bool;
}
extern "C" {
    pub fn YGConfigSetNodeClonedFunc(config: YGConfigRef, callback: YGNodeClonedFunc);
}
extern "C" {
    pub fn YGConfigGetDefault() -> YGConfigRef;
}
extern "C" {
    pub fn YGConfigSetContext(config: YGConfigRef, context: *mut ::std::os::raw::c_void);
}
extern "C" {
    pub fn YGConfigGetContext(config: YGConfigRef) -> *mut ::std::os::raw::c_void;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct YGNodeList {
    _unused: [u8; 0],
}
pub type YGNodeListRef = *mut YGNodeList;
extern "C" {
    pub fn YGNodeListNew(initialCapacity: u32) -> YGNodeListRef;
}
extern "C" {
    pub fn YGNodeListFree(list: YGNodeListRef);
}
extern "C" {
    pub fn YGNodeListCount(list: YGNodeListRef) -> u32;
}
extern "C" {
    pub fn YGNodeListAdd(listp: *mut YGNodeListRef, node: YGNodeRef);
}
extern "C" {
    pub fn YGNodeListInsert(listp: *mut YGNodeListRef, node: YGNodeRef, index: u32);
}
extern "C" {
    pub fn YGNodeListReplace(list: YGNodeListRef, index: u32, newNode: YGNodeRef);
}
extern "C" {
    pub fn YGNodeListRemoveAll(list: YGNodeListRef);
}
extern "C" {
    pub fn YGNodeListRemove(list: YGNodeListRef, index: u32) -> YGNodeRef;
}
extern "C" {
    pub fn YGNodeListDelete(list: YGNodeListRef, node: YGNodeRef) -> YGNodeRef;
}
extern "C" {
    pub fn YGNodeListGet(list: YGNodeListRef, index: u32) -> YGNodeRef;
}
extern "C" {
    pub fn YGNodeListClone(list: YGNodeListRef) -> YGNodeListRef;
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list_tag {
    pub gp_offset: ::std::os::raw::c_uint,
    pub fp_offset: ::std::os::raw::c_uint,
    pub overflow_arg_area: *mut ::std::os::raw::c_void,
    pub reg_save_area: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout___va_list_tag() {
    assert_eq!(
        ::std::mem::size_of::<__va_list_tag>(),
        24usize,
        concat!("Size of: ", stringify!(__va_list_tag))
    );
    assert_eq!(
        ::std::mem::align_of::<__va_list_tag>(),
        8usize,
        concat!("Alignment of ", stringify!(__va_list_tag))
    );
    assert_eq!(
        unsafe { &(*(0 as *const __va_list_tag)).gp_offset as *const _ as usize },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(gp_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const __va_list_tag)).fp_offset as *const _ as usize },
        4usize,
        concat!(
            "Alignment of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(fp_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const __va_list_tag)).overflow_arg_area as *const _ as usize },
        8usize,
        concat!(
            "Alignment of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(overflow_arg_area)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const __va_list_tag)).reg_save_area as *const _ as usize },
        16usize,
        concat!(
            "Alignment of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(reg_save_area)
        )
    );
}