/* automatically generated by rust-bindgen */

pub type ChakraCookie = usize;
pub type ChakraBytePtr = *mut libc::c_uchar;
pub type BYTE = libc::c_uchar;
pub type byte = BYTE;
#[repr(u32)]
/// <summary>
    ///     An error code returned from a Chakra hosting API.
    /// </summary>
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _JsErrorCode {
    NoError = 0,
    CategoryUsage = 65536,
    InvalidArgument = 65537,
    NullArgument = 65538,
    NoCurrentContext = 65539,
    InExceptionState = 65540,
    NotImplemented = 65541,
    WrongThread = 65542,
    RuntimeInUse = 65543,
    BadSerializedScript = 65544,
    InDisabledState = 65545,
    CannotDisableExecution = 65546,
    HeapEnumInProgress = 65547,
    ArgumentNotObject = 65548,
    InProfileCallback = 65549,
    InThreadServiceCallback = 65550,
    CannotSerializeDebugScript = 65551,
    AlreadyDebuggingContext = 65552,
    AlreadyProfilingContext = 65553,
    IdleNotEnabled = 65554,
    CannotSetProjectionEnqueueCallback = 65555,
    CannotStartProjection = 65556,
    InObjectBeforeCollectCallback = 65557,
    ObjectNotInspectable = 65558,
    PropertyNotSymbol = 65559,
    PropertyNotString = 65560,
    InvalidContext = 65561,
    InvalidModuleHostInfoKind = 65562,
    ModuleParsed = 65563,
    ModuleEvaluated = 65564,
    CategoryEngine = 131072,
    OutOfMemory = 131073,
    BadFPUState = 131074,
    CategoryScript = 196608,
    ScriptException = 196609,
    ScriptCompile = 196610,
    ScriptTerminated = 196611,
    ScriptEvalDisabled = 196612,
    CategoryFatal = 262144,
    Fatal = 262145,
    WrongRuntime = 262146,
    CategoryDiagError = 327680,
    DiagAlreadyInDebugMode = 327681,
    DiagNotInDebugMode = 327682,
    DiagNotAtBreak = 327683,
    DiagInvalidHandle = 327684,
    DiagObjectNotFound = 327685,
    DiagUnableToPerformAction = 327686,
}
pub use self::_JsErrorCode as JsErrorCode;
/// <summary>
    ///     A handle to a Chakra runtime.
    /// </summary>
    /// <remarks>
    ///     <para>
    ///     Each Chakra runtime has its own independent execution engine, JIT compiler, and garbage
    ///     collected heap. As such, each runtime is completely isolated from other runtimes.
    ///     </para>
    ///     <para>
    ///     Runtimes can be used on any thread, but only one thread can call into a runtime at any
    ///     time.
    ///     </para>
    ///     <para>
    ///     NOTE: A <c>JsRuntimeHandle</c>, unlike other object references in the Chakra hosting API,
    ///     is not garbage collected since it contains the garbage collected heap itself. A runtime
    ///     will continue to exist until <c>JsDisposeRuntime</c> is called.
    ///     </para>
    /// </remarks>
#[repr(C)]
#[derive(Eq, PartialEq, Copy, Clone, Debug)]
pub struct JsRuntimeHandle(pub *mut libc::c_void);
impl JsRuntimeHandle {
pub fn new() -> Self { JsRuntimeHandle(::std::ptr::null_mut()) }
}
/// <summary>
    ///     A reference to an object owned by the Chakra garbage collector.
    /// </summary>
    /// <remarks>
    ///     A Chakra runtime will automatically track <c>JsRef</c> references as long as they are
    ///     stored in local variables or in parameters (i.e. on the stack). Storing a <c>JsRef</c>
    ///     somewhere other than on the stack requires calling <c>JsAddRef</c> and <c>JsRelease</c> to
    ///     manage the lifetime of the object, otherwise the garbage collector may free the object
    ///     while it is still in use.
    /// </remarks>
#[repr(C)]
#[derive(Eq, PartialEq, Copy, Clone, Debug)]
pub struct JsRef(pub *mut libc::c_void);
impl JsRef {
pub fn new() -> Self { JsRef(::std::ptr::null_mut()) }
}
/// <summary>
    ///     A reference to a script context.
    /// </summary>
    /// <remarks>
    ///     <para>
    ///     Each script context contains its own global object, distinct from the global object in
    ///     other script contexts.
    ///     </para>
    ///     <para>
    ///     Many Chakra hosting APIs require an "active" script context, which can be set using
    ///     <c>JsSetCurrentContext</c>. Chakra hosting APIs that require a current context to be set
    ///     will note that explicitly in their documentation.
    ///     </para>
    /// </remarks>
pub type JsContextRef = JsRef;
/// <summary>
    ///     A reference to a JavaScript value.
    /// </summary>
    /// <remarks>
    ///     A JavaScript value is one of the following types of values: undefined, null, Boolean,
    ///     string, number, or object.
    /// </remarks>
pub type JsValueRef = JsRef;
/// <summary>
    ///     A cookie that identifies a script for debugging purposes.
    /// </summary>
pub type JsSourceContext = ChakraCookie;
/// <summary>
    ///     A property identifier.
    /// </summary>
    /// <remarks>
    ///     Property identifiers are used to refer to properties of JavaScript objects instead of using
    ///     strings.
    /// </remarks>
pub type JsPropertyIdRef = JsRef;
pub const JsRuntimeAttributeNone: _JsRuntimeAttributes =
    _JsRuntimeAttributes(0);
pub const JsRuntimeAttributeDisableBackgroundWork:
          _JsRuntimeAttributes =
    _JsRuntimeAttributes(1);
pub const JsRuntimeAttributeAllowScriptInterrupt:
          _JsRuntimeAttributes =
    _JsRuntimeAttributes(2);
pub const JsRuntimeAttributeEnableIdleProcessing:
          _JsRuntimeAttributes =
    _JsRuntimeAttributes(4);
pub const JsRuntimeAttributeDisableNativeCodeGeneration:
          _JsRuntimeAttributes =
    _JsRuntimeAttributes(8);
pub const JsRuntimeAttributeDisableEval:
          _JsRuntimeAttributes =
    _JsRuntimeAttributes(16);
pub const JsRuntimeAttributeEnableExperimentalFeatures:
          _JsRuntimeAttributes =
    _JsRuntimeAttributes(32);
pub const JsRuntimeAttributeDispatchSetExceptionsToDebugger:
          _JsRuntimeAttributes =
    _JsRuntimeAttributes(64);
impl ::std::ops::BitOr<_JsRuntimeAttributes> for _JsRuntimeAttributes {
    type
    Output
    =
    Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        _JsRuntimeAttributes(self.0 | other.0)
    }
}
impl ::std::ops::BitOrAssign for _JsRuntimeAttributes {
    #[inline]
    fn bitor_assign(&mut self, rhs: _JsRuntimeAttributes) { self.0 |= rhs.0; }
}
impl ::std::ops::BitAnd<_JsRuntimeAttributes> for _JsRuntimeAttributes {
    type
    Output
    =
    Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        _JsRuntimeAttributes(self.0 & other.0)
    }
}
impl ::std::ops::BitAndAssign for _JsRuntimeAttributes {
    #[inline]
    fn bitand_assign(&mut self, rhs: _JsRuntimeAttributes) {
        self.0 &= rhs.0;
    }
}
#[repr(C)]
/// <summary>
    ///     Attributes of a runtime.
    /// </summary>
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct _JsRuntimeAttributes(pub libc::c_uint);
pub use self::_JsRuntimeAttributes as JsRuntimeAttributes;
#[repr(u32)]
/// <summary>
    ///     The type of a typed JavaScript array.
    /// </summary>
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _JsTypedArrayType {
    Int8 = 0,
    Uint8 = 1,
    Uint8Clamped = 2,
    Int16 = 3,
    Uint16 = 4,
    Int32 = 5,
    Uint32 = 6,
    Float32 = 7,
    Float64 = 8,
}
pub use self::_JsTypedArrayType as JsTypedArrayType;
#[repr(u32)]
/// <summary>
    ///     Allocation callback event type.
    /// </summary>
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _JsMemoryEventType {
    Allocate = 0,
    Free = 1,
    Failure = 2,
}
pub use self::_JsMemoryEventType as JsMemoryEventType;
pub const JsParseScriptAttributeNone:
          _JsParseScriptAttributes =
    _JsParseScriptAttributes(0);
pub const JsParseScriptAttributeLibraryCode:
          _JsParseScriptAttributes =
    _JsParseScriptAttributes(1);
pub const JsParseScriptAttributeArrayBufferIsUtf16Encoded:
          _JsParseScriptAttributes =
    _JsParseScriptAttributes(2);
impl ::std::ops::BitOr<_JsParseScriptAttributes> for _JsParseScriptAttributes
 {
    type
    Output
    =
    Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        _JsParseScriptAttributes(self.0 | other.0)
    }
}
impl ::std::ops::BitOrAssign for _JsParseScriptAttributes {
    #[inline]
    fn bitor_assign(&mut self, rhs: _JsParseScriptAttributes) {
        self.0 |= rhs.0;
    }
}
impl ::std::ops::BitAnd<_JsParseScriptAttributes> for _JsParseScriptAttributes
 {
    type
    Output
    =
    Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        _JsParseScriptAttributes(self.0 & other.0)
    }
}
impl ::std::ops::BitAndAssign for _JsParseScriptAttributes {
    #[inline]
    fn bitand_assign(&mut self, rhs: _JsParseScriptAttributes) {
        self.0 &= rhs.0;
    }
}
#[repr(C)]
/// <summary>
    ///     Attribute mask for JsParseScriptWithAttributes
    /// </summary>
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct _JsParseScriptAttributes(pub libc::c_uint);
pub use self::_JsParseScriptAttributes as JsParseScriptAttributes;
#[repr(u32)]
/// <summary>
    ///     Type enumeration of a JavaScript property
    /// </summary>
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _JsPropertyIdType {
    PropertyIdTypeString = 0,
    PropertyIdTypeSymbol = 1,
}
pub use self::_JsPropertyIdType as JsPropertyIdType;
#[repr(u32)]
/// <summary>
    ///     The JavaScript type of a JsValueRef.
    /// </summary>
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _JsValueType {
    Undefined = 0,
    Null = 1,
    Number = 2,
    String = 3,
    Boolean = 4,
    Object = 5,
    Function = 6,
    Error = 7,
    Array = 8,
    Symbol = 9,
    ArrayBuffer = 10,
    TypedArray = 11,
    DataView = 12,
}
pub use self::_JsValueType as JsValueType;
/// <summary>
    ///     User implemented callback routine for memory allocation events
    /// </summary>
    /// <remarks>
    ///     Use <c>JsSetRuntimeMemoryAllocationCallback</c> to register this callback.
    /// </remarks>
    /// <param name="callbackState">
    ///     The state passed to <c>JsSetRuntimeMemoryAllocationCallback</c>.
    /// </param>
    /// <param name="allocationEvent">The type of type allocation event.</param>
    /// <param name="allocationSize">The size of the allocation.</param>
    /// <returns>
    ///     For the <c>JsMemoryAllocate</c> event, returning <c>true</c> allows the runtime to continue
    ///     with the allocation. Returning false indicates the allocation request is rejected. The
    ///     return value is ignored for other allocation events.
    /// </returns>
pub type JsMemoryAllocationCallback =
    ::std::option::Option<unsafe extern "system" fn(callbackState:
                                                   *mut libc::c_void,
                                               allocationEvent:
                                                   JsMemoryEventType,
                                               allocationSize: usize)
                              -> bool>;
/// <summary>
    ///     A callback called before collection.
    /// </summary>
    /// <remarks>
    ///     Use <c>JsSetBeforeCollectCallback</c> to register this callback.
    /// </remarks>
    /// <param name="callbackState">The state passed to <c>JsSetBeforeCollectCallback</c>.</param>
pub type JsBeforeCollectCallback =
    ::std::option::Option<unsafe extern "system" fn(callbackState:
                                                   *mut libc::c_void)>;
/// <summary>
    ///     A callback called before collecting an object.
    /// </summary>
    /// <remarks>
    ///     Use <c>JsSetObjectBeforeCollectCallback</c> to register this callback.
    /// </remarks>
    /// <param name="ref">The object to be collected.</param>
    /// <param name="callbackState">The state passed to <c>JsSetObjectBeforeCollectCallback</c>.</param>
pub type JsObjectBeforeCollectCallback =
    ::std::option::Option<unsafe extern "system" fn(ref_: JsRef,
                                               callbackState:
                                                   *mut libc::c_void)>;
/// <summary>
    ///     A background work item callback.
    /// </summary>
    /// <remarks>
    ///     This is passed to the host's thread service (if provided) to allow the host to
    ///     invoke the work item callback on the background thread of its choice.
    /// </remarks>
    /// <param name="callbackState">Data argument passed to the thread service.</param>
pub type JsBackgroundWorkItemCallback =
    ::std::option::Option<unsafe extern "system" fn(callbackState:
                                                   *mut libc::c_void)>;
/// <summary>
    ///     A thread service callback.
    /// </summary>
    /// <remarks>
    ///     The host can specify a background thread service when calling <c>JsCreateRuntime</c>. If
    ///     specified, then background work items will be passed to the host using this callback. The
    ///     host is expected to either begin executing the background work item immediately and return
    ///     true or return false and the runtime will handle the work item in-thread.
    /// </remarks>
    /// <param name="callback">The callback for the background work item.</param>
    /// <param name="callbackState">The data argument to be passed to the callback.</param>
pub type JsThreadServiceCallback =
    ::std::option::Option<unsafe extern "system" fn(callback:
                                                   JsBackgroundWorkItemCallback,
                                               callbackState:
                                                   *mut libc::c_void)
                              -> bool>;
/// <summary>
    ///     Called by the runtime when it is finished with all resources related to the script execution.
    ///     The caller should free the source if loaded, the byte code, and the context at this time.
    /// </summary>
    /// <param name="sourceContext">The context passed to Js[Parse|Run]SerializedScriptWithCallback</param>
pub type JsSerializedScriptUnloadCallback =
    ::std::option::Option<unsafe extern "system" fn(sourceContext:
                                                   JsSourceContext)>;
/// <summary>
    ///     A finalizer callback.
    /// </summary>
    /// <param name="data">
    ///     The external data that was passed in when creating the object being finalized.
    /// </param>
pub type JsFinalizeCallback =
    ::std::option::Option<unsafe extern "system" fn(data: *mut libc::c_void)>;
/// <summary>
    ///     A function callback.
    /// </summary>
    /// <param name="callee">
    ///     A function object that represents the function being invoked.
    /// </param>
    /// <param name="isConstructCall">Indicates whether this is a regular call or a 'new' call.</param>
    /// <param name="arguments">The arguments to the call.</param>
    /// <param name="argumentCount">The number of arguments.</param>
    /// <param name="callbackState">
    ///     The state passed to <c>JsCreateFunction</c>.
    /// </param>
    /// <returns>The result of the call, if any.</returns>
pub type JsNativeFunction =
    ::std::option::Option<unsafe extern "system" fn(callee: JsValueRef,
                                               isConstructCall: bool,
                                               arguments: *mut JsValueRef,
                                               argumentCount: libc::c_ushort,
                                               callbackState:
                                                   *mut libc::c_void)
                              -> JsValueRef>;
/// <summary>
    ///     A promise continuation callback.
    /// </summary>
    /// <remarks>
    ///     The host can specify a promise continuation callback in <c>JsSetPromiseContinuationCallback</c>. If
    ///     a script creates a task to be run later, then the promise continuation callback will be called with
    ///     the task and the task should be put in a FIFO queue, to be run when the current script is
    ///     done executing.
    /// </remarks>
    /// <param name="task">The task, represented as a JavaScript function.</param>
    /// <param name="callbackState">The data argument to be passed to the callback.</param>
pub type JsPromiseContinuationCallback =
    ::std::option::Option<unsafe extern "system" fn(task: JsValueRef,
                                               callbackState:
                                                   *mut libc::c_void)>;
extern "system" {
    /// <summary>
    ///     Creates a new runtime.
    /// </summary>
    /// <param name="attributes">The attributes of the runtime to be created.</param>
    /// <param name="threadService">The thread service for the runtime. Can be null.</param>
    /// <param name="runtime">The runtime created.</param>
    /// <remarks>In the edge-mode binary, chakra.dll, this function lacks the <c>runtimeVersion</c>
    /// parameter (compare to jsrt9.h).</remarks>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCreateRuntime(attributes: JsRuntimeAttributes,
                           threadService: JsThreadServiceCallback,
                           runtime: *mut JsRuntimeHandle) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Performs a full garbage collection.
    /// </summary>
    /// <param name="runtime">The runtime in which the garbage collection will be performed.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCollectGarbage(runtime: JsRuntimeHandle) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Disposes a runtime.
    /// </summary>
    /// <remarks>
    ///     Once a runtime has been disposed, all resources owned by it are invalid and cannot be used.
    ///     If the runtime is active (i.e. it is set to be current on a particular thread), it cannot
    ///     be disposed.
    /// </remarks>
    /// <param name="runtime">The runtime to dispose.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsDisposeRuntime(runtime: JsRuntimeHandle) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the current memory usage for a runtime.
    /// </summary>
    /// <remarks>
    ///     Memory usage can be always be retrieved, regardless of whether or not the runtime is active
    ///     on another thread.
    /// </remarks>
    /// <param name="runtime">The runtime whose memory usage is to be retrieved.</param>
    /// <param name="memoryUsage">The runtime's current memory usage, in bytes.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetRuntimeMemoryUsage(runtime: JsRuntimeHandle,
                                   memoryUsage: *mut usize) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the current memory limit for a runtime.
    /// </summary>
    /// <remarks>
    ///     The memory limit of a runtime can be always be retrieved, regardless of whether or not the
    ///     runtime is active on another thread.
    /// </remarks>
    /// <param name="runtime">The runtime whose memory limit is to be retrieved.</param>
    /// <param name="memoryLimit">
    ///     The runtime's current memory limit, in bytes, or -1 if no limit has been set.
    /// </param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetRuntimeMemoryLimit(runtime: JsRuntimeHandle,
                                   memoryLimit: *mut usize) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Sets the current memory limit for a runtime.
    /// </summary>
    /// <remarks>
    ///     <para>
    ///     A memory limit will cause any operation which exceeds the limit to fail with an "out of
    ///     memory" error. Setting a runtime's memory limit to -1 means that the runtime has no memory
    ///     limit. New runtimes  default to having no memory limit. If the new memory limit exceeds
    ///     current usage, the call will succeed and any future allocations in this runtime will fail
    ///     until the runtime's memory usage drops below the limit.
    ///     </para>
    ///     <para>
    ///     A runtime's memory limit can be always be set, regardless of whether or not the runtime is
    ///     active on another thread.
    ///     </para>
    /// </remarks>
    /// <param name="runtime">The runtime whose memory limit is to be set.</param>
    /// <param name="memoryLimit">
    ///     The new runtime memory limit, in bytes, or -1 for no memory limit.
    /// </param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsSetRuntimeMemoryLimit(runtime: JsRuntimeHandle,
                                   memoryLimit: usize) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Sets a memory allocation callback for specified runtime
    /// </summary>
    /// <remarks>
    ///     <para>
    ///     Registering a memory allocation callback will cause the runtime to call back to the host
    ///     whenever it acquires memory from, or releases memory to, the OS. The callback routine is
    ///     called before the runtime memory manager allocates a block of memory. The allocation will
    ///     be rejected if the callback returns false. The runtime memory manager will also invoke the
    ///     callback routine after freeing a block of memory, as well as after allocation failures.
    ///     </para>
    ///     <para>
    ///     The callback is invoked on the current runtime execution thread, therefore execution is
    ///     blocked until the callback completes.
    ///     </para>
    ///     <para>
    ///     The return value of the callback is not stored; previously rejected allocations will not
    ///     prevent the runtime from invoking the callback again later for new memory allocations.
    ///     </para>
    /// </remarks>
    /// <param name="runtime">The runtime for which to register the allocation callback.</param>
    /// <param name="callbackState">
    ///     User provided state that will be passed back to the callback.
    /// </param>
    /// <param name="allocationCallback">
    ///     Memory allocation callback to be called for memory allocation events.
    /// </param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsSetRuntimeMemoryAllocationCallback(runtime: JsRuntimeHandle,
                                                callbackState:
                                                    *mut libc::c_void,
                                                allocationCallback:
                                                    JsMemoryAllocationCallback)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Sets a callback function that is called by the runtime before garbage collection.
    /// </summary>
    /// <remarks>
    ///     <para>
    ///     The callback is invoked on the current runtime execution thread, therefore execution is
    ///     blocked until the callback completes.
    ///     </para>
    ///     <para>
    ///     The callback can be used by hosts to prepare for garbage collection. For example, by
    ///     releasing unnecessary references on Chakra objects.
    ///     </para>
    /// </remarks>
    /// <param name="runtime">The runtime for which to register the allocation callback.</param>
    /// <param name="callbackState">
    ///     User provided state that will be passed back to the callback.
    /// </param>
    /// <param name="beforeCollectCallback">The callback function being set.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsSetRuntimeBeforeCollectCallback(runtime: JsRuntimeHandle,
                                             callbackState: *mut libc::c_void,
                                             beforeCollectCallback:
                                                 JsBeforeCollectCallback)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Adds a reference to a garbage collected object.
    /// </summary>
    /// <remarks>
    ///     This only needs to be called on <c>JsRef</c> handles that are not going to be stored
    ///     somewhere on the stack. Calling <c>JsAddRef</c> ensures that the object the <c>JsRef</c>
    ///     refers to will not be freed until <c>JsRelease</c> is called.
    /// </remarks>
    /// <param name="ref">The object to add a reference to.</param>
    /// <param name="count">The object's new reference count (can pass in null).</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsAddRef(ref_: JsRef, count: *mut libc::c_uint) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Releases a reference to a garbage collected object.
    /// </summary>
    /// <remarks>
    ///     Removes a reference to a <c>JsRef</c> handle that was created by <c>JsAddRef</c>.
    /// </remarks>
    /// <param name="ref">The object to add a reference to.</param>
    /// <param name="count">The object's new reference count (can pass in null).</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsRelease(ref_: JsRef, count: *mut libc::c_uint) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Sets a callback function that is called by the runtime before garbage collection of
    ///     an object.
    /// </summary>
    /// <remarks>
    ///     <para>
    ///     The callback is invoked on the current runtime execution thread, therefore execution is
    ///     blocked until the callback completes.
    ///     </para>
    /// </remarks>
    /// <param name="ref">The object for which to register the callback.</param>
    /// <param name="callbackState">
    ///     User provided state that will be passed back to the callback.
    /// </param>
    /// <param name="objectBeforeCollectCallback">The callback function being set. Use null to clear
    ///     previously registered callback.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsSetObjectBeforeCollectCallback(ref_: JsRef,
                                            callbackState: *mut libc::c_void,
                                            objectBeforeCollectCallback:
                                                JsObjectBeforeCollectCallback)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a script context for running scripts.
    /// </summary>
    /// <remarks>
    ///     Each script context has its own global object that is isolated from all other script
    ///     contexts.
    /// </remarks>
    /// <param name="runtime">The runtime the script context is being created in.</param>
    /// <param name="newContext">The created script context.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCreateContext(runtime: JsRuntimeHandle,
                           newContext: *mut JsContextRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the current script context on the thread.
    /// </summary>
    /// <param name="currentContext">
    ///     The current script context on the thread, null if there is no current script context.
    /// </param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetCurrentContext(currentContext: *mut JsContextRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Sets the current script context on the thread.
    /// </summary>
    /// <param name="context">The script context to make current.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsSetCurrentContext(context: JsContextRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the script context that the object belongs to.
    /// </summary>
    /// <param name="object">The object to get the context from.</param>
    /// <param name="context">The context the object belongs to.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetContextOfObject(object: JsValueRef,
                                context: *mut JsContextRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the internal data set on JsrtContext.
    /// </summary>
    /// <param name="context">The context to get the data from.</param>
    /// <param name="data">The pointer to the data where data will be returned.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetContextData(context: JsContextRef,
                            data: *mut *mut libc::c_void) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Sets the internal data of JsrtContext.
    /// </summary>
    /// <param name="context">The context to set the data to.</param>
    /// <param name="data">The pointer to the data to be set.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsSetContextData(context: JsContextRef, data: *mut libc::c_void)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the runtime that the context belongs to.
    /// </summary>
    /// <param name="context">The context to get the runtime from.</param>
    /// <param name="runtime">The runtime the context belongs to.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetRuntime(context: JsContextRef, runtime: *mut JsRuntimeHandle)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Tells the runtime to do any idle processing it need to do.
    /// </summary>
    /// <remarks>
    ///     <para>
    ///     If idle processing has been enabled for the current runtime, calling <c>JsIdle</c> will
    ///     inform the current runtime that the host is idle and that the runtime can perform
    ///     memory cleanup tasks.
    ///     </para>
    ///     <para>
    ///     <c>JsIdle</c> can also return the number of system ticks until there will be more idle work
    ///     for the runtime to do. Calling <c>JsIdle</c> before this number of ticks has passed will do
    ///     no work.
    ///     </para>
    ///     <para>
    ///     Requires an active script context.
    ///     </para>
    /// </remarks>
    /// <param name="nextIdleTick">
    ///     The next system tick when there will be more idle work to do. Can be null. Returns the
    ///     maximum number of ticks if there no upcoming idle work to do.
    /// </param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsIdle(nextIdleTick: *mut libc::c_uint) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the symbol associated with the property ID.
    /// </summary>
    /// <remarks>
    ///     <para>
    ///     Requires an active script context.
    ///     </para>
    /// </remarks>
    /// <param name="propertyId">The property ID to get the symbol of.</param>
    /// <param name="symbol">The symbol associated with the property ID.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetSymbolFromPropertyId(propertyId: JsPropertyIdRef,
                                     symbol: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the type of property
    /// </summary>
    /// <remarks>
    ///     <para>
    ///     Requires an active script context.
    ///     </para>
    /// </remarks>
    /// <param name="propertyId">The property ID to get the type of.</param>
    /// <param name="propertyIdType">The JsPropertyIdType of the given property ID</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetPropertyIdType(propertyId: JsPropertyIdRef,
                               propertyIdType: *mut JsPropertyIdType)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the property ID associated with the symbol.
    /// </summary>
    /// <remarks>
    ///     <para>
    ///     Property IDs are specific to a context and cannot be used across contexts.
    ///     </para>
    ///     <para>
    ///     Requires an active script context.
    ///     </para>
    /// </remarks>
    /// <param name="symbol">
    ///     The symbol whose property ID is being retrieved.
    /// </param>
    /// <param name="propertyId">The property ID for the given symbol.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetPropertyIdFromSymbol(symbol: JsValueRef,
                                     propertyId: *mut JsPropertyIdRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a Javascript symbol.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="description">The string description of the symbol. Can be null.</param>
    /// <param name="result">The new symbol.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCreateSymbol(description: JsValueRef, result: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the list of all symbol properties on the object.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The object from which to get the property symbols.</param>
    /// <param name="propertySymbols">An array of property symbols.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetOwnPropertySymbols(object: JsValueRef,
                                   propertySymbols: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the value of <c>undefined</c> in the current script context.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="undefinedValue">The <c>undefined</c> value.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetUndefinedValue(undefinedValue: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the value of <c>null</c> in the current script context.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="nullValue">The <c>null</c> value.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetNullValue(nullValue: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the value of <c>true</c> in the current script context.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="trueValue">The <c>true</c> value.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetTrueValue(trueValue: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the value of <c>false</c> in the current script context.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="falseValue">The <c>false</c> value.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetFalseValue(falseValue: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a Boolean value from a <c>bool</c> value.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="value">The value to be converted.</param>
    /// <param name="booleanValue">The converted value.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsBoolToBoolean(value: bool, booleanValue: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Retrieves the <c>bool</c> value of a Boolean value.
    /// </summary>
    /// <param name="value">The value to be converted.</param>
    /// <param name="boolValue">The converted value.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsBooleanToBool(value: JsValueRef, boolValue: *mut bool)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Converts the value to Boolean using standard JavaScript semantics.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="value">The value to be converted.</param>
    /// <param name="booleanValue">The converted value.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsConvertValueToBoolean(value: JsValueRef,
                                   booleanValue: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the JavaScript type of a JsValueRef.
    /// </summary>
    /// <param name="value">The value whose type is to be returned.</param>
    /// <param name="type">The type of the value.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetValueType(value: JsValueRef, type_: *mut JsValueType)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a number value from a <c>double</c> value.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="doubleValue">The <c>double</c> to convert to a number value.</param>
    /// <param name="value">The new number value.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsDoubleToNumber(doubleValue: f64, value: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a number value from an <c>int</c> value.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="intValue">The <c>int</c> to convert to a number value.</param>
    /// <param name="value">The new number value.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsIntToNumber(intValue: libc::c_int, value: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Retrieves the <c>double</c> value of a number value.
    /// </summary>
    /// <remarks>
    ///     This function retrieves the value of a number value. It will fail with
    ///     <c>JsErrorInvalidArgument</c> if the type of the value is not number.
    /// </remarks>
    /// <param name="value">The number value to convert to a <c>double</c> value.</param>
    /// <param name="doubleValue">The <c>double</c> value.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsNumberToDouble(value: JsValueRef, doubleValue: *mut f64)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Retrieves the <c>int</c> value of a number value.
    /// </summary>
    /// <remarks>
    ///     This function retrieves the value of a number value and converts to an <c>int</c> value.
    ///     It will fail with <c>JsErrorInvalidArgument</c> if the type of the value is not number.
    /// </remarks>
    /// <param name="value">The number value to convert to an <c>int</c> value.</param>
    /// <param name="intValue">The <c>int</c> value.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsNumberToInt(value: JsValueRef, intValue: *mut libc::c_int)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Converts the value to number using standard JavaScript semantics.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="value">The value to be converted.</param>
    /// <param name="numberValue">The converted value.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsConvertValueToNumber(value: JsValueRef,
                                  numberValue: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the length of a string value.
    /// </summary>
    /// <param name="stringValue">The string value to get the length of.</param>
    /// <param name="length">The length of the string.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetStringLength(stringValue: JsValueRef,
                             length: *mut libc::c_int) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Converts the value to string using standard JavaScript semantics.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="value">The value to be converted.</param>
    /// <param name="stringValue">The converted value.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsConvertValueToString(value: JsValueRef,
                                  stringValue: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the global object in the current script context.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="globalObject">The global object.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetGlobalObject(globalObject: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a new object.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The new object.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCreateObject(object: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a new object that stores some external data.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="data">External data that the object will represent. May be null.</param>
    /// <param name="finalizeCallback">
    ///     A callback for when the object is finalized. May be null.
    /// </param>
    /// <param name="object">The new object.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCreateExternalObject(data: *mut libc::c_void,
                                  finalizeCallback: JsFinalizeCallback,
                                  object: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Converts the value to object using standard JavaScript semantics.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="value">The value to be converted.</param>
    /// <param name="object">The converted value.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsConvertValueToObject(value: JsValueRef, object: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Returns the prototype of an object.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The object whose prototype is to be returned.</param>
    /// <param name="prototypeObject">The object's prototype.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetPrototype(object: JsValueRef,
                          prototypeObject: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Sets the prototype of an object.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The object whose prototype is to be changed.</param>
    /// <param name="prototypeObject">The object's new prototype.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsSetPrototype(object: JsValueRef, prototypeObject: JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Performs JavaScript "instanceof" operator test.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The object to test.</param>
    /// <param name="constructor">The constructor function to test against.</param>
    /// <param name="result">Whether "object instanceof constructor" is true.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsInstanceOf(object: JsValueRef, constructor: JsValueRef,
                        result: *mut bool) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Returns a value that indicates whether an object is extensible or not.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The object to test.</param>
    /// <param name="value">Whether the object is extensible or not.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetExtensionAllowed(object: JsValueRef, value: *mut bool)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Makes an object non-extensible.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The object to make non-extensible.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsPreventExtension(object: JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets an object's property.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The object that contains the property.</param>
    /// <param name="propertyId">The ID of the property.</param>
    /// <param name="value">The value of the property.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetProperty(object: JsValueRef, propertyId: JsPropertyIdRef,
                         value: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets a property descriptor for an object's own property.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The object that has the property.</param>
    /// <param name="propertyId">The ID of the property.</param>
    /// <param name="propertyDescriptor">The property descriptor.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetOwnPropertyDescriptor(object: JsValueRef,
                                      propertyId: JsPropertyIdRef,
                                      propertyDescriptor: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the list of all properties on the object.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The object from which to get the property names.</param>
    /// <param name="propertyNames">An array of property names.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetOwnPropertyNames(object: JsValueRef,
                                 propertyNames: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Puts an object's property.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The object that contains the property.</param>
    /// <param name="propertyId">The ID of the property.</param>
    /// <param name="value">The new value of the property.</param>
    /// <param name="useStrictRules">The property set should follow strict mode rules.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsSetProperty(object: JsValueRef, propertyId: JsPropertyIdRef,
                         value: JsValueRef, useStrictRules: bool)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Determines whether an object has a property.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The object that may contain the property.</param>
    /// <param name="propertyId">The ID of the property.</param>
    /// <param name="hasProperty">Whether the object (or a prototype) has the property.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsHasProperty(object: JsValueRef, propertyId: JsPropertyIdRef,
                         hasProperty: *mut bool) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Deletes an object's property.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The object that contains the property.</param>
    /// <param name="propertyId">The ID of the property.</param>
    /// <param name="useStrictRules">The property set should follow strict mode rules.</param>
    /// <param name="result">Whether the property was deleted.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsDeleteProperty(object: JsValueRef, propertyId: JsPropertyIdRef,
                            useStrictRules: bool, result: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Defines a new object's own property from a property descriptor.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The object that has the property.</param>
    /// <param name="propertyId">The ID of the property.</param>
    /// <param name="propertyDescriptor">The property descriptor.</param>
    /// <param name="result">Whether the property was defined.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsDefineProperty(object: JsValueRef, propertyId: JsPropertyIdRef,
                            propertyDescriptor: JsValueRef, result: *mut bool)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Tests whether an object has a value at the specified index.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The object to operate on.</param>
    /// <param name="index">The index to test.</param>
    /// <param name="result">Whether the object has a value at the specified index.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsHasIndexedProperty(object: JsValueRef, index: JsValueRef,
                                result: *mut bool) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Retrieve the value at the specified index of an object.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The object to operate on.</param>
    /// <param name="index">The index to retrieve.</param>
    /// <param name="result">The retrieved value.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetIndexedProperty(object: JsValueRef, index: JsValueRef,
                                result: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Set the value at the specified index of an object.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The object to operate on.</param>
    /// <param name="index">The index to set.</param>
    /// <param name="value">The value to set.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsSetIndexedProperty(object: JsValueRef, index: JsValueRef,
                                value: JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Delete the value at the specified index of an object.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The object to operate on.</param>
    /// <param name="index">The index to delete.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsDeleteIndexedProperty(object: JsValueRef, index: JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Determines whether an object has its indexed properties in external data.
    /// </summary>
    /// <param name="object">The object.</param>
    /// <param name="value">Whether the object has its indexed properties in external data.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsHasIndexedPropertiesExternalData(object: JsValueRef,
                                              value: *mut bool)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Retrieves an object's indexed properties external data information.
    /// </summary>
    /// <param name="object">The object.</param>
    /// <param name="data">The external data back store for the object's indexed properties.</param>
    /// <param name="arrayType">The array element type in external data.</param>
    /// <param name="elementLength">The number of array elements in external data.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetIndexedPropertiesExternalData(object: JsValueRef,
                                              data: *mut *mut libc::c_void,
                                              arrayType:
                                                  *mut JsTypedArrayType,
                                              elementLength:
                                                  *mut libc::c_uint)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Sets an object's indexed properties to external data. The external data will be used as back
    ///     store for the object's indexed properties and accessed like a typed array.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="object">The object to operate on.</param>
    /// <param name="data">The external data to be used as back store for the object's indexed properties.</param>
    /// <param name="arrayType">The array element type in external data.</param>
    /// <param name="elementLength">The number of array elements in external data.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsSetIndexedPropertiesToExternalData(object: JsValueRef,
                                                data: *mut libc::c_void,
                                                arrayType: JsTypedArrayType,
                                                elementLength: libc::c_uint)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Compare two JavaScript values for equality.
    /// </summary>
    /// <remarks>
    ///     <para>
    ///     This function is equivalent to the <c>==</c> operator in Javascript.
    ///     </para>
    ///     <para>
    ///     Requires an active script context.
    ///     </para>
    /// </remarks>
    /// <param name="object1">The first object to compare.</param>
    /// <param name="object2">The second object to compare.</param>
    /// <param name="result">Whether the values are equal.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsEquals(object1: JsValueRef, object2: JsValueRef,
                    result: *mut bool) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Compare two JavaScript values for strict equality.
    /// </summary>
    /// <remarks>
    ///     <para>
    ///     This function is equivalent to the <c>===</c> operator in Javascript.
    ///     </para>
    ///     <para>
    ///     Requires an active script context.
    ///     </para>
    /// </remarks>
    /// <param name="object1">The first object to compare.</param>
    /// <param name="object2">The second object to compare.</param>
    /// <param name="result">Whether the values are strictly equal.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsStrictEquals(object1: JsValueRef, object2: JsValueRef,
                          result: *mut bool) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Determines whether an object is an external object.
    /// </summary>
    /// <param name="object">The object.</param>
    /// <param name="value">Whether the object is an external object.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsHasExternalData(object: JsValueRef, value: *mut bool)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Retrieves the data from an external object.
    /// </summary>
    /// <param name="object">The external object.</param>
    /// <param name="externalData">
    ///     The external data stored in the object. Can be null if no external data is stored in the
    ///     object.
    /// </param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetExternalData(object: JsValueRef,
                             externalData: *mut *mut libc::c_void)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Sets the external data on an external object.
    /// </summary>
    /// <param name="object">The external object.</param>
    /// <param name="externalData">
    ///     The external data to be stored in the object. Can be null if no external data is
    ///     to be stored in the object.
    /// </param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsSetExternalData(object: JsValueRef,
                             externalData: *mut libc::c_void) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a Javascript array object.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="length">The initial length of the array.</param>
    /// <param name="result">The new array object.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCreateArray(length: libc::c_uint, result: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a Javascript ArrayBuffer object.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="byteLength">
    ///     The number of bytes in the ArrayBuffer.
    /// </param>
    /// <param name="result">The new ArrayBuffer object.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCreateArrayBuffer(byteLength: libc::c_uint,
                               result: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a Javascript ArrayBuffer object to access external memory.
    /// </summary>
    /// <remarks>Requires an active script context.</remarks>
    /// <param name="data">A pointer to the external memory.</param>
    /// <param name="byteLength">The number of bytes in the external memory.</param>
    /// <param name="finalizeCallback">A callback for when the object is finalized. May be null.</param>
    /// <param name="callbackState">User provided state that will be passed back to finalizeCallback.</param>
    /// <param name="result">The new ArrayBuffer object.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCreateExternalArrayBuffer(data: *mut libc::c_void,
                                       byteLength: libc::c_uint,
                                       finalizeCallback: JsFinalizeCallback,
                                       callbackState: *mut libc::c_void,
                                       result: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a Javascript typed array object.
    /// </summary>
    /// <remarks>
    ///     <para>
    ///     The <c>baseArray</c> can be an <c>ArrayBuffer</c>, another typed array, or a JavaScript
    ///     <c>Array</c>. The returned typed array will use the baseArray if it is an ArrayBuffer, or
    ///     otherwise create and use a copy of the underlying source array.
    ///     </para>
    ///     <para>
    ///     Requires an active script context.
    ///     </para>
    /// </remarks>
    /// <param name="arrayType">The type of the array to create.</param>
    /// <param name="baseArray">
    ///     The base array of the new array. Use <c>JS_INVALID_REFERENCE</c> if no base array.
    /// </param>
    /// <param name="byteOffset">
    ///     The offset in bytes from the start of baseArray (ArrayBuffer) for result typed array to reference.
    ///     Only applicable when baseArray is an ArrayBuffer object. Must be 0 otherwise.
    /// </param>
    /// <param name="elementLength">
    ///     The number of elements in the array. Only applicable when creating a new typed array without
    ///     baseArray (baseArray is <c>JS_INVALID_REFERENCE</c>) or when baseArray is an ArrayBuffer object.
    ///     Must be 0 otherwise.
    /// </param>
    /// <param name="result">The new typed array object.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCreateTypedArray(arrayType: JsTypedArrayType,
                              baseArray: JsValueRef, byteOffset: libc::c_uint,
                              elementLength: libc::c_uint,
                              result: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a Javascript DataView object.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="arrayBuffer">
    ///     An existing ArrayBuffer object to use as the storage for the result DataView object.
    /// </param>
    /// <param name="byteOffset">
    ///     The offset in bytes from the start of arrayBuffer for result DataView to reference.
    /// </param>
    /// <param name="byteLength">
    ///     The number of bytes in the ArrayBuffer for result DataView to reference.
    /// </param>
    /// <param name="result">The new DataView object.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCreateDataView(arrayBuffer: JsValueRef, byteOffset: libc::c_uint,
                            byteLength: libc::c_uint, result: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Obtains frequently used properties of a typed array.
    /// </summary>
    /// <param name="typedArray">The typed array instance.</param>
    /// <param name="arrayType">The type of the array.</param>
    /// <param name="arrayBuffer">The ArrayBuffer backstore of the array.</param>
    /// <param name="byteOffset">The offset in bytes from the start of arrayBuffer referenced by the array.</param>
    /// <param name="byteLength">The number of bytes in the array.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetTypedArrayInfo(typedArray: JsValueRef,
                               arrayType: *mut JsTypedArrayType,
                               arrayBuffer: *mut JsValueRef,
                               byteOffset: *mut libc::c_uint,
                               byteLength: *mut libc::c_uint) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Obtains the underlying memory storage used by an <c>ArrayBuffer</c>.
    /// </summary>
    /// <param name="arrayBuffer">The ArrayBuffer instance.</param>
    /// <param name="buffer">
    ///     The ArrayBuffer's buffer. The lifetime of the buffer returned is the same as the lifetime of the
    ///     the ArrayBuffer. The buffer pointer does not count as a reference to the ArrayBuffer for the purpose
    ///     of garbage collection.
    /// </param>
    /// <param name="bufferLength">The number of bytes in the buffer.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetArrayBufferStorage(arrayBuffer: JsValueRef,
                                   buffer: *mut ChakraBytePtr,
                                   bufferLength: *mut libc::c_uint)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Obtains the underlying memory storage used by a typed array.
    /// </summary>
    /// <param name="typedArray">The typed array instance.</param>
    /// <param name="buffer">
    ///     The array's buffer. The lifetime of the buffer returned is the same as the lifetime of the
    ///     the array. The buffer pointer does not count as a reference to the array for the purpose
    ///     of garbage collection.
    /// </param>
    /// <param name="bufferLength">The number of bytes in the buffer.</param>
    /// <param name="arrayType">The type of the array.</param>
    /// <param name="elementSize">
    ///     The size of an element of the array.
    /// </param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetTypedArrayStorage(typedArray: JsValueRef,
                                  buffer: *mut ChakraBytePtr,
                                  bufferLength: *mut libc::c_uint,
                                  arrayType: *mut JsTypedArrayType,
                                  elementSize: *mut libc::c_int)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Obtains the underlying memory storage used by a DataView.
    /// </summary>
    /// <param name="dataView">The DataView instance.</param>
    /// <param name="buffer">
    ///     The DataView's buffer. The lifetime of the buffer returned is the same as the lifetime of the
    ///     the DataView. The buffer pointer does not count as a reference to the DataView for the purpose
    ///     of garbage collection.
    /// </param>
    /// <param name="bufferLength">The number of bytes in the buffer.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetDataViewStorage(dataView: JsValueRef,
                                buffer: *mut ChakraBytePtr,
                                bufferLength: *mut libc::c_uint)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Invokes a function.
    /// </summary>
    /// <remarks>
    ///     Requires thisArg as first argument of arguments.
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="function">The function to invoke.</param>
    /// <param name="arguments">The arguments to the call.</param>
    /// <param name="argumentCount">The number of arguments being passed in to the function.</param>
    /// <param name="result">The value returned from the function invocation, if any.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCallFunction(function: JsValueRef, arguments: *mut JsValueRef,
                          argumentCount: libc::c_ushort,
                          result: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Invokes a function as a constructor.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="function">The function to invoke as a constructor.</param>
    /// <param name="arguments">The arguments to the call.</param>
    /// <param name="argumentCount">The number of arguments being passed in to the function.</param>
    /// <param name="result">The value returned from the function invocation.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsConstructObject(function: JsValueRef, arguments: *mut JsValueRef,
                             argumentCount: libc::c_ushort,
                             result: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a new JavaScript function.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="nativeFunction">The method to call when the function is invoked.</param>
    /// <param name="callbackState">
    ///     User provided state that will be passed back to the callback.
    /// </param>
    /// <param name="function">The new function object.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCreateFunction(nativeFunction: JsNativeFunction,
                            callbackState: *mut libc::c_void,
                            function: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a new JavaScript function with name.
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="name">The name of this function that will be used for diagnostics and stringification purposes.</param>
    /// <param name="nativeFunction">The method to call when the function is invoked.</param>
    /// <param name="callbackState">
    ///     User provided state that will be passed back to the callback.
    /// </param>
    /// <param name="function">The new function object.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCreateNamedFunction(name: JsValueRef,
                                 nativeFunction: JsNativeFunction,
                                 callbackState: *mut libc::c_void,
                                 function: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a new JavaScript error object
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="message">Message for the error object.</param>
    /// <param name="error">The new error object.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCreateError(message: JsValueRef, error: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a new JavaScript RangeError error object
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="message">Message for the error object.</param>
    /// <param name="error">The new error object.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCreateRangeError(message: JsValueRef, error: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a new JavaScript ReferenceError error object
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="message">Message for the error object.</param>
    /// <param name="error">The new error object.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCreateReferenceError(message: JsValueRef, error: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a new JavaScript SyntaxError error object
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="message">Message for the error object.</param>
    /// <param name="error">The new error object.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCreateSyntaxError(message: JsValueRef, error: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a new JavaScript TypeError error object
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="message">Message for the error object.</param>
    /// <param name="error">The new error object.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCreateTypeError(message: JsValueRef, error: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Creates a new JavaScript URIError error object
    /// </summary>
    /// <remarks>
    ///     Requires an active script context.
    /// </remarks>
    /// <param name="message">Message for the error object.</param>
    /// <param name="error">The new error object.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsCreateURIError(message: JsValueRef, error: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Determines whether the runtime of the current context is in an exception state.
    /// </summary>
    /// <remarks>
    ///     <para>
    ///     If a call into the runtime results in an exception (either as the result of running a
    ///     script or due to something like a conversion failure), the runtime is placed into an
    ///     "exception state." All calls into any context created by the runtime (except for the
    ///     exception APIs) will fail with <c>JsErrorInExceptionState</c> until the exception is
    ///     cleared.
    ///     </para>
    ///     <para>
    ///     If the runtime of the current context is in the exception state when a callback returns
    ///     into the engine, the engine will automatically rethrow the exception.
    ///     </para>
    ///     <para>
    ///     Requires an active script context.
    ///     </para>
    /// </remarks>
    /// <param name="hasException">
    ///     Whether the runtime of the current context is in the exception state.
    /// </param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsHasException(hasException: *mut bool) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Returns the exception that caused the runtime of the current context to be in the
    ///     exception state and resets the exception state for that runtime.
    /// </summary>
    /// <remarks>
    ///     <para>
    ///     If the runtime of the current context is not in an exception state, this API will return
    ///     <c>JsErrorInvalidArgument</c>. If the runtime is disabled, this will return an exception
    ///     indicating that the script was terminated, but it will not clear the exception (the
    ///     exception will be cleared if the runtime is re-enabled using
    ///     <c>JsEnableRuntimeExecution</c>).
    ///     </para>
    ///     <para>
    ///     Requires an active script context.
    ///     </para>
    /// </remarks>
    /// <param name="exception">The exception for the runtime of the current context.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsGetAndClearException(exception: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Sets the runtime of the current context to an exception state.
    /// </summary>
    /// <remarks>
    ///     <para>
    ///     If the runtime of the current context is already in an exception state, this API will
    ///     return <c>JsErrorInExceptionState</c>.
    ///     </para>
    ///     <para>
    ///     Requires an active script context.
    ///     </para>
    /// </remarks>
    /// <param name="exception">
    ///     The JavaScript exception to set for the runtime of the current context.
    /// </param>
    /// <returns>
    ///     JsNoError if the engine was set into an exception state, a failure code otherwise.
    /// </returns>
    pub fn JsSetException(exception: JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Suspends script execution and terminates any running scripts in a runtime.
    /// </summary>
    /// <remarks>
    ///     <para>
    ///     Calls to a suspended runtime will fail until <c>JsEnableRuntimeExecution</c> is called.
    ///     </para>
    ///     <para>
    ///     This API does not have to be called on the thread the runtime is active on. Although the
    ///     runtime will be set into a suspended state, an executing script may not be suspended
    ///     immediately; a running script will be terminated with an uncatchable exception as soon as
    ///     possible.
    ///     </para>
    ///     <para>
    ///     Suspending execution in a runtime that is already suspended is a no-op.
    ///     </para>
    /// </remarks>
    /// <param name="runtime">The runtime to be suspended.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsDisableRuntimeExecution(runtime: JsRuntimeHandle) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Enables script execution in a runtime.
    /// </summary>
    /// <remarks>
    ///     Enabling script execution in a runtime that already has script execution enabled is a
    ///     no-op.
    /// </remarks>
    /// <param name="runtime">The runtime to be enabled.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsEnableRuntimeExecution(runtime: JsRuntimeHandle) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Returns a value that indicates whether script execution is disabled in the runtime.
    /// </summary>
    /// <param name="runtime">Specifies the runtime to check if execution is disabled.</param>
    /// <param name="isDisabled">If execution is disabled, <c>true</c>, <c>false</c> otherwise.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsIsRuntimeExecutionDisabled(runtime: JsRuntimeHandle,
                                        isDisabled: *mut bool) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Sets a promise continuation callback function that is called by the context when a task
    ///     needs to be queued for future execution
    /// </summary>
    /// <remarks>
    ///     <para>
    ///     Requires an active script context.
    ///     </para>
    /// </remarks>
    /// <param name="promiseContinuationCallback">The callback function being set.</param>
    /// <param name="callbackState">
    ///     User provided state that will be passed back to the callback.
    /// </param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsSetPromiseContinuationCallback(promiseContinuationCallback:
                                                JsPromiseContinuationCallback,
                                            callbackState: *mut libc::c_void)
     -> JsErrorCode;
}
#[repr(u32)]
/// <summary>
    ///     Debug events reported from ChakraCore engine.
    /// </summary>
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _JsDiagDebugEvent {
    DiagDebugEventSourceCompile = 0,
    DiagDebugEventCompileError = 1,
    DiagDebugEventBreakpoint = 2,
    DiagDebugEventStepComplete = 3,
    DiagDebugEventDebuggerStatement = 4,
    DiagDebugEventAsyncBreak = 5,
    DiagDebugEventRuntimeException = 6,
}
pub use self::_JsDiagDebugEvent as JsDiagDebugEvent;
pub const JsDiagBreakOnExceptionAttributeNone:
          _JsDiagBreakOnExceptionAttributes =
    _JsDiagBreakOnExceptionAttributes(0);
pub const JsDiagBreakOnExceptionAttributeUncaught:
          _JsDiagBreakOnExceptionAttributes =
    _JsDiagBreakOnExceptionAttributes(1);
pub const JsDiagBreakOnExceptionAttributeFirstChance:
          _JsDiagBreakOnExceptionAttributes =
    _JsDiagBreakOnExceptionAttributes(2);
impl ::std::ops::BitOr<_JsDiagBreakOnExceptionAttributes> for
 _JsDiagBreakOnExceptionAttributes {
    type
    Output
    =
    Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        _JsDiagBreakOnExceptionAttributes(self.0 | other.0)
    }
}
impl ::std::ops::BitOrAssign for _JsDiagBreakOnExceptionAttributes {
    #[inline]
    fn bitor_assign(&mut self, rhs: _JsDiagBreakOnExceptionAttributes) {
        self.0 |= rhs.0;
    }
}
impl ::std::ops::BitAnd<_JsDiagBreakOnExceptionAttributes> for
 _JsDiagBreakOnExceptionAttributes {
    type
    Output
    =
    Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        _JsDiagBreakOnExceptionAttributes(self.0 & other.0)
    }
}
impl ::std::ops::BitAndAssign for _JsDiagBreakOnExceptionAttributes {
    #[inline]
    fn bitand_assign(&mut self, rhs: _JsDiagBreakOnExceptionAttributes) {
        self.0 &= rhs.0;
    }
}
#[repr(C)]
/// <summary>
    ///     Break on Exception attributes.
    /// </summary>
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct _JsDiagBreakOnExceptionAttributes(pub libc::c_uint);
pub use self::_JsDiagBreakOnExceptionAttributes as
        JsDiagBreakOnExceptionAttributes;
#[repr(u32)]
/// <summary>
    ///     Stepping types.
    /// </summary>
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _JsDiagStepType {
    DiagStepTypeStepIn = 0,
    DiagStepTypeStepOut = 1,
    DiagStepTypeStepOver = 2,
    DiagStepTypeStepBack = 3,
    DiagStepTypeReverseContinue = 4,
    DiagStepTypeContinue = 5,
}
pub use self::_JsDiagStepType as JsDiagStepType;
/// <summary>
    ///     User implemented callback routine for debug events.
    /// </summary>
    /// <remarks>
    ///     Use <c>JsDiagStartDebugging</c> to register the callback.
    /// </remarks>
    /// <param name="debugEvent">The type of JsDiagDebugEvent event.</param>
    /// <param name="eventData">Additional data related to the debug event.</param>
    /// <param name="callbackState">The state passed to <c>JsDiagStartDebugging</c>.</param>
pub type JsDiagDebugEventCallback =
    ::std::option::Option<unsafe extern "system" fn(debugEvent: JsDiagDebugEvent,
                                               eventData: JsValueRef,
                                               callbackState:
                                                   *mut libc::c_void)>;
extern "system" {
    /// <summary>
    ///     Starts debugging in the given runtime.
    /// </summary>
    /// <param name="runtimeHandle">Runtime to put into debug mode.</param>
    /// <param name="debugEventCallback">Registers a callback to be called on every JsDiagDebugEvent.</param>
    /// <param name="callbackState">User provided state that will be passed back to the callback.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    /// <remarks>
    ///     The runtime should be active on the current thread and should not be in debug state.
    /// </remarks>
    pub fn JsDiagStartDebugging(runtimeHandle: JsRuntimeHandle,
                                debugEventCallback: JsDiagDebugEventCallback,
                                callbackState: *mut libc::c_void)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Stops debugging in the given runtime.
    /// </summary>
    /// <param name="runtimeHandle">Runtime to stop debugging.</param>
    /// <param name="callbackState">User provided state that was passed in JsDiagStartDebugging.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    /// <remarks>
    ///     The runtime should be active on the current thread and in debug state.
    /// </remarks>
    pub fn JsDiagStopDebugging(runtimeHandle: JsRuntimeHandle,
                               callbackState: *mut *mut libc::c_void)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Request the runtime to break on next JavaScript statement.
    /// </summary>
    /// <param name="runtimeHandle">Runtime to request break.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    /// <remarks>
    ///     The runtime should be in debug state. This API can be called from another runtime.
    /// </remarks>
    pub fn JsDiagRequestAsyncBreak(runtimeHandle: JsRuntimeHandle)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     List all breakpoints in the current runtime.
    /// </summary>
    /// <param name="breakpoints">Array of breakpoints.</param>
    /// <remarks>
    ///     <para>
    ///     [{
    ///         "breakpointId" : 1,
    ///         "scriptId" : 1,
    ///         "line" : 0,
    ///         "column" : 62
    ///     }]
    ///     </para>
    /// </remarks>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    /// <remarks>
    ///     The current runtime should be in debug state. This API can be called when runtime is at a break or running.
    /// </remarks>
    pub fn JsDiagGetBreakpoints(breakpoints: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Sets breakpoint in the specified script at give location.
    /// </summary>
    /// <param name="scriptId">Id of script from JsDiagGetScripts or JsDiagGetSource to put breakpoint.</param>
    /// <param name="lineNumber">0 based line number to put breakpoint.</param>
    /// <param name="columnNumber">0 based column number to put breakpoint.</param>
    /// <param name="breakpoint">Breakpoint object with id, line and column if success.</param>
    /// <remarks>
    ///     <para>
    ///     {
    ///         "breakpointId" : 1,
    ///         "line" : 2,
    ///         "column" : 4
    ///     }
    ///     </para>
    /// </remarks>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    /// <remarks>
    ///     The current runtime should be in debug state. This API can be called when runtime is at a break or running.
    /// </remarks>
    pub fn JsDiagSetBreakpoint(scriptId: libc::c_uint,
                               lineNumber: libc::c_uint,
                               columnNumber: libc::c_uint,
                               breakpoint: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Remove a breakpoint.
    /// </summary>
    /// <param name="breakpointId">Breakpoint id returned from JsDiagSetBreakpoint.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    /// <remarks>
    ///     The current runtime should be in debug state. This API can be called when runtime is at a break or running.
    /// </remarks>
    pub fn JsDiagRemoveBreakpoint(breakpointId: libc::c_uint) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Sets break on exception handling.
    /// </summary>
    /// <param name="runtimeHandle">Runtime to set break on exception attributes.</param>
    /// <param name="exceptionAttributes">Mask of JsDiagBreakOnExceptionAttributes to set.</param>
    /// <remarks>
    ///     <para>
    ///         If this API is not called the default value is set to JsDiagBreakOnExceptionAttributeUncaught in the runtime.
    ///     </para>
    /// </remarks>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    /// <remarks>
    ///     The runtime should be in debug state. This API can be called from another runtime.
    /// </remarks>
    pub fn JsDiagSetBreakOnException(runtimeHandle: JsRuntimeHandle,
                                     exceptionAttributes:
                                         JsDiagBreakOnExceptionAttributes)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets break on exception setting.
    /// </summary>
    /// <param name="runtimeHandle">Runtime from which to get break on exception attributes, should be in debug mode.</param>
    /// <param name="exceptionAttributes">Mask of JsDiagBreakOnExceptionAttributes.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    /// <remarks>
    ///     The runtime should be in debug state. This API can be called from another runtime.
    /// </remarks>
    pub fn JsDiagGetBreakOnException(runtimeHandle: JsRuntimeHandle,
                                     exceptionAttributes:
                                         *mut JsDiagBreakOnExceptionAttributes)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Sets the step type in the runtime after a debug break.
    /// </summary>
    /// <remarks>
    ///     Requires to be at a debug break.
    /// </remarks>
    /// <param name="resumeType">Type of JsDiagStepType.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    /// <remarks>
    ///     The current runtime should be in debug state. This API can only be called when runtime is at a break.
    /// </remarks>
    pub fn JsDiagSetStepType(stepType: JsDiagStepType) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets list of scripts.
    /// </summary>
    /// <param name="scriptsArray">Array of script objects.</param>
    /// <remarks>
    ///     <para>
    ///     [{
    ///         "scriptId" : 2,
    ///         "fileName" : "c:\\Test\\Test.js",
    ///         "lineCount" : 4,
    ///         "sourceLength" : 111
    ///       }, {
    ///         "scriptId" : 3,
    ///         "parentScriptId" : 2,
    ///         "scriptType" : "eval code",
    ///         "lineCount" : 1,
    ///         "sourceLength" : 12
    ///     }]
    ///     </para>
    /// </remarks>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    /// <remarks>
    ///     The current runtime should be in debug state. This API can be called when runtime is at a break or running.
    /// </remarks>
    pub fn JsDiagGetScripts(scriptsArray: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets source for a specific script identified by scriptId from JsDiagGetScripts.
    /// </summary>
    /// <param name="scriptId">Id of the script.</param>
    /// <param name="source">Source object.</param>
    /// <remarks>
    ///     <para>
    ///     {
    ///         "scriptId" : 1,
    ///         "fileName" : "c:\\Test\\Test.js",
    ///         "lineCount" : 12,
    ///         "sourceLength" : 15154,
    ///         "source" : "var x = 1;"
    ///     }
    ///     </para>
    /// </remarks>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    /// <remarks>
    ///     The current runtime should be in debug state. This API can be called when runtime is at a break or running.
    /// </remarks>
    pub fn JsDiagGetSource(scriptId: libc::c_uint, source: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the source information for a function object.
    /// </summary>
    /// <param name="function">JavaScript function.</param>
    /// <param name="functionPosition">Function position - scriptId, start line, start column, line number of first statement, column number of first statement.</param>
    /// <remarks>
    ///     <para>
    ///     {
    ///         "scriptId" : 1,
    ///         "fileName" : "c:\\Test\\Test.js",
    ///         "line" : 1,
    ///         "column" : 2,
    ///         "firstStatementLine" : 6,
    ///         "firstStatementColumn" : 0
    ///     }
    ///     </para>
    /// </remarks>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    /// <remarks>
    ///     This API can be called when runtime is at a break or running.
    /// </remarks>
    pub fn JsDiagGetFunctionPosition(function: JsValueRef,
                                     functionPosition: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the stack trace information.
    /// </summary>
    /// <param name="stackTrace">Stack trace information.</param>
    /// <remarks>
    ///     <para>
    ///     [{
    ///         "index" : 0,
    ///         "scriptId" : 2,
    ///         "line" : 3,
    ///         "column" : 0,
    ///         "sourceLength" : 9,
    ///         "sourceText" : "var x = 1",
    ///         "functionHandle" : 1
    ///     }]
    ///    </para>
    /// </remarks>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    /// <remarks>
    ///     The current runtime should be in debug state. This API can only be called when runtime is at a break.
    /// </remarks>
    pub fn JsDiagGetStackTrace(stackTrace: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the list of properties corresponding to the frame.
    /// </summary>
    /// <param name="stackFrameIndex">Index of stack frame from JsDiagGetStackTrace.</param>
    /// <param name="properties">Object of properties array (properties, scopes and globals).</param>
    /// <remarks>
    ///     <para>
    ///     propertyAttributes is a bit mask of
    ///         NONE = 0x1,
    ///         HAVE_CHILDRENS = 0x2,
    ///         READ_ONLY_VALUE = 0x4,
    ///     </para>
    ///     <para>
    ///     {
    ///         "thisObject": {
    ///             "name": "this",
    ///             "type" : "object",
    ///             "className" : "Object",
    ///             "display" : "{...}",
    ///             "propertyAttributes" : 1,
    ///             "handle" : 306
    ///         },
    ///         "exception" : {
    ///             "name" : "{exception}",
    ///             "type" : "object",
    ///             "display" : "'a' is undefined",
    ///             "className" : "Error",
    ///             "propertyAttributes" : 1,
    ///             "handle" : 307
    ///         }
    ///         "arguments" : {
    ///             "name" : "arguments",
    ///             "type" : "object",
    ///             "display" : "{...}",
    ///             "className" : "Object",
    ///             "propertyAttributes" : 1,
    ///             "handle" : 190
    ///         },
    ///         "returnValue" : {
    ///             "name" : "[Return value]",
    ///             "type" : "undefined",
    ///             "propertyAttributes" : 0,
    ///             "handle" : 192
    ///         },
    ///         "functionCallsReturn" : [{
    ///                 "name" : "[foo1 returned]",
    ///                 "type" : "number",
    ///                 "value" : 1,
    ///                 "propertyAttributes" : 2,
    ///                 "handle" : 191
    ///             }
    ///         ],
    ///         "locals" : [],
    ///         "scopes" : [{
    ///                 "index" : 0,
    ///                 "handle" : 193
    ///             }
    ///         ],
    ///         "globals" : {
    ///             "handle" : 194
    ///         }
    ///     }
    ///     </para>
    /// </remarks>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    /// <remarks>
    ///     The current runtime should be in debug state. This API can only be called when runtime is at a break.
    /// </remarks>
    pub fn JsDiagGetStackProperties(stackFrameIndex: libc::c_uint,
                                    properties: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the list of children of a handle.
    /// </summary>
    /// <param name="objectHandle">Handle of object.</param>
    /// <param name="fromCount">0-based from count of properties, usually 0.</param>
    /// <param name="totalCount">Number of properties to return.</param>
    /// <param name="propertiesObject">Array of properties.</param>
    /// <remarks>Handle should be from objects returned from call to JsDiagGetStackProperties.</remarks>
    /// <remarks>For scenarios where object have large number of properties totalCount can be used to control how many properties are given.</remarks>
    /// <remarks>
    ///     <para>
    ///     {
    ///         "totalPropertiesOfObject": 10,
    ///         "properties" : [{
    ///                 "name" : "__proto__",
    ///                 "type" : "object",
    ///                 "display" : "{...}",
    ///                 "className" : "Object",
    ///                 "propertyAttributes" : 1,
    ///                 "handle" : 156
    ///             }
    ///         ],
    ///         "debuggerOnlyProperties" : [{
    ///                 "name" : "[Map]",
    ///                 "type" : "string",
    ///                 "value" : "size = 0",
    ///                 "propertyAttributes" : 2,
    ///                 "handle" : 157
    ///             }
    ///         ]
    ///     }
    ///     </para>
    /// </remarks>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    /// <remarks>
    ///     The current runtime should be in debug state. This API can only be called when runtime is at a break.
    /// </remarks>
    pub fn JsDiagGetProperties(objectHandle: libc::c_uint,
                               fromCount: libc::c_uint,
                               totalCount: libc::c_uint,
                               propertiesObject: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Gets the object corresponding to handle.
    /// </summary>
    /// <param name="objectHandle">Handle of object.</param>
    /// <param name="handleObject">Object corresponding to the handle.</param>
    /// <remarks>
    ///     <para>
    ///     {
    ///         "scriptId" : 24,
    ///          "line" : 1,
    ///          "column" : 63,
    ///          "name" : "foo",
    ///          "type" : "function",
    ///          "handle" : 2
    ///     }
    ///    </para>
    /// </remarks>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    /// <remarks>
    ///     The current runtime should be in debug state. This API can only be called when runtime is at a break.
    /// </remarks>
    pub fn JsDiagGetObjectFromHandle(objectHandle: libc::c_uint,
                                     handleObject: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     Evaluates an expression on given frame.
    /// </summary>
    /// <param name="expression">
    ///     Javascript String or ArrayBuffer (incl. ExternalArrayBuffer).
    /// </param>
    /// <param name="stackFrameIndex">Index of stack frame on which to evaluate the expression.</param>
    /// <param name="parseAttributes">
    ///     Defines how `expression` (JsValueRef) should be parsed.
    ///     - `JsParseScriptAttributeNone` when `expression` is a Utf8 encoded ArrayBuffer and/or a Javascript String (encoding independent)
    ///     - `JsParseScriptAttributeArrayBufferIsUtf16Encoded` when `expression` is Utf16 Encoded ArrayBuffer
    ///     - `JsParseScriptAttributeLibraryCode` has no use for this function and has similar effect with `JsParseScriptAttributeNone`
    /// </param>
    /// <param name="forceSetValueProp">Forces the result to contain the raw value of the expression result.</param>
    /// <param name="evalResult">Result of evaluation.</param>
    /// <remarks>
    ///     <para>
    ///     evalResult when evaluating 'this' and return is JsNoError
    ///     {
    ///         "name" : "this",
    ///         "type" : "object",
    ///         "className" : "Object",
    ///         "display" : "{...}",
    ///         "propertyAttributes" : 1,
    ///         "handle" : 18
    ///     }
    ///
    ///     evalResult when evaluating a script which throws JavaScript error and return is JsErrorScriptException
    ///     {
    ///         "name" : "a.b.c",
    ///         "type" : "object",
    ///         "className" : "Error",
    ///         "display" : "'a' is undefined",
    ///         "propertyAttributes" : 1,
    ///         "handle" : 18
    ///     }
    ///     </para>
    /// </remarks>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, evalResult will contain the result
    ///     The code <c>JsErrorScriptException</c> if evaluate generated a JavaScript exception, evalResult will contain the error details
    ///     Other error code for invalid parameters or API was not called at break
    /// </returns>
    /// <remarks>
    ///     The current runtime should be in debug state. This API can only be called when runtime is at a break.
    /// </remarks>
    pub fn JsDiagEvaluate(expression: JsValueRef,
                          stackFrameIndex: libc::c_uint,
                          parseAttributes: JsParseScriptAttributes,
                          forceSetValueProp: bool,
                          evalResult: *mut JsValueRef) -> JsErrorCode;
}
pub const JsTTDMoveNone: _JsTTDMoveModes = _JsTTDMoveModes(0);
pub const JsTTDMoveFirstEvent: _JsTTDMoveModes =
    _JsTTDMoveModes(1);
pub const JsTTDMoveLastEvent: _JsTTDMoveModes =
    _JsTTDMoveModes(2);
pub const JsTTDMoveKthEvent: _JsTTDMoveModes =
    _JsTTDMoveModes(4);
pub const JsTTDMoveScanIntervalForContinue: _JsTTDMoveModes =
    _JsTTDMoveModes(16);
pub const JsTTDMoveScanIntervalForContinueInActiveBreakpointSegment:
          _JsTTDMoveModes =
    _JsTTDMoveModes(32);
pub const JsTTDMoveBreakOnEntry: _JsTTDMoveModes =
    _JsTTDMoveModes(256);
impl ::std::ops::BitOr<_JsTTDMoveModes> for _JsTTDMoveModes {
    type
    Output
    =
    Self;
    #[inline]
    fn bitor(self, other: Self) -> Self { _JsTTDMoveModes(self.0 | other.0) }
}
impl ::std::ops::BitOrAssign for _JsTTDMoveModes {
    #[inline]
    fn bitor_assign(&mut self, rhs: _JsTTDMoveModes) { self.0 |= rhs.0; }
}
impl ::std::ops::BitAnd<_JsTTDMoveModes> for _JsTTDMoveModes {
    type
    Output
    =
    Self;
    #[inline]
    fn bitand(self, other: Self) -> Self { _JsTTDMoveModes(self.0 & other.0) }
}
impl ::std::ops::BitAndAssign for _JsTTDMoveModes {
    #[inline]
    fn bitand_assign(&mut self, rhs: _JsTTDMoveModes) { self.0 &= rhs.0; }
}
#[repr(C)]
/////////////////////
    /// <summary>
    ///     TimeTravel move options as bit flag enum.
    /// </summary>
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct _JsTTDMoveModes(pub libc::c_uint);
pub use self::_JsTTDMoveModes as JsTTDMoveMode;
/// <summary>
    ///     A handle for URI's that TTD information is written to/read from.
    /// </summary>
#[repr(C)]
#[derive(Eq, PartialEq, Copy, Clone, Debug)]
pub struct JsTTDStreamHandle(pub *mut libc::c_void);
impl JsTTDStreamHandle {
pub fn new() -> Self { JsTTDStreamHandle(::std::ptr::null_mut()) }
}
/// <summary>
    ///     TTD API -- may change in future versions:
    ///     Construct a JsTTDStreamHandle that will be used to read/write the event log portion of the TTD data based on the uri
    ///     provided by JsTTDInitializeUriCallback.
    /// </summary>
    /// <remarks>
    ///     <para>Exactly one of read or write will be set to true.</para>
    /// </remarks>
    /// <param name="uriLength">The length of the uri array that the host passed in for storing log info.</param>
    /// <param name="uri">The URI that the host passed in for storing log info.</param>
    /// <param name="asciiNameLength">The length of the ascii name array that the host passed in for storing log info.</param>
    /// <param name="asciiResourceName">An optional ascii string giving a unique name to the resource that the JsTTDStreamHandle will be created for.</param>
    /// <param name="read">If the handle should be opened for reading.</param>
    /// <param name="write">If the handle should be opened for writing.</param>
    /// <returns>A JsTTDStreamHandle opened in read/write mode as specified.</returns>
pub type TTDOpenResourceStreamCallback =
    ::std::option::Option<unsafe extern "system" fn(uriLength: usize,
                                               uri: *const libc::c_char,
                                               asciiNameLength: usize,
                                               asciiResourceName:
                                                   *const libc::c_char,
                                               read: bool, write: bool)
                              -> JsTTDStreamHandle>;
/// <summary>
    ///     TTD API -- may change in future versions:
    ///     A callback for reading data from a handle.
    /// </summary>
    /// <param name="handle">The JsTTDStreamHandle to read the data from.</param>
    /// <param name="buff">The buffer to place the data into.</param>
    /// <param name="size">The max number of bytes that should be read.</param>
    /// <param name="readCount">The actual number of bytes read and placed in the buffer.</param>
    /// <returns>true if the read was successful false otherwise.</returns>
pub type JsTTDReadBytesFromStreamCallback =
    ::std::option::Option<unsafe extern "system" fn(handle: JsTTDStreamHandle,
                                               buff: *mut byte, size: usize,
                                               readCount: *mut usize)
                              -> bool>;
/// <summary>
    ///     TTD API -- may change in future versions:
    ///     A callback for writing data to a handle.
    /// </summary>
    /// <param name="handle">The JsTTDStreamHandle to write the data to.</param>
    /// <param name="buff">The buffer to copy the data from.</param>
    /// <param name="size">The max number of bytes that should be written.</param>
    /// <param name="readCount">The actual number of bytes written to the HANDLE.</param>
    /// <returns>true if the write was successful false otherwise.</returns>
pub type JsTTDWriteBytesToStreamCallback =
    ::std::option::Option<unsafe extern "system" fn(handle: JsTTDStreamHandle,
                                               buff: *const byte, size: usize,
                                               writtenCount: *mut usize)
                              -> bool>;
/// <summary>
    ///     TTD API -- may change in future versions:
    ///     Flush and close the stream represented by the HANDLE as needed.
    /// </summary>
    /// <remarks>
    ///     <para>Exactly one of read or write will be set to true.</para>
    /// </remarks>
    /// <param name="handle">The JsTTDStreamHandle to close.</param>
    /// <param name="read">If the handle was opened for reading.</param>
    /// <param name="write">If the handle was opened for writing.</param>
pub type JsTTDFlushAndCloseStreamCallback =
    ::std::option::Option<unsafe extern "system" fn(handle: JsTTDStreamHandle,
                                               read: bool, write: bool)>;
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Creates a new runtime in Record Mode.
    /// </summary>
    /// <param name="attributes">The attributes of the runtime to be created.</param>
    /// <param name="snapInterval">The interval to wait between snapshots (measured in millis).</param>
    /// <param name="snapHistoryLength">The amount of history to maintain before discarding -- measured in number of snapshots and controls how far back in time a trace can be reversed.</param>
    /// <param name="openResourceStream">The <c>TTDOpenResourceStreamCallback</c> function for generating a JsTTDStreamHandle to read/write serialized data.</param>
    /// <param name="writeBytesToStream">The <c>JsTTDWriteBytesToStreamCallback</c> function for writing bytes to a JsTTDStreamHandle.</param>
    /// <param name="flushAndCloseStream">The <c>JsTTDFlushAndCloseStreamCallback</c> function for flushing and closing a JsTTDStreamHandle as needed.</param>
    /// <param name="threadService">The thread service for the runtime. Can be null.</param>
    /// <param name="runtime">The runtime created.</param>
    /// <remarks>
    ///     <para>See <c>JsCreateRuntime</c> for additional information.</para>
    /// </remarks>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsTTDCreateRecordRuntime(attributes: JsRuntimeAttributes,
                                    snapInterval: usize,
                                    snapHistoryLength: usize,
                                    openResourceStream:
                                        TTDOpenResourceStreamCallback,
                                    writeBytesToStream:
                                        JsTTDWriteBytesToStreamCallback,
                                    flushAndCloseStream:
                                        JsTTDFlushAndCloseStreamCallback,
                                    threadService: JsThreadServiceCallback,
                                    runtime: *mut JsRuntimeHandle)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Creates a new runtime in Debug Mode.
    /// </summary>
    /// <param name="attributes">The attributes of the runtime to be created.</param>
    /// <param name="infoUri">The uri where the recorded Time-Travel data should be loaded from.</param>
    /// <param name="enableDebugging">A flag to enable addtional debugging operation support during replay.</param>
    /// <param name="openResourceStream">The <c>TTDOpenResourceStreamCallback</c> function for generating a JsTTDStreamHandle to read/write serialized data.</param>
    /// <param name="readBytesFromStream">The <c>JsTTDReadBytesFromStreamCallback</c> function for reading bytes from a JsTTDStreamHandle.</param>
    /// <param name="flushAndCloseStream">The <c>JsTTDFlushAndCloseStreamCallback</c> function for flushing and closing a JsTTDStreamHandle as needed.</param>
    /// <param name="threadService">The thread service for the runtime. Can be null.</param>
    /// <param name="runtime">The runtime created.</param>
    /// <remarks>
    ///     <para>See <c>JsCreateRuntime</c> for additional information.</para>
    /// </remarks>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsTTDCreateReplayRuntime(attributes: JsRuntimeAttributes,
                                    infoUri: *const libc::c_char,
                                    infoUriCount: usize,
                                    enableDebugging: bool,
                                    openResourceStream:
                                        TTDOpenResourceStreamCallback,
                                    readBytesFromStream:
                                        JsTTDReadBytesFromStreamCallback,
                                    flushAndCloseStream:
                                        JsTTDFlushAndCloseStreamCallback,
                                    threadService: JsThreadServiceCallback,
                                    runtime: *mut JsRuntimeHandle)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Creates a script context that takes the TTD mode from the log or explicitly is not in TTD mode (regular takes mode from currently active script).
    /// </summary>
    /// <param name="runtime">The runtime the script context is being created in.</param>
    /// <param name="useRuntimeTTDMode">Set to true to use runtime TTD mode false to explicitly be non-TTD context.</param>
    /// <param name="newContext">The created script context.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsTTDCreateContext(runtimeHandle: JsRuntimeHandle,
                              useRuntimeTTDMode: bool,
                              newContext: *mut JsContextRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Notify the time-travel system that a context has been identified as dead by the gc (and is being de-allocated).
    /// </summary>
    /// <param name="context">The script context that is now dead.</param>
    /// <returns>
    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
    /// </returns>
    pub fn JsTTDNotifyContextDestroy(context: JsContextRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Start Time-Travel record or replay at next turn of event loop.
    /// </summary>
    /// <returns>The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.</returns>
    pub fn JsTTDStart() -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Stop Time-Travel record or replay.
    /// </summary>
    /// <returns>The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.</returns>
    pub fn JsTTDStop() -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Pause Time-Travel recording before executing code on behalf of debugger or other diagnostic/telemetry.
    /// </summary>
    /// <returns>The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.</returns>
    pub fn JsTTDPauseTimeTravelBeforeRuntimeOperation() -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     ReStart Time-Travel recording after executing code on behalf of debugger or other diagnostic/telemetry.
    /// </summary>
    /// <returns>The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.</returns>
    pub fn JsTTDReStartTimeTravelAfterRuntimeOperation() -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Notify the Js runtime we are at a safe yield point in the event loop (i.e. no locals on the stack and we can proccess as desired).
    /// </summary>
    /// <returns>The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.</returns>
    pub fn JsTTDNotifyYield() -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Notify the TTD runtime that we are doing a weak add on a reference (we may use this in external API calls and the release will happen in a GC callback).
    /// </summary>
    /// <param name="value">The value we are adding the ref to.</param>
    /// <returns>The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.</returns>
    pub fn JsTTDNotifyLongLivedReferenceAdd(value: JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Notify the Js runtime the host is aborting the process and what the status code is.
    /// </summary>
    /// <param name="statusCode">The exit status code.</param>
    /// <returns>The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.</returns>
    pub fn JsTTDHostExit(statusCode: libc::c_int) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Notify the event log that the contents of one buffer have been copied to a second buffer.
    /// </summary>
    /// <param name="dst">The buffer that was written into.</param>
    /// <param name="dstIndex">The first index modified.</param>
    /// <param name="src">The buffer that was copied from.</param>
    /// <param name="srcIndex">The first index copied.</param>
    /// <param name="count">The number of bytes copied.</param>
    /// <returns>The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.</returns>
    pub fn JsTTDRawBufferCopySyncIndirect(dst: JsValueRef, dstIndex: usize,
                                          src: JsValueRef, srcIndex: usize,
                                          count: usize) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Notify the event log that the contents of a naked byte* buffer passed to the host have been modified synchronously.
    /// </summary>
    /// <param name="buffer">The buffer that was modified.</param>
    /// <param name="index">The first index modified.</param>
    /// <param name="count">The number of bytes written.</param>
    /// <returns>The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.</returns>
    pub fn JsTTDRawBufferModifySyncIndirect(buffer: JsValueRef, index: usize,
                                            count: usize) -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Get info for notifying the TTD system that a raw buffer it shares with the host has been modified.
    /// </summary>
    /// <param name="instance">The array buffer we want to monitor for contents modification.</param>
    /// <param name="initialModPos">The first position in the buffer that may be modified.</param>
    /// <returns>The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.</returns>
    pub fn JsTTDRawBufferAsyncModificationRegister(instance: JsValueRef,
                                                   initialModPos: *mut byte)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Notify the event log that the contents of a naked byte* buffer passed to the host have been modified asynchronously.
    /// </summary>
    /// <param name="finalModPos">One past the last modified position in the buffer.</param>
    /// <returns>The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.</returns>
    pub fn JsTTDRawBufferAsyncModifyComplete(finalModPos: *mut byte)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     A check for unimplmented TTD actions in the host.
    ///     This API is a TEMPORARY API while we complete the implementation of TTD support in the Node host and will be deleted once that is complete.
    /// </summary>
    /// <param name="msg">The message to print if we should be catching this as a TTD operation.</param>
    /// <returns>The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.</returns>
    pub fn JsTTDCheckAndAssertIfTTDRunning(msg: *const libc::c_char)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Before calling JsTTDMoveToTopLevelEvent (which inflates a snapshot and replays) check to see if we want to reset the script context.
    ///     We reset the script context if the move will require inflating from a different snapshot that the last one.
    /// </summary>
    /// <param name="runtimeHandle">The runtime handle that the script is executing in.</param>
    /// <param name="moveMode">Flags controlling the way the move it performed and how other parameters are interpreted.</param>
    /// <param name="kthEvent">When <c>moveMode == JsTTDMoveKthEvent</c> indicates which event, otherwise this parameter is ignored.</param>
    /// <param name="targetEventTime">The event time we want to move to or -1 if not relevant.</param>
    /// <param name="targetStartSnapTime">Out parameter with the event time of the snapshot that we should inflate from.</param>
    /// <param name="targetEndSnapTime">Optional Out parameter with the snapshot time following the event.</param>
    /// <returns>The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.</returns>
    pub fn JsTTDGetSnapTimeTopLevelEventMove(runtimeHandle: JsRuntimeHandle,
                                             moveMode: JsTTDMoveMode,
                                             kthEvent: u32,
                                             targetEventTime: *mut i64,
                                             targetStartSnapTime: *mut i64,
                                             targetEndSnapTime: *mut i64)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Get the snapshot interval that bounds the target event time.
    /// </summary>
    /// <param name="runtimeHandle">The runtime handle that the script is executing in.</param>
    /// <param name="targetEventTime">The event time we want to get the interval for.</param>
    /// <param name="startSnapTime">The snapshot time that comes before the desired event.</param>
    /// <param name="endSnapTime">The snapshot time that comes after the desired event (-1 if the leg ends before a snapshot appears).</param>
    /// <returns>The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.</returns>
    pub fn JsTTDGetSnapShotBoundInterval(runtimeHandle: JsRuntimeHandle,
                                         targetEventTime: i64,
                                         startSnapTime: *mut i64,
                                         endSnapTime: *mut i64)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Get the snapshot interval that precedes the one given by currentSnapStartTime (or -1 if there is no such interval).
    /// </summary>
    /// <param name="runtimeHandle">The runtime handle that the script is executing in.</param>
    /// <param name="currentSnapStartTime">The current snapshot interval start time.</param>
    /// <param name="previousSnapTime">The resulting previous snapshot interval start time or -1 if no such time.</param>
    /// <returns>The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.</returns>
    pub fn JsTTDGetPreviousSnapshotInterval(runtimeHandle: JsRuntimeHandle,
                                            currentSnapStartTime: i64,
                                            previousSnapTime: *mut i64)
     -> JsErrorCode;
}
extern "system" {
    /// <param name="moveMode">Additional flags for controling how the move is done.</param>
    /// <param name="newTargetEventTime">The updated target event time set according to the moveMode (-1 if not found).</param>
    /// <returns>The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.</returns>
    pub fn JsTTDPreExecuteSnapShotInterval(runtimeHandle: JsRuntimeHandle,
                                           startSnapTime: i64,
                                           endSnapTime: i64,
                                           moveMode: JsTTDMoveMode,
                                           newTargetEventTime: *mut i64)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Move to the given top-level call event time (assuming JsTTDPrepContextsForTopLevelEventMove) was called previously to reset any script contexts.
    ///     This also computes the ready-to-run snapshot if needed.
    /// </summary>
    /// <param name="runtimeHandle">The runtime handle that the script is executing in.</param>
    /// <param name="moveMode">Additional flags for controling how the move is done.</param>
    /// <param name="snapshotTime">The event time that we will start executing from to move to the given target time.</param>
    /// <param name="eventTime">The event that we want to move to.</param>
    /// <returns>The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.</returns>
    pub fn JsTTDMoveToTopLevelEvent(runtimeHandle: JsRuntimeHandle,
                                    moveMode: JsTTDMoveMode,
                                    snapshotTime: i64, eventTime: i64)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
    ///     TTD API -- may change in future versions:
    ///     Execute from the current point in the log to the end returning the error code.
    /// </summary>
    /// <param name="moveMode">Additional flags for controling how the move is done.</param>
    /// <param name="rootEventTime">The event time that we should move to next or notification (-1) that replay has ended.</param>
    /// <returns>
    ///     If the debugger requested an abort the code is JsNoError -- rootEventTime is the target event time we need to move to and re - execute from.
    ///     If we aborted at the end of the replay log the code is JsNoError -- rootEventTime is -1.
    ///     If there was an unhandled script exception the code is JsErrorCategoryScript.
    /// </returns>
    pub fn JsTTDReplayExecution(moveMode: *mut JsTTDMoveMode,
                                rootEventTime: *mut i64) -> JsErrorCode;
}
#[repr(C)]
#[derive(Eq, PartialEq, Copy, Clone, Debug)]
pub struct JsModuleRecord(pub *mut libc::c_void);
impl JsModuleRecord {
pub fn new() -> Self { JsModuleRecord(::std::ptr::null_mut()) }
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum JsParseModuleSourceFlags {
    DataIsUTF16LE = 0,
    DataIsUTF8 = 1,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum JsModuleHostInfoKind {
    Exception = 1,
    HostDefined = 2,
    NotifyModuleReadyCallback = 3,
    FetchImportedModuleCallback = 4,
}
extern "system" {
    /// <summary>
///     Initialize a ModuleRecord from host
/// </summary>
/// <remarks>
///     Bootstrap the module loading process by creating a new module record.
/// </remarks>
/// <param name="referencingModule">The referencingModule as in HostResolveImportedModule (15.2.1.17). nullptr if this is the top level module.</param>
/// <param name="normalizedSpecifier">The host normalized specifier. This is the key to a unique ModuleRecord.</param>
/// <param name="moduleRecord">The new ModuleRecord created. The host should not try to call this API twice with the same normalizedSpecifier.
///                           chakra will return an existing ModuleRecord if the specifier was passed in before.</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsInitializeModuleRecord(referencingModule: JsModuleRecord,
                                    normalizedSpecifier: JsValueRef,
                                    moduleRecord: *mut JsModuleRecord)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
///     Parse the module source
/// </summary>
/// <remarks>
/// This is basically ParseModule operation in ES6 spec. It is slightly different in that the ModuleRecord was initialized earlier, and passed in as an argument.
/// </remarks>
/// <param name="requestModule">The ModuleRecord that holds the parse tree of the source code.</param>
/// <param name="sourceContext">A cookie identifying the script that can be used by debuggable script contexts.</param>
/// <param name="script">The source script to be parsed, but not executed in this code.</param>
/// <param name="scriptLength">The source length of sourceText. The input might contain embedded null.</param>
/// <param name="sourceFlag">The type of the source code passed in. It could be UNICODE or utf8 at this time.</param>
/// <param name="exceptionValueRef">The error object if there is parse error.</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsParseModuleSource(requestModule: JsModuleRecord,
                               sourceContext: JsSourceContext,
                               script: *mut BYTE, scriptLength: libc::c_uint,
                               sourceFlag: JsParseModuleSourceFlags,
                               exceptionValueRef: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
///     Execute module code.
/// </summary>
/// <remarks>
///     This method implements 15.2.1.1.6.5, "ModuleEvaluation" concrete method.
///     When this methid is called, the chakra engine should have notified the host that the module and all its dependent are ready to be executed.
///     One moduleRecord will be executed only once. Additional execution call on the same moduleRecord will fail.
/// </remarks>
/// <param name="requestModule">The module to be executed.</param>
/// <param name="result">The return value of the module.</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsModuleEvaluation(requestModule: JsModuleRecord,
                              result: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
///     Set the host info for the specified module.
/// </summary>
/// <param name="requestModule">The request module.</param>
/// <param name="moduleHostInfo">The type of host info to be set.</param>
/// <param name="hostInfo">The host info to be set.</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsSetModuleHostInfo(requestModule: JsModuleRecord,
                               moduleHostInfo: JsModuleHostInfoKind,
                               hostInfo: *mut libc::c_void) -> JsErrorCode;
}
extern "system" {
    /// <summary>
///     Retrieve the host info for the specified module.
/// </summary>
/// <param name="requestModule">The request module.</param>
/// <param name="moduleHostInfo">The type of host info to get.</param>
/// <param name="hostInfo">The host info to be retrieved.</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsGetModuleHostInfo(requestModule: JsModuleRecord,
                               moduleHostInfo: JsModuleHostInfoKind,
                               hostInfo: *mut *mut libc::c_void)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
///     Returns metadata relating to the exception that caused the runtime of the current context
///     to be in the exception state and resets the exception state for that runtime. The metadata
///     includes a reference to the exception itself.
/// </summary>
/// <remarks>
///     <para>
///     If the runtime of the current context is not in an exception state, this API will return
///     <c>JsErrorInvalidArgument</c>. If the runtime is disabled, this will return an exception
///     indicating that the script was terminated, but it will not clear the exception (the
///     exception will be cleared if the runtime is re-enabled using
///     <c>JsEnableRuntimeExecution</c>).
///     </para>
///     <para>
///     The metadata value is a javascript object with the following properties: <c>exception</c>, the
///     thrown exception object; <c>line</c>, the 0 indexed line number where the exception was thrown;
///     <c>column</c>, the 0 indexed column number where the exception was thrown; <c>length</c>, the
///     source-length of the cause of the exception; <c>source</c>, a string containing the line of
///     source code where the exception was thrown; and <c>url</c>, a string containing the name of
///     the script file containing the code that threw the exception.
///     </para>
///     <para>
///     Requires an active script context.
///     </para>
/// </remarks>
/// <param name="metadata">The exception metadata for the runtime of the current context.</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsGetAndClearExceptionWithMetadata(metadata: *mut JsValueRef)
     -> JsErrorCode;
}
/// <summary>
///     Called by the runtime to load the source code of the serialized script.
/// </summary>
/// <param name="sourceContext">The context passed to Js[Parse|Run]SerializedScriptCallback</param>
/// <param name="script">The script returned.</param>
/// <returns>
///     true if the operation succeeded, false otherwise.
/// </returns>
pub type JsSerializedLoadScriptCallback =
    ::std::option::Option<unsafe extern "system" fn(sourceContext: JsSourceContext,
                                               value: *mut JsValueRef,
                                               parseAttributes:
                                                   *mut JsParseScriptAttributes)
                              -> bool>;
extern "system" {
    /// <summary>
///     Create JavascriptString variable from ASCII or Utf8 string
/// </summary>
/// <remarks>
///     <para>
///         Input string can be either ASCII or Utf8
///     </para>
/// </remarks>
/// <param name="content">Pointer to string memory.</param>
/// <param name="length">Number of bytes within the string</param>
/// <param name="value">JsValueRef representing the JavascriptString</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsCreateString(content: *const libc::c_char, length: usize,
                          value: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
///     Create JavascriptString variable from Utf16 string
/// </summary>
/// <remarks>
///     <para>
///         Expects Utf16 string
///     </para>
/// </remarks>
/// <param name="content">Pointer to string memory.</param>
/// <param name="length">Number of characters within the string</param>
/// <param name="value">JsValueRef representing the JavascriptString</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsCreateStringUtf16(content: *const u16, length: usize,
                               value: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
///     Write JavascriptString value into C string buffer (Utf8)
/// </summary>
/// <remarks>
///     <para>
///         When size of the `buffer` is unknown,
///         `buffer` argument can be nullptr.
///         In that case, `written` argument will return the length needed.
///     </para>
/// </remarks>
/// <param name="value">JavascriptString value</param>
/// <param name="buffer">Pointer to buffer</param>
/// <param name="bufferSize">Buffer size</param>
/// <param name="written">Total number of characters written</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsCopyString(value: JsValueRef, buffer: *mut libc::c_char,
                        bufferSize: usize, written: *mut usize)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
///     Write string value into Utf16 string buffer
/// </summary>
/// <remarks>
///     <para>
///         When size of the `buffer` is unknown,
///         `buffer` argument can be nullptr.
///         In that case, `written` argument will return the length needed.
///     </para>
///     <para>
///         when start is out of range or &lt; 0, returns JsErrorInvalidArgument
///         and `written` will be equal to 0.
///         If calculated length is 0 (It can be due to string length or `start`
///         and length combination), then `written` will be equal to 0 and call
///         returns JsNoError
///     </para>
/// </remarks>
/// <param name="value">JavascriptString value</param>
/// <param name="start">start offset of buffer</param>
/// <param name="length">length to be written</param>
/// <param name="buffer">Pointer to buffer</param>
/// <param name="written">Total number of characters written</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsCopyStringUtf16(value: JsValueRef, start: libc::c_int,
                             length: libc::c_int, buffer: *mut u16,
                             written: *mut usize) -> JsErrorCode;
}
extern "system" {
    /// <summary>
///     Parses a script and returns a function representing the script.
/// </summary>
/// <remarks>
///     <para>
///        Requires an active script context.
///     </para>
///     <para>
///         Script source can be either JavascriptString or JavascriptExternalArrayBuffer.
///         In case it is an ExternalArrayBuffer, and the encoding of the buffer is Utf16,
///         JsParseScriptAttributeArrayBufferIsUtf16Encoded is expected on parseAttributes.
///     </para>
///     <para>
///         Use JavascriptExternalArrayBuffer with Utf8/ASCII script source
///         for better performance and smaller memory footprint.
///     </para>
/// </remarks>
/// <param name="script">The script to run.</param>
/// <param name="sourceContext">
///     A cookie identifying the script that can be used by debuggable script contexts.
/// </param>
/// <param name="sourceUrl">The location the script came from.</param>
/// <param name="parseAttributes">Attribute mask for parsing the script</param>
/// <param name="result">The result of the compiled script.</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsParse(script: JsValueRef, sourceContext: JsSourceContext,
                   sourceUrl: JsValueRef,
                   parseAttributes: JsParseScriptAttributes,
                   result: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
///     Executes a script.
/// </summary>
/// <remarks>
///     <para>
///        Requires an active script context.
///     </para>
///     <para>
///         Script source can be either JavascriptString or JavascriptExternalArrayBuffer.
///         In case it is an ExternalArrayBuffer, and the encoding of the buffer is Utf16,
///         JsParseScriptAttributeArrayBufferIsUtf16Encoded is expected on parseAttributes.
///     </para>
///     <para>
///         Use JavascriptExternalArrayBuffer with Utf8/ASCII script source
///         for better performance and smaller memory footprint.
///     </para>
/// </remarks>
/// <param name="script">The script to run.</param>
/// <param name="sourceContext">
///     A cookie identifying the script that can be used by debuggable script contexts.
/// </param>
/// <param name="sourceUrl">The location the script came from</param>
/// <param name="parseAttributes">Attribute mask for parsing the script</param>
/// <param name="result">The result of the script, if any. This parameter can be null.</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsRun(script: JsValueRef, sourceContext: JsSourceContext,
                 sourceUrl: JsValueRef,
                 parseAttributes: JsParseScriptAttributes,
                 result: *mut JsValueRef) -> JsErrorCode;
}
extern "system" {
    /// <summary>
///     Creates the property ID associated with the name.
/// </summary>
/// <remarks>
///     <para>
///         Property IDs are specific to a context and cannot be used across contexts.
///     </para>
///     <para>
///         Requires an active script context.
///     </para>
/// </remarks>
/// <param name="name">
///     The name of the property ID to get or create. The name may consist of only digits.
///     The string is expected to be ASCII / utf8 encoded.
/// </param>
/// <param name="length">length of the name in bytes</param>
/// <param name="propertyId">The property ID in this runtime for the given name.</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsCreatePropertyId(name: *const libc::c_char, length: usize,
                              propertyId: *mut JsPropertyIdRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
///     Copies the name associated with the property ID into a buffer.
/// </summary>
/// <remarks>
///     <para>
///         Requires an active script context.
///     </para>
///     <para>
///         When size of the `buffer` is unknown,
///         `buffer` argument can be nullptr.
///         `length` argument will return the size needed.
///     </para>
/// </remarks>
/// <param name="propertyId">The property ID to get the name of.</param>
/// <param name="buffer">The buffer holding the name associated with the property ID, encoded as utf8</param>
/// <param name="bufferSize">Size of the buffer.</param>
/// <param name="written">Total number of characters written or to be written</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsCopyPropertyId(propertyId: JsPropertyIdRef,
                            buffer: *mut libc::c_char, bufferSize: usize,
                            length: *mut usize) -> JsErrorCode;
}
extern "system" {
    /// <summary>
///     Serializes a parsed script to a buffer than can be reused.
/// </summary>
/// <remarks>
///     <para>
///     <c>JsSerializeScript</c> parses a script and then stores the parsed form of the script in a
///     runtime-independent format. The serialized script then can be deserialized in any
///     runtime without requiring the script to be re-parsed.
///     </para>
///     <para>
///     Requires an active script context.
///     </para>
///     <para>
///         Script source can be either JavascriptString or JavascriptExternalArrayBuffer.
///         In case it is an ExternalArrayBuffer, and the encoding of the buffer is Utf16,
///         JsParseScriptAttributeArrayBufferIsUtf16Encoded is expected on parseAttributes.
///     </para>
///     <para>
///         Use JavascriptExternalArrayBuffer with Utf8/ASCII script source
///         for better performance and smaller memory footprint.
///     </para>
/// </remarks>
/// <param name="script">The script to serialize</param>
/// <param name="buffer">ArrayBuffer</param>
/// <param name="parseAttributes">Encoding for the script.</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsSerialize(script: JsValueRef, buffer: *mut JsValueRef,
                       parseAttributes: JsParseScriptAttributes)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
///     Parses a serialized script and returns a function representing the script.
///     Provides the ability to lazy load the script source only if/when it is needed.
/// </summary>
/// <remarks>
///     <para>
///     Requires an active script context.
///     </para>
/// </remarks>
/// <param name="buffer">The serialized script as an ArrayBuffer (preferably ExternalArrayBuffer).</param>
/// <param name="scriptLoadCallback">
///     Callback called when the source code of the script needs to be loaded.
///     This is an optional parameter, set to null if not needed.
/// </param>
/// <param name="sourceContext">
///     A cookie identifying the script that can be used by debuggable script contexts.
///     This context will passed into scriptLoadCallback.
/// </param>
/// <param name="sourceUrl">The location the script came from.</param>
/// <param name="result">A function representing the script code.</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsParseSerialized(buffer: JsValueRef,
                             scriptLoadCallback:
                                 JsSerializedLoadScriptCallback,
                             sourceContext: JsSourceContext,
                             sourceUrl: JsValueRef, result: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
///     Runs a serialized script.
///     Provides the ability to lazy load the script source only if/when it is needed.
/// </summary>
/// <remarks>
///     <para>
///     Requires an active script context.
///     </para>
///     <para>
///     The runtime will hold on to the buffer until all instances of any functions created from
///     the buffer are garbage collected.
///     </para>
/// </remarks>
/// <param name="buffer">The serialized script as an ArrayBuffer (preferably ExternalArrayBuffer).</param>
/// <param name="scriptLoadCallback">Callback called when the source code of the script needs to be loaded.</param>
/// <param name="sourceContext">
///     A cookie identifying the script that can be used by debuggable script contexts.
///     This context will passed into scriptLoadCallback.
/// </param>
/// <param name="sourceUrl">The location the script came from.</param>
/// <param name="result">
///     The result of running the script, if any. This parameter can be null.
/// </param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsRunSerialized(buffer: JsValueRef,
                           scriptLoadCallback: JsSerializedLoadScriptCallback,
                           sourceContext: JsSourceContext,
                           sourceUrl: JsValueRef, result: *mut JsValueRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
///     Creates a new JavaScript Promise object.
/// </summary>
/// <remarks>
///     Requires an active script context.
/// </remarks>
/// <param name="promise">The new Promise object.</param>
/// <param name="resolveFunction">The function called to resolve the created Promise object.</param>
/// <param name="rejectFunction">The function called to reject the created Promise object.</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsCreatePromise(promise: *mut JsValueRef,
                           resolveFunction: *mut JsValueRef,
                           rejectFunction: *mut JsValueRef) -> JsErrorCode;
}
/// <summary>
///     A weak reference to a JavaScript value.
/// </summary>
/// <remarks>
///     A value with only weak references is available for garbage-collection. A strong reference
///     to the value (<c>JsValueRef</c>) may be obtained from a weak reference if the value happens
///     to still be available.
/// </remarks>
pub type JsWeakRef = JsRef;
extern "system" {
    /// <summary>
///     Creates a weak reference to a value.
/// </summary>
/// <param name="value">The value to be referenced.</param>
/// <param name="weakRef">Weak reference to the value.</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsCreateWeakReference(value: JsValueRef, weakRef: *mut JsWeakRef)
     -> JsErrorCode;
}
extern "system" {
    /// <summary>
///     Gets a strong reference to the value referred to by a weak reference.
/// </summary>
/// <param name="weakRef">A weak reference.</param>
/// <param name="value">Reference to the value, or <c>JS_INVALID_REFERENCE</c> if the value is
///     no longer available.</param>
/// <returns>
///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
    pub fn JsGetWeakReferenceValue(weakRef: JsWeakRef, value: *mut JsValueRef)
     -> JsErrorCode;
}