MFP_ACQUIRE_USER_CREDENTIAL_EVENT

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MFP_EVENT_HEADER
{
    public int eEventType;
    public int hrEvent;
    public IntPtr pMediaPlayer;
    public int eState;
    public IntPtr pPropertyStore;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MFP_ACQUIRE_USER_CREDENTIAL_EVENT
{
    public MFP_EVENT_HEADER header;
    public UIntPtr dwUserData;
    [MarshalAs(UnmanagedType.Bool)] public bool fProceedWithAuthentication;
    public int hrAuthenticationStatus;
    public IntPtr pwszURL;
    public IntPtr pwszSite;
    public IntPtr pwszRealm;
    public IntPtr pwszPackage;
    public int nRetries;
    public uint flags;
    public IntPtr pCredential;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MFP_EVENT_HEADER
    Public eEventType As Integer
    Public hrEvent As Integer
    Public pMediaPlayer As IntPtr
    Public eState As Integer
    Public pPropertyStore As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MFP_ACQUIRE_USER_CREDENTIAL_EVENT
    Public header As MFP_EVENT_HEADER
    Public dwUserData As UIntPtr
    <MarshalAs(UnmanagedType.Bool)> Public fProceedWithAuthentication As Boolean
    Public hrAuthenticationStatus As Integer
    Public pwszURL As IntPtr
    Public pwszSite As IntPtr
    Public pwszRealm As IntPtr
    Public pwszPackage As IntPtr
    Public nRetries As Integer
    Public flags As UInteger
    Public pCredential As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class MFP_EVENT_HEADER(ctypes.Structure):
    _fields_ = [
        ("eEventType", ctypes.c_int),
        ("hrEvent", ctypes.c_int),
        ("pMediaPlayer", ctypes.c_void_p),
        ("eState", ctypes.c_int),
        ("pPropertyStore", ctypes.c_void_p),
    ]

class MFP_ACQUIRE_USER_CREDENTIAL_EVENT(ctypes.Structure):
    _fields_ = [
        ("header", MFP_EVENT_HEADER),
        ("dwUserData", ctypes.c_size_t),
        ("fProceedWithAuthentication", wintypes.BOOL),
        ("hrAuthenticationStatus", ctypes.c_int),
        ("pwszURL", ctypes.c_void_p),
        ("pwszSite", ctypes.c_void_p),
        ("pwszRealm", ctypes.c_void_p),
        ("pwszPackage", ctypes.c_void_p),
        ("nRetries", ctypes.c_int),
        ("flags", wintypes.DWORD),
        ("pCredential", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct MFP_EVENT_HEADER {
    pub eEventType: i32,
    pub hrEvent: i32,
    pub pMediaPlayer: *mut core::ffi::c_void,
    pub eState: i32,
    pub pPropertyStore: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct MFP_ACQUIRE_USER_CREDENTIAL_EVENT {
    pub header: MFP_EVENT_HEADER,
    pub dwUserData: usize,
    pub fProceedWithAuthentication: i32,
    pub hrAuthenticationStatus: i32,
    pub pwszURL: *mut core::ffi::c_void,
    pub pwszSite: *mut core::ffi::c_void,
    pub pwszRealm: *mut core::ffi::c_void,
    pub pwszPackage: *mut core::ffi::c_void,
    pub nRetries: i32,
    pub flags: u32,
    pub pCredential: *mut core::ffi::c_void,
}

import "golang.org/x/sys/windows"

type MFP_EVENT_HEADER struct {
	eEventType int32
	hrEvent int32
	pMediaPlayer uintptr
	eState int32
	pPropertyStore uintptr
}

type MFP_ACQUIRE_USER_CREDENTIAL_EVENT struct {
	header MFP_EVENT_HEADER
	dwUserData uintptr
	fProceedWithAuthentication int32
	hrAuthenticationStatus int32
	pwszURL uintptr
	pwszSite uintptr
	pwszRealm uintptr
	pwszPackage uintptr
	nRetries int32
	flags uint32
	pCredential uintptr
}

type
  MFP_EVENT_HEADER = record
    eEventType: Integer;
    hrEvent: Integer;
    pMediaPlayer: Pointer;
    eState: Integer;
    pPropertyStore: Pointer;
  end;

  MFP_ACQUIRE_USER_CREDENTIAL_EVENT = record
    header: MFP_EVENT_HEADER;
    dwUserData: NativeUInt;
    fProceedWithAuthentication: BOOL;
    hrAuthenticationStatus: Integer;
    pwszURL: Pointer;
    pwszSite: Pointer;
    pwszRealm: Pointer;
    pwszPackage: Pointer;
    nRetries: Integer;
    flags: DWORD;
    pCredential: Pointer;
  end;

const MFP_EVENT_HEADER = extern struct {
    eEventType: i32,
    hrEvent: i32,
    pMediaPlayer: ?*anyopaque,
    eState: i32,
    pPropertyStore: ?*anyopaque,
};

const MFP_ACQUIRE_USER_CREDENTIAL_EVENT = extern struct {
    header: MFP_EVENT_HEADER,
    dwUserData: usize,
    fProceedWithAuthentication: i32,
    hrAuthenticationStatus: i32,
    pwszURL: ?*anyopaque,
    pwszSite: ?*anyopaque,
    pwszRealm: ?*anyopaque,
    pwszPackage: ?*anyopaque,
    nRetries: i32,
    flags: u32,
    pCredential: ?*anyopaque,
};

type
  MFP_EVENT_HEADER {.bycopy.} = object
    eEventType: int32
    hrEvent: int32
    pMediaPlayer: pointer
    eState: int32
    pPropertyStore: pointer

  MFP_ACQUIRE_USER_CREDENTIAL_EVENT {.bycopy.} = object
    header: MFP_EVENT_HEADER
    dwUserData: uint
    fProceedWithAuthentication: int32
    hrAuthenticationStatus: int32
    pwszURL: pointer
    pwszSite: pointer
    pwszRealm: pointer
    pwszPackage: pointer
    nRetries: int32
    flags: uint32
    pCredential: pointer

struct MFP_EVENT_HEADER
{
    int eEventType;
    int hrEvent;
    void* pMediaPlayer;
    int eState;
    void* pPropertyStore;
}

struct MFP_ACQUIRE_USER_CREDENTIAL_EVENT
{
    MFP_EVENT_HEADER header;
    size_t dwUserData;
    int fProceedWithAuthentication;
    int hrAuthenticationStatus;
    void* pwszURL;
    void* pwszSite;
    void* pwszRealm;
    void* pwszPackage;
    int nRetries;
    uint flags;
    void* pCredential;
}