Postgres server bindings

postgres.scala

package libtest

import _root_.scala.scalanative.unsafe.*
import _root_.scala.scalanative.unsigned.*
import _root_.scala.scalanative.libc.*
import _root_.scala.scalanative.*

object predef:
  private[libtest] trait CEnumU[T](using eq: T =:= UInt):
    given Tag[T] = Tag.UInt.asInstanceOf[Tag[T]]
    extension (inline t: T)
     inline def int: CInt = eq.apply(t).toInt
     inline def uint: CUnsignedInt = eq.apply(t)
     inline def value: CUnsignedInt = eq.apply(t)


object enumerations:
  import predef.*
  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  opaque type FmgrHookEventType = CUnsignedInt
  object FmgrHookEventType extends CEnumU[FmgrHookEventType]:
    given _tag: Tag[FmgrHookEventType] = Tag.UInt
    inline def define(inline a: Long): FmgrHookEventType = a.toUInt
    val FHET_START = define(0)
    val FHET_END = define(1)
    val FHET_ABORT = define(2)
    inline def getName(inline value: FmgrHookEventType): Option[String] =
      inline value match
        case FHET_START => Some("FHET_START")
        case FHET_END => Some("FHET_END")
        case FHET_ABORT => Some("FHET_ABORT")
        case _ => None
    extension (a: FmgrHookEventType)
      inline def &(b: FmgrHookEventType): FmgrHookEventType = a & b
      inline def |(b: FmgrHookEventType): FmgrHookEventType = a | b
      inline def is(b: FmgrHookEventType): Boolean = (a & b) == b

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  opaque type PGErrorVerbosity = CUnsignedInt
  object PGErrorVerbosity extends CEnumU[PGErrorVerbosity]:
    given _tag: Tag[PGErrorVerbosity] = Tag.UInt
    inline def define(inline a: Long): PGErrorVerbosity = a.toUInt
    val PGERROR_TERSE = define(0)
    val PGERROR_DEFAULT = define(1)
    val PGERROR_VERBOSE = define(2)
    inline def getName(inline value: PGErrorVerbosity): Option[String] =
      inline value match
        case PGERROR_TERSE => Some("PGERROR_TERSE")
        case PGERROR_DEFAULT => Some("PGERROR_DEFAULT")
        case PGERROR_VERBOSE => Some("PGERROR_VERBOSE")
        case _ => None
    extension (a: PGErrorVerbosity)
      inline def &(b: PGErrorVerbosity): PGErrorVerbosity = a & b
      inline def |(b: PGErrorVerbosity): PGErrorVerbosity = a | b
      inline def is(b: PGErrorVerbosity): Boolean = (a & b) == b

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/postgres.h
  */
  opaque type vartag_external = CUnsignedInt
  object vartag_external extends CEnumU[vartag_external]:
    given _tag: Tag[vartag_external] = Tag.UInt
    inline def define(inline a: Long): vartag_external = a.toUInt
    val VARTAG_INDIRECT = define(1)
    val VARTAG_EXPANDED_RO = define(2)
    val VARTAG_EXPANDED_RW = define(3)
    val VARTAG_ONDISK = define(18)
    inline def getName(inline value: vartag_external): Option[String] =
      inline value match
        case VARTAG_INDIRECT => Some("VARTAG_INDIRECT")
        case VARTAG_EXPANDED_RO => Some("VARTAG_EXPANDED_RO")
        case VARTAG_EXPANDED_RW => Some("VARTAG_EXPANDED_RW")
        case VARTAG_ONDISK => Some("VARTAG_ONDISK")
        case _ => None
    extension (a: vartag_external)
      inline def &(b: vartag_external): vartag_external = a & b
      inline def |(b: vartag_external): vartag_external = a | b
      inline def is(b: vartag_external): Boolean = (a & b) == b

object aliases:
  import _root_.libtest.enumerations.*
  import _root_.libtest.aliases.*
  import _root_.libtest.structs.*
  import _root_.libtest.unions.*

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  type CommandId = uint32
  object CommandId: 
    given _tag: Tag[CommandId] = uint32._tag
    inline def apply(inline o: uint32): CommandId = o
    extension (v: CommandId)
      inline def value: uint32 = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/postgres.h
  */
  type Datum = uintptr_t
  object Datum: 
    given _tag: Tag[Datum] = uintptr_t._tag
    inline def apply(inline o: uintptr_t): Datum = o
    extension (v: Datum)
      inline def value: uintptr_t = v

  type FILE = libc.stdio.FILE
  object FILE: 
    val _tag: Tag[FILE] = summon[Tag[libc.stdio.FILE]]
    inline def apply(inline o: libc.stdio.FILE): FILE = o
    extension (v: FILE)
      inline def value: libc.stdio.FILE = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  opaque type FunctionCallInfo = Ptr[FunctionCallInfoBaseData]
  object FunctionCallInfo: 
    given _tag: Tag[FunctionCallInfo] = Tag.Ptr[FunctionCallInfoBaseData](FunctionCallInfoBaseData._tag)
    inline def apply(inline o: Ptr[FunctionCallInfoBaseData]): FunctionCallInfo = o
    extension (v: FunctionCallInfo)
      inline def value: Ptr[FunctionCallInfoBaseData] = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type Index = CUnsignedInt
  object Index: 
    given _tag: Tag[Index] = Tag.UInt
    inline def apply(inline o: CUnsignedInt): Index = o
    extension (v: Index)
      inline def value: CUnsignedInt = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  type LocalTransactionId = uint32
  object LocalTransactionId: 
    given _tag: Tag[LocalTransactionId] = uint32._tag
    inline def apply(inline o: uint32): LocalTransactionId = o
    extension (v: LocalTransactionId)
      inline def value: uint32 = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  opaque type MemoryContext = Ptr[MemoryContextData]
  object MemoryContext: 
    given _tag: Tag[MemoryContext] = Tag.Ptr[MemoryContextData](MemoryContextData._tag)
    inline def apply(inline o: Ptr[MemoryContextData]): MemoryContext = o
    extension (v: MemoryContext)
      inline def value: Ptr[MemoryContextData] = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  opaque type MemoryContextCallbackFunction = CFuncPtr1[Ptr[Byte], Unit]
  object MemoryContextCallbackFunction: 
    given _tag: Tag[MemoryContextCallbackFunction] = Tag.materializeCFuncPtr1[Ptr[Byte], Unit]
    inline def apply(inline o: CFuncPtr1[Ptr[Byte], Unit]): MemoryContextCallbackFunction = o
    extension (v: MemoryContextCallbackFunction)
      inline def value: CFuncPtr1[Ptr[Byte], Unit] = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  type MultiXactId = TransactionId
  object MultiXactId: 
    given _tag: Tag[MultiXactId] = TransactionId._tag
    inline def apply(inline o: TransactionId): MultiXactId = o
    extension (v: MultiXactId)
      inline def value: TransactionId = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  type MultiXactOffset = uint32
  object MultiXactOffset: 
    given _tag: Tag[MultiXactOffset] = uint32._tag
    inline def apply(inline o: uint32): MultiXactOffset = o
    extension (v: MultiXactOffset)
      inline def value: uint32 = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type Name = Ptr[NameData]
  object Name: 
    given _tag: Tag[Name] = Tag.Ptr[NameData](NameData._tag)
    inline def apply(inline o: Ptr[NameData]): Name = o
    extension (v: Name)
      inline def value: Ptr[NameData] = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type Offset = CInt
  object Offset: 
    given _tag: Tag[Offset] = Tag.Int
    inline def apply(inline o: CInt): Offset = o
    extension (v: Offset)
      inline def value: CInt = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/postgres_ext.h
  */
  opaque type Oid = CUnsignedInt
  object Oid: 
    given _tag: Tag[Oid] = Tag.UInt
    inline def apply(inline o: CUnsignedInt): Oid = o
    extension (v: Oid)
      inline def value: CUnsignedInt = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  opaque type PGFInfoFunction = CFuncPtr0[Ptr[Pg_finfo_record]]
  object PGFInfoFunction: 
    given _tag: Tag[PGFInfoFunction] = Tag.materializeCFuncPtr0[Ptr[Pg_finfo_record]]
    inline def apply(inline o: CFuncPtr0[Ptr[Pg_finfo_record]]): PGFInfoFunction = o
    extension (v: PGFInfoFunction)
      inline def value: CFuncPtr0[Ptr[Pg_finfo_record]] = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  opaque type PGFunction = CFuncPtr1[FunctionCallInfo, Datum]
  object PGFunction: 
    given _tag: Tag[PGFunction] = Tag.materializeCFuncPtr1[FunctionCallInfo, Datum]
    inline def apply(inline o: CFuncPtr1[FunctionCallInfo, Datum]): PGFunction = o
    extension (v: PGFunction)
      inline def value: CFuncPtr1[FunctionCallInfo, Datum] = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  opaque type PGModuleMagicFunction = CFuncPtr0[Ptr[Pg_magic_struct]]
  object PGModuleMagicFunction: 
    given _tag: Tag[PGModuleMagicFunction] = Tag.materializeCFuncPtr0[Ptr[Pg_magic_struct]]
    inline def apply(inline o: CFuncPtr0[Ptr[Pg_magic_struct]]): PGModuleMagicFunction = o
    extension (v: PGModuleMagicFunction)
      inline def value: CFuncPtr0[Ptr[Pg_magic_struct]] = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type Pointer = CString
  object Pointer: 
    given _tag: Tag[Pointer] = Tag.Ptr[CChar](Tag.Byte)
    inline def apply(inline o: CString): Pointer = o
    extension (v: Pointer)
      inline def value: CString = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  type RegProcedure = regproc
  object RegProcedure: 
    given _tag: Tag[RegProcedure] = regproc._tag
    inline def apply(inline o: regproc): RegProcedure = o
    extension (v: RegProcedure)
      inline def value: regproc = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  type Size = size_t
  object Size: 
    given _tag: Tag[Size] = size_t._tag
    inline def apply(inline o: size_t): Size = o
    extension (v: Size)
      inline def value: size_t = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  type SubTransactionId = uint32
  object SubTransactionId: 
    given _tag: Tag[SubTransactionId] = uint32._tag
    inline def apply(inline o: uint32): SubTransactionId = o
    extension (v: SubTransactionId)
      inline def value: uint32 = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  type TransactionId = uint32
  object TransactionId: 
    given _tag: Tag[TransactionId] = uint32._tag
    inline def apply(inline o: uint32): TransactionId = o
    extension (v: TransactionId)
      inline def value: uint32 = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  type bits16 = uint16
  object bits16: 
    given _tag: Tag[bits16] = uint16._tag
    inline def apply(inline o: uint16): bits16 = o
    extension (v: bits16)
      inline def value: uint16 = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  type bits32 = uint32
  object bits32: 
    given _tag: Tag[bits32] = uint32._tag
    inline def apply(inline o: uint32): bits32 = o
    extension (v: bits32)
      inline def value: uint32 = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  type bits8 = uint8
  object bits8: 
    given _tag: Tag[bits8] = uint8._tag
    inline def apply(inline o: uint8): bits8 = o
    extension (v: bits8)
      inline def value: uint8 = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  opaque type emit_log_hook_type = CFuncPtr1[Ptr[ErrorData], Unit]
  object emit_log_hook_type: 
    given _tag: Tag[emit_log_hook_type] = Tag.materializeCFuncPtr1[Ptr[ErrorData], Unit]
    inline def apply(inline o: CFuncPtr1[Ptr[ErrorData], Unit]): emit_log_hook_type = o
    extension (v: emit_log_hook_type)
      inline def value: CFuncPtr1[Ptr[ErrorData], Unit] = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type float4 = Float
  object float4: 
    given _tag: Tag[float4] = Tag.Float
    inline def apply(inline o: Float): float4 = o
    extension (v: float4)
      inline def value: Float = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type float8 = Double
  object float8: 
    given _tag: Tag[float8] = Tag.Double
    inline def apply(inline o: Double): float8 = o
    extension (v: float8)
      inline def value: Double = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  opaque type fmAggrefPtr = Ptr[Aggref]
  object fmAggrefPtr: 
    given _tag: Tag[fmAggrefPtr] = Tag.Ptr[Aggref](Aggref._tag)
    inline def apply(inline o: Ptr[Aggref]): fmAggrefPtr = o
    extension (v: fmAggrefPtr)
      inline def value: Ptr[Aggref] = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  opaque type fmExprContextCallbackFunction = CFuncPtr1[Datum, Unit]
  object fmExprContextCallbackFunction: 
    given _tag: Tag[fmExprContextCallbackFunction] = Tag.materializeCFuncPtr1[Datum, Unit]
    inline def apply(inline o: CFuncPtr1[Datum, Unit]): fmExprContextCallbackFunction = o
    extension (v: fmExprContextCallbackFunction)
      inline def value: CFuncPtr1[Datum, Unit] = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  opaque type fmNodePtr = Ptr[Node]
  object fmNodePtr: 
    given _tag: Tag[fmNodePtr] = Tag.Ptr[Node](Node._tag)
    inline def apply(inline o: Ptr[Node]): fmNodePtr = o
    extension (v: fmNodePtr)
      inline def value: Ptr[Node] = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  opaque type fmStringInfo = Ptr[StringInfoData]
  object fmStringInfo: 
    given _tag: Tag[fmStringInfo] = Tag.Ptr[StringInfoData](StringInfoData._tag)
    inline def apply(inline o: Ptr[StringInfoData]): fmStringInfo = o
    extension (v: fmStringInfo)
      inline def value: Ptr[StringInfoData] = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  opaque type fmgr_hook_type = CFuncPtr3[FmgrHookEventType, Ptr[FmgrInfo], Ptr[Datum], Unit]
  object fmgr_hook_type: 
    given _tag: Tag[fmgr_hook_type] = Tag.materializeCFuncPtr3[FmgrHookEventType, Ptr[FmgrInfo], Ptr[Datum], Unit]
    inline def apply(inline o: CFuncPtr3[FmgrHookEventType, Ptr[FmgrInfo], Ptr[Datum], Unit]): fmgr_hook_type = o
    extension (v: fmgr_hook_type)
      inline def value: CFuncPtr3[FmgrHookEventType, Ptr[FmgrInfo], Ptr[Datum], Unit] = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  type int128 = Unit
  object int128: 
    given _tag: Tag[int128] = Tag.Unit
    inline def apply(inline o: Unit): int128 = o
    extension (v: int128)
      inline def value: Unit = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type int16 = CShort
  object int16: 
    given _tag: Tag[int16] = Tag.Short
    inline def apply(inline o: CShort): int16 = o
    extension (v: int16)
      inline def value: CShort = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type int32 = CInt
  object int32: 
    given _tag: Tag[int32] = Tag.Int
    inline def apply(inline o: CInt): int32 = o
    extension (v: int32)
      inline def value: CInt = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type int64 = CLongInt
  object int64: 
    given _tag: Tag[int64] = Tag.Long
    inline def apply(inline o: CLongInt): int64 = o
    extension (v: int64)
      inline def value: CLongInt = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type int8 = CChar
  object int8: 
    given _tag: Tag[int8] = Tag.Byte
    inline def apply(inline o: CChar): int8 = o
    extension (v: int8)
      inline def value: CChar = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  opaque type needs_fmgr_hook_type = CFuncPtr1[Oid, Boolean]
  object needs_fmgr_hook_type: 
    given _tag: Tag[needs_fmgr_hook_type] = Tag.materializeCFuncPtr1[Oid, Boolean]
    inline def apply(inline o: CFuncPtr1[Oid, Boolean]): needs_fmgr_hook_type = o
    extension (v: needs_fmgr_hook_type)
      inline def value: CFuncPtr1[Oid, Boolean] = v

  type passwd = posix.pwd.passwd
  object passwd: 
    val _tag: Tag[passwd] = summon[Tag[posix.pwd.passwd]]
    inline def apply(inline o: posix.pwd.passwd): passwd = o
    extension (v: passwd)
      inline def value: posix.pwd.passwd = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type pg_funcptr_t = CFuncPtr0[Unit]
  object pg_funcptr_t: 
    given _tag: Tag[pg_funcptr_t] = Tag.materializeCFuncPtr0[Unit]
    inline def apply(inline o: CFuncPtr0[Unit]): pg_funcptr_t = o
    extension (v: pg_funcptr_t)
      inline def value: CFuncPtr0[Unit] = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/postgres_ext.h
  */
  opaque type pg_int64 = CLongInt
  object pg_int64: 
    given _tag: Tag[pg_int64] = Tag.Long
    inline def apply(inline o: CLongInt): pg_int64 = o
    extension (v: pg_int64)
      inline def value: CLongInt = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  opaque type pgsocket = CInt
  object pgsocket: 
    given _tag: Tag[pgsocket] = Tag.Int
    inline def apply(inline o: CInt): pgsocket = o
    extension (v: pgsocket)
      inline def value: CInt = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  opaque type pqsigfunc = CFuncPtr1[CInt, Unit]
  object pqsigfunc: 
    given _tag: Tag[pqsigfunc] = Tag.materializeCFuncPtr1[CInt, Unit]
    inline def apply(inline o: CFuncPtr1[CInt, Unit]): pqsigfunc = o
    extension (v: pqsigfunc)
      inline def value: CFuncPtr1[CInt, Unit] = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  opaque type qsort_arg_comparator = CFuncPtr3[Ptr[Byte], Ptr[Byte], Ptr[Byte], CInt]
  object qsort_arg_comparator: 
    given _tag: Tag[qsort_arg_comparator] = Tag.materializeCFuncPtr3[Ptr[Byte], Ptr[Byte], Ptr[Byte], CInt]
    inline def apply(inline o: CFuncPtr3[Ptr[Byte], Ptr[Byte], Ptr[Byte], CInt]): qsort_arg_comparator = o
    extension (v: qsort_arg_comparator)
      inline def value: CFuncPtr3[Ptr[Byte], Ptr[Byte], Ptr[Byte], CInt] = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  type regproc = Oid
  object regproc: 
    given _tag: Tag[regproc] = Oid._tag
    inline def apply(inline o: Oid): regproc = o
    extension (v: regproc)
      inline def value: Oid = v

  type size_t = libc.stddef.size_t
  object size_t: 
    val _tag: Tag[size_t] = summon[Tag[libc.stddef.size_t]]
    inline def apply(inline o: libc.stddef.size_t): size_t = o
    extension (v: size_t)
      inline def value: libc.stddef.size_t = v

  type uid_t = posix.sys.types.uid_t
  object uid_t: 
    val _tag: Tag[uid_t] = summon[Tag[posix.sys.types.uid_t]]
    inline def apply(inline o: posix.sys.types.uid_t): uid_t = o
    extension (v: uid_t)
      inline def value: posix.sys.types.uid_t = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  type uint128 = Unit
  object uint128: 
    given _tag: Tag[uint128] = Tag.Unit
    inline def apply(inline o: Unit): uint128 = o
    extension (v: uint128)
      inline def value: Unit = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type uint16 = CUnsignedShort
  object uint16: 
    given _tag: Tag[uint16] = Tag.UShort
    inline def apply(inline o: CUnsignedShort): uint16 = o
    extension (v: uint16)
      inline def value: CUnsignedShort = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type uint32 = CUnsignedInt
  object uint32: 
    given _tag: Tag[uint32] = Tag.UInt
    inline def apply(inline o: CUnsignedInt): uint32 = o
    extension (v: uint32)
      inline def value: CUnsignedInt = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type uint64 = CUnsignedLongInt
  object uint64: 
    given _tag: Tag[uint64] = Tag.ULong
    inline def apply(inline o: CUnsignedLongInt): uint64 = o
    extension (v: uint64)
      inline def value: CUnsignedLongInt = v

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type uint8 = CUnsignedChar
  object uint8: 
    given _tag: Tag[uint8] = Tag.UByte
    inline def apply(inline o: CUnsignedChar): uint8 = o
    extension (v: uint8)
      inline def value: CUnsignedChar = v

  /**
   * [bindgen] header: /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/sys/_types/_uintptr_t.h
  */
  opaque type uintptr_t = CUnsignedLongInt
  object uintptr_t: 
    given _tag: Tag[uintptr_t] = Tag.ULong
    inline def apply(inline o: CUnsignedLongInt): uintptr_t = o
    extension (v: uintptr_t)
      inline def value: CUnsignedLongInt = v

  type va_list = unsafe.CVarArgList
  object va_list: 
    val _tag: Tag[va_list] = summon[Tag[unsafe.CVarArgList]]
    inline def apply(inline o: unsafe.CVarArgList): va_list = o
    extension (v: va_list)
      inline def value: unsafe.CVarArgList = v

object structs:
  import _root_.libtest.enumerations.*
  import _root_.libtest.aliases.*
  import _root_.libtest.structs.*
  import _root_.libtest.unions.*

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  opaque type Aggref = CStruct0
  object Aggref:
    given _tag: Tag[Aggref] = Tag.materializeCStruct0Tag

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type BpChar = CStruct1[CArray[CChar, Nat._4]]
  object BpChar:
    given _tag: Tag[BpChar] = Tag.materializeCStruct1Tag[CArray[CChar, Nat._4]]
    def apply()(using Zone): Ptr[BpChar] = scala.scalanative.unsafe.alloc[BpChar](1)
    def apply(`vl_len_` : CArray[CChar, Nat._4])(using Zone): Ptr[BpChar] = 
      val ____ptr = apply()
      (!____ptr).`vl_len_` = `vl_len_`
      ____ptr
    extension (struct: BpChar)
      def `vl_len_` : CArray[CChar, Nat._4] = struct._1
      def vl_len__=(value: CArray[CChar, Nat._4]): Unit = !struct.at1 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  opaque type ErrorContextCallback = CStruct3[Ptr[Byte], CFuncPtr1[Ptr[Byte], Unit], Ptr[Byte]]
  object ErrorContextCallback:
    given _tag: Tag[ErrorContextCallback] = Tag.materializeCStruct3Tag[Ptr[Byte], CFuncPtr1[Ptr[Byte], Unit], Ptr[Byte]]
    def apply()(using Zone): Ptr[ErrorContextCallback] = scala.scalanative.unsafe.alloc[ErrorContextCallback](1)
    def apply(previous : Ptr[ErrorContextCallback], callback : CFuncPtr1[Ptr[Byte], Unit], arg : Ptr[Byte])(using Zone): Ptr[ErrorContextCallback] = 
      val ____ptr = apply()
      (!____ptr).previous = previous
      (!____ptr).callback = callback
      (!____ptr).arg = arg
      ____ptr
    extension (struct: ErrorContextCallback)
      def previous : Ptr[ErrorContextCallback] = struct._1.asInstanceOf[Ptr[ErrorContextCallback]]
      def previous_=(value: Ptr[ErrorContextCallback]): Unit = !struct.at1 = value.asInstanceOf[Ptr[Byte]]
      def callback : CFuncPtr1[Ptr[Byte], Unit] = struct._2
      def callback_=(value: CFuncPtr1[Ptr[Byte], Unit]): Unit = !struct.at2 = value
      def arg : Ptr[Byte] = struct._3
      def arg_=(value: Ptr[Byte]): Unit = !struct.at3 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  opaque type ErrorData = CArray[CChar, Nat.Digit3[Nat._1, Nat._8, Nat._4]]
  object ErrorData:
    /**
     * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
    */
    opaque type Struct0 = CStruct0
    object Struct0:
      given _tag: Tag[Struct0] = Tag.materializeCStruct0Tag
    given _tag: Tag[ErrorData] = Tag.CArray[CChar, Nat.Digit3[Nat._1, Nat._8, Nat._4]](Tag.Byte, Tag.Digit3[Nat._1, Nat._8, Nat._4](Tag.Nat1, Tag.Nat8, Tag.Nat4))
    def apply()(using Zone): Ptr[ErrorData] = scala.scalanative.unsafe.alloc[ErrorData](1)
    def apply(elevel : CInt, output_to_server : Boolean, output_to_client : Boolean, hide_stmt : Boolean, hide_ctx : Boolean, filename : CString, lineno : CInt, funcname : CString, domain : CString, context_domain : CString, sqlerrcode : CInt, message : CString, detail : CString, detail_log : CString, hint : CString, context : CString, backtrace : CString, message_id : CString, schema_name : CString, table_name : CString, column_name : CString, datatype_name : CString, constraint_name : CString, cursorpos : CInt, internalpos : CInt, internalquery : CString, saved_errno : CInt, assoc_context : Ptr[MemoryContextData])(using Zone): Ptr[ErrorData] = 
      val ____ptr = apply()
      (!____ptr).elevel = elevel
      (!____ptr).output_to_server = output_to_server
      (!____ptr).output_to_client = output_to_client
      (!____ptr).hide_stmt = hide_stmt
      (!____ptr).hide_ctx = hide_ctx
      (!____ptr).filename = filename
      (!____ptr).lineno = lineno
      (!____ptr).funcname = funcname
      (!____ptr).domain = domain
      (!____ptr).context_domain = context_domain
      (!____ptr).sqlerrcode = sqlerrcode
      (!____ptr).message = message
      (!____ptr).detail = detail
      (!____ptr).detail_log = detail_log
      (!____ptr).hint = hint
      (!____ptr).context = context
      (!____ptr).backtrace = backtrace
      (!____ptr).message_id = message_id
      (!____ptr).schema_name = schema_name
      (!____ptr).table_name = table_name
      (!____ptr).column_name = column_name
      (!____ptr).datatype_name = datatype_name
      (!____ptr).constraint_name = constraint_name
      (!____ptr).cursorpos = cursorpos
      (!____ptr).internalpos = internalpos
      (!____ptr).internalquery = internalquery
      (!____ptr).saved_errno = saved_errno
      (!____ptr).assoc_context = assoc_context
      ____ptr
    extension (struct: ErrorData)
      def elevel: CInt = !struct.at(0).asInstanceOf[Ptr[CInt]]
      def elevel_=(value: CInt): Unit = !struct.at(0).asInstanceOf[Ptr[CInt]] = value
      def output_to_server: Boolean = !struct.at(4).asInstanceOf[Ptr[Boolean]]
      def output_to_server_=(value: Boolean): Unit = !struct.at(4).asInstanceOf[Ptr[Boolean]] = value
      def output_to_client: Boolean = !struct.at(5).asInstanceOf[Ptr[Boolean]]
      def output_to_client_=(value: Boolean): Unit = !struct.at(5).asInstanceOf[Ptr[Boolean]] = value
      def hide_stmt: Boolean = !struct.at(6).asInstanceOf[Ptr[Boolean]]
      def hide_stmt_=(value: Boolean): Unit = !struct.at(6).asInstanceOf[Ptr[Boolean]] = value
      def hide_ctx: Boolean = !struct.at(7).asInstanceOf[Ptr[Boolean]]
      def hide_ctx_=(value: Boolean): Unit = !struct.at(7).asInstanceOf[Ptr[Boolean]] = value
      def filename: CString = !struct.at(8).asInstanceOf[Ptr[CString]]
      def filename_=(value: CString): Unit = !struct.at(8).asInstanceOf[Ptr[CString]] = value
      def lineno: CInt = !struct.at(16).asInstanceOf[Ptr[CInt]]
      def lineno_=(value: CInt): Unit = !struct.at(16).asInstanceOf[Ptr[CInt]] = value
      def funcname: CString = !struct.at(24).asInstanceOf[Ptr[CString]]
      def funcname_=(value: CString): Unit = !struct.at(24).asInstanceOf[Ptr[CString]] = value
      def domain: CString = !struct.at(32).asInstanceOf[Ptr[CString]]
      def domain_=(value: CString): Unit = !struct.at(32).asInstanceOf[Ptr[CString]] = value
      def context_domain: CString = !struct.at(40).asInstanceOf[Ptr[CString]]
      def context_domain_=(value: CString): Unit = !struct.at(40).asInstanceOf[Ptr[CString]] = value
      def sqlerrcode: CInt = !struct.at(48).asInstanceOf[Ptr[CInt]]
      def sqlerrcode_=(value: CInt): Unit = !struct.at(48).asInstanceOf[Ptr[CInt]] = value
      def message: CString = !struct.at(56).asInstanceOf[Ptr[CString]]
      def message_=(value: CString): Unit = !struct.at(56).asInstanceOf[Ptr[CString]] = value
      def detail: CString = !struct.at(64).asInstanceOf[Ptr[CString]]
      def detail_=(value: CString): Unit = !struct.at(64).asInstanceOf[Ptr[CString]] = value
      def detail_log: CString = !struct.at(72).asInstanceOf[Ptr[CString]]
      def detail_log_=(value: CString): Unit = !struct.at(72).asInstanceOf[Ptr[CString]] = value
      def hint: CString = !struct.at(80).asInstanceOf[Ptr[CString]]
      def hint_=(value: CString): Unit = !struct.at(80).asInstanceOf[Ptr[CString]] = value
      def context: CString = !struct.at(88).asInstanceOf[Ptr[CString]]
      def context_=(value: CString): Unit = !struct.at(88).asInstanceOf[Ptr[CString]] = value
      def backtrace: CString = !struct.at(96).asInstanceOf[Ptr[CString]]
      def backtrace_=(value: CString): Unit = !struct.at(96).asInstanceOf[Ptr[CString]] = value
      def message_id: CString = !struct.at(104).asInstanceOf[Ptr[CString]]
      def message_id_=(value: CString): Unit = !struct.at(104).asInstanceOf[Ptr[CString]] = value
      def schema_name: CString = !struct.at(112).asInstanceOf[Ptr[CString]]
      def schema_name_=(value: CString): Unit = !struct.at(112).asInstanceOf[Ptr[CString]] = value
      def table_name: CString = !struct.at(120).asInstanceOf[Ptr[CString]]
      def table_name_=(value: CString): Unit = !struct.at(120).asInstanceOf[Ptr[CString]] = value
      def column_name: CString = !struct.at(128).asInstanceOf[Ptr[CString]]
      def column_name_=(value: CString): Unit = !struct.at(128).asInstanceOf[Ptr[CString]] = value
      def datatype_name: CString = !struct.at(136).asInstanceOf[Ptr[CString]]
      def datatype_name_=(value: CString): Unit = !struct.at(136).asInstanceOf[Ptr[CString]] = value
      def constraint_name: CString = !struct.at(144).asInstanceOf[Ptr[CString]]
      def constraint_name_=(value: CString): Unit = !struct.at(144).asInstanceOf[Ptr[CString]] = value
      def cursorpos: CInt = !struct.at(152).asInstanceOf[Ptr[CInt]]
      def cursorpos_=(value: CInt): Unit = !struct.at(152).asInstanceOf[Ptr[CInt]] = value
      def internalpos: CInt = !struct.at(156).asInstanceOf[Ptr[CInt]]
      def internalpos_=(value: CInt): Unit = !struct.at(156).asInstanceOf[Ptr[CInt]] = value
      def internalquery: CString = !struct.at(160).asInstanceOf[Ptr[CString]]
      def internalquery_=(value: CString): Unit = !struct.at(160).asInstanceOf[Ptr[CString]] = value
      def saved_errno: CInt = !struct.at(168).asInstanceOf[Ptr[CInt]]
      def saved_errno_=(value: CInt): Unit = !struct.at(168).asInstanceOf[Ptr[CInt]] = value
      def assoc_context: Ptr[MemoryContextData] = !struct.at(176).asInstanceOf[Ptr[Ptr[MemoryContextData]]]
      def assoc_context_=(value: Ptr[MemoryContextData]): Unit = !struct.at(176).asInstanceOf[Ptr[Ptr[MemoryContextData]]] = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/postgres.h
  */
  opaque type ExpandedObjectHeader = CStruct0
  object ExpandedObjectHeader:
    given _tag: Tag[ExpandedObjectHeader] = Tag.materializeCStruct0Tag

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  opaque type FmgrInfo = CStruct9[Ptr[Byte], Oid, CShort, Boolean, Boolean, CUnsignedChar, Ptr[Byte], MemoryContext, fmNodePtr]
  object FmgrInfo:
    given _tag: Tag[FmgrInfo] = Tag.materializeCStruct9Tag[Ptr[Byte], Oid, CShort, Boolean, Boolean, CUnsignedChar, Ptr[Byte], MemoryContext, fmNodePtr]
    def apply()(using Zone): Ptr[FmgrInfo] = scala.scalanative.unsafe.alloc[FmgrInfo](1)
    def apply(fn_addr : PGFunction, fn_oid : Oid, fn_nargs : CShort, fn_strict : Boolean, fn_retset : Boolean, fn_stats : CUnsignedChar, fn_extra : Ptr[Byte], fn_mcxt : MemoryContext, fn_expr : fmNodePtr)(using Zone): Ptr[FmgrInfo] = 
      val ____ptr = apply()
      (!____ptr).fn_addr = fn_addr
      (!____ptr).fn_oid = fn_oid
      (!____ptr).fn_nargs = fn_nargs
      (!____ptr).fn_strict = fn_strict
      (!____ptr).fn_retset = fn_retset
      (!____ptr).fn_stats = fn_stats
      (!____ptr).fn_extra = fn_extra
      (!____ptr).fn_mcxt = fn_mcxt
      (!____ptr).fn_expr = fn_expr
      ____ptr
    extension (struct: FmgrInfo)
      def fn_addr : PGFunction = struct._1.asInstanceOf[PGFunction]
      def fn_addr_=(value: PGFunction): Unit = !struct.at1 = value.asInstanceOf[Ptr[Byte]]
      def fn_oid : Oid = struct._2
      def fn_oid_=(value: Oid): Unit = !struct.at2 = value
      def fn_nargs : CShort = struct._3
      def fn_nargs_=(value: CShort): Unit = !struct.at3 = value
      def fn_strict : Boolean = struct._4
      def fn_strict_=(value: Boolean): Unit = !struct.at4 = value
      def fn_retset : Boolean = struct._5
      def fn_retset_=(value: Boolean): Unit = !struct.at5 = value
      def fn_stats : CUnsignedChar = struct._6
      def fn_stats_=(value: CUnsignedChar): Unit = !struct.at6 = value
      def fn_extra : Ptr[Byte] = struct._7
      def fn_extra_=(value: Ptr[Byte]): Unit = !struct.at7 = value
      def fn_mcxt : MemoryContext = struct._8
      def fn_mcxt_=(value: MemoryContext): Unit = !struct.at8 = value
      def fn_expr : fmNodePtr = struct._9
      def fn_expr_=(value: fmNodePtr): Unit = !struct.at9 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  opaque type FunctionCallInfoBaseData = CStruct6[Ptr[Byte], fmNodePtr, fmNodePtr, Oid, Boolean, CShort]
  object FunctionCallInfoBaseData:
    given _tag: Tag[FunctionCallInfoBaseData] = Tag.materializeCStruct6Tag[Ptr[Byte], fmNodePtr, fmNodePtr, Oid, Boolean, CShort]
    def apply()(using Zone): Ptr[FunctionCallInfoBaseData] = scala.scalanative.unsafe.alloc[FunctionCallInfoBaseData](1)
    def apply(flinfo : Ptr[FmgrInfo], context : fmNodePtr, resultinfo : fmNodePtr, fncollation : Oid, isnull : Boolean, nargs : CShort)(using Zone): Ptr[FunctionCallInfoBaseData] = 
      val ____ptr = apply()
      (!____ptr).flinfo = flinfo
      (!____ptr).context = context
      (!____ptr).resultinfo = resultinfo
      (!____ptr).fncollation = fncollation
      (!____ptr).isnull = isnull
      (!____ptr).nargs = nargs
      ____ptr
    extension (struct: FunctionCallInfoBaseData)
      def flinfo : Ptr[FmgrInfo] = struct._1.asInstanceOf[Ptr[FmgrInfo]]
      def flinfo_=(value: Ptr[FmgrInfo]): Unit = !struct.at1 = value.asInstanceOf[Ptr[Byte]]
      def context : fmNodePtr = struct._2
      def context_=(value: fmNodePtr): Unit = !struct.at2 = value
      def resultinfo : fmNodePtr = struct._3
      def resultinfo_=(value: fmNodePtr): Unit = !struct.at3 = value
      def fncollation : Oid = struct._4
      def fncollation_=(value: Oid): Unit = !struct.at4 = value
      def isnull : Boolean = struct._5
      def isnull_=(value: Boolean): Unit = !struct.at5 = value
      def nargs : CShort = struct._6
      def nargs_=(value: CShort): Unit = !struct.at6 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  opaque type MemoryContextCallback = CStruct3[MemoryContextCallbackFunction, Ptr[Byte], Ptr[Byte]]
  object MemoryContextCallback:
    given _tag: Tag[MemoryContextCallback] = Tag.materializeCStruct3Tag[MemoryContextCallbackFunction, Ptr[Byte], Ptr[Byte]]
    def apply()(using Zone): Ptr[MemoryContextCallback] = scala.scalanative.unsafe.alloc[MemoryContextCallback](1)
    def apply(func : MemoryContextCallbackFunction, arg : Ptr[Byte], next : Ptr[MemoryContextCallback])(using Zone): Ptr[MemoryContextCallback] = 
      val ____ptr = apply()
      (!____ptr).func = func
      (!____ptr).arg = arg
      (!____ptr).next = next
      ____ptr
    extension (struct: MemoryContextCallback)
      def func : MemoryContextCallbackFunction = struct._1
      def func_=(value: MemoryContextCallbackFunction): Unit = !struct.at1 = value
      def arg : Ptr[Byte] = struct._2
      def arg_=(value: Ptr[Byte]): Unit = !struct.at2 = value
      def next : Ptr[MemoryContextCallback] = struct._3.asInstanceOf[Ptr[MemoryContextCallback]]
      def next_=(value: Ptr[MemoryContextCallback]): Unit = !struct.at3 = value.asInstanceOf[Ptr[Byte]]

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  opaque type MemoryContextData = CStruct0
  object MemoryContextData:
    given _tag: Tag[MemoryContextData] = Tag.materializeCStruct0Tag

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type NameData = CStruct1[CArray[CChar, Nat.Digit2[Nat._6, Nat._4]]]
  object NameData:
    given _tag: Tag[NameData] = Tag.materializeCStruct1Tag[CArray[CChar, Nat.Digit2[Nat._6, Nat._4]]]
    def apply()(using Zone): Ptr[NameData] = scala.scalanative.unsafe.alloc[NameData](1)
    def apply(data : CArray[CChar, Nat.Digit2[Nat._6, Nat._4]])(using Zone): Ptr[NameData] = 
      val ____ptr = apply()
      (!____ptr).data = data
      ____ptr
    extension (struct: NameData)
      def data : CArray[CChar, Nat.Digit2[Nat._6, Nat._4]] = struct._1
      def data_=(value: CArray[CChar, Nat.Digit2[Nat._6, Nat._4]]): Unit = !struct.at1 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  opaque type Node = CStruct0
  object Node:
    given _tag: Tag[Node] = Tag.materializeCStruct0Tag

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/postgres.h
  */
  opaque type NullableDatum = CStruct2[Datum, Boolean]
  object NullableDatum:
    given _tag: Tag[NullableDatum] = Tag.materializeCStruct2Tag[Datum, Boolean]
    def apply()(using Zone): Ptr[NullableDatum] = scala.scalanative.unsafe.alloc[NullableDatum](1)
    def apply(value : Datum, isnull : Boolean)(using Zone): Ptr[NullableDatum] = 
      val ____ptr = apply()
      (!____ptr).value = value
      (!____ptr).isnull = isnull
      ____ptr
    extension (struct: NullableDatum)
      def value : Datum = struct._1
      def value_=(value: Datum): Unit = !struct.at1 = value
      def isnull : Boolean = struct._2
      def isnull_=(value: Boolean): Unit = !struct.at2 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  opaque type Pg_finfo_record = CStruct1[CInt]
  object Pg_finfo_record:
    given _tag: Tag[Pg_finfo_record] = Tag.materializeCStruct1Tag[CInt]
    def apply()(using Zone): Ptr[Pg_finfo_record] = scala.scalanative.unsafe.alloc[Pg_finfo_record](1)
    def apply(api_version : CInt)(using Zone): Ptr[Pg_finfo_record] = 
      val ____ptr = apply()
      (!____ptr).api_version = api_version
      ____ptr
    extension (struct: Pg_finfo_record)
      def api_version : CInt = struct._1
      def api_version_=(value: CInt): Unit = !struct.at1 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  opaque type Pg_magic_struct = CStruct6[CInt, CInt, CInt, CInt, CInt, CInt]
  object Pg_magic_struct:
    given _tag: Tag[Pg_magic_struct] = Tag.materializeCStruct6Tag[CInt, CInt, CInt, CInt, CInt, CInt]
    def apply()(using Zone): Ptr[Pg_magic_struct] = scala.scalanative.unsafe.alloc[Pg_magic_struct](1)
    def apply(len : CInt, version : CInt, funcmaxargs : CInt, indexmaxkeys : CInt, namedatalen : CInt, float8byval : CInt)(using Zone): Ptr[Pg_magic_struct] = 
      val ____ptr = apply()
      (!____ptr).len = len
      (!____ptr).version = version
      (!____ptr).funcmaxargs = funcmaxargs
      (!____ptr).indexmaxkeys = indexmaxkeys
      (!____ptr).namedatalen = namedatalen
      (!____ptr).float8byval = float8byval
      ____ptr
    extension (struct: Pg_magic_struct)
      def len : CInt = struct._1
      def len_=(value: CInt): Unit = !struct.at1 = value
      def version : CInt = struct._2
      def version_=(value: CInt): Unit = !struct.at2 = value
      def funcmaxargs : CInt = struct._3
      def funcmaxargs_=(value: CInt): Unit = !struct.at3 = value
      def indexmaxkeys : CInt = struct._4
      def indexmaxkeys_=(value: CInt): Unit = !struct.at4 = value
      def namedatalen : CInt = struct._5
      def namedatalen_=(value: CInt): Unit = !struct.at5 = value
      def float8byval : CInt = struct._6
      def float8byval_=(value: CInt): Unit = !struct.at6 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  opaque type StringInfoData = CStruct0
  object StringInfoData:
    given _tag: Tag[StringInfoData] = Tag.materializeCStruct0Tag

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type VarChar = CStruct1[CArray[CChar, Nat._4]]
  object VarChar:
    given _tag: Tag[VarChar] = Tag.materializeCStruct1Tag[CArray[CChar, Nat._4]]
    def apply()(using Zone): Ptr[VarChar] = scala.scalanative.unsafe.alloc[VarChar](1)
    def apply(`vl_len_` : CArray[CChar, Nat._4])(using Zone): Ptr[VarChar] = 
      val ____ptr = apply()
      (!____ptr).`vl_len_` = `vl_len_`
      ____ptr
    extension (struct: VarChar)
      def `vl_len_` : CArray[CChar, Nat._4] = struct._1
      def vl_len__=(value: CArray[CChar, Nat._4]): Unit = !struct.at1 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type bytea = CStruct1[CArray[CChar, Nat._4]]
  object bytea:
    given _tag: Tag[bytea] = Tag.materializeCStruct1Tag[CArray[CChar, Nat._4]]
    def apply()(using Zone): Ptr[bytea] = scala.scalanative.unsafe.alloc[bytea](1)
    def apply(`vl_len_` : CArray[CChar, Nat._4])(using Zone): Ptr[bytea] = 
      val ____ptr = apply()
      (!____ptr).`vl_len_` = `vl_len_`
      ____ptr
    extension (struct: bytea)
      def `vl_len_` : CArray[CChar, Nat._4] = struct._1
      def vl_len__=(value: CArray[CChar, Nat._4]): Unit = !struct.at1 = value

  /**
   * [bindgen] header: /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/netdb.h
  */
  opaque type hostent = CStruct5[CString, Ptr[CString], CInt, CInt, Ptr[CString]]
  object hostent:
    given _tag: Tag[hostent] = Tag.materializeCStruct5Tag[CString, Ptr[CString], CInt, CInt, Ptr[CString]]
    def apply()(using Zone): Ptr[hostent] = scala.scalanative.unsafe.alloc[hostent](1)
    def apply(h_name : CString, h_aliases : Ptr[CString], h_addrtype : CInt, h_length : CInt, h_addr_list : Ptr[CString])(using Zone): Ptr[hostent] = 
      val ____ptr = apply()
      (!____ptr).h_name = h_name
      (!____ptr).h_aliases = h_aliases
      (!____ptr).h_addrtype = h_addrtype
      (!____ptr).h_length = h_length
      (!____ptr).h_addr_list = h_addr_list
      ____ptr
    extension (struct: hostent)
      def h_name : CString = struct._1
      def h_name_=(value: CString): Unit = !struct.at1 = value
      def h_aliases : Ptr[CString] = struct._2
      def h_aliases_=(value: Ptr[CString]): Unit = !struct.at2 = value
      def h_addrtype : CInt = struct._3
      def h_addrtype_=(value: CInt): Unit = !struct.at3 = value
      def h_length : CInt = struct._4
      def h_length_=(value: CInt): Unit = !struct.at4 = value
      def h_addr_list : Ptr[CString] = struct._5
      def h_addr_list_=(value: Ptr[CString]): Unit = !struct.at5 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type int2vector = CStruct6[int32, CInt, int32, Oid, CInt, CInt]
  object int2vector:
    given _tag: Tag[int2vector] = Tag.materializeCStruct6Tag[int32, CInt, int32, Oid, CInt, CInt]
    def apply()(using Zone): Ptr[int2vector] = scala.scalanative.unsafe.alloc[int2vector](1)
    def apply(`vl_len_` : int32, ndim : CInt, dataoffset : int32, elemtype : Oid, dim1 : CInt, lbound1 : CInt)(using Zone): Ptr[int2vector] = 
      val ____ptr = apply()
      (!____ptr).`vl_len_` = `vl_len_`
      (!____ptr).ndim = ndim
      (!____ptr).dataoffset = dataoffset
      (!____ptr).elemtype = elemtype
      (!____ptr).dim1 = dim1
      (!____ptr).lbound1 = lbound1
      ____ptr
    extension (struct: int2vector)
      def `vl_len_` : int32 = struct._1
      def vl_len__=(value: int32): Unit = !struct.at1 = value
      def ndim : CInt = struct._2
      def ndim_=(value: CInt): Unit = !struct.at2 = value
      def dataoffset : int32 = struct._3
      def dataoffset_=(value: int32): Unit = !struct.at3 = value
      def elemtype : Oid = struct._4
      def elemtype_=(value: Oid): Unit = !struct.at4 = value
      def dim1 : CInt = struct._5
      def dim1_=(value: CInt): Unit = !struct.at5 = value
      def lbound1 : CInt = struct._6
      def lbound1_=(value: CInt): Unit = !struct.at6 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type nameData = CStruct1[CArray[CChar, Nat.Digit2[Nat._6, Nat._4]]]
  object nameData:
    given _tag: Tag[nameData] = Tag.materializeCStruct1Tag[CArray[CChar, Nat.Digit2[Nat._6, Nat._4]]]
    def apply()(using Zone): Ptr[nameData] = scala.scalanative.unsafe.alloc[nameData](1)
    def apply(data : CArray[CChar, Nat.Digit2[Nat._6, Nat._4]])(using Zone): Ptr[nameData] = 
      val ____ptr = apply()
      (!____ptr).data = data
      ____ptr
    extension (struct: nameData)
      def data : CArray[CChar, Nat.Digit2[Nat._6, Nat._4]] = struct._1
      def data_=(value: CArray[CChar, Nat.Digit2[Nat._6, Nat._4]]): Unit = !struct.at1 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type oidvector = CStruct6[int32, CInt, int32, Oid, CInt, CInt]
  object oidvector:
    given _tag: Tag[oidvector] = Tag.materializeCStruct6Tag[int32, CInt, int32, Oid, CInt, CInt]
    def apply()(using Zone): Ptr[oidvector] = scala.scalanative.unsafe.alloc[oidvector](1)
    def apply(`vl_len_` : int32, ndim : CInt, dataoffset : int32, elemtype : Oid, dim1 : CInt, lbound1 : CInt)(using Zone): Ptr[oidvector] = 
      val ____ptr = apply()
      (!____ptr).`vl_len_` = `vl_len_`
      (!____ptr).ndim = ndim
      (!____ptr).dataoffset = dataoffset
      (!____ptr).elemtype = elemtype
      (!____ptr).dim1 = dim1
      (!____ptr).lbound1 = lbound1
      ____ptr
    extension (struct: oidvector)
      def `vl_len_` : int32 = struct._1
      def vl_len__=(value: int32): Unit = !struct.at1 = value
      def ndim : CInt = struct._2
      def ndim_=(value: CInt): Unit = !struct.at2 = value
      def dataoffset : int32 = struct._3
      def dataoffset_=(value: int32): Unit = !struct.at3 = value
      def elemtype : Oid = struct._4
      def elemtype_=(value: Oid): Unit = !struct.at4 = value
      def dim1 : CInt = struct._5
      def dim1_=(value: CInt): Unit = !struct.at5 = value
      def lbound1 : CInt = struct._6
      def lbound1_=(value: CInt): Unit = !struct.at6 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type text = CStruct1[CArray[CChar, Nat._4]]
  object text:
    given _tag: Tag[text] = Tag.materializeCStruct1Tag[CArray[CChar, Nat._4]]
    def apply()(using Zone): Ptr[text] = scala.scalanative.unsafe.alloc[text](1)
    def apply(`vl_len_` : CArray[CChar, Nat._4])(using Zone): Ptr[text] = 
      val ____ptr = apply()
      (!____ptr).`vl_len_` = `vl_len_`
      ____ptr
    extension (struct: text)
      def `vl_len_` : CArray[CChar, Nat._4] = struct._1
      def vl_len__=(value: CArray[CChar, Nat._4]): Unit = !struct.at1 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/postgres.h
  */
  opaque type varatt_expanded = CStruct1[Ptr[ExpandedObjectHeader]]
  object varatt_expanded:
    given _tag: Tag[varatt_expanded] = Tag.materializeCStruct1Tag[Ptr[ExpandedObjectHeader]]
    def apply()(using Zone): Ptr[varatt_expanded] = scala.scalanative.unsafe.alloc[varatt_expanded](1)
    def apply(eohptr : Ptr[ExpandedObjectHeader])(using Zone): Ptr[varatt_expanded] = 
      val ____ptr = apply()
      (!____ptr).eohptr = eohptr
      ____ptr
    extension (struct: varatt_expanded)
      def eohptr : Ptr[ExpandedObjectHeader] = struct._1
      def eohptr_=(value: Ptr[ExpandedObjectHeader]): Unit = !struct.at1 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/postgres.h
  */
  opaque type varatt_external = CStruct4[int32, uint32, Oid, Oid]
  object varatt_external:
    given _tag: Tag[varatt_external] = Tag.materializeCStruct4Tag[int32, uint32, Oid, Oid]
    def apply()(using Zone): Ptr[varatt_external] = scala.scalanative.unsafe.alloc[varatt_external](1)
    def apply(va_rawsize : int32, va_extinfo : uint32, va_valueid : Oid, va_toastrelid : Oid)(using Zone): Ptr[varatt_external] = 
      val ____ptr = apply()
      (!____ptr).va_rawsize = va_rawsize
      (!____ptr).va_extinfo = va_extinfo
      (!____ptr).va_valueid = va_valueid
      (!____ptr).va_toastrelid = va_toastrelid
      ____ptr
    extension (struct: varatt_external)
      def va_rawsize : int32 = struct._1
      def va_rawsize_=(value: int32): Unit = !struct.at1 = value
      def va_extinfo : uint32 = struct._2
      def va_extinfo_=(value: uint32): Unit = !struct.at2 = value
      def va_valueid : Oid = struct._3
      def va_valueid_=(value: Oid): Unit = !struct.at3 = value
      def va_toastrelid : Oid = struct._4
      def va_toastrelid_=(value: Oid): Unit = !struct.at4 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/postgres.h
  */
  opaque type varatt_indirect = CStruct1[Ptr[varlena]]
  object varatt_indirect:
    given _tag: Tag[varatt_indirect] = Tag.materializeCStruct1Tag[Ptr[varlena]]
    def apply()(using Zone): Ptr[varatt_indirect] = scala.scalanative.unsafe.alloc[varatt_indirect](1)
    def apply(pointer : Ptr[varlena])(using Zone): Ptr[varatt_indirect] = 
      val ____ptr = apply()
      (!____ptr).pointer = pointer
      ____ptr
    extension (struct: varatt_indirect)
      def pointer : Ptr[varlena] = struct._1
      def pointer_=(value: Ptr[varlena]): Unit = !struct.at1 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/postgres.h
  */
  opaque type varattrib_1b = CStruct1[uint8]
  object varattrib_1b:
    given _tag: Tag[varattrib_1b] = Tag.materializeCStruct1Tag[uint8]
    def apply()(using Zone): Ptr[varattrib_1b] = scala.scalanative.unsafe.alloc[varattrib_1b](1)
    def apply(va_header : uint8)(using Zone): Ptr[varattrib_1b] = 
      val ____ptr = apply()
      (!____ptr).va_header = va_header
      ____ptr
    extension (struct: varattrib_1b)
      def va_header : uint8 = struct._1
      def va_header_=(value: uint8): Unit = !struct.at1 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/postgres.h
  */
  opaque type varattrib_1b_e = CStruct2[uint8, uint8]
  object varattrib_1b_e:
    given _tag: Tag[varattrib_1b_e] = Tag.materializeCStruct2Tag[uint8, uint8]
    def apply()(using Zone): Ptr[varattrib_1b_e] = scala.scalanative.unsafe.alloc[varattrib_1b_e](1)
    def apply(va_header : uint8, va_tag : uint8)(using Zone): Ptr[varattrib_1b_e] = 
      val ____ptr = apply()
      (!____ptr).va_header = va_header
      (!____ptr).va_tag = va_tag
      ____ptr
    extension (struct: varattrib_1b_e)
      def va_header : uint8 = struct._1
      def va_header_=(value: uint8): Unit = !struct.at1 = value
      def va_tag : uint8 = struct._2
      def va_tag_=(value: uint8): Unit = !struct.at2 = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type varlena = CStruct1[CArray[CChar, Nat._4]]
  object varlena:
    given _tag: Tag[varlena] = Tag.materializeCStruct1Tag[CArray[CChar, Nat._4]]
    def apply()(using Zone): Ptr[varlena] = scala.scalanative.unsafe.alloc[varlena](1)
    def apply(`vl_len_` : CArray[CChar, Nat._4])(using Zone): Ptr[varlena] = 
      val ____ptr = apply()
      (!____ptr).`vl_len_` = `vl_len_`
      ____ptr
    extension (struct: varlena)
      def `vl_len_` : CArray[CChar, Nat._4] = struct._1
      def vl_len__=(value: CArray[CChar, Nat._4]): Unit = !struct.at1 = value

object unions:
  import _root_.libtest.enumerations.*
  import _root_.libtest.aliases.*
  import _root_.libtest.structs.*
  import _root_.libtest.unions.*

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type PGAlignedBlock = CArray[Byte, Nat.Digit4[Nat._8, Nat._1, Nat._9, Nat._2]]
  object PGAlignedBlock:
    given _tag: Tag[PGAlignedBlock] = Tag.CArray[CChar, Nat.Digit4[Nat._8, Nat._1, Nat._9, Nat._2]](Tag.Byte, Tag.Digit4[Nat._8, Nat._1, Nat._9, Nat._2](Tag.Nat8, Tag.Nat1, Tag.Nat9, Tag.Nat2))
    def apply()(using Zone): Ptr[PGAlignedBlock] = 
      val ___ptr = alloc[PGAlignedBlock](1)
      ___ptr
    @scala.annotation.targetName("apply_data")
    def apply(data: CArray[CChar, Nat.Digit4[Nat._8, Nat._1, Nat._9, Nat._2]])(using Zone): Ptr[PGAlignedBlock] =
      val ___ptr = alloc[PGAlignedBlock](1)
      val un = !___ptr
      un.at(0).asInstanceOf[Ptr[CArray[CChar, Nat.Digit4[Nat._8, Nat._1, Nat._9, Nat._2]]]].update(0, data)
      ___ptr
    @scala.annotation.targetName("apply_force_align_d")
    def apply(force_align_d: Double)(using Zone): Ptr[PGAlignedBlock] =
      val ___ptr = alloc[PGAlignedBlock](1)
      val un = !___ptr
      un.at(0).asInstanceOf[Ptr[Double]].update(0, force_align_d)
      ___ptr
    @scala.annotation.targetName("apply_force_align_i64")
    def apply(force_align_i64: int64)(using Zone): Ptr[PGAlignedBlock] =
      val ___ptr = alloc[PGAlignedBlock](1)
      val un = !___ptr
      un.at(0).asInstanceOf[Ptr[int64]].update(0, force_align_i64)
      ___ptr
    extension (struct: PGAlignedBlock)
      def data : CArray[CChar, Nat.Digit4[Nat._8, Nat._1, Nat._9, Nat._2]] = !struct.at(0).asInstanceOf[Ptr[CArray[CChar, Nat.Digit4[Nat._8, Nat._1, Nat._9, Nat._2]]]]
      def data_=(value: CArray[CChar, Nat.Digit4[Nat._8, Nat._1, Nat._9, Nat._2]]): Unit = !struct.at(0).asInstanceOf[Ptr[CArray[CChar, Nat.Digit4[Nat._8, Nat._1, Nat._9, Nat._2]]]] = value
      def force_align_d : Double = !struct.at(0).asInstanceOf[Ptr[Double]]
      def force_align_d_=(value: Double): Unit = !struct.at(0).asInstanceOf[Ptr[Double]] = value
      def force_align_i64 : int64 = !struct.at(0).asInstanceOf[Ptr[int64]]
      def force_align_i64_=(value: int64): Unit = !struct.at(0).asInstanceOf[Ptr[int64]] = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  opaque type PGAlignedXLogBlock = CArray[Byte, Nat.Digit4[Nat._8, Nat._1, Nat._9, Nat._2]]
  object PGAlignedXLogBlock:
    given _tag: Tag[PGAlignedXLogBlock] = Tag.CArray[CChar, Nat.Digit4[Nat._8, Nat._1, Nat._9, Nat._2]](Tag.Byte, Tag.Digit4[Nat._8, Nat._1, Nat._9, Nat._2](Tag.Nat8, Tag.Nat1, Tag.Nat9, Tag.Nat2))
    def apply()(using Zone): Ptr[PGAlignedXLogBlock] = 
      val ___ptr = alloc[PGAlignedXLogBlock](1)
      ___ptr
    @scala.annotation.targetName("apply_data")
    def apply(data: CArray[CChar, Nat.Digit4[Nat._8, Nat._1, Nat._9, Nat._2]])(using Zone): Ptr[PGAlignedXLogBlock] =
      val ___ptr = alloc[PGAlignedXLogBlock](1)
      val un = !___ptr
      un.at(0).asInstanceOf[Ptr[CArray[CChar, Nat.Digit4[Nat._8, Nat._1, Nat._9, Nat._2]]]].update(0, data)
      ___ptr
    @scala.annotation.targetName("apply_force_align_d")
    def apply(force_align_d: Double)(using Zone): Ptr[PGAlignedXLogBlock] =
      val ___ptr = alloc[PGAlignedXLogBlock](1)
      val un = !___ptr
      un.at(0).asInstanceOf[Ptr[Double]].update(0, force_align_d)
      ___ptr
    @scala.annotation.targetName("apply_force_align_i64")
    def apply(force_align_i64: int64)(using Zone): Ptr[PGAlignedXLogBlock] =
      val ___ptr = alloc[PGAlignedXLogBlock](1)
      val un = !___ptr
      un.at(0).asInstanceOf[Ptr[int64]].update(0, force_align_i64)
      ___ptr
    extension (struct: PGAlignedXLogBlock)
      def data : CArray[CChar, Nat.Digit4[Nat._8, Nat._1, Nat._9, Nat._2]] = !struct.at(0).asInstanceOf[Ptr[CArray[CChar, Nat.Digit4[Nat._8, Nat._1, Nat._9, Nat._2]]]]
      def data_=(value: CArray[CChar, Nat.Digit4[Nat._8, Nat._1, Nat._9, Nat._2]]): Unit = !struct.at(0).asInstanceOf[Ptr[CArray[CChar, Nat.Digit4[Nat._8, Nat._1, Nat._9, Nat._2]]]] = value
      def force_align_d : Double = !struct.at(0).asInstanceOf[Ptr[Double]]
      def force_align_d_=(value: Double): Unit = !struct.at(0).asInstanceOf[Ptr[Double]] = value
      def force_align_i64 : int64 = !struct.at(0).asInstanceOf[Ptr[int64]]
      def force_align_i64_=(value: int64): Unit = !struct.at(0).asInstanceOf[Ptr[int64]] = value

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/postgres.h
  */
  opaque type varattrib_4b = CArray[Byte, Nat._8]
  object varattrib_4b:
    /**
     * [bindgen] header: /opt/homebrew/include/postgresql@14/server/postgres.h
    */
    opaque type Struct0 = CStruct1[uint32]
    object Struct0:
      given _tag: Tag[Struct0] = Tag.materializeCStruct1Tag[uint32]
      def apply()(using Zone): Ptr[Struct0] = scala.scalanative.unsafe.alloc[Struct0](1)
      def apply(va_header : uint32)(using Zone): Ptr[Struct0] = 
        val ____ptr = apply()
        (!____ptr).va_header = va_header
        ____ptr
      extension (struct: Struct0)
        def va_header : uint32 = struct._1
        def va_header_=(value: uint32): Unit = !struct.at1 = value
    /**
     * [bindgen] header: /opt/homebrew/include/postgresql@14/server/postgres.h
    */
    opaque type Struct1 = CStruct2[uint32, uint32]
    object Struct1:
      given _tag: Tag[Struct1] = Tag.materializeCStruct2Tag[uint32, uint32]
      def apply()(using Zone): Ptr[Struct1] = scala.scalanative.unsafe.alloc[Struct1](1)
      def apply(va_header : uint32, va_tcinfo : uint32)(using Zone): Ptr[Struct1] = 
        val ____ptr = apply()
        (!____ptr).va_header = va_header
        (!____ptr).va_tcinfo = va_tcinfo
        ____ptr
      extension (struct: Struct1)
        def va_header : uint32 = struct._1
        def va_header_=(value: uint32): Unit = !struct.at1 = value
        def va_tcinfo : uint32 = struct._2
        def va_tcinfo_=(value: uint32): Unit = !struct.at2 = value
    given _tag: Tag[varattrib_4b] = Tag.CArray[CChar, Nat._8](Tag.Byte, Tag.Nat8)
    def apply()(using Zone): Ptr[varattrib_4b] = 
      val ___ptr = alloc[varattrib_4b](1)
      ___ptr
    @scala.annotation.targetName("apply_va_4byte")
    def apply(va_4byte: varattrib_4b.Struct0)(using Zone): Ptr[varattrib_4b] =
      val ___ptr = alloc[varattrib_4b](1)
      val un = !___ptr
      un.at(0).asInstanceOf[Ptr[varattrib_4b.Struct0]].update(0, va_4byte)
      ___ptr
    @scala.annotation.targetName("apply_va_compressed")
    def apply(va_compressed: varattrib_4b.Struct1)(using Zone): Ptr[varattrib_4b] =
      val ___ptr = alloc[varattrib_4b](1)
      val un = !___ptr
      un.at(0).asInstanceOf[Ptr[varattrib_4b.Struct1]].update(0, va_compressed)
      ___ptr
    extension (struct: varattrib_4b)
      def va_4byte : varattrib_4b.Struct0 = !struct.at(0).asInstanceOf[Ptr[varattrib_4b.Struct0]]
      def va_4byte_=(value: varattrib_4b.Struct0): Unit = !struct.at(0).asInstanceOf[Ptr[varattrib_4b.Struct0]] = value
      def va_compressed : varattrib_4b.Struct1 = !struct.at(0).asInstanceOf[Ptr[varattrib_4b.Struct1]]
      def va_compressed_=(value: varattrib_4b.Struct1): Unit = !struct.at(0).asInstanceOf[Ptr[varattrib_4b.Struct1]] = value


@extern
private[libtest] object extern_functions:
  import _root_.libtest.enumerations.*
  import _root_.libtest.aliases.*
  import _root_.libtest.structs.*
  import _root_.libtest.unions.*

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def AggCheckCallContext(fcinfo : FunctionCallInfo, aggcontext : Ptr[MemoryContext]): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def AggGetAggref(fcinfo : FunctionCallInfo): fmAggrefPtr = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def AggGetTempMemoryContext(fcinfo : FunctionCallInfo): MemoryContext = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def AggRegisterCallback(fcinfo : FunctionCallInfo, func : fmExprContextCallbackFunction, arg : Datum): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def AggStateIsShared(fcinfo : FunctionCallInfo): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def CallerFInfoFunctionCall1(func : PGFunction, flinfo : Ptr[FmgrInfo], collation : Oid, arg1 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def CallerFInfoFunctionCall2(func : PGFunction, flinfo : Ptr[FmgrInfo], collation : Oid, arg1 : Datum, arg2 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def CheckFunctionValidatorAccess(validatorOid : Oid, functionOid : Oid): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def CopyErrorData(): Ptr[ErrorData] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/postgres.h
  */
  def DatumGetFloat4(X : Datum): float4 = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/postgres.h
  */
  def DatumGetFloat8(X : Datum): float8 = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def DebugFileOpen(): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def DirectFunctionCall1Coll(func : PGFunction, collation : Oid, arg1 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def DirectFunctionCall2Coll(func : PGFunction, collation : Oid, arg1 : Datum, arg2 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def DirectFunctionCall3Coll(func : PGFunction, collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def DirectFunctionCall4Coll(func : PGFunction, collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum, arg4 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def DirectFunctionCall5Coll(func : PGFunction, collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum, arg4 : Datum, arg5 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def DirectFunctionCall6Coll(func : PGFunction, collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum, arg4 : Datum, arg5 : Datum, arg6 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def DirectFunctionCall7Coll(func : PGFunction, collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum, arg4 : Datum, arg5 : Datum, arg6 : Datum, arg7 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def DirectFunctionCall8Coll(func : PGFunction, collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum, arg4 : Datum, arg5 : Datum, arg6 : Datum, arg7 : Datum, arg8 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def DirectFunctionCall9Coll(func : PGFunction, collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum, arg4 : Datum, arg5 : Datum, arg6 : Datum, arg7 : Datum, arg8 : Datum, arg9 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def EmitErrorReport(): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def EstimateLibraryStateSpace(): Size = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  def ExceptionalCondition(conditionName : CString, errorType : CString, fileName : CString, lineNumber : CInt): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/postgres.h
  */
  def Float4GetDatum(X : float4): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/postgres.h
  */
  def Float8GetDatum(X : float8): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def FlushErrorState(): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def FreeErrorData(edata : Ptr[ErrorData]): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def FunctionCall0Coll(flinfo : Ptr[FmgrInfo], collation : Oid): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def FunctionCall1Coll(flinfo : Ptr[FmgrInfo], collation : Oid, arg1 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def FunctionCall2Coll(flinfo : Ptr[FmgrInfo], collation : Oid, arg1 : Datum, arg2 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def FunctionCall3Coll(flinfo : Ptr[FmgrInfo], collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def FunctionCall4Coll(flinfo : Ptr[FmgrInfo], collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum, arg4 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def FunctionCall5Coll(flinfo : Ptr[FmgrInfo], collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum, arg4 : Datum, arg5 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def FunctionCall6Coll(flinfo : Ptr[FmgrInfo], collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum, arg4 : Datum, arg5 : Datum, arg6 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def FunctionCall7Coll(flinfo : Ptr[FmgrInfo], collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum, arg4 : Datum, arg5 : Datum, arg6 : Datum, arg7 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def FunctionCall8Coll(flinfo : Ptr[FmgrInfo], collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum, arg4 : Datum, arg5 : Datum, arg6 : Datum, arg7 : Datum, arg8 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def FunctionCall9Coll(flinfo : Ptr[FmgrInfo], collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum, arg4 : Datum, arg5 : Datum, arg6 : Datum, arg7 : Datum, arg8 : Datum, arg9 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def GetErrorContextStack(): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def InputFunctionCall(flinfo : Ptr[FmgrInfo], str : CString, typioparam : Oid, typmod : int32): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def MemoryContextAlloc(context : MemoryContext, size : Size): Ptr[Byte] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def MemoryContextAllocExtended(context : MemoryContext, size : Size, flags : CInt): Ptr[Byte] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def MemoryContextAllocHuge(context : MemoryContext, size : Size): Ptr[Byte] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def MemoryContextAllocZero(context : MemoryContext, size : Size): Ptr[Byte] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def MemoryContextAllocZeroAligned(context : MemoryContext, size : Size): Ptr[Byte] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def MemoryContextRegisterResetCallback(context : MemoryContext, cb : Ptr[MemoryContextCallback]): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def MemoryContextStrdup(context : MemoryContext, string : CString): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def MemoryContextSwitchTo(context : MemoryContext): MemoryContext = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def OidFunctionCall0Coll(functionId : Oid, collation : Oid): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def OidFunctionCall1Coll(functionId : Oid, collation : Oid, arg1 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def OidFunctionCall2Coll(functionId : Oid, collation : Oid, arg1 : Datum, arg2 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def OidFunctionCall3Coll(functionId : Oid, collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def OidFunctionCall4Coll(functionId : Oid, collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum, arg4 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def OidFunctionCall5Coll(functionId : Oid, collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum, arg4 : Datum, arg5 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def OidFunctionCall6Coll(functionId : Oid, collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum, arg4 : Datum, arg5 : Datum, arg6 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def OidFunctionCall7Coll(functionId : Oid, collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum, arg4 : Datum, arg5 : Datum, arg6 : Datum, arg7 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def OidFunctionCall8Coll(functionId : Oid, collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum, arg4 : Datum, arg5 : Datum, arg6 : Datum, arg7 : Datum, arg8 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def OidFunctionCall9Coll(functionId : Oid, collation : Oid, arg1 : Datum, arg2 : Datum, arg3 : Datum, arg4 : Datum, arg5 : Datum, arg6 : Datum, arg7 : Datum, arg8 : Datum, arg9 : Datum): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def OidInputFunctionCall(functionId : Oid, str : CString, typioparam : Oid, typmod : int32): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def OidOutputFunctionCall(functionId : Oid, `val` : Datum): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def OidReceiveFunctionCall(functionId : Oid, buf : fmStringInfo, typioparam : Oid, typmod : int32): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def OidSendFunctionCall(functionId : Oid, `val` : Datum): Ptr[bytea] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def OutputFunctionCall(flinfo : Ptr[FmgrInfo], `val` : Datum): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def ReThrowError(edata : Ptr[ErrorData]): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def ReceiveFunctionCall(flinfo : Ptr[FmgrInfo], buf : fmStringInfo, typioparam : Oid, typmod : int32): Datum = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def RestoreLibraryState(start_address : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def SendFunctionCall(flinfo : Ptr[FmgrInfo], `val` : Datum): Ptr[bytea] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def SerializeLibraryState(maxsize : Size, start_address : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def ThrowErrorData(edata : Ptr[ErrorData]): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def bsearch_arg(key : Ptr[Byte], base : Ptr[Byte], nmemb : size_t, size : size_t, compar : CFuncPtr3[Ptr[Byte], Ptr[Byte], Ptr[Byte], CInt], arg : Ptr[Byte]): Ptr[Byte] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def canonicalize_path(path : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def cleanup_path(path : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def clear_external_function_hash(filehandle : Ptr[Byte]): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def err_generic_string(field : CInt, str : CString): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errbacktrace(): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errcode(sqlerrcode : CInt): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errcode_for_file_access(): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errcode_for_socket_access(): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errcontext_msg(fmt : CString, rest: Any*): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errdetail(fmt : CString, rest: Any*): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errdetail_internal(fmt : CString, rest: Any*): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errdetail_log(fmt : CString, rest: Any*): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errdetail_log_plural(fmt_singular : CString, fmt_plural : CString, n : CUnsignedLongInt, rest: Any*): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errdetail_plural(fmt_singular : CString, fmt_plural : CString, n : CUnsignedLongInt, rest: Any*): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errfinish(filename : CString, lineno : CInt, funcname : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errhidecontext(hide_ctx : Boolean): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errhidestmt(hide_stmt : Boolean): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errhint(fmt : CString, rest: Any*): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errhint_plural(fmt_singular : CString, fmt_plural : CString, n : CUnsignedLongInt, rest: Any*): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errmsg(fmt : CString, rest: Any*): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errmsg_internal(fmt : CString, rest: Any*): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errmsg_plural(fmt_singular : CString, fmt_plural : CString, n : CUnsignedLongInt, rest: Any*): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errposition(cursorpos : CInt): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errstart(elevel : CInt, domain : CString): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def errstart_cold(elevel : CInt, domain : CString): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def escape_single_quotes_ascii(src : CString): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def explicit_bzero(buf : Ptr[Byte], len : size_t): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/c.h
  */
  def fdatasync(fildes : CInt): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def fetch_finfo_record(filehandle : Ptr[Byte], funcname : CString): Ptr[Pg_finfo_record] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def find_my_exec(argv0 : CString, retpath : CString): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def find_other_exec(argv0 : CString, target : CString, versionstr : CString, retpath : CString): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def find_rendezvous_variable(varName : CString): Ptr[Ptr[Byte]] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def first_dir_separator(filename : CString): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def first_path_var_separator(pathlist : CString): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def fmgr_info(functionId : Oid, finfo : Ptr[FmgrInfo]): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def fmgr_info_copy(dstinfo : Ptr[FmgrInfo], srcinfo : Ptr[FmgrInfo], destcxt : MemoryContext): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def fmgr_info_cxt(functionId : Oid, finfo : Ptr[FmgrInfo], mcxt : MemoryContext): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def fmgr_internal_function(proname : CString): Oid = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def fmgr_symbol(functionId : Oid, mod : Ptr[CString], fn : Ptr[CString]): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def format_elog_string(fmt : CString, rest: Any*): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def get_call_expr_arg_stable(expr : fmNodePtr, argnum : CInt): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def get_call_expr_argtype(expr : fmNodePtr, argnum : CInt): Oid = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def get_doc_path(my_exec_path : CString, ret_path : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def get_etc_path(my_exec_path : CString, ret_path : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def get_fn_expr_arg_stable(flinfo : Ptr[FmgrInfo], argnum : CInt): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def get_fn_expr_argtype(flinfo : Ptr[FmgrInfo], argnum : CInt): Oid = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def get_fn_expr_rettype(flinfo : Ptr[FmgrInfo]): Oid = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def get_fn_expr_variadic(flinfo : Ptr[FmgrInfo]): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def get_fn_opclass_options(flinfo : Ptr[FmgrInfo]): Ptr[bytea] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def get_home_path(ret_path : CString): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def get_html_path(my_exec_path : CString, ret_path : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def get_include_path(my_exec_path : CString, ret_path : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def get_includeserver_path(my_exec_path : CString, ret_path : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def get_lib_path(my_exec_path : CString, ret_path : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def get_locale_path(my_exec_path : CString, ret_path : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def get_man_path(my_exec_path : CString, ret_path : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def get_parent_directory(path : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def get_pkginclude_path(my_exec_path : CString, ret_path : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def get_pkglib_path(my_exec_path : CString, ret_path : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def get_progname(argv0 : CString): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def get_share_path(my_exec_path : CString, ret_path : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def geterrcode(): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def geterrposition(): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def getinternalerrposition(): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def has_drive_prefix(filename : CString): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def has_fn_opclass_options(flinfo : Ptr[FmgrInfo]): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def in_error_recursion_trouble(): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def internalerrposition(cursorpos : CInt): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def internalerrquery(query : CString): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def join_path_components(ret_path : CString, head : CString, tail : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def last_dir_separator(filename : CString): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def load_external_function(filename : CString, funcname : CString, signalNotFound : Boolean, filehandle : Ptr[Ptr[Byte]]): Ptr[Byte] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def load_file(filename : CString, restricted : Boolean): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def lookup_external_function(filehandle : Ptr[Byte], funcname : CString): Ptr[Byte] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def make_absolute_path(path : CString): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def make_native_path(path : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def message_level_is_interesting(elevel : CInt): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def palloc(size : Size): Ptr[Byte] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def palloc0(size : Size): Ptr[Byte] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def palloc_extended(size : Size, flags : CInt): Ptr[Byte] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def path_contains_parent_reference(path : CString): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def path_is_prefix_of_path(path1 : CString, path2 : CString): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def path_is_relative_and_below_cwd(path : CString): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def pchomp(in : CString): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pclose_check(stream : Ptr[FILE]): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def pfree(pointer : Ptr[Byte]): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_ascii_tolower(ch : CUnsignedChar): CUnsignedChar = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_ascii_toupper(ch : CUnsignedChar): CUnsignedChar = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_check_dir(dir : CString): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def pg_detoast_datum(datum : Ptr[varlena]): Ptr[varlena] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def pg_detoast_datum_copy(datum : Ptr[varlena]): Ptr[varlena] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def pg_detoast_datum_packed(datum : Ptr[varlena]): Ptr[varlena] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def pg_detoast_datum_slice(datum : Ptr[varlena], first : int32, count : int32): Ptr[varlena] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_erand48(xseed : CArray[CUnsignedShort, Nat._3]): Double = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_fprintf(stream : Ptr[FILE], fmt : CString, rest: Any*): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_get_encoding_from_locale(ctype : CString, write_message : Boolean): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_inet_net_ntop(af : CInt, src : Ptr[Byte], bits : CInt, dst : CString, size : size_t): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_jrand48(xseed : CArray[CUnsignedShort, Nat._3]): CLongInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_lrand48(): CLongInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_mkdir_p(path : CString, omode : CInt): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_printf(fmt : CString, rest: Any*): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_qsort(base : Ptr[Byte], nel : size_t, elsize : size_t, cmp : CFuncPtr2[Ptr[Byte], Ptr[Byte], CInt]): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_qsort_strcmp(a : Ptr[Byte], b : Ptr[Byte]): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def pg_re_throw(): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_set_block(sock : pgsocket): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_set_noblock(sock : pgsocket): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_snprintf(str : CString, count : size_t, fmt : CString, rest: Any*): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_sprintf(str : CString, fmt : CString, rest: Any*): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_srand48(seed : CLongInt): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_strcasecmp(s1 : CString, s2 : CString): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_strerror(errnum : CInt): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_strerror_r(errnum : CInt, buf : CString, buflen : size_t): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_strfromd(str : CString, count : size_t, precision : CInt, value : Double): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_strncasecmp(s1 : CString, s2 : CString, n : size_t): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_strong_random(buf : Ptr[Byte], len : size_t): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_strong_random_init(): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_strsignal(signum : CInt): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_tolower(ch : CUnsignedChar): CUnsignedChar = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_toupper(ch : CUnsignedChar): CUnsignedChar = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_usleep(microsec : CLongInt): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_vfprintf(stream : Ptr[FILE], fmt : CString, args : va_list): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_vprintf(fmt : CString, args : va_list): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_vsnprintf(str : CString, count : size_t, fmt : CString, args : va_list): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pg_vsprintf(str : CString, fmt : CString, args : va_list): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pgfnames(path : CString): Ptr[CString] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pgfnames_cleanup(filenames : Ptr[CString]): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pipe_read_line(cmd : CString, line : CString, maxsize : CInt): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def pnstrdup(in : CString, len : Size): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pqGethostbyname(name : CString, resultbuf : Ptr[hostent], buffer : CString, buflen : size_t, result : Ptr[Ptr[hostent]], herrno : Ptr[CInt]): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pqGetpwuid(uid : uid_t, resultbuf : Ptr[passwd], buffer : CString, buflen : size_t, result : Ptr[Ptr[passwd]]): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def pqsignal(signo : CInt, func : pqsigfunc): pqsigfunc = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def pre_format_elog_string(errnumber : CInt, domain : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def psprintf(fmt : CString, rest: Any*): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def pstrdup(in : CString): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def pvsnprintf(buf : CString, len : size_t, fmt : CString, args : va_list): size_t = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def qsort_arg(base : Ptr[Byte], nel : size_t, elsize : size_t, cmp : qsort_arg_comparator, arg : Ptr[Byte]): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def qsort_interruptible(base : Ptr[Byte], nel : size_t, elsize : size_t, cmp : qsort_arg_comparator, arg : Ptr[Byte]): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def repalloc(pointer : Ptr[Byte], size : Size): Ptr[Byte] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/palloc.h
  */
  def repalloc_huge(pointer : Ptr[Byte], size : Size): Ptr[Byte] = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def rmtree(path : CString, rmtopdir : Boolean): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def set_errcontext_domain(domain : CString): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/fmgr.h
  */
  def set_fn_opclass_options(flinfo : Ptr[FmgrInfo], options : Ptr[bytea]): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def set_pglocale_pgservice(argv0 : CString, app : CString): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def set_syslog_parameters(ident : CString, facility : CInt): Unit = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def unpack_sql_state(sql_state : CInt): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def validate_exec(path : CString): CInt = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def wait_result_is_any_signal(exit_status : CInt, include_command_not_found : Boolean): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def wait_result_is_signal(exit_status : CInt, signum : CInt): Boolean = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/port.h
  */
  def wait_result_to_str(exit_status : CInt): CString = extern

  /**
   * [bindgen] header: /opt/homebrew/include/postgresql@14/server/utils/elog.h
  */
  def write_stderr(fmt : CString, rest: Any*): Unit = extern


object functions:
  import _root_.libtest.enumerations.*
  import _root_.libtest.aliases.*
  import _root_.libtest.structs.*
  import _root_.libtest.unions.*

  import extern_functions.*
  export extern_functions.*

object types:
  export _root_.libtest.structs.*
  export _root_.libtest.aliases.*
  export _root_.libtest.unions.*
  export _root_.libtest.enumerations.*

object all:
  export _root_.libtest.enumerations.FmgrHookEventType
  export _root_.libtest.enumerations.PGErrorVerbosity
  export _root_.libtest.enumerations.vartag_external
  export _root_.libtest.aliases.CommandId
  export _root_.libtest.aliases.Datum
  export _root_.libtest.aliases.FILE
  export _root_.libtest.aliases.FunctionCallInfo
  export _root_.libtest.aliases.Index
  export _root_.libtest.aliases.LocalTransactionId
  export _root_.libtest.aliases.MemoryContext
  export _root_.libtest.aliases.MemoryContextCallbackFunction
  export _root_.libtest.aliases.MultiXactId
  export _root_.libtest.aliases.MultiXactOffset
  export _root_.libtest.aliases.Name
  export _root_.libtest.aliases.Offset
  export _root_.libtest.aliases.Oid
  export _root_.libtest.aliases.PGFInfoFunction
  export _root_.libtest.aliases.PGFunction
  export _root_.libtest.aliases.PGModuleMagicFunction
  export _root_.libtest.aliases.Pointer
  export _root_.libtest.aliases.RegProcedure
  export _root_.libtest.aliases.Size
  export _root_.libtest.aliases.SubTransactionId
  export _root_.libtest.aliases.TransactionId
  export _root_.libtest.aliases.bits16
  export _root_.libtest.aliases.bits32
  export _root_.libtest.aliases.bits8
  export _root_.libtest.aliases.emit_log_hook_type
  export _root_.libtest.aliases.float4
  export _root_.libtest.aliases.float8
  export _root_.libtest.aliases.fmAggrefPtr
  export _root_.libtest.aliases.fmExprContextCallbackFunction
  export _root_.libtest.aliases.fmNodePtr
  export _root_.libtest.aliases.fmStringInfo
  export _root_.libtest.aliases.fmgr_hook_type
  export _root_.libtest.aliases.int128
  export _root_.libtest.aliases.int16
  export _root_.libtest.aliases.int32
  export _root_.libtest.aliases.int64
  export _root_.libtest.aliases.int8
  export _root_.libtest.aliases.needs_fmgr_hook_type
  export _root_.libtest.aliases.passwd
  export _root_.libtest.aliases.pg_funcptr_t
  export _root_.libtest.aliases.pg_int64
  export _root_.libtest.aliases.pgsocket
  export _root_.libtest.aliases.pqsigfunc
  export _root_.libtest.aliases.qsort_arg_comparator
  export _root_.libtest.aliases.regproc
  export _root_.libtest.aliases.size_t
  export _root_.libtest.aliases.uid_t
  export _root_.libtest.aliases.uint128
  export _root_.libtest.aliases.uint16
  export _root_.libtest.aliases.uint32
  export _root_.libtest.aliases.uint64
  export _root_.libtest.aliases.uint8
  export _root_.libtest.aliases.uintptr_t
  export _root_.libtest.aliases.va_list
  export _root_.libtest.structs.Aggref
  export _root_.libtest.structs.BpChar
  export _root_.libtest.structs.ErrorContextCallback
  export _root_.libtest.structs.ErrorData
  export _root_.libtest.structs.ExpandedObjectHeader
  export _root_.libtest.structs.FmgrInfo
  export _root_.libtest.structs.FunctionCallInfoBaseData
  export _root_.libtest.structs.MemoryContextCallback
  export _root_.libtest.structs.MemoryContextData
  export _root_.libtest.structs.NameData
  export _root_.libtest.structs.Node
  export _root_.libtest.structs.NullableDatum
  export _root_.libtest.structs.Pg_finfo_record
  export _root_.libtest.structs.Pg_magic_struct
  export _root_.libtest.structs.StringInfoData
  export _root_.libtest.structs.VarChar
  export _root_.libtest.structs.bytea
  export _root_.libtest.structs.hostent
  export _root_.libtest.structs.int2vector
  export _root_.libtest.structs.nameData
  export _root_.libtest.structs.oidvector
  export _root_.libtest.structs.text
  export _root_.libtest.structs.varatt_expanded
  export _root_.libtest.structs.varatt_external
  export _root_.libtest.structs.varatt_indirect
  export _root_.libtest.structs.varattrib_1b
  export _root_.libtest.structs.varattrib_1b_e
  export _root_.libtest.structs.varlena
  export _root_.libtest.unions.PGAlignedBlock
  export _root_.libtest.unions.PGAlignedXLogBlock
  export _root_.libtest.unions.varattrib_4b
  export _root_.libtest.functions.AggCheckCallContext
  export _root_.libtest.functions.AggGetAggref
  export _root_.libtest.functions.AggGetTempMemoryContext
  export _root_.libtest.functions.AggRegisterCallback
  export _root_.libtest.functions.AggStateIsShared
  export _root_.libtest.functions.CallerFInfoFunctionCall1
  export _root_.libtest.functions.CallerFInfoFunctionCall2
  export _root_.libtest.functions.CheckFunctionValidatorAccess
  export _root_.libtest.functions.CopyErrorData
  export _root_.libtest.functions.DatumGetFloat4
  export _root_.libtest.functions.DatumGetFloat8
  export _root_.libtest.functions.DebugFileOpen
  export _root_.libtest.functions.DirectFunctionCall1Coll
  export _root_.libtest.functions.DirectFunctionCall2Coll
  export _root_.libtest.functions.DirectFunctionCall3Coll
  export _root_.libtest.functions.DirectFunctionCall4Coll
  export _root_.libtest.functions.DirectFunctionCall5Coll
  export _root_.libtest.functions.DirectFunctionCall6Coll
  export _root_.libtest.functions.DirectFunctionCall7Coll
  export _root_.libtest.functions.DirectFunctionCall8Coll
  export _root_.libtest.functions.DirectFunctionCall9Coll
  export _root_.libtest.functions.EmitErrorReport
  export _root_.libtest.functions.EstimateLibraryStateSpace
  export _root_.libtest.functions.ExceptionalCondition
  export _root_.libtest.functions.Float4GetDatum
  export _root_.libtest.functions.Float8GetDatum
  export _root_.libtest.functions.FlushErrorState
  export _root_.libtest.functions.FreeErrorData
  export _root_.libtest.functions.FunctionCall0Coll
  export _root_.libtest.functions.FunctionCall1Coll
  export _root_.libtest.functions.FunctionCall2Coll
  export _root_.libtest.functions.FunctionCall3Coll
  export _root_.libtest.functions.FunctionCall4Coll
  export _root_.libtest.functions.FunctionCall5Coll
  export _root_.libtest.functions.FunctionCall6Coll
  export _root_.libtest.functions.FunctionCall7Coll
  export _root_.libtest.functions.FunctionCall8Coll
  export _root_.libtest.functions.FunctionCall9Coll
  export _root_.libtest.functions.GetErrorContextStack
  export _root_.libtest.functions.InputFunctionCall
  export _root_.libtest.functions.MemoryContextAlloc
  export _root_.libtest.functions.MemoryContextAllocExtended
  export _root_.libtest.functions.MemoryContextAllocHuge
  export _root_.libtest.functions.MemoryContextAllocZero
  export _root_.libtest.functions.MemoryContextAllocZeroAligned
  export _root_.libtest.functions.MemoryContextRegisterResetCallback
  export _root_.libtest.functions.MemoryContextStrdup
  export _root_.libtest.functions.MemoryContextSwitchTo
  export _root_.libtest.functions.OidFunctionCall0Coll
  export _root_.libtest.functions.OidFunctionCall1Coll
  export _root_.libtest.functions.OidFunctionCall2Coll
  export _root_.libtest.functions.OidFunctionCall3Coll
  export _root_.libtest.functions.OidFunctionCall4Coll
  export _root_.libtest.functions.OidFunctionCall5Coll
  export _root_.libtest.functions.OidFunctionCall6Coll
  export _root_.libtest.functions.OidFunctionCall7Coll
  export _root_.libtest.functions.OidFunctionCall8Coll
  export _root_.libtest.functions.OidFunctionCall9Coll
  export _root_.libtest.functions.OidInputFunctionCall
  export _root_.libtest.functions.OidOutputFunctionCall
  export _root_.libtest.functions.OidReceiveFunctionCall
  export _root_.libtest.functions.OidSendFunctionCall
  export _root_.libtest.functions.OutputFunctionCall
  export _root_.libtest.functions.ReThrowError
  export _root_.libtest.functions.ReceiveFunctionCall
  export _root_.libtest.functions.RestoreLibraryState
  export _root_.libtest.functions.SendFunctionCall
  export _root_.libtest.functions.SerializeLibraryState
  export _root_.libtest.functions.ThrowErrorData
  export _root_.libtest.functions.bsearch_arg
  export _root_.libtest.functions.canonicalize_path
  export _root_.libtest.functions.cleanup_path
  export _root_.libtest.functions.clear_external_function_hash
  export _root_.libtest.functions.err_generic_string
  export _root_.libtest.functions.errbacktrace
  export _root_.libtest.functions.errcode
  export _root_.libtest.functions.errcode_for_file_access
  export _root_.libtest.functions.errcode_for_socket_access
  export _root_.libtest.functions.errcontext_msg
  export _root_.libtest.functions.errdetail
  export _root_.libtest.functions.errdetail_internal
  export _root_.libtest.functions.errdetail_log
  export _root_.libtest.functions.errdetail_log_plural
  export _root_.libtest.functions.errdetail_plural
  export _root_.libtest.functions.errfinish
  export _root_.libtest.functions.errhidecontext
  export _root_.libtest.functions.errhidestmt
  export _root_.libtest.functions.errhint
  export _root_.libtest.functions.errhint_plural
  export _root_.libtest.functions.errmsg
  export _root_.libtest.functions.errmsg_internal
  export _root_.libtest.functions.errmsg_plural
  export _root_.libtest.functions.errposition
  export _root_.libtest.functions.errstart
  export _root_.libtest.functions.errstart_cold
  export _root_.libtest.functions.escape_single_quotes_ascii
  export _root_.libtest.functions.explicit_bzero
  export _root_.libtest.functions.fdatasync
  export _root_.libtest.functions.fetch_finfo_record
  export _root_.libtest.functions.find_my_exec
  export _root_.libtest.functions.find_other_exec
  export _root_.libtest.functions.find_rendezvous_variable
  export _root_.libtest.functions.first_dir_separator
  export _root_.libtest.functions.first_path_var_separator
  export _root_.libtest.functions.fmgr_info
  export _root_.libtest.functions.fmgr_info_copy
  export _root_.libtest.functions.fmgr_info_cxt
  export _root_.libtest.functions.fmgr_internal_function
  export _root_.libtest.functions.fmgr_symbol
  export _root_.libtest.functions.format_elog_string
  export _root_.libtest.functions.get_call_expr_arg_stable
  export _root_.libtest.functions.get_call_expr_argtype
  export _root_.libtest.functions.get_doc_path
  export _root_.libtest.functions.get_etc_path
  export _root_.libtest.functions.get_fn_expr_arg_stable
  export _root_.libtest.functions.get_fn_expr_argtype
  export _root_.libtest.functions.get_fn_expr_rettype
  export _root_.libtest.functions.get_fn_expr_variadic
  export _root_.libtest.functions.get_fn_opclass_options
  export _root_.libtest.functions.get_home_path
  export _root_.libtest.functions.get_html_path
  export _root_.libtest.functions.get_include_path
  export _root_.libtest.functions.get_includeserver_path
  export _root_.libtest.functions.get_lib_path
  export _root_.libtest.functions.get_locale_path
  export _root_.libtest.functions.get_man_path
  export _root_.libtest.functions.get_parent_directory
  export _root_.libtest.functions.get_pkginclude_path
  export _root_.libtest.functions.get_pkglib_path
  export _root_.libtest.functions.get_progname
  export _root_.libtest.functions.get_share_path
  export _root_.libtest.functions.geterrcode
  export _root_.libtest.functions.geterrposition
  export _root_.libtest.functions.getinternalerrposition
  export _root_.libtest.functions.has_drive_prefix
  export _root_.libtest.functions.has_fn_opclass_options
  export _root_.libtest.functions.in_error_recursion_trouble
  export _root_.libtest.functions.internalerrposition
  export _root_.libtest.functions.internalerrquery
  export _root_.libtest.functions.join_path_components
  export _root_.libtest.functions.last_dir_separator
  export _root_.libtest.functions.load_external_function
  export _root_.libtest.functions.load_file
  export _root_.libtest.functions.lookup_external_function
  export _root_.libtest.functions.make_absolute_path
  export _root_.libtest.functions.make_native_path
  export _root_.libtest.functions.message_level_is_interesting
  export _root_.libtest.functions.palloc
  export _root_.libtest.functions.palloc0
  export _root_.libtest.functions.palloc_extended
  export _root_.libtest.functions.path_contains_parent_reference
  export _root_.libtest.functions.path_is_prefix_of_path
  export _root_.libtest.functions.path_is_relative_and_below_cwd
  export _root_.libtest.functions.pchomp
  export _root_.libtest.functions.pclose_check
  export _root_.libtest.functions.pfree
  export _root_.libtest.functions.pg_ascii_tolower
  export _root_.libtest.functions.pg_ascii_toupper
  export _root_.libtest.functions.pg_check_dir
  export _root_.libtest.functions.pg_detoast_datum
  export _root_.libtest.functions.pg_detoast_datum_copy
  export _root_.libtest.functions.pg_detoast_datum_packed
  export _root_.libtest.functions.pg_detoast_datum_slice
  export _root_.libtest.functions.pg_erand48
  export _root_.libtest.functions.pg_fprintf
  export _root_.libtest.functions.pg_get_encoding_from_locale
  export _root_.libtest.functions.pg_inet_net_ntop
  export _root_.libtest.functions.pg_jrand48
  export _root_.libtest.functions.pg_lrand48
  export _root_.libtest.functions.pg_mkdir_p
  export _root_.libtest.functions.pg_printf
  export _root_.libtest.functions.pg_qsort
  export _root_.libtest.functions.pg_qsort_strcmp
  export _root_.libtest.functions.pg_re_throw
  export _root_.libtest.functions.pg_set_block
  export _root_.libtest.functions.pg_set_noblock
  export _root_.libtest.functions.pg_snprintf
  export _root_.libtest.functions.pg_sprintf
  export _root_.libtest.functions.pg_srand48
  export _root_.libtest.functions.pg_strcasecmp
  export _root_.libtest.functions.pg_strerror
  export _root_.libtest.functions.pg_strerror_r
  export _root_.libtest.functions.pg_strfromd
  export _root_.libtest.functions.pg_strncasecmp
  export _root_.libtest.functions.pg_strong_random
  export _root_.libtest.functions.pg_strong_random_init
  export _root_.libtest.functions.pg_strsignal
  export _root_.libtest.functions.pg_tolower
  export _root_.libtest.functions.pg_toupper
  export _root_.libtest.functions.pg_usleep
  export _root_.libtest.functions.pg_vfprintf
  export _root_.libtest.functions.pg_vprintf
  export _root_.libtest.functions.pg_vsnprintf
  export _root_.libtest.functions.pg_vsprintf
  export _root_.libtest.functions.pgfnames
  export _root_.libtest.functions.pgfnames_cleanup
  export _root_.libtest.functions.pipe_read_line
  export _root_.libtest.functions.pnstrdup
  export _root_.libtest.functions.pqGethostbyname
  export _root_.libtest.functions.pqGetpwuid
  export _root_.libtest.functions.pqsignal
  export _root_.libtest.functions.pre_format_elog_string
  export _root_.libtest.functions.psprintf
  export _root_.libtest.functions.pstrdup
  export _root_.libtest.functions.pvsnprintf
  export _root_.libtest.functions.qsort_arg
  export _root_.libtest.functions.qsort_interruptible
  export _root_.libtest.functions.repalloc
  export _root_.libtest.functions.repalloc_huge
  export _root_.libtest.functions.rmtree
  export _root_.libtest.functions.set_errcontext_domain
  export _root_.libtest.functions.set_fn_opclass_options
  export _root_.libtest.functions.set_pglocale_pgservice
  export _root_.libtest.functions.set_syslog_parameters
  export _root_.libtest.functions.unpack_sql_state
  export _root_.libtest.functions.validate_exec
  export _root_.libtest.functions.wait_result_is_any_signal
  export _root_.libtest.functions.wait_result_is_signal
  export _root_.libtest.functions.wait_result_to_str
  export _root_.libtest.functions.write_stderr