proc get[T](row: Row; col: int; _: typedesc[Option[T]]): Option[T]

proc getBit(row`gensym79: Row; name`gensym79: string): PgBit {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getBitArray(row`gensym127: Row; name`gensym127: string): seq[PgBit] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getBitArrayOpt(row`gensym128: Row; name`gensym128: string): Option[
    seq[PgBit]] {....raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getBitOpt(row`gensym80: Row; name`gensym80: string): Option[PgBit] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getBool(row`gensym22: Row; name`gensym22: string): bool {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getBoolArray(row`gensym121: Row; name`gensym121: string): seq[bool] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getBoolArrayElemOpt(row`gensym223: Row; name`gensym223: string): seq[
    Option[bool]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                    forbids: [].}

proc getBoolArrayElemOptOpt(row`gensym224: Row; name`gensym224: string): Option[
    seq[Option[bool]]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                         forbids: [].}

proc getBoolArrayOpt(row`gensym122: Row; name`gensym122: string): Option[
    seq[bool]] {....raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getBoolOpt(row`gensym23: Row; name`gensym23: string): Option[bool] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getBox(row`gensym94: Row; name`gensym94: string): PgBox {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getBoxArray(row`gensym184: Row; name`gensym184: string): seq[PgBox] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getBoxArrayOpt(row`gensym185: Row; name`gensym185: string): Option[
    seq[PgBox]] {....raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getBoxOpt(row`gensym95: Row; name`gensym95: string): Option[PgBox] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getBytes(row`gensym25: Row; name`gensym25: string): seq[byte] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getBytesArray(row`gensym169: Row; name`gensym169: string): seq[seq[byte]] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getBytesArrayOpt(row`gensym170: Row; name`gensym170: string): Option[
    seq[seq[byte]]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                      forbids: [].}

proc getBytesOpt(row`gensym26: Row; name`gensym26: string): Option[seq[byte]] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getCidr(row`gensym61: Row; name`gensym61: string): PgCidr {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getCidrArray(row`gensym154: Row; name`gensym154: string): seq[PgCidr] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getCidrArrayOpt(row`gensym155: Row; name`gensym155: string): Option[
    seq[PgCidr]] {....raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getCidrOpt(row`gensym62: Row; name`gensym62: string): Option[PgCidr] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getCircle(row`gensym103: Row; name`gensym103: string): PgCircle {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getCircleArray(row`gensym193: Row; name`gensym193: string): seq[PgCircle] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getCircleArrayOpt(row`gensym194: Row; name`gensym194: string): Option[
    seq[PgCircle]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                     forbids: [].}

proc getCircleOpt(row`gensym104: Row; name`gensym104: string): Option[PgCircle] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getDate(row`gensym43: Row; name`gensym43: string): DateTime {.
    ...raises: [PgTypeError, CatchableError, PgProtocolError], tags: [TimeEffect],
    forbids: [].}

proc getDateArray(row`gensym136: Row; name`gensym136: string): seq[DateTime] {.
    ...raises: [PgTypeError, PgProtocolError, CatchableError], tags: [TimeEffect],
    forbids: [].}

proc getDateArrayOpt(row`gensym137: Row; name`gensym137: string): Option[
    seq[DateTime]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                     tags: [TimeEffect], forbids: [].}

proc getDateMultirange(row`gensym276: Row; name`gensym276: string): PgMultirange[
    DateTime] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                tags: [RootEffect], forbids: [].}

proc getDateMultirangeArray(row`gensym280: Row; name`gensym280: string): seq[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}

proc getDateMultirangeArrayOpt(row`gensym281: Row; name`gensym281: string): Option[
    seq[PgMultirange[DateTime]]] {....raises: [PgTypeError, PgProtocolError,
    CatchableError], tags: [RootEffect], forbids: [].}

proc getDateMultirangeOpt(row`gensym277: Row; name`gensym277: string): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}

proc getDateOpt(row`gensym44: Row; name`gensym44: string): Option[DateTime] {.
    ...raises: [PgTypeError, CatchableError, PgProtocolError], tags: [TimeEffect],
    forbids: [].}

proc getDateRange(row`gensym274: Row; name`gensym274: string): PgRange[DateTime] {.
    ...raises: [PgTypeError, PgProtocolError, CatchableError], tags: [RootEffect],
    forbids: [].}

proc getDateRangeArray(row`gensym278: Row; name`gensym278: string): seq[
    PgRange[DateTime]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                         tags: [RootEffect], forbids: [].}

proc getDateRangeArrayOpt(row`gensym279: Row; name`gensym279: string): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}

proc getDateRangeOpt(row`gensym275: Row; name`gensym275: string): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                         tags: [RootEffect], forbids: [].}

proc getFloat(row`gensym16: Row; name`gensym16: string): float64 {.
    ...raises: [PgTypeError], tags: [], forbids: [].}

proc getFloat32(row`gensym19: Row; name`gensym19: string): float32 {.
    ...raises: [PgTypeError], tags: [], forbids: [].}

proc getFloat32Array(row`gensym118: Row; name`gensym118: string): seq[float32] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getFloat32ArrayElemOpt(row`gensym220: Row; name`gensym220: string): seq[
    Option[float32]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                       forbids: [].}

proc getFloat32ArrayElemOptOpt(row`gensym221: Row; name`gensym221: string): Option[
    seq[Option[float32]]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                            forbids: [].}

proc getFloat32ArrayOpt(row`gensym119: Row; name`gensym119: string): Option[
    seq[float32]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                    forbids: [].}

proc getFloat32Opt(row`gensym20: Row; name`gensym20: string): Option[float32] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}

proc getFloatArray(row`gensym115: Row; name`gensym115: string): seq[float64] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getFloatArrayElemOpt(row`gensym217: Row; name`gensym217: string): seq[
    Option[float64]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                       forbids: [].}

proc getFloatArrayElemOptOpt(row`gensym218: Row; name`gensym218: string): Option[
    seq[Option[float64]]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                            forbids: [].}

proc getFloatArrayOpt(row`gensym116: Row; name`gensym116: string): Option[
    seq[float64]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                    forbids: [].}

proc getFloatOpt(row`gensym17: Row; name`gensym17: string): Option[float64] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}

proc getHstore(row`gensym82: Row; name`gensym82: string): PgHstore {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getHstoreArray(row`gensym205: Row; name`gensym205: string): seq[PgHstore] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getHstoreArrayOpt(row`gensym206: Row; name`gensym206: string): Option[
    seq[PgHstore]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                     forbids: [].}

proc getHstoreOpt(row`gensym83: Row; name`gensym83: string): Option[PgHstore] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getInet(row`gensym58: Row; name`gensym58: string): PgInet {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getInetArray(row`gensym151: Row; name`gensym151: string): seq[PgInet] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getInetArrayOpt(row`gensym152: Row; name`gensym152: string): Option[
    seq[PgInet]] {....raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getInetOpt(row`gensym59: Row; name`gensym59: string): Option[PgInet] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getInt(row`gensym7: Row; name`gensym7: string): int32 {.
    ...raises: [PgTypeError], tags: [], forbids: [].}

proc getInt4Multirange(row`gensym231: Row; name`gensym231: string): PgMultirange[
    int32] {....raises: [PgTypeError, PgProtocolError, CatchableError],
             tags: [RootEffect], forbids: [].}

proc getInt4MultirangeArray(row`gensym235: Row; name`gensym235: string): seq[
    PgMultirange[int32]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                           tags: [RootEffect], forbids: [].}

proc getInt4MultirangeArrayOpt(row`gensym236: Row; name`gensym236: string): Option[
    seq[PgMultirange[int32]]] {....raises: [PgTypeError, PgProtocolError,
    CatchableError], tags: [RootEffect], forbids: [].}

proc getInt4MultirangeOpt(row`gensym232: Row; name`gensym232: string): Option[
    PgMultirange[int32]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                           tags: [RootEffect], forbids: [].}

proc getInt4Range(row`gensym229: Row; name`gensym229: string): PgRange[int32] {.
    ...raises: [PgTypeError, PgProtocolError, CatchableError], tags: [RootEffect],
    forbids: [].}

proc getInt4RangeArray(row`gensym233: Row; name`gensym233: string): seq[
    PgRange[int32]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                      tags: [RootEffect], forbids: [].}

proc getInt4RangeArrayOpt(row`gensym234: Row; name`gensym234: string): Option[
    seq[PgRange[int32]]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                           tags: [RootEffect], forbids: [].}

proc getInt4RangeOpt(row`gensym230: Row; name`gensym230: string): Option[
    PgRange[int32]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                      tags: [RootEffect], forbids: [].}

proc getInt8Multirange(row`gensym240: Row; name`gensym240: string): PgMultirange[
    int64] {....raises: [PgTypeError, PgProtocolError, CatchableError],
             tags: [RootEffect], forbids: [].}

proc getInt8MultirangeArray(row`gensym244: Row; name`gensym244: string): seq[
    PgMultirange[int64]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                           tags: [RootEffect], forbids: [].}

proc getInt8MultirangeArrayOpt(row`gensym245: Row; name`gensym245: string): Option[
    seq[PgMultirange[int64]]] {....raises: [PgTypeError, PgProtocolError,
    CatchableError], tags: [RootEffect], forbids: [].}

proc getInt8MultirangeOpt(row`gensym241: Row; name`gensym241: string): Option[
    PgMultirange[int64]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                           tags: [RootEffect], forbids: [].}

proc getInt8Range(row`gensym238: Row; name`gensym238: string): PgRange[int64] {.
    ...raises: [PgTypeError, PgProtocolError, CatchableError], tags: [RootEffect],
    forbids: [].}

proc getInt8RangeArray(row`gensym242: Row; name`gensym242: string): seq[
    PgRange[int64]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                      tags: [RootEffect], forbids: [].}

proc getInt8RangeArrayOpt(row`gensym243: Row; name`gensym243: string): Option[
    seq[PgRange[int64]]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                           tags: [RootEffect], forbids: [].}

proc getInt8RangeOpt(row`gensym239: Row; name`gensym239: string): Option[
    PgRange[int64]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                      tags: [RootEffect], forbids: [].}

proc getInt16(row`gensym10: Row; name`gensym10: string): int16 {.
    ...raises: [PgTypeError], tags: [], forbids: [].}

proc getInt16Array(row`gensym109: Row; name`gensym109: string): seq[int16] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getInt16ArrayElemOpt(row`gensym211: Row; name`gensym211: string): seq[
    Option[int16]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                     forbids: [].}

proc getInt16ArrayElemOptOpt(row`gensym212: Row; name`gensym212: string): Option[
    seq[Option[int16]]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                          forbids: [].}

proc getInt16ArrayOpt(row`gensym110: Row; name`gensym110: string): Option[
    seq[int16]] {....raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getInt16Opt(row`gensym11: Row; name`gensym11: string): Option[int16] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}

proc getInt64(row`gensym13: Row; name`gensym13: string): int64 {.
    ...raises: [PgTypeError], tags: [], forbids: [].}

proc getInt64Array(row`gensym112: Row; name`gensym112: string): seq[int64] {.
    ...raises: [PgTypeError, PgProtocolError, CatchableError], tags: [],
    forbids: [].}

proc getInt64ArrayElemOpt(row`gensym214: Row; name`gensym214: string): seq[
    Option[int64]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                     tags: [], forbids: [].}

proc getInt64ArrayElemOptOpt(row`gensym215: Row; name`gensym215: string): Option[
    seq[Option[int64]]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                          tags: [], forbids: [].}

proc getInt64ArrayOpt(row`gensym113: Row; name`gensym113: string): Option[
    seq[int64]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                  tags: [], forbids: [].}

proc getInt64Opt(row`gensym14: Row; name`gensym14: string): Option[int64] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}

proc getIntArray(row`gensym106: Row; name`gensym106: string): seq[int32] {.
    ...raises: [PgTypeError, PgProtocolError, CatchableError], tags: [],
    forbids: [].}

proc getIntArrayElemOpt(row`gensym208: Row; name`gensym208: string): seq[
    Option[int32]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                     tags: [], forbids: [].}

proc getIntArrayElemOptOpt(row`gensym209: Row; name`gensym209: string): Option[
    seq[Option[int32]]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                          tags: [], forbids: [].}

proc getIntArrayOpt(row`gensym107: Row; name`gensym107: string): Option[
    seq[int32]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                  tags: [], forbids: [].}

proc getInterval(row`gensym55: Row; name`gensym55: string): PgInterval {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getIntervalArray(row`gensym145: Row; name`gensym145: string): seq[
    PgInterval] {....raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getIntervalArrayOpt(row`gensym146: Row; name`gensym146: string): Option[
    seq[PgInterval]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                       forbids: [].}

proc getIntervalOpt(row`gensym56: Row; name`gensym56: string): Option[PgInterval] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getIntOpt(row`gensym8: Row; name`gensym8: string): Option[int32] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}

proc getJson(row`gensym52: Row; name`gensym52: string): JsonNode {.
    ...raises: [PgTypeError, PgProtocolError, IOError, OSError, ValueError],
    tags: [ReadIOEffect, WriteIOEffect], forbids: [].}

proc getJsonArray(row`gensym172: Row; name`gensym172: string): seq[JsonNode] {.
    ...raises: [PgTypeError, PgProtocolError, IOError, OSError, ValueError],
    tags: [ReadIOEffect, WriteIOEffect], forbids: [].}

proc getJsonArrayOpt(row`gensym173: Row; name`gensym173: string): Option[
    seq[JsonNode]] {....raises: [PgTypeError, PgProtocolError, IOError, OSError,
                              ValueError], tags: [ReadIOEffect, WriteIOEffect],
                     forbids: [].}

proc getJsonOpt(row`gensym53: Row; name`gensym53: string): Option[JsonNode] {.
    ...raises: [PgTypeError, PgProtocolError, IOError, OSError, ValueError],
    tags: [ReadIOEffect, WriteIOEffect], forbids: [].}

proc getLine(row`gensym88: Row; name`gensym88: string): PgLine {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getLineArray(row`gensym178: Row; name`gensym178: string): seq[PgLine] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getLineArrayOpt(row`gensym179: Row; name`gensym179: string): Option[
    seq[PgLine]] {....raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getLineOpt(row`gensym89: Row; name`gensym89: string): Option[PgLine] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getLseg(row`gensym91: Row; name`gensym91: string): PgLseg {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getLsegArray(row`gensym181: Row; name`gensym181: string): seq[PgLseg] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getLsegArrayOpt(row`gensym182: Row; name`gensym182: string): Option[
    seq[PgLseg]] {....raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getLsegOpt(row`gensym92: Row; name`gensym92: string): Option[PgLseg] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getMacAddr(row`gensym64: Row; name`gensym64: string): PgMacAddr {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getMacAddr8(row`gensym67: Row; name`gensym67: string): PgMacAddr8 {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getMacAddr8Array(row`gensym160: Row; name`gensym160: string): seq[
    PgMacAddr8] {....raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getMacAddr8ArrayOpt(row`gensym161: Row; name`gensym161: string): Option[
    seq[PgMacAddr8]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                       forbids: [].}

proc getMacAddr8Opt(row`gensym68: Row; name`gensym68: string): Option[PgMacAddr8] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getMacAddrArray(row`gensym157: Row; name`gensym157: string): seq[PgMacAddr] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getMacAddrArrayOpt(row`gensym158: Row; name`gensym158: string): Option[
    seq[PgMacAddr]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                      forbids: [].}

proc getMacAddrOpt(row`gensym65: Row; name`gensym65: string): Option[PgMacAddr] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getMoney(row`gensym31: Row; name`gensym31: string; scale`gensym31: int = 2): PgMoney {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getMoneyArray(row`gensym166: Row; name`gensym166: string;
                   scale`gensym166: int = 2): seq[PgMoney] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getMoneyArrayND(row`gensym1: Row; name`gensym1: string;
                     scale`gensym1: int = 2): PgArray[PgMoney] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}

proc getMoneyArrayNDOpt(row`gensym2: Row; name`gensym2: string;
                        scale`gensym2: int = 2): Option[PgArray[PgMoney]] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}

proc getMoneyArrayOpt(row`gensym167: Row; name`gensym167: string;
                      scale`gensym167: int = 2): Option[seq[PgMoney]] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getMoneyOpt(row`gensym32: Row; name`gensym32: string;
                 scale`gensym32: int = 2): Option[PgMoney] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getNumeric(row`gensym28: Row; name`gensym28: string): PgNumeric {.
    ...raises: [PgTypeError, CatchableError, PgProtocolError], tags: [],
    forbids: [].}

proc getNumericArray(row`gensym163: Row; name`gensym163: string): seq[PgNumeric] {.
    ...raises: [PgTypeError, PgProtocolError, CatchableError], tags: [],
    forbids: [].}

proc getNumericArrayOpt(row`gensym164: Row; name`gensym164: string): Option[
    seq[PgNumeric]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                      tags: [], forbids: [].}

proc getNumericOpt(row`gensym29: Row; name`gensym29: string): Option[PgNumeric] {.
    ...raises: [PgTypeError, CatchableError, PgProtocolError], tags: [],
    forbids: [].}

proc getNumMultirange(row`gensym249: Row; name`gensym249: string): PgMultirange[
    PgNumeric] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                 tags: [RootEffect], forbids: [].}

proc getNumMultirangeArray(row`gensym253: Row; name`gensym253: string): seq[
    PgMultirange[PgNumeric]] {....raises: [PgTypeError, PgProtocolError,
                                        CatchableError], tags: [RootEffect],
                               forbids: [].}

proc getNumMultirangeArrayOpt(row`gensym254: Row; name`gensym254: string): Option[
    seq[PgMultirange[PgNumeric]]] {....raises: [PgTypeError, PgProtocolError,
    CatchableError], tags: [RootEffect], forbids: [].}

proc getNumMultirangeOpt(row`gensym250: Row; name`gensym250: string): Option[
    PgMultirange[PgNumeric]] {....raises: [PgTypeError, PgProtocolError,
                                        CatchableError], tags: [RootEffect],
                               forbids: [].}

proc getNumRange(row`gensym247: Row; name`gensym247: string): PgRange[PgNumeric] {.
    ...raises: [PgTypeError, PgProtocolError, CatchableError], tags: [RootEffect],
    forbids: [].}

proc getNumRangeArray(row`gensym251: Row; name`gensym251: string): seq[
    PgRange[PgNumeric]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                          tags: [RootEffect], forbids: [].}

proc getNumRangeArrayOpt(row`gensym252: Row; name`gensym252: string): Option[
    seq[PgRange[PgNumeric]]] {....raises: [PgTypeError, PgProtocolError,
                                        CatchableError], tags: [RootEffect],
                               forbids: [].}

proc getNumRangeOpt(row`gensym248: Row; name`gensym248: string): Option[
    PgRange[PgNumeric]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                          tags: [RootEffect], forbids: [].}

proc getPath(row`gensym97: Row; name`gensym97: string): PgPath {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getPathArray(row`gensym187: Row; name`gensym187: string): seq[PgPath] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getPathArrayOpt(row`gensym188: Row; name`gensym188: string): Option[
    seq[PgPath]] {....raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getPathOpt(row`gensym98: Row; name`gensym98: string): Option[PgPath] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getPoint(row`gensym85: Row; name`gensym85: string): PgPoint {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getPointArray(row`gensym175: Row; name`gensym175: string): seq[PgPoint] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getPointArrayOpt(row`gensym176: Row; name`gensym176: string): Option[
    seq[PgPoint]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                    forbids: [].}

proc getPointOpt(row`gensym86: Row; name`gensym86: string): Option[PgPoint] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getPolygon(row`gensym100: Row; name`gensym100: string): PgPolygon {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getPolygonArray(row`gensym190: Row; name`gensym190: string): seq[PgPolygon] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getPolygonArrayOpt(row`gensym191: Row; name`gensym191: string): Option[
    seq[PgPolygon]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                      forbids: [].}

proc getPolygonOpt(row`gensym101: Row; name`gensym101: string): Option[PgPolygon] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getStr(row`gensym4: Row; name`gensym4: string): string {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getStrArray(row`gensym124: Row; name`gensym124: string): seq[string] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getStrArrayElemOpt(row`gensym226: Row; name`gensym226: string): seq[
    Option[string]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                      forbids: [].}

proc getStrArrayElemOptOpt(row`gensym227: Row; name`gensym227: string): Option[
    seq[Option[string]]] {....raises: [PgTypeError, PgProtocolError], tags: [],
                           forbids: [].}

proc getStrArrayOpt(row`gensym125: Row; name`gensym125: string): Option[
    seq[string]] {....raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getStrOpt(row`gensym5: Row; name`gensym5: string): Option[string] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getTime(row`gensym46: Row; name`gensym46: string): PgTime {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getTimeArray(row`gensym139: Row; name`gensym139: string): seq[PgTime] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getTimeArrayOpt(row`gensym140: Row; name`gensym140: string): Option[
    seq[PgTime]] {....raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getTimeOpt(row`gensym47: Row; name`gensym47: string): Option[PgTime] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}

proc getTimestamp(row`gensym37: Row; name`gensym37: string): DateTime {.
    ...raises: [PgTypeError, PgProtocolError, CatchableError], tags: [TimeEffect],
    forbids: [].}

proc getTimestampArray(row`gensym130: Row; name`gensym130: string): seq[DateTime] {.
    ...raises: [PgTypeError, PgProtocolError, CatchableError], tags: [TimeEffect],
    forbids: [].}

proc getTimestampArrayOpt(row`gensym131: Row; name`gensym131: string): Option[
    seq[DateTime]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                     tags: [TimeEffect], forbids: [].}