WLX_CONSOLESWITCH_CREDENTIALS_INFO_V1_0

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct LUID
{
    public uint LowPart;
    public int HighPart;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct QUOTA_LIMITS
{
    public UIntPtr PagedPoolLimit;
    public UIntPtr NonPagedPoolLimit;
    public UIntPtr MinimumWorkingSetSize;
    public UIntPtr MaximumWorkingSetSize;
    public UIntPtr PagefileLimit;
    public long TimeLimit;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct WLX_CONSOLESWITCH_CREDENTIALS_INFO_V1_0
{
    public uint dwType;
    public IntPtr UserToken;
    public LUID LogonId;
    public QUOTA_LIMITS Quotas;
    public IntPtr UserName;
    public IntPtr Domain;
    public long LogonTime;
    [MarshalAs(UnmanagedType.Bool)] public bool SmartCardLogon;
    public uint ProfileLength;
    public uint MessageType;
    public ushort LogonCount;
    public ushort BadPasswordCount;
    public long ProfileLogonTime;
    public long LogoffTime;
    public long KickOffTime;
    public long PasswordLastSet;
    public long PasswordCanChange;
    public long PasswordMustChange;
    public IntPtr LogonScript;
    public IntPtr HomeDirectory;
    public IntPtr FullName;
    public IntPtr ProfilePath;
    public IntPtr HomeDirectoryDrive;
    public IntPtr LogonServer;
    public uint UserFlags;
    public uint PrivateDataLen;
    public IntPtr PrivateData;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure LUID
    Public LowPart As UInteger
    Public HighPart As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure QUOTA_LIMITS
    Public PagedPoolLimit As UIntPtr
    Public NonPagedPoolLimit As UIntPtr
    Public MinimumWorkingSetSize As UIntPtr
    Public MaximumWorkingSetSize As UIntPtr
    Public PagefileLimit As UIntPtr
    Public TimeLimit As Long
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure WLX_CONSOLESWITCH_CREDENTIALS_INFO_V1_0
    Public dwType As UInteger
    Public UserToken As IntPtr
    Public LogonId As LUID
    Public Quotas As QUOTA_LIMITS
    Public UserName As IntPtr
    Public Domain As IntPtr
    Public LogonTime As Long
    <MarshalAs(UnmanagedType.Bool)> Public SmartCardLogon As Boolean
    Public ProfileLength As UInteger
    Public MessageType As UInteger
    Public LogonCount As UShort
    Public BadPasswordCount As UShort
    Public ProfileLogonTime As Long
    Public LogoffTime As Long
    Public KickOffTime As Long
    Public PasswordLastSet As Long
    Public PasswordCanChange As Long
    Public PasswordMustChange As Long
    Public LogonScript As IntPtr
    Public HomeDirectory As IntPtr
    Public FullName As IntPtr
    Public ProfilePath As IntPtr
    Public HomeDirectoryDrive As IntPtr
    Public LogonServer As IntPtr
    Public UserFlags As UInteger
    Public PrivateDataLen As UInteger
    Public PrivateData As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class LUID(ctypes.Structure):
    _fields_ = [
        ("LowPart", wintypes.DWORD),
        ("HighPart", ctypes.c_int),
    ]

class QUOTA_LIMITS(ctypes.Structure):
    _fields_ = [
        ("PagedPoolLimit", ctypes.c_size_t),
        ("NonPagedPoolLimit", ctypes.c_size_t),
        ("MinimumWorkingSetSize", ctypes.c_size_t),
        ("MaximumWorkingSetSize", ctypes.c_size_t),
        ("PagefileLimit", ctypes.c_size_t),
        ("TimeLimit", ctypes.c_longlong),
    ]

class WLX_CONSOLESWITCH_CREDENTIALS_INFO_V1_0(ctypes.Structure):
    _fields_ = [
        ("dwType", wintypes.DWORD),
        ("UserToken", ctypes.c_void_p),
        ("LogonId", LUID),
        ("Quotas", QUOTA_LIMITS),
        ("UserName", ctypes.c_void_p),
        ("Domain", ctypes.c_void_p),
        ("LogonTime", ctypes.c_longlong),
        ("SmartCardLogon", wintypes.BOOL),
        ("ProfileLength", wintypes.DWORD),
        ("MessageType", wintypes.DWORD),
        ("LogonCount", ctypes.c_ushort),
        ("BadPasswordCount", ctypes.c_ushort),
        ("ProfileLogonTime", ctypes.c_longlong),
        ("LogoffTime", ctypes.c_longlong),
        ("KickOffTime", ctypes.c_longlong),
        ("PasswordLastSet", ctypes.c_longlong),
        ("PasswordCanChange", ctypes.c_longlong),
        ("PasswordMustChange", ctypes.c_longlong),
        ("LogonScript", ctypes.c_void_p),
        ("HomeDirectory", ctypes.c_void_p),
        ("FullName", ctypes.c_void_p),
        ("ProfilePath", ctypes.c_void_p),
        ("HomeDirectoryDrive", ctypes.c_void_p),
        ("LogonServer", ctypes.c_void_p),
        ("UserFlags", wintypes.DWORD),
        ("PrivateDataLen", wintypes.DWORD),
        ("PrivateData", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct LUID {
    pub LowPart: u32,
    pub HighPart: i32,
}

#[repr(C)]
pub struct QUOTA_LIMITS {
    pub PagedPoolLimit: usize,
    pub NonPagedPoolLimit: usize,
    pub MinimumWorkingSetSize: usize,
    pub MaximumWorkingSetSize: usize,
    pub PagefileLimit: usize,
    pub TimeLimit: i64,
}

#[repr(C)]
pub struct WLX_CONSOLESWITCH_CREDENTIALS_INFO_V1_0 {
    pub dwType: u32,
    pub UserToken: *mut core::ffi::c_void,
    pub LogonId: LUID,
    pub Quotas: QUOTA_LIMITS,
    pub UserName: *mut core::ffi::c_void,
    pub Domain: *mut core::ffi::c_void,
    pub LogonTime: i64,
    pub SmartCardLogon: i32,
    pub ProfileLength: u32,
    pub MessageType: u32,
    pub LogonCount: u16,
    pub BadPasswordCount: u16,
    pub ProfileLogonTime: i64,
    pub LogoffTime: i64,
    pub KickOffTime: i64,
    pub PasswordLastSet: i64,
    pub PasswordCanChange: i64,
    pub PasswordMustChange: i64,
    pub LogonScript: *mut core::ffi::c_void,
    pub HomeDirectory: *mut core::ffi::c_void,
    pub FullName: *mut core::ffi::c_void,
    pub ProfilePath: *mut core::ffi::c_void,
    pub HomeDirectoryDrive: *mut core::ffi::c_void,
    pub LogonServer: *mut core::ffi::c_void,
    pub UserFlags: u32,
    pub PrivateDataLen: u32,
    pub PrivateData: *mut core::ffi::c_void,
}

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

type LUID struct {
	LowPart uint32
	HighPart int32
}

type QUOTA_LIMITS struct {
	PagedPoolLimit uintptr
	NonPagedPoolLimit uintptr
	MinimumWorkingSetSize uintptr
	MaximumWorkingSetSize uintptr
	PagefileLimit uintptr
	TimeLimit int64
}

type WLX_CONSOLESWITCH_CREDENTIALS_INFO_V1_0 struct {
	dwType uint32
	UserToken uintptr
	LogonId LUID
	Quotas QUOTA_LIMITS
	UserName uintptr
	Domain uintptr
	LogonTime int64
	SmartCardLogon int32
	ProfileLength uint32
	MessageType uint32
	LogonCount uint16
	BadPasswordCount uint16
	ProfileLogonTime int64
	LogoffTime int64
	KickOffTime int64
	PasswordLastSet int64
	PasswordCanChange int64
	PasswordMustChange int64
	LogonScript uintptr
	HomeDirectory uintptr
	FullName uintptr
	ProfilePath uintptr
	HomeDirectoryDrive uintptr
	LogonServer uintptr
	UserFlags uint32
	PrivateDataLen uint32
	PrivateData uintptr
}

type
  LUID = record
    LowPart: DWORD;
    HighPart: Integer;
  end;

  QUOTA_LIMITS = record
    PagedPoolLimit: NativeUInt;
    NonPagedPoolLimit: NativeUInt;
    MinimumWorkingSetSize: NativeUInt;
    MaximumWorkingSetSize: NativeUInt;
    PagefileLimit: NativeUInt;
    TimeLimit: Int64;
  end;

  WLX_CONSOLESWITCH_CREDENTIALS_INFO_V1_0 = record
    dwType: DWORD;
    UserToken: Pointer;
    LogonId: LUID;
    Quotas: QUOTA_LIMITS;
    UserName: Pointer;
    Domain: Pointer;
    LogonTime: Int64;
    SmartCardLogon: BOOL;
    ProfileLength: DWORD;
    MessageType: DWORD;
    LogonCount: Word;
    BadPasswordCount: Word;
    ProfileLogonTime: Int64;
    LogoffTime: Int64;
    KickOffTime: Int64;
    PasswordLastSet: Int64;
    PasswordCanChange: Int64;
    PasswordMustChange: Int64;
    LogonScript: Pointer;
    HomeDirectory: Pointer;
    FullName: Pointer;
    ProfilePath: Pointer;
    HomeDirectoryDrive: Pointer;
    LogonServer: Pointer;
    UserFlags: DWORD;
    PrivateDataLen: DWORD;
    PrivateData: Pointer;
  end;

const LUID = extern struct {
    LowPart: u32,
    HighPart: i32,
};

const QUOTA_LIMITS = extern struct {
    PagedPoolLimit: usize,
    NonPagedPoolLimit: usize,
    MinimumWorkingSetSize: usize,
    MaximumWorkingSetSize: usize,
    PagefileLimit: usize,
    TimeLimit: i64,
};

const WLX_CONSOLESWITCH_CREDENTIALS_INFO_V1_0 = extern struct {
    dwType: u32,
    UserToken: ?*anyopaque,
    LogonId: LUID,
    Quotas: QUOTA_LIMITS,
    UserName: ?*anyopaque,
    Domain: ?*anyopaque,
    LogonTime: i64,
    SmartCardLogon: i32,
    ProfileLength: u32,
    MessageType: u32,
    LogonCount: u16,
    BadPasswordCount: u16,
    ProfileLogonTime: i64,
    LogoffTime: i64,
    KickOffTime: i64,
    PasswordLastSet: i64,
    PasswordCanChange: i64,
    PasswordMustChange: i64,
    LogonScript: ?*anyopaque,
    HomeDirectory: ?*anyopaque,
    FullName: ?*anyopaque,
    ProfilePath: ?*anyopaque,
    HomeDirectoryDrive: ?*anyopaque,
    LogonServer: ?*anyopaque,
    UserFlags: u32,
    PrivateDataLen: u32,
    PrivateData: ?*anyopaque,
};

type
  LUID {.bycopy.} = object
    LowPart: uint32
    HighPart: int32

  QUOTA_LIMITS {.bycopy.} = object
    PagedPoolLimit: uint
    NonPagedPoolLimit: uint
    MinimumWorkingSetSize: uint
    MaximumWorkingSetSize: uint
    PagefileLimit: uint
    TimeLimit: int64

  WLX_CONSOLESWITCH_CREDENTIALS_INFO_V1_0 {.bycopy.} = object
    dwType: uint32
    UserToken: pointer
    LogonId: LUID
    Quotas: QUOTA_LIMITS
    UserName: pointer
    Domain: pointer
    LogonTime: int64
    SmartCardLogon: int32
    ProfileLength: uint32
    MessageType: uint32
    LogonCount: uint16
    BadPasswordCount: uint16
    ProfileLogonTime: int64
    LogoffTime: int64
    KickOffTime: int64
    PasswordLastSet: int64
    PasswordCanChange: int64
    PasswordMustChange: int64
    LogonScript: pointer
    HomeDirectory: pointer
    FullName: pointer
    ProfilePath: pointer
    HomeDirectoryDrive: pointer
    LogonServer: pointer
    UserFlags: uint32
    PrivateDataLen: uint32
    PrivateData: pointer

struct LUID
{
    uint LowPart;
    int HighPart;
}

struct QUOTA_LIMITS
{
    size_t PagedPoolLimit;
    size_t NonPagedPoolLimit;
    size_t MinimumWorkingSetSize;
    size_t MaximumWorkingSetSize;
    size_t PagefileLimit;
    long TimeLimit;
}

struct WLX_CONSOLESWITCH_CREDENTIALS_INFO_V1_0
{
    uint dwType;
    void* UserToken;
    LUID LogonId;
    QUOTA_LIMITS Quotas;
    void* UserName;
    void* Domain;
    long LogonTime;
    int SmartCardLogon;
    uint ProfileLength;
    uint MessageType;
    ushort LogonCount;
    ushort BadPasswordCount;
    long ProfileLogonTime;
    long LogoffTime;
    long KickOffTime;
    long PasswordLastSet;
    long PasswordCanChange;
    long PasswordMustChange;
    void* LogonScript;
    void* HomeDirectory;
    void* FullName;
    void* ProfilePath;
    void* HomeDirectoryDrive;
    void* LogonServer;
    uint UserFlags;
    uint PrivateDataLen;
    void* PrivateData;
}