MBN_PROVIDER2

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MBN_PROVIDER
{
    public IntPtr providerID;
    public uint providerState;
    public IntPtr providerName;
    public uint dataClass;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MBN_PROVIDER2
{
    public MBN_PROVIDER provider;
    public int cellularClass;
    public uint signalStrength;
    public uint signalError;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MBN_PROVIDER
    Public providerID As IntPtr
    Public providerState As UInteger
    Public providerName As IntPtr
    Public dataClass As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MBN_PROVIDER2
    Public provider As MBN_PROVIDER
    Public cellularClass As Integer
    Public signalStrength As UInteger
    Public signalError As UInteger
End Structure

import ctypes
from ctypes import wintypes

class MBN_PROVIDER(ctypes.Structure):
    _fields_ = [
        ("providerID", ctypes.c_void_p),
        ("providerState", wintypes.DWORD),
        ("providerName", ctypes.c_void_p),
        ("dataClass", wintypes.DWORD),
    ]

class MBN_PROVIDER2(ctypes.Structure):
    _fields_ = [
        ("provider", MBN_PROVIDER),
        ("cellularClass", ctypes.c_int),
        ("signalStrength", wintypes.DWORD),
        ("signalError", wintypes.DWORD),
    ]

#[repr(C)]
pub struct MBN_PROVIDER {
    pub providerID: *mut core::ffi::c_void,
    pub providerState: u32,
    pub providerName: *mut core::ffi::c_void,
    pub dataClass: u32,
}

#[repr(C)]
pub struct MBN_PROVIDER2 {
    pub provider: MBN_PROVIDER,
    pub cellularClass: i32,
    pub signalStrength: u32,
    pub signalError: u32,
}

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

type MBN_PROVIDER struct {
	providerID uintptr
	providerState uint32
	providerName uintptr
	dataClass uint32
}

type MBN_PROVIDER2 struct {
	provider MBN_PROVIDER
	cellularClass int32
	signalStrength uint32
	signalError uint32
}

type
  MBN_PROVIDER = record
    providerID: Pointer;
    providerState: DWORD;
    providerName: Pointer;
    dataClass: DWORD;
  end;

  MBN_PROVIDER2 = record
    provider: MBN_PROVIDER;
    cellularClass: Integer;
    signalStrength: DWORD;
    signalError: DWORD;
  end;

const MBN_PROVIDER = extern struct {
    providerID: ?*anyopaque,
    providerState: u32,
    providerName: ?*anyopaque,
    dataClass: u32,
};

const MBN_PROVIDER2 = extern struct {
    provider: MBN_PROVIDER,
    cellularClass: i32,
    signalStrength: u32,
    signalError: u32,
};

type
  MBN_PROVIDER {.bycopy.} = object
    providerID: pointer
    providerState: uint32
    providerName: pointer
    dataClass: uint32

  MBN_PROVIDER2 {.bycopy.} = object
    provider: MBN_PROVIDER
    cellularClass: int32
    signalStrength: uint32
    signalError: uint32

struct MBN_PROVIDER
{
    void* providerID;
    uint providerState;
    void* providerName;
    uint dataClass;
}

struct MBN_PROVIDER2
{
    MBN_PROVIDER provider;
    int cellularClass;
    uint signalStrength;
    uint signalError;
}