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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

proc getMoneyArray(row`gensym97: Row; name`gensym97: string): seq[PgMoney] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}

proc getMoneyArrayOpt(row`gensym123: Row; name`gensym123: string): Option[
    seq[PgMoney]] {....raises: [PgTypeError], tags: [], forbids: [].}

proc getMoneyOpt(row`gensym42: Row; name`gensym42: string): Option[PgMoney] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

proc getTimestampOpt(row`gensym47: Row; name`gensym47: string): Option[DateTime] {.
    ...raises: [PgTypeError, TimeFormatParseError], tags: [TimeEffect], forbids: [].}

proc getTimestampTz(row`gensym13: Row; name`gensym13: string): DateTime {.
    ...raises: [PgTypeError, TimeFormatParseError], tags: [TimeEffect], forbids: [].}

proc getTimestampTzArray(row`gensym86: Row; name`gensym86: string): seq[DateTime] {.
    ...raises: [PgTypeError, TimeFormatParseError], tags: [TimeEffect], forbids: [].}

proc getTimestampTzArrayOpt(row`gensym112: Row; name`gensym112: string): Option[
    seq[DateTime]] {....raises: [PgTypeError, TimeFormatParseError],
                     tags: [TimeEffect], forbids: [].}

proc getTimestampTzOpt(row`gensym48: Row; name`gensym48: string): Option[
    DateTime] {....raises: [PgTypeError, TimeFormatParseError], tags: [TimeEffect],
                forbids: [].}

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

proc getTimeTzArray(row`gensym89: Row; name`gensym89: string): seq[PgTimeTz] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}

proc getTimeTzArrayOpt(row`gensym115: Row; name`gensym115: string): Option[
    seq[PgTimeTz]] {....raises: [PgTypeError], tags: [], forbids: [].}