#[repr(C)]
pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
impl<T> __BindgenUnionField<T> {
#[inline]
pub const fn new() -> Self {
__BindgenUnionField(::std::marker::PhantomData)
}
#[inline]
pub unsafe fn as_ref(&self) -> &T {
::std::mem::transmute(self)
}
#[inline]
pub unsafe fn as_mut(&mut self) -> &mut T {
::std::mem::transmute(self)
}
}
impl<T> ::std::default::Default for __BindgenUnionField<T> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
#[inline]
fn clone(&self) -> Self {
Self::new()
}
}
impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
fmt.write_str("__BindgenUnionField")
}
}
impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
}
impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
true
}
}
impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
pub type size_t = ::std::os::raw::c_uint;
pub type DWORD = ::std::os::raw::c_ulong;
pub type FLOAT = f32;
pub type UINT = ::std::os::raw::c_uint;
pub type __time64_t = ::std::os::raw::c_longlong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _Mbstatet {
pub _Wchar: ::std::os::raw::c_ulong,
pub _Byte: ::std::os::raw::c_ushort,
pub _State: ::std::os::raw::c_ushort,
}
#[test]
fn bindgen_test_layout__Mbstatet() {
assert_eq!(
::std::mem::size_of::<_Mbstatet>(),
8usize,
concat!("Size of: ", stringify!(_Mbstatet))
);
assert_eq!(
::std::mem::align_of::<_Mbstatet>(),
4usize,
concat!("Alignment of ", stringify!(_Mbstatet))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_Mbstatet>()))._Wchar as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_Mbstatet),
"::",
stringify!(_Wchar)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_Mbstatet>()))._Byte as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_Mbstatet),
"::",
stringify!(_Byte)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_Mbstatet>()))._State as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(_Mbstatet),
"::",
stringify!(_State)
)
);
}
pub type time_t = __time64_t;
pub type INT64 = ::std::os::raw::c_longlong;
pub type UINT64 = ::std::os::raw::c_ulonglong;
pub type UINT_PTR = ::std::os::raw::c_uint;
pub type LONG_PTR = ::std::os::raw::c_long;
pub type LONG = ::std::os::raw::c_long;
pub type TCHAR = ::std::os::raw::c_char;
pub type WPARAM = UINT_PTR;
pub type LPARAM = LONG_PTR;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct HWND__ {
pub unused: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_HWND__() {
assert_eq!(
::std::mem::size_of::<HWND__>(),
4usize,
concat!("Size of: ", stringify!(HWND__))
);
assert_eq!(
::std::mem::align_of::<HWND__>(),
4usize,
concat!("Alignment of ", stringify!(HWND__))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HWND__>())).unused as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(HWND__),
"::",
stringify!(unused)
)
);
}
pub type HWND = *mut HWND__;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct tagRECT {
pub left: LONG,
pub top: LONG,
pub right: LONG,
pub bottom: LONG,
}
#[test]
fn bindgen_test_layout_tagRECT() {
assert_eq!(
::std::mem::size_of::<tagRECT>(),
16usize,
concat!("Size of: ", stringify!(tagRECT))
);
assert_eq!(
::std::mem::align_of::<tagRECT>(),
4usize,
concat!("Alignment of ", stringify!(tagRECT))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagRECT>())).left as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagRECT),
"::",
stringify!(left)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagRECT>())).top as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(tagRECT),
"::",
stringify!(top)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagRECT>())).right as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(tagRECT),
"::",
stringify!(right)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagRECT>())).bottom as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(tagRECT),
"::",
stringify!(bottom)
)
);
}
pub type RECT = tagRECT;
pub type std_integral_constant_value_type<_Ty> = _Ty;
pub type std_integral_constant_type = u8;
pub type std_bool_constant = u8;
pub type std_true_type = u8;
pub type std_conditional_type<_Ty1> = _Ty1;
pub type std_conditional_t = u8;
pub type std_streamoff = ::std::os::raw::c_longlong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_fpos<_Statetype> {
pub _Myoff: std_streamoff,
pub _Fpos: fpos_t,
pub _Mystate: _Statetype,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Statetype>>,
}
pub type std_streampos = std_fpos<_Mbstatet>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_input_iterator_tag {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std_input_iterator_tag() {
assert_eq!(
::std::mem::size_of::<std_input_iterator_tag>(),
1usize,
concat!("Size of: ", stringify!(std_input_iterator_tag))
);
assert_eq!(
::std::mem::align_of::<std_input_iterator_tag>(),
1usize,
concat!("Alignment of ", stringify!(std_input_iterator_tag))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_forward_iterator_tag {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std_forward_iterator_tag() {
assert_eq!(
::std::mem::size_of::<std_forward_iterator_tag>(),
1usize,
concat!("Size of: ", stringify!(std_forward_iterator_tag))
);
assert_eq!(
::std::mem::align_of::<std_forward_iterator_tag>(),
1usize,
concat!("Alignment of ", stringify!(std_forward_iterator_tag))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_bidirectional_iterator_tag {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std_bidirectional_iterator_tag() {
assert_eq!(
::std::mem::size_of::<std_bidirectional_iterator_tag>(),
1usize,
concat!("Size of: ", stringify!(std_bidirectional_iterator_tag))
);
assert_eq!(
::std::mem::align_of::<std_bidirectional_iterator_tag>(),
1usize,
concat!("Alignment of ", stringify!(std_bidirectional_iterator_tag))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_random_access_iterator_tag {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std_random_access_iterator_tag() {
assert_eq!(
::std::mem::size_of::<std_random_access_iterator_tag>(),
1usize,
concat!("Size of: ", stringify!(std_random_access_iterator_tag))
);
assert_eq!(
::std::mem::align_of::<std_random_access_iterator_tag>(),
1usize,
concat!("Alignment of ", stringify!(std_random_access_iterator_tag))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Iterator_traits_base {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_iterator_traits {
pub _address: u8,
}
pub type std__Iter_ref_t = std_iterator_traits;
pub type std__Iter_value_t = std_iterator_traits;
pub type std__Iter_diff_t = std_iterator_traits;
pub type std__Iter_cat_t = std_iterator_traits;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_reverse_iterator<_BidIt> {
pub current: _BidIt,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_BidIt>>,
}
pub type std_reverse_iterator_iterator_type<_BidIt> = _BidIt;
pub type std_reverse_iterator_iterator_category = std__Iter_cat_t;
pub type std_reverse_iterator_value_type = std__Iter_value_t;
pub type std_reverse_iterator_difference_type = std__Iter_diff_t;
pub type std_reverse_iterator_pointer = std_iterator_traits;
pub type std_reverse_iterator_reference = std__Iter_ref_t;
pub type std_reverse_iterator__Prevent_inheriting_unwrap<_BidIt> = std_reverse_iterator<_BidIt>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_allocator_traits {
pub _address: u8,
}
pub type std__Rebind_alloc_t = std_allocator_traits;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_allocator {
pub _address: u8,
}
pub type std_allocator__From_primary = std_allocator;
pub type std_allocator_value_type<_Ty> = _Ty;
pub type std_allocator_pointer<_Ty> = *mut _Ty;
pub type std_allocator_const_pointer<_Ty> = *const _Ty;
pub type std_allocator_reference<_Ty> = *mut _Ty;
pub type std_allocator_const_reference<_Ty> = *const _Ty;
pub type std_allocator_size_type = size_t;
pub type std_allocator_difference_type = isize;
pub type std_allocator_propagate_on_container_move_assignment = std_true_type;
pub type std_allocator_is_always_equal = std_true_type;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_allocator_rebind {
pub _address: u8,
}
pub type std_allocator_rebind_other = std_allocator;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Container_base0 {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std__Container_base0() {
assert_eq!(
::std::mem::size_of::<std__Container_base0>(),
1usize,
concat!("Size of: ", stringify!(std__Container_base0))
);
assert_eq!(
::std::mem::align_of::<std__Container_base0>(),
1usize,
concat!("Alignment of ", stringify!(std__Container_base0))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Iterator_base0 {
pub _address: u8,
}
pub const std__Iterator_base0__Unwrap_when_unverified: bool = true;
#[test]
fn bindgen_test_layout_std__Iterator_base0() {
assert_eq!(
::std::mem::size_of::<std__Iterator_base0>(),
1usize,
concat!("Size of: ", stringify!(std__Iterator_base0))
);
assert_eq!(
::std::mem::align_of::<std__Iterator_base0>(),
1usize,
concat!("Alignment of ", stringify!(std__Iterator_base0))
);
}
pub type std__Container_base = std__Container_base0;
pub type std__Iterator_base = std__Iterator_base0;
pub type std__Compressed_pair__Mybase<_Ty1> = _Ty1;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std__Char_traits {
pub _address: u8,
}
pub type std__Char_traits_char_type<_Elem> = _Elem;
pub type std__Char_traits_int_type<_Int_type> = _Int_type;
pub type std__Char_traits_pos_type = std_streampos;
pub type std__Char_traits_off_type = std_streamoff;
pub type std__Char_traits_state_type = _Mbstatet;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_char_traits {
pub _address: u8,
}
#[repr(C)]
pub struct std__String_const_iterator {
pub _Ptr: std__String_const_iterator_pointer,
}
pub type std__String_const_iterator_iterator_category = std_random_access_iterator_tag;
pub type std__String_const_iterator_value_type = [u8; 0usize];
pub type std__String_const_iterator_difference_type = [u8; 0usize];
pub type std__String_const_iterator_pointer = [u8; 0usize];
pub type std__String_const_iterator_reference = *const std__String_const_iterator_value_type;
pub type std__String_const_iterator__Prevent_inheriting_unwrap = std__String_const_iterator;
#[repr(C)]
pub struct std__String_iterator {
pub _base: std__String_const_iterator,
}
pub type std__String_iterator__Mybase = std__String_const_iterator;
pub type std__String_iterator_iterator_category = std_random_access_iterator_tag;
pub type std__String_iterator_value_type = [u8; 0usize];
pub type std__String_iterator_difference_type = [u8; 0usize];
pub type std__String_iterator_pointer = [u8; 0usize];
pub type std__String_iterator_reference = *mut std__String_iterator_value_type;
pub type std__String_iterator__Prevent_inheriting_unwrap = std__String_iterator;
#[repr(C)]
pub struct std__String_val {
pub _Bx: std__String_val__Bxty,
pub _Mysize: std__String_val_size_type,
pub _Myres: std__String_val_size_type,
}
pub type std__String_val_value_type = [u8; 0usize];
pub type std__String_val_size_type = [u8; 0usize];
pub type std__String_val_difference_type = [u8; 0usize];
pub type std__String_val_pointer = [u8; 0usize];
pub type std__String_val_const_pointer = [u8; 0usize];
pub type std__String_val_reference = *mut std__String_val_value_type;
pub type std__String_val_const_reference = *const std__String_val_value_type;
#[repr(C)]
pub struct std__String_val__Bxty {
pub _Buf: __BindgenUnionField<*mut std__String_val_value_type>,
pub _Ptr: __BindgenUnionField<std__String_val_pointer>,
pub _Alias: __BindgenUnionField<*mut ::std::os::raw::c_char>,
pub bindgen_union_field: u32,
}
#[repr(C)]
#[derive(Debug)]
pub struct std_basic_string {
pub _Mypair: u8,
}
pub type std_basic_string__Alty = std__Rebind_alloc_t;
pub type std_basic_string__Alty_traits = std_allocator_traits;
pub type std_basic_string__Scary_val = std__String_val;
pub type std_basic_string_traits_type<_Traits> = _Traits;
pub type std_basic_string_allocator_type<_Alloc> = _Alloc;
pub type std_basic_string_value_type<_Elem> = _Elem;
pub type std_basic_string_size_type = std_basic_string__Alty_traits;
pub type std_basic_string_difference_type = std_basic_string__Alty_traits;
pub type std_basic_string_pointer = std_basic_string__Alty_traits;
pub type std_basic_string_const_pointer = std_basic_string__Alty_traits;
pub type std_basic_string_reference<_Elem> = *mut std_basic_string_value_type<_Elem>;
pub type std_basic_string_const_reference<_Elem> = *const std_basic_string_value_type<_Elem>;
pub type std_basic_string_iterator = std__String_iterator;
pub type std_basic_string_const_iterator = std__String_const_iterator;
pub type std_basic_string_reverse_iterator = std_reverse_iterator<std_basic_string_iterator>;
pub type std_basic_string_const_reverse_iterator =
std_reverse_iterator<std_basic_string_const_iterator>;
pub type std_basic_string__Is_elem_cptr = std_bool_constant;
pub type std_wstring = std_basic_string;
#[doc = "<Success."]
pub const ZOOMSDK_SDKError_SDKERR_SUCCESS: ZOOMSDK_SDKError = 0;
#[doc = "<This feature is currently invalid."]
pub const ZOOMSDK_SDKError_SDKERR_NO_IMPL: ZOOMSDK_SDKError = 1;
#[doc = "<Incorrect usage of the feature."]
pub const ZOOMSDK_SDKError_SDKERR_WRONG_USEAGE: ZOOMSDK_SDKError = 2;
#[doc = "<Wrong parameter."]
pub const ZOOMSDK_SDKError_SDKERR_INVALID_PARAMETER: ZOOMSDK_SDKError = 3;
#[doc = "<Loading module failed."]
pub const ZOOMSDK_SDKError_SDKERR_MODULE_LOAD_FAILED: ZOOMSDK_SDKError = 4;
#[doc = "<No memory is allocated."]
pub const ZOOMSDK_SDKError_SDKERR_MEMORY_FAILED: ZOOMSDK_SDKError = 5;
#[doc = "<Internal service error."]
pub const ZOOMSDK_SDKError_SDKERR_SERVICE_FAILED: ZOOMSDK_SDKError = 6;
#[doc = "<Not initialized before the usage."]
pub const ZOOMSDK_SDKError_SDKERR_UNINITIALIZE: ZOOMSDK_SDKError = 7;
#[doc = "<Not authorized before the usage."]
pub const ZOOMSDK_SDKError_SDKERR_UNAUTHENTICATION: ZOOMSDK_SDKError = 8;
#[doc = "<No recording in process."]
pub const ZOOMSDK_SDKError_SDKERR_NORECORDINGINPROCESS: ZOOMSDK_SDKError = 9;
#[doc = "<Transcoder module is not found."]
pub const ZOOMSDK_SDKError_SDKERR_TRANSCODER_NOFOUND: ZOOMSDK_SDKError = 10;
#[doc = "<The video service is not ready."]
pub const ZOOMSDK_SDKError_SDKERR_VIDEO_NOTREADY: ZOOMSDK_SDKError = 11;
#[doc = "<No permission."]
pub const ZOOMSDK_SDKError_SDKERR_NO_PERMISSION: ZOOMSDK_SDKError = 12;
#[doc = "<Unknown error."]
pub const ZOOMSDK_SDKError_SDKERR_UNKNOWN: ZOOMSDK_SDKError = 13;
#[doc = "<The other instance of the SDK is in process."]
pub const ZOOMSDK_SDKError_SDKERR_OTHER_SDK_INSTANCE_RUNNING: ZOOMSDK_SDKError = 14;
#[doc = "<SDK internal error."]
pub const ZOOMSDK_SDKError_SDKERR_INTELNAL_ERROR: ZOOMSDK_SDKError = 15;
#[doc = "<No audio device found."]
pub const ZOOMSDK_SDKError_SDKERR_NO_AUDIODEVICE_ISFOUND: ZOOMSDK_SDKError = 16;
#[doc = "<No video device found."]
pub const ZOOMSDK_SDKError_SDKERR_NO_VIDEODEVICE_ISFOUND: ZOOMSDK_SDKError = 17;
#[doc = "<API calls too frequently."]
pub const ZOOMSDK_SDKError_SDKERR_TOO_FREQUENT_CALL: ZOOMSDK_SDKError = 18;
#[doc = "<User can't be assigned with new privilege."]
pub const ZOOMSDK_SDKError_SDKERR_FAIL_ASSIGN_USER_PRIVILEGE: ZOOMSDK_SDKError = 19;
#[doc = "<The current meeting doesn't support the feature."]
pub const ZOOMSDK_SDKError_SDKERR_MEETING_DONT_SUPPORT_FEATURE: ZOOMSDK_SDKError = 20;
#[doc = "<The current user is not the presenter."]
pub const ZOOMSDK_SDKError_SDKERR_MEETING_NOT_SHARE_SENDER: ZOOMSDK_SDKError = 21;
#[doc = "<There is no sharing."]
pub const ZOOMSDK_SDKError_SDKERR_MEETING_YOU_HAVE_NO_SHARE: ZOOMSDK_SDKError = 22;
#[doc = "<Incorrect ViewType parameters."]
pub const ZOOMSDK_SDKError_SDKERR_MEETING_VIEWTYPE_PARAMETER_IS_WRONG: ZOOMSDK_SDKError = 23;
#[doc = "<Annotation is disabled."]
pub const ZOOMSDK_SDKError_SDKERR_MEETING_ANNOTATION_IS_OFF: ZOOMSDK_SDKError = 24;
#[doc = "<Current OS doesn't support the setting."]
pub const ZOOMSDK_SDKError_SDKERR_SETTING_OS_DONT_SUPPORT: ZOOMSDK_SDKError = 25;
#[doc = "<Email login is disable"]
pub const ZOOMSDK_SDKError_SDKERR_EMAIL_LOGIN_IS_DISABLED: ZOOMSDK_SDKError = 26;
#[doc = "<Computer doesn't meet the minimum requirements to use virtual background feature."]
pub const ZOOMSDK_SDKError_SDKERR_HARDWARE_NOT_MEET_FOR_VB: ZOOMSDK_SDKError = 27;
#[doc = " \\enum SDKError"]
#[doc = "\\brief SDK error types."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_SDKError = ::std::os::raw::c_int;
#[doc = "<For initialization."]
pub const ZOOMSDK_SDK_LANGUAGE_ID_LANGUAGE_Unknow: ZOOMSDK_SDK_LANGUAGE_ID = 0;
#[doc = "<In English."]
pub const ZOOMSDK_SDK_LANGUAGE_ID_LANGUAGE_English: ZOOMSDK_SDK_LANGUAGE_ID = 1;
#[doc = "<In simplified Chinese."]
pub const ZOOMSDK_SDK_LANGUAGE_ID_LANGUAGE_Chinese_Simplified: ZOOMSDK_SDK_LANGUAGE_ID = 2;
#[doc = "<In traditional Chinese."]
pub const ZOOMSDK_SDK_LANGUAGE_ID_LANGUAGE_Chinese_Traditional: ZOOMSDK_SDK_LANGUAGE_ID = 3;
#[doc = "<In Japanese."]
pub const ZOOMSDK_SDK_LANGUAGE_ID_LANGUAGE_Japanese: ZOOMSDK_SDK_LANGUAGE_ID = 4;
#[doc = "<In Spanish."]
pub const ZOOMSDK_SDK_LANGUAGE_ID_LANGUAGE_Spanish: ZOOMSDK_SDK_LANGUAGE_ID = 5;
#[doc = "<In German."]
pub const ZOOMSDK_SDK_LANGUAGE_ID_LANGUAGE_German: ZOOMSDK_SDK_LANGUAGE_ID = 6;
#[doc = "<In French."]
pub const ZOOMSDK_SDK_LANGUAGE_ID_LANGUAGE_French: ZOOMSDK_SDK_LANGUAGE_ID = 7;
#[doc = "<In Portuguese."]
pub const ZOOMSDK_SDK_LANGUAGE_ID_LANGUAGE_Portuguese: ZOOMSDK_SDK_LANGUAGE_ID = 8;
#[doc = "<In Russian."]
pub const ZOOMSDK_SDK_LANGUAGE_ID_LANGUAGE_Russian: ZOOMSDK_SDK_LANGUAGE_ID = 9;
#[doc = "<In Korean."]
pub const ZOOMSDK_SDK_LANGUAGE_ID_LANGUAGE_Korean: ZOOMSDK_SDK_LANGUAGE_ID = 10;
#[doc = "<In Vietnamese."]
pub const ZOOMSDK_SDK_LANGUAGE_ID_LANGUAGE_Vietnamese: ZOOMSDK_SDK_LANGUAGE_ID = 11;
#[doc = "<In Italian."]
pub const ZOOMSDK_SDK_LANGUAGE_ID_LANGUAGE_Italian: ZOOMSDK_SDK_LANGUAGE_ID = 12;
#[doc = " \\enum SDK_LANGUAGE_ID"]
#[doc = "\\brief The text resource type used by the SDK."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_SDK_LANGUAGE_ID = ::std::os::raw::c_int;
#[doc = " \\struct tagWndPosition"]
#[doc = "\\brief The position of the window. The coordinate of position is that of monitor when the parent window is null. If the the parent window is not null, the position coordinate is that of the parent window."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagWndPosition {
#[doc = "<Specifies the X-axis coordinate of the top-left corner of the window"]
pub left: ::std::os::raw::c_int,
#[doc = "<Specifies the Y-axis coordinate of the top-left of the window."]
pub top: ::std::os::raw::c_int,
#[doc = "<Specifies the window handle of the window itself."]
pub hSelfWnd: HWND,
#[doc = "<Specifies the window handle of the parent window. If the value is NULL, the position coordinate is the monitor coordinate."]
pub hParent: HWND,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagWndPosition() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagWndPosition>(),
16usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagWndPosition))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagWndPosition>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagWndPosition))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZOOMSDK_tagWndPosition>())).left as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagWndPosition),
"::",
stringify!(left)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZOOMSDK_tagWndPosition>())).top as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagWndPosition),
"::",
stringify!(top)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZOOMSDK_tagWndPosition>())).hSelfWnd as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagWndPosition),
"::",
stringify!(hSelfWnd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZOOMSDK_tagWndPosition>())).hParent as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagWndPosition),
"::",
stringify!(hParent)
)
);
}
#[doc = " \\struct tagWndPosition"]
#[doc = "\\brief The position of the window. The coordinate of position is that of monitor when the parent window is null. If the the parent window is not null, the position coordinate is that of the parent window."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_WndPosition = ZOOMSDK_tagWndPosition;
#[doc = "<No use of the custom resource."]
pub const ZOOMSDK_CustomizedLanguageType_CustomizedLanguage_None: ZOOMSDK_CustomizedLanguageType =
0;
#[doc = "<Use the specified file path to assign the custom resource."]
pub const ZOOMSDK_CustomizedLanguageType_CustomizedLanguage_FilePath:
ZOOMSDK_CustomizedLanguageType = 1;
#[doc = "<Use the specified content to assign the custom resource."]
pub const ZOOMSDK_CustomizedLanguageType_CustomizedLanguage_Content:
ZOOMSDK_CustomizedLanguageType = 2;
#[doc = " \\enum CustomizedLanguageType"]
#[doc = "\\brief Custom resource type used by the SDK."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_CustomizedLanguageType = ::std::os::raw::c_int;
#[doc = " \\struct CustomizedLanguageType"]
#[doc = "\\brief The custom resource information used by the SDK."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagCustomizedLanguageInfo {
#[doc = "<Resource name."]
pub langName: *const ::std::os::raw::c_char,
#[doc = "<The value should be the full path of the resource file when the langType value is CustomizedLanguage_FilePath, including the file name. When the langType value is CustomizedLanguage_Content, the value saves the content of the resource."]
pub langInfo: *const ::std::os::raw::c_char,
#[doc = "<Use the custom resource type."]
pub langType: ZOOMSDK_CustomizedLanguageType,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagCustomizedLanguageInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagCustomizedLanguageInfo>(),
12usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagCustomizedLanguageInfo))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagCustomizedLanguageInfo>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagCustomizedLanguageInfo)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagCustomizedLanguageInfo>())).langName as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagCustomizedLanguageInfo),
"::",
stringify!(langName)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagCustomizedLanguageInfo>())).langInfo as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagCustomizedLanguageInfo),
"::",
stringify!(langInfo)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagCustomizedLanguageInfo>())).langType as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagCustomizedLanguageInfo),
"::",
stringify!(langType)
)
);
}
#[doc = " \\struct CustomizedLanguageType"]
#[doc = "\\brief The custom resource information used by the SDK."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_CustomizedLanguageInfo = ZOOMSDK_tagCustomizedLanguageInfo;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagConfigurableOptions {
pub customizedLang: ZOOMSDK_CustomizedLanguageInfo,
#[doc = "<Additional functional configuration. The function currently supports whether to use the custom UI mode only. When the value of the optionalFeatures&ENABLE_CUSTOMIZED_UI_FLAG is TRUE, it means the custom UI mode will be used. Otherwise the Zoom UI mode will be used."]
pub optionalFeatures: ::std::os::raw::c_int,
pub sdkPathPostfix: *const u16,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagConfigurableOptions() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagConfigurableOptions>(),
20usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagConfigurableOptions))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagConfigurableOptions>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagConfigurableOptions))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagConfigurableOptions>())).customizedLang as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagConfigurableOptions),
"::",
stringify!(customizedLang)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagConfigurableOptions>())).optionalFeatures as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagConfigurableOptions),
"::",
stringify!(optionalFeatures)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagConfigurableOptions>())).sdkPathPostfix as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagConfigurableOptions),
"::",
stringify!(sdkPathPostfix)
)
);
}
pub type ZOOMSDK_ConfigurableOptions = ZOOMSDK_tagConfigurableOptions;
pub const ZOOMSDK_SDK_APP_Locale_SDK_APP_Locale_Default: ZOOMSDK_SDK_APP_Locale = 0;
pub const ZOOMSDK_SDK_APP_Locale_SDK_APP_Locale_CN: ZOOMSDK_SDK_APP_Locale = 1;
#[doc = " \\enum SDK_APP_Locale"]
#[doc = "\\brief SDK_APP locale type."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_SDK_APP_Locale = ::std::os::raw::c_int;
pub const ZOOMSDK_ZoomSDKRawDataMemoryMode_ZoomSDKRawDataMemoryModeStack:
ZOOMSDK_ZoomSDKRawDataMemoryMode = 0;
pub const ZOOMSDK_ZoomSDKRawDataMemoryMode_ZoomSDKRawDataMemoryModeHeap:
ZOOMSDK_ZoomSDKRawDataMemoryMode = 1;
pub type ZOOMSDK_ZoomSDKRawDataMemoryMode = ::std::os::raw::c_int;
pub const ZOOMSDK_ZoomSDKVideoRenderMode_ZoomSDKVideoRenderMode_None:
ZOOMSDK_ZoomSDKVideoRenderMode = 0;
pub const ZOOMSDK_ZoomSDKVideoRenderMode_ZoomSDKVideoRenderMode_Auto:
ZOOMSDK_ZoomSDKVideoRenderMode = 1;
pub const ZOOMSDK_ZoomSDKVideoRenderMode_ZoomSDKVideoRenderMode_D3D11EnableFLIP:
ZOOMSDK_ZoomSDKVideoRenderMode = 2;
pub const ZOOMSDK_ZoomSDKVideoRenderMode_ZoomSDKVideoRenderMode_D3D11:
ZOOMSDK_ZoomSDKVideoRenderMode = 3;
pub const ZOOMSDK_ZoomSDKVideoRenderMode_ZoomSDKVideoRenderMode_D3D9:
ZOOMSDK_ZoomSDKVideoRenderMode = 4;
pub const ZOOMSDK_ZoomSDKVideoRenderMode_ZoomSDKVideoRenderMode_GDI:
ZOOMSDK_ZoomSDKVideoRenderMode = 5;
pub type ZOOMSDK_ZoomSDKVideoRenderMode = ::std::os::raw::c_int;
pub const ZOOMSDK_ZoomSDKRenderPostProcessing_ZoomSDKRenderPostProcessing_None:
ZOOMSDK_ZoomSDKRenderPostProcessing = 0;
pub const ZOOMSDK_ZoomSDKRenderPostProcessing_ZoomSDKRenderPostProcessing_Auto:
ZOOMSDK_ZoomSDKRenderPostProcessing = 1;
pub const ZOOMSDK_ZoomSDKRenderPostProcessing_ZoomSDKRenderPostProcessing_Enable:
ZOOMSDK_ZoomSDKRenderPostProcessing = 2;
pub const ZOOMSDK_ZoomSDKRenderPostProcessing_ZoomSDKRenderPostProcessing_Disable:
ZOOMSDK_ZoomSDKRenderPostProcessing = 3;
pub type ZOOMSDK_ZoomSDKRenderPostProcessing = ::std::os::raw::c_int;
pub const ZOOMSDK_ZoomSDKVideoCaptureMethod_ZoomSDKVideoCaptureMethod_None:
ZOOMSDK_ZoomSDKVideoCaptureMethod = 0;
pub const ZOOMSDK_ZoomSDKVideoCaptureMethod_ZoomSDKVideoCaptureMethod_Auto:
ZOOMSDK_ZoomSDKVideoCaptureMethod = 1;
pub const ZOOMSDK_ZoomSDKVideoCaptureMethod_ZoomSDKVideoCaptureMethod_DirectSHow:
ZOOMSDK_ZoomSDKVideoCaptureMethod = 2;
pub const ZOOMSDK_ZoomSDKVideoCaptureMethod_ZoomSDKVideoCaptureMethod_MediaFoundation:
ZOOMSDK_ZoomSDKVideoCaptureMethod = 3;
pub type ZOOMSDK_ZoomSDKVideoCaptureMethod = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagZoomSDKRenderOptions {
pub videoRenderMode: ZOOMSDK_ZoomSDKVideoRenderMode,
pub renderPostProcessing: ZOOMSDK_ZoomSDKRenderPostProcessing,
pub videoCaptureMethod: ZOOMSDK_ZoomSDKVideoCaptureMethod,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagZoomSDKRenderOptions() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagZoomSDKRenderOptions>(),
12usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagZoomSDKRenderOptions))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagZoomSDKRenderOptions>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagZoomSDKRenderOptions))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagZoomSDKRenderOptions>())).videoRenderMode as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagZoomSDKRenderOptions),
"::",
stringify!(videoRenderMode)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagZoomSDKRenderOptions>())).renderPostProcessing
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagZoomSDKRenderOptions),
"::",
stringify!(renderPostProcessing)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagZoomSDKRenderOptions>())).videoCaptureMethod
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagZoomSDKRenderOptions),
"::",
stringify!(videoCaptureMethod)
)
);
}
pub type ZOOMSDK_ZoomSDKRenderOptions = ZOOMSDK_tagZoomSDKRenderOptions;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagRawDataOptions {
#[doc = "<false -- YUV420data, true -- intermediate data"]
pub enableRawdataIntermediateMode: bool,
pub videoRawdataMemoryMode: ZOOMSDK_ZoomSDKRawDataMemoryMode,
pub shareRawdataMemoryMode: ZOOMSDK_ZoomSDKRawDataMemoryMode,
pub audioRawdataMemoryMode: ZOOMSDK_ZoomSDKRawDataMemoryMode,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagRawDataOptions() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagRawDataOptions>(),
16usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagRawDataOptions))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagRawDataOptions>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagRawDataOptions))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagRawDataOptions>())).enableRawdataIntermediateMode
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagRawDataOptions),
"::",
stringify!(enableRawdataIntermediateMode)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagRawDataOptions>())).videoRawdataMemoryMode as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagRawDataOptions),
"::",
stringify!(videoRawdataMemoryMode)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagRawDataOptions>())).shareRawdataMemoryMode as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagRawDataOptions),
"::",
stringify!(shareRawdataMemoryMode)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagRawDataOptions>())).audioRawdataMemoryMode as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagRawDataOptions),
"::",
stringify!(audioRawdataMemoryMode)
)
);
}
pub type ZOOMSDK_RawDataOptions = ZOOMSDK_tagRawDataOptions;
#[doc = " \\struct tagInitParam"]
#[doc = "\\brief Initialize the SDK Parameter."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagInitParam {
#[doc = "<Web domain."]
pub strWebDomain: *const u16,
#[doc = "<Branding name."]
pub strBrandingName: *const u16,
#[doc = "<Support URL."]
pub strSupportUrl: *const u16,
#[doc = "<Resource module handle."]
pub hResInstance: *mut ::std::os::raw::c_void,
#[doc = "<The ID of the small icon on the window."]
pub uiWindowIconSmallID: ::std::os::raw::c_uint,
#[doc = "<The ID of the big Icon on the window."]
pub uiWindowIconBigID: ::std::os::raw::c_uint,
#[doc = "<The ID of the SDK language."]
pub emLanguageID: ZOOMSDK_SDK_LANGUAGE_ID,
#[doc = "<Enable generate dump file if the app crashed."]
pub enableGenerateDump: bool,
#[doc = "<Enable log feature."]
pub enableLogByDefault: bool,
#[doc = "<Size of a log file in M(megabyte). The default size is 5M. There are 5 log files in total and the file size varies from 1M to 50M."]
pub uiLogFileSize: ::std::os::raw::c_uint,
#[doc = "<The configuration options of the SDK."]
pub obConfigOpts: ZOOMSDK_ConfigurableOptions,
pub locale: ZOOMSDK_SDK_APP_Locale,
pub permonitor_awareness_mode: bool,
pub renderOpts: ZOOMSDK_ZoomSDKRenderOptions,
pub rawdataOpts: ZOOMSDK_RawDataOptions,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagInitParam() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagInitParam>(),
92usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagInitParam))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagInitParam>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagInitParam))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagInitParam>())).strWebDomain as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagInitParam),
"::",
stringify!(strWebDomain)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagInitParam>())).strBrandingName as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagInitParam),
"::",
stringify!(strBrandingName)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagInitParam>())).strSupportUrl as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagInitParam),
"::",
stringify!(strSupportUrl)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagInitParam>())).hResInstance as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagInitParam),
"::",
stringify!(hResInstance)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagInitParam>())).uiWindowIconSmallID as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagInitParam),
"::",
stringify!(uiWindowIconSmallID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagInitParam>())).uiWindowIconBigID as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagInitParam),
"::",
stringify!(uiWindowIconBigID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagInitParam>())).emLanguageID as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagInitParam),
"::",
stringify!(emLanguageID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagInitParam>())).enableGenerateDump as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagInitParam),
"::",
stringify!(enableGenerateDump)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagInitParam>())).enableLogByDefault as *const _ as usize
},
29usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagInitParam),
"::",
stringify!(enableLogByDefault)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagInitParam>())).uiLogFileSize as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagInitParam),
"::",
stringify!(uiLogFileSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagInitParam>())).obConfigOpts as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagInitParam),
"::",
stringify!(obConfigOpts)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZOOMSDK_tagInitParam>())).locale as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagInitParam),
"::",
stringify!(locale)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagInitParam>())).permonitor_awareness_mode as *const _
as usize
},
60usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagInitParam),
"::",
stringify!(permonitor_awareness_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZOOMSDK_tagInitParam>())).renderOpts as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagInitParam),
"::",
stringify!(renderOpts)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagInitParam>())).rawdataOpts as *const _ as usize
},
76usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagInitParam),
"::",
stringify!(rawdataOpts)
)
);
}
#[doc = " \\struct tagInitParam"]
#[doc = "\\brief Initialize the SDK Parameter."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_InitParam = ZOOMSDK_tagInitParam;
#[doc = "<No error."]
pub const ZOOMSDK_LastErrorType_LastErrorType_None: ZOOMSDK_LastErrorType = 0;
#[doc = "<Error during verification."]
pub const ZOOMSDK_LastErrorType_LastErrorType_Auth: ZOOMSDK_LastErrorType = 1;
#[doc = "<Error during login."]
pub const ZOOMSDK_LastErrorType_LastErrorType_Login: ZOOMSDK_LastErrorType = 2;
#[doc = "<The associated error with the meeting."]
pub const ZOOMSDK_LastErrorType_LastErrorType_Meeting: ZOOMSDK_LastErrorType = 3;
#[doc = "<The associated error with the SDK bottom layer."]
pub const ZOOMSDK_LastErrorType_LastErrorType_System: ZOOMSDK_LastErrorType = 4;
#[doc = " \\enum LastErrorType"]
#[doc = "\\brief The last error types of the SDK."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_LastErrorType = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IZoomLastError__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Error mechanism interface provided by the SDK"]
#[doc = "This feature is gradually improved, so some errors may not be supported."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IZoomLastError {
pub vtable_: *const ZOOMSDK_IZoomLastError__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IZoomLastError() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IZoomLastError>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IZoomLastError))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IZoomLastError>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IZoomLastError))
);
}
#[repr(C)]
pub struct ZOOMSDK_IList__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IList {
pub vtable_: *const ZOOMSDK_IList__bindgen_vtable,
}
extern "C" {
#[link_name = "\u{1}?_SDK_TEST_VIDEO_INIT_RECT@ZOOMSDK@@3UtagRECT@@B"]
pub static ZOOMSDK__SDK_TEST_VIDEO_INIT_RECT: RECT;
}
extern "C" {
#[doc = " \\brief Initialize ZOOM SDK."]
#[doc = " \\param [out] initParam Initialize the parameter of ZOOM SDK. For more details, see \\link InitParam \\endlink structure."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success."]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_InitSDK"]
pub fn ZOOMSDK_InitSDK(initParam: *mut ZOOMSDK_InitParam) -> ZOOMSDK_SDKError;
}
extern "C" {
#[link_name = "\u{1}_SwitchDomain"]
pub fn ZOOMSDK_SwitchDomain(new_domain: *const u16, bForce: bool) -> ZOOMSDK_SDKError;
}
extern "C" {
#[doc = " \\brief Create meeting service interface."]
#[doc = " \\param ppMeetingService An object pointer to the IMeetingService*."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success while the value of ppMeetingService is not NULL."]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_CreateMeetingService"]
pub fn ZOOMSDK_CreateMeetingService(
ppMeetingService: *mut *mut ZOOMSDK_IMeetingService,
) -> ZOOMSDK_SDKError;
}
extern "C" {
#[doc = " \\brief Destroy the specified meeting service Interface."]
#[doc = " \\param pMeetingService A pointer to the IMeetingService to be destroyed."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success."]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_DestroyMeetingService"]
pub fn ZOOMSDK_DestroyMeetingService(
pMeetingService: *mut ZOOMSDK_IMeetingService,
) -> ZOOMSDK_SDKError;
}
extern "C" {
#[doc = " \\brief Create authentication service interface."]
#[doc = " \\param ppAuthService An object pointer to the IAuthService*."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success while the value of ppAuthService is not NULL."]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_CreateAuthService"]
pub fn ZOOMSDK_CreateAuthService(
ppAuthService: *mut *mut ZOOMSDK_IAuthService,
) -> ZOOMSDK_SDKError;
}
extern "C" {
#[doc = " \\brief Destroy the specified authentication service interface."]
#[doc = " \\param pAuthService A pointer to the IAuthService to be destroyed."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success."]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_DestroyAuthService"]
pub fn ZOOMSDK_DestroyAuthService(pAuthService: *mut ZOOMSDK_IAuthService) -> ZOOMSDK_SDKError;
}
extern "C" {
#[doc = " \\brief Create setting service interface."]
#[doc = " \\param ppSettingService An object pointer to the ISettingService*."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success while the value of ppSettingService is not NULL."]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_CreateSettingService"]
pub fn ZOOMSDK_CreateSettingService(
ppSettingService: *mut *mut ZOOMSDK_ISettingService,
) -> ZOOMSDK_SDKError;
}
extern "C" {
#[doc = " \\brief Destroy the specified setting service interface."]
#[doc = " \\param pSettingService A pointer to the ISettingService to be destroyed."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success."]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_DestroySettingService"]
pub fn ZOOMSDK_DestroySettingService(
pSettingService: *mut ZOOMSDK_ISettingService,
) -> ZOOMSDK_SDKError;
}
extern "C" {
#[doc = " \\brief Create calender service interface."]
#[doc = " \\param ppCalenderService An object pointer to the ICalenderService*."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success while the value of ppCalenderService is not NULL."]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_CreateCalenderService"]
pub fn ZOOMSDK_CreateCalenderService(
ppCalenderService: *mut *mut ZOOMSDK_ICalenderService,
) -> ZOOMSDK_SDKError;
}
extern "C" {
#[doc = " \\brief Destroy the specified account service interface."]
#[doc = " \\param pCalenderService A pointer to the ICalenderService to be destroyed."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success."]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_DestroyCalenderService"]
pub fn ZOOMSDK_DestroyCalenderService(
pCalenderService: *mut ZOOMSDK_ICalenderService,
) -> ZOOMSDK_SDKError;
}
extern "C" {
#[doc = " \\brief Create pre-meeting service interface."]
#[doc = " \\param ppPreMeetingService An object pointer to the IPreMeetingService*."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success while the value of ppCalenderService is not NULL."]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_CreatePreMeetingService"]
pub fn ZOOMSDK_CreatePreMeetingService(
ppPreMeetingService: *mut *mut ZOOMSDK_IPreMeetingService,
) -> ZOOMSDK_SDKError;
}
extern "C" {
#[doc = " \\brief Destroy the specified pre-meeting service Interface"]
#[doc = " \\param pPreMeetingService A pointer to the IPreMeetingService to be destroyed."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success."]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_DestroyPreMeetingService"]
pub fn ZOOMSDK_DestroyPreMeetingService(
pPreMeetingService: *mut ZOOMSDK_IPreMeetingService,
) -> ZOOMSDK_SDKError;
}
extern "C" {
#[doc = " \\brief Create network connection helper interface."]
#[doc = " \\param ppNetworkHelper An object pointer to the INetworkConnectionHelper*."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success while the value of ppNetworkHelper is not NULL."]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_CreateNetworkConnectionHelper"]
pub fn ZOOMSDK_CreateNetworkConnectionHelper(
ppNetworkHelper: *mut *mut ZOOMSDK_INetworkConnectionHelper,
) -> ZOOMSDK_SDKError;
}
extern "C" {
#[doc = " \\brief Destroy the specified network connection helper interface."]
#[doc = " \\param pNetworkHelper A pointer to the INetworkConnectionHelper to be destroyed."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success."]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_DestroyNetworkConnectionHelper"]
pub fn ZOOMSDK_DestroyNetworkConnectionHelper(
pNetworkHelper: *mut ZOOMSDK_INetworkConnectionHelper,
) -> ZOOMSDK_SDKError;
}
extern "C" {
#[doc = " \\brief Clean up ZOOM SDK."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success."]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_CleanUPSDK"]
pub fn ZOOMSDK_CleanUPSDK() -> ZOOMSDK_SDKError;
}
extern "C" {
#[doc = " \\brief Get the version of ZOOM SDK."]
#[doc = " \\return The version of ZOOM SDK."]
#[link_name = "\u{1}_GetVersion"]
pub fn ZOOMSDK_GetVersion() -> *const u16;
}
extern "C" {
#[doc = " \\brief Get ZOOM last error interface."]
#[doc = " \\return If the function succeeds, the return value is an interface of ZOOM last error."]
#[doc = "If the function fails or there is no error, the return value is NULL."]
#[doc = " For more information, see \\link IZoomLastError \\endlink"]
#[link_name = "\u{1}_GetZoomLastError"]
pub fn ZOOMSDK_GetZoomLastError() -> *const ZOOMSDK_IZoomLastError;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IEmbeddedBrowser {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IUIHooker {
_unused: [u8; 0],
}
extern "C" {
#[doc = " \\brief Create an embedded browser interface."]
#[doc = " \\param ppEmbeddedBrowser An object pointer to the IEmbeddedBrowser*."]
#[doc = " \\param hwnd The handle of the window in which the browser object is embedded."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success, and ppEmbeddedBrowser is not NULL"]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_CreateEmbeddedBrowser"]
pub fn ZOOMSDK_CreateEmbeddedBrowser(
ppEmbeddedBrowser: *mut *mut ZOOMSDK_IEmbeddedBrowser,
hwnd: HWND,
) -> ZOOMSDK_SDKError;
}
extern "C" {
#[doc = " \\brief Destroy the embedded browser interface."]
#[doc = " \\param pEmbeddedBrowser A pointer to the IEmbeddedBrowser to be destroyed."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success."]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_DestroyEmbeddedBrowser"]
pub fn ZOOMSDK_DestroyEmbeddedBrowser(
pEmbeddedBrowser: *mut ZOOMSDK_IEmbeddedBrowser,
) -> ZOOMSDK_SDKError;
}
extern "C" {
#[doc = " \\brief Retrieve user Hooker interface."]
#[doc = " \\param ppUIHooker A pointer to the IUIHooker*."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success, and ppEmbeddedBrowser is not NULL"]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_RetrieveUIHooker"]
pub fn ZOOMSDK_RetrieveUIHooker(ppUIHooker: *mut *mut ZOOMSDK_IUIHooker) -> ZOOMSDK_SDKError;
}
extern "C" {
#[doc = " \\brief Retrieve customized resource helper interface."]
#[doc = " \\param ppCustomiezedResourceHelper A pointer to the ICustomizedResourceHelper*."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success, and ppCustomiezedResourceHelper is not NULL"]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_RetrieveCustomizedResourceHelper"]
pub fn ZOOMSDK_RetrieveCustomizedResourceHelper(
ppCustomiezedResourceHelper: *mut *mut ZOOMSDK_ICustomizedResourceHelper,
) -> ZOOMSDK_SDKError;
}
#[doc = "<API returns unknown error."]
pub const ZOOMSDK_PremeetingAPIResult_PREMETAPIRET_UNKNOW: ZOOMSDK_PremeetingAPIResult = 0;
#[doc = "<Calls API successfully."]
pub const ZOOMSDK_PremeetingAPIResult_PREMETAPIRET_SUCCESS: ZOOMSDK_PremeetingAPIResult = 1;
#[doc = " \\enum PremeetingAPIResult"]
#[doc = "\\brief The result of premeeting API request."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_PremeetingAPIResult = ::std::os::raw::c_int;
pub const ZOOMSDK_InterpreteLanguageInfo_LANGUAGEINFO_NONE: ZOOMSDK_InterpreteLanguageInfo = -1;
pub const ZOOMSDK_InterpreteLanguageInfo_LANGUAGEINFO_US: ZOOMSDK_InterpreteLanguageInfo = 0;
pub const ZOOMSDK_InterpreteLanguageInfo_LANGUAGEINFO_CN: ZOOMSDK_InterpreteLanguageInfo = 1;
pub const ZOOMSDK_InterpreteLanguageInfo_LANGUAGEINFO_JP: ZOOMSDK_InterpreteLanguageInfo = 2;
pub const ZOOMSDK_InterpreteLanguageInfo_LANGUAGEINFO_DE: ZOOMSDK_InterpreteLanguageInfo = 3;
pub const ZOOMSDK_InterpreteLanguageInfo_LANGUAGEINFO_FR: ZOOMSDK_InterpreteLanguageInfo = 4;
pub const ZOOMSDK_InterpreteLanguageInfo_LANGUAGEINFO_RU: ZOOMSDK_InterpreteLanguageInfo = 5;
pub const ZOOMSDK_InterpreteLanguageInfo_LANGUAGEINFO_PT: ZOOMSDK_InterpreteLanguageInfo = 6;
pub const ZOOMSDK_InterpreteLanguageInfo_LANGUAGEINFO_ES: ZOOMSDK_InterpreteLanguageInfo = 7;
pub const ZOOMSDK_InterpreteLanguageInfo_LANGUAGEINFO_KR: ZOOMSDK_InterpreteLanguageInfo = 8;
pub const ZOOMSDK_InterpreteLanguageInfo_LANGUAGEINFO_NUM: ZOOMSDK_InterpreteLanguageInfo = 9;
pub type ZOOMSDK_InterpreteLanguageInfo = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IInterpreterInfo__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IInterpreterInfo {
pub vtable_: *const ZOOMSDK_IInterpreterInfo__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IInterpreterInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IInterpreterInfo>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IInterpreterInfo))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IInterpreterInfo>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IInterpreterInfo))
);
}
#[repr(C)]
pub struct ZOOMSDK_IAlternativeHostInfo__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IAlternativeHostInfo {
pub vtable_: *const ZOOMSDK_IAlternativeHostInfo__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IAlternativeHostInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IAlternativeHostInfo>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IAlternativeHostInfo))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IAlternativeHostInfo>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IAlternativeHostInfo))
);
}
#[repr(C)]
pub struct ZOOMSDK_IQueryMeetingItemDateInfoHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief The interface to query the basic information of meeting."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IQueryMeetingItemDateInfoHelper {
pub vtable_: *const ZOOMSDK_IQueryMeetingItemDateInfoHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IQueryMeetingItemDateInfoHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IQueryMeetingItemDateInfoHelper>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IQueryMeetingItemDateInfoHelper)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IQueryMeetingItemDateInfoHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IQueryMeetingItemDateInfoHelper)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_ISelectMeetingItemDateHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief The interface to set the meeting basic information."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_ISelectMeetingItemDateHelper {
pub vtable_: *const ZOOMSDK_ISelectMeetingItemDateHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ISelectMeetingItemDateHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ISelectMeetingItemDateHelper>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_ISelectMeetingItemDateHelper)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ISelectMeetingItemDateHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ISelectMeetingItemDateHelper)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_ISelectMeetingItemDateHelperEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief The callback interface that the selected meeting status changes."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_ISelectMeetingItemDateHelperEvent {
pub vtable_: *const ZOOMSDK_ISelectMeetingItemDateHelperEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ISelectMeetingItemDateHelperEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ISelectMeetingItemDateHelperEvent>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_ISelectMeetingItemDateHelperEvent)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ISelectMeetingItemDateHelperEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ISelectMeetingItemDateHelperEvent)
)
);
}
#[doc = "<For initialization."]
pub const ZOOMSDK_SCHEDULEAUDIOTYPE_SCHEDULEAUDIOTYPE_none: ZOOMSDK_SCHEDULEAUDIOTYPE = 0;
#[doc = "<Support telephony."]
pub const ZOOMSDK_SCHEDULEAUDIOTYPE_SCHEDULEAUDIOTYPE_telephony: ZOOMSDK_SCHEDULEAUDIOTYPE = 2;
#[doc = "<Support VoiP."]
pub const ZOOMSDK_SCHEDULEAUDIOTYPE_SCHEDULEAUDIOTYPE_voip: ZOOMSDK_SCHEDULEAUDIOTYPE = 4;
#[doc = "<Support both telephony and VoiP."]
pub const ZOOMSDK_SCHEDULEAUDIOTYPE_SCHEDULEAUDIOTYPE_both: ZOOMSDK_SCHEDULEAUDIOTYPE = 8;
#[doc = "<Support the third audio device."]
pub const ZOOMSDK_SCHEDULEAUDIOTYPE_SCHEDULEAUDIOTYPE_3rd: ZOOMSDK_SCHEDULEAUDIOTYPE = 16;
#[doc = " \\enum SCHEDULEAUDIOTYPE"]
#[doc = "\\brief Specify the meeting audio type."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_SCHEDULEAUDIOTYPE = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IQueryMeetingItemTelAudioInfoHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief The interface to query the meeting telephony number information."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IQueryMeetingItemTelAudioInfoHelper {
pub vtable_: *const ZOOMSDK_IQueryMeetingItemTelAudioInfoHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IQueryMeetingItemTelAudioInfoHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IQueryMeetingItemTelAudioInfoHelper>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IQueryMeetingItemTelAudioInfoHelper)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IQueryMeetingItemTelAudioInfoHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IQueryMeetingItemTelAudioInfoHelper)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_ISelectMeetingItemTelAudioHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief The interface to set the meeting telephony numbers information."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_ISelectMeetingItemTelAudioHelper {
pub vtable_: *const ZOOMSDK_ISelectMeetingItemTelAudioHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ISelectMeetingItemTelAudioHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ISelectMeetingItemTelAudioHelper>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_ISelectMeetingItemTelAudioHelper)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ISelectMeetingItemTelAudioHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ISelectMeetingItemTelAudioHelper)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_ISelectMeetingItemAudioOptionHelperEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief The callback interface that the selected meeting audio function changes."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_ISelectMeetingItemAudioOptionHelperEvent {
pub vtable_: *const ZOOMSDK_ISelectMeetingItemAudioOptionHelperEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ISelectMeetingItemAudioOptionHelperEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ISelectMeetingItemAudioOptionHelperEvent>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_ISelectMeetingItemAudioOptionHelperEvent)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ISelectMeetingItemAudioOptionHelperEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ISelectMeetingItemAudioOptionHelperEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IQueryMeetingItemAudioOptionHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief The interface to query the meeting audio information."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IQueryMeetingItemAudioOptionHelper {
pub vtable_: *const ZOOMSDK_IQueryMeetingItemAudioOptionHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IQueryMeetingItemAudioOptionHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IQueryMeetingItemAudioOptionHelper>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IQueryMeetingItemAudioOptionHelper)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IQueryMeetingItemAudioOptionHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IQueryMeetingItemAudioOptionHelper)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_ISelectMeetingItemAudioOptionHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief The interface to set the meeting audio information."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_ISelectMeetingItemAudioOptionHelper {
pub vtable_: *const ZOOMSDK_ISelectMeetingItemAudioOptionHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ISelectMeetingItemAudioOptionHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ISelectMeetingItemAudioOptionHelper>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_ISelectMeetingItemAudioOptionHelper)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ISelectMeetingItemAudioOptionHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ISelectMeetingItemAudioOptionHelper)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IQueryMeetingItemVideoOptionHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief The interface to query meeting video information."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IQueryMeetingItemVideoOptionHelper {
pub vtable_: *const ZOOMSDK_IQueryMeetingItemVideoOptionHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IQueryMeetingItemVideoOptionHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IQueryMeetingItemVideoOptionHelper>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IQueryMeetingItemVideoOptionHelper)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IQueryMeetingItemVideoOptionHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IQueryMeetingItemVideoOptionHelper)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_ISelectMeetingItemVideoOptionHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief The interface to set the meeting video information."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_ISelectMeetingItemVideoOptionHelper {
pub vtable_: *const ZOOMSDK_ISelectMeetingItemVideoOptionHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ISelectMeetingItemVideoOptionHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ISelectMeetingItemVideoOptionHelper>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_ISelectMeetingItemVideoOptionHelper)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ISelectMeetingItemVideoOptionHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ISelectMeetingItemVideoOptionHelper)
)
);
}
#[doc = "<For initialization."]
pub const ZOOMSDK_SCHEDULERECTYPE_SCHEDULERecordType_none: ZOOMSDK_SCHEDULERECTYPE = 0;
#[doc = "<Cloud recording."]
pub const ZOOMSDK_SCHEDULERECTYPE_SCHEDULERecordType_Cloud: ZOOMSDK_SCHEDULERECTYPE = 1;
#[doc = "<Local recording."]
pub const ZOOMSDK_SCHEDULERECTYPE_SCHEDULERecordType_Local: ZOOMSDK_SCHEDULERECTYPE = 2;
#[doc = " \\enum SCHEDULERECTYPE"]
#[doc = "\\brief Specify the meeting recording type."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_SCHEDULERECTYPE = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_ISelectMeetingItemMeetingOptionHelperEvent__bindgen_vtable(
::std::os::raw::c_void,
);
#[doc = " \\brief The callback interface to configure the meeting basic information."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_ISelectMeetingItemMeetingOptionHelperEvent {
pub vtable_: *const ZOOMSDK_ISelectMeetingItemMeetingOptionHelperEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ISelectMeetingItemMeetingOptionHelperEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ISelectMeetingItemMeetingOptionHelperEvent>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_ISelectMeetingItemMeetingOptionHelperEvent)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ISelectMeetingItemMeetingOptionHelperEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ISelectMeetingItemMeetingOptionHelperEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IScheduleForUser__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief The interface of the user who can be specified as the host."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IScheduleForUser {
pub vtable_: *const ZOOMSDK_IScheduleForUser__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IScheduleForUser() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IScheduleForUser>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IScheduleForUser))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IScheduleForUser>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IScheduleForUser))
);
}
#[repr(C)]
pub struct ZOOMSDK_IQueryMeetingItemScheduleForHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief The interface to query the information of the user who is specified as the meeting host."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IQueryMeetingItemScheduleForHelper {
pub vtable_: *const ZOOMSDK_IQueryMeetingItemScheduleForHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IQueryMeetingItemScheduleForHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IQueryMeetingItemScheduleForHelper>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IQueryMeetingItemScheduleForHelper)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IQueryMeetingItemScheduleForHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IQueryMeetingItemScheduleForHelper)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_ISelectMeetingItemScheduleForHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief The meeting information interface to specify others as the host."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_ISelectMeetingItemScheduleForHelper {
pub vtable_: *const ZOOMSDK_ISelectMeetingItemScheduleForHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ISelectMeetingItemScheduleForHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ISelectMeetingItemScheduleForHelper>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_ISelectMeetingItemScheduleForHelper)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ISelectMeetingItemScheduleForHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ISelectMeetingItemScheduleForHelper)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IQueryMeetingItemMeetingOptionHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = "\\brief The interface to query the meeting basic configuration information."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IQueryMeetingItemMeetingOptionHelper {
pub vtable_: *const ZOOMSDK_IQueryMeetingItemMeetingOptionHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IQueryMeetingItemMeetingOptionHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IQueryMeetingItemMeetingOptionHelper>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IQueryMeetingItemMeetingOptionHelper)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IQueryMeetingItemMeetingOptionHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IQueryMeetingItemMeetingOptionHelper)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_ISelectMeetingItemMeetingOptionHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = "\\brief The interface to configure the meeting basic information."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_ISelectMeetingItemMeetingOptionHelper {
pub vtable_: *const ZOOMSDK_ISelectMeetingItemMeetingOptionHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ISelectMeetingItemMeetingOptionHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ISelectMeetingItemMeetingOptionHelper>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_ISelectMeetingItemMeetingOptionHelper)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ISelectMeetingItemMeetingOptionHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ISelectMeetingItemMeetingOptionHelper)
)
);
}
#[doc = "\\brief Meeting item information interface."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IMeetingItemInfo {
pub _base: ZOOMSDK_IQueryMeetingItemDateInfoHelper,
pub _base_1: ZOOMSDK_IQueryMeetingItemVideoOptionHelper,
pub _base_2: ZOOMSDK_IQueryMeetingItemAudioOptionHelper,
pub _base_3: ZOOMSDK_IQueryMeetingItemMeetingOptionHelper,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingItemInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingItemInfo>(),
16usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingItemInfo))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingItemInfo>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMeetingItemInfo))
);
}
#[doc = "\\brief The interface to query the meeting information."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IMeetingItemInfoQueryHelper {
pub _base: ZOOMSDK_IMeetingItemInfo,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingItemInfoQueryHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingItemInfoQueryHelper>(),
16usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingItemInfoQueryHelper))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingItemInfoQueryHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingItemInfoQueryHelper)
)
);
}
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IMeetingItemInfoSelectHelper {
pub _base: ZOOMSDK_ISelectMeetingItemDateHelper,
pub _base_1: ZOOMSDK_ISelectMeetingItemVideoOptionHelper,
pub _base_2: ZOOMSDK_ISelectMeetingItemAudioOptionHelper,
pub _base_3: ZOOMSDK_ISelectMeetingItemMeetingOptionHelper,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingItemInfoSelectHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingItemInfoSelectHelper>(),
16usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IMeetingItemInfoSelectHelper)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingItemInfoSelectHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingItemInfoSelectHelper)
)
);
}
#[doc = " \\brief The interface to configure the meeting information."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IScheduleMeetingItemStatusCallback {
pub _base: ZOOMSDK_ISelectMeetingItemDateHelperEvent,
pub _base_1: ZOOMSDK_ISelectMeetingItemAudioOptionHelperEvent,
pub _base_2: ZOOMSDK_ISelectMeetingItemMeetingOptionHelperEvent,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IScheduleMeetingItemStatusCallback() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IScheduleMeetingItemStatusCallback>(),
12usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IScheduleMeetingItemStatusCallback)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IScheduleMeetingItemStatusCallback>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IScheduleMeetingItemStatusCallback)
)
);
}
#[doc = " \\brief Schedule meeting item interface."]
#[doc = "The APIs are used to schedule meeting and edit scheduled meeting."]
#[doc = "You can create/destroy the interface via CreateScheduleMeetingItem and DestoryScheduleMeetingItem in IPreMeetingService"]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IScheduleMeetingItem {
pub _base: ZOOMSDK_IMeetingItemInfoSelectHelper,
pub _base_1: ZOOMSDK_IMeetingItemInfoQueryHelper,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IScheduleMeetingItem() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IScheduleMeetingItem>(),
32usize,
concat!("Size of: ", stringify!(ZOOMSDK_IScheduleMeetingItem))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IScheduleMeetingItem>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IScheduleMeetingItem))
);
}
#[repr(C)]
pub struct ZOOMSDK_IPreMeetingServiceEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Pre-meeting service event interface."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IPreMeetingServiceEvent {
pub vtable_: *const ZOOMSDK_IPreMeetingServiceEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IPreMeetingServiceEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IPreMeetingServiceEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IPreMeetingServiceEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IPreMeetingServiceEvent>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IPreMeetingServiceEvent))
);
}
#[repr(C)]
pub struct ZOOMSDK_IPreMeetingService__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Pre-meeting service interface."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IPreMeetingService {
pub vtable_: *const ZOOMSDK_IPreMeetingService__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IPreMeetingService() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IPreMeetingService>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IPreMeetingService))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IPreMeetingService>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IPreMeetingService))
);
}
#[repr(C)]
pub struct ZOOMSDK_IOutlookPluginIntegrationHelperEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Outlook plugin integration helper Callback event."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IOutlookPluginIntegrationHelperEvent {
pub vtable_: *const ZOOMSDK_IOutlookPluginIntegrationHelperEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IOutlookPluginIntegrationHelperEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IOutlookPluginIntegrationHelperEvent>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IOutlookPluginIntegrationHelperEvent)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IOutlookPluginIntegrationHelperEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IOutlookPluginIntegrationHelperEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IOutlookPluginIntegrationHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Outlook plugin integration helper interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IOutlookPluginIntegrationHelper {
pub vtable_: *const ZOOMSDK_IOutlookPluginIntegrationHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IOutlookPluginIntegrationHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IOutlookPluginIntegrationHelper>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IOutlookPluginIntegrationHelper)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IOutlookPluginIntegrationHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IOutlookPluginIntegrationHelper)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_ICalenderEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Calendar information interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_ICalenderEvent {
pub vtable_: *const ZOOMSDK_ICalenderEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ICalenderEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ICalenderEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ICalenderEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ICalenderEvent>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_ICalenderEvent))
);
}
#[doc = "<Verification successful."]
pub const ZOOMSDK_CalenderResult_CALENDER_SUCCESS: ZOOMSDK_CalenderResult = 0;
#[doc = "<Verification failed."]
pub const ZOOMSDK_CalenderResult_CALENDER_AUTH_ERROR: ZOOMSDK_CalenderResult = 1;
#[doc = "<Web API service error."]
pub const ZOOMSDK_CalenderResult_CALENDER_WEBAPI_ERROR: ZOOMSDK_CalenderResult = 2;
#[doc = "<Unknown error."]
pub const ZOOMSDK_CalenderResult_CALENDER_UNKNOW: ZOOMSDK_CalenderResult = 3;
#[doc = " \\enum CalenderResult"]
#[doc = "\\brief The type of calendar result."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_CalenderResult = ::std::os::raw::c_int;
#[doc = "<For initiation."]
pub const ZOOMSDK_CalenderAuthType_CalenderAuth_None: ZOOMSDK_CalenderAuthType = 0;
#[doc = "<Use OutlookExchange to verify."]
pub const ZOOMSDK_CalenderAuthType_CalenderAuth_OutlookExchage: ZOOMSDK_CalenderAuthType = 1;
#[doc = "<Use Google to verify. This function is currently invalid, hereby only for reservations."]
pub const ZOOMSDK_CalenderAuthType_CalenderAuth_Goole: ZOOMSDK_CalenderAuthType = 2;
#[doc = " \\enum CalenderAuthType"]
#[doc = "\\brief The type of calendar authority."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_CalenderAuthType = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_ICalenderServiceEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief calendar Service Callback Event."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_ICalenderServiceEvent {
pub vtable_: *const ZOOMSDK_ICalenderServiceEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ICalenderServiceEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ICalenderServiceEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ICalenderServiceEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ICalenderServiceEvent>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_ICalenderServiceEvent))
);
}
#[doc = " \\struct tagOutlookExchageAuth"]
#[doc = "\\brief The verification of SDK when use the Outlook Exchange."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagOutlookExchageAuth {
#[doc = "<The URL of server."]
pub serverUrl: *const u16,
#[doc = "<Username."]
pub userName: *const u16,
#[doc = "<The password of user."]
pub password: *const u16,
#[doc = "<The email box of user."]
pub calendaremail: *const u16,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagOutlookExchageAuth() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagOutlookExchageAuth>(),
16usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagOutlookExchageAuth))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagOutlookExchageAuth>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagOutlookExchageAuth))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagOutlookExchageAuth>())).serverUrl as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagOutlookExchageAuth),
"::",
stringify!(serverUrl)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagOutlookExchageAuth>())).userName as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagOutlookExchageAuth),
"::",
stringify!(userName)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagOutlookExchageAuth>())).password as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagOutlookExchageAuth),
"::",
stringify!(password)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagOutlookExchageAuth>())).calendaremail as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagOutlookExchageAuth),
"::",
stringify!(calendaremail)
)
);
}
#[doc = " \\struct tagOutlookExchageAuth"]
#[doc = "\\brief The verification of SDK when use the Outlook Exchange."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_OutlookExchageAuth = ZOOMSDK_tagOutlookExchageAuth;
#[repr(C)]
pub struct ZOOMSDK_ICalenderService__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief calendar Service Interface"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_ICalenderService {
pub vtable_: *const ZOOMSDK_ICalenderService__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ICalenderService() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ICalenderService>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ICalenderService))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ICalenderService>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_ICalenderService))
);
}
#[doc = "<Only for initialization."]
pub const ZOOMSDK_DirectShareStatusStatus_Enum_DirectShare_Unknown:
ZOOMSDK_DirectShareStatusStatus_Enum = 0;
#[doc = "<Waiting for enabling the direct sharing."]
pub const ZOOMSDK_DirectShareStatusStatus_Enum_DirectShare_Connecting:
ZOOMSDK_DirectShareStatusStatus_Enum = 1;
#[doc = "<In direct sharing mode."]
pub const ZOOMSDK_DirectShareStatusStatus_Enum_DirectShare_In_Direct_Share_Mode:
ZOOMSDK_DirectShareStatusStatus_Enum = 2;
#[doc = "<End the direct sharing."]
pub const ZOOMSDK_DirectShareStatusStatus_Enum_DirectShare_Ended:
ZOOMSDK_DirectShareStatusStatus_Enum = 3;
#[doc = "<Re-enter the meeting ID/paring code."]
pub const ZOOMSDK_DirectShareStatusStatus_Enum_DirectShare_Need_MeetingID_Or_PairingCode:
ZOOMSDK_DirectShareStatusStatus_Enum = 4;
#[doc = "<Network error. Please try again later."]
pub const ZOOMSDK_DirectShareStatusStatus_Enum_DirectShare_NetWork_Error:
ZOOMSDK_DirectShareStatusStatus_Enum = 5;
#[doc = "<Other errors. Mainly occur in SIP call mode."]
pub const ZOOMSDK_DirectShareStatusStatus_Enum_DirectShare_Other_Error:
ZOOMSDK_DirectShareStatusStatus_Enum = 6;
#[doc = "<Wrong meeting id or sharing key."]
pub const ZOOMSDK_DirectShareStatusStatus_Enum_DirectShare_WrongMeetingID_Or_SharingKey:
ZOOMSDK_DirectShareStatusStatus_Enum = 7;
#[doc = " \\enum DirectShareStatusStatus_Enum"]
#[doc = "\\brief Direct sharing status."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_DirectShareStatusStatus_Enum = ::std::os::raw::c_int;
#[doc = " \\enum DirectShareStatusStatus_Enum"]
#[doc = "\\brief Direct sharing status."]
#[doc = "Here are more detailed structural descriptions."]
pub use self::ZOOMSDK_DirectShareStatusStatus_Enum as ZOOMSDK_DirectShareStatus;
#[repr(C)]
pub struct ZOOMSDK_IDirectShareViaMeetingIDOrPairingCodeHandler__bindgen_vtable(
::std::os::raw::c_void,
);
#[doc = " \\brief Direct sharing by meeting ID or pairing code helper interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IDirectShareViaMeetingIDOrPairingCodeHandler {
pub vtable_: *const ZOOMSDK_IDirectShareViaMeetingIDOrPairingCodeHandler__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IDirectShareViaMeetingIDOrPairingCodeHandler() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IDirectShareViaMeetingIDOrPairingCodeHandler>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IDirectShareViaMeetingIDOrPairingCodeHandler)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IDirectShareViaMeetingIDOrPairingCodeHandler>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IDirectShareViaMeetingIDOrPairingCodeHandler)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IDirectShareServiceHelperEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Direct sharing helper callback event."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IDirectShareServiceHelperEvent {
pub vtable_: *const ZOOMSDK_IDirectShareServiceHelperEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IDirectShareServiceHelperEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IDirectShareServiceHelperEvent>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IDirectShareServiceHelperEvent)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IDirectShareServiceHelperEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IDirectShareServiceHelperEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IDirectShareServiceHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Direct sharing helper Interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IDirectShareServiceHelper {
pub vtable_: *const ZOOMSDK_IDirectShareServiceHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IDirectShareServiceHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IDirectShareServiceHelper>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IDirectShareServiceHelper))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IDirectShareServiceHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IDirectShareServiceHelper)
)
);
}
#[doc = " \\struct tagProxySettings"]
#[doc = "\\brief The proxy that the user want to use according to the net environment."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagProxySettings {
#[doc = "<The proxy ip address and port that user want to use, should be organized like ip:port, such as '255.255.255.255:8080'. Use ';' to separate multi proxies."]
pub proxy: *const u16,
#[doc = "<TRUE indicates automatic detection."]
pub auto_detect: bool,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagProxySettings() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagProxySettings>(),
8usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagProxySettings))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagProxySettings>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagProxySettings))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZOOMSDK_tagProxySettings>())).proxy as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagProxySettings),
"::",
stringify!(proxy)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagProxySettings>())).auto_detect as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagProxySettings),
"::",
stringify!(auto_detect)
)
);
}
#[doc = " \\struct tagProxySettings"]
#[doc = "\\brief The proxy that the user want to use according to the net environment."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_ProxySettings = ZOOMSDK_tagProxySettings;
#[repr(C)]
pub struct ZOOMSDK_IProxySettingHandler__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Proxy setting information callback interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IProxySettingHandler {
pub vtable_: *const ZOOMSDK_IProxySettingHandler__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IProxySettingHandler() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IProxySettingHandler>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IProxySettingHandler))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IProxySettingHandler>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IProxySettingHandler))
);
}
#[repr(C)]
pub struct ZOOMSDK_ISSLCertVerificationHandler__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Verification of the SSL certificate callback interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_ISSLCertVerificationHandler {
pub vtable_: *const ZOOMSDK_ISSLCertVerificationHandler__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ISSLCertVerificationHandler() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ISSLCertVerificationHandler>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ISSLCertVerificationHandler))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ISSLCertVerificationHandler>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ISSLCertVerificationHandler)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_INetworkConnectionHandler__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief The network connection handler callback event."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_INetworkConnectionHandler {
pub vtable_: *const ZOOMSDK_INetworkConnectionHandler__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_INetworkConnectionHandler() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_INetworkConnectionHandler>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_INetworkConnectionHandler))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_INetworkConnectionHandler>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_INetworkConnectionHandler)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_INetworkConnectionHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief The network connection helper interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_INetworkConnectionHelper {
pub vtable_: *const ZOOMSDK_INetworkConnectionHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_INetworkConnectionHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_INetworkConnectionHelper>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_INetworkConnectionHelper))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_INetworkConnectionHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_INetworkConnectionHelper)
)
);
}
#[doc = "<Authentication is successful."]
pub const ZOOMSDK_AuthResult_AUTHRET_SUCCESS: ZOOMSDK_AuthResult = 0;
#[doc = "<The key or secret to authenticate is empty."]
pub const ZOOMSDK_AuthResult_AUTHRET_KEYORSECRETEMPTY: ZOOMSDK_AuthResult = 1;
#[doc = "<The key or secret to authenticate is wrong."]
pub const ZOOMSDK_AuthResult_AUTHRET_KEYORSECRETWRONG: ZOOMSDK_AuthResult = 2;
#[doc = "<The user account does not support."]
pub const ZOOMSDK_AuthResult_AUTHRET_ACCOUNTNOTSUPPORT: ZOOMSDK_AuthResult = 3;
#[doc = "<The user account is not enabled for SDK."]
pub const ZOOMSDK_AuthResult_AUTHRET_ACCOUNTNOTENABLESDK: ZOOMSDK_AuthResult = 4;
#[doc = "<Unknown error."]
pub const ZOOMSDK_AuthResult_AUTHRET_UNKNOWN: ZOOMSDK_AuthResult = 5;
#[doc = "<Service is busy."]
pub const ZOOMSDK_AuthResult_AUTHRET_SERVICE_BUSY: ZOOMSDK_AuthResult = 6;
#[doc = "<Initial status."]
pub const ZOOMSDK_AuthResult_AUTHRET_NONE: ZOOMSDK_AuthResult = 7;
#[doc = "<Time out."]
pub const ZOOMSDK_AuthResult_AUTHRET_OVERTIME: ZOOMSDK_AuthResult = 8;
#[doc = "<Network issues."]
pub const ZOOMSDK_AuthResult_AUTHRET_NETWORKISSUE: ZOOMSDK_AuthResult = 9;
pub const ZOOMSDK_AuthResult_AUTHRET_CLIENT_INCOMPATIBLE: ZOOMSDK_AuthResult = 10;
#[doc = " \\enum AuthResult"]
#[doc = "\\brief SDK Authentication Result."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_AuthResult = ::std::os::raw::c_int;
#[doc = "<Unlogged in."]
pub const ZOOMSDK_LOGINSTATUS_LOGIN_IDLE: ZOOMSDK_LOGINSTATUS = 0;
#[doc = "<In process of login."]
pub const ZOOMSDK_LOGINSTATUS_LOGIN_PROCESSING: ZOOMSDK_LOGINSTATUS = 1;
#[doc = "<Login successful."]
pub const ZOOMSDK_LOGINSTATUS_LOGIN_SUCCESS: ZOOMSDK_LOGINSTATUS = 2;
#[doc = "<Login failed."]
pub const ZOOMSDK_LOGINSTATUS_LOGIN_FAILED: ZOOMSDK_LOGINSTATUS = 3;
#[doc = " \\enum LOGINSTATUS"]
#[doc = "\\brief Login status."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_LOGINSTATUS = ::std::os::raw::c_int;
#[doc = " \\struct tagAuthParam"]
#[doc = "\\brief SDK Authentication parameter with sdk key/secret."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagAuthParam {
#[doc = "<APP Key string."]
pub appKey: *const u16,
#[doc = "<APP Secret string."]
pub appSecret: *const u16,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagAuthParam() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagAuthParam>(),
8usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagAuthParam))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagAuthParam>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagAuthParam))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZOOMSDK_tagAuthParam>())).appKey as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagAuthParam),
"::",
stringify!(appKey)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZOOMSDK_tagAuthParam>())).appSecret as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagAuthParam),
"::",
stringify!(appSecret)
)
);
}
#[doc = " \\struct tagAuthParam"]
#[doc = "\\brief SDK Authentication parameter with sdk key/secret."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_AuthParam = ZOOMSDK_tagAuthParam;
#[doc = " \\struct tagAuthContext"]
#[doc = "\\brief SDK Authentication parameter with jwt token."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagAuthContext {
pub jwt_token: *const u16,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagAuthContext() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagAuthContext>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagAuthContext))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagAuthContext>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagAuthContext))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagAuthContext>())).jwt_token as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagAuthContext),
"::",
stringify!(jwt_token)
)
);
}
#[doc = " \\struct tagAuthContext"]
#[doc = "\\brief SDK Authentication parameter with jwt token."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_AuthContext = ZOOMSDK_tagAuthContext;
#[doc = "<Unknown type."]
pub const ZOOMSDK_LoginType_LoginType_Unknown: ZOOMSDK_LoginType = 0;
#[doc = "<Login with work mailbox."]
pub const ZOOMSDK_LoginType_LoginType_Email: ZOOMSDK_LoginType = 1;
#[doc = "<Login with SSO token."]
pub const ZOOMSDK_LoginType_LoginType_SSO: ZOOMSDK_LoginType = 2;
#[doc = " \\enum LoginType"]
#[doc = "\\brief User login type."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_LoginType = ::std::os::raw::c_int;
#[doc = " \\struct tagLoginParam4Email"]
#[doc = "\\brief SDK parameter for login via email."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagLoginParam4Email {
#[doc = "<Username. It is usually working mailbox or other mailbox."]
pub userName: *const u16,
#[doc = "<Account password."]
pub password: *const u16,
#[doc = "<True indicates to save the information for next login."]
pub bRememberMe: bool,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagLoginParam4Email() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagLoginParam4Email>(),
12usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagLoginParam4Email))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagLoginParam4Email>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagLoginParam4Email))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagLoginParam4Email>())).userName as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagLoginParam4Email),
"::",
stringify!(userName)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagLoginParam4Email>())).password as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagLoginParam4Email),
"::",
stringify!(password)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagLoginParam4Email>())).bRememberMe as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagLoginParam4Email),
"::",
stringify!(bRememberMe)
)
);
}
#[doc = " \\struct tagLoginParam4Email"]
#[doc = "\\brief SDK parameter for login via email."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_LoginParam4Email = ZOOMSDK_tagLoginParam4Email;
#[doc = " \\struct tagLoginParam4SSO"]
#[doc = "\\brief SDK parameter for login via SSO."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagLoginParam4SSO {
#[doc = "<Account SSO token when logging."]
pub ssoToken: *const u16,
#[doc = "<True indicates to save the information for next login."]
pub bRememberMe: bool,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagLoginParam4SSO() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagLoginParam4SSO>(),
8usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagLoginParam4SSO))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagLoginParam4SSO>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagLoginParam4SSO))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagLoginParam4SSO>())).ssoToken as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagLoginParam4SSO),
"::",
stringify!(ssoToken)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagLoginParam4SSO>())).bRememberMe as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagLoginParam4SSO),
"::",
stringify!(bRememberMe)
)
);
}
#[doc = " \\struct tagLoginParam4SSO"]
#[doc = "\\brief SDK parameter for login via SSO."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_LoginParam4SSO = ZOOMSDK_tagLoginParam4SSO;
#[doc = " \\struct tagLoginParam"]
#[doc = "\\brief Account login parameter."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ZOOMSDK_tagLoginParam {
#[doc = "<Type of login."]
pub loginType: ZOOMSDK_LoginType,
pub ut: ZOOMSDK_tagLoginParam__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ZOOMSDK_tagLoginParam__bindgen_ty_1 {
#[doc = "<Login with mailbox."]
pub emailLogin: ZOOMSDK_LoginParam4Email,
#[doc = "<Login with SSO token."]
pub ssoLogin: ZOOMSDK_LoginParam4SSO,
_bindgen_union_align: [u32; 3usize],
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagLoginParam__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagLoginParam__bindgen_ty_1>(),
12usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagLoginParam__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagLoginParam__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagLoginParam__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagLoginParam__bindgen_ty_1>())).emailLogin as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagLoginParam__bindgen_ty_1),
"::",
stringify!(emailLogin)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagLoginParam__bindgen_ty_1>())).ssoLogin as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagLoginParam__bindgen_ty_1),
"::",
stringify!(ssoLogin)
)
);
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagLoginParam() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagLoginParam>(),
16usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagLoginParam))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagLoginParam>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagLoginParam))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZOOMSDK_tagLoginParam>())).loginType as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagLoginParam),
"::",
stringify!(loginType)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZOOMSDK_tagLoginParam>())).ut as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagLoginParam),
"::",
stringify!(ut)
)
);
}
#[doc = " \\struct tagLoginParam"]
#[doc = "\\brief Account login parameter."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_LoginParam = ZOOMSDK_tagLoginParam;
#[repr(C)]
pub struct ZOOMSDK_IAccountInfo__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Account information interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IAccountInfo {
pub vtable_: *const ZOOMSDK_IAccountInfo__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IAccountInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IAccountInfo>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IAccountInfo))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IAccountInfo>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IAccountInfo))
);
}
#[repr(C)]
pub struct ZOOMSDK_IAuthServiceEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Authentication service callback event."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IAuthServiceEvent {
pub vtable_: *const ZOOMSDK_IAuthServiceEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IAuthServiceEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IAuthServiceEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IAuthServiceEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IAuthServiceEvent>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IAuthServiceEvent))
);
}
#[repr(C)]
pub struct ZOOMSDK_IAuthService__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Authentication Service Interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IAuthService {
pub vtable_: *const ZOOMSDK_IAuthService__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IAuthService() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IAuthService>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IAuthService))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IAuthService>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IAuthService))
);
}
#[doc = "<No meeting is running."]
pub const ZOOMSDK_MeetingStatus_MEETING_STATUS_IDLE: ZOOMSDK_MeetingStatus = 0;
#[doc = "<Connect to the meeting server status."]
pub const ZOOMSDK_MeetingStatus_MEETING_STATUS_CONNECTING: ZOOMSDK_MeetingStatus = 1;
#[doc = "<Waiting for the host to start the meeting."]
pub const ZOOMSDK_MeetingStatus_MEETING_STATUS_WAITINGFORHOST: ZOOMSDK_MeetingStatus = 2;
#[doc = "<Meeting is ready, in meeting status."]
pub const ZOOMSDK_MeetingStatus_MEETING_STATUS_INMEETING: ZOOMSDK_MeetingStatus = 3;
#[doc = "<Disconnect the meeting server, leave meeting status."]
pub const ZOOMSDK_MeetingStatus_MEETING_STATUS_DISCONNECTING: ZOOMSDK_MeetingStatus = 4;
#[doc = "<Reconnecting meeting server status."]
pub const ZOOMSDK_MeetingStatus_MEETING_STATUS_RECONNECTING: ZOOMSDK_MeetingStatus = 5;
#[doc = "<Failed to connect the meeting server."]
pub const ZOOMSDK_MeetingStatus_MEETING_STATUS_FAILED: ZOOMSDK_MeetingStatus = 6;
#[doc = "<Meeting ends."]
pub const ZOOMSDK_MeetingStatus_MEETING_STATUS_ENDED: ZOOMSDK_MeetingStatus = 7;
#[doc = "<Unknown status."]
pub const ZOOMSDK_MeetingStatus_MEETING_STATUS_UNKNOW: ZOOMSDK_MeetingStatus = 8;
#[doc = "<Meeting is locked to prevent the further participants to join the meeting."]
pub const ZOOMSDK_MeetingStatus_MEETING_STATUS_LOCKED: ZOOMSDK_MeetingStatus = 9;
#[doc = "<Meeting is open and participants can join the meeting."]
pub const ZOOMSDK_MeetingStatus_MEETING_STATUS_UNLOCKED: ZOOMSDK_MeetingStatus = 10;
#[doc = "<Participants who join the meeting before the start are in the waiting room."]
pub const ZOOMSDK_MeetingStatus_MEETING_STATUS_IN_WAITING_ROOM: ZOOMSDK_MeetingStatus = 11;
#[doc = "<Upgrade the attendees to panelist in webinar."]
pub const ZOOMSDK_MeetingStatus_MEETING_STATUS_WEBINAR_PROMOTE: ZOOMSDK_MeetingStatus = 12;
#[doc = "<Downgrade the attendees from the panelist."]
pub const ZOOMSDK_MeetingStatus_MEETING_STATUS_WEBINAR_DEPROMOTE: ZOOMSDK_MeetingStatus = 13;
#[doc = "<Join the breakout room."]
pub const ZOOMSDK_MeetingStatus_MEETING_STATUS_JOIN_BREAKOUT_ROOM: ZOOMSDK_MeetingStatus = 14;
#[doc = "<Leave the breakout room."]
pub const ZOOMSDK_MeetingStatus_MEETING_STATUS_LEAVE_BREAKOUT_ROOM: ZOOMSDK_MeetingStatus = 15;
#[doc = "<Waiting for the additional secret key."]
pub const ZOOMSDK_MeetingStatus_MEETING_STATUS_WAITING_EXTERNAL_SESSION_KEY: ZOOMSDK_MeetingStatus =
16;
#[doc = " \\enum MeetingStatus"]
#[doc = "\\brief Meeting status."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_MeetingStatus = ::std::os::raw::c_int;
#[doc = "<Start meeting successfully."]
pub const ZOOMSDK_MeetingFailCode_MEETING_SUCCESS: ZOOMSDK_MeetingFailCode = 0;
#[doc = "<Network error."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_NETWORK_ERR: ZOOMSDK_MeetingFailCode = 1;
#[doc = "<Reconnect error."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_RECONNECT_ERR: ZOOMSDK_MeetingFailCode = 2;
#[doc = "<Multi-media Router error."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_MMR_ERR: ZOOMSDK_MeetingFailCode = 3;
#[doc = "<Password is wrong."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_PASSWORD_ERR: ZOOMSDK_MeetingFailCode = 4;
#[doc = "<Session error."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_SESSION_ERR: ZOOMSDK_MeetingFailCode = 5;
#[doc = "<Meeting is over."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_MEETING_OVER: ZOOMSDK_MeetingFailCode = 6;
#[doc = "<Meeting has not begun."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_MEETING_NOT_START: ZOOMSDK_MeetingFailCode = 7;
#[doc = "<Meeting does not exist."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_MEETING_NOT_EXIST: ZOOMSDK_MeetingFailCode = 8;
#[doc = "<The capacity of meeting is full."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_MEETING_USER_FULL: ZOOMSDK_MeetingFailCode = 9;
#[doc = "<The client is incompatible."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_CLIENT_INCOMPATIBLE: ZOOMSDK_MeetingFailCode = 10;
#[doc = "<The Multi-media router is not founded."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_NO_MMR: ZOOMSDK_MeetingFailCode = 11;
#[doc = "<The meeting is locked."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_CONFLOCKED: ZOOMSDK_MeetingFailCode = 12;
#[doc = "<The meeting is failed because of the restriction by the same account."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_MEETING_RESTRICTED: ZOOMSDK_MeetingFailCode = 13;
#[doc = "<The meeting is restricted by the same account while the attendee is allowed to join before the host."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_MEETING_RESTRICTED_JBH: ZOOMSDK_MeetingFailCode = 14;
#[doc = "<Unable to send web request."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_CANNOT_EMIT_WEBREQUEST: ZOOMSDK_MeetingFailCode = 15;
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_CANNOT_START_TOKENEXPIRE: ZOOMSDK_MeetingFailCode =
16;
#[doc = "<Video hardware or software error."]
pub const ZOOMSDK_MeetingFailCode_SESSION_VIDEO_ERR: ZOOMSDK_MeetingFailCode = 17;
#[doc = "<Audio autostart error."]
pub const ZOOMSDK_MeetingFailCode_SESSION_AUDIO_AUTOSTARTERR: ZOOMSDK_MeetingFailCode = 18;
#[doc = "<The number of webinar registered has reached the upper limit."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_REGISTERWEBINAR_FULL: ZOOMSDK_MeetingFailCode = 19;
#[doc = "<Register webinar with the role of webinar host."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_REGISTERWEBINAR_HOSTREGISTER:
ZOOMSDK_MeetingFailCode = 20;
#[doc = "<Register webinar with the role of panelist member."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_REGISTERWEBINAR_PANELISTREGISTER:
ZOOMSDK_MeetingFailCode = 21;
#[doc = "<Register webinar with the denied email."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_REGISTERWEBINAR_DENIED_EMAIL:
ZOOMSDK_MeetingFailCode = 22;
#[doc = "<Webinar request to login."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_ENFORCE_LOGIN: ZOOMSDK_MeetingFailCode = 23;
#[doc = "<Invalid for Windows SDK."]
pub const ZOOMSDK_MeetingFailCode_CONF_FAIL_ZC_CERTIFICATE_CHANGED: ZOOMSDK_MeetingFailCode = 24;
#[doc = "<Vanity conference ID does not exist."]
pub const ZOOMSDK_MeetingFailCode_CONF_FAIL_VANITY_NOT_EXIST: ZOOMSDK_MeetingFailCode = 27;
#[doc = "<Join webinar with the same email."]
pub const ZOOMSDK_MeetingFailCode_CONF_FAIL_JOIN_WEBINAR_WITHSAMEEMAIL: ZOOMSDK_MeetingFailCode =
28;
#[doc = "<Meeting settings is not allowed to start a meeting."]
pub const ZOOMSDK_MeetingFailCode_CONF_FAIL_DISALLOW_HOST_MEETING: ZOOMSDK_MeetingFailCode = 29;
#[doc = "<Disabled to write the configure file."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_WRITE_CONFIG_FILE: ZOOMSDK_MeetingFailCode = 50;
#[doc = "<Forbidden to join the internal meeting."]
pub const ZOOMSDK_MeetingFailCode_MEETING_FAIL_FORBID_TO_JOIN_INTERNAL_MEETING:
ZOOMSDK_MeetingFailCode = 60;
#[doc = "<Removed by the host."]
pub const ZOOMSDK_MeetingFailCode_CONF_FAIL_REMOVED_BY_HOST: ZOOMSDK_MeetingFailCode = 61;
#[doc = " \\enum MeetingFailCode."]
#[doc = "\\brief Meeting failure code."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_MeetingFailCode = ::std::os::raw::c_int;
#[doc = "<For initialization."]
pub const ZOOMSDK_MeetingEndReason_EndMeetingReason_None: ZOOMSDK_MeetingEndReason = 0;
#[doc = "<Kicked by host."]
pub const ZOOMSDK_MeetingEndReason_EndMeetingReason_KickByHost: ZOOMSDK_MeetingEndReason = 1;
#[doc = "<Ended by host."]
pub const ZOOMSDK_MeetingEndReason_EndMeetingReason_EndByHost: ZOOMSDK_MeetingEndReason = 2;
#[doc = "<JBH times out."]
pub const ZOOMSDK_MeetingEndReason_EndMeetingReason_JBHTimeOut: ZOOMSDK_MeetingEndReason = 3;
#[doc = "<No attendee."]
pub const ZOOMSDK_MeetingEndReason_EndMeetingReason_NoAttendee: ZOOMSDK_MeetingEndReason = 4;
#[doc = "<Host starts another meeting."]
pub const ZOOMSDK_MeetingEndReason_EndMeetingReason_HostStartAnotherMeeting:
ZOOMSDK_MeetingEndReason = 5;
#[doc = "<Free meeting times out."]
pub const ZOOMSDK_MeetingEndReason_EndMeetingReason_FreeMeetingTimeOut: ZOOMSDK_MeetingEndReason =
6;
#[doc = "<Network is broken."]
pub const ZOOMSDK_MeetingEndReason_EndMeetingReason_NetworkBroken: ZOOMSDK_MeetingEndReason = 7;
#[doc = " \\enum MeetingEndReason"]
#[doc = "\\brief Meeting end reason."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_MeetingEndReason = ::std::os::raw::c_int;
#[doc = "<For initialization."]
pub const ZOOMSDK_MeetingType_MEETING_TYPE_NONE: ZOOMSDK_MeetingType = 0;
#[doc = "<Ordinary meeting."]
pub const ZOOMSDK_MeetingType_MEETING_TYPE_NORMAL: ZOOMSDK_MeetingType = 1;
#[doc = "<Webinar."]
pub const ZOOMSDK_MeetingType_MEETING_TYPE_WEBINAR: ZOOMSDK_MeetingType = 2;
#[doc = "<Breakout meeting."]
pub const ZOOMSDK_MeetingType_MEETING_TYPE_BREAKOUTROOM: ZOOMSDK_MeetingType = 3;
#[doc = " \\enum MeetingType"]
#[doc = "\\brief Meeting type."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_MeetingType = ::std::os::raw::c_int;
#[doc = "<Leave meeting"]
pub const ZOOMSDK_LeaveMeetingCmd_LEAVE_MEETING: ZOOMSDK_LeaveMeetingCmd = 0;
#[doc = "<End meeting"]
pub const ZOOMSDK_LeaveMeetingCmd_END_MEETING: ZOOMSDK_LeaveMeetingCmd = 1;
#[doc = " \\enum LeaveMeetingCmd"]
#[doc = "\\brief Leave meeting command."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_LeaveMeetingCmd = ::std::os::raw::c_int;
#[doc = "<Type of ordinary user who needs to login."]
pub const ZOOMSDK_SDKUserType_SDK_UT_NORMALUSER: ZOOMSDK_SDKUserType = 100;
#[doc = "<Start meeting without login."]
pub const ZOOMSDK_SDKUserType_SDK_UT_WITHOUT_LOGIN: ZOOMSDK_SDKUserType = 101;
#[doc = " \\enum SDKUserType"]
#[doc = "\\brief SDK user type."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_SDKUserType = ::std::os::raw::c_int;
#[doc = " \\struct tagJoinParam4WithoutLogin"]
#[doc = "\\brief The parameters of non-login user when joins the meeting."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagJoinParam4WithoutLogin {
#[doc = "< Meeting number."]
pub meetingNumber: UINT64,
#[doc = "<Meeting vanity ID"]
pub vanityID: *const u16,
#[doc = "<Username when logged in the meeting."]
pub userName: *const u16,
#[doc = "<Meeting password."]
pub psw: *const u16,
#[doc = "<The window handle of the direct Sharing application."]
pub hDirectShareAppWnd: HWND,
#[doc = "<ZOOM access token."]
pub userZAK: *const u16,
#[doc = "<The ID of attendees. The SDK will set this value when the associated settings are turned on."]
pub participantId: *const u16,
#[doc = "<Webinar token."]
pub webinarToken: *const u16,
#[doc = "<Share the desktop directly or not. True indicates to Share."]
pub isDirectShareDesktop: bool,
#[doc = "<Turn off the video of not. True indicates to turn off. In addition, this flag is affected by meeting attributes."]
pub isVideoOff: bool,
#[doc = "<Turn off the audio or not. True indicates to turn off. In addition, this flag is affected by meeting attributes."]
pub isAudioOff: bool,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagJoinParam4WithoutLogin() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagJoinParam4WithoutLogin>(),
40usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagJoinParam4WithoutLogin))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagJoinParam4WithoutLogin>(),
8usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagJoinParam4WithoutLogin)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4WithoutLogin>())).meetingNumber as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4WithoutLogin),
"::",
stringify!(meetingNumber)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4WithoutLogin>())).vanityID as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4WithoutLogin),
"::",
stringify!(vanityID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4WithoutLogin>())).userName as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4WithoutLogin),
"::",
stringify!(userName)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4WithoutLogin>())).psw as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4WithoutLogin),
"::",
stringify!(psw)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4WithoutLogin>())).hDirectShareAppWnd
as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4WithoutLogin),
"::",
stringify!(hDirectShareAppWnd)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4WithoutLogin>())).userZAK as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4WithoutLogin),
"::",
stringify!(userZAK)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4WithoutLogin>())).participantId as *const _
as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4WithoutLogin),
"::",
stringify!(participantId)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4WithoutLogin>())).webinarToken as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4WithoutLogin),
"::",
stringify!(webinarToken)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4WithoutLogin>())).isDirectShareDesktop
as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4WithoutLogin),
"::",
stringify!(isDirectShareDesktop)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4WithoutLogin>())).isVideoOff as *const _
as usize
},
37usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4WithoutLogin),
"::",
stringify!(isVideoOff)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4WithoutLogin>())).isAudioOff as *const _
as usize
},
38usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4WithoutLogin),
"::",
stringify!(isAudioOff)
)
);
}
#[doc = " \\struct tagJoinParam4WithoutLogin"]
#[doc = "\\brief The parameters of non-login user when joins the meeting."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_JoinParam4WithoutLogin = ZOOMSDK_tagJoinParam4WithoutLogin;
#[doc = " \\struct tagJoinParam4NormalUser"]
#[doc = "\\brief The parameter of ordinary logged-in user."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagJoinParam4NormalUser {
#[doc = "<Meeting number."]
pub meetingNumber: UINT64,
#[doc = "<Meeting vanity ID."]
pub vanityID: *const u16,
#[doc = "<Username when logged in the meeting."]
pub userName: *const u16,
#[doc = "<Meeting password."]
pub psw: *const u16,
#[doc = "<The window handle of the direct sharing application."]
pub hDirectShareAppWnd: HWND,
#[doc = "<The ID of attendees. The SDK will set this value when the associated settings are turned on."]
pub participantId: *const u16,
#[doc = "<Webinar token."]
pub webinarToken: *const u16,
#[doc = "<Turn off the video or not. True indicates to turn off. In addition, this flag is affected by meeting attributes."]
pub isVideoOff: bool,
#[doc = "<Turn off the audio or not. True indicates to turn off. In addition, this flag is affected by meeting attributes."]
pub isAudioOff: bool,
#[doc = "<Share the desktop directly or not. True indicates to Share."]
pub isDirectShareDesktop: bool,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagJoinParam4NormalUser() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagJoinParam4NormalUser>(),
40usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagJoinParam4NormalUser))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagJoinParam4NormalUser>(),
8usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagJoinParam4NormalUser))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4NormalUser>())).meetingNumber as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4NormalUser),
"::",
stringify!(meetingNumber)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4NormalUser>())).vanityID as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4NormalUser),
"::",
stringify!(vanityID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4NormalUser>())).userName as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4NormalUser),
"::",
stringify!(userName)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4NormalUser>())).psw as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4NormalUser),
"::",
stringify!(psw)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4NormalUser>())).hDirectShareAppWnd
as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4NormalUser),
"::",
stringify!(hDirectShareAppWnd)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4NormalUser>())).participantId as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4NormalUser),
"::",
stringify!(participantId)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4NormalUser>())).webinarToken as *const _
as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4NormalUser),
"::",
stringify!(webinarToken)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4NormalUser>())).isVideoOff as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4NormalUser),
"::",
stringify!(isVideoOff)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4NormalUser>())).isAudioOff as *const _
as usize
},
33usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4NormalUser),
"::",
stringify!(isAudioOff)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam4NormalUser>())).isDirectShareDesktop
as *const _ as usize
},
34usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam4NormalUser),
"::",
stringify!(isDirectShareDesktop)
)
);
}
#[doc = " \\struct tagJoinParam4NormalUser"]
#[doc = "\\brief The parameter of ordinary logged-in user."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_JoinParam4NormalUser = ZOOMSDK_tagJoinParam4NormalUser;
#[doc = " \\struct tagJoinParam"]
#[doc = "\\brief The way and the parameter of the users when join the meeting."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ZOOMSDK_tagJoinParam {
#[doc = "<User type. For more details, see \\link SDKUserType \\endlink enum."]
pub userType: ZOOMSDK_SDKUserType,
pub param: ZOOMSDK_tagJoinParam__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ZOOMSDK_tagJoinParam__bindgen_ty_1 {
#[doc = "<The parameter of ordinary user when joins the meeting."]
pub normaluserJoin: ZOOMSDK_JoinParam4NormalUser,
#[doc = "<The parameters of unlogged-in user when joins the meeting."]
pub withoutloginuserJoin: ZOOMSDK_JoinParam4WithoutLogin,
_bindgen_union_align: [u64; 5usize],
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagJoinParam__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagJoinParam__bindgen_ty_1>(),
40usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagJoinParam__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagJoinParam__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagJoinParam__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam__bindgen_ty_1>())).normaluserJoin
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam__bindgen_ty_1),
"::",
stringify!(normaluserJoin)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagJoinParam__bindgen_ty_1>())).withoutloginuserJoin
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam__bindgen_ty_1),
"::",
stringify!(withoutloginuserJoin)
)
);
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagJoinParam() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagJoinParam>(),
48usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagJoinParam))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagJoinParam>(),
8usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagJoinParam))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZOOMSDK_tagJoinParam>())).userType as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam),
"::",
stringify!(userType)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZOOMSDK_tagJoinParam>())).param as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagJoinParam),
"::",
stringify!(param)
)
);
}
#[doc = " \\struct tagJoinParam"]
#[doc = "\\brief The way and the parameter of the users when join the meeting."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_JoinParam = ZOOMSDK_tagJoinParam;
#[doc = "<API user."]
pub const ZOOMSDK_ZoomUserType_ZoomUserType_APIUSER: ZOOMSDK_ZoomUserType = 0;
#[doc = "<User logged in with email."]
pub const ZOOMSDK_ZoomUserType_ZoomUserType_EMAIL_LOGIN: ZOOMSDK_ZoomUserType = 1;
#[doc = "<User logged in with Facebook."]
pub const ZOOMSDK_ZoomUserType_ZoomUserType_FACEBOOK: ZOOMSDK_ZoomUserType = 2;
#[doc = "<User logged in with Google."]
pub const ZOOMSDK_ZoomUserType_ZoomUserType_GoogleOAuth: ZOOMSDK_ZoomUserType = 3;
#[doc = "<User logged in with SSO."]
pub const ZOOMSDK_ZoomUserType_ZoomUserType_SSO: ZOOMSDK_ZoomUserType = 4;
#[doc = "<User of unknown type."]
pub const ZOOMSDK_ZoomUserType_ZoomUserType_Unknown: ZOOMSDK_ZoomUserType = 5;
#[doc = " \\enum ZoomUserType"]
#[doc = "\\brief SDK user type."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_ZoomUserType = ::std::os::raw::c_int;
#[doc = " \\struct tagStartParam4WithoutLogin"]
#[doc = "\\brief The parameter used by unlogged-in user when starts the meeting."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagStartParam4WithoutLogin {
#[doc = "<User ID."]
pub userID: *const u16,
#[doc = "<ZOOM access token."]
pub userZAK: *const u16,
#[doc = "<Username when logged in the meeting."]
pub userName: *const u16,
#[doc = "<User type."]
pub zoomuserType: ZOOMSDK_ZoomUserType,
#[doc = "<Meeting number."]
pub meetingNumber: UINT64,
#[doc = "< Meeting vanity ID"]
pub vanityID: *const u16,
#[doc = "<The window handle of the direct sharing application."]
pub hDirectShareAppWnd: HWND,
#[doc = "<The ID of attendees. The SDK will set this value when the associated settings are turned on."]
pub participantId: *const u16,
#[doc = "<Share the desktop directly or not. True indicates to share."]
pub isDirectShareDesktop: bool,
#[doc = "<Turn off the video or not. True indicates to turn off. In addition, this flag is affected by meeting attributes."]
pub isVideoOff: bool,
#[doc = "<Turn off the audio or not. True indicates to turn off. In addition, this flag is affected by meeting attributes."]
pub isAudioOff: bool,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagStartParam4WithoutLogin() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagStartParam4WithoutLogin>(),
40usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagStartParam4WithoutLogin))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagStartParam4WithoutLogin>(),
8usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagStartParam4WithoutLogin)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam4WithoutLogin>())).userID as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam4WithoutLogin),
"::",
stringify!(userID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam4WithoutLogin>())).userZAK as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam4WithoutLogin),
"::",
stringify!(userZAK)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam4WithoutLogin>())).userName as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam4WithoutLogin),
"::",
stringify!(userName)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam4WithoutLogin>())).zoomuserType as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam4WithoutLogin),
"::",
stringify!(zoomuserType)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam4WithoutLogin>())).meetingNumber as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam4WithoutLogin),
"::",
stringify!(meetingNumber)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam4WithoutLogin>())).vanityID as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam4WithoutLogin),
"::",
stringify!(vanityID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam4WithoutLogin>())).hDirectShareAppWnd
as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam4WithoutLogin),
"::",
stringify!(hDirectShareAppWnd)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam4WithoutLogin>())).participantId as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam4WithoutLogin),
"::",
stringify!(participantId)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam4WithoutLogin>())).isDirectShareDesktop
as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam4WithoutLogin),
"::",
stringify!(isDirectShareDesktop)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam4WithoutLogin>())).isVideoOff as *const _
as usize
},
37usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam4WithoutLogin),
"::",
stringify!(isVideoOff)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam4WithoutLogin>())).isAudioOff as *const _
as usize
},
38usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam4WithoutLogin),
"::",
stringify!(isAudioOff)
)
);
}
#[doc = " \\struct tagStartParam4WithoutLogin"]
#[doc = "\\brief The parameter used by unlogged-in user when starts the meeting."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_StartParam4WithoutLogin = ZOOMSDK_tagStartParam4WithoutLogin;
#[doc = " \\struct tagStartParam4NormalUser"]
#[doc = "\\brief The parameter of ordinary user when starts meeting."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagStartParam4NormalUser {
#[doc = "<Meeting number."]
pub meetingNumber: UINT64,
#[doc = "<Meeting vanity ID. Generate a ZOOM access token via REST API."]
pub vanityID: *const u16,
#[doc = "<The window handle of the direct sharing application."]
pub hDirectShareAppWnd: HWND,
#[doc = "<The ID of attendees. The SDK will set this value when the associated settings are turned on."]
pub participantId: *const u16,
#[doc = "<Turn off video or not. True indicates to turn off. In addition, this flag is affected by meeting attributes."]
pub isVideoOff: bool,
#[doc = "<Turn off audio or not. True indicates to turn off. In addition, this flag is affected by meeting attributes."]
pub isAudioOff: bool,
#[doc = "<Share the desktop directly or not. True indicates to Share."]
pub isDirectShareDesktop: bool,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagStartParam4NormalUser() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagStartParam4NormalUser>(),
24usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagStartParam4NormalUser))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagStartParam4NormalUser>(),
8usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagStartParam4NormalUser)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam4NormalUser>())).meetingNumber as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam4NormalUser),
"::",
stringify!(meetingNumber)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam4NormalUser>())).vanityID as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam4NormalUser),
"::",
stringify!(vanityID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam4NormalUser>())).hDirectShareAppWnd
as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam4NormalUser),
"::",
stringify!(hDirectShareAppWnd)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam4NormalUser>())).participantId as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam4NormalUser),
"::",
stringify!(participantId)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam4NormalUser>())).isVideoOff as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam4NormalUser),
"::",
stringify!(isVideoOff)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam4NormalUser>())).isAudioOff as *const _
as usize
},
21usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam4NormalUser),
"::",
stringify!(isAudioOff)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam4NormalUser>())).isDirectShareDesktop
as *const _ as usize
},
22usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam4NormalUser),
"::",
stringify!(isDirectShareDesktop)
)
);
}
#[doc = " \\struct tagStartParam4NormalUser"]
#[doc = "\\brief The parameter of ordinary user when starts meeting."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_StartParam4NormalUser = ZOOMSDK_tagStartParam4NormalUser;
#[doc = " \\struct tagJoinParam"]
#[doc = "\\brief The way and the parameter for meeting start."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ZOOMSDK_tagStartParam {
#[doc = "<User type."]
pub userType: ZOOMSDK_SDKUserType,
pub param: ZOOMSDK_tagStartParam__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ZOOMSDK_tagStartParam__bindgen_ty_1 {
#[doc = "<The parameter for ordinary user when starts the meeting."]
pub normaluserStart: ZOOMSDK_StartParam4NormalUser,
#[doc = "<The parameter for unlogged-in user when starts the meeting."]
pub withoutloginStart: ZOOMSDK_StartParam4WithoutLogin,
_bindgen_union_align: [u64; 5usize],
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagStartParam__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagStartParam__bindgen_ty_1>(),
40usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagStartParam__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagStartParam__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagStartParam__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam__bindgen_ty_1>())).normaluserStart
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam__bindgen_ty_1),
"::",
stringify!(normaluserStart)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagStartParam__bindgen_ty_1>())).withoutloginStart
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam__bindgen_ty_1),
"::",
stringify!(withoutloginStart)
)
);
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagStartParam() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagStartParam>(),
48usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagStartParam))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagStartParam>(),
8usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagStartParam))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZOOMSDK_tagStartParam>())).userType as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam),
"::",
stringify!(userType)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZOOMSDK_tagStartParam>())).param as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagStartParam),
"::",
stringify!(param)
)
);
}
#[doc = " \\struct tagJoinParam"]
#[doc = "\\brief The way and the parameter for meeting start."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_StartParam = ZOOMSDK_tagStartParam;
#[doc = "<Unknown connection status"]
pub const ZOOMSDK_ConnectionQuality_Conn_Quality_Unknow: ZOOMSDK_ConnectionQuality = 0;
#[doc = "<The connection quality is very poor."]
pub const ZOOMSDK_ConnectionQuality_Conn_Quality_Very_Bad: ZOOMSDK_ConnectionQuality = 1;
#[doc = "<The connection quality is poor."]
pub const ZOOMSDK_ConnectionQuality_Conn_Quality_Bad: ZOOMSDK_ConnectionQuality = 2;
#[doc = "<The connection quality is not good."]
pub const ZOOMSDK_ConnectionQuality_Conn_Quality_Not_Good: ZOOMSDK_ConnectionQuality = 3;
#[doc = "<The connection quality is normal."]
pub const ZOOMSDK_ConnectionQuality_Conn_Quality_Normal: ZOOMSDK_ConnectionQuality = 4;
#[doc = "<The connection quality is good."]
pub const ZOOMSDK_ConnectionQuality_Conn_Quality_Good: ZOOMSDK_ConnectionQuality = 5;
#[doc = "<The connection quality is excellent."]
pub const ZOOMSDK_ConnectionQuality_Conn_Quality_Excellent: ZOOMSDK_ConnectionQuality = 6;
#[doc = " \\enum ConnectionQuality"]
#[doc = "\\brief Connection quality."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_ConnectionQuality = ::std::os::raw::c_int;
pub const ZOOMSDK_SDKViewType_SDK_FIRST_VIEW: ZOOMSDK_SDKViewType = 0;
#[doc = "<Secondary displayer."]
pub const ZOOMSDK_SDKViewType_SDK_SECOND_VIEW: ZOOMSDK_SDKViewType = 1;
#[doc = " \\enum SDKViewType"]
#[doc = "\\brief SDK View Type, primary displayer and secondary displayer."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_SDKViewType = ::std::os::raw::c_int;
#[doc = "<Disconnection."]
pub const ZOOMSDK_MeetingConnType_Meeting_Conn_None: ZOOMSDK_MeetingConnType = 0;
#[doc = "<Normal connection."]
pub const ZOOMSDK_MeetingConnType_Meeting_Conn_Normal: ZOOMSDK_MeetingConnType = 1;
#[doc = "<Failure and reconnection."]
pub const ZOOMSDK_MeetingConnType_Meeting_Conn_FailOver: ZOOMSDK_MeetingConnType = 2;
#[doc = " \\enum MeetingConnType"]
#[doc = "\\brief Meeting connection type."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_MeetingConnType = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IMeetingInfo__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting information Interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IMeetingInfo {
pub vtable_: *const ZOOMSDK_IMeetingInfo__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingInfo>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingInfo))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingInfo>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMeetingInfo))
);
}
#[doc = " \\struct tagMeetingParameter"]
#[doc = "\\brief Meeting parameter."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_tagMeetingParameter {
#[doc = "<Meeting type."]
pub meeting_type: ZOOMSDK_MeetingType,
#[doc = "<View only or not. True indicates to view only."]
pub is_view_only: bool,
#[doc = "<Meeting number."]
pub meeting_number: UINT64,
#[doc = "<Meeting topic."]
pub meeting_topic: *const u16,
#[doc = "<Meeting host."]
pub meeting_host: *const u16,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagMeetingParameter() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagMeetingParameter>(),
24usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagMeetingParameter))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagMeetingParameter>(),
8usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagMeetingParameter))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagMeetingParameter>())).meeting_type as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagMeetingParameter),
"::",
stringify!(meeting_type)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagMeetingParameter>())).is_view_only as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagMeetingParameter),
"::",
stringify!(is_view_only)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagMeetingParameter>())).meeting_number as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagMeetingParameter),
"::",
stringify!(meeting_number)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagMeetingParameter>())).meeting_topic as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagMeetingParameter),
"::",
stringify!(meeting_topic)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagMeetingParameter>())).meeting_host as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagMeetingParameter),
"::",
stringify!(meeting_host)
)
);
}
#[doc = " \\struct tagMeetingParameter"]
#[doc = "\\brief Meeting parameter."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_MeetingParameter = ZOOMSDK_tagMeetingParameter;
#[repr(C)]
pub struct ZOOMSDK_IMeetingExternalSecureKeyHandler__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting external secure key handler."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IMeetingExternalSecureKeyHandler {
pub vtable_: *const ZOOMSDK_IMeetingExternalSecureKeyHandler__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingExternalSecureKeyHandler() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingExternalSecureKeyHandler>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IMeetingExternalSecureKeyHandler)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingExternalSecureKeyHandler>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingExternalSecureKeyHandler)
)
);
}
#[doc = "<No warning."]
pub const ZOOMSDK_StatisticsWarningType_Statistics_Warning_None: ZOOMSDK_StatisticsWarningType = 0;
#[doc = "<The network connection quality is bad."]
pub const ZOOMSDK_StatisticsWarningType_Statistics_Warning_Network_Quality_Bad:
ZOOMSDK_StatisticsWarningType = 1;
#[doc = "<The system is busy."]
pub const ZOOMSDK_StatisticsWarningType_Statistics_Warning_Busy_System:
ZOOMSDK_StatisticsWarningType = 2;
#[doc = " \\enum StatisticsWarningType"]
#[doc = "\\brief Meeting statistics warning type."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_StatisticsWarningType = ::std::os::raw::c_int;
pub const ZOOMSDK_OSSessionType_OS_SessionType_NotHandle: ZOOMSDK_OSSessionType = 0;
#[doc = "<equals to WTS_SESSION_LOCK"]
pub const ZOOMSDK_OSSessionType_OS_SessionType_Lock: ZOOMSDK_OSSessionType = 1;
#[doc = "<equals to WTS_SESSION_LOGOFF"]
pub const ZOOMSDK_OSSessionType_OS_SessionType_Logoff: ZOOMSDK_OSSessionType = 2;
#[doc = "<equals to WTS_REMOTE_DISCONNECT"]
pub const ZOOMSDK_OSSessionType_OS_SessionType_Remote_DISCONNECT: ZOOMSDK_OSSessionType = 3;
#[doc = " \\enum OSSessionType"]
#[doc = "\\brief OS session type."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_OSSessionType = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IMeetingServiceEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting service callback event."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingServiceEvent {
pub vtable_: *const ZOOMSDK_IMeetingServiceEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingServiceEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingServiceEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingServiceEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingServiceEvent>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMeetingServiceEvent))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingLiveStreamController {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingWebinarController {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingQAController {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingBOController {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingInterpretationController {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IEmojiReactionController {
_unused: [u8; 0],
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingService__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting Service Interface"]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingService {
pub vtable_: *const ZOOMSDK_IMeetingService__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingService() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingService>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingService))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingService>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMeetingService))
);
}
#[doc = "<Switch to mouse cursor."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_NONE_DRAWING: ZOOMSDK_AnnotationToolType = 0;
#[doc = "<Pen."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_PEN: ZOOMSDK_AnnotationToolType = 1;
#[doc = "<Highlighter."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_HIGHLIGHTER: ZOOMSDK_AnnotationToolType = 2;
#[doc = "<A straight line changes automatically in pace with the mouse cursor."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_AUTO_LINE: ZOOMSDK_AnnotationToolType = 3;
#[doc = "<A rectangle changes automatically in pace with the mouse cursor."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_AUTO_RECTANGLE: ZOOMSDK_AnnotationToolType = 4;
#[doc = "<An ellipse changes automatically in pace with the mouse cursor."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_AUTO_ELLIPSE: ZOOMSDK_AnnotationToolType = 5;
#[doc = "<An arrow changes automatically in pace with the mouse cursor."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_AUTO_ARROW: ZOOMSDK_AnnotationToolType = 6;
#[doc = "<A filled rectangle."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_AUTO_RECTANGLE_FILL: ZOOMSDK_AnnotationToolType = 7;
#[doc = "<A filled ellipse."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_AUTO_ELLIPSE_FILL: ZOOMSDK_AnnotationToolType = 8;
#[doc = "<Laser pointer."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_SPOTLIGHT: ZOOMSDK_AnnotationToolType = 9;
#[doc = "<An arrow showing the name of whom click on the sharing content."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_ARROW: ZOOMSDK_AnnotationToolType = 10;
#[doc = "<An eraser."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_ERASER: ZOOMSDK_AnnotationToolType = 11;
#[doc = "<Insert a textbox in order to input letters."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_TEXTBOX: ZOOMSDK_AnnotationToolType = 12;
#[doc = "<Select the annotations."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_PICKER: ZOOMSDK_AnnotationToolType = 13;
#[doc = "<A fair rectangle changes automatically in pace with the mouse cursor."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_AUTO_RECTANGLE_SEMI_FILL: ZOOMSDK_AnnotationToolType =
14;
#[doc = "<A fair ellipse changes automatically in pace with the mouse cursor."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_AUTO_ELLIPSE_SEMI_FILL: ZOOMSDK_AnnotationToolType =
15;
#[doc = "<A line with double-arrow."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_AUTO_DOUBLE_ARROW: ZOOMSDK_AnnotationToolType = 16;
#[doc = "<An unfilled rhombus."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_AUTO_DIAMOND: ZOOMSDK_AnnotationToolType = 17;
#[doc = "<A fixed-size arrow for marking."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_AUTO_STAMP_ARROW: ZOOMSDK_AnnotationToolType = 18;
#[doc = "<A sign marking that something is correct."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_AUTO_STAMP_CHECK: ZOOMSDK_AnnotationToolType = 19;
#[doc = "<A sign marking that something is wrong."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_AUTO_STAMP_X: ZOOMSDK_AnnotationToolType = 20;
#[doc = "<A star for marking."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_AUTO_STAMP_STAR: ZOOMSDK_AnnotationToolType = 21;
#[doc = "<A heart for marking."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_AUTO_STAMP_HEART: ZOOMSDK_AnnotationToolType = 22;
#[doc = "<A sign for interrogation."]
pub const ZOOMSDK_AnnotationToolType_ANNOTOOL_AUTO_STAMP_QM: ZOOMSDK_AnnotationToolType = 23;
#[doc = " \\enum AnnotationToolType"]
#[doc = "\\brief Types of annotation tool."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_AnnotationToolType = ::std::os::raw::c_int;
#[doc = "<Clear all annotations."]
pub const ZOOMSDK_AnnotationClearType_ANNOCLEAR_ALL: ZOOMSDK_AnnotationClearType = 0;
#[doc = "<Clear only your own annotations."]
pub const ZOOMSDK_AnnotationClearType_ANNOCLEAR_SELF: ZOOMSDK_AnnotationClearType = 1;
#[doc = "<Clear only the others' annotations."]
pub const ZOOMSDK_AnnotationClearType_ANNOCLEAR_OTHER: ZOOMSDK_AnnotationClearType = 2;
#[doc = " \\enum AnnotationClearType"]
#[doc = "\\brief Clear types of annotation tools."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_AnnotationClearType = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IMeetingAnnotationSupportEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Callback interface that viewer's annotation status changes."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingAnnotationSupportEvent {
pub vtable_: *const ZOOMSDK_IMeetingAnnotationSupportEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingAnnotationSupportEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingAnnotationSupportEvent>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IMeetingAnnotationSupportEvent)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingAnnotationSupportEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingAnnotationSupportEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IAnnotationController__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting annotation tool interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IAnnotationController {
pub vtable_: *const ZOOMSDK_IAnnotationController__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IAnnotationController() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IAnnotationController>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IAnnotationController))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IAnnotationController>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IAnnotationController))
);
}
#[doc = "<Initialization."]
pub const ZOOMSDK_AudioStatus_Audio_None: ZOOMSDK_AudioStatus = 0;
#[doc = "<Muted status."]
pub const ZOOMSDK_AudioStatus_Audio_Muted: ZOOMSDK_AudioStatus = 1;
#[doc = "<Unmuted status."]
pub const ZOOMSDK_AudioStatus_Audio_UnMuted: ZOOMSDK_AudioStatus = 2;
#[doc = "<Muted by the host."]
pub const ZOOMSDK_AudioStatus_Audio_Muted_ByHost: ZOOMSDK_AudioStatus = 3;
#[doc = "<Unmuted by the host."]
pub const ZOOMSDK_AudioStatus_Audio_UnMuted_ByHost: ZOOMSDK_AudioStatus = 4;
#[doc = "<The host mutes all."]
pub const ZOOMSDK_AudioStatus_Audio_MutedAll_ByHost: ZOOMSDK_AudioStatus = 5;
#[doc = "<The host unmutes all."]
pub const ZOOMSDK_AudioStatus_Audio_UnMutedAll_ByHost: ZOOMSDK_AudioStatus = 6;
#[doc = " \\enum AudioStatus"]
#[doc = "\\brief Define the audio status of the user."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_AudioStatus = ::std::os::raw::c_int;
#[doc = "<Normal audio type."]
pub const ZOOMSDK_AudioType_AUDIOTYPE_NONE: ZOOMSDK_AudioType = 0;
#[doc = "<In VoIP mode."]
pub const ZOOMSDK_AudioType_AUDIOTYPE_VOIP: ZOOMSDK_AudioType = 1;
#[doc = "<In telephone mode."]
pub const ZOOMSDK_AudioType_AUDIOTYPE_PHONE: ZOOMSDK_AudioType = 2;
#[doc = "<Unknown mode."]
pub const ZOOMSDK_AudioType_AUDIOTYPE_UNKNOW: ZOOMSDK_AudioType = 3;
#[doc = " \\enum AudioType"]
#[doc = "\\brief Define the audio type of the user."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_AudioType = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IRequestStartAudioHandler__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Process after the user receives the requirement from the host to turn on the audio."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IRequestStartAudioHandler {
pub vtable_: *const ZOOMSDK_IRequestStartAudioHandler__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IRequestStartAudioHandler() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IRequestStartAudioHandler>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IRequestStartAudioHandler))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IRequestStartAudioHandler>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IRequestStartAudioHandler)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IUserAudioStatus__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief User audio status interface."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IUserAudioStatus {
pub vtable_: *const ZOOMSDK_IUserAudioStatus__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IUserAudioStatus() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IUserAudioStatus>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IUserAudioStatus))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IUserAudioStatus>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IUserAudioStatus))
);
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingAudioCtrlEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting audio callback event"]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingAudioCtrlEvent {
pub vtable_: *const ZOOMSDK_IMeetingAudioCtrlEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingAudioCtrlEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingAudioCtrlEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingAudioCtrlEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingAudioCtrlEvent>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMeetingAudioCtrlEvent))
);
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingAudioController__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting audio controller interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingAudioController {
pub vtable_: *const ZOOMSDK_IMeetingAudioController__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingAudioController() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingAudioController>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingAudioController))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingAudioController>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMeetingAudioController))
);
}
#[repr(C)]
pub struct ZOOMSDK_IBreakoutRoomsInfo__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\deprecated This interface will be deprecated, please stop using it."]
#[doc = " \\brief Meeting breakout rooms information interface."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IBreakoutRoomsInfo {
pub vtable_: *const ZOOMSDK_IBreakoutRoomsInfo__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IBreakoutRoomsInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IBreakoutRoomsInfo>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IBreakoutRoomsInfo))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IBreakoutRoomsInfo>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IBreakoutRoomsInfo))
);
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingBreakoutRoomsEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\deprecated This interface will be deprecated, please stop using it."]
#[doc = " \\brief Meeting Breakout Room callback event"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingBreakoutRoomsEvent {
pub vtable_: *const ZOOMSDK_IMeetingBreakoutRoomsEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingBreakoutRoomsEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingBreakoutRoomsEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingBreakoutRoomsEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingBreakoutRoomsEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingBreakoutRoomsEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingBreakoutRoomsController__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\deprecated This interface will be deprecated, please stop using it."]
#[doc = " \\brief Breakout Rooms controller interface"]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingBreakoutRoomsController {
pub vtable_: *const ZOOMSDK_IMeetingBreakoutRoomsController__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingBreakoutRoomsController() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingBreakoutRoomsController>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IMeetingBreakoutRoomsController)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingBreakoutRoomsController>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingBreakoutRoomsController)
)
);
}
pub const ZOOMSDK_SDKChatMessageType_SDKChatMessageType_To_None: ZOOMSDK_SDKChatMessageType = 0;
#[doc = "For initialize"]
pub const ZOOMSDK_SDKChatMessageType_SDKChatMessageType_To_All: ZOOMSDK_SDKChatMessageType = 1;
#[doc = "Chat message is send to all."]
pub const ZOOMSDK_SDKChatMessageType_SDKChatMessageType_To_All_Panelist:
ZOOMSDK_SDKChatMessageType = 2;
#[doc = "Chat message is send to all panelists."]
pub const ZOOMSDK_SDKChatMessageType_SDKChatMessageType_To_Individual_Panelist:
ZOOMSDK_SDKChatMessageType = 3;
#[doc = "Chat message is send to individual attendee and cc panelists."]
pub const ZOOMSDK_SDKChatMessageType_SDKChatMessageType_To_Individual: ZOOMSDK_SDKChatMessageType =
4;
#[doc = "Chat message is send to individual user."]
pub const ZOOMSDK_SDKChatMessageType_SDKChatMessageType_To_WaitingRoomUsers:
ZOOMSDK_SDKChatMessageType = 5;
#[doc = " @brief Enumerations of the type for chat message."]
pub type ZOOMSDK_SDKChatMessageType = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IChatMsgInfo__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Chat message interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IChatMsgInfo {
pub vtable_: *const ZOOMSDK_IChatMsgInfo__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IChatMsgInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IChatMsgInfo>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IChatMsgInfo))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IChatMsgInfo>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IChatMsgInfo))
);
}
#[doc = " \\struct NormalMeetingChatStaus"]
#[doc = "\\brief The authority to chat in the normal meeting."]
#[doc = "Here are more detailed structural descriptions.."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagNormalMeetingChatStaus {
#[doc = "<TRUE indicates that the user owns the authority to send message to chat."]
pub can_chat: bool,
#[doc = "<TRUE indicates that the user owns the authority to send message to all."]
pub can_chat_to_all: bool,
#[doc = "<TRUE indicates that the user owns the authority to send message to an individual attendee in the meeting."]
pub can_chat_to_individual: bool,
#[doc = "<TRUE indicates that the user owns the authority to send message only to the host."]
pub is_only_can_chat_to_host: bool,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagNormalMeetingChatStaus() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagNormalMeetingChatStaus>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagNormalMeetingChatStaus))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagNormalMeetingChatStaus>(),
1usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagNormalMeetingChatStaus)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagNormalMeetingChatStaus>())).can_chat as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagNormalMeetingChatStaus),
"::",
stringify!(can_chat)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagNormalMeetingChatStaus>())).can_chat_to_all
as *const _ as usize
},
1usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagNormalMeetingChatStaus),
"::",
stringify!(can_chat_to_all)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagNormalMeetingChatStaus>())).can_chat_to_individual
as *const _ as usize
},
2usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagNormalMeetingChatStaus),
"::",
stringify!(can_chat_to_individual)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagNormalMeetingChatStaus>())).is_only_can_chat_to_host
as *const _ as usize
},
3usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagNormalMeetingChatStaus),
"::",
stringify!(is_only_can_chat_to_host)
)
);
}
#[doc = " \\struct NormalMeetingChatStaus"]
#[doc = "\\brief The authority to chat in the normal meeting."]
#[doc = "Here are more detailed structural descriptions.."]
pub type ZOOMSDK_NormalMeetingChatStaus = ZOOMSDK_tagNormalMeetingChatStaus;
#[doc = " \\struct tagWebinarAttendeeChatStatus"]
#[doc = "\\brief The authority to chat for the normal attendee in the webinar."]
#[doc = "Here are more detailed structural descriptions.."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagWebinarAttendeeChatStatus {
#[doc = "<TRUE indicates that the attendee can send message to chat."]
pub can_chat: bool,
#[doc = "<TRUE indicates that the user owns the authority to send message to all the panelists and attendees."]
pub can_chat_to_all_panellist_and_attendee: bool,
#[doc = "<TRUE indicates that the user owns the authority to send message to all the panelists."]
pub can_chat_to_all_panellist: bool,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagWebinarAttendeeChatStatus() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagWebinarAttendeeChatStatus>(),
3usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_tagWebinarAttendeeChatStatus)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagWebinarAttendeeChatStatus>(),
1usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagWebinarAttendeeChatStatus)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagWebinarAttendeeChatStatus>())).can_chat as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagWebinarAttendeeChatStatus),
"::",
stringify!(can_chat)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagWebinarAttendeeChatStatus>()))
.can_chat_to_all_panellist_and_attendee as *const _ as usize
},
1usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagWebinarAttendeeChatStatus),
"::",
stringify!(can_chat_to_all_panellist_and_attendee)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagWebinarAttendeeChatStatus>()))
.can_chat_to_all_panellist as *const _ as usize
},
2usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagWebinarAttendeeChatStatus),
"::",
stringify!(can_chat_to_all_panellist)
)
);
}
#[doc = " \\struct tagWebinarAttendeeChatStatus"]
#[doc = "\\brief The authority to chat for the normal attendee in the webinar."]
#[doc = "Here are more detailed structural descriptions.."]
pub type ZOOMSDK_WebinarAttendeeChatStatus = ZOOMSDK_tagWebinarAttendeeChatStatus;
#[doc = " \\struct tagWebinarOtherUserRoleChatStatus"]
#[doc = "\\brief The authority to chat for the host, co-host and panelist to chat in webinar."]
#[doc = "Here are more detailed structural descriptions.."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagWebinarOtherUserRoleChatStatus {
#[doc = "<TRUE indicates that the user owns the authority to send message to all the panelists."]
pub can_chat_to_all_panellist: bool,
#[doc = "<TRUE indicates that the user owns the authority to send message to all."]
pub can_chat_to_all_panellist_and_attendee: bool,
#[doc = "<TRUE indicates that the user owns the authority to send message to individual attendee."]
pub can_chat_to_individual: bool,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagWebinarOtherUserRoleChatStatus() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagWebinarOtherUserRoleChatStatus>(),
3usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_tagWebinarOtherUserRoleChatStatus)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagWebinarOtherUserRoleChatStatus>(),
1usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagWebinarOtherUserRoleChatStatus)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagWebinarOtherUserRoleChatStatus>()))
.can_chat_to_all_panellist as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagWebinarOtherUserRoleChatStatus),
"::",
stringify!(can_chat_to_all_panellist)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagWebinarOtherUserRoleChatStatus>()))
.can_chat_to_all_panellist_and_attendee as *const _ as usize
},
1usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagWebinarOtherUserRoleChatStatus),
"::",
stringify!(can_chat_to_all_panellist_and_attendee)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagWebinarOtherUserRoleChatStatus>()))
.can_chat_to_individual as *const _ as usize
},
2usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagWebinarOtherUserRoleChatStatus),
"::",
stringify!(can_chat_to_individual)
)
);
}
#[doc = " \\struct tagWebinarOtherUserRoleChatStatus"]
#[doc = "\\brief The authority to chat for the host, co-host and panelist to chat in webinar."]
#[doc = "Here are more detailed structural descriptions.."]
pub type ZOOMSDK_WebinarOtherUserRoleChatStatus = ZOOMSDK_tagWebinarOtherUserRoleChatStatus;
#[doc = " \\struct tagChatStatus"]
#[doc = "\\brief The authority to chat in the specified meeting."]
#[doc = "Here are more detailed structural descriptions.."]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ZOOMSDK_tagChatStatus {
#[doc = "<The ut value depends on the value of the other members in the structure. When the value of is_webinar_meeting is false, the ut value is the NormalMeetingChatStausnormal_meeting_status. When the values of the is_webinar_meeting and the is_webinar_attendee is true, the ut value is WebinarAttendeeChatStatus webinar_attendee_status. The value of is_webinar_meeting is true while the is_webinar_attendee is false, the ut value is WebinarOtherUserRoleChatStatus webinar_other_status."]
pub ut: ZOOMSDK_tagChatStatus__bindgen_ty_1,
#[doc = "<TRUE indicates that it is disabled to chat in the specified meeting."]
pub is_chat_off: bool,
#[doc = "<TRUE indicates that the owner of the current message is the attendee of the webinar."]
pub is_webinar_attendee: bool,
#[doc = "<TRUE indicates that the current meeting is webinar."]
pub is_webinar_meeting: bool,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ZOOMSDK_tagChatStatus__bindgen_ty_1 {
pub normal_meeting_status: ZOOMSDK_NormalMeetingChatStaus,
pub webinar_attendee_status: ZOOMSDK_WebinarAttendeeChatStatus,
pub webinar_other_status: ZOOMSDK_WebinarOtherUserRoleChatStatus,
_bindgen_union_align: [u8; 4usize],
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagChatStatus__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagChatStatus__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagChatStatus__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagChatStatus__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagChatStatus__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagChatStatus__bindgen_ty_1>())).normal_meeting_status
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagChatStatus__bindgen_ty_1),
"::",
stringify!(normal_meeting_status)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagChatStatus__bindgen_ty_1>())).webinar_attendee_status
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagChatStatus__bindgen_ty_1),
"::",
stringify!(webinar_attendee_status)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagChatStatus__bindgen_ty_1>())).webinar_other_status
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagChatStatus__bindgen_ty_1),
"::",
stringify!(webinar_other_status)
)
);
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagChatStatus() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagChatStatus>(),
7usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagChatStatus))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagChatStatus>(),
1usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagChatStatus))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZOOMSDK_tagChatStatus>())).ut as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagChatStatus),
"::",
stringify!(ut)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagChatStatus>())).is_chat_off as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagChatStatus),
"::",
stringify!(is_chat_off)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagChatStatus>())).is_webinar_attendee as *const _
as usize
},
5usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagChatStatus),
"::",
stringify!(is_webinar_attendee)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagChatStatus>())).is_webinar_meeting as *const _
as usize
},
6usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagChatStatus),
"::",
stringify!(is_webinar_meeting)
)
);
}
#[doc = " \\struct tagChatStatus"]
#[doc = "\\brief The authority to chat in the specified meeting."]
#[doc = "Here are more detailed structural descriptions.."]
pub type ZOOMSDK_ChatStatus = ZOOMSDK_tagChatStatus;
pub const ZOOMSDK_SDKChatPriviledge_SDK_CHAT_PRIVILEDGE_ALL: ZOOMSDK_SDKChatPriviledge = 1;
#[doc = " allow attendee to chat with everyone [meeting & webinar]"]
pub const ZOOMSDK_SDKChatPriviledge_SDK_CHAT_PRIVILEDGE_ALL_PANELIST: ZOOMSDK_SDKChatPriviledge = 2;
#[doc = " allow attendee to chat with all panelists only, but cannot to \"all panelists and attendees\" [webinar]"]
pub const ZOOMSDK_SDKChatPriviledge_SDK_CHAT_PRIVILEDGE_HOST: ZOOMSDK_SDKChatPriviledge = 3;
#[doc = " allow attendee to chat with host only [meeting]"]
pub const ZOOMSDK_SDKChatPriviledge_SDK_CHAT_PRIVILEDGE_DISABLE_ATTENDEE_CHAT:
ZOOMSDK_SDKChatPriviledge = 4;
#[doc = " allow attendee to chat with no one [meeting & webinar]"]
pub const ZOOMSDK_SDKChatPriviledge_SDK_CHAT_PRIVILEDGE_HOST_PUBLIC: ZOOMSDK_SDKChatPriviledge = 5;
#[doc = " allow attendee to chat with host and public [meeting]"]
pub const ZOOMSDK_SDKChatPriviledge_SDK_CHAT_PRIVILEDGE_END: ZOOMSDK_SDKChatPriviledge = 6;
#[doc = " @brief Enumerations of the chat priviledge."]
pub type ZOOMSDK_SDKChatPriviledge = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IMeetingChatCtrlEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting chat callback event."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingChatCtrlEvent {
pub vtable_: *const ZOOMSDK_IMeetingChatCtrlEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingChatCtrlEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingChatCtrlEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingChatCtrlEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingChatCtrlEvent>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMeetingChatCtrlEvent))
);
}
#[doc = "<Disable to send message."]
pub const ZOOMSDK_WebinarChatMsgType_WebinarChatMsgType_None: ZOOMSDK_WebinarChatMsgType = 0;
#[doc = "<Enable to send message to all the panelists."]
pub const ZOOMSDK_WebinarChatMsgType_WebinarChatMsgType_ToAllPanelist: ZOOMSDK_WebinarChatMsgType =
1;
#[doc = "<Enable to send message to all."]
pub const ZOOMSDK_WebinarChatMsgType_WebinarChatMsgType_ToAllPanelistAndAttendee:
ZOOMSDK_WebinarChatMsgType = 2;
#[doc = "<Enable to send message to individual attendee."]
pub const ZOOMSDK_WebinarChatMsgType_WebinarChatMsgType_ToIndividualUser:
ZOOMSDK_WebinarChatMsgType = 3;
#[doc = " \\enum WebinarChatMsgType"]
#[doc = "\\brief The sending message type in webinar."]
#[doc = "Here are more detailed structural descriptions.."]
pub type ZOOMSDK_WebinarChatMsgType = ::std::os::raw::c_int;
#[doc = " \\struct tagSendChatItem4Webinar"]
#[doc = "\\brief The structure of chat message for webinar."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagSendChatItem4Webinar {
#[doc = "<The authority to send chat message."]
pub msgType: ZOOMSDK_WebinarChatMsgType,
#[doc = "<The content of the message."]
pub content: *const u16,
#[doc = "<This member is only used to specify the attendee ID when the authority is WebinarChatMsgType_ToIndividualUser."]
pub userID: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagSendChatItem4Webinar() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagSendChatItem4Webinar>(),
12usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagSendChatItem4Webinar))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagSendChatItem4Webinar>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagSendChatItem4Webinar))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagSendChatItem4Webinar>())).msgType as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagSendChatItem4Webinar),
"::",
stringify!(msgType)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagSendChatItem4Webinar>())).content as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagSendChatItem4Webinar),
"::",
stringify!(content)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagSendChatItem4Webinar>())).userID as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagSendChatItem4Webinar),
"::",
stringify!(userID)
)
);
}
#[doc = " \\struct tagSendChatItem4Webinar"]
#[doc = "\\brief The structure of chat message for webinar."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_SendChatItem4Webinar = ZOOMSDK_tagSendChatItem4Webinar;
#[repr(C)]
pub struct ZOOMSDK_IMeetingChatController__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting chat controller interface"]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingChatController {
pub vtable_: *const ZOOMSDK_IMeetingChatController__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingChatController() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingChatController>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingChatController))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingChatController>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMeetingChatController))
);
}
#[doc = "<The new string must end up with \"%s\" so that the menu item can show correctly. This type is used to define a string to replace the menu item ON %S on live streaming."]
pub const ZOOMSDK_SDKCustomizedStringType_SDK_Customized_LiveStream_MenuString_LiveOn_String:
ZOOMSDK_SDKCustomizedStringType = 0;
#[doc = "<The new string must end up with \"%s\" so that the menu item can show correctly. This type is used to define a string to replace the menu item VIEW STREAM ON %S on live streaming."]
pub const ZOOMSDK_SDKCustomizedStringType_SDK_Customized_LiveStream_MenuString_LiveView_String:
ZOOMSDK_SDKCustomizedStringType = 1;
#[doc = "<The new string must be a pure string so that it can show correctly. This type is used to define a string to replace the menu item STOP LIVE STREAM on live streaming."]
pub const ZOOMSDK_SDKCustomizedStringType_SDK_Customized_LiveStream_MenuString_LiveStop_String:
ZOOMSDK_SDKCustomizedStringType = 2;
#[doc = "<The new string must be a pure string so that it can show correctly. This type is used to define a string to replace the menu item COPY STREAMING LINK on live streaming."]
pub const ZOOMSDK_SDKCustomizedStringType_SDK_Customized_LiveStream_MenuString_CopyURL_String:
ZOOMSDK_SDKCustomizedStringType = 3;
#[doc = "<The new string must be a pure string so that it can show correctly. This type is used to define a string to replace the title of the meeting video UI."]
pub const ZOOMSDK_SDKCustomizedStringType_SDK_Customized_Title_App:
ZOOMSDK_SDKCustomizedStringType = 4;
#[doc = "<The new string must be the same format as \"Zoom Participant ID: %s Meeting ID: %s\" so that it can show correctly. This type is used to define a string to replace the title of the meeting video UI."]
pub const ZOOMSDK_SDKCustomizedStringType_SDK_Customized_Title_ZoomVideo:
ZOOMSDK_SDKCustomizedStringType = 5;
#[doc = "<The new string must be the same format as \"Zoom Participant ID: %s %d-Minutes Meeting ID:%s\" so that it can show correctly. This type is used to define a string to replace the title of the meeting video UI when the user is free user and in view-only status."]
pub const ZOOMSDK_SDKCustomizedStringType_SDK_Customized_Title_FreeZoomVideo:
ZOOMSDK_SDKCustomizedStringType = 6;
#[doc = "<The new string must be the same format as \"Zoom %d-Minutes Meeting ID: %s\" so that it can show correctly. This type is used to define a string to replace the title of the meeting video UI when the user is free user and in view-only status."]
pub const ZOOMSDK_SDKCustomizedStringType_SDK_Customized_Title_ViewOnly_FreeZoomVideo:
ZOOMSDK_SDKCustomizedStringType = 7;
#[doc = " \\enum SDKCustomizedStringType"]
#[doc = "\\brief Custom string type."]
#[doc = "Here are more detailed structural descriptions."]
#[doc = "\\remarks Read the description of the each type carefully. You must follow the format to custom your own string. Wrong usage may cause unpredictable crash."]
pub type ZOOMSDK_SDKCustomizedStringType = ::std::os::raw::c_int;
#[doc = "<Set the custom help URL in the virtual background tab page."]
pub const ZOOMSDK_SDKCustomizedURLType_SDKCustomizedURL_VITRULBG_HELP:
ZOOMSDK_SDKCustomizedURLType = 0;
#[doc = "<Set the custom Learn More URL in the virtual background tab page."]
pub const ZOOMSDK_SDKCustomizedURLType_SDKCustomizedURL_VITRULBG_LEARN_MORE:
ZOOMSDK_SDKCustomizedURLType = 1;
#[doc = "<Set the Support URL in the meeting."]
pub const ZOOMSDK_SDKCustomizedURLType_SDKCustomizedURL_SUPPORTURL: ZOOMSDK_SDKCustomizedURLType =
2;
#[doc = " \\enum SDKCustomizedURLType"]
#[doc = "\\brief Custom URL type."]
#[doc = "Here are more detailed structural descriptions."]
#[doc = "\\remarks The URL must remain intact and should contain 'http' or https'."]
pub type ZOOMSDK_SDKCustomizedURLType = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_ICustomizedResourceHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Customized resource helper interface."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_ICustomizedResourceHelper {
pub vtable_: *const ZOOMSDK_ICustomizedResourceHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ICustomizedResourceHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ICustomizedResourceHelper>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ICustomizedResourceHelper))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ICustomizedResourceHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ICustomizedResourceHelper)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingPasswordAndScreenNameHandler__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting screen name and password handler."]
#[doc = " \\remarks If the user information is not completed, the SDK will take the instance of this class as a reference to remind the user to complete the information via IMeetingConfigurationEvent::onInputMeetingPasswordAndScreenNameNotification()callback."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IMeetingPasswordAndScreenNameHandler {
pub vtable_: *const ZOOMSDK_IMeetingPasswordAndScreenNameHandler__bindgen_vtable,
}
#[doc = "<Initialization."]
pub const ZOOMSDK_IMeetingPasswordAndScreenNameHandler_RequiredInfoType_REQUIRED_INFO_TYPE_NONE:
ZOOMSDK_IMeetingPasswordAndScreenNameHandler_RequiredInfoType = 0;
#[doc = "<The user needs to enter the password when joins the meeting. Via the InputMeetingPasswordAndScreenName() to specify the password information."]
pub const ZOOMSDK_IMeetingPasswordAndScreenNameHandler_RequiredInfoType_REQUIRED_INFO_TYPE_Password : ZOOMSDK_IMeetingPasswordAndScreenNameHandler_RequiredInfoType = 1 ;
#[doc = "<If the password is invalid, the user needs to re-enter it. Via the InputMeetingPasswordAndScreenName() to specify the password information."]
pub const ZOOMSDK_IMeetingPasswordAndScreenNameHandler_RequiredInfoType_REQUIRED_INFO_TYPE_Password4WrongPassword : ZOOMSDK_IMeetingPasswordAndScreenNameHandler_RequiredInfoType = 2 ;
#[doc = "<The user needs to enter the screen name and the password,via the InputMeetingPasswordAndScreenName() to specify the necessary information."]
pub const ZOOMSDK_IMeetingPasswordAndScreenNameHandler_RequiredInfoType_REQUIRED_INFO_TYPE_PasswordAndScreenName : ZOOMSDK_IMeetingPasswordAndScreenNameHandler_RequiredInfoType = 3 ;
#[doc = "<The user needs to enter the screen name. Via the InputMeetingPasswordAndScreenName() to specify the screen name information."]
pub const ZOOMSDK_IMeetingPasswordAndScreenNameHandler_RequiredInfoType_REQUIRED_INFO_TYPE_ScreenName : ZOOMSDK_IMeetingPasswordAndScreenNameHandler_RequiredInfoType = 4 ;
#[doc = "<The user needs to enter the screen name and the meeting id,via the InputMeetingMeetingIDAndScreenName() to specify the necessary information."]
pub const ZOOMSDK_IMeetingPasswordAndScreenNameHandler_RequiredInfoType_REQUIRED_INFO_TYPE_MeetingIDAndScreenName : ZOOMSDK_IMeetingPasswordAndScreenNameHandler_RequiredInfoType = 5 ;
#[doc = " \\enum RequiredInfoType"]
#[doc = "\\brief Type of necessary information to join the meeting."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_IMeetingPasswordAndScreenNameHandler_RequiredInfoType = ::std::os::raw::c_int;
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingPasswordAndScreenNameHandler() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingPasswordAndScreenNameHandler>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IMeetingPasswordAndScreenNameHandler)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingPasswordAndScreenNameHandler>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingPasswordAndScreenNameHandler)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IWebinarNeedRegisterHandler__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Webinar register handler."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IWebinarNeedRegisterHandler {
pub vtable_: *const ZOOMSDK_IWebinarNeedRegisterHandler__bindgen_vtable,
}
#[doc = "<Initialization."]
pub const ZOOMSDK_IWebinarNeedRegisterHandler_WebinarNeedRegisterType_WebinarReg_NONE:
ZOOMSDK_IWebinarNeedRegisterHandler_WebinarNeedRegisterType = 0;
#[doc = "<Register webinar account by URL."]
pub const ZOOMSDK_IWebinarNeedRegisterHandler_WebinarNeedRegisterType_WebinarReg_By_Register_Url:
ZOOMSDK_IWebinarNeedRegisterHandler_WebinarNeedRegisterType = 1;
#[doc = "<Register webinar account by email and the screen name."]
pub const ZOOMSDK_IWebinarNeedRegisterHandler_WebinarNeedRegisterType_WebinarReg_By_Email_and_DisplayName : ZOOMSDK_IWebinarNeedRegisterHandler_WebinarNeedRegisterType = 2 ;
#[doc = " \\enum WebinarNeedRegisterType"]
#[doc = "\\brief Register type of webinar."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_IWebinarNeedRegisterHandler_WebinarNeedRegisterType = ::std::os::raw::c_int;
#[test]
fn bindgen_test_layout_ZOOMSDK_IWebinarNeedRegisterHandler() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IWebinarNeedRegisterHandler>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IWebinarNeedRegisterHandler))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IWebinarNeedRegisterHandler>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IWebinarNeedRegisterHandler)
)
);
}
#[doc = " \\brief Register webinar with URL Handler"]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IWebinarNeedRegisterHandlerByUrl {
pub _base: ZOOMSDK_IWebinarNeedRegisterHandler,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IWebinarNeedRegisterHandlerByUrl() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IWebinarNeedRegisterHandlerByUrl>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IWebinarNeedRegisterHandlerByUrl)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IWebinarNeedRegisterHandlerByUrl>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IWebinarNeedRegisterHandlerByUrl)
)
);
}
#[doc = " \\brief Webinar register with email and screen name Handler."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IWebinarNeedRegisterHandlerByEmail {
pub _base: ZOOMSDK_IWebinarNeedRegisterHandler,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IWebinarNeedRegisterHandlerByEmail() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IWebinarNeedRegisterHandlerByEmail>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IWebinarNeedRegisterHandlerByEmail)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IWebinarNeedRegisterHandlerByEmail>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IWebinarNeedRegisterHandlerByEmail)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IEndOtherMeetingToJoinMeetingHandler__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief End other meeting to join the new meeting Handler."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IEndOtherMeetingToJoinMeetingHandler {
pub vtable_: *const ZOOMSDK_IEndOtherMeetingToJoinMeetingHandler__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IEndOtherMeetingToJoinMeetingHandler() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IEndOtherMeetingToJoinMeetingHandler>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IEndOtherMeetingToJoinMeetingHandler)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IEndOtherMeetingToJoinMeetingHandler>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IEndOtherMeetingToJoinMeetingHandler)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IFreeMeetingEndingReminderHandler__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\deprecated This interface will be deprecated, please stop using it."]
#[doc = " \\brief Reminder handler of ending free meeting."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IFreeMeetingEndingReminderHandler {
pub vtable_: *const ZOOMSDK_IFreeMeetingEndingReminderHandler__bindgen_vtable,
}
#[doc = "<Initialization."]
pub const ZOOMSDK_IFreeMeetingEndingReminderHandler_FreeMeetingEndingReminderType_FreeMeetingEndingReminder_NONE : ZOOMSDK_IFreeMeetingEndingReminderHandler_FreeMeetingEndingReminderType = 0 ;
#[doc = "<Upgrade to the priority meeting at once."]
pub const ZOOMSDK_IFreeMeetingEndingReminderHandler_FreeMeetingEndingReminderType_FreeMeetingEndingReminder_Can_UpgradeMeeting_ToPro_Once : ZOOMSDK_IFreeMeetingEndingReminderHandler_FreeMeetingEndingReminderType = 1 ;
#[doc = "<Upgrade the account."]
pub const ZOOMSDK_IFreeMeetingEndingReminderHandler_FreeMeetingEndingReminderType_FreeMeetingEndingReminder_Can_UpgradeAccount : ZOOMSDK_IFreeMeetingEndingReminderHandler_FreeMeetingEndingReminderType = 2 ;
#[doc = "<Remind to pay."]
pub const ZOOMSDK_IFreeMeetingEndingReminderHandler_FreeMeetingEndingReminderType_FreeMeetingEndingReminder_Reminder : ZOOMSDK_IFreeMeetingEndingReminderHandler_FreeMeetingEndingReminderType = 3 ;
#[doc = "<Upgrade failed."]
pub const ZOOMSDK_IFreeMeetingEndingReminderHandler_FreeMeetingEndingReminderType_FreeMeetingEndingReminder_UpgradeMeeting_ToPro_Failed : ZOOMSDK_IFreeMeetingEndingReminderHandler_FreeMeetingEndingReminderType = 4 ;
#[doc = "<Upgrade successfully."]
pub const ZOOMSDK_IFreeMeetingEndingReminderHandler_FreeMeetingEndingReminderType_FreeMeetingEndingReminder_UpgradeMeeting_ToPro_Success : ZOOMSDK_IFreeMeetingEndingReminderHandler_FreeMeetingEndingReminderType = 5 ;
#[doc = " \\enum FreeMeetingEndingReminderType"]
#[doc = "\\brief Reminder type at the end of free meeting."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_IFreeMeetingEndingReminderHandler_FreeMeetingEndingReminderType =
::std::os::raw::c_int;
#[test]
fn bindgen_test_layout_ZOOMSDK_IFreeMeetingEndingReminderHandler() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IFreeMeetingEndingReminderHandler>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IFreeMeetingEndingReminderHandler)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IFreeMeetingEndingReminderHandler>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IFreeMeetingEndingReminderHandler)
)
);
}
#[doc = "<'Invite by Email' tab page"]
pub const ZOOMSDK_SDKInviteDlgTabPage_SDK_INVITEDLG_TAB_EMAILCONTACT: ZOOMSDK_SDKInviteDlgTabPage =
0;
#[doc = "<'Invite by Phone' tab pag"]
pub const ZOOMSDK_SDKInviteDlgTabPage_SDK_INVITEDLG_TAB_PHONECONTACT: ZOOMSDK_SDKInviteDlgTabPage =
1;
#[doc = "<'Invite a Room System' tab page"]
pub const ZOOMSDK_SDKInviteDlgTabPage_SDK_INVITEDLG_TAB_ROOMSYSTEM: ZOOMSDK_SDKInviteDlgTabPage = 2;
pub type ZOOMSDK_SDKInviteDlgTabPage = ::std::os::raw::c_int;
#[doc = "<'Dial In' sub-tab page under Room System invitation tab page"]
pub const ZOOMSDK_SDKH323TabPage_SDK_INVITEDLG_H323_DIALIN: ZOOMSDK_SDKH323TabPage = 0;
#[doc = "<'Call Out' sub-tab page under Room System invitation tab page"]
pub const ZOOMSDK_SDKH323TabPage_SDK_INVITEDLG_H323_CALLOUT: ZOOMSDK_SDKH323TabPage = 1;
pub type ZOOMSDK_SDKH323TabPage = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IMeetingConfigurationFreeMeetingEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Free meeting event handler."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingConfigurationFreeMeetingEvent {
pub vtable_: *const ZOOMSDK_IMeetingConfigurationFreeMeetingEvent__bindgen_vtable,
}
#[doc = "<Initialization."]
pub const ZOOMSDK_IMeetingConfigurationFreeMeetingEvent_FreeMeetingNeedUpgradeType_FreeMeetingNeedUpgradeType_NONE : ZOOMSDK_IMeetingConfigurationFreeMeetingEvent_FreeMeetingNeedUpgradeType = 0 ;
#[doc = "<It is necessary for administrator to upgrade the free meeting."]
pub const ZOOMSDK_IMeetingConfigurationFreeMeetingEvent_FreeMeetingNeedUpgradeType_FreeMeetingNeedUpgradeType_BY_ADMIN : ZOOMSDK_IMeetingConfigurationFreeMeetingEvent_FreeMeetingNeedUpgradeType = 1 ;
#[doc = "<Upgrade the free meeting by the gift link."]
pub const ZOOMSDK_IMeetingConfigurationFreeMeetingEvent_FreeMeetingNeedUpgradeType_FreeMeetingNeedUpgradeType_BY_GIFTURL : ZOOMSDK_IMeetingConfigurationFreeMeetingEvent_FreeMeetingNeedUpgradeType = 2 ;
#[doc = " \\enum FreeMeetingNeedUpgradeType"]
#[doc = "\\brief Upgrade types of free meeting."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_IMeetingConfigurationFreeMeetingEvent_FreeMeetingNeedUpgradeType =
::std::os::raw::c_int;
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingConfigurationFreeMeetingEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingConfigurationFreeMeetingEvent>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IMeetingConfigurationFreeMeetingEvent)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingConfigurationFreeMeetingEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingConfigurationFreeMeetingEvent)
)
);
}
#[doc = " \\brief Meeting configuration event callback."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingConfigurationEvent {
pub _base: ZOOMSDK_IMeetingConfigurationFreeMeetingEvent,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingConfigurationEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingConfigurationEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingConfigurationEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingConfigurationEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingConfigurationEvent)
)
);
}
#[doc = " \\struct tagRedirectWarningMsgOption"]
#[doc = "\\brief Determine if the user handles the corresponding type of the warning message with user's own program."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagRedirectWarningMsgOption {
#[doc = "<TRUE indicates the user will handle the warning message of bad network with its own program."]
pub bRedirectBadNetwork: bool,
#[doc = "<TRUE indicates the user will handle the warning message of high cpu with its own program."]
pub bRedirectWarnHighCPU: bool,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagRedirectWarningMsgOption() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagRedirectWarningMsgOption>(),
2usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagRedirectWarningMsgOption))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagRedirectWarningMsgOption>(),
1usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagRedirectWarningMsgOption)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagRedirectWarningMsgOption>())).bRedirectBadNetwork
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagRedirectWarningMsgOption),
"::",
stringify!(bRedirectBadNetwork)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagRedirectWarningMsgOption>())).bRedirectWarnHighCPU
as *const _ as usize
},
1usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagRedirectWarningMsgOption),
"::",
stringify!(bRedirectWarnHighCPU)
)
);
}
#[doc = " \\struct tagRedirectWarningMsgOption"]
#[doc = "\\brief Determine if the user handles the corresponding type of the warning message with user's own program."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_RedirectWarningMsgOption = ZOOMSDK_tagRedirectWarningMsgOption;
#[doc = " \\struct tagPanelistMenuItemOption"]
#[doc = "\\brief Define the strategy to show the menu items for panelist."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagPanelistMenuItemOption {
#[doc = "<True indicates to hide 'Change role to attendee' menu item"]
pub bNotShowDowngradePanelist: bool,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagPanelistMenuItemOption() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagPanelistMenuItemOption>(),
1usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagPanelistMenuItemOption))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagPanelistMenuItemOption>(),
1usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagPanelistMenuItemOption)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagPanelistMenuItemOption>())).bNotShowDowngradePanelist
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagPanelistMenuItemOption),
"::",
stringify!(bNotShowDowngradePanelist)
)
);
}
#[doc = " \\struct tagPanelistMenuItemOption"]
#[doc = "\\brief Define the strategy to show the menu items for panelist."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_PanelistMenuItemOption = ZOOMSDK_tagPanelistMenuItemOption;
#[doc = " \\struct tagAttendeeMenuItemOption"]
#[doc = "\\brief Define the strategy to show the menu items for attendee."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagAttendeeMenuItemOption {
#[doc = "<True indicates to hide 'Promote to panelist'menu item"]
pub bNotShowPromoteToPanelist: bool,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagAttendeeMenuItemOption() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagAttendeeMenuItemOption>(),
1usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagAttendeeMenuItemOption))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagAttendeeMenuItemOption>(),
1usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagAttendeeMenuItemOption)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagAttendeeMenuItemOption>())).bNotShowPromoteToPanelist
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagAttendeeMenuItemOption),
"::",
stringify!(bNotShowPromoteToPanelist)
)
);
}
#[doc = " \\struct tagAttendeeMenuItemOption"]
#[doc = "\\brief Define the strategy to show the menu items for attendee."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_AttendeeMenuItemOption = ZOOMSDK_tagAttendeeMenuItemOption;
#[repr(C)]
pub struct ZOOMSDK_IMeetingUIElemConfiguration__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting user configuration interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingUIElemConfiguration {
pub vtable_: *const ZOOMSDK_IMeetingUIElemConfiguration__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingUIElemConfiguration() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingUIElemConfiguration>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingUIElemConfiguration))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingUIElemConfiguration>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingUIElemConfiguration)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IJoinMeetingBehaviorConfiguration__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting connect configuration Interface"]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IJoinMeetingBehaviorConfiguration {
pub vtable_: *const ZOOMSDK_IJoinMeetingBehaviorConfiguration__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IJoinMeetingBehaviorConfiguration() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IJoinMeetingBehaviorConfiguration>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IJoinMeetingBehaviorConfiguration)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IJoinMeetingBehaviorConfiguration>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IJoinMeetingBehaviorConfiguration)
)
);
}
#[doc = " \\brief Meeting configuration interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingConfiguration {
pub _base: ZOOMSDK_IMeetingUIElemConfiguration,
pub _base_1: ZOOMSDK_IJoinMeetingBehaviorConfiguration,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingConfiguration() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingConfiguration>(),
8usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingConfiguration))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingConfiguration>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMeetingConfiguration))
);
}
#[doc = "<Used only for initialization."]
pub const ZOOMSDK_H323CalloutStatus_H323Callout_Unknown: ZOOMSDK_H323CalloutStatus = 0;
#[doc = "<Call out successfully."]
pub const ZOOMSDK_H323CalloutStatus_H323Callout_Success: ZOOMSDK_H323CalloutStatus = 1;
#[doc = "<Bell during the call."]
pub const ZOOMSDK_H323CalloutStatus_H323Callout_Ring: ZOOMSDK_H323CalloutStatus = 2;
#[doc = "<Call timeout."]
pub const ZOOMSDK_H323CalloutStatus_H323Callout_Timeout: ZOOMSDK_H323CalloutStatus = 3;
#[doc = "<Call fails."]
pub const ZOOMSDK_H323CalloutStatus_H323Callout_Failed: ZOOMSDK_H323CalloutStatus = 4;
#[doc = "<Busy"]
pub const ZOOMSDK_H323CalloutStatus_H323Callout_Busy: ZOOMSDK_H323CalloutStatus = 5;
#[doc = "<Decline"]
pub const ZOOMSDK_H323CalloutStatus_H323Callout_Decline: ZOOMSDK_H323CalloutStatus = 6;
#[doc = " \\enum H323CalloutStatus"]
#[doc = "\\brief H.323 Callout status."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_H323CalloutStatus = ::std::os::raw::c_int;
#[doc = "<Used only for initialization."]
pub const ZOOMSDK_H323ParingResult_H323Paring_Unknown: ZOOMSDK_H323ParingResult = 0;
#[doc = "<Pairing successful."]
pub const ZOOMSDK_H323ParingResult_H323Paring_Success: ZOOMSDK_H323ParingResult = 1;
#[doc = "<The meeting being paired does not exist."]
pub const ZOOMSDK_H323ParingResult_H323Paring_Meeting_Not_Exist: ZOOMSDK_H323ParingResult = 2;
#[doc = "<Pairing code does not exist."]
pub const ZOOMSDK_H323ParingResult_H323Paring_Paringcode_Not_Exist: ZOOMSDK_H323ParingResult = 3;
#[doc = "<No pairing privilege."]
pub const ZOOMSDK_H323ParingResult_H323Paring_No_Privilege: ZOOMSDK_H323ParingResult = 4;
#[doc = "<Other issues."]
pub const ZOOMSDK_H323ParingResult_H323Paring_Other_Error: ZOOMSDK_H323ParingResult = 5;
#[doc = " \\enum H323ParingResult"]
#[doc = "\\brief H.323 Pairing status."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_H323ParingResult = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IMeetingH323HelperEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting H.323 Helper callback event."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingH323HelperEvent {
pub vtable_: *const ZOOMSDK_IMeetingH323HelperEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingH323HelperEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingH323HelperEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingH323HelperEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingH323HelperEvent>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMeetingH323HelperEvent))
);
}
#[doc = "<Unknown device, only for initialization."]
pub const ZOOMSDK_H323DeviceType_H323DeviceType_Unknown: ZOOMSDK_H323DeviceType = 0;
#[doc = "<H.323 device."]
pub const ZOOMSDK_H323DeviceType_H323DeviceType_H323: ZOOMSDK_H323DeviceType = 1;
#[doc = "<SIP device."]
pub const ZOOMSDK_H323DeviceType_H323DeviceType_SIP: ZOOMSDK_H323DeviceType = 2;
#[doc = "<H.323 device and SIP device."]
pub const ZOOMSDK_H323DeviceType_H323DeviceType_BOTH: ZOOMSDK_H323DeviceType = 3;
#[doc = " \\enum H323DeviceType"]
#[doc = "\\brief H.323 device type."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_H323DeviceType = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IH323Device__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting H.323 device Interface"]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IH323Device {
pub vtable_: *const ZOOMSDK_IH323Device__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IH323Device() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IH323Device>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IH323Device))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IH323Device>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IH323Device))
);
}
#[doc = " \\brief Customized Meeting H.323 device"]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_CustomizedH323Device {
pub _base: ZOOMSDK_IH323Device,
#[doc = "<Type of device."]
pub _type: ZOOMSDK_H323DeviceType,
#[doc = "<Device name."]
pub _name: std_wstring,
#[doc = "<Device IP."]
pub _ip: std_wstring,
#[doc = "<E.164 number"]
pub _e164num: std_wstring,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_CustomizedH323Device() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_CustomizedH323Device>(),
80usize,
concat!("Size of: ", stringify!(ZOOMSDK_CustomizedH323Device))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_CustomizedH323Device>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_CustomizedH323Device))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_CustomizedH323Device>()))._type as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_CustomizedH323Device),
"::",
stringify!(_type)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_CustomizedH323Device>()))._name as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_CustomizedH323Device),
"::",
stringify!(_name)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_CustomizedH323Device>()))._ip as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_CustomizedH323Device),
"::",
stringify!(_ip)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_CustomizedH323Device>()))._e164num as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_CustomizedH323Device),
"::",
stringify!(_e164num)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingH323Helper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting H323 Helper Interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingH323Helper {
pub vtable_: *const ZOOMSDK_IMeetingH323Helper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingH323Helper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingH323Helper>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingH323Helper))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingH323Helper>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMeetingH323Helper))
);
}
#[doc = "<For initialization."]
pub const ZOOMSDK_UserRole_USERROLE_NONE: ZOOMSDK_UserRole = 0;
#[doc = "<Role of the host."]
pub const ZOOMSDK_UserRole_USERROLE_HOST: ZOOMSDK_UserRole = 1;
#[doc = "<Role of co-host."]
pub const ZOOMSDK_UserRole_USERROLE_COHOST: ZOOMSDK_UserRole = 2;
#[doc = "<Role of the panelist, valid only in webinar."]
pub const ZOOMSDK_UserRole_USERROLE_PANELIST: ZOOMSDK_UserRole = 3;
#[doc = "<Host role in breakout room."]
pub const ZOOMSDK_UserRole_USERROLE_BREAKOUTROOM_MODERATOR: ZOOMSDK_UserRole = 4;
#[doc = "<Role of attendee."]
pub const ZOOMSDK_UserRole_USERROLE_ATTENDEE: ZOOMSDK_UserRole = 5;
#[doc = " \\enum UserRole"]
#[doc = "\\brief Role of user."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_UserRole = ::std::os::raw::c_int;
#[doc = " \\struct tagWebinarAttendeeStatus"]
#[doc = "\\brief Status of webinar attendee."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagWebinarAttendeeStatus {
#[doc = "<TRUE indicates that it is able to talk."]
pub allow_talk: bool,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagWebinarAttendeeStatus() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagWebinarAttendeeStatus>(),
1usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagWebinarAttendeeStatus))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagWebinarAttendeeStatus>(),
1usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagWebinarAttendeeStatus)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagWebinarAttendeeStatus>())).allow_talk as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagWebinarAttendeeStatus),
"::",
stringify!(allow_talk)
)
);
}
#[doc = " \\struct tagWebinarAttendeeStatus"]
#[doc = "\\brief Status of webinar attendee."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_WebinarAttendeeStatus = ZOOMSDK_tagWebinarAttendeeStatus;
#[repr(C)]
pub struct ZOOMSDK_IUserInfo__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief User information interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IUserInfo {
pub vtable_: *const ZOOMSDK_IUserInfo__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IUserInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IUserInfo>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IUserInfo))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IUserInfo>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IUserInfo))
);
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingParticipantsCtrlEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting Participants Controller Callback Event."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingParticipantsCtrlEvent {
pub vtable_: *const ZOOMSDK_IMeetingParticipantsCtrlEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingParticipantsCtrlEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingParticipantsCtrlEvent>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IMeetingParticipantsCtrlEvent)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingParticipantsCtrlEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingParticipantsCtrlEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingParticipantsController__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting waiting room controller interface"]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingParticipantsController {
pub vtable_: *const ZOOMSDK_IMeetingParticipantsController__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingParticipantsController() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingParticipantsController>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IMeetingParticipantsController)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingParticipantsController>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingParticipantsController)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingPhoneSupportCountryInfo__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Phone meeting support country information interface."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IMeetingPhoneSupportCountryInfo {
pub vtable_: *const ZOOMSDK_IMeetingPhoneSupportCountryInfo__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingPhoneSupportCountryInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingPhoneSupportCountryInfo>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IMeetingPhoneSupportCountryInfo)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingPhoneSupportCountryInfo>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingPhoneSupportCountryInfo)
)
);
}
#[doc = "<For initialization."]
pub const ZOOMSDK_CALLINNUMTYPE_CALLINNUMTYPE_NONE: ZOOMSDK_CALLINNUMTYPE = 0;
#[doc = "<Paid."]
pub const ZOOMSDK_CALLINNUMTYPE_CALLINNUMTYPE_TOLL: ZOOMSDK_CALLINNUMTYPE = 1;
#[doc = "<Free."]
pub const ZOOMSDK_CALLINNUMTYPE_CALLINNUMTYPE_TOLLFREE: ZOOMSDK_CALLINNUMTYPE = 2;
#[doc = " \\enum CALLINNUMTYPE"]
#[doc = "\\brief Type of telephone call."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_CALLINNUMTYPE = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IMeetingCallInPhoneNumberInfo__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Call-in meeting Interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IMeetingCallInPhoneNumberInfo {
pub vtable_: *const ZOOMSDK_IMeetingCallInPhoneNumberInfo__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingCallInPhoneNumberInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingCallInPhoneNumberInfo>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IMeetingCallInPhoneNumberInfo)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingCallInPhoneNumberInfo>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingCallInPhoneNumberInfo)
)
);
}
#[doc = "<No status."]
pub const ZOOMSDK_PhoneStatus_PhoneStatus_None: ZOOMSDK_PhoneStatus = 0;
#[doc = "<In process of calling out."]
pub const ZOOMSDK_PhoneStatus_PhoneStatus_Calling: ZOOMSDK_PhoneStatus = 1;
#[doc = "<In process of ringing."]
pub const ZOOMSDK_PhoneStatus_PhoneStatus_Ringing: ZOOMSDK_PhoneStatus = 2;
#[doc = "<Accept the call."]
pub const ZOOMSDK_PhoneStatus_PhoneStatus_Accepted: ZOOMSDK_PhoneStatus = 3;
#[doc = "<Call successful."]
pub const ZOOMSDK_PhoneStatus_PhoneStatus_Success: ZOOMSDK_PhoneStatus = 4;
#[doc = "<Call failed."]
pub const ZOOMSDK_PhoneStatus_PhoneStatus_Failed: ZOOMSDK_PhoneStatus = 5;
#[doc = "<In process of canceling the response to the previous state."]
pub const ZOOMSDK_PhoneStatus_PhoneStatus_Canceling: ZOOMSDK_PhoneStatus = 6;
#[doc = "<Cancel successfully."]
pub const ZOOMSDK_PhoneStatus_PhoneStatus_Canceled: ZOOMSDK_PhoneStatus = 7;
#[doc = "<Cancel fails."]
pub const ZOOMSDK_PhoneStatus_PhoneStatus_Cancel_Failed: ZOOMSDK_PhoneStatus = 8;
#[doc = "<Timeout."]
pub const ZOOMSDK_PhoneStatus_PhoneStatus_Timeout: ZOOMSDK_PhoneStatus = 9;
#[doc = " \\enum PhoneStatus"]
#[doc = "\\brief Status of telephone."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_PhoneStatus = ::std::os::raw::c_int;
#[doc = "<For initialization."]
pub const ZOOMSDK_PhoneFailedReason_PhoneFailedReason_None: ZOOMSDK_PhoneFailedReason = 0;
#[doc = "<The telephone service is busy."]
pub const ZOOMSDK_PhoneFailedReason_PhoneFailedReason_Busy: ZOOMSDK_PhoneFailedReason = 1;
#[doc = "<The telephone is out of the service."]
pub const ZOOMSDK_PhoneFailedReason_PhoneFailedReason_Not_Available: ZOOMSDK_PhoneFailedReason = 2;
#[doc = "<The user hangs up."]
pub const ZOOMSDK_PhoneFailedReason_PhoneFailedReason_User_Hangup: ZOOMSDK_PhoneFailedReason = 3;
#[doc = "<Other reasons."]
pub const ZOOMSDK_PhoneFailedReason_PhoneFailedReason_Other_Fail: ZOOMSDK_PhoneFailedReason = 4;
#[doc = "<The telephone does not reply."]
pub const ZOOMSDK_PhoneFailedReason_PhoneFailedReason_No_Answer: ZOOMSDK_PhoneFailedReason = 5;
#[doc = "<Disable the function of international call-out before the host joins the meeting."]
pub const ZOOMSDK_PhoneFailedReason_PhoneFailedReason_Block_No_Host: ZOOMSDK_PhoneFailedReason = 6;
#[doc = "<The call-out is blocked by the system due to the high cost."]
pub const ZOOMSDK_PhoneFailedReason_PhoneFailedReason_Block_High_Rate: ZOOMSDK_PhoneFailedReason =
7;
#[doc = "<All the invitees invited by the call should press the button one(1) to join the meeting. In case that many invitees do not press the button that leads to time out, the call invitation for this meeting shall be banned."]
pub const ZOOMSDK_PhoneFailedReason_PhoneFailedReason_Block_Too_Frequent:
ZOOMSDK_PhoneFailedReason = 8;
#[doc = " \\enum PhoneFailedReason"]
#[doc = "\\brief The reason for the failure of the telephone call."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_PhoneFailedReason = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IMeetingPhoneHelperEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting phone helper callback event."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingPhoneHelperEvent {
pub vtable_: *const ZOOMSDK_IMeetingPhoneHelperEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingPhoneHelperEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingPhoneHelperEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingPhoneHelperEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingPhoneHelperEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingPhoneHelperEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingPhoneHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting phone helper interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingPhoneHelper {
pub vtable_: *const ZOOMSDK_IMeetingPhoneHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingPhoneHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingPhoneHelper>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingPhoneHelper))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingPhoneHelper>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMeetingPhoneHelper))
);
}
pub const ZOOMSDK_RecordingStatus_Recording_Start: ZOOMSDK_RecordingStatus = 0;
#[doc = "Start recording on local computer or on cloud."]
pub const ZOOMSDK_RecordingStatus_Recording_Stop: ZOOMSDK_RecordingStatus = 1;
#[doc = "Stop recording on local computer or on cloud."]
pub const ZOOMSDK_RecordingStatus_Recording_DiskFull: ZOOMSDK_RecordingStatus = 2;
#[doc = "There is no space to store for both local and cloud recording."]
pub const ZOOMSDK_RecordingStatus_Recording_Pause: ZOOMSDK_RecordingStatus = 3;
#[doc = "Pause recording on local or on cloud."]
pub const ZOOMSDK_RecordingStatus_Recording_Connecting: ZOOMSDK_RecordingStatus = 4;
#[doc = " \\enum RecordingStatus"]
#[doc = "\\brief Recording status."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_RecordingStatus = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IMeetingRecordingCtrlEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting recording callback event."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingRecordingCtrlEvent {
pub vtable_: *const ZOOMSDK_IMeetingRecordingCtrlEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingRecordingCtrlEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingRecordingCtrlEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingRecordingCtrlEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingRecordingCtrlEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingRecordingCtrlEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingRecordingController__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting recording controller interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingRecordingController {
pub vtable_: *const ZOOMSDK_IMeetingRecordingController__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingRecordingController() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingRecordingController>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingRecordingController))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingRecordingController>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingRecordingController)
)
);
}
#[doc = "<For initialization."]
pub const ZOOMSDK_RemoteControlStatus_Remote_Control_None: ZOOMSDK_RemoteControlStatus = 0;
#[doc = "<Remote control information. I can enable the remote control."]
pub const ZOOMSDK_RemoteControlStatus_Remote_Control_I_Can_Request_Control_Who:
ZOOMSDK_RemoteControlStatus = 1;
#[doc = "<The authority of remote control. I get control when remote control begins."]
pub const ZOOMSDK_RemoteControlStatus_Remote_Control_I_Can_Control_Who_Begin:
ZOOMSDK_RemoteControlStatus = 2;
#[doc = "<The authority of remote control. I lose control when remote control ends."]
pub const ZOOMSDK_RemoteControlStatus_Remote_Control_I_Can_Control_Who_End:
ZOOMSDK_RemoteControlStatus = 3;
#[doc = "<The status of remote control. I am in the status of remote control."]
pub const ZOOMSDK_RemoteControlStatus_Remote_Control_I_Control_Who_Begin:
ZOOMSDK_RemoteControlStatus = 4;
#[doc = "<The status of remote control. I am out of the remote control."]
pub const ZOOMSDK_RemoteControlStatus_Remote_Control_I_Control_Who_End:
ZOOMSDK_RemoteControlStatus = 5;
#[doc = "<The status of remote control. I am controlled by whom."]
pub const ZOOMSDK_RemoteControlStatus_Remote_Control_Who_Control_Me: ZOOMSDK_RemoteControlStatus =
6;
#[doc = "<Remote control information. I have received a refused information of remote control."]
pub const ZOOMSDK_RemoteControlStatus_Remote_Control_I_Recv_Decline_Msg:
ZOOMSDK_RemoteControlStatus = 7;
#[doc = "<Remote control information. I have received an information of request for remote control."]
pub const ZOOMSDK_RemoteControlStatus_Remote_Control_I_Recv_Request_Msg:
ZOOMSDK_RemoteControlStatus = 8;
#[doc = " \\enum RemoteControlStatus"]
#[doc = "\\brief Information category for authority and status changes during the remote Control."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_RemoteControlStatus = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IMeetingRemoteCtrlEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting remote control callback event."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingRemoteCtrlEvent {
pub vtable_: *const ZOOMSDK_IMeetingRemoteCtrlEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingRemoteCtrlEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingRemoteCtrlEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingRemoteCtrlEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingRemoteCtrlEvent>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMeetingRemoteCtrlEvent))
);
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingRemoteController__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting remote control interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingRemoteController {
pub vtable_: *const ZOOMSDK_IMeetingRemoteController__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingRemoteController() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingRemoteController>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingRemoteController))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingRemoteController>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingRemoteController)
)
);
}
#[doc = "<Begin to share by the user himself."]
pub const ZOOMSDK_SharingStatus_Sharing_Self_Send_Begin: ZOOMSDK_SharingStatus = 0;
#[doc = "<Stop sharing by the user."]
pub const ZOOMSDK_SharingStatus_Sharing_Self_Send_End: ZOOMSDK_SharingStatus = 1;
#[doc = "<Others begin to share."]
pub const ZOOMSDK_SharingStatus_Sharing_Other_Share_Begin: ZOOMSDK_SharingStatus = 2;
#[doc = "<Others stop sharing."]
pub const ZOOMSDK_SharingStatus_Sharing_Other_Share_End: ZOOMSDK_SharingStatus = 3;
#[doc = "<View the sharing of others."]
pub const ZOOMSDK_SharingStatus_Sharing_View_Other_Sharing: ZOOMSDK_SharingStatus = 4;
#[doc = "<Pause sharing."]
pub const ZOOMSDK_SharingStatus_Sharing_Pause: ZOOMSDK_SharingStatus = 5;
#[doc = "<Resume sharing."]
pub const ZOOMSDK_SharingStatus_Sharing_Resume: ZOOMSDK_SharingStatus = 6;
#[doc = " \\enum SharingStatus"]
#[doc = "\\brief Sharing status."]
#[doc = "Here are more detailed structural descriptions.."]
pub type ZOOMSDK_SharingStatus = ::std::os::raw::c_int;
#[doc = " \\struct tagViewableShareSource"]
#[doc = "\\brief Visible shared source information."]
#[doc = "Here are more detailed structural descriptions.."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagViewableShareSource {
#[doc = "<User ID."]
pub userid: ::std::os::raw::c_uint,
#[doc = "<Display or not on the primary view."]
pub isShowingInFirstView: bool,
#[doc = "<Display or not on the secondary view."]
pub isShowingInSecondView: bool,
#[doc = "<Enable or disable the remote control."]
pub isCanBeRemoteControl: bool,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagViewableShareSource() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagViewableShareSource>(),
8usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagViewableShareSource))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagViewableShareSource>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagViewableShareSource))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagViewableShareSource>())).userid as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagViewableShareSource),
"::",
stringify!(userid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagViewableShareSource>())).isShowingInFirstView
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagViewableShareSource),
"::",
stringify!(isShowingInFirstView)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagViewableShareSource>())).isShowingInSecondView
as *const _ as usize
},
5usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagViewableShareSource),
"::",
stringify!(isShowingInSecondView)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagViewableShareSource>())).isCanBeRemoteControl
as *const _ as usize
},
6usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagViewableShareSource),
"::",
stringify!(isCanBeRemoteControl)
)
);
}
#[doc = " \\struct tagViewableShareSource"]
#[doc = "\\brief Visible shared source information."]
#[doc = "Here are more detailed structural descriptions.."]
pub type ZOOMSDK_ViewableShareSource = ZOOMSDK_tagViewableShareSource;
#[doc = "<Type unknown."]
pub const ZOOMSDK_ShareType_SHARE_TYPE_UNKNOWN: ZOOMSDK_ShareType = 0;
#[doc = "<Type of sharing the application."]
pub const ZOOMSDK_ShareType_SHARE_TYPE_AS: ZOOMSDK_ShareType = 1;
#[doc = "<Type of sharing the desktop."]
pub const ZOOMSDK_ShareType_SHARE_TYPE_DS: ZOOMSDK_ShareType = 2;
#[doc = "<Type of sharing the white-board."]
pub const ZOOMSDK_ShareType_SHARE_TYPE_WB: ZOOMSDK_ShareType = 3;
#[doc = "<Type of sharing data from the device connected WIFI."]
pub const ZOOMSDK_ShareType_SHARE_TYPE_AIRHOST: ZOOMSDK_ShareType = 4;
#[doc = "<Type of sharing the camera."]
pub const ZOOMSDK_ShareType_SHARE_TYPE_CAMERA: ZOOMSDK_ShareType = 5;
#[doc = "<Type of sharing the data."]
pub const ZOOMSDK_ShareType_SHARE_TYPE_DATA: ZOOMSDK_ShareType = 6;
#[doc = " \\enum ShareType"]
#[doc = "Type of current sharing received by the user."]
#[doc = "Here are more detailed structural descriptions.."]
pub type ZOOMSDK_ShareType = ::std::os::raw::c_int;
#[doc = "<Type of sharing a selected area of desktop."]
pub const ZOOMSDK_AdvanceShareOption_AdvanceShareOption_ShareFrame: ZOOMSDK_AdvanceShareOption = 0;
#[doc = "<Type of sharing only the computer audio."]
pub const ZOOMSDK_AdvanceShareOption_AdvanceShareOption_PureComputerAudio:
ZOOMSDK_AdvanceShareOption = 1;
#[doc = "<Type of sharing the camera."]
pub const ZOOMSDK_AdvanceShareOption_AdvanceShareOption_ShareCamera: ZOOMSDK_AdvanceShareOption = 2;
#[doc = " \\enum AdvanceShareOption"]
#[doc = "Additional type of current sharing sent to others."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_AdvanceShareOption = ::std::os::raw::c_int;
#[doc = "<Multi-participants can share simultaneously."]
pub const ZOOMSDK_MultiShareOption_Enable_Multi_Share: ZOOMSDK_MultiShareOption = 0;
#[doc = "<Only host can share at a time."]
pub const ZOOMSDK_MultiShareOption_Enable_Only_HOST_Start_Share: ZOOMSDK_MultiShareOption = 1;
#[doc = "<One participant can share at a time, during sharing only host can start a new sharing and the previous sharing will be replaced."]
pub const ZOOMSDK_MultiShareOption_Enable_Only_HOST_Grab_Share: ZOOMSDK_MultiShareOption = 2;
#[doc = "<One participant can share at a time, during sharing everyone can start a new sharing and the previous sharing will be replaced."]
pub const ZOOMSDK_MultiShareOption_Enable_All_Grab_Share: ZOOMSDK_MultiShareOption = 3;
#[doc = " \\struct tagShareInfo"]
#[doc = "\\brief Information of current sharing."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_MultiShareOption = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ZOOMSDK_tagShareInfo {
#[doc = "<Type of sharing, see \\link ShareType \\endlink enum."]
pub eShareType: ZOOMSDK_ShareType,
pub ut: ZOOMSDK_tagShareInfo__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ZOOMSDK_tagShareInfo__bindgen_ty_1 {
#[doc = "<Handle of sharing application or white-board. It is invalid unless the value of the eShareType is SHARE_TYPE_AS or SHARE_TYPE_WB."]
pub hwndSharedApp: HWND,
#[doc = "<The ID of screen to be shared. It is invalid unless the value of the eShareType is SHARE_TYPE_DS."]
pub monitorID: *const u16,
_bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagShareInfo__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagShareInfo__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagShareInfo__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagShareInfo__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagShareInfo__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagShareInfo__bindgen_ty_1>())).hwndSharedApp as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagShareInfo__bindgen_ty_1),
"::",
stringify!(hwndSharedApp)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagShareInfo__bindgen_ty_1>())).monitorID as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagShareInfo__bindgen_ty_1),
"::",
stringify!(monitorID)
)
);
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagShareInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagShareInfo>(),
8usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagShareInfo))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagShareInfo>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagShareInfo))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZOOMSDK_tagShareInfo>())).eShareType as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagShareInfo),
"::",
stringify!(eShareType)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ZOOMSDK_tagShareInfo>())).ut as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagShareInfo),
"::",
stringify!(ut)
)
);
}
pub type ZOOMSDK_ShareInfo = ZOOMSDK_tagShareInfo;
#[repr(C)]
pub struct ZOOMSDK_IShareSwitchMultiToSingleConfirmHandler__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Reminder handler of switching from multi-share to single share."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IShareSwitchMultiToSingleConfirmHandler {
pub vtable_: *const ZOOMSDK_IShareSwitchMultiToSingleConfirmHandler__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IShareSwitchMultiToSingleConfirmHandler() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IShareSwitchMultiToSingleConfirmHandler>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IShareSwitchMultiToSingleConfirmHandler)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IShareSwitchMultiToSingleConfirmHandler>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IShareSwitchMultiToSingleConfirmHandler)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingShareCtrlEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Callback event of meeting share controller."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingShareCtrlEvent {
pub vtable_: *const ZOOMSDK_IMeetingShareCtrlEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingShareCtrlEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingShareCtrlEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingShareCtrlEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingShareCtrlEvent>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMeetingShareCtrlEvent))
);
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingShareController__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting share controller interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingShareController {
pub vtable_: *const ZOOMSDK_IMeetingShareController__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingShareController() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingShareController>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingShareController))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingShareController>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMeetingShareController))
);
}
#[doc = "<For initialization."]
pub const ZOOMSDK_SDKMeetingUIType_SDK_Meeting_UI_None: ZOOMSDK_SDKMeetingUIType = 0;
#[doc = "<Video wall mode."]
pub const ZOOMSDK_SDKMeetingUIType_SDK_Meeting_UI_VideoWall_Mode: ZOOMSDK_SDKMeetingUIType = 1;
#[doc = "<Active user mode."]
pub const ZOOMSDK_SDKMeetingUIType_SDK_Meeting_UI_ActiveRender_Mode: ZOOMSDK_SDKMeetingUIType = 2;
#[doc = " \\enum SDKMeetingUIType"]
#[doc = "\\brief The displayed type of the user videos in the meeting."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_SDKMeetingUIType = ::std::os::raw::c_int;
#[doc = " \\struct tagVideoWallPageInfoParam"]
#[doc = "\\brief Video wall page information."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagVideoWallPageInfoParam {
#[doc = "<The page in video wall mode for the moment."]
pub nCurrentPage: ::std::os::raw::c_int,
#[doc = "<The total number of pages in video wall mode."]
pub nTotalPages: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagVideoWallPageInfoParam() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagVideoWallPageInfoParam>(),
8usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagVideoWallPageInfoParam))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagVideoWallPageInfoParam>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagVideoWallPageInfoParam)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagVideoWallPageInfoParam>())).nCurrentPage as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagVideoWallPageInfoParam),
"::",
stringify!(nCurrentPage)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagVideoWallPageInfoParam>())).nTotalPages as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagVideoWallPageInfoParam),
"::",
stringify!(nTotalPages)
)
);
}
#[doc = " \\struct tagVideoWallPageInfoParam"]
#[doc = "\\brief Video wall page information."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_VideoWallPageInfoParam = ZOOMSDK_tagVideoWallPageInfoParam;
#[doc = " \\struct tagShowChatDlgParam"]
#[doc = "\\brief The configuration of the parameters to display the dialog."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagShowChatDlgParam {
#[doc = "<Parent window handle."]
pub hParent: HWND,
#[doc = "<Chat dialog position."]
pub rect: RECT,
#[doc = "<Chat dialog handle."]
pub hChatWnd: HWND,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagShowChatDlgParam() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagShowChatDlgParam>(),
24usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagShowChatDlgParam))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagShowChatDlgParam>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagShowChatDlgParam))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagShowChatDlgParam>())).hParent as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagShowChatDlgParam),
"::",
stringify!(hParent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagShowChatDlgParam>())).rect as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagShowChatDlgParam),
"::",
stringify!(rect)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagShowChatDlgParam>())).hChatWnd as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagShowChatDlgParam),
"::",
stringify!(hChatWnd)
)
);
}
#[doc = " \\struct tagShowChatDlgParam"]
#[doc = "\\brief The configuration of the parameters to display the dialog."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_ShowChatDlgParam = ZOOMSDK_tagShowChatDlgParam;
#[doc = "<Type of list."]
pub const ZOOMSDK_SDKFloatVideoType_FLOATVIDEO_List: ZOOMSDK_SDKFloatVideoType = 0;
#[doc = "<Small."]
pub const ZOOMSDK_SDKFloatVideoType_FLOATVIDEO_Small: ZOOMSDK_SDKFloatVideoType = 1;
#[doc = "<Large."]
pub const ZOOMSDK_SDKFloatVideoType_FLOATVIDEO_Large: ZOOMSDK_SDKFloatVideoType = 2;
#[doc = "<Minimized."]
pub const ZOOMSDK_SDKFloatVideoType_FLOATVIDEO_Minimize: ZOOMSDK_SDKFloatVideoType = 3;
#[doc = " \\enum SDKFloatVideoType"]
#[doc = "\\brief The user interface type of float video."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_SDKFloatVideoType = ::std::os::raw::c_int;
#[doc = "<For initialization."]
pub const ZOOMSDK_SDKMinimizeUIMode_MinimizeUIMode_NONE: ZOOMSDK_SDKMinimizeUIMode = 0;
#[doc = "<Minimized mode for sharing."]
pub const ZOOMSDK_SDKMinimizeUIMode_MinimizeUIMode_SHARE: ZOOMSDK_SDKMinimizeUIMode = 1;
#[doc = "<Minimized mode for video."]
pub const ZOOMSDK_SDKMinimizeUIMode_MinimizeUIMode_VIDEO: ZOOMSDK_SDKMinimizeUIMode = 2;
#[doc = "<Minimized mode for speaking."]
pub const ZOOMSDK_SDKMinimizeUIMode_MinimizeUIMode_ACTIVESPEAKER: ZOOMSDK_SDKMinimizeUIMode = 3;
#[doc = " \\enum SDKMinimizeUIMode"]
#[doc = "\\brief The type of minimize user interface mode."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_SDKMinimizeUIMode = ::std::os::raw::c_int;
#[doc = " \\struct tagSplitScreenInfo"]
#[doc = "\\brief Split screen mode information."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagSplitScreenInfo {
#[doc = "<Support display the video in a row."]
pub bSupportSplitScreen: bool,
#[doc = "<In the process of displaying the video in the row."]
pub bInSplitScreenMode: bool,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagSplitScreenInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagSplitScreenInfo>(),
2usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagSplitScreenInfo))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagSplitScreenInfo>(),
1usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagSplitScreenInfo))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagSplitScreenInfo>())).bSupportSplitScreen as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagSplitScreenInfo),
"::",
stringify!(bSupportSplitScreen)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagSplitScreenInfo>())).bInSplitScreenMode as *const _
as usize
},
1usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagSplitScreenInfo),
"::",
stringify!(bInSplitScreenMode)
)
);
}
#[doc = " \\struct tagSplitScreenInfo"]
#[doc = "\\brief Split screen mode information."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_SplitScreenInfo = ZOOMSDK_tagSplitScreenInfo;
#[doc = "<For initialization."]
pub const ZOOMSDK_AudioCallbackActionInfo_ACTION_NONE: ZOOMSDK_AudioCallbackActionInfo = 0;
#[doc = "<Choose audio device because no audio device is connected yet."]
pub const ZOOMSDK_AudioCallbackActionInfo_ACTION_CHOOSE_AUDIO_DEVICE_NOAUDIODEVICECONNECTTED:
ZOOMSDK_AudioCallbackActionInfo = 1;
#[doc = "<Choose audio device because there is an error in the connected computer audio device."]
pub const ZOOMSDK_AudioCallbackActionInfo_ACTION_CHOOSE_AUDIO_DEVICE_COMPUTERAUDIODEVICEERROR:
ZOOMSDK_AudioCallbackActionInfo = 2;
#[doc = "<Choose audio device because there is an error in the connected phone call device."]
pub const ZOOMSDK_AudioCallbackActionInfo_ACTION_CHOOSE_AUDIO_DEVICE_PHONECALLDEVICEERROR:
ZOOMSDK_AudioCallbackActionInfo = 3;
#[doc = "<Need to join voip."]
pub const ZOOMSDK_AudioCallbackActionInfo_ACTION_NEED_JOIN_VOIP: ZOOMSDK_AudioCallbackActionInfo =
4;
#[doc = "<Mute or unmute some user's audio according to the \"AudioBtnClickedCallbackInfo::userid_MuteUnmute\""]
pub const ZOOMSDK_AudioCallbackActionInfo_ACTION_MUTE_UNMUTE_AUDIO:
ZOOMSDK_AudioCallbackActionInfo = 5;
#[doc = "<Show audio setting window."]
pub const ZOOMSDK_AudioCallbackActionInfo_ACTION_SHOW_AUDIO_SETTING_WINDOW:
ZOOMSDK_AudioCallbackActionInfo = 6;
#[doc = " \\enum AudioCallbackActionInfo"]
#[doc = "\\brief The action user suggested to take after getting the callback event \"IMeetingUIControllerEvent::onAudioBtnClicked()\""]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_AudioCallbackActionInfo = ::std::os::raw::c_int;
#[doc = " \\struct tagAudioBtnClickedCallbackInfo"]
#[doc = "\\brief The suggested action information for user to handle after getting the callback event \"IMeetingUIControllerEvent::onAudioBtnClicked()\""]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagAudioBtnClickedCallbackInfo {
#[doc = "<The id of the user that should be muted or unmuted. When no mute or unmute operation is required, the value is 0"]
pub userid_MuteUnmute: ::std::os::raw::c_uint,
#[doc = "<The suggested action for user to take."]
pub audio_clicked_action: ZOOMSDK_AudioCallbackActionInfo,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagAudioBtnClickedCallbackInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagAudioBtnClickedCallbackInfo>(),
8usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_tagAudioBtnClickedCallbackInfo)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagAudioBtnClickedCallbackInfo>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagAudioBtnClickedCallbackInfo)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagAudioBtnClickedCallbackInfo>())).userid_MuteUnmute
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagAudioBtnClickedCallbackInfo),
"::",
stringify!(userid_MuteUnmute)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagAudioBtnClickedCallbackInfo>())).audio_clicked_action
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagAudioBtnClickedCallbackInfo),
"::",
stringify!(audio_clicked_action)
)
);
}
#[doc = " \\struct tagAudioBtnClickedCallbackInfo"]
#[doc = "\\brief The suggested action information for user to handle after getting the callback event \"IMeetingUIControllerEvent::onAudioBtnClicked()\""]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_AudioBtnClickedCallbackInfo = ZOOMSDK_tagAudioBtnClickedCallbackInfo;
#[repr(C)]
pub struct ZOOMSDK_IMeetingUIControllerEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Callback Event of Meeting UI Controller."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingUIControllerEvent {
pub vtable_: *const ZOOMSDK_IMeetingUIControllerEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingUIControllerEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingUIControllerEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingUIControllerEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingUIControllerEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingUIControllerEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingUIController__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting UI Controller Interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingUIController {
pub vtable_: *const ZOOMSDK_IMeetingUIController__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingUIController() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingUIController>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingUIController))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingUIController>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMeetingUIController))
);
}
#[repr(C)]
pub struct ZOOMSDK_ICameraControllerEvent__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_ICameraControllerEvent {
pub vtable_: *const ZOOMSDK_ICameraControllerEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ICameraControllerEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ICameraControllerEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ICameraControllerEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ICameraControllerEvent>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_ICameraControllerEvent))
);
}
#[repr(C)]
pub struct ZOOMSDK_ICameraController__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_ICameraController {
pub vtable_: *const ZOOMSDK_ICameraController__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ICameraController() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ICameraController>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ICameraController))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ICameraController>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_ICameraController))
);
}
#[doc = "<Video is on."]
pub const ZOOMSDK_VideoStatus_Video_ON: ZOOMSDK_VideoStatus = 0;
#[doc = "<Video is off."]
pub const ZOOMSDK_VideoStatus_Video_OFF: ZOOMSDK_VideoStatus = 1;
#[doc = "<Video is muted by host."]
pub const ZOOMSDK_VideoStatus_Video_Mute_ByHost: ZOOMSDK_VideoStatus = 2;
#[doc = " \\enum VideoStatus"]
#[doc = "\\brief The video status of the user."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_VideoStatus = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IRequestStartVideoHandler__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Process after the user receives the requirement from the host to turn on the video."]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IRequestStartVideoHandler {
pub vtable_: *const ZOOMSDK_IRequestStartVideoHandler__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IRequestStartVideoHandler() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IRequestStartVideoHandler>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IRequestStartVideoHandler))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IRequestStartVideoHandler>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IRequestStartVideoHandler)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingVideoCtrlEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting video controller event callback"]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingVideoCtrlEvent {
pub vtable_: *const ZOOMSDK_IMeetingVideoCtrlEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingVideoCtrlEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingVideoCtrlEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingVideoCtrlEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingVideoCtrlEvent>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMeetingVideoCtrlEvent))
);
}
pub const ZOOMSDK_PinResult_PinResult_Success: ZOOMSDK_PinResult = 0;
pub const ZOOMSDK_PinResult_PinResult_Fail_NotEnoughUsers: ZOOMSDK_PinResult = 1;
#[doc = " user counts less than 2"]
pub const ZOOMSDK_PinResult_PinResult_Fail_ToMuchPinnedUsers: ZOOMSDK_PinResult = 2;
#[doc = " pinned user counts more than 9"]
pub const ZOOMSDK_PinResult_PinResult_Fail_UserCannotBePinned: ZOOMSDK_PinResult = 3;
#[doc = " user in view only mode or silent mode or active"]
pub const ZOOMSDK_PinResult_PinResult_Fail_VideoModeDoNotSupport: ZOOMSDK_PinResult = 4;
#[doc = " other reasons"]
pub const ZOOMSDK_PinResult_PinResult_Fail_NoPrivilegeToPin: ZOOMSDK_PinResult = 5;
#[doc = " current user has no privilege to pin"]
pub const ZOOMSDK_PinResult_PinResult_Fail_MeetingDoNotSupport: ZOOMSDK_PinResult = 6;
#[doc = " webinar and in view only meeting"]
pub const ZOOMSDK_PinResult_PinResult_Unknown: ZOOMSDK_PinResult = 100;
pub type ZOOMSDK_PinResult = ::std::os::raw::c_int;
pub const ZOOMSDK_SpotlightResult_SpotResult_Success: ZOOMSDK_SpotlightResult = 0;
pub const ZOOMSDK_SpotlightResult_SpotResult_Fail_NotEnoughUsers: ZOOMSDK_SpotlightResult = 1;
#[doc = " user counts less than 2"]
pub const ZOOMSDK_SpotlightResult_SpotResult_Fail_ToMuchSpotlightedUsers: ZOOMSDK_SpotlightResult =
2;
#[doc = " spotlighted user counts is more than 9"]
pub const ZOOMSDK_SpotlightResult_SpotResult_Fail_UserCannotBeSpotlighted: ZOOMSDK_SpotlightResult =
3;
#[doc = " user in view only mode or silent mode or active"]
pub const ZOOMSDK_SpotlightResult_SpotResult_Fail_UserWithoutVideo: ZOOMSDK_SpotlightResult = 4;
#[doc = " user doesn't turn on video"]
pub const ZOOMSDK_SpotlightResult_SpotResult_Fail_NoPrivilegeToSpotlight: ZOOMSDK_SpotlightResult =
5;
#[doc = " current user has no privilege to spotlight"]
pub const ZOOMSDK_SpotlightResult_SpotResult_Fail_UserNotSpotlighted: ZOOMSDK_SpotlightResult = 6;
#[doc = "user is not spotlighted"]
pub const ZOOMSDK_SpotlightResult_SpotResult_Unknown: ZOOMSDK_SpotlightResult = 100;
pub type ZOOMSDK_SpotlightResult = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IMeetingVideoController__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting video controller interface"]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingVideoController {
pub vtable_: *const ZOOMSDK_IMeetingVideoController__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingVideoController() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingVideoController>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingVideoController))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingVideoController>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMeetingVideoController))
);
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingWaitingRoomEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting Waiting Room Callback Event."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingWaitingRoomEvent {
pub vtable_: *const ZOOMSDK_IMeetingWaitingRoomEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingWaitingRoomEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingWaitingRoomEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMeetingWaitingRoomEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingWaitingRoomEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingWaitingRoomEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IMeetingWaitingRoomController__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting waiting room controller interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IMeetingWaitingRoomController {
pub vtable_: *const ZOOMSDK_IMeetingWaitingRoomController__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMeetingWaitingRoomController() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMeetingWaitingRoomController>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IMeetingWaitingRoomController)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMeetingWaitingRoomController>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IMeetingWaitingRoomController)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IClosedCaptionControllerEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Closed Caption controller callback event."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IClosedCaptionControllerEvent {
pub vtable_: *const ZOOMSDK_IClosedCaptionControllerEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IClosedCaptionControllerEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IClosedCaptionControllerEvent>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IClosedCaptionControllerEvent)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IClosedCaptionControllerEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IClosedCaptionControllerEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IClosedCaptionController__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Closed caption controller interface."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IClosedCaptionController {
pub vtable_: *const ZOOMSDK_IClosedCaptionController__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IClosedCaptionController() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IClosedCaptionController>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IClosedCaptionController))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IClosedCaptionController>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IClosedCaptionController)
)
);
}
#[doc = "<For initialization."]
pub const ZOOMSDK_RECORDING_LAYOUT_MODE_RECORDING_LAYOUT_MODE_NONE: ZOOMSDK_RECORDING_LAYOUT_MODE =
0;
#[doc = "<Record only the active video for the moment."]
pub const ZOOMSDK_RECORDING_LAYOUT_MODE_RECORDING_LAYOUT_MODE_ACTIVE_VIDEO_ONLY:
ZOOMSDK_RECORDING_LAYOUT_MODE = 1;
#[doc = "<Record the video wall."]
pub const ZOOMSDK_RECORDING_LAYOUT_MODE_RECORDING_LAYOUT_MODE_VIDEO_WALL:
ZOOMSDK_RECORDING_LAYOUT_MODE = 2;
#[doc = "<Record the shared content, video or other specified videos."]
pub const ZOOMSDK_RECORDING_LAYOUT_MODE_RECORDING_LAYOUT_MODE_SHARE_AND_VIDEO:
ZOOMSDK_RECORDING_LAYOUT_MODE = 4;
#[doc = "<Record only the audio."]
pub const ZOOMSDK_RECORDING_LAYOUT_MODE_RECORDING_LAYOUT_MODE_ONLY_AUDIO:
ZOOMSDK_RECORDING_LAYOUT_MODE = 8;
#[doc = "<Record only the shared content."]
pub const ZOOMSDK_RECORDING_LAYOUT_MODE_RECORDING_LAYOUT_MODE_ONLY_SHARE:
ZOOMSDK_RECORDING_LAYOUT_MODE = 16;
#[doc = " \\enum RECORDING_LAYOUT_MODE"]
#[doc = "\\brief Layout mode of local recording."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_RECORDING_LAYOUT_MODE = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_ICustomizedLocalRecordingLayoutHelper__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_ICustomizedLocalRecordingLayoutHelper {
pub vtable_: *const ZOOMSDK_ICustomizedLocalRecordingLayoutHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ICustomizedLocalRecordingLayoutHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ICustomizedLocalRecordingLayoutHelper>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_ICustomizedLocalRecordingLayoutHelper)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ICustomizedLocalRecordingLayoutHelper>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ICustomizedLocalRecordingLayoutHelper)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_ICameraInfo__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Camera device information interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_ICameraInfo {
pub vtable_: *const ZOOMSDK_ICameraInfo__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ICameraInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ICameraInfo>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ICameraInfo))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ICameraInfo>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_ICameraInfo))
);
}
#[repr(C)]
pub struct ZOOMSDK_IMicInfo__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Microphone device information interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IMicInfo {
pub vtable_: *const ZOOMSDK_IMicInfo__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IMicInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IMicInfo>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IMicInfo))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IMicInfo>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IMicInfo))
);
}
#[repr(C)]
pub struct ZOOMSDK_ISpeakerInfo__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Audio speaker device information interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_ISpeakerInfo {
pub vtable_: *const ZOOMSDK_ISpeakerInfo__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ISpeakerInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ISpeakerInfo>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ISpeakerInfo))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ISpeakerInfo>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_ISpeakerInfo))
);
}
#[doc = "<The feature is not enabled."]
pub const ZOOMSDK_LimitFPSValue_limitfps_Not_Enable: ZOOMSDK_LimitFPSValue = 0;
#[doc = "<1 frame per second."]
pub const ZOOMSDK_LimitFPSValue_limitfps_1_frame: ZOOMSDK_LimitFPSValue = 1;
#[doc = "<2 frames per second."]
pub const ZOOMSDK_LimitFPSValue_limitfps_2_frame: ZOOMSDK_LimitFPSValue = 2;
#[doc = "<4 frames per second."]
pub const ZOOMSDK_LimitFPSValue_limitfps_4_frame: ZOOMSDK_LimitFPSValue = 3;
#[doc = "<6 frames per second."]
pub const ZOOMSDK_LimitFPSValue_limitfps_6_frame: ZOOMSDK_LimitFPSValue = 4;
#[doc = "<8 frames per second."]
pub const ZOOMSDK_LimitFPSValue_limitfps_8_frame: ZOOMSDK_LimitFPSValue = 5;
#[doc = "<10 frames per second."]
pub const ZOOMSDK_LimitFPSValue_limitfps_10_frame: ZOOMSDK_LimitFPSValue = 6;
#[doc = "<15 frames per second."]
pub const ZOOMSDK_LimitFPSValue_limitfps_15_frame: ZOOMSDK_LimitFPSValue = 7;
#[doc = " \\enum LimitFPSValue"]
#[doc = "\\brief Specify the values of available limit fps."]
#[doc = "Here are more detailed enum descriptions."]
pub type ZOOMSDK_LimitFPSValue = ::std::os::raw::c_int;
#[doc = "<General setting page."]
pub const ZOOMSDK_SettingTabPage_SettingTabPage_General: ZOOMSDK_SettingTabPage = 0;
#[doc = "<Audio setting page."]
pub const ZOOMSDK_SettingTabPage_SettingTabPage_Audio: ZOOMSDK_SettingTabPage = 1;
#[doc = "<Video setting page."]
pub const ZOOMSDK_SettingTabPage_SettingTabPage_Video: ZOOMSDK_SettingTabPage = 2;
#[doc = " \\enum SettingTabPage"]
#[doc = "\\brief Specify the shown tab page at the top of the displayed setting dialog."]
#[doc = "Here are more detailed enum descriptions."]
pub type ZOOMSDK_SettingTabPage = ::std::os::raw::c_int;
pub const ZOOMSDK_tagReactionSkinToneType_ReactionSkinTone_None: ZOOMSDK_tagReactionSkinToneType =
0;
pub const ZOOMSDK_tagReactionSkinToneType_ReactionSkinTone_Default:
ZOOMSDK_tagReactionSkinToneType = 1;
pub const ZOOMSDK_tagReactionSkinToneType_ReactionSkinTone_Light: ZOOMSDK_tagReactionSkinToneType =
2;
pub const ZOOMSDK_tagReactionSkinToneType_ReactionSkinTone_MediumLight:
ZOOMSDK_tagReactionSkinToneType = 3;
pub const ZOOMSDK_tagReactionSkinToneType_ReactionSkinTone_Medium: ZOOMSDK_tagReactionSkinToneType =
4;
pub const ZOOMSDK_tagReactionSkinToneType_ReactionSkinTone_MediumDark:
ZOOMSDK_tagReactionSkinToneType = 5;
pub const ZOOMSDK_tagReactionSkinToneType_ReactionSkinTone_Dark: ZOOMSDK_tagReactionSkinToneType =
6;
#[doc = " \\enum ReactionSkinToneType"]
#[doc = "\\brief Specify the skin tone type."]
#[doc = "Here are more detailed enum descriptions."]
pub type ZOOMSDK_tagReactionSkinToneType = ::std::os::raw::c_int;
#[doc = " \\enum ReactionSkinToneType"]
#[doc = "\\brief Specify the skin tone type."]
#[doc = "Here are more detailed enum descriptions."]
pub use self::ZOOMSDK_tagReactionSkinToneType as ZOOMSDK_ReactionSkinToneType;
pub const ZOOMSDK_WindowSizeType_WindowSize_None: ZOOMSDK_WindowSizeType = 0;
pub const ZOOMSDK_WindowSizeType_WindowSize_FullScreen: ZOOMSDK_WindowSizeType = 1;
pub const ZOOMSDK_WindowSizeType_WindowSize_Maximize: ZOOMSDK_WindowSizeType = 2;
pub const ZOOMSDK_WindowSizeType_WindowSize_CurrentSize: ZOOMSDK_WindowSizeType = 3;
pub type ZOOMSDK_WindowSizeType = ::std::os::raw::c_int;
pub const ZOOMSDK_ScreenCaptureMode_CaptureMode_auto: ZOOMSDK_ScreenCaptureMode = 0;
pub const ZOOMSDK_ScreenCaptureMode_CaptureMode_legacy: ZOOMSDK_ScreenCaptureMode = 1;
pub const ZOOMSDK_ScreenCaptureMode_CaptureMode_gpu_copy_filter: ZOOMSDK_ScreenCaptureMode = 2;
pub const ZOOMSDK_ScreenCaptureMode_CaptureMode_ada_copy_filter: ZOOMSDK_ScreenCaptureMode = 3;
pub const ZOOMSDK_ScreenCaptureMode_CaptureMode_ada_copy_without_filter: ZOOMSDK_ScreenCaptureMode =
4;
pub const ZOOMSDK_ScreenCaptureMode_CaptureMode_end: ZOOMSDK_ScreenCaptureMode = 5;
pub type ZOOMSDK_ScreenCaptureMode = ::std::os::raw::c_int;
#[doc = " \\struct tagShowChatDlgParam"]
#[doc = "\\brief Display the parameter of the meeting chat dialog."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagShowSettingDlgParam {
#[doc = "<Parent window handle."]
pub hParent: HWND,
#[doc = "<The Y-axis value of the top-left corner of the dialog uses the coordinate system of the monitor."]
pub top: ::std::os::raw::c_int,
#[doc = "<The X-axis value of the top-left corner of the dialog uses the coordinate system of the monitor."]
pub left: ::std::os::raw::c_int,
#[doc = "<Window handle of the dialog setting."]
pub hSettingWnd: HWND,
#[doc = "<Enable to display or nor."]
pub bShow: bool,
#[doc = "<Enable to display the dialog at the center of the screen and discard the value of top and left"]
pub bCenter: bool,
#[doc = "<The tab page shown at the top of the displayed setting dialog."]
pub eTabPageType: ZOOMSDK_SettingTabPage,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagShowSettingDlgParam() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagShowSettingDlgParam>(),
24usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagShowSettingDlgParam))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagShowSettingDlgParam>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagShowSettingDlgParam))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagShowSettingDlgParam>())).hParent as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagShowSettingDlgParam),
"::",
stringify!(hParent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagShowSettingDlgParam>())).top as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagShowSettingDlgParam),
"::",
stringify!(top)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagShowSettingDlgParam>())).left as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagShowSettingDlgParam),
"::",
stringify!(left)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagShowSettingDlgParam>())).hSettingWnd as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagShowSettingDlgParam),
"::",
stringify!(hSettingWnd)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagShowSettingDlgParam>())).bShow as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagShowSettingDlgParam),
"::",
stringify!(bShow)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagShowSettingDlgParam>())).bCenter as *const _ as usize
},
17usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagShowSettingDlgParam),
"::",
stringify!(bCenter)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagShowSettingDlgParam>())).eTabPageType as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagShowSettingDlgParam),
"::",
stringify!(eTabPageType)
)
);
}
#[doc = " \\struct tagShowChatDlgParam"]
#[doc = "\\brief Display the parameter of the meeting chat dialog."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_ShowSettingDlgParam = ZOOMSDK_tagShowSettingDlgParam;
#[doc = " \\struct tagSettingDlgShowTabPageOption"]
#[doc = "\\brief Define the strategy to show the tab pages in the setting dialog."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagSettingDlgShowTabPageOption {
#[doc = "<True indicates to show general page"]
pub bShowGeneral: bool,
#[doc = "<True indicates to show video page"]
pub bShowVideo: bool,
#[doc = "<True indicates to show audio page"]
pub bShowAudio: bool,
#[doc = "<True indicates to show share screen page"]
pub bShowShareScreen: bool,
#[doc = "<True indicates to show virtual background page"]
pub bShowVirtualBackGround: bool,
#[doc = "<True indicates to show recording page"]
pub bSHowRecording: bool,
#[doc = "<True indicates to show advance feature page"]
pub bShowAdvancedFeature: bool,
#[doc = "<True indicates to show staticstics page"]
pub bShowStatistics: bool,
#[doc = "<True indicates to show feed back page"]
pub bShowFeedback: bool,
#[doc = "<True indicates to show keyboard shortcuts page"]
pub bShowKeyboardShortcuts: bool,
#[doc = "<True indicates to show accessibility page"]
pub bShowAccessibility: bool,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagSettingDlgShowTabPageOption() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagSettingDlgShowTabPageOption>(),
11usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_tagSettingDlgShowTabPageOption)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagSettingDlgShowTabPageOption>(),
1usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagSettingDlgShowTabPageOption)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagSettingDlgShowTabPageOption>())).bShowGeneral
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagSettingDlgShowTabPageOption),
"::",
stringify!(bShowGeneral)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagSettingDlgShowTabPageOption>())).bShowVideo
as *const _ as usize
},
1usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagSettingDlgShowTabPageOption),
"::",
stringify!(bShowVideo)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagSettingDlgShowTabPageOption>())).bShowAudio
as *const _ as usize
},
2usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagSettingDlgShowTabPageOption),
"::",
stringify!(bShowAudio)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagSettingDlgShowTabPageOption>())).bShowShareScreen
as *const _ as usize
},
3usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagSettingDlgShowTabPageOption),
"::",
stringify!(bShowShareScreen)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagSettingDlgShowTabPageOption>()))
.bShowVirtualBackGround as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagSettingDlgShowTabPageOption),
"::",
stringify!(bShowVirtualBackGround)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagSettingDlgShowTabPageOption>())).bSHowRecording
as *const _ as usize
},
5usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagSettingDlgShowTabPageOption),
"::",
stringify!(bSHowRecording)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagSettingDlgShowTabPageOption>())).bShowAdvancedFeature
as *const _ as usize
},
6usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagSettingDlgShowTabPageOption),
"::",
stringify!(bShowAdvancedFeature)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagSettingDlgShowTabPageOption>())).bShowStatistics
as *const _ as usize
},
7usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagSettingDlgShowTabPageOption),
"::",
stringify!(bShowStatistics)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagSettingDlgShowTabPageOption>())).bShowFeedback
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagSettingDlgShowTabPageOption),
"::",
stringify!(bShowFeedback)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagSettingDlgShowTabPageOption>()))
.bShowKeyboardShortcuts as *const _ as usize
},
9usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagSettingDlgShowTabPageOption),
"::",
stringify!(bShowKeyboardShortcuts)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagSettingDlgShowTabPageOption>())).bShowAccessibility
as *const _ as usize
},
10usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagSettingDlgShowTabPageOption),
"::",
stringify!(bShowAccessibility)
)
);
}
#[doc = " \\struct tagSettingDlgShowTabPageOption"]
#[doc = "\\brief Define the strategy to show the tab pages in the setting dialog."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_SettingDlgShowTabPageOption = ZOOMSDK_tagSettingDlgShowTabPageOption;
#[doc = "<Test the mic via TestMicStartRecording. It is useless to call TestMicStopTesting/TestMicPlayRecording in this status."]
pub const ZOOMSDK_SDK_TESTMIC_STATUS_enuCanTest: ZOOMSDK_SDK_TESTMIC_STATUS = 0;
#[doc = "<Test the mic via TestMicStopTesting/TestMicPlayRecording. It is useless to call TestMicStartRecording in this status."]
pub const ZOOMSDK_SDK_TESTMIC_STATUS_enuMicRecording: ZOOMSDK_SDK_TESTMIC_STATUS = 1;
#[doc = "<Test the mic via TestMicStopTesting/TestMicPlayRecording. It is useless call TestMicStartRecording in this status."]
pub const ZOOMSDK_SDK_TESTMIC_STATUS_enuCanPlay: ZOOMSDK_SDK_TESTMIC_STATUS = 2;
#[doc = " \\enum SDK_TESTMIC_STATUS"]
#[doc = "\\brief Notify the status of the mic when testing."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_SDK_TESTMIC_STATUS = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_ITestAudioDeviceHelperEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Audio device testing callback events."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_ITestAudioDeviceHelperEvent {
pub vtable_: *const ZOOMSDK_ITestAudioDeviceHelperEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ITestAudioDeviceHelperEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ITestAudioDeviceHelperEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ITestAudioDeviceHelperEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ITestAudioDeviceHelperEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ITestAudioDeviceHelperEvent)
)
);
}
pub const ZOOMSDK_Suppress_Background_Noise_Level_Suppress_BGNoise_Level_None:
ZOOMSDK_Suppress_Background_Noise_Level = 0;
pub const ZOOMSDK_Suppress_Background_Noise_Level_Suppress_BGNoise_Level_Auto:
ZOOMSDK_Suppress_Background_Noise_Level = 1;
pub const ZOOMSDK_Suppress_Background_Noise_Level_Suppress_BGNoise_Level_Low:
ZOOMSDK_Suppress_Background_Noise_Level = 2;
pub const ZOOMSDK_Suppress_Background_Noise_Level_Suppress_BGNoise_Level_Medium:
ZOOMSDK_Suppress_Background_Noise_Level = 3;
pub const ZOOMSDK_Suppress_Background_Noise_Level_Suppress_BGNoise_Level_High:
ZOOMSDK_Suppress_Background_Noise_Level = 4;
pub type ZOOMSDK_Suppress_Background_Noise_Level = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_ITestAudioDeviceHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Audio device test interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_ITestAudioDeviceHelper {
pub vtable_: *const ZOOMSDK_ITestAudioDeviceHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ITestAudioDeviceHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ITestAudioDeviceHelper>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ITestAudioDeviceHelper))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ITestAudioDeviceHelper>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_ITestAudioDeviceHelper))
);
}
#[repr(C)]
pub struct ZOOMSDK_IGeneralSettingContext__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief General setting interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IGeneralSettingContext {
pub vtable_: *const ZOOMSDK_IGeneralSettingContext__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IGeneralSettingContext() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IGeneralSettingContext>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IGeneralSettingContext))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IGeneralSettingContext>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IGeneralSettingContext))
);
}
#[doc = "< No rotation."]
pub const ZOOMSDK_PREVIEW_VIDEO_ROTATION_ACTION_PREVIEW_VIDEO_ROTATION_ACTION_0:
ZOOMSDK_PREVIEW_VIDEO_ROTATION_ACTION = 0;
#[doc = "<Rotate to the left."]
pub const ZOOMSDK_PREVIEW_VIDEO_ROTATION_ACTION_PREVIEW_VIDEO_ROTATION_ACTION_CLOCK90:
ZOOMSDK_PREVIEW_VIDEO_ROTATION_ACTION = 1;
#[doc = "<Rotate 180 degrees."]
pub const ZOOMSDK_PREVIEW_VIDEO_ROTATION_ACTION_PREVIEW_VIDEO_ROTATION_ACTION_CLOCK180:
ZOOMSDK_PREVIEW_VIDEO_ROTATION_ACTION = 2;
#[doc = "<Rotate to the right."]
pub const ZOOMSDK_PREVIEW_VIDEO_ROTATION_ACTION_PREVIEW_VIDEO_ROTATION_ACTION_ANTI_CLOCK90:
ZOOMSDK_PREVIEW_VIDEO_ROTATION_ACTION = 3;
#[doc = " \\enum PREVIEW_VIDEO_ROTATION_ACTION"]
#[doc = "\\brief Notify to rotate the video preview based on the current view."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_PREVIEW_VIDEO_ROTATION_ACTION = ::std::os::raw::c_int;
#[doc = " \\enum PREVIEW_VIDEO_ROTATION_ACTION"]
#[doc = "\\brief Notify to rotate the video preview based on the current view."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_PPREVIEW_VIDEO_ROTATION_ACTION = *mut ZOOMSDK_PREVIEW_VIDEO_ROTATION_ACTION;
pub const ZOOMSDK_VIDEO_HARDWARE_ENCODE_TYPE_VIDEO_HARDWARE_ENCODE_RECEIVING:
ZOOMSDK_VIDEO_HARDWARE_ENCODE_TYPE = 0;
pub const ZOOMSDK_VIDEO_HARDWARE_ENCODE_TYPE_VIDEO_HARDWARE_ENCODE_SENDING:
ZOOMSDK_VIDEO_HARDWARE_ENCODE_TYPE = 1;
pub const ZOOMSDK_VIDEO_HARDWARE_ENCODE_TYPE_VIDEO_HARDWARE_ENCODE_PROCESSING:
ZOOMSDK_VIDEO_HARDWARE_ENCODE_TYPE = 2;
pub type ZOOMSDK_VIDEO_HARDWARE_ENCODE_TYPE = ::std::os::raw::c_int;
pub const ZOOMSDK_VIDEO_LIGHT_ADAPTION_TYPE_Light_Adaption_None: ZOOMSDK_VIDEO_LIGHT_ADAPTION_TYPE =
0;
pub const ZOOMSDK_VIDEO_LIGHT_ADAPTION_TYPE_Light_Adaption_Auto: ZOOMSDK_VIDEO_LIGHT_ADAPTION_TYPE =
1;
pub const ZOOMSDK_VIDEO_LIGHT_ADAPTION_TYPE_Light_Adaption_Manual:
ZOOMSDK_VIDEO_LIGHT_ADAPTION_TYPE = 2;
pub type ZOOMSDK_VIDEO_LIGHT_ADAPTION_TYPE = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_ITestVideoDeviceHelperEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Video Device test callback event."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_ITestVideoDeviceHelperEvent {
pub vtable_: *const ZOOMSDK_ITestVideoDeviceHelperEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ITestVideoDeviceHelperEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ITestVideoDeviceHelperEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ITestVideoDeviceHelperEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ITestVideoDeviceHelperEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ITestVideoDeviceHelperEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_ITestVideoDeviceHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Video device test interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_ITestVideoDeviceHelper {
pub vtable_: *const ZOOMSDK_ITestVideoDeviceHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ITestVideoDeviceHelper() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ITestVideoDeviceHelper>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ITestVideoDeviceHelper))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ITestVideoDeviceHelper>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_ITestVideoDeviceHelper))
);
}
#[repr(C)]
pub struct ZOOMSDK_IVideoSettingContextEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Video setting context callback event."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IVideoSettingContextEvent {
pub vtable_: *const ZOOMSDK_IVideoSettingContextEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IVideoSettingContextEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IVideoSettingContextEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IVideoSettingContextEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IVideoSettingContextEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IVideoSettingContextEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IVideoSettingContext__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Video setting interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IVideoSettingContext {
pub vtable_: *const ZOOMSDK_IVideoSettingContext__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IVideoSettingContext() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IVideoSettingContext>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IVideoSettingContext))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IVideoSettingContext>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IVideoSettingContext))
);
}
#[repr(C)]
pub struct ZOOMSDK_IAudioSettingContextEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Audio setting context callback event."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IAudioSettingContextEvent {
pub vtable_: *const ZOOMSDK_IAudioSettingContextEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IAudioSettingContextEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IAudioSettingContextEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IAudioSettingContextEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IAudioSettingContextEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IAudioSettingContextEvent)
)
);
}
pub const ZOOMSDK_SDK_AUDIO_DEVICE_RAW_MODE_TYPE_SDK_AUDIO_DEVICE_RAW_MODE_DEFAULT:
ZOOMSDK_SDK_AUDIO_DEVICE_RAW_MODE_TYPE = 0;
pub const ZOOMSDK_SDK_AUDIO_DEVICE_RAW_MODE_TYPE_SDK_AUDIO_DEVICE_RAW_MODE_ON:
ZOOMSDK_SDK_AUDIO_DEVICE_RAW_MODE_TYPE = 1;
pub const ZOOMSDK_SDK_AUDIO_DEVICE_RAW_MODE_TYPE_SDK_AUDIO_DEVICE_RAW_MODE_OFF:
ZOOMSDK_SDK_AUDIO_DEVICE_RAW_MODE_TYPE = 2;
pub type ZOOMSDK_SDK_AUDIO_DEVICE_RAW_MODE_TYPE = ::std::os::raw::c_int;
pub const ZOOMSDK_SDK_ECHO_CANCELLATION_LEVEL_SDK_ECHO_CANCELLATION_DEFAULT:
ZOOMSDK_SDK_ECHO_CANCELLATION_LEVEL = 0;
pub const ZOOMSDK_SDK_ECHO_CANCELLATION_LEVEL_SDK_ECHO_CANCELLATION_AGGRESSIVE:
ZOOMSDK_SDK_ECHO_CANCELLATION_LEVEL = 1;
pub type ZOOMSDK_SDK_ECHO_CANCELLATION_LEVEL = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IAudioSettingContext__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Audio setting interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IAudioSettingContext {
pub vtable_: *const ZOOMSDK_IAudioSettingContext__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IAudioSettingContext() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IAudioSettingContext>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IAudioSettingContext))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IAudioSettingContext>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IAudioSettingContext))
);
}
#[repr(C)]
pub struct ZOOMSDK_IRecordingSettingContextEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Recording setting context callback event."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IRecordingSettingContextEvent {
pub vtable_: *const ZOOMSDK_IRecordingSettingContextEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IRecordingSettingContextEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IRecordingSettingContextEvent>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IRecordingSettingContextEvent)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IRecordingSettingContextEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IRecordingSettingContextEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IRecordingSettingContext__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Recording setting interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IRecordingSettingContext {
pub vtable_: *const ZOOMSDK_IRecordingSettingContext__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IRecordingSettingContext() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IRecordingSettingContext>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IRecordingSettingContext))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IRecordingSettingContext>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IRecordingSettingContext)
)
);
}
#[doc = "<Wired LAN"]
pub const ZOOMSDK_SettingsNetWorkType_SETTINGS_NETWORK_WIRED: ZOOMSDK_SettingsNetWorkType = 0;
#[doc = "<WIFI"]
pub const ZOOMSDK_SettingsNetWorkType_SETTINGS_NETWORK_WIFI: ZOOMSDK_SettingsNetWorkType = 1;
#[doc = "<PPP"]
pub const ZOOMSDK_SettingsNetWorkType_SETTINGS_NETWORK_PPP: ZOOMSDK_SettingsNetWorkType = 2;
#[doc = "<3G"]
pub const ZOOMSDK_SettingsNetWorkType_SETTINGS_NETWORK_3G: ZOOMSDK_SettingsNetWorkType = 3;
#[doc = "<Others"]
pub const ZOOMSDK_SettingsNetWorkType_SETTINGS_NETWORK_OTHERS: ZOOMSDK_SettingsNetWorkType = 4;
#[doc = "<Unknown network."]
pub const ZOOMSDK_SettingsNetWorkType_SETTINGS_NETWORK_UNKNOWN: ZOOMSDK_SettingsNetWorkType = -1;
#[doc = " \\enum SettingsNetWorkType"]
#[doc = "\\brief Notify network type."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_SettingsNetWorkType = ::std::os::raw::c_int;
#[doc = "<Cloud connection."]
pub const ZOOMSDK_SettingConnectionType_SETTINGS_CONNECTION_TYPE_CLOUD:
ZOOMSDK_SettingConnectionType = 0;
#[doc = "<Direct connection."]
pub const ZOOMSDK_SettingConnectionType_SETTINGS_CONNECTION_TYPE_DIRECT:
ZOOMSDK_SettingConnectionType = 1;
#[doc = "<Unknown connection."]
pub const ZOOMSDK_SettingConnectionType_SETTINGS_CONNECTION_TYPE_UNKNOWN:
ZOOMSDK_SettingConnectionType = -1;
#[doc = " \\enum SettingConnectionType"]
#[doc = "\\brief Notify connection type."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_SettingConnectionType = ::std::os::raw::c_int;
#[doc = " \\struct tagOverallStatisticInfo"]
#[doc = "\\brief Notify overall statistic information."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagOverallStatisticInfo {
#[doc = "<Network type."]
pub net_work_type_: ZOOMSDK_SettingsNetWorkType,
#[doc = "<Connection type"]
pub connection_type_: ZOOMSDK_SettingConnectionType,
#[doc = "<Proxy address."]
pub proxy_addr_: *const u16,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagOverallStatisticInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagOverallStatisticInfo>(),
12usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagOverallStatisticInfo))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagOverallStatisticInfo>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_tagOverallStatisticInfo))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagOverallStatisticInfo>())).net_work_type_ as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagOverallStatisticInfo),
"::",
stringify!(net_work_type_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagOverallStatisticInfo>())).connection_type_ as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagOverallStatisticInfo),
"::",
stringify!(connection_type_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagOverallStatisticInfo>())).proxy_addr_ as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagOverallStatisticInfo),
"::",
stringify!(proxy_addr_)
)
);
}
#[doc = " \\struct tagOverallStatisticInfo"]
#[doc = "\\brief Notify overall statistic information."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_OverallStatisticInfo = ZOOMSDK_tagOverallStatisticInfo;
#[doc = " \\struct tagAudioSessionStatisticInfo"]
#[doc = "\\brief Notify the audio status information."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagAudioSessionStatisticInfo {
#[doc = "<Sending frequency, unit: KHz."]
pub frequency_send_: ::std::os::raw::c_int,
#[doc = "<Receiving frequency, unit: KHz."]
pub frequency_recv_: ::std::os::raw::c_int,
#[doc = "<Sending latency, unit: ms."]
pub latency_send_: ::std::os::raw::c_int,
#[doc = "<Receiving latency, unit: ms."]
pub latency_recv_: ::std::os::raw::c_int,
#[doc = "<Sending jitter, unit: ms."]
pub jitter_send_: ::std::os::raw::c_int,
#[doc = "<Receiving jitter, unit: ms."]
pub jitter_recv_: ::std::os::raw::c_int,
#[doc = "<Sending packet loss, unit: %."]
pub packetloss_send_: f32,
#[doc = "<Receiving packet loss, unit: %."]
pub packetloss_recv_: f32,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagAudioSessionStatisticInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagAudioSessionStatisticInfo>(),
32usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_tagAudioSessionStatisticInfo)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagAudioSessionStatisticInfo>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagAudioSessionStatisticInfo)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagAudioSessionStatisticInfo>())).frequency_send_
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagAudioSessionStatisticInfo),
"::",
stringify!(frequency_send_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagAudioSessionStatisticInfo>())).frequency_recv_
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagAudioSessionStatisticInfo),
"::",
stringify!(frequency_recv_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagAudioSessionStatisticInfo>())).latency_send_
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagAudioSessionStatisticInfo),
"::",
stringify!(latency_send_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagAudioSessionStatisticInfo>())).latency_recv_
as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagAudioSessionStatisticInfo),
"::",
stringify!(latency_recv_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagAudioSessionStatisticInfo>())).jitter_send_
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagAudioSessionStatisticInfo),
"::",
stringify!(jitter_send_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagAudioSessionStatisticInfo>())).jitter_recv_
as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagAudioSessionStatisticInfo),
"::",
stringify!(jitter_recv_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagAudioSessionStatisticInfo>())).packetloss_send_
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagAudioSessionStatisticInfo),
"::",
stringify!(packetloss_send_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagAudioSessionStatisticInfo>())).packetloss_recv_
as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagAudioSessionStatisticInfo),
"::",
stringify!(packetloss_recv_)
)
);
}
#[doc = " \\struct tagAudioSessionStatisticInfo"]
#[doc = "\\brief Notify the audio status information."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_AudioSessionStatisticInfo = ZOOMSDK_tagAudioSessionStatisticInfo;
#[doc = " \\struct tagASVSessionStatisticInfo"]
#[doc = "\\brief Notify video status information."]
#[doc = "Here are more detailed structural descriptions."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_tagASVSessionStatisticInfo {
#[doc = "<Sending latency, unit: ms."]
pub latency_send_: ::std::os::raw::c_int,
#[doc = "<Receiving latency, unit: ms."]
pub latency_recv_: ::std::os::raw::c_int,
#[doc = "<Sending jitter, unit: ms."]
pub jitter_send_: ::std::os::raw::c_int,
#[doc = "<Receiving jitter, unit: ms."]
pub jitter_recv_: ::std::os::raw::c_int,
#[doc = "<Sending max packet loss, unit: %."]
pub packetloss_send_max_: f32,
#[doc = "<Receiving max packet loss, unit: %."]
pub packetloss_recv_max_: f32,
#[doc = "<Sending average packet loss, unit: %."]
pub packetloss_send_avg_: f32,
#[doc = "<Receiving average packet loss, unit: %."]
pub packetloss_recv_avg_: f32,
#[doc = "<HIWORD->height, LOWORD->width."]
pub resolution_send_: ::std::os::raw::c_int,
#[doc = "<HIWORD->height, LOWORD->width."]
pub resolution_recv_: ::std::os::raw::c_int,
#[doc = "<Frame per second sending."]
pub fps_send_: ::std::os::raw::c_int,
#[doc = "<Frame per second receiving."]
pub fps_recv_: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_tagASVSessionStatisticInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_tagASVSessionStatisticInfo>(),
48usize,
concat!("Size of: ", stringify!(ZOOMSDK_tagASVSessionStatisticInfo))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_tagASVSessionStatisticInfo>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_tagASVSessionStatisticInfo)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagASVSessionStatisticInfo>())).latency_send_ as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagASVSessionStatisticInfo),
"::",
stringify!(latency_send_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagASVSessionStatisticInfo>())).latency_recv_ as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagASVSessionStatisticInfo),
"::",
stringify!(latency_recv_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagASVSessionStatisticInfo>())).jitter_send_ as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagASVSessionStatisticInfo),
"::",
stringify!(jitter_send_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagASVSessionStatisticInfo>())).jitter_recv_ as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagASVSessionStatisticInfo),
"::",
stringify!(jitter_recv_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagASVSessionStatisticInfo>())).packetloss_send_max_
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagASVSessionStatisticInfo),
"::",
stringify!(packetloss_send_max_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagASVSessionStatisticInfo>())).packetloss_recv_max_
as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagASVSessionStatisticInfo),
"::",
stringify!(packetloss_recv_max_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagASVSessionStatisticInfo>())).packetloss_send_avg_
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagASVSessionStatisticInfo),
"::",
stringify!(packetloss_send_avg_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagASVSessionStatisticInfo>())).packetloss_recv_avg_
as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagASVSessionStatisticInfo),
"::",
stringify!(packetloss_recv_avg_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagASVSessionStatisticInfo>())).resolution_send_
as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagASVSessionStatisticInfo),
"::",
stringify!(resolution_send_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagASVSessionStatisticInfo>())).resolution_recv_
as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagASVSessionStatisticInfo),
"::",
stringify!(resolution_recv_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagASVSessionStatisticInfo>())).fps_send_ as *const _
as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagASVSessionStatisticInfo),
"::",
stringify!(fps_send_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_tagASVSessionStatisticInfo>())).fps_recv_ as *const _
as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_tagASVSessionStatisticInfo),
"::",
stringify!(fps_recv_)
)
);
}
#[doc = " \\struct tagASVSessionStatisticInfo"]
#[doc = "\\brief Notify video status information."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_ASVSessionStatisticInfo = ZOOMSDK_tagASVSessionStatisticInfo;
#[repr(C)]
pub struct ZOOMSDK_IStatisticSettingContext__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Statistic setting interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IStatisticSettingContext {
pub vtable_: *const ZOOMSDK_IStatisticSettingContext__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IStatisticSettingContext() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IStatisticSettingContext>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IStatisticSettingContext))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IStatisticSettingContext>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IStatisticSettingContext)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IAccessibilitySettingContext__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Accessibility setting interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IAccessibilitySettingContext {
pub vtable_: *const ZOOMSDK_IAccessibilitySettingContext__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IAccessibilitySettingContext() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IAccessibilitySettingContext>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IAccessibilitySettingContext)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IAccessibilitySettingContext>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IAccessibilitySettingContext)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_ISettingUIStrategy__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Setting user strategy interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_ISettingUIStrategy {
pub vtable_: *const ZOOMSDK_ISettingUIStrategy__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ISettingUIStrategy() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ISettingUIStrategy>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ISettingUIStrategy))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ISettingUIStrategy>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_ISettingUIStrategy))
);
}
#[repr(C)]
pub struct ZOOMSDK_IVirtualBGImageInfo__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Virtual background image information interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IVirtualBGImageInfo {
pub vtable_: *const ZOOMSDK_IVirtualBGImageInfo__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IVirtualBGImageInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IVirtualBGImageInfo>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IVirtualBGImageInfo))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IVirtualBGImageInfo>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IVirtualBGImageInfo))
);
}
pub const ZOOMSDK_VBVideoError_VB_VideoError_None: ZOOMSDK_VBVideoError = 0;
pub const ZOOMSDK_VBVideoError_VB_VideoError_UnknowFormat: ZOOMSDK_VBVideoError = 1;
pub const ZOOMSDK_VBVideoError_VB_VideoError_ResolutionHigh1080P: ZOOMSDK_VBVideoError = 2;
pub const ZOOMSDK_VBVideoError_VB_VideoError_ResolutionHigh720P: ZOOMSDK_VBVideoError = 3;
pub const ZOOMSDK_VBVideoError_VB_VideoError_ResolutionLow: ZOOMSDK_VBVideoError = 4;
pub const ZOOMSDK_VBVideoError_VB_VideoError_PlayError: ZOOMSDK_VBVideoError = 5;
pub const ZOOMSDK_VBVideoError_VB_VideoError_OpenError: ZOOMSDK_VBVideoError = 6;
pub type ZOOMSDK_VBVideoError = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IVirtualBGSettingContextEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Virtual background context Callback Event."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IVirtualBGSettingContextEvent {
pub vtable_: *const ZOOMSDK_IVirtualBGSettingContextEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IVirtualBGSettingContextEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IVirtualBGSettingContextEvent>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IVirtualBGSettingContextEvent)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IVirtualBGSettingContextEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IVirtualBGSettingContextEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IVirtualBGSettingContext__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Virtual background setting interface."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IVirtualBGSettingContext {
pub vtable_: *const ZOOMSDK_IVirtualBGSettingContext__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IVirtualBGSettingContext() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IVirtualBGSettingContext>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IVirtualBGSettingContext))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IVirtualBGSettingContext>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IVirtualBGSettingContext)
)
);
}
pub const ZOOMSDK_ZoomSDKVideoEffectType_ZoomSDKVideoEffectType_None:
ZOOMSDK_ZoomSDKVideoEffectType = 0;
pub const ZOOMSDK_ZoomSDKVideoEffectType_ZoomSDKVideoEffectType_Filter:
ZOOMSDK_ZoomSDKVideoEffectType = 1;
pub const ZOOMSDK_ZoomSDKVideoEffectType_ZoomSDKVideoEffectType_Frame:
ZOOMSDK_ZoomSDKVideoEffectType = 2;
pub const ZOOMSDK_ZoomSDKVideoEffectType_ZoomSDKVideoEffectType_Sticker:
ZOOMSDK_ZoomSDKVideoEffectType = 4;
#[doc = ""]
pub type ZOOMSDK_ZoomSDKVideoEffectType = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IVideoFilterImageInfo__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Video filter image information interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IVideoFilterImageInfo {
pub vtable_: *const ZOOMSDK_IVideoFilterImageInfo__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IVideoFilterImageInfo() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IVideoFilterImageInfo>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IVideoFilterImageInfo))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IVideoFilterImageInfo>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IVideoFilterImageInfo))
);
}
#[repr(C)]
pub struct ZOOMSDK_IVideoFilterSettingContextEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Video filter context Callback Event."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IVideoFilterSettingContextEvent {
pub vtable_: *const ZOOMSDK_IVideoFilterSettingContextEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IVideoFilterSettingContextEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IVideoFilterSettingContextEvent>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_IVideoFilterSettingContextEvent)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IVideoFilterSettingContextEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IVideoFilterSettingContextEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IVideoFilterSettingContext__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Video filter setting interface."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IVideoFilterSettingContext {
pub vtable_: *const ZOOMSDK_IVideoFilterSettingContext__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IVideoFilterSettingContext() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IVideoFilterSettingContext>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IVideoFilterSettingContext))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IVideoFilterSettingContext>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IVideoFilterSettingContext)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_IShareSettingContext__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Share setting interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_IShareSettingContext {
pub vtable_: *const ZOOMSDK_IShareSettingContext__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IShareSettingContext() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IShareSettingContext>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IShareSettingContext))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IShareSettingContext>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IShareSettingContext))
);
}
#[repr(C)]
pub struct ZOOMSDK_ISettingService__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Meeting setting interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_ISettingService {
pub vtable_: *const ZOOMSDK_ISettingService__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ISettingService() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ISettingService>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ISettingService))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ISettingService>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_ISettingService))
);
}
#[repr(C)]
pub struct ZOOMSDK_ICustomizedUIMgrEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief The callback event of custom UI manager interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_ICustomizedUIMgrEvent {
pub vtable_: *const ZOOMSDK_ICustomizedUIMgrEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ICustomizedUIMgrEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ICustomizedUIMgrEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ICustomizedUIMgrEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ICustomizedUIMgrEvent>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_ICustomizedUIMgrEvent))
);
}
#[repr(C)]
pub struct ZOOMSDK_ICustomizedUIMgr__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Custom UI manager interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_ICustomizedUIMgr {
pub vtable_: *const ZOOMSDK_ICustomizedUIMgr__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ICustomizedUIMgr() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ICustomizedUIMgr>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ICustomizedUIMgr))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ICustomizedUIMgr>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_ICustomizedUIMgr))
);
}
#[doc = "<For initiation."]
pub const ZOOMSDK_VideoRenderElementType_VideoRenderElement_None: ZOOMSDK_VideoRenderElementType =
0;
#[doc = "<Preview type, see \\link IPreviewVideoRenderElement \\endlink."]
pub const ZOOMSDK_VideoRenderElementType_VideoRenderElement_PRVIEW: ZOOMSDK_VideoRenderElementType =
1;
#[doc = "<Active type, see \\link IActiveVideoRenderElement \\endlink."]
pub const ZOOMSDK_VideoRenderElementType_VideoRenderElement_ACTIVE: ZOOMSDK_VideoRenderElementType =
2;
#[doc = "<Normal type, see \\link INormalVideoRenderElement \\endlink."]
pub const ZOOMSDK_VideoRenderElementType_VideoRenderElement_NORMAL: ZOOMSDK_VideoRenderElementType =
3;
#[doc = " \\enum VideoRenderElementType"]
#[doc = "\\brief Type of the video render element."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_VideoRenderElementType = ::std::os::raw::c_int;
#[doc = "<For initiation."]
pub const ZOOMSDK_VideoRenderDataType_VideoRenderData_None: ZOOMSDK_VideoRenderDataType = 0;
#[doc = "<Data type including the video data."]
pub const ZOOMSDK_VideoRenderDataType_VideoRenderData_Video: ZOOMSDK_VideoRenderDataType = 1;
#[doc = "<Data type without video data."]
pub const ZOOMSDK_VideoRenderDataType_VideoRenderData_Avatar: ZOOMSDK_VideoRenderDataType = 2;
#[doc = "<Data type of screen name only."]
pub const ZOOMSDK_VideoRenderDataType_VideoRenderData_ScreenName: ZOOMSDK_VideoRenderDataType = 3;
#[doc = " \\enum VideoRenderDataType"]
#[doc = "\\brief Data type of the video render element."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_VideoRenderDataType = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_IVideoRenderElement__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief The base class for the video element interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IVideoRenderElement {
pub vtable_: *const ZOOMSDK_IVideoRenderElement__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IVideoRenderElement() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IVideoRenderElement>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IVideoRenderElement))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IVideoRenderElement>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_IVideoRenderElement))
);
}
#[doc = " \\brief The interface to preview the video render element of the participant who joins the meeting before the host."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IPreviewVideoRenderElement {
pub _base: ZOOMSDK_IVideoRenderElement,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IPreviewVideoRenderElement() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IPreviewVideoRenderElement>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IPreviewVideoRenderElement))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IPreviewVideoRenderElement>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IPreviewVideoRenderElement)
)
);
}
#[doc = " \\brief The active video render element interface in the meeting."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_IActiveVideoRenderElement {
pub _base: ZOOMSDK_IVideoRenderElement,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_IActiveVideoRenderElement() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_IActiveVideoRenderElement>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_IActiveVideoRenderElement))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_IActiveVideoRenderElement>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_IActiveVideoRenderElement)
)
);
}
#[doc = " \\brief Normal video render element interface in the meeting."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_INormalVideoRenderElement {
pub _base: ZOOMSDK_IVideoRenderElement,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_INormalVideoRenderElement() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_INormalVideoRenderElement>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_INormalVideoRenderElement))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_INormalVideoRenderElement>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_INormalVideoRenderElement)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_ICustomizedVideoContainerEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Callback event of custom video container."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_ICustomizedVideoContainerEvent {
pub vtable_: *const ZOOMSDK_ICustomizedVideoContainerEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ICustomizedVideoContainerEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ICustomizedVideoContainerEvent>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_ICustomizedVideoContainerEvent)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ICustomizedVideoContainerEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ICustomizedVideoContainerEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_ICustomizedVideoContainer__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Video container interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_ICustomizedVideoContainer {
pub vtable_: *const ZOOMSDK_ICustomizedVideoContainer__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ICustomizedVideoContainer() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ICustomizedVideoContainer>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ICustomizedVideoContainer))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ICustomizedVideoContainer>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ICustomizedVideoContainer)
)
);
}
extern "C" {
#[doc = " \\brief Create a custom UI manager interface."]
#[doc = " \\param ppCustomizedUIMgr The parameter stores the pointer to ICustomizedUIMgr* once the function calls successfully."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success, while the return value of ppCustomizedUIMgr is not NULL"]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_CreateCustomizedUIMgr"]
pub fn ZOOMSDK_CreateCustomizedUIMgr(
ppCustomizedUIMgr: *mut *mut ZOOMSDK_ICustomizedUIMgr,
) -> ZOOMSDK_SDKError;
}
extern "C" {
#[doc = " \\brief Destroy the specified custom UI manager interface."]
#[doc = " \\param pCustomizedUIMgr A pointer to the ICustomizedUIMgr to be destroyed."]
#[doc = " \\return If the function succeeds, the return value is SDKErr_Success."]
#[doc = "Otherwise failed. To get extended error information, see \\link SDKError \\endlink enum."]
#[link_name = "\u{1}_DestroyCustomizedUIMgr"]
pub fn ZOOMSDK_DestroyCustomizedUIMgr(
pCustomizedUIMgr: *mut ZOOMSDK_ICustomizedUIMgr,
) -> ZOOMSDK_SDKError;
}
pub const ZOOMSDK_CustomizedViewShareMode_CSM_FULLFILL: ZOOMSDK_CustomizedViewShareMode = 0;
#[doc = "View the shared content in full screen mode."]
pub const ZOOMSDK_CustomizedViewShareMode_CSM_LETTER_BOX: ZOOMSDK_CustomizedViewShareMode = 1;
#[doc = " \\enum CustomizedViewShareMode"]
#[doc = "\\brief View mode of shared render."]
#[doc = "Here are more detailed structural descriptions."]
pub type ZOOMSDK_CustomizedViewShareMode = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_ICustomizedShareRenderEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Share render callback event."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_ICustomizedShareRenderEvent {
pub vtable_: *const ZOOMSDK_ICustomizedShareRenderEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ICustomizedShareRenderEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ICustomizedShareRenderEvent>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ICustomizedShareRenderEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ICustomizedShareRenderEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ICustomizedShareRenderEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_ICustomizedShareRender__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Share render interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_ICustomizedShareRender {
pub vtable_: *const ZOOMSDK_ICustomizedShareRender__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ICustomizedShareRender() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ICustomizedShareRender>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ICustomizedShareRender))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ICustomizedShareRender>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_ICustomizedShareRender))
);
}
#[doc = "<The toolbar has been created."]
pub const ZOOMSDK_CustomizedShareAnnotationStatus_CS_ANNO_READYTOUSE:
ZOOMSDK_CustomizedShareAnnotationStatus = 0;
#[doc = "<The toolbar will be destroyed."]
pub const ZOOMSDK_CustomizedShareAnnotationStatus_CS_ANNO_CLOSE:
ZOOMSDK_CustomizedShareAnnotationStatus = 1;
#[doc = " \\enum CustomizedShareAnnotationStatus"]
#[doc = "\\brief Status of custom annotation toolbar."]
#[doc = "Here are more detailed structural descriptions.."]
pub type ZOOMSDK_CustomizedShareAnnotationStatus = ::std::os::raw::c_int;
pub const ZOOMSDK_SDKAnnoSaveType_SDK_ANNO_SAVE_NONE: ZOOMSDK_SDKAnnoSaveType = 0;
pub const ZOOMSDK_SDKAnnoSaveType_SDK_ANNO_SAVE_PNG: ZOOMSDK_SDKAnnoSaveType = 1;
pub const ZOOMSDK_SDKAnnoSaveType_SDK_ANNO_SAVE_PDF: ZOOMSDK_SDKAnnoSaveType = 2;
pub const ZOOMSDK_SDKAnnoSaveType_SDK_ANNO_SAVE_PNG_MEMORY: ZOOMSDK_SDKAnnoSaveType = 3;
pub const ZOOMSDK_SDKAnnoSaveType_SDK_ANNO_SAVE_PDF_MEMORY: ZOOMSDK_SDKAnnoSaveType = 4;
pub const ZOOMSDK_SDKAnnoSaveType_SDK_ANNO_SAVE_BITMAP_MEMORY: ZOOMSDK_SDKAnnoSaveType = 5;
pub type ZOOMSDK_SDKAnnoSaveType = ::std::os::raw::c_int;
#[repr(C)]
pub struct ZOOMSDK_ICustomizedAnnotationObjEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Annotation object callback event."]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_ICustomizedAnnotationObjEvent {
pub vtable_: *const ZOOMSDK_ICustomizedAnnotationObjEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ICustomizedAnnotationObjEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ICustomizedAnnotationObjEvent>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_ICustomizedAnnotationObjEvent)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ICustomizedAnnotationObjEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ICustomizedAnnotationObjEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_ICustomizedAnnotationObj__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Annotation object interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_ICustomizedAnnotationObj {
pub vtable_: *const ZOOMSDK_ICustomizedAnnotationObj__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ICustomizedAnnotationObj() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ICustomizedAnnotationObj>(),
4usize,
concat!("Size of: ", stringify!(ZOOMSDK_ICustomizedAnnotationObj))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ICustomizedAnnotationObj>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ICustomizedAnnotationObj)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_ICustomizedAnnotationControllerEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Annotation controller callback event"]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_ICustomizedAnnotationControllerEvent {
pub vtable_: *const ZOOMSDK_ICustomizedAnnotationControllerEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ICustomizedAnnotationControllerEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ICustomizedAnnotationControllerEvent>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_ICustomizedAnnotationControllerEvent)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ICustomizedAnnotationControllerEvent>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ICustomizedAnnotationControllerEvent)
)
);
}
#[repr(C)]
pub struct ZOOMSDK_ICustomizedAnnotationController__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Annotation controller interface."]
#[doc = ""]
#[repr(C)]
#[derive(Debug)]
pub struct ZOOMSDK_ICustomizedAnnotationController {
pub vtable_: *const ZOOMSDK_ICustomizedAnnotationController__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_ICustomizedAnnotationController() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_ICustomizedAnnotationController>(),
4usize,
concat!(
"Size of: ",
stringify!(ZOOMSDK_ICustomizedAnnotationController)
)
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_ICustomizedAnnotationController>(),
4usize,
concat!(
"Alignment of ",
stringify!(ZOOMSDK_ICustomizedAnnotationController)
)
);
}
extern "C" {
#[link_name = "\u{1}?InitParam_Default@ZOOMSDK@@YA?AUtagInitParam@1@XZ"]
pub fn ZOOMSDK_InitParam_Default() -> ZOOMSDK_InitParam;
}
extern "C" {
#[link_name = "\u{1}?IZoomLastError_GetErrorType@ZOOMSDK@@YA?AW4LastErrorType@1@PBVIZoomLastError@1@@Z"]
pub fn ZOOMSDK_IZoomLastError_GetErrorType(
self_: *const ZOOMSDK_IZoomLastError,
) -> ZOOMSDK_LastErrorType;
}
extern "C" {
#[link_name = "\u{1}?IZoomLastError_GetErrorCode@ZOOMSDK@@YA_KPBVIZoomLastError@1@@Z"]
pub fn ZOOMSDK_IZoomLastError_GetErrorCode(self_: *const ZOOMSDK_IZoomLastError) -> UINT64;
}
extern "C" {
#[link_name = "\u{1}?IZoomLastError_GetErrorDescription@ZOOMSDK@@YAPB_WPBVIZoomLastError@1@@Z"]
pub fn ZOOMSDK_IZoomLastError_GetErrorDescription(
self_: *const ZOOMSDK_IZoomLastError,
) -> *const u16;
}
extern "C" {
#[link_name = "\u{1}?StringDrop@ZOOMSDK@@YAXPA_W@Z"]
pub fn ZOOMSDK_StringDrop(string: *mut u16);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZOOMSDK_CAuthServiceEvent {
pub callbackData: *mut ::std::os::raw::c_void,
pub authenticationReturn: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void, arg2: ZOOMSDK_AuthResult),
>,
pub loginReturn: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut ::std::os::raw::c_void,
arg2: ZOOMSDK_LOGINSTATUS,
arg3: *mut ZOOMSDK_IAccountInfo,
),
>,
}
#[test]
fn bindgen_test_layout_ZOOMSDK_CAuthServiceEvent() {
assert_eq!(
::std::mem::size_of::<ZOOMSDK_CAuthServiceEvent>(),
12usize,
concat!("Size of: ", stringify!(ZOOMSDK_CAuthServiceEvent))
);
assert_eq!(
::std::mem::align_of::<ZOOMSDK_CAuthServiceEvent>(),
4usize,
concat!("Alignment of ", stringify!(ZOOMSDK_CAuthServiceEvent))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_CAuthServiceEvent>())).callbackData as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_CAuthServiceEvent),
"::",
stringify!(callbackData)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_CAuthServiceEvent>())).authenticationReturn as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_CAuthServiceEvent),
"::",
stringify!(authenticationReturn)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ZOOMSDK_CAuthServiceEvent>())).loginReturn as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ZOOMSDK_CAuthServiceEvent),
"::",
stringify!(loginReturn)
)
);
}
extern "C" {
#[link_name = "\u{1}?IAuthService_SetEvent@ZOOMSDK@@YA?AW4SDKError@1@PAVIAuthService@1@PBUCAuthServiceEvent@1@@Z"]
pub fn ZOOMSDK_IAuthService_SetEvent(
self_: *mut ZOOMSDK_IAuthService,
event: *const ZOOMSDK_CAuthServiceEvent,
) -> ZOOMSDK_SDKError;
}
extern "C" {
#[link_name = "\u{1}?IAuthService_SDKAuthParam@ZOOMSDK@@YA?AW4SDKError@1@PAVIAuthService@1@UtagAuthParam@1@@Z"]
pub fn ZOOMSDK_IAuthService_SDKAuthParam(
self_: *mut ZOOMSDK_IAuthService,
param: ZOOMSDK_AuthParam,
) -> ZOOMSDK_SDKError;
}
extern "C" {
#[link_name = "\u{1}?IAuthService_Login@ZOOMSDK@@YA?AW4SDKError@1@PAVIAuthService@1@UtagLoginParam@1@@Z"]
pub fn ZOOMSDK_IAuthService_Login(
self_: *mut ZOOMSDK_IAuthService,
param: ZOOMSDK_LoginParam,
) -> ZOOMSDK_SDKError;
}
extern "C" {
#[link_name = "\u{1}?IAccountInfo_GetDisplayName@ZOOMSDK@@YAPB_WPAVIAccountInfo@1@@Z"]
pub fn ZOOMSDK_IAccountInfo_GetDisplayName(self_: *mut ZOOMSDK_IAccountInfo) -> *const u16;
}
extern "C" {
#[link_name = "\u{1}?IAccountInfo_GetLoginType@ZOOMSDK@@YA?AW4LoginType@1@PAVIAccountInfo@1@@Z"]
pub fn ZOOMSDK_IAccountInfo_GetLoginType(self_: *mut ZOOMSDK_IAccountInfo)
-> ZOOMSDK_LoginType;
}
extern "C" {
#[link_name = "\u{1}?IMeetingsService_HandleZoomWebUriProtocolAction@ZOOMSDK@@YA?AW4SDKError@1@PAVIMeetingService@1@PB_W@Z"]
pub fn ZOOMSDK_IMeetingsService_HandleZoomWebUriProtocolAction(
self_: *mut ZOOMSDK_IMeetingService,
protocol_action: *const u16,
) -> ZOOMSDK_SDKError;
}
#[repr(C)]
pub struct IVector__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct IVector {
pub vtable_: *const IVector__bindgen_vtable,
}
#[repr(C)]
pub struct IZoomRetrieveSMSVerificationCodeHandler__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Retrieve SMS verification code handler interface."]
#[repr(C)]
#[derive(Debug)]
pub struct IZoomRetrieveSMSVerificationCodeHandler {
pub vtable_: *const IZoomRetrieveSMSVerificationCodeHandler__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_IZoomRetrieveSMSVerificationCodeHandler() {
assert_eq!(
::std::mem::size_of::<IZoomRetrieveSMSVerificationCodeHandler>(),
4usize,
concat!(
"Size of: ",
stringify!(IZoomRetrieveSMSVerificationCodeHandler)
)
);
assert_eq!(
::std::mem::align_of::<IZoomRetrieveSMSVerificationCodeHandler>(),
4usize,
concat!(
"Alignment of ",
stringify!(IZoomRetrieveSMSVerificationCodeHandler)
)
);
}
#[repr(C)]
pub struct IZoomVerifySMSVerificationCodeHandler__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Verify SMS verification code handler interface."]
#[repr(C)]
#[derive(Debug)]
pub struct IZoomVerifySMSVerificationCodeHandler {
pub vtable_: *const IZoomVerifySMSVerificationCodeHandler__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_IZoomVerifySMSVerificationCodeHandler() {
assert_eq!(
::std::mem::size_of::<IZoomVerifySMSVerificationCodeHandler>(),
4usize,
concat!(
"Size of: ",
stringify!(IZoomVerifySMSVerificationCodeHandler)
)
);
assert_eq!(
::std::mem::align_of::<IZoomVerifySMSVerificationCodeHandler>(),
4usize,
concat!(
"Alignment of ",
stringify!(IZoomVerifySMSVerificationCodeHandler)
)
);
}
#[doc = "<For initialization."]
pub const SMSVerificationCodeErr_SMSVerificationCodeErr_Unknown: SMSVerificationCodeErr = 0;
#[doc = "<Success."]
pub const SMSVerificationCodeErr_SMSVerificationCodeErr_Success: SMSVerificationCodeErr = 1;
#[doc = "<Send SMS Failed."]
pub const SMSVerificationCodeErr_SMSVerificationCodeErr_Retrieve_SendSMSFailed:
SMSVerificationCodeErr = 2;
#[doc = "<Invalid phone number."]
pub const SMSVerificationCodeErr_SMSVerificationCodeErr_Retrieve_InvalidPhoneNum:
SMSVerificationCodeErr = 3;
#[doc = "<The phone number is already bound."]
pub const SMSVerificationCodeErr_SMSVerificationCodeErr_Retrieve_PhoneNumAlreadyBound:
SMSVerificationCodeErr = 4;
#[doc = "<Send phone number too frequently."]
pub const SMSVerificationCodeErr_SMSVerificationCodeErr_Retrieve_PhoneNumSendTooFrequent:
SMSVerificationCodeErr = 5;
#[doc = "<Verification code is incorrect."]
pub const SMSVerificationCodeErr_SMSVerificationCodeErr_Verify_CodeIncorrect:
SMSVerificationCodeErr = 6;
#[doc = "<Verification code is expired."]
pub const SMSVerificationCodeErr_SMSVerificationCodeErr_Verify_CodeExpired: SMSVerificationCodeErr =
7;
#[doc = "<Unknown error for verification."]
pub const SMSVerificationCodeErr_SMSVerificationCodeErr_Verify_UnknownError:
SMSVerificationCodeErr = 8;
#[doc = " \\enum SMSVerificationCodeErr"]
#[doc = "\\brief SMS verification error types."]
#[doc = "Here are more detailed structural descriptions."]
pub type SMSVerificationCodeErr = ::std::os::raw::c_int;
#[repr(C)]
pub struct IZoomRealNameAuthCountryInfo__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Interface of country information that supports real name auth."]
#[repr(C)]
#[derive(Debug)]
pub struct IZoomRealNameAuthCountryInfo {
pub vtable_: *const IZoomRealNameAuthCountryInfo__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_IZoomRealNameAuthCountryInfo() {
assert_eq!(
::std::mem::size_of::<IZoomRealNameAuthCountryInfo>(),
4usize,
concat!("Size of: ", stringify!(IZoomRealNameAuthCountryInfo))
);
assert_eq!(
::std::mem::align_of::<IZoomRealNameAuthCountryInfo>(),
4usize,
concat!("Alignment of ", stringify!(IZoomRealNameAuthCountryInfo))
);
}
#[repr(C)]
pub struct IZoomRealNameAuthMeetingEvent__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Real name auth meeting callback event."]
#[repr(C)]
#[derive(Debug)]
pub struct IZoomRealNameAuthMeetingEvent {
pub vtable_: *const IZoomRealNameAuthMeetingEvent__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_IZoomRealNameAuthMeetingEvent() {
assert_eq!(
::std::mem::size_of::<IZoomRealNameAuthMeetingEvent>(),
4usize,
concat!("Size of: ", stringify!(IZoomRealNameAuthMeetingEvent))
);
assert_eq!(
::std::mem::align_of::<IZoomRealNameAuthMeetingEvent>(),
4usize,
concat!("Alignment of ", stringify!(IZoomRealNameAuthMeetingEvent))
);
}
#[repr(C)]
pub struct IZoomRealNameAuthMeetingHelper__bindgen_vtable(::std::os::raw::c_void);
#[doc = " \\brief Real name auth meeting helper Interface."]
#[repr(C)]
#[derive(Debug)]
pub struct IZoomRealNameAuthMeetingHelper {
pub vtable_: *const IZoomRealNameAuthMeetingHelper__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_IZoomRealNameAuthMeetingHelper() {
assert_eq!(
::std::mem::size_of::<IZoomRealNameAuthMeetingHelper>(),
4usize,
concat!("Size of: ", stringify!(IZoomRealNameAuthMeetingHelper))
);
assert_eq!(
::std::mem::align_of::<IZoomRealNameAuthMeetingHelper>(),
4usize,
concat!("Alignment of ", stringify!(IZoomRealNameAuthMeetingHelper))
);
}
pub type fpos_t = ::std::os::raw::c_longlong;
#[test]
fn __bindgen_test_layout_std_basic_string_open0_wchar_t_std_char_traits_open1_wchar_t_close1_std_allocator_open1_wchar_t_close1_close0_instantiation(
) {
assert_eq!(
::std::mem::size_of::<std_basic_string>(),
24usize,
concat!(
"Size of template specialization: ",
stringify!(std_basic_string)
)
);
assert_eq!(
::std::mem::align_of::<std_basic_string>(),
4usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_basic_string)
)
);
}
#[test]
fn __bindgen_test_layout_std_char_traits_open0_wchar_t_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_char_traits>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_char_traits)
)
);
assert_eq!(
::std::mem::align_of::<std_char_traits>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_char_traits)
)
);
}
#[test]
fn __bindgen_test_layout_std_allocator_open0_wchar_t_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}