SERVICE_TYPE_INFO_ABSA

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SERVICE_TYPE_VALUE_ABSA
{
    public uint dwNameSpace;
    public uint dwValueType;
    public uint dwValueSize;
    public IntPtr lpValueName;
    public IntPtr lpValue;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SERVICE_TYPE_INFO_ABSA
{
    public IntPtr lpTypeName;
    public uint dwValueCount;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] public SERVICE_TYPE_VALUE_ABSA[] Values;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SERVICE_TYPE_VALUE_ABSA
    Public dwNameSpace As UInteger
    Public dwValueType As UInteger
    Public dwValueSize As UInteger
    Public lpValueName As IntPtr
    Public lpValue As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SERVICE_TYPE_INFO_ABSA
    Public lpTypeName As IntPtr
    Public dwValueCount As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=1)> Public Values() As SERVICE_TYPE_VALUE_ABSA
End Structure

import ctypes
from ctypes import wintypes

class SERVICE_TYPE_VALUE_ABSA(ctypes.Structure):
    _fields_ = [
        ("dwNameSpace", wintypes.DWORD),
        ("dwValueType", wintypes.DWORD),
        ("dwValueSize", wintypes.DWORD),
        ("lpValueName", ctypes.c_void_p),
        ("lpValue", ctypes.c_void_p),
    ]

class SERVICE_TYPE_INFO_ABSA(ctypes.Structure):
    _fields_ = [
        ("lpTypeName", ctypes.c_void_p),
        ("dwValueCount", wintypes.DWORD),
        ("Values", SERVICE_TYPE_VALUE_ABSA * 1),
    ]

#[repr(C)]
pub struct SERVICE_TYPE_VALUE_ABSA {
    pub dwNameSpace: u32,
    pub dwValueType: u32,
    pub dwValueSize: u32,
    pub lpValueName: *mut core::ffi::c_void,
    pub lpValue: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct SERVICE_TYPE_INFO_ABSA {
    pub lpTypeName: *mut core::ffi::c_void,
    pub dwValueCount: u32,
    pub Values: [SERVICE_TYPE_VALUE_ABSA; 1],
}

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

type SERVICE_TYPE_VALUE_ABSA struct {
	dwNameSpace uint32
	dwValueType uint32
	dwValueSize uint32
	lpValueName uintptr
	lpValue uintptr
}

type SERVICE_TYPE_INFO_ABSA struct {
	lpTypeName uintptr
	dwValueCount uint32
	Values [1]SERVICE_TYPE_VALUE_ABSA
}

type
  SERVICE_TYPE_VALUE_ABSA = record
    dwNameSpace: DWORD;
    dwValueType: DWORD;
    dwValueSize: DWORD;
    lpValueName: Pointer;
    lpValue: Pointer;
  end;

  SERVICE_TYPE_INFO_ABSA = record
    lpTypeName: Pointer;
    dwValueCount: DWORD;
    Values: array[0..0] of SERVICE_TYPE_VALUE_ABSA;
  end;

const SERVICE_TYPE_VALUE_ABSA = extern struct {
    dwNameSpace: u32,
    dwValueType: u32,
    dwValueSize: u32,
    lpValueName: ?*anyopaque,
    lpValue: ?*anyopaque,
};

const SERVICE_TYPE_INFO_ABSA = extern struct {
    lpTypeName: ?*anyopaque,
    dwValueCount: u32,
    Values: [1]SERVICE_TYPE_VALUE_ABSA,
};

type
  SERVICE_TYPE_VALUE_ABSA {.bycopy.} = object
    dwNameSpace: uint32
    dwValueType: uint32
    dwValueSize: uint32
    lpValueName: pointer
    lpValue: pointer

  SERVICE_TYPE_INFO_ABSA {.bycopy.} = object
    lpTypeName: pointer
    dwValueCount: uint32
    Values: array[1, SERVICE_TYPE_VALUE_ABSA]

struct SERVICE_TYPE_VALUE_ABSA
{
    uint dwNameSpace;
    uint dwValueType;
    uint dwValueSize;
    void* lpValueName;
    void* lpValue;
}

struct SERVICE_TYPE_INFO_ABSA
{
    void* lpTypeName;
    uint dwValueCount;
    SERVICE_TYPE_VALUE_ABSA[1] Values;
}