winio-winui3 0.4.0

// Bindings generated by `windows-bindgen` 0.66.0

#![allow(
    non_snake_case,
    non_upper_case_globals,
    non_camel_case_types,
    dead_code,
    clippy::all
)]

windows_core::imp::define_interface!(
    IComponentConnector,
    IComponentConnector_Vtbl,
    0xad401812_b091_51d0_b915_2d682cd2af10
);
impl windows_core::RuntimeType for IComponentConnector {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
windows_core::imp::interface_hierarchy!(
    IComponentConnector,
    windows_core::IUnknown,
    windows_core::IInspectable
);
impl IComponentConnector {
    pub fn Connect<P1>(&self, connectionid: i32, target: P1) -> windows_core::Result<()>
    where
        P1: windows_core::Param<windows_core::IInspectable>,
    {
        let this = self;
        unsafe {
            (windows_core::Interface::vtable(this).Connect)(
                windows_core::Interface::as_raw(this),
                connectionid,
                target.param().abi(),
            )
            .ok()
        }
    }
    pub fn GetBindingConnector<P1>(
        &self,
        connectionid: i32,
        target: P1,
    ) -> windows_core::Result<IComponentConnector>
    where
        P1: windows_core::Param<windows_core::IInspectable>,
    {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).GetBindingConnector)(
                windows_core::Interface::as_raw(this),
                connectionid,
                target.param().abi(),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
}
impl windows_core::RuntimeName for IComponentConnector {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IComponentConnector";
}
pub trait IComponentConnector_Impl: windows_core::IUnknownImpl {
    fn Connect(
        &self,
        connectionId: i32,
        target: windows_core::Ref<windows_core::IInspectable>,
    ) -> windows_core::Result<()>;
    fn GetBindingConnector(
        &self,
        connectionId: i32,
        target: windows_core::Ref<windows_core::IInspectable>,
    ) -> windows_core::Result<IComponentConnector>;
}
impl IComponentConnector_Vtbl {
    pub const fn new<Identity: IComponentConnector_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Connect<
            Identity: IComponentConnector_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            connectionid: i32,
            target: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IComponentConnector_Impl::Connect(
                    this,
                    connectionid,
                    core::mem::transmute_copy(&target),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetBindingConnector<
            Identity: IComponentConnector_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            connectionid: i32,
            target: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IComponentConnector_Impl::GetBindingConnector(
                    this,
                    connectionid,
                    core::mem::transmute_copy(&target),
                ) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<Identity, IComponentConnector, OFFSET>(),
            Connect: Connect::<Identity, OFFSET>,
            GetBindingConnector: GetBindingConnector::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IComponentConnector as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IComponentConnector_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
    pub Connect: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        i32,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetBindingConnector: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        i32,
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
windows_core::imp::define_interface!(
    IDataTemplateComponent,
    IDataTemplateComponent_Vtbl,
    0x1743ddf7_38ba_58c9_a2a6_b0ae28713bee
);
impl windows_core::RuntimeType for IDataTemplateComponent {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
windows_core::imp::interface_hierarchy!(
    IDataTemplateComponent,
    windows_core::IUnknown,
    windows_core::IInspectable
);
impl IDataTemplateComponent {
    pub fn Recycle(&self) -> windows_core::Result<()> {
        let this = self;
        unsafe {
            (windows_core::Interface::vtable(this).Recycle)(windows_core::Interface::as_raw(this))
                .ok()
        }
    }
    pub fn ProcessBindings<P0>(
        &self,
        item: P0,
        itemindex: i32,
        phase: i32,
        nextphase: &mut i32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::IInspectable>,
    {
        let this = self;
        unsafe {
            (windows_core::Interface::vtable(this).ProcessBindings)(
                windows_core::Interface::as_raw(this),
                item.param().abi(),
                itemindex,
                phase,
                nextphase,
            )
            .ok()
        }
    }
}
impl windows_core::RuntimeName for IDataTemplateComponent {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IDataTemplateComponent";
}
pub trait IDataTemplateComponent_Impl: windows_core::IUnknownImpl {
    fn Recycle(&self) -> windows_core::Result<()>;
    fn ProcessBindings(
        &self,
        item: windows_core::Ref<windows_core::IInspectable>,
        itemIndex: i32,
        phase: i32,
        nextPhase: &mut i32,
    ) -> windows_core::Result<()>;
}
impl IDataTemplateComponent_Vtbl {
    pub const fn new<Identity: IDataTemplateComponent_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Recycle<
            Identity: IDataTemplateComponent_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IDataTemplateComponent_Impl::Recycle(this).into()
            }
        }
        unsafe extern "system" fn ProcessBindings<
            Identity: IDataTemplateComponent_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            item: *mut core::ffi::c_void,
            itemindex: i32,
            phase: i32,
            nextphase: *mut i32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IDataTemplateComponent_Impl::ProcessBindings(
                    this,
                    core::mem::transmute_copy(&item),
                    itemindex,
                    phase,
                    core::mem::transmute_copy(&nextphase),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<Identity, IDataTemplateComponent, OFFSET>(
            ),
            Recycle: Recycle::<Identity, OFFSET>,
            ProcessBindings: ProcessBindings::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IDataTemplateComponent as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataTemplateComponent_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
    pub Recycle: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub ProcessBindings: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        i32,
        i32,
        *mut i32,
    ) -> windows_core::HRESULT,
}
windows_core::imp::define_interface!(
    IMarkupExtension,
    IMarkupExtension_Vtbl,
    0xc355371e_091d_5136_af4a_baf5e00616bd
);
impl windows_core::RuntimeType for IMarkupExtension {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
impl windows_core::RuntimeName for IMarkupExtension {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IMarkupExtension";
}
pub trait IMarkupExtension_Impl: windows_core::IUnknownImpl {}
impl IMarkupExtension_Vtbl {
    pub const fn new<Identity: IMarkupExtension_Impl, const OFFSET: isize>() -> Self {
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<Identity, IMarkupExtension, OFFSET>(),
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMarkupExtension as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IMarkupExtension_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
}
windows_core::imp::define_interface!(
    IMarkupExtensionFactory,
    IMarkupExtensionFactory_Vtbl,
    0x20651afa_5f3a_5f0c_adb1_b6551f53a6a0
);
impl windows_core::RuntimeType for IMarkupExtensionFactory {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
impl windows_core::RuntimeName for IMarkupExtensionFactory {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IMarkupExtensionFactory";
}
pub trait IMarkupExtensionFactory_Impl: windows_core::IUnknownImpl {
    fn CreateInstance(
        &self,
        baseInterface: windows_core::Ref<windows_core::IInspectable>,
        innerInterface: windows_core::OutRef<windows_core::IInspectable>,
    ) -> windows_core::Result<MarkupExtension>;
}
impl IMarkupExtensionFactory_Vtbl {
    pub const fn new<Identity: IMarkupExtensionFactory_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn CreateInstance<
            Identity: IMarkupExtensionFactory_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            baseinterface: *mut core::ffi::c_void,
            innerinterface: *mut *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMarkupExtensionFactory_Impl::CreateInstance(
                    this,
                    core::mem::transmute_copy(&baseinterface),
                    core::mem::transmute_copy(&innerinterface),
                ) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<Identity, IMarkupExtensionFactory, OFFSET>(
            ),
            CreateInstance: CreateInstance::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMarkupExtensionFactory as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IMarkupExtensionFactory_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
    pub CreateInstance: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
windows_core::imp::define_interface!(
    IMarkupExtensionOverrides,
    IMarkupExtensionOverrides_Vtbl,
    0xa12aa575_5d31_5b68_a30f_8495412a351d
);
impl windows_core::RuntimeType for IMarkupExtensionOverrides {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
impl IMarkupExtensionOverrides {
    pub fn ProvideValue(&self) -> windows_core::Result<windows_core::IInspectable> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).ProvideValue)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
}
impl windows_core::RuntimeName for IMarkupExtensionOverrides {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IMarkupExtensionOverrides";
}
pub trait IMarkupExtensionOverrides_Impl: windows_core::IUnknownImpl {
    fn ProvideValue(&self) -> windows_core::Result<windows_core::IInspectable>;
}
impl IMarkupExtensionOverrides_Vtbl {
    pub const fn new<Identity: IMarkupExtensionOverrides_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn ProvideValue<
            Identity: IMarkupExtensionOverrides_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMarkupExtensionOverrides_Impl::ProvideValue(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<
                Identity,
                IMarkupExtensionOverrides,
                OFFSET,
            >(),
            ProvideValue: ProvideValue::<Identity, OFFSET>,
            ProvideValueWithIXamlServiceProvider: 0,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMarkupExtensionOverrides as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IMarkupExtensionOverrides_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
    pub ProvideValue: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    ProvideValueWithIXamlServiceProvider: usize,
}
windows_core::imp::define_interface!(
    IProvideValueTarget,
    IProvideValueTarget_Vtbl,
    0x3f01ff68_3efd_591d_a506_de13fcaabd83
);
impl windows_core::RuntimeType for IProvideValueTarget {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
windows_core::imp::interface_hierarchy!(
    IProvideValueTarget,
    windows_core::IUnknown,
    windows_core::IInspectable
);
impl IProvideValueTarget {
    pub fn TargetObject(&self) -> windows_core::Result<windows_core::IInspectable> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).TargetObject)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub fn TargetProperty(&self) -> windows_core::Result<windows_core::IInspectable> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).TargetProperty)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
}
impl windows_core::RuntimeName for IProvideValueTarget {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IProvideValueTarget";
}
pub trait IProvideValueTarget_Impl: windows_core::IUnknownImpl {
    fn TargetObject(&self) -> windows_core::Result<windows_core::IInspectable>;
    fn TargetProperty(&self) -> windows_core::Result<windows_core::IInspectable>;
}
impl IProvideValueTarget_Vtbl {
    pub const fn new<Identity: IProvideValueTarget_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn TargetObject<
            Identity: IProvideValueTarget_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IProvideValueTarget_Impl::TargetObject(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn TargetProperty<
            Identity: IProvideValueTarget_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IProvideValueTarget_Impl::TargetProperty(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<Identity, IProvideValueTarget, OFFSET>(),
            TargetObject: TargetObject::<Identity, OFFSET>,
            TargetProperty: TargetProperty::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IProvideValueTarget as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IProvideValueTarget_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
    pub TargetObject: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub TargetProperty: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
windows_core::imp::define_interface!(
    IProvideValueTargetProperty,
    IProvideValueTargetProperty_Vtbl,
    0xce777b1f_b42e_59d1_870d_12fdf0629133
);
impl windows_core::RuntimeType for IProvideValueTargetProperty {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
impl windows_core::RuntimeName for IProvideValueTargetProperty {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IProvideValueTargetProperty";
}
pub trait IProvideValueTargetProperty_Impl: windows_core::IUnknownImpl {
    fn Name(&self) -> windows_core::Result<windows_core::HSTRING>;
    fn Type(&self) -> windows_core::Result<crate::Windows::UI::Xaml::Interop::TypeName>;
    fn DeclaringType(&self) -> windows_core::Result<crate::Windows::UI::Xaml::Interop::TypeName>;
}
impl IProvideValueTargetProperty_Vtbl {
    pub const fn new<Identity: IProvideValueTargetProperty_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Name<
            Identity: IProvideValueTargetProperty_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IProvideValueTargetProperty_Impl::Name(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn Type<
            Identity: IProvideValueTargetProperty_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            result__: *mut core::mem::MaybeUninit<crate::Windows::UI::Xaml::Interop::TypeName>,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IProvideValueTargetProperty_Impl::Type(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn DeclaringType<
            Identity: IProvideValueTargetProperty_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            result__: *mut core::mem::MaybeUninit<crate::Windows::UI::Xaml::Interop::TypeName>,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IProvideValueTargetProperty_Impl::DeclaringType(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<
                Identity,
                IProvideValueTargetProperty,
                OFFSET,
            >(),
            Name: Name::<Identity, OFFSET>,
            Type: Type::<Identity, OFFSET>,
            DeclaringType: DeclaringType::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IProvideValueTargetProperty as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IProvideValueTargetProperty_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
    pub Name: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Type: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::mem::MaybeUninit<crate::Windows::UI::Xaml::Interop::TypeName>,
    ) -> windows_core::HRESULT,
    pub DeclaringType: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::mem::MaybeUninit<crate::Windows::UI::Xaml::Interop::TypeName>,
    ) -> windows_core::HRESULT,
}
windows_core::imp::define_interface!(
    IRootObjectProvider,
    IRootObjectProvider_Vtbl,
    0x13d63599_352f_5eb8_81c1_bc62fb12d6da
);
impl windows_core::RuntimeType for IRootObjectProvider {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
windows_core::imp::interface_hierarchy!(
    IRootObjectProvider,
    windows_core::IUnknown,
    windows_core::IInspectable
);
impl IRootObjectProvider {
    pub fn RootObject(&self) -> windows_core::Result<windows_core::IInspectable> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).RootObject)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
}
impl windows_core::RuntimeName for IRootObjectProvider {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IRootObjectProvider";
}
pub trait IRootObjectProvider_Impl: windows_core::IUnknownImpl {
    fn RootObject(&self) -> windows_core::Result<windows_core::IInspectable>;
}
impl IRootObjectProvider_Vtbl {
    pub const fn new<Identity: IRootObjectProvider_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn RootObject<
            Identity: IRootObjectProvider_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IRootObjectProvider_Impl::RootObject(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<Identity, IRootObjectProvider, OFFSET>(),
            RootObject: RootObject::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IRootObjectProvider as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IRootObjectProvider_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
    pub RootObject: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
windows_core::imp::define_interface!(
    IUriContext,
    IUriContext_Vtbl,
    0xfb8605f6_8f05_52ee_a01c_3a9e118a6ea2
);
impl windows_core::RuntimeType for IUriContext {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
windows_core::imp::interface_hierarchy!(
    IUriContext,
    windows_core::IUnknown,
    windows_core::IInspectable
);
impl IUriContext {
    pub fn BaseUri(&self) -> windows_core::Result<windows::Foundation::Uri> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).BaseUri)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
}
impl windows_core::RuntimeName for IUriContext {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IUriContext";
}
pub trait IUriContext_Impl: windows_core::IUnknownImpl {
    fn BaseUri(&self) -> windows_core::Result<windows::Foundation::Uri>;
}
impl IUriContext_Vtbl {
    pub const fn new<Identity: IUriContext_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn BaseUri<Identity: IUriContext_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IUriContext_Impl::BaseUri(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<Identity, IUriContext, OFFSET>(),
            BaseUri: BaseUri::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IUriContext as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IUriContext_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
    pub BaseUri: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
windows_core::imp::define_interface!(
    IXamlBinaryWriter,
    IXamlBinaryWriter_Vtbl,
    0x8fb45e3b_e689_55bf_aa11_d83b1c1cdda1
);
impl windows_core::RuntimeType for IXamlBinaryWriter {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
impl windows_core::RuntimeName for IXamlBinaryWriter {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IXamlBinaryWriter";
}
pub trait IXamlBinaryWriter_Impl: windows_core::IUnknownImpl {}
impl IXamlBinaryWriter_Vtbl {
    pub const fn new<Identity: IXamlBinaryWriter_Impl, const OFFSET: isize>() -> Self {
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<Identity, IXamlBinaryWriter, OFFSET>(),
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IXamlBinaryWriter as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IXamlBinaryWriter_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
}
windows_core::imp::define_interface!(
    IXamlBinaryWriterStatics,
    IXamlBinaryWriterStatics_Vtbl,
    0x774907fc_c846_517f_abcc_c3f7e8c3ffc9
);
impl windows_core::RuntimeType for IXamlBinaryWriterStatics {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
impl windows_core::RuntimeName for IXamlBinaryWriterStatics {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IXamlBinaryWriterStatics";
}
pub trait IXamlBinaryWriterStatics_Impl: windows_core::IUnknownImpl {
    fn Write(
        &self,
        inputStreams: windows_core::Ref<
            windows_collections::IVector<windows::Storage::Streams::IRandomAccessStream>,
        >,
        outputStreams: windows_core::Ref<
            windows_collections::IVector<windows::Storage::Streams::IRandomAccessStream>,
        >,
        xamlMetadataProvider: windows_core::Ref<IXamlMetadataProvider>,
    ) -> windows_core::Result<XamlBinaryWriterErrorInformation>;
}
impl IXamlBinaryWriterStatics_Vtbl {
    pub const fn new<Identity: IXamlBinaryWriterStatics_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Write<
            Identity: IXamlBinaryWriterStatics_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            inputstreams: *mut core::ffi::c_void,
            outputstreams: *mut core::ffi::c_void,
            xamlmetadataprovider: *mut core::ffi::c_void,
            result__: *mut XamlBinaryWriterErrorInformation,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlBinaryWriterStatics_Impl::Write(
                    this,
                    core::mem::transmute_copy(&inputstreams),
                    core::mem::transmute_copy(&outputstreams),
                    core::mem::transmute_copy(&xamlmetadataprovider),
                ) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<
                Identity,
                IXamlBinaryWriterStatics,
                OFFSET,
            >(),
            Write: Write::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IXamlBinaryWriterStatics as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IXamlBinaryWriterStatics_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
    pub Write: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut XamlBinaryWriterErrorInformation,
    ) -> windows_core::HRESULT,
}
windows_core::imp::define_interface!(
    IXamlBindScopeDiagnostics,
    IXamlBindScopeDiagnostics_Vtbl,
    0x3ea84e4e_fdfe_55a8_a561_edf5697846d7
);
impl windows_core::RuntimeType for IXamlBindScopeDiagnostics {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
windows_core::imp::interface_hierarchy!(
    IXamlBindScopeDiagnostics,
    windows_core::IUnknown,
    windows_core::IInspectable
);
impl IXamlBindScopeDiagnostics {
    pub fn Disable(&self, linenumber: i32, columnnumber: i32) -> windows_core::Result<()> {
        let this = self;
        unsafe {
            (windows_core::Interface::vtable(this).Disable)(
                windows_core::Interface::as_raw(this),
                linenumber,
                columnnumber,
            )
            .ok()
        }
    }
}
impl windows_core::RuntimeName for IXamlBindScopeDiagnostics {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IXamlBindScopeDiagnostics";
}
pub trait IXamlBindScopeDiagnostics_Impl: windows_core::IUnknownImpl {
    fn Disable(&self, lineNumber: i32, columnNumber: i32) -> windows_core::Result<()>;
}
impl IXamlBindScopeDiagnostics_Vtbl {
    pub const fn new<Identity: IXamlBindScopeDiagnostics_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Disable<
            Identity: IXamlBindScopeDiagnostics_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            linenumber: i32,
            columnnumber: i32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXamlBindScopeDiagnostics_Impl::Disable(this, linenumber, columnnumber).into()
            }
        }
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<
                Identity,
                IXamlBindScopeDiagnostics,
                OFFSET,
            >(),
            Disable: Disable::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IXamlBindScopeDiagnostics as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IXamlBindScopeDiagnostics_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
    pub Disable:
        unsafe extern "system" fn(*mut core::ffi::c_void, i32, i32) -> windows_core::HRESULT,
}
windows_core::imp::define_interface!(
    IXamlBindingHelper,
    IXamlBindingHelper_Vtbl,
    0x607a9bf2_5a6d_5c89_a756_bb44f24f28f8
);
impl windows_core::RuntimeType for IXamlBindingHelper {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
impl windows_core::RuntimeName for IXamlBindingHelper {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IXamlBindingHelper";
}
pub trait IXamlBindingHelper_Impl: windows_core::IUnknownImpl {}
impl IXamlBindingHelper_Vtbl {
    pub const fn new<Identity: IXamlBindingHelper_Impl, const OFFSET: isize>() -> Self {
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<Identity, IXamlBindingHelper, OFFSET>(),
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IXamlBindingHelper as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IXamlBindingHelper_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
}
windows_core::imp::define_interface!(
    IXamlBindingHelperStatics,
    IXamlBindingHelperStatics_Vtbl,
    0x93c7dad3_f9c2_5372_84dc_9e9c4661d083
);
impl windows_core::RuntimeType for IXamlBindingHelperStatics {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
#[cfg(feature = "UI_Composition")]
impl windows_core::RuntimeName for IXamlBindingHelperStatics {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IXamlBindingHelperStatics";
}
#[cfg(feature = "UI_Composition")]
pub trait IXamlBindingHelperStatics_Impl: windows_core::IUnknownImpl {
    fn GetDataTemplateComponent(
        &self,
        element: windows_core::Ref<super::DependencyObject>,
    ) -> windows_core::Result<IDataTemplateComponent>;
    fn SetDataTemplateComponent(
        &self,
        element: windows_core::Ref<super::DependencyObject>,
        value: windows_core::Ref<IDataTemplateComponent>,
    ) -> windows_core::Result<()>;
    fn SuspendRendering(
        &self,
        target: windows_core::Ref<super::UIElement>,
    ) -> windows_core::Result<()>;
    fn ResumeRendering(
        &self,
        target: windows_core::Ref<super::UIElement>,
    ) -> windows_core::Result<()>;
    fn ConvertValue(
        &self,
        r#type: &crate::Windows::UI::Xaml::Interop::TypeName,
        value: windows_core::Ref<windows_core::IInspectable>,
    ) -> windows_core::Result<windows_core::IInspectable>;
}
#[cfg(feature = "UI_Composition")]
impl IXamlBindingHelperStatics_Vtbl {
    pub const fn new<Identity: IXamlBindingHelperStatics_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetDataTemplateComponent<
            Identity: IXamlBindingHelperStatics_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            element: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlBindingHelperStatics_Impl::GetDataTemplateComponent(
                    this,
                    core::mem::transmute_copy(&element),
                ) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn SetDataTemplateComponent<
            Identity: IXamlBindingHelperStatics_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            element: *mut core::ffi::c_void,
            value: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXamlBindingHelperStatics_Impl::SetDataTemplateComponent(
                    this,
                    core::mem::transmute_copy(&element),
                    core::mem::transmute_copy(&value),
                )
                .into()
            }
        }
        unsafe extern "system" fn SuspendRendering<
            Identity: IXamlBindingHelperStatics_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            target: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXamlBindingHelperStatics_Impl::SuspendRendering(
                    this,
                    core::mem::transmute_copy(&target),
                )
                .into()
            }
        }
        unsafe extern "system" fn ResumeRendering<
            Identity: IXamlBindingHelperStatics_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            target: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXamlBindingHelperStatics_Impl::ResumeRendering(
                    this,
                    core::mem::transmute_copy(&target),
                )
                .into()
            }
        }
        unsafe extern "system" fn ConvertValue<
            Identity: IXamlBindingHelperStatics_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            r#type: core::mem::MaybeUninit<crate::Windows::UI::Xaml::Interop::TypeName>,
            value: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlBindingHelperStatics_Impl::ConvertValue(
                    this,
                    core::mem::transmute(&r#type),
                    core::mem::transmute_copy(&value),
                ) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<
                Identity,
                IXamlBindingHelperStatics,
                OFFSET,
            >(),
            DataTemplateComponentProperty: 0,
            GetDataTemplateComponent: GetDataTemplateComponent::<Identity, OFFSET>,
            SetDataTemplateComponent: SetDataTemplateComponent::<Identity, OFFSET>,
            SuspendRendering: SuspendRendering::<Identity, OFFSET>,
            ResumeRendering: ResumeRendering::<Identity, OFFSET>,
            ConvertValue: ConvertValue::<Identity, OFFSET>,
            SetPropertyFromString: 0,
            SetPropertyFromBoolean: 0,
            SetPropertyFromChar16: 0,
            SetPropertyFromDateTime: 0,
            SetPropertyFromDouble: 0,
            SetPropertyFromInt32: 0,
            SetPropertyFromUInt32: 0,
            SetPropertyFromInt64: 0,
            SetPropertyFromUInt64: 0,
            SetPropertyFromSingle: 0,
            SetPropertyFromPoint: 0,
            SetPropertyFromRect: 0,
            SetPropertyFromSize: 0,
            SetPropertyFromTimeSpan: 0,
            SetPropertyFromByte: 0,
            SetPropertyFromUri: 0,
            SetPropertyFromObject: 0,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IXamlBindingHelperStatics as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IXamlBindingHelperStatics_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
    DataTemplateComponentProperty: usize,
    pub GetDataTemplateComponent: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SetDataTemplateComponent: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    #[cfg(feature = "UI_Composition")]
    pub SuspendRendering: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    #[cfg(not(feature = "UI_Composition"))]
    SuspendRendering: usize,
    #[cfg(feature = "UI_Composition")]
    pub ResumeRendering: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    #[cfg(not(feature = "UI_Composition"))]
    ResumeRendering: usize,
    pub ConvertValue: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        core::mem::MaybeUninit<crate::Windows::UI::Xaml::Interop::TypeName>,
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    SetPropertyFromString: usize,
    SetPropertyFromBoolean: usize,
    SetPropertyFromChar16: usize,
    SetPropertyFromDateTime: usize,
    SetPropertyFromDouble: usize,
    SetPropertyFromInt32: usize,
    SetPropertyFromUInt32: usize,
    SetPropertyFromInt64: usize,
    SetPropertyFromUInt64: usize,
    SetPropertyFromSingle: usize,
    SetPropertyFromPoint: usize,
    SetPropertyFromRect: usize,
    SetPropertyFromSize: usize,
    SetPropertyFromTimeSpan: usize,
    SetPropertyFromByte: usize,
    SetPropertyFromUri: usize,
    SetPropertyFromObject: usize,
}
windows_core::imp::define_interface!(
    IXamlCondition,
    IXamlCondition_Vtbl,
    0x9124118d_cdfa_545f_8c12_4cf7bcc5fffa
);
impl windows_core::RuntimeType for IXamlCondition {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
windows_core::imp::interface_hierarchy!(
    IXamlCondition,
    windows_core::IUnknown,
    windows_core::IInspectable
);
impl IXamlCondition {
    pub fn Evaluate(&self, argument: &windows_core::HSTRING) -> windows_core::Result<bool> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).Evaluate)(
                windows_core::Interface::as_raw(this),
                core::mem::transmute_copy(argument),
                &mut result__,
            )
            .map(|| result__)
        }
    }
}
impl windows_core::RuntimeName for IXamlCondition {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IXamlCondition";
}
pub trait IXamlCondition_Impl: windows_core::IUnknownImpl {
    fn Evaluate(&self, argument: &windows_core::HSTRING) -> windows_core::Result<bool>;
}
impl IXamlCondition_Vtbl {
    pub const fn new<Identity: IXamlCondition_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Evaluate<Identity: IXamlCondition_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            argument: *mut core::ffi::c_void,
            result__: *mut bool,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlCondition_Impl::Evaluate(this, core::mem::transmute(&argument)) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<Identity, IXamlCondition, OFFSET>(),
            Evaluate: Evaluate::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IXamlCondition as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IXamlCondition_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
    pub Evaluate: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut bool,
    ) -> windows_core::HRESULT,
}
windows_core::imp::define_interface!(
    IXamlMarkupHelper,
    IXamlMarkupHelper_Vtbl,
    0xcd677310_3b06_5a13_b31a_401849570858
);
impl windows_core::RuntimeType for IXamlMarkupHelper {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
impl windows_core::RuntimeName for IXamlMarkupHelper {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IXamlMarkupHelper";
}
pub trait IXamlMarkupHelper_Impl: windows_core::IUnknownImpl {}
impl IXamlMarkupHelper_Vtbl {
    pub const fn new<Identity: IXamlMarkupHelper_Impl, const OFFSET: isize>() -> Self {
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<Identity, IXamlMarkupHelper, OFFSET>(),
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IXamlMarkupHelper as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IXamlMarkupHelper_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
}
windows_core::imp::define_interface!(
    IXamlMarkupHelperStatics,
    IXamlMarkupHelperStatics_Vtbl,
    0xd9a0f6e3_c6cc_5cb6_8999_85788701f339
);
impl windows_core::RuntimeType for IXamlMarkupHelperStatics {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
impl windows_core::RuntimeName for IXamlMarkupHelperStatics {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IXamlMarkupHelperStatics";
}
pub trait IXamlMarkupHelperStatics_Impl: windows_core::IUnknownImpl {
    fn UnloadObject(
        &self,
        element: windows_core::Ref<super::DependencyObject>,
    ) -> windows_core::Result<()>;
}
impl IXamlMarkupHelperStatics_Vtbl {
    pub const fn new<Identity: IXamlMarkupHelperStatics_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn UnloadObject<
            Identity: IXamlMarkupHelperStatics_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            element: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXamlMarkupHelperStatics_Impl::UnloadObject(
                    this,
                    core::mem::transmute_copy(&element),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<
                Identity,
                IXamlMarkupHelperStatics,
                OFFSET,
            >(),
            UnloadObject: UnloadObject::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IXamlMarkupHelperStatics as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IXamlMarkupHelperStatics_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
    pub UnloadObject: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
windows_core::imp::define_interface!(
    IXamlMember,
    IXamlMember_Vtbl,
    0xbf3a2913_5c63_50ec_8660_61809be7b9b9
);
impl windows_core::RuntimeType for IXamlMember {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
windows_core::imp::interface_hierarchy!(
    IXamlMember,
    windows_core::IUnknown,
    windows_core::IInspectable
);
impl IXamlMember {
    pub fn IsAttachable(&self) -> windows_core::Result<bool> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).IsAttachable)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .map(|| result__)
        }
    }
    pub fn IsDependencyProperty(&self) -> windows_core::Result<bool> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).IsDependencyProperty)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .map(|| result__)
        }
    }
    pub fn IsReadOnly(&self) -> windows_core::Result<bool> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).IsReadOnly)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .map(|| result__)
        }
    }
    pub fn Name(&self) -> windows_core::Result<windows_core::HSTRING> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).Name)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .map(|| core::mem::transmute(result__))
        }
    }
    pub fn TargetType(&self) -> windows_core::Result<IXamlType> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).TargetType)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub fn Type(&self) -> windows_core::Result<IXamlType> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).Type)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub fn GetValue<P0>(&self, instance: P0) -> windows_core::Result<windows_core::IInspectable>
    where
        P0: windows_core::Param<windows_core::IInspectable>,
    {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).GetValue)(
                windows_core::Interface::as_raw(this),
                instance.param().abi(),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub fn SetValue<P0, P1>(&self, instance: P0, value: P1) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::IInspectable>,
        P1: windows_core::Param<windows_core::IInspectable>,
    {
        let this = self;
        unsafe {
            (windows_core::Interface::vtable(this).SetValue)(
                windows_core::Interface::as_raw(this),
                instance.param().abi(),
                value.param().abi(),
            )
            .ok()
        }
    }
}
impl windows_core::RuntimeName for IXamlMember {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IXamlMember";
}
pub trait IXamlMember_Impl: windows_core::IUnknownImpl {
    fn IsAttachable(&self) -> windows_core::Result<bool>;
    fn IsDependencyProperty(&self) -> windows_core::Result<bool>;
    fn IsReadOnly(&self) -> windows_core::Result<bool>;
    fn Name(&self) -> windows_core::Result<windows_core::HSTRING>;
    fn TargetType(&self) -> windows_core::Result<IXamlType>;
    fn Type(&self) -> windows_core::Result<IXamlType>;
    fn GetValue(
        &self,
        instance: windows_core::Ref<windows_core::IInspectable>,
    ) -> windows_core::Result<windows_core::IInspectable>;
    fn SetValue(
        &self,
        instance: windows_core::Ref<windows_core::IInspectable>,
        value: windows_core::Ref<windows_core::IInspectable>,
    ) -> windows_core::Result<()>;
}
impl IXamlMember_Vtbl {
    pub const fn new<Identity: IXamlMember_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn IsAttachable<Identity: IXamlMember_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            result__: *mut bool,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlMember_Impl::IsAttachable(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn IsDependencyProperty<
            Identity: IXamlMember_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            result__: *mut bool,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlMember_Impl::IsDependencyProperty(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn IsReadOnly<Identity: IXamlMember_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            result__: *mut bool,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlMember_Impl::IsReadOnly(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn Name<Identity: IXamlMember_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlMember_Impl::Name(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn TargetType<Identity: IXamlMember_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlMember_Impl::TargetType(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn Type<Identity: IXamlMember_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlMember_Impl::Type(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn GetValue<Identity: IXamlMember_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            instance: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlMember_Impl::GetValue(this, core::mem::transmute_copy(&instance)) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn SetValue<Identity: IXamlMember_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            instance: *mut core::ffi::c_void,
            value: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXamlMember_Impl::SetValue(
                    this,
                    core::mem::transmute_copy(&instance),
                    core::mem::transmute_copy(&value),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<Identity, IXamlMember, OFFSET>(),
            IsAttachable: IsAttachable::<Identity, OFFSET>,
            IsDependencyProperty: IsDependencyProperty::<Identity, OFFSET>,
            IsReadOnly: IsReadOnly::<Identity, OFFSET>,
            Name: Name::<Identity, OFFSET>,
            TargetType: TargetType::<Identity, OFFSET>,
            Type: Type::<Identity, OFFSET>,
            GetValue: GetValue::<Identity, OFFSET>,
            SetValue: SetValue::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IXamlMember as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IXamlMember_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
    pub IsAttachable:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
    pub IsDependencyProperty:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
    pub IsReadOnly:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
    pub Name: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub TargetType: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Type: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetValue: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SetValue: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
windows_core::imp::define_interface!(
    IXamlMetadataProvider,
    IXamlMetadataProvider_Vtbl,
    0xa96251f0_2214_5d53_8746_ce99a2593cd7
);
impl windows_core::RuntimeType for IXamlMetadataProvider {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
windows_core::imp::interface_hierarchy!(
    IXamlMetadataProvider,
    windows_core::IUnknown,
    windows_core::IInspectable
);
impl IXamlMetadataProvider {
    pub fn GetXamlType(
        &self,
        r#type: &crate::Windows::UI::Xaml::Interop::TypeName,
    ) -> windows_core::Result<IXamlType> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).GetXamlType)(
                windows_core::Interface::as_raw(this),
                core::mem::transmute_copy(r#type),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub fn GetXamlTypeByFullName(
        &self,
        fullname: &windows_core::HSTRING,
    ) -> windows_core::Result<IXamlType> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).GetXamlTypeByFullName)(
                windows_core::Interface::as_raw(this),
                core::mem::transmute_copy(fullname),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub fn GetXmlnsDefinitions(
        &self,
    ) -> windows_core::Result<windows_core::Array<XmlnsDefinition>> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::MaybeUninit::zeroed();
            (windows_core::Interface::vtable(this).GetXmlnsDefinitions)(
                windows_core::Interface::as_raw(this),
                windows_core::Array::<XmlnsDefinition>::set_abi_len(core::mem::transmute(
                    &mut result__,
                )),
                result__.as_mut_ptr() as *mut _ as _,
            )
            .map(|| result__.assume_init())
        }
    }
}
impl windows_core::RuntimeName for IXamlMetadataProvider {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IXamlMetadataProvider";
}
pub trait IXamlMetadataProvider_Impl: windows_core::IUnknownImpl {
    fn GetXamlType(
        &self,
        r#type: &crate::Windows::UI::Xaml::Interop::TypeName,
    ) -> windows_core::Result<IXamlType>;
    fn GetXamlTypeByFullName(
        &self,
        fullName: &windows_core::HSTRING,
    ) -> windows_core::Result<IXamlType>;
    fn GetXmlnsDefinitions(&self) -> windows_core::Result<windows_core::Array<XmlnsDefinition>>;
}
impl IXamlMetadataProvider_Vtbl {
    pub const fn new<Identity: IXamlMetadataProvider_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetXamlType<
            Identity: IXamlMetadataProvider_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            r#type: core::mem::MaybeUninit<crate::Windows::UI::Xaml::Interop::TypeName>,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlMetadataProvider_Impl::GetXamlType(this, core::mem::transmute(&r#type)) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn GetXamlTypeByFullName<
            Identity: IXamlMetadataProvider_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            fullname: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlMetadataProvider_Impl::GetXamlTypeByFullName(
                    this,
                    core::mem::transmute(&fullname),
                ) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn GetXmlnsDefinitions<
            Identity: IXamlMetadataProvider_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            result_size__: *mut u32,
            result__: *mut *mut core::mem::MaybeUninit<XmlnsDefinition>,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlMetadataProvider_Impl::GetXmlnsDefinitions(this) {
                    Ok(ok__) => {
                        let (ok_data__, ok_data_len__) = ok__.into_abi();
                        result__.write(core::mem::transmute(ok_data__));
                        result_size__.write(ok_data_len__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<Identity, IXamlMetadataProvider, OFFSET>(
            ),
            GetXamlType: GetXamlType::<Identity, OFFSET>,
            GetXamlTypeByFullName: GetXamlTypeByFullName::<Identity, OFFSET>,
            GetXmlnsDefinitions: GetXmlnsDefinitions::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IXamlMetadataProvider as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IXamlMetadataProvider_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
    pub GetXamlType: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        core::mem::MaybeUninit<crate::Windows::UI::Xaml::Interop::TypeName>,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetXamlTypeByFullName: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetXmlnsDefinitions: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut u32,
        *mut *mut core::mem::MaybeUninit<XmlnsDefinition>,
    ) -> windows_core::HRESULT,
}
windows_core::imp::define_interface!(
    IXamlReader,
    IXamlReader_Vtbl,
    0x54ce54c8_38c6_50d9_ac98_4b03eddbde9f
);
impl windows_core::RuntimeType for IXamlReader {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
impl windows_core::RuntimeName for IXamlReader {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IXamlReader";
}
pub trait IXamlReader_Impl: windows_core::IUnknownImpl {}
impl IXamlReader_Vtbl {
    pub const fn new<Identity: IXamlReader_Impl, const OFFSET: isize>() -> Self {
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<Identity, IXamlReader, OFFSET>(),
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IXamlReader as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IXamlReader_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
}
windows_core::imp::define_interface!(
    IXamlReaderStatics,
    IXamlReaderStatics_Vtbl,
    0x82a4cd9e_435e_5aeb_8c4f_300cece45cae
);
impl windows_core::RuntimeType for IXamlReaderStatics {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
impl windows_core::RuntimeName for IXamlReaderStatics {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IXamlReaderStatics";
}
pub trait IXamlReaderStatics_Impl: windows_core::IUnknownImpl {
    fn Load(
        &self,
        xaml: &windows_core::HSTRING,
    ) -> windows_core::Result<windows_core::IInspectable>;
    fn LoadWithInitialTemplateValidation(
        &self,
        xaml: &windows_core::HSTRING,
    ) -> windows_core::Result<windows_core::IInspectable>;
}
impl IXamlReaderStatics_Vtbl {
    pub const fn new<Identity: IXamlReaderStatics_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Load<Identity: IXamlReaderStatics_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            xaml: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlReaderStatics_Impl::Load(this, core::mem::transmute(&xaml)) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn LoadWithInitialTemplateValidation<
            Identity: IXamlReaderStatics_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            xaml: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlReaderStatics_Impl::LoadWithInitialTemplateValidation(
                    this,
                    core::mem::transmute(&xaml),
                ) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<Identity, IXamlReaderStatics, OFFSET>(),
            Load: Load::<Identity, OFFSET>,
            LoadWithInitialTemplateValidation: LoadWithInitialTemplateValidation::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IXamlReaderStatics as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IXamlReaderStatics_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
    pub Load: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub LoadWithInitialTemplateValidation: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
windows_core::imp::define_interface!(
    IXamlType,
    IXamlType_Vtbl,
    0xd24219df_7ec9_57f1_a27b_6af251d9c5bc
);
impl windows_core::RuntimeType for IXamlType {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
windows_core::imp::interface_hierarchy!(
    IXamlType,
    windows_core::IUnknown,
    windows_core::IInspectable
);
impl IXamlType {
    pub fn BaseType(&self) -> windows_core::Result<IXamlType> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).BaseType)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub fn ContentProperty(&self) -> windows_core::Result<IXamlMember> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).ContentProperty)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub fn FullName(&self) -> windows_core::Result<windows_core::HSTRING> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).FullName)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .map(|| core::mem::transmute(result__))
        }
    }
    pub fn IsArray(&self) -> windows_core::Result<bool> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).IsArray)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .map(|| result__)
        }
    }
    pub fn IsCollection(&self) -> windows_core::Result<bool> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).IsCollection)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .map(|| result__)
        }
    }
    pub fn IsConstructible(&self) -> windows_core::Result<bool> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).IsConstructible)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .map(|| result__)
        }
    }
    pub fn IsDictionary(&self) -> windows_core::Result<bool> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).IsDictionary)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .map(|| result__)
        }
    }
    pub fn IsMarkupExtension(&self) -> windows_core::Result<bool> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).IsMarkupExtension)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .map(|| result__)
        }
    }
    pub fn IsBindable(&self) -> windows_core::Result<bool> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).IsBindable)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .map(|| result__)
        }
    }
    pub fn ItemType(&self) -> windows_core::Result<IXamlType> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).ItemType)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub fn KeyType(&self) -> windows_core::Result<IXamlType> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).KeyType)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub fn BoxedType(&self) -> windows_core::Result<IXamlType> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).BoxedType)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub fn UnderlyingType(
        &self,
    ) -> windows_core::Result<crate::Windows::UI::Xaml::Interop::TypeName> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).UnderlyingType)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .map(|| core::mem::transmute(result__))
        }
    }
    pub fn ActivateInstance(&self) -> windows_core::Result<windows_core::IInspectable> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).ActivateInstance)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub fn CreateFromString(
        &self,
        value: &windows_core::HSTRING,
    ) -> windows_core::Result<windows_core::IInspectable> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).CreateFromString)(
                windows_core::Interface::as_raw(this),
                core::mem::transmute_copy(value),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub fn GetMember(&self, name: &windows_core::HSTRING) -> windows_core::Result<IXamlMember> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).GetMember)(
                windows_core::Interface::as_raw(this),
                core::mem::transmute_copy(name),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub fn AddToVector<P0, P1>(&self, instance: P0, value: P1) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::IInspectable>,
        P1: windows_core::Param<windows_core::IInspectable>,
    {
        let this = self;
        unsafe {
            (windows_core::Interface::vtable(this).AddToVector)(
                windows_core::Interface::as_raw(this),
                instance.param().abi(),
                value.param().abi(),
            )
            .ok()
        }
    }
    pub fn AddToMap<P0, P1, P2>(&self, instance: P0, key: P1, value: P2) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::IInspectable>,
        P1: windows_core::Param<windows_core::IInspectable>,
        P2: windows_core::Param<windows_core::IInspectable>,
    {
        let this = self;
        unsafe {
            (windows_core::Interface::vtable(this).AddToMap)(
                windows_core::Interface::as_raw(this),
                instance.param().abi(),
                key.param().abi(),
                value.param().abi(),
            )
            .ok()
        }
    }
    pub fn RunInitializer(&self) -> windows_core::Result<()> {
        let this = self;
        unsafe {
            (windows_core::Interface::vtable(this).RunInitializer)(windows_core::Interface::as_raw(
                this,
            ))
            .ok()
        }
    }
}
impl windows_core::RuntimeName for IXamlType {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IXamlType";
}
pub trait IXamlType_Impl: windows_core::IUnknownImpl {
    fn BaseType(&self) -> windows_core::Result<IXamlType>;
    fn ContentProperty(&self) -> windows_core::Result<IXamlMember>;
    fn FullName(&self) -> windows_core::Result<windows_core::HSTRING>;
    fn IsArray(&self) -> windows_core::Result<bool>;
    fn IsCollection(&self) -> windows_core::Result<bool>;
    fn IsConstructible(&self) -> windows_core::Result<bool>;
    fn IsDictionary(&self) -> windows_core::Result<bool>;
    fn IsMarkupExtension(&self) -> windows_core::Result<bool>;
    fn IsBindable(&self) -> windows_core::Result<bool>;
    fn ItemType(&self) -> windows_core::Result<IXamlType>;
    fn KeyType(&self) -> windows_core::Result<IXamlType>;
    fn BoxedType(&self) -> windows_core::Result<IXamlType>;
    fn UnderlyingType(&self) -> windows_core::Result<crate::Windows::UI::Xaml::Interop::TypeName>;
    fn ActivateInstance(&self) -> windows_core::Result<windows_core::IInspectable>;
    fn CreateFromString(
        &self,
        value: &windows_core::HSTRING,
    ) -> windows_core::Result<windows_core::IInspectable>;
    fn GetMember(&self, name: &windows_core::HSTRING) -> windows_core::Result<IXamlMember>;
    fn AddToVector(
        &self,
        instance: windows_core::Ref<windows_core::IInspectable>,
        value: windows_core::Ref<windows_core::IInspectable>,
    ) -> windows_core::Result<()>;
    fn AddToMap(
        &self,
        instance: windows_core::Ref<windows_core::IInspectable>,
        key: windows_core::Ref<windows_core::IInspectable>,
        value: windows_core::Ref<windows_core::IInspectable>,
    ) -> windows_core::Result<()>;
    fn RunInitializer(&self) -> windows_core::Result<()>;
}
impl IXamlType_Vtbl {
    pub const fn new<Identity: IXamlType_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn BaseType<Identity: IXamlType_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlType_Impl::BaseType(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn ContentProperty<Identity: IXamlType_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlType_Impl::ContentProperty(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn FullName<Identity: IXamlType_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlType_Impl::FullName(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn IsArray<Identity: IXamlType_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            result__: *mut bool,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlType_Impl::IsArray(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn IsCollection<Identity: IXamlType_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            result__: *mut bool,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlType_Impl::IsCollection(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn IsConstructible<Identity: IXamlType_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            result__: *mut bool,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlType_Impl::IsConstructible(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn IsDictionary<Identity: IXamlType_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            result__: *mut bool,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlType_Impl::IsDictionary(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn IsMarkupExtension<
            Identity: IXamlType_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            result__: *mut bool,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlType_Impl::IsMarkupExtension(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn IsBindable<Identity: IXamlType_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            result__: *mut bool,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlType_Impl::IsBindable(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn ItemType<Identity: IXamlType_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlType_Impl::ItemType(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn KeyType<Identity: IXamlType_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlType_Impl::KeyType(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn BoxedType<Identity: IXamlType_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlType_Impl::BoxedType(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn UnderlyingType<Identity: IXamlType_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            result__: *mut core::mem::MaybeUninit<crate::Windows::UI::Xaml::Interop::TypeName>,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlType_Impl::UnderlyingType(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn ActivateInstance<
            Identity: IXamlType_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlType_Impl::ActivateInstance(this) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn CreateFromString<
            Identity: IXamlType_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            value: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlType_Impl::CreateFromString(this, core::mem::transmute(&value)) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn GetMember<Identity: IXamlType_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            name: *mut core::ffi::c_void,
            result__: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlType_Impl::GetMember(this, core::mem::transmute(&name)) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn AddToVector<Identity: IXamlType_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            instance: *mut core::ffi::c_void,
            value: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXamlType_Impl::AddToVector(
                    this,
                    core::mem::transmute_copy(&instance),
                    core::mem::transmute_copy(&value),
                )
                .into()
            }
        }
        unsafe extern "system" fn AddToMap<Identity: IXamlType_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            instance: *mut core::ffi::c_void,
            key: *mut core::ffi::c_void,
            value: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXamlType_Impl::AddToMap(
                    this,
                    core::mem::transmute_copy(&instance),
                    core::mem::transmute_copy(&key),
                    core::mem::transmute_copy(&value),
                )
                .into()
            }
        }
        unsafe extern "system" fn RunInitializer<Identity: IXamlType_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXamlType_Impl::RunInitializer(this).into()
            }
        }
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<Identity, IXamlType, OFFSET>(),
            BaseType: BaseType::<Identity, OFFSET>,
            ContentProperty: ContentProperty::<Identity, OFFSET>,
            FullName: FullName::<Identity, OFFSET>,
            IsArray: IsArray::<Identity, OFFSET>,
            IsCollection: IsCollection::<Identity, OFFSET>,
            IsConstructible: IsConstructible::<Identity, OFFSET>,
            IsDictionary: IsDictionary::<Identity, OFFSET>,
            IsMarkupExtension: IsMarkupExtension::<Identity, OFFSET>,
            IsBindable: IsBindable::<Identity, OFFSET>,
            ItemType: ItemType::<Identity, OFFSET>,
            KeyType: KeyType::<Identity, OFFSET>,
            BoxedType: BoxedType::<Identity, OFFSET>,
            UnderlyingType: UnderlyingType::<Identity, OFFSET>,
            ActivateInstance: ActivateInstance::<Identity, OFFSET>,
            CreateFromString: CreateFromString::<Identity, OFFSET>,
            GetMember: GetMember::<Identity, OFFSET>,
            AddToVector: AddToVector::<Identity, OFFSET>,
            AddToMap: AddToMap::<Identity, OFFSET>,
            RunInitializer: RunInitializer::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IXamlType as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IXamlType_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
    pub BaseType: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub ContentProperty: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub FullName: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub IsArray:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
    pub IsCollection:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
    pub IsConstructible:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
    pub IsDictionary:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
    pub IsMarkupExtension:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
    pub IsBindable:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
    pub ItemType: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub KeyType: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub BoxedType: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub UnderlyingType: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::mem::MaybeUninit<crate::Windows::UI::Xaml::Interop::TypeName>,
    ) -> windows_core::HRESULT,
    pub ActivateInstance: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub CreateFromString: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetMember: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub AddToVector: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub AddToMap: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub RunInitializer: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
}
windows_core::imp::define_interface!(
    IXamlTypeResolver,
    IXamlTypeResolver_Vtbl,
    0x3fa15615_cacf_547f_b1ed_89dae8c67452
);
impl windows_core::RuntimeType for IXamlTypeResolver {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_interface::<Self>();
}
windows_core::imp::interface_hierarchy!(
    IXamlTypeResolver,
    windows_core::IUnknown,
    windows_core::IInspectable
);
impl IXamlTypeResolver {
    pub fn Resolve(
        &self,
        qualifiedtypename: &windows_core::HSTRING,
    ) -> windows_core::Result<crate::Windows::UI::Xaml::Interop::TypeName> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).Resolve)(
                windows_core::Interface::as_raw(this),
                core::mem::transmute_copy(qualifiedtypename),
                &mut result__,
            )
            .map(|| core::mem::transmute(result__))
        }
    }
}
impl windows_core::RuntimeName for IXamlTypeResolver {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.IXamlTypeResolver";
}
pub trait IXamlTypeResolver_Impl: windows_core::IUnknownImpl {
    fn Resolve(
        &self,
        qualifiedTypeName: &windows_core::HSTRING,
    ) -> windows_core::Result<crate::Windows::UI::Xaml::Interop::TypeName>;
}
impl IXamlTypeResolver_Vtbl {
    pub const fn new<Identity: IXamlTypeResolver_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Resolve<Identity: IXamlTypeResolver_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            qualifiedtypename: *mut core::ffi::c_void,
            result__: *mut core::mem::MaybeUninit<crate::Windows::UI::Xaml::Interop::TypeName>,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IXamlTypeResolver_Impl::Resolve(
                    this,
                    core::mem::transmute(&qualifiedtypename),
                ) {
                    Ok(ok__) => {
                        result__.write(core::mem::transmute_copy(&ok__));
                        core::mem::forget(ok__);
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows_core::IInspectable_Vtbl::new::<Identity, IXamlTypeResolver, OFFSET>(),
            Resolve: Resolve::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IXamlTypeResolver as windows_core::Interface>::IID
    }
}
#[repr(C)]
#[doc(hidden)]
pub struct IXamlTypeResolver_Vtbl {
    pub base__: windows_core::IInspectable_Vtbl,
    pub Resolve: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut core::mem::MaybeUninit<crate::Windows::UI::Xaml::Interop::TypeName>,
    ) -> windows_core::HRESULT,
}
#[repr(transparent)]
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct MarkupExtension(windows_core::IUnknown);
windows_core::imp::interface_hierarchy!(
    MarkupExtension,
    windows_core::IUnknown,
    windows_core::IInspectable
);
impl MarkupExtension {
    pub fn new() -> windows_core::Result<MarkupExtension> {
        Self::IMarkupExtensionFactory(|this| unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).CreateInstance)(
                windows_core::Interface::as_raw(this),
                core::ptr::null_mut(),
                &mut core::ptr::null_mut(),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        })
    }
    pub fn ProvideValue(&self) -> windows_core::Result<windows_core::IInspectable> {
        let this = &windows_core::Interface::cast::<IMarkupExtensionOverrides>(self)?;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).ProvideValue)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    fn IMarkupExtensionFactory<
        R,
        F: FnOnce(&IMarkupExtensionFactory) -> windows_core::Result<R>,
    >(
        callback: F,
    ) -> windows_core::Result<R> {
        static SHARED: windows_core::imp::FactoryCache<MarkupExtension, IMarkupExtensionFactory> =
            windows_core::imp::FactoryCache::new();
        SHARED.call(callback)
    }
}
impl windows_core::RuntimeType for MarkupExtension {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_class::<Self, IMarkupExtension>();
}
unsafe impl windows_core::Interface for MarkupExtension {
    type Vtable = <IMarkupExtension as windows_core::Interface>::Vtable;
    const IID: windows_core::GUID = <IMarkupExtension as windows_core::Interface>::IID;
}
impl windows_core::RuntimeName for MarkupExtension {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.MarkupExtension";
}
unsafe impl Send for MarkupExtension {}
unsafe impl Sync for MarkupExtension {}
#[repr(transparent)]
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ProvideValueTargetProperty(windows_core::IUnknown);
windows_core::imp::interface_hierarchy!(
    ProvideValueTargetProperty,
    windows_core::IUnknown,
    windows_core::IInspectable
);
impl ProvideValueTargetProperty {
    pub fn new() -> windows_core::Result<Self> {
        Self::IActivationFactory(|f| f.ActivateInstance::<Self>())
    }
    fn IActivationFactory<
        R,
        F: FnOnce(&windows_core::imp::IGenericFactory) -> windows_core::Result<R>,
    >(
        callback: F,
    ) -> windows_core::Result<R> {
        static SHARED: windows_core::imp::FactoryCache<
            ProvideValueTargetProperty,
            windows_core::imp::IGenericFactory,
        > = windows_core::imp::FactoryCache::new();
        SHARED.call(callback)
    }
    pub fn Name(&self) -> windows_core::Result<windows_core::HSTRING> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).Name)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .map(|| core::mem::transmute(result__))
        }
    }
    pub fn Type(&self) -> windows_core::Result<crate::Windows::UI::Xaml::Interop::TypeName> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).Type)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .map(|| core::mem::transmute(result__))
        }
    }
    pub fn DeclaringType(
        &self,
    ) -> windows_core::Result<crate::Windows::UI::Xaml::Interop::TypeName> {
        let this = self;
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).DeclaringType)(
                windows_core::Interface::as_raw(this),
                &mut result__,
            )
            .map(|| core::mem::transmute(result__))
        }
    }
}
impl windows_core::RuntimeType for ProvideValueTargetProperty {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_class::<Self, IProvideValueTargetProperty>();
}
unsafe impl windows_core::Interface for ProvideValueTargetProperty {
    type Vtable = <IProvideValueTargetProperty as windows_core::Interface>::Vtable;
    const IID: windows_core::GUID = <IProvideValueTargetProperty as windows_core::Interface>::IID;
}
impl windows_core::RuntimeName for ProvideValueTargetProperty {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.ProvideValueTargetProperty";
}
unsafe impl Send for ProvideValueTargetProperty {}
unsafe impl Sync for ProvideValueTargetProperty {}
#[repr(transparent)]
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct XamlBinaryWriter(windows_core::IUnknown);
windows_core::imp::interface_hierarchy!(
    XamlBinaryWriter,
    windows_core::IUnknown,
    windows_core::IInspectable
);
impl XamlBinaryWriter {
    pub fn Write<P0, P1, P2>(
        inputstreams: P0,
        outputstreams: P1,
        xamlmetadataprovider: P2,
    ) -> windows_core::Result<XamlBinaryWriterErrorInformation>
    where
        P0: windows_core::Param<
            windows_collections::IVector<windows::Storage::Streams::IRandomAccessStream>,
        >,
        P1: windows_core::Param<
            windows_collections::IVector<windows::Storage::Streams::IRandomAccessStream>,
        >,
        P2: windows_core::Param<IXamlMetadataProvider>,
    {
        Self::IXamlBinaryWriterStatics(|this| unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).Write)(
                windows_core::Interface::as_raw(this),
                inputstreams.param().abi(),
                outputstreams.param().abi(),
                xamlmetadataprovider.param().abi(),
                &mut result__,
            )
            .map(|| result__)
        })
    }
    fn IXamlBinaryWriterStatics<
        R,
        F: FnOnce(&IXamlBinaryWriterStatics) -> windows_core::Result<R>,
    >(
        callback: F,
    ) -> windows_core::Result<R> {
        static SHARED: windows_core::imp::FactoryCache<XamlBinaryWriter, IXamlBinaryWriterStatics> =
            windows_core::imp::FactoryCache::new();
        SHARED.call(callback)
    }
}
impl windows_core::RuntimeType for XamlBinaryWriter {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_class::<Self, IXamlBinaryWriter>();
}
unsafe impl windows_core::Interface for XamlBinaryWriter {
    type Vtable = <IXamlBinaryWriter as windows_core::Interface>::Vtable;
    const IID: windows_core::GUID = <IXamlBinaryWriter as windows_core::Interface>::IID;
}
impl windows_core::RuntimeName for XamlBinaryWriter {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.XamlBinaryWriter";
}
unsafe impl Send for XamlBinaryWriter {}
unsafe impl Sync for XamlBinaryWriter {}
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct XamlBinaryWriterErrorInformation {
    pub InputStreamIndex: u32,
    pub LineNumber: u32,
    pub LinePosition: u32,
}
impl windows_core::TypeKind for XamlBinaryWriterErrorInformation {
    type TypeKind = windows_core::CopyType;
}
impl windows_core::RuntimeType for XamlBinaryWriterErrorInformation {
    const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::from_slice(
        b"struct(Microsoft.UI.Xaml.Markup.XamlBinaryWriterErrorInformation;u4;u4;u4)",
    );
}
#[repr(transparent)]
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct XamlBindingHelper(windows_core::IUnknown);
windows_core::imp::interface_hierarchy!(
    XamlBindingHelper,
    windows_core::IUnknown,
    windows_core::IInspectable
);
impl XamlBindingHelper {
    pub fn GetDataTemplateComponent<P0>(element: P0) -> windows_core::Result<IDataTemplateComponent>
    where
        P0: windows_core::Param<super::DependencyObject>,
    {
        Self::IXamlBindingHelperStatics(|this| unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).GetDataTemplateComponent)(
                windows_core::Interface::as_raw(this),
                element.param().abi(),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        })
    }
    pub fn SetDataTemplateComponent<P0, P1>(element: P0, value: P1) -> windows_core::Result<()>
    where
        P0: windows_core::Param<super::DependencyObject>,
        P1: windows_core::Param<IDataTemplateComponent>,
    {
        Self::IXamlBindingHelperStatics(|this| unsafe {
            (windows_core::Interface::vtable(this).SetDataTemplateComponent)(
                windows_core::Interface::as_raw(this),
                element.param().abi(),
                value.param().abi(),
            )
            .ok()
        })
    }
    #[cfg(feature = "UI_Composition")]
    pub fn SuspendRendering<P0>(target: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<super::UIElement>,
    {
        Self::IXamlBindingHelperStatics(|this| unsafe {
            (windows_core::Interface::vtable(this).SuspendRendering)(
                windows_core::Interface::as_raw(this),
                target.param().abi(),
            )
            .ok()
        })
    }
    #[cfg(feature = "UI_Composition")]
    pub fn ResumeRendering<P0>(target: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<super::UIElement>,
    {
        Self::IXamlBindingHelperStatics(|this| unsafe {
            (windows_core::Interface::vtable(this).ResumeRendering)(
                windows_core::Interface::as_raw(this),
                target.param().abi(),
            )
            .ok()
        })
    }
    pub fn ConvertValue<P1>(
        r#type: &crate::Windows::UI::Xaml::Interop::TypeName,
        value: P1,
    ) -> windows_core::Result<windows_core::IInspectable>
    where
        P1: windows_core::Param<windows_core::IInspectable>,
    {
        Self::IXamlBindingHelperStatics(|this| unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).ConvertValue)(
                windows_core::Interface::as_raw(this),
                core::mem::transmute_copy(r#type),
                value.param().abi(),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        })
    }
    fn IXamlBindingHelperStatics<
        R,
        F: FnOnce(&IXamlBindingHelperStatics) -> windows_core::Result<R>,
    >(
        callback: F,
    ) -> windows_core::Result<R> {
        static SHARED: windows_core::imp::FactoryCache<
            XamlBindingHelper,
            IXamlBindingHelperStatics,
        > = windows_core::imp::FactoryCache::new();
        SHARED.call(callback)
    }
}
impl windows_core::RuntimeType for XamlBindingHelper {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_class::<Self, IXamlBindingHelper>();
}
unsafe impl windows_core::Interface for XamlBindingHelper {
    type Vtable = <IXamlBindingHelper as windows_core::Interface>::Vtable;
    const IID: windows_core::GUID = <IXamlBindingHelper as windows_core::Interface>::IID;
}
impl windows_core::RuntimeName for XamlBindingHelper {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.XamlBindingHelper";
}
unsafe impl Send for XamlBindingHelper {}
unsafe impl Sync for XamlBindingHelper {}
#[repr(transparent)]
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct XamlMarkupHelper(windows_core::IUnknown);
windows_core::imp::interface_hierarchy!(
    XamlMarkupHelper,
    windows_core::IUnknown,
    windows_core::IInspectable
);
impl XamlMarkupHelper {
    pub fn UnloadObject<P0>(element: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<super::DependencyObject>,
    {
        Self::IXamlMarkupHelperStatics(|this| unsafe {
            (windows_core::Interface::vtable(this).UnloadObject)(
                windows_core::Interface::as_raw(this),
                element.param().abi(),
            )
            .ok()
        })
    }
    fn IXamlMarkupHelperStatics<
        R,
        F: FnOnce(&IXamlMarkupHelperStatics) -> windows_core::Result<R>,
    >(
        callback: F,
    ) -> windows_core::Result<R> {
        static SHARED: windows_core::imp::FactoryCache<XamlMarkupHelper, IXamlMarkupHelperStatics> =
            windows_core::imp::FactoryCache::new();
        SHARED.call(callback)
    }
}
impl windows_core::RuntimeType for XamlMarkupHelper {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_class::<Self, IXamlMarkupHelper>();
}
unsafe impl windows_core::Interface for XamlMarkupHelper {
    type Vtable = <IXamlMarkupHelper as windows_core::Interface>::Vtable;
    const IID: windows_core::GUID = <IXamlMarkupHelper as windows_core::Interface>::IID;
}
impl windows_core::RuntimeName for XamlMarkupHelper {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.XamlMarkupHelper";
}
unsafe impl Send for XamlMarkupHelper {}
unsafe impl Sync for XamlMarkupHelper {}
#[repr(transparent)]
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct XamlReader(windows_core::IUnknown);
windows_core::imp::interface_hierarchy!(
    XamlReader,
    windows_core::IUnknown,
    windows_core::IInspectable
);
impl XamlReader {
    pub fn Load(xaml: &windows_core::HSTRING) -> windows_core::Result<windows_core::IInspectable> {
        Self::IXamlReaderStatics(|this| unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).Load)(
                windows_core::Interface::as_raw(this),
                core::mem::transmute_copy(xaml),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        })
    }
    pub fn LoadWithInitialTemplateValidation(
        xaml: &windows_core::HSTRING,
    ) -> windows_core::Result<windows_core::IInspectable> {
        Self::IXamlReaderStatics(|this| unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(this).LoadWithInitialTemplateValidation)(
                windows_core::Interface::as_raw(this),
                core::mem::transmute_copy(xaml),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        })
    }
    fn IXamlReaderStatics<R, F: FnOnce(&IXamlReaderStatics) -> windows_core::Result<R>>(
        callback: F,
    ) -> windows_core::Result<R> {
        static SHARED: windows_core::imp::FactoryCache<XamlReader, IXamlReaderStatics> =
            windows_core::imp::FactoryCache::new();
        SHARED.call(callback)
    }
}
impl windows_core::RuntimeType for XamlReader {
    const SIGNATURE: windows_core::imp::ConstBuffer =
        windows_core::imp::ConstBuffer::for_class::<Self, IXamlReader>();
}
unsafe impl windows_core::Interface for XamlReader {
    type Vtable = <IXamlReader as windows_core::Interface>::Vtable;
    const IID: windows_core::GUID = <IXamlReader as windows_core::Interface>::IID;
}
impl windows_core::RuntimeName for XamlReader {
    const NAME: &'static str = "Microsoft.UI.Xaml.Markup.XamlReader";
}
unsafe impl Send for XamlReader {}
unsafe impl Sync for XamlReader {}
#[repr(C)]
#[derive(Clone, Debug, Default, PartialEq)]
pub struct XmlnsDefinition {
    pub XmlNamespace: windows_core::HSTRING,
    pub Namespace: windows_core::HSTRING,
}
impl windows_core::TypeKind for XmlnsDefinition {
    type TypeKind = windows_core::CloneType;
}
impl windows_core::RuntimeType for XmlnsDefinition {
    const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::from_slice(
        b"struct(Microsoft.UI.Xaml.Markup.XmlnsDefinition;string;string)",
    );
}