mozilla-central/__GENERATED__/dist/xpcrs/rt/nsIWebAuthnService.rs

Copy as Markdown

Other Tools

//
// DO NOT EDIT. THIS FILE IS GENERATED FROM $SRCDIR/dom/webauthn/nsIWebAuthnService.idl
//
/// `interface nsICredentialParameters : nsISupports`
///
// The actual type definition for the interface. This struct has methods
// declared on it which will call through its vtable. You never want to pass
// this type around by value, always pass it behind a reference.
#[repr(C)]
pub struct nsICredentialParameters {
vtable: &'static nsICredentialParametersVTable,
/// This field is a phantomdata to ensure that the VTable type and any
/// struct containing it is not safe to send across threads by default, as
/// XPCOM is generally not threadsafe.
///
/// If this type is marked as [rust_sync], there will be explicit `Send` and
/// `Sync` implementations on this type, which will override the inherited
/// negative impls from `Rc`.
__nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
// Make the rust compiler aware that there might be interior mutability
// in what actually implements the interface. This works around UB
// that a rust lint would make blatantly obvious, but doesn't exist.
// This prevents optimizations, but those optimizations weren't available
// before rustc switched to LLVM 16, and they now cause problems because
// of the UB.
// Until there's a lint available to find all our UB, it's simpler to
// avoid the UB in the first place, at the cost of preventing optimizations
// in places that don't cause UB. But again, those optimizations weren't
// available before.
__maybe_interior_mutability: ::std::cell::UnsafeCell<[u8; 0]>,
}
// Implementing XpCom for an interface exposes its IID, which allows for easy
// use of the `.query_interface<T>` helper method. This also defines that
// method for nsICredentialParameters.
unsafe impl XpCom for nsICredentialParameters {
const IID: nsIID = nsID(0x6c4ecd9f, 0x57c0, 0x4d7d,
[0x80, 0x80, 0xbf, 0x6e, 0x4d, 0x49, 0x9f, 0x8f]);
}
// We need to implement the RefCounted trait so we can be used with `RefPtr`.
// This trait teaches `RefPtr` how to manage our memory.
unsafe impl RefCounted for nsICredentialParameters {
#[inline]
unsafe fn addref(&self) {
self.AddRef();
}
#[inline]
unsafe fn release(&self) {
self.Release();
}
}
// This trait is implemented on all types which can be coerced to from nsICredentialParameters.
// It is used in the implementation of `fn coerce<T>`. We hide it from the
// documentation, because it clutters it up a lot.
#[doc(hidden)]
pub trait nsICredentialParametersCoerce {
/// Cheaply cast a value of this type from a `nsICredentialParameters`.
fn coerce_from(v: &nsICredentialParameters) -> &Self;
}
// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsICredentialParametersCoerce for nsICredentialParameters {
#[inline]
fn coerce_from(v: &nsICredentialParameters) -> &Self {
v
}
}
impl nsICredentialParameters {
/// Cast this `nsICredentialParameters` to one of its base interfaces.
#[inline]
pub fn coerce<T: nsICredentialParametersCoerce>(&self) -> &T {
T::coerce_from(self)
}
}
// Every interface struct type implements `Deref` to its base interface. This
// causes methods on the base interfaces to be directly avaliable on the
// object. For example, you can call `.AddRef` or `.QueryInterface` directly
// on any interface which inherits from `nsISupports`.
impl ::std::ops::Deref for nsICredentialParameters {
type Target = nsISupports;
#[inline]
fn deref(&self) -> &nsISupports {
unsafe {
::std::mem::transmute(self)
}
}
}
// Ensure we can use .coerce() to cast to our base types as well. Any type which
// our base interface can coerce from should be coercable from us as well.
impl<T: nsISupportsCoerce> nsICredentialParametersCoerce for T {
#[inline]
fn coerce_from(v: &nsICredentialParameters) -> &Self {
T::coerce_from(v)
}
}
// This struct represents the interface's VTable. A pointer to a statically
// allocated version of this struct is at the beginning of every nsICredentialParameters
// object. It contains one pointer field for each method in the interface. In
// the case where we can't generate a binding for a method, we include a void
// pointer.
#[doc(hidden)]
#[repr(C)]
pub struct nsICredentialParametersVTable {
/// We need to include the members from the base interface's vtable at the start
/// of the VTable definition.
pub __base: nsISupportsVTable,
/* readonly attribute ACString credentialId; */
pub GetCredentialId: unsafe extern "system" fn (this: *const nsICredentialParameters, aCredentialId: *mut ::nsstring::nsACString) -> ::nserror::nsresult,
/* readonly attribute boolean isResidentCredential; */
pub GetIsResidentCredential: unsafe extern "system" fn (this: *const nsICredentialParameters, aIsResidentCredential: *mut bool) -> ::nserror::nsresult,
/* readonly attribute ACString rpId; */
pub GetRpId: unsafe extern "system" fn (this: *const nsICredentialParameters, aRpId: *mut ::nsstring::nsACString) -> ::nserror::nsresult,
/* readonly attribute ACString privateKey; */
pub GetPrivateKey: unsafe extern "system" fn (this: *const nsICredentialParameters, aPrivateKey: *mut ::nsstring::nsACString) -> ::nserror::nsresult,
/* readonly attribute ACString userHandle; */
pub GetUserHandle: unsafe extern "system" fn (this: *const nsICredentialParameters, aUserHandle: *mut ::nsstring::nsACString) -> ::nserror::nsresult,
/* readonly attribute uint32_t signCount; */
pub GetSignCount: unsafe extern "system" fn (this: *const nsICredentialParameters, aSignCount: *mut u32) -> ::nserror::nsresult,
}
// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsICredentialParameters {
/// `readonly attribute ACString credentialId;`
#[inline]
pub unsafe fn GetCredentialId(&self, aCredentialId: *mut ::nsstring::nsACString) -> ::nserror::nsresult {
((*self.vtable).GetCredentialId)(self, aCredentialId)
}
/// `readonly attribute boolean isResidentCredential;`
#[inline]
pub unsafe fn GetIsResidentCredential(&self, aIsResidentCredential: *mut bool) -> ::nserror::nsresult {
((*self.vtable).GetIsResidentCredential)(self, aIsResidentCredential)
}
/// `readonly attribute ACString rpId;`
#[inline]
pub unsafe fn GetRpId(&self, aRpId: *mut ::nsstring::nsACString) -> ::nserror::nsresult {
((*self.vtable).GetRpId)(self, aRpId)
}
/// `readonly attribute ACString privateKey;`
#[inline]
pub unsafe fn GetPrivateKey(&self, aPrivateKey: *mut ::nsstring::nsACString) -> ::nserror::nsresult {
((*self.vtable).GetPrivateKey)(self, aPrivateKey)
}
/// `readonly attribute ACString userHandle;`
#[inline]
pub unsafe fn GetUserHandle(&self, aUserHandle: *mut ::nsstring::nsACString) -> ::nserror::nsresult {
((*self.vtable).GetUserHandle)(self, aUserHandle)
}
/// `readonly attribute uint32_t signCount;`
#[inline]
pub unsafe fn GetSignCount(&self, aSignCount: *mut u32) -> ::nserror::nsresult {
((*self.vtable).GetSignCount)(self, aSignCount)
}
}
/// `interface nsIWebAuthnAutoFillEntry : nsISupports`
///
// The actual type definition for the interface. This struct has methods
// declared on it which will call through its vtable. You never want to pass
// this type around by value, always pass it behind a reference.
#[repr(C)]
pub struct nsIWebAuthnAutoFillEntry {
vtable: &'static nsIWebAuthnAutoFillEntryVTable,
/// This field is a phantomdata to ensure that the VTable type and any
/// struct containing it is not safe to send across threads by default, as
/// XPCOM is generally not threadsafe.
///
/// If this type is marked as [rust_sync], there will be explicit `Send` and
/// `Sync` implementations on this type, which will override the inherited
/// negative impls from `Rc`.
__nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
// Make the rust compiler aware that there might be interior mutability
// in what actually implements the interface. This works around UB
// that a rust lint would make blatantly obvious, but doesn't exist.
// This prevents optimizations, but those optimizations weren't available
// before rustc switched to LLVM 16, and they now cause problems because
// of the UB.
// Until there's a lint available to find all our UB, it's simpler to
// avoid the UB in the first place, at the cost of preventing optimizations
// in places that don't cause UB. But again, those optimizations weren't
// available before.
__maybe_interior_mutability: ::std::cell::UnsafeCell<[u8; 0]>,
}
// Implementing XpCom for an interface exposes its IID, which allows for easy
// use of the `.query_interface<T>` helper method. This also defines that
// method for nsIWebAuthnAutoFillEntry.
unsafe impl XpCom for nsIWebAuthnAutoFillEntry {
const IID: nsIID = nsID(0x686d552e, 0xa39d, 0x4ba2,
[0x81, 0x27, 0xfa, 0xca, 0x54, 0x27, 0x40, 0x39]);
}
// We need to implement the RefCounted trait so we can be used with `RefPtr`.
// This trait teaches `RefPtr` how to manage our memory.
unsafe impl RefCounted for nsIWebAuthnAutoFillEntry {
#[inline]
unsafe fn addref(&self) {
self.AddRef();
}
#[inline]
unsafe fn release(&self) {
self.Release();
}
}
// This trait is implemented on all types which can be coerced to from nsIWebAuthnAutoFillEntry.
// It is used in the implementation of `fn coerce<T>`. We hide it from the
// documentation, because it clutters it up a lot.
#[doc(hidden)]
pub trait nsIWebAuthnAutoFillEntryCoerce {
/// Cheaply cast a value of this type from a `nsIWebAuthnAutoFillEntry`.
fn coerce_from(v: &nsIWebAuthnAutoFillEntry) -> &Self;
}
// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsIWebAuthnAutoFillEntryCoerce for nsIWebAuthnAutoFillEntry {
#[inline]
fn coerce_from(v: &nsIWebAuthnAutoFillEntry) -> &Self {
v
}
}
impl nsIWebAuthnAutoFillEntry {
/// Cast this `nsIWebAuthnAutoFillEntry` to one of its base interfaces.
#[inline]
pub fn coerce<T: nsIWebAuthnAutoFillEntryCoerce>(&self) -> &T {
T::coerce_from(self)
}
}
// Every interface struct type implements `Deref` to its base interface. This
// causes methods on the base interfaces to be directly avaliable on the
// object. For example, you can call `.AddRef` or `.QueryInterface` directly
// on any interface which inherits from `nsISupports`.
impl ::std::ops::Deref for nsIWebAuthnAutoFillEntry {
type Target = nsISupports;
#[inline]
fn deref(&self) -> &nsISupports {
unsafe {
::std::mem::transmute(self)
}
}
}
// Ensure we can use .coerce() to cast to our base types as well. Any type which
// our base interface can coerce from should be coercable from us as well.
impl<T: nsISupportsCoerce> nsIWebAuthnAutoFillEntryCoerce for T {
#[inline]
fn coerce_from(v: &nsIWebAuthnAutoFillEntry) -> &Self {
T::coerce_from(v)
}
}
// This struct represents the interface's VTable. A pointer to a statically
// allocated version of this struct is at the beginning of every nsIWebAuthnAutoFillEntry
// object. It contains one pointer field for each method in the interface. In
// the case where we can't generate a binding for a method, we include a void
// pointer.
#[doc(hidden)]
#[repr(C)]
pub struct nsIWebAuthnAutoFillEntryVTable {
/// We need to include the members from the base interface's vtable at the start
/// of the VTable definition.
pub __base: nsISupportsVTable,
/* readonly attribute octet provider; */
pub GetProvider: unsafe extern "system" fn (this: *const nsIWebAuthnAutoFillEntry, aProvider: *mut u8) -> ::nserror::nsresult,
/* readonly attribute AString userName; */
pub GetUserName: unsafe extern "system" fn (this: *const nsIWebAuthnAutoFillEntry, aUserName: *mut ::nsstring::nsAString) -> ::nserror::nsresult,
/* readonly attribute AString rpId; */
pub GetRpId: unsafe extern "system" fn (this: *const nsIWebAuthnAutoFillEntry, aRpId: *mut ::nsstring::nsAString) -> ::nserror::nsresult,
/* readonly attribute Array<uint8_t> credentialId; */
pub GetCredentialId: unsafe extern "system" fn (this: *const nsIWebAuthnAutoFillEntry, aCredentialId: *mut thin_vec::ThinVec<u8>) -> ::nserror::nsresult,
}
// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIWebAuthnAutoFillEntry {
pub const PROVIDER_UNKNOWN: u8 = 0;
pub const PROVIDER_TEST_TOKEN: u8 = 1;
pub const PROVIDER_PLATFORM_WINDOWS: u8 = 2;
pub const PROVIDER_PLATFORM_MACOS: u8 = 3;
pub const PROVIDER_PLATFORM_ANDROID: u8 = 4;
/// `readonly attribute octet provider;`
#[inline]
pub unsafe fn GetProvider(&self, aProvider: *mut u8) -> ::nserror::nsresult {
((*self.vtable).GetProvider)(self, aProvider)
}
/// `readonly attribute AString userName;`
#[inline]
pub unsafe fn GetUserName(&self, aUserName: *mut ::nsstring::nsAString) -> ::nserror::nsresult {
((*self.vtable).GetUserName)(self, aUserName)
}
/// `readonly attribute AString rpId;`
#[inline]
pub unsafe fn GetRpId(&self, aRpId: *mut ::nsstring::nsAString) -> ::nserror::nsresult {
((*self.vtable).GetRpId)(self, aRpId)
}
/// `readonly attribute Array<uint8_t> credentialId;`
#[inline]
pub unsafe fn GetCredentialId(&self, aCredentialId: *mut thin_vec::ThinVec<u8>) -> ::nserror::nsresult {
((*self.vtable).GetCredentialId)(self, aCredentialId)
}
}
/// `interface nsIWebAuthnService : nsISupports`
///
// The actual type definition for the interface. This struct has methods
// declared on it which will call through its vtable. You never want to pass
// this type around by value, always pass it behind a reference.
#[repr(C)]
pub struct nsIWebAuthnService {
vtable: &'static nsIWebAuthnServiceVTable,
/// This field is a phantomdata to ensure that the VTable type and any
/// struct containing it is not safe to send across threads by default, as
/// XPCOM is generally not threadsafe.
///
/// If this type is marked as [rust_sync], there will be explicit `Send` and
/// `Sync` implementations on this type, which will override the inherited
/// negative impls from `Rc`.
__nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
// Make the rust compiler aware that there might be interior mutability
// in what actually implements the interface. This works around UB
// that a rust lint would make blatantly obvious, but doesn't exist.
// This prevents optimizations, but those optimizations weren't available
// before rustc switched to LLVM 16, and they now cause problems because
// of the UB.
// Until there's a lint available to find all our UB, it's simpler to
// avoid the UB in the first place, at the cost of preventing optimizations
// in places that don't cause UB. But again, those optimizations weren't
// available before.
__maybe_interior_mutability: ::std::cell::UnsafeCell<[u8; 0]>,
}
// Implementing XpCom for an interface exposes its IID, which allows for easy
// use of the `.query_interface<T>` helper method. This also defines that
// method for nsIWebAuthnService.
unsafe impl XpCom for nsIWebAuthnService {
const IID: nsIID = nsID(0xe236a9b4, 0xa26f, 0x11ed,
[0xb6, 0xcc, 0x07, 0xa9, 0x83, 0x4e, 0x19, 0xb1]);
}
// We need to implement the RefCounted trait so we can be used with `RefPtr`.
// This trait teaches `RefPtr` how to manage our memory.
unsafe impl RefCounted for nsIWebAuthnService {
#[inline]
unsafe fn addref(&self) {
self.AddRef();
}
#[inline]
unsafe fn release(&self) {
self.Release();
}
}
// This trait is implemented on all types which can be coerced to from nsIWebAuthnService.
// It is used in the implementation of `fn coerce<T>`. We hide it from the
// documentation, because it clutters it up a lot.
#[doc(hidden)]
pub trait nsIWebAuthnServiceCoerce {
/// Cheaply cast a value of this type from a `nsIWebAuthnService`.
fn coerce_from(v: &nsIWebAuthnService) -> &Self;
}
// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsIWebAuthnServiceCoerce for nsIWebAuthnService {
#[inline]
fn coerce_from(v: &nsIWebAuthnService) -> &Self {
v
}
}
impl nsIWebAuthnService {
/// Cast this `nsIWebAuthnService` to one of its base interfaces.
#[inline]
pub fn coerce<T: nsIWebAuthnServiceCoerce>(&self) -> &T {
T::coerce_from(self)
}
}
// Every interface struct type implements `Deref` to its base interface. This
// causes methods on the base interfaces to be directly avaliable on the
// object. For example, you can call `.AddRef` or `.QueryInterface` directly
// on any interface which inherits from `nsISupports`.
impl ::std::ops::Deref for nsIWebAuthnService {
type Target = nsISupports;
#[inline]
fn deref(&self) -> &nsISupports {
unsafe {
::std::mem::transmute(self)
}
}
}
// Ensure we can use .coerce() to cast to our base types as well. Any type which
// our base interface can coerce from should be coercable from us as well.
impl<T: nsISupportsCoerce> nsIWebAuthnServiceCoerce for T {
#[inline]
fn coerce_from(v: &nsIWebAuthnService) -> &Self {
T::coerce_from(v)
}
}
// This struct represents the interface's VTable. A pointer to a statically
// allocated version of this struct is at the beginning of every nsIWebAuthnService
// object. It contains one pointer field for each method in the interface. In
// the case where we can't generate a binding for a method, we include a void
// pointer.
#[doc(hidden)]
#[repr(C)]
pub struct nsIWebAuthnServiceVTable {
/// We need to include the members from the base interface's vtable at the start
/// of the VTable definition.
pub __base: nsISupportsVTable,
/* readonly attribute boolean isUVPAA; */
pub GetIsUVPAA: unsafe extern "system" fn (this: *const nsIWebAuthnService, aIsUVPAA: *mut bool) -> ::nserror::nsresult,
/* [noscript] void makeCredential (in uint64_t aTransactionId, in uint64_t browsingContextId, in nsIWebAuthnRegisterArgs args, in nsIWebAuthnRegisterPromise promise); */
pub MakeCredential: unsafe extern "system" fn (this: *const nsIWebAuthnService, aTransactionId: u64, browsingContextId: u64, args: *const nsIWebAuthnRegisterArgs, promise: *const nsIWebAuthnRegisterPromise) -> ::nserror::nsresult,
/* [noscript] void getAssertion (in uint64_t aTransactionId, in uint64_t browsingContextId, in nsIWebAuthnSignArgs args, in nsIWebAuthnSignPromise promise); */
pub GetAssertion: unsafe extern "system" fn (this: *const nsIWebAuthnService, aTransactionId: u64, browsingContextId: u64, args: *const nsIWebAuthnSignArgs, promise: *const nsIWebAuthnSignPromise) -> ::nserror::nsresult,
/* [noscript] void reset (); */
pub Reset: unsafe extern "system" fn (this: *const nsIWebAuthnService) -> ::nserror::nsresult,
/* void cancel (in uint64_t aTransactionId); */
pub Cancel: unsafe extern "system" fn (this: *const nsIWebAuthnService, aTransactionId: u64) -> ::nserror::nsresult,
/* uint64_t hasPendingConditionalGet (in uint64_t aBrowsingContextId, in AString aOrigin); */
pub HasPendingConditionalGet: unsafe extern "system" fn (this: *const nsIWebAuthnService, aBrowsingContextId: u64, aOrigin: *const ::nsstring::nsAString, _retval: *mut u64) -> ::nserror::nsresult,
/* Array<nsIWebAuthnAutoFillEntry> getAutoFillEntries (in uint64_t aTransactionId); */
pub GetAutoFillEntries: unsafe extern "system" fn (this: *const nsIWebAuthnService, aTransactionId: u64, _retval: *mut thin_vec::ThinVec<Option<RefPtr<nsIWebAuthnAutoFillEntry>>>) -> ::nserror::nsresult,
/* void selectAutoFillEntry (in uint64_t aTransactionId, in Array<uint8_t> aCredentialId); */
pub SelectAutoFillEntry: unsafe extern "system" fn (this: *const nsIWebAuthnService, aTransactionId: u64, aCredentialId: *const thin_vec::ThinVec<u8>) -> ::nserror::nsresult,
/* void resumeConditionalGet (in uint64_t aTransactionId); */
pub ResumeConditionalGet: unsafe extern "system" fn (this: *const nsIWebAuthnService, aTransactionId: u64) -> ::nserror::nsresult,
/* void pinCallback (in uint64_t aTransactionId, in ACString aPin); */
pub PinCallback: unsafe extern "system" fn (this: *const nsIWebAuthnService, aTransactionId: u64, aPin: *const ::nsstring::nsACString) -> ::nserror::nsresult,
/* void setHasAttestationConsent (in uint64_t aTransactionId, in boolean aHasConsent); */
pub SetHasAttestationConsent: unsafe extern "system" fn (this: *const nsIWebAuthnService, aTransactionId: u64, aHasConsent: bool) -> ::nserror::nsresult,
/* void selectionCallback (in uint64_t aTransactionId, in uint64_t aIndex); */
pub SelectionCallback: unsafe extern "system" fn (this: *const nsIWebAuthnService, aTransactionId: u64, aIndex: u64) -> ::nserror::nsresult,
/* uint64_t addVirtualAuthenticator (in ACString protocol, in ACString transport, in boolean hasResidentKey, in boolean hasUserVerification, in boolean isUserConsenting, in boolean isUserVerified); */
pub AddVirtualAuthenticator: unsafe extern "system" fn (this: *const nsIWebAuthnService, protocol: *const ::nsstring::nsACString, transport: *const ::nsstring::nsACString, hasResidentKey: bool, hasUserVerification: bool, isUserConsenting: bool, isUserVerified: bool, _retval: *mut u64) -> ::nserror::nsresult,
/* void removeVirtualAuthenticator (in uint64_t authenticatorId); */
pub RemoveVirtualAuthenticator: unsafe extern "system" fn (this: *const nsIWebAuthnService, authenticatorId: u64) -> ::nserror::nsresult,
/* void addCredential (in uint64_t authenticatorId, in ACString credentialId, in boolean isResidentCredential, in ACString rpId, in ACString privateKey, in ACString userHandle, in uint32_t signCount); */
pub AddCredential: unsafe extern "system" fn (this: *const nsIWebAuthnService, authenticatorId: u64, credentialId: *const ::nsstring::nsACString, isResidentCredential: bool, rpId: *const ::nsstring::nsACString, privateKey: *const ::nsstring::nsACString, userHandle: *const ::nsstring::nsACString, signCount: u32) -> ::nserror::nsresult,
/* Array<nsICredentialParameters> getCredentials (in uint64_t authenticatorId); */
pub GetCredentials: unsafe extern "system" fn (this: *const nsIWebAuthnService, authenticatorId: u64, _retval: *mut thin_vec::ThinVec<Option<RefPtr<nsICredentialParameters>>>) -> ::nserror::nsresult,
/* void removeCredential (in uint64_t authenticatorId, in ACString credentialId); */
pub RemoveCredential: unsafe extern "system" fn (this: *const nsIWebAuthnService, authenticatorId: u64, credentialId: *const ::nsstring::nsACString) -> ::nserror::nsresult,
/* void removeAllCredentials (in uint64_t authenticatorId); */
pub RemoveAllCredentials: unsafe extern "system" fn (this: *const nsIWebAuthnService, authenticatorId: u64) -> ::nserror::nsresult,
/* void setUserVerified (in uint64_t authenticatorId, in boolean isUserVerified); */
pub SetUserVerified: unsafe extern "system" fn (this: *const nsIWebAuthnService, authenticatorId: u64, isUserVerified: bool) -> ::nserror::nsresult,
/* void listen (); */
pub Listen: unsafe extern "system" fn (this: *const nsIWebAuthnService) -> ::nserror::nsresult,
/* void runCommand (in ACString aCommand); */
pub RunCommand: unsafe extern "system" fn (this: *const nsIWebAuthnService, aCommand: *const ::nsstring::nsACString) -> ::nserror::nsresult,
}
// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIWebAuthnService {
/// `readonly attribute boolean isUVPAA;`
#[inline]
pub unsafe fn GetIsUVPAA(&self, aIsUVPAA: *mut bool) -> ::nserror::nsresult {
((*self.vtable).GetIsUVPAA)(self, aIsUVPAA)
}
/// `[noscript] void makeCredential (in uint64_t aTransactionId, in uint64_t browsingContextId, in nsIWebAuthnRegisterArgs args, in nsIWebAuthnRegisterPromise promise);`
#[inline]
pub unsafe fn MakeCredential(&self, aTransactionId: u64, browsingContextId: u64, args: *const nsIWebAuthnRegisterArgs, promise: *const nsIWebAuthnRegisterPromise) -> ::nserror::nsresult {
((*self.vtable).MakeCredential)(self, aTransactionId, browsingContextId, args, promise)
}
/// `[noscript] void getAssertion (in uint64_t aTransactionId, in uint64_t browsingContextId, in nsIWebAuthnSignArgs args, in nsIWebAuthnSignPromise promise);`
#[inline]
pub unsafe fn GetAssertion(&self, aTransactionId: u64, browsingContextId: u64, args: *const nsIWebAuthnSignArgs, promise: *const nsIWebAuthnSignPromise) -> ::nserror::nsresult {
((*self.vtable).GetAssertion)(self, aTransactionId, browsingContextId, args, promise)
}
/// `[noscript] void reset ();`
#[inline]
pub unsafe fn Reset(&self, ) -> ::nserror::nsresult {
((*self.vtable).Reset)(self, )
}
/// `void cancel (in uint64_t aTransactionId);`
#[inline]
pub unsafe fn Cancel(&self, aTransactionId: u64) -> ::nserror::nsresult {
((*self.vtable).Cancel)(self, aTransactionId)
}
/// `uint64_t hasPendingConditionalGet (in uint64_t aBrowsingContextId, in AString aOrigin);`
#[inline]
pub unsafe fn HasPendingConditionalGet(&self, aBrowsingContextId: u64, aOrigin: *const ::nsstring::nsAString, _retval: *mut u64) -> ::nserror::nsresult {
((*self.vtable).HasPendingConditionalGet)(self, aBrowsingContextId, aOrigin, _retval)
}
/// `Array<nsIWebAuthnAutoFillEntry> getAutoFillEntries (in uint64_t aTransactionId);`
#[inline]
pub unsafe fn GetAutoFillEntries(&self, aTransactionId: u64, _retval: *mut thin_vec::ThinVec<Option<RefPtr<nsIWebAuthnAutoFillEntry>>>) -> ::nserror::nsresult {
((*self.vtable).GetAutoFillEntries)(self, aTransactionId, _retval)
}
/// `void selectAutoFillEntry (in uint64_t aTransactionId, in Array<uint8_t> aCredentialId);`
#[inline]
pub unsafe fn SelectAutoFillEntry(&self, aTransactionId: u64, aCredentialId: *const thin_vec::ThinVec<u8>) -> ::nserror::nsresult {
((*self.vtable).SelectAutoFillEntry)(self, aTransactionId, aCredentialId)
}
/// `void resumeConditionalGet (in uint64_t aTransactionId);`
#[inline]
pub unsafe fn ResumeConditionalGet(&self, aTransactionId: u64) -> ::nserror::nsresult {
((*self.vtable).ResumeConditionalGet)(self, aTransactionId)
}
/// `void pinCallback (in uint64_t aTransactionId, in ACString aPin);`
#[inline]
pub unsafe fn PinCallback(&self, aTransactionId: u64, aPin: *const ::nsstring::nsACString) -> ::nserror::nsresult {
((*self.vtable).PinCallback)(self, aTransactionId, aPin)
}
/// `void setHasAttestationConsent (in uint64_t aTransactionId, in boolean aHasConsent);`
#[inline]
pub unsafe fn SetHasAttestationConsent(&self, aTransactionId: u64, aHasConsent: bool) -> ::nserror::nsresult {
((*self.vtable).SetHasAttestationConsent)(self, aTransactionId, aHasConsent)
}
/// `void selectionCallback (in uint64_t aTransactionId, in uint64_t aIndex);`
#[inline]
pub unsafe fn SelectionCallback(&self, aTransactionId: u64, aIndex: u64) -> ::nserror::nsresult {
((*self.vtable).SelectionCallback)(self, aTransactionId, aIndex)
}
/// `uint64_t addVirtualAuthenticator (in ACString protocol, in ACString transport, in boolean hasResidentKey, in boolean hasUserVerification, in boolean isUserConsenting, in boolean isUserVerified);`
#[inline]
pub unsafe fn AddVirtualAuthenticator(&self, protocol: *const ::nsstring::nsACString, transport: *const ::nsstring::nsACString, hasResidentKey: bool, hasUserVerification: bool, isUserConsenting: bool, isUserVerified: bool, _retval: *mut u64) -> ::nserror::nsresult {
((*self.vtable).AddVirtualAuthenticator)(self, protocol, transport, hasResidentKey, hasUserVerification, isUserConsenting, isUserVerified, _retval)
}
/// `void removeVirtualAuthenticator (in uint64_t authenticatorId);`
#[inline]
pub unsafe fn RemoveVirtualAuthenticator(&self, authenticatorId: u64) -> ::nserror::nsresult {
((*self.vtable).RemoveVirtualAuthenticator)(self, authenticatorId)
}
/// `void addCredential (in uint64_t authenticatorId, in ACString credentialId, in boolean isResidentCredential, in ACString rpId, in ACString privateKey, in ACString userHandle, in uint32_t signCount);`
#[inline]
pub unsafe fn AddCredential(&self, authenticatorId: u64, credentialId: *const ::nsstring::nsACString, isResidentCredential: bool, rpId: *const ::nsstring::nsACString, privateKey: *const ::nsstring::nsACString, userHandle: *const ::nsstring::nsACString, signCount: u32) -> ::nserror::nsresult {
((*self.vtable).AddCredential)(self, authenticatorId, credentialId, isResidentCredential, rpId, privateKey, userHandle, signCount)
}
/// `Array<nsICredentialParameters> getCredentials (in uint64_t authenticatorId);`
#[inline]
pub unsafe fn GetCredentials(&self, authenticatorId: u64, _retval: *mut thin_vec::ThinVec<Option<RefPtr<nsICredentialParameters>>>) -> ::nserror::nsresult {
((*self.vtable).GetCredentials)(self, authenticatorId, _retval)
}
/// `void removeCredential (in uint64_t authenticatorId, in ACString credentialId);`
#[inline]
pub unsafe fn RemoveCredential(&self, authenticatorId: u64, credentialId: *const ::nsstring::nsACString) -> ::nserror::nsresult {
((*self.vtable).RemoveCredential)(self, authenticatorId, credentialId)
}
/// `void removeAllCredentials (in uint64_t authenticatorId);`
#[inline]
pub unsafe fn RemoveAllCredentials(&self, authenticatorId: u64) -> ::nserror::nsresult {
((*self.vtable).RemoveAllCredentials)(self, authenticatorId)
}
/// `void setUserVerified (in uint64_t authenticatorId, in boolean isUserVerified);`
#[inline]
pub unsafe fn SetUserVerified(&self, authenticatorId: u64, isUserVerified: bool) -> ::nserror::nsresult {
((*self.vtable).SetUserVerified)(self, authenticatorId, isUserVerified)
}
/// `void listen ();`
#[inline]
pub unsafe fn Listen(&self, ) -> ::nserror::nsresult {
((*self.vtable).Listen)(self, )
}
/// `void runCommand (in ACString aCommand);`
#[inline]
pub unsafe fn RunCommand(&self, aCommand: *const ::nsstring::nsACString) -> ::nserror::nsresult {
((*self.vtable).RunCommand)(self, aCommand)
}
}