@pgsql/utils 13.7.0 → 13.9.0

package/src/asts.ts

@@ -1,2560 +1,2565 @@
 /**
-* This file was automatically generated by pg-proto-parser@1.12.2.
+* This file was automatically generated by pg-proto-parser@1.20.0.
 * DO NOT MODIFY IT BY HAND. Instead, modify the source proto file,
 * and run the pg-proto-parser generate command to regenerate this file.
 */
-import { ParseResult, ScanResult, Node, Integer, Float, String, BitString, Null, List, OidList, IntList, Alias, RangeVar, TableFunc, Expr, Var, Param, Aggref, GroupingFunc, WindowFunc, SubscriptingRef, FuncExpr, NamedArgExpr, OpExpr, DistinctExpr, NullIfExpr, ScalarArrayOpExpr, BoolExpr, SubLink, SubPlan, AlternativeSubPlan, FieldSelect, FieldStore, RelabelType, CoerceViaIO, ArrayCoerceExpr, ConvertRowtypeExpr, CollateExpr, CaseExpr, CaseWhen, CaseTestExpr, ArrayExpr, RowExpr, RowCompareExpr, CoalesceExpr, MinMaxExpr, SQLValueFunction, XmlExpr, NullTest, BooleanTest, CoerceToDomain, CoerceToDomainValue, SetToDefault, CurrentOfExpr, NextValueExpr, InferenceElem, TargetEntry, RangeTblRef, JoinExpr, FromExpr, OnConflictExpr, IntoClause, RawStmt, Query, InsertStmt, DeleteStmt, UpdateStmt, SelectStmt, AlterTableStmt, AlterTableCmd, AlterDomainStmt, SetOperationStmt, GrantStmt, GrantRoleStmt, AlterDefaultPrivilegesStmt, ClosePortalStmt, ClusterStmt, CopyStmt, CreateStmt, DefineStmt, DropStmt, TruncateStmt, CommentStmt, FetchStmt, IndexStmt, CreateFunctionStmt, AlterFunctionStmt, DoStmt, RenameStmt, RuleStmt, NotifyStmt, ListenStmt, UnlistenStmt, TransactionStmt, ViewStmt, LoadStmt, CreateDomainStmt, CreatedbStmt, DropdbStmt, VacuumStmt, ExplainStmt, CreateTableAsStmt, CreateSeqStmt, AlterSeqStmt, VariableSetStmt, VariableShowStmt, DiscardStmt, CreateTrigStmt, CreatePLangStmt, CreateRoleStmt, AlterRoleStmt, DropRoleStmt, LockStmt, ConstraintsSetStmt, ReindexStmt, CheckPointStmt, CreateSchemaStmt, AlterDatabaseStmt, AlterDatabaseSetStmt, AlterRoleSetStmt, CreateConversionStmt, CreateCastStmt, CreateOpClassStmt, CreateOpFamilyStmt, AlterOpFamilyStmt, PrepareStmt, ExecuteStmt, DeallocateStmt, DeclareCursorStmt, CreateTableSpaceStmt, DropTableSpaceStmt, AlterObjectDependsStmt, AlterObjectSchemaStmt, AlterOwnerStmt, AlterOperatorStmt, AlterTypeStmt, DropOwnedStmt, ReassignOwnedStmt, CompositeTypeStmt, CreateEnumStmt, CreateRangeStmt, AlterEnumStmt, AlterTSDictionaryStmt, AlterTSConfigurationStmt, CreateFdwStmt, AlterFdwStmt, CreateForeignServerStmt, AlterForeignServerStmt, CreateUserMappingStmt, AlterUserMappingStmt, DropUserMappingStmt, AlterTableSpaceOptionsStmt, AlterTableMoveAllStmt, SecLabelStmt, CreateForeignTableStmt, ImportForeignSchemaStmt, CreateExtensionStmt, AlterExtensionStmt, AlterExtensionContentsStmt, CreateEventTrigStmt, AlterEventTrigStmt, RefreshMatViewStmt, ReplicaIdentityStmt, AlterSystemStmt, CreatePolicyStmt, AlterPolicyStmt, CreateTransformStmt, CreateAmStmt, CreatePublicationStmt, AlterPublicationStmt, CreateSubscriptionStmt, AlterSubscriptionStmt, DropSubscriptionStmt, CreateStatsStmt, AlterCollationStmt, CallStmt, AlterStatsStmt, A_Expr, ColumnRef, ParamRef, A_Const, FuncCall, A_Star, A_Indices, A_Indirection, A_ArrayExpr, ResTarget, MultiAssignRef, TypeCast, CollateClause, SortBy, WindowDef, RangeSubselect, RangeFunction, RangeTableSample, RangeTableFunc, RangeTableFuncCol, TypeName, ColumnDef, IndexElem, Constraint, DefElem, RangeTblEntry, RangeTblFunction, TableSampleClause, WithCheckOption, SortGroupClause, GroupingSet, WindowClause, ObjectWithArgs, AccessPriv, CreateOpClassItem, TableLikeClause, FunctionParameter, LockingClause, RowMarkClause, XmlSerialize, WithClause, InferClause, OnConflictClause, CommonTableExpr, RoleSpec, TriggerTransition, PartitionElem, PartitionSpec, PartitionBoundSpec, PartitionRangeDatum, PartitionCmd, VacuumRelation, InlineCodeBlock, CallContext, ScanToken } from "@pgsql/types/types/wrapped";
+import _o from "nested-obj";
+import { ParseResult, ScanResult, Integer, Float, String, BitString, Null, List, OidList, IntList, Alias, RangeVar, TableFunc, Expr, Var, Param, Aggref, GroupingFunc, WindowFunc, SubscriptingRef, FuncExpr, NamedArgExpr, OpExpr, DistinctExpr, NullIfExpr, ScalarArrayOpExpr, BoolExpr, SubLink, SubPlan, AlternativeSubPlan, FieldSelect, FieldStore, RelabelType, CoerceViaIO, ArrayCoerceExpr, ConvertRowtypeExpr, CollateExpr, CaseExpr, CaseWhen, CaseTestExpr, ArrayExpr, RowExpr, RowCompareExpr, CoalesceExpr, MinMaxExpr, SQLValueFunction, XmlExpr, NullTest, BooleanTest, CoerceToDomain, CoerceToDomainValue, SetToDefault, CurrentOfExpr, NextValueExpr, InferenceElem, TargetEntry, RangeTblRef, JoinExpr, FromExpr, OnConflictExpr, IntoClause, RawStmt, Query, InsertStmt, DeleteStmt, UpdateStmt, SelectStmt, AlterTableStmt, AlterTableCmd, AlterDomainStmt, SetOperationStmt, GrantStmt, GrantRoleStmt, AlterDefaultPrivilegesStmt, ClosePortalStmt, ClusterStmt, CopyStmt, CreateStmt, DefineStmt, DropStmt, TruncateStmt, CommentStmt, FetchStmt, IndexStmt, CreateFunctionStmt, AlterFunctionStmt, DoStmt, RenameStmt, RuleStmt, NotifyStmt, ListenStmt, UnlistenStmt, TransactionStmt, ViewStmt, LoadStmt, CreateDomainStmt, CreatedbStmt, DropdbStmt, VacuumStmt, ExplainStmt, CreateTableAsStmt, CreateSeqStmt, AlterSeqStmt, VariableSetStmt, VariableShowStmt, DiscardStmt, CreateTrigStmt, CreatePLangStmt, CreateRoleStmt, AlterRoleStmt, DropRoleStmt, LockStmt, ConstraintsSetStmt, ReindexStmt, CheckPointStmt, CreateSchemaStmt, AlterDatabaseStmt, AlterDatabaseSetStmt, AlterRoleSetStmt, CreateConversionStmt, CreateCastStmt, CreateOpClassStmt, CreateOpFamilyStmt, AlterOpFamilyStmt, PrepareStmt, ExecuteStmt, DeallocateStmt, DeclareCursorStmt, CreateTableSpaceStmt, DropTableSpaceStmt, AlterObjectDependsStmt, AlterObjectSchemaStmt, AlterOwnerStmt, AlterOperatorStmt, AlterTypeStmt, DropOwnedStmt, ReassignOwnedStmt, CompositeTypeStmt, CreateEnumStmt, CreateRangeStmt, AlterEnumStmt, AlterTSDictionaryStmt, AlterTSConfigurationStmt, CreateFdwStmt, AlterFdwStmt, CreateForeignServerStmt, AlterForeignServerStmt, CreateUserMappingStmt, AlterUserMappingStmt, DropUserMappingStmt, AlterTableSpaceOptionsStmt, AlterTableMoveAllStmt, SecLabelStmt, CreateForeignTableStmt, ImportForeignSchemaStmt, CreateExtensionStmt, AlterExtensionStmt, AlterExtensionContentsStmt, CreateEventTrigStmt, AlterEventTrigStmt, RefreshMatViewStmt, ReplicaIdentityStmt, AlterSystemStmt, CreatePolicyStmt, AlterPolicyStmt, CreateTransformStmt, CreateAmStmt, CreatePublicationStmt, AlterPublicationStmt, CreateSubscriptionStmt, AlterSubscriptionStmt, DropSubscriptionStmt, CreateStatsStmt, AlterCollationStmt, CallStmt, AlterStatsStmt, A_Expr, ColumnRef, ParamRef, A_Const, FuncCall, A_Star, A_Indices, A_Indirection, A_ArrayExpr, ResTarget, MultiAssignRef, TypeCast, CollateClause, SortBy, WindowDef, RangeSubselect, RangeFunction, RangeTableSample, RangeTableFunc, RangeTableFuncCol, TypeName, ColumnDef, IndexElem, Constraint, DefElem, RangeTblEntry, RangeTblFunction, TableSampleClause, WithCheckOption, SortGroupClause, GroupingSet, WindowClause, ObjectWithArgs, AccessPriv, CreateOpClassItem, TableLikeClause, FunctionParameter, LockingClause, RowMarkClause, XmlSerialize, WithClause, InferClause, OnConflictClause, CommonTableExpr, RoleSpec, TriggerTransition, PartitionElem, PartitionSpec, PartitionBoundSpec, PartitionRangeDatum, PartitionCmd, VacuumRelation, InlineCodeBlock, CallContext, ScanToken } from "./wrapped";
 export default {
   parseResult(_p?: ParseResult["ParseResult"]): ParseResult {
-    return {
-      ParseResult: {
-        version: _p?.version,
-        stmts: _p?.stmts
-      }
-    };
+    const _j = ({
+      ParseResult: {}
+    } as ParseResult);
+    _o.set(_j, "ParseResult.version", _p?.version);
+    _o.set(_j, "ParseResult.stmts", _p?.stmts);
+    return _j;
   },
   scanResult(_p?: ScanResult["ScanResult"]): ScanResult {
-    return {
-      ScanResult: {
-        version: _p?.version,
-        tokens: _p?.tokens
-      }
-    };
+    const _j = ({
+      ScanResult: {}
+    } as ScanResult);
+    _o.set(_j, "ScanResult.version", _p?.version);
+    _o.set(_j, "ScanResult.tokens", _p?.tokens);
+    return _j;
   },
   integer(_p?: Integer["Integer"]): Integer {
-    return {
-      Integer: {
-        ival: _p?.ival
-      }
-    };
+    const _j = ({
+      Integer: {}
+    } as Integer);
+    _o.set(_j, "Integer.ival", _p?.ival);
+    return _j;
   },
   float(_p?: Float["Float"]): Float {
-    return {
-      Float: {
-        str: _p?.str
-      }
-    };
+    const _j = ({
+      Float: {}
+    } as Float);
+    _o.set(_j, "Float.str", _p?.str);
+    return _j;
   },
   string(_p?: String["String"]): String {
-    return {
-      String: {
-        str: _p?.str
-      }
-    };
+    const _j = ({
+      String: {}
+    } as String);
+    _o.set(_j, "String.str", _p?.str);
+    return _j;
   },
   bitString(_p?: BitString["BitString"]): BitString {
-    return {
-      BitString: {
-        str: _p?.str
-      }
-    };
+    const _j = ({
+      BitString: {}
+    } as BitString);
+    _o.set(_j, "BitString.str", _p?.str);
+    return _j;
   },
   null(_p?: Null["Null"]): Null {
-    return {
+    const _j = ({
       Null: {}
-    };
+    } as Null);
+    return _j;
   },
   list(_p?: List["List"]): List {
-    return {
-      List: {
-        items: _p?.items
-      }
-    };
+    const _j = ({
+      List: {}
+    } as List);
+    _o.set(_j, "List.items", _p?.items);
+    return _j;
   },
   oidList(_p?: OidList["OidList"]): OidList {
-    return {
-      OidList: {
-        items: _p?.items
-      }
-    };
+    const _j = ({
+      OidList: {}
+    } as OidList);
+    _o.set(_j, "OidList.items", _p?.items);
+    return _j;
   },
   intList(_p?: IntList["IntList"]): IntList {
-    return {
-      IntList: {
-        items: _p?.items
-      }
-    };
+    const _j = ({
+      IntList: {}
+    } as IntList);
+    _o.set(_j, "IntList.items", _p?.items);
+    return _j;
   },
   alias(_p?: Alias["Alias"]): Alias {
-    return {
-      Alias: {
-        aliasname: _p?.aliasname,
-        colnames: _p?.colnames
-      }
-    };
+    const _j = ({
+      Alias: {}
+    } as Alias);
+    _o.set(_j, "Alias.aliasname", _p?.aliasname);
+    _o.set(_j, "Alias.colnames", _p?.colnames);
+    return _j;
   },
   rangeVar(_p?: RangeVar["RangeVar"]): RangeVar {
-    return {
-      RangeVar: {
-        catalogname: _p?.catalogname,
-        schemaname: _p?.schemaname,
-        relname: _p?.relname,
-        inh: _p?.inh,
-        relpersistence: _p?.relpersistence,
-        alias: _p?.alias,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      RangeVar: {}
+    } as RangeVar);
+    _o.set(_j, "RangeVar.catalogname", _p?.catalogname);
+    _o.set(_j, "RangeVar.schemaname", _p?.schemaname);
+    _o.set(_j, "RangeVar.relname", _p?.relname);
+    _o.set(_j, "RangeVar.inh", _p?.inh);
+    _o.set(_j, "RangeVar.relpersistence", _p?.relpersistence);
+    _o.set(_j, "RangeVar.alias", _p?.alias);
+    _o.set(_j, "RangeVar.location", _p?.location);
+    return _j;
   },
   tableFunc(_p?: TableFunc["TableFunc"]): TableFunc {
-    return {
-      TableFunc: {
-        ns_uris: _p?.ns_uris,
-        ns_names: _p?.ns_names,
-        docexpr: _p?.docexpr,
-        rowexpr: _p?.rowexpr,
-        colnames: _p?.colnames,
-        coltypes: _p?.coltypes,
-        coltypmods: _p?.coltypmods,
-        colcollations: _p?.colcollations,
-        colexprs: _p?.colexprs,
-        coldefexprs: _p?.coldefexprs,
-        notnulls: _p?.notnulls,
-        ordinalitycol: _p?.ordinalitycol,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      TableFunc: {}
+    } as TableFunc);
+    _o.set(_j, "TableFunc.ns_uris", _p?.ns_uris);
+    _o.set(_j, "TableFunc.ns_names", _p?.ns_names);
+    _o.set(_j, "TableFunc.docexpr", _p?.docexpr);
+    _o.set(_j, "TableFunc.rowexpr", _p?.rowexpr);
+    _o.set(_j, "TableFunc.colnames", _p?.colnames);
+    _o.set(_j, "TableFunc.coltypes", _p?.coltypes);
+    _o.set(_j, "TableFunc.coltypmods", _p?.coltypmods);
+    _o.set(_j, "TableFunc.colcollations", _p?.colcollations);
+    _o.set(_j, "TableFunc.colexprs", _p?.colexprs);
+    _o.set(_j, "TableFunc.coldefexprs", _p?.coldefexprs);
+    _o.set(_j, "TableFunc.notnulls", _p?.notnulls);
+    _o.set(_j, "TableFunc.ordinalitycol", _p?.ordinalitycol);
+    _o.set(_j, "TableFunc.location", _p?.location);
+    return _j;
   },
   expr(_p?: Expr["Expr"]): Expr {
-    return {
+    const _j = ({
       Expr: {}
-    };
+    } as Expr);
+    return _j;
   },
   var(_p?: Var["Var"]): Var {
-    return {
-      Var: {
-        xpr: _p?.xpr,
-        varno: _p?.varno,
-        varattno: _p?.varattno,
-        vartype: _p?.vartype,
-        vartypmod: _p?.vartypmod,
-        varcollid: _p?.varcollid,
-        varlevelsup: _p?.varlevelsup,
-        varnosyn: _p?.varnosyn,
-        varattnosyn: _p?.varattnosyn,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      Var: {}
+    } as Var);
+    _o.set(_j, "Var.xpr", _p?.xpr);
+    _o.set(_j, "Var.varno", _p?.varno);
+    _o.set(_j, "Var.varattno", _p?.varattno);
+    _o.set(_j, "Var.vartype", _p?.vartype);
+    _o.set(_j, "Var.vartypmod", _p?.vartypmod);
+    _o.set(_j, "Var.varcollid", _p?.varcollid);
+    _o.set(_j, "Var.varlevelsup", _p?.varlevelsup);
+    _o.set(_j, "Var.varnosyn", _p?.varnosyn);
+    _o.set(_j, "Var.varattnosyn", _p?.varattnosyn);
+    _o.set(_j, "Var.location", _p?.location);
+    return _j;
   },
   param(_p?: Param["Param"]): Param {
-    return {
-      Param: {
-        xpr: _p?.xpr,
-        paramkind: _p?.paramkind,
-        paramid: _p?.paramid,
-        paramtype: _p?.paramtype,
-        paramtypmod: _p?.paramtypmod,
-        paramcollid: _p?.paramcollid,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      Param: {}
+    } as Param);
+    _o.set(_j, "Param.xpr", _p?.xpr);
+    _o.set(_j, "Param.paramkind", _p?.paramkind);
+    _o.set(_j, "Param.paramid", _p?.paramid);
+    _o.set(_j, "Param.paramtype", _p?.paramtype);
+    _o.set(_j, "Param.paramtypmod", _p?.paramtypmod);
+    _o.set(_j, "Param.paramcollid", _p?.paramcollid);
+    _o.set(_j, "Param.location", _p?.location);
+    return _j;
   },
   aggref(_p?: Aggref["Aggref"]): Aggref {
-    return {
-      Aggref: {
-        xpr: _p?.xpr,
-        aggfnoid: _p?.aggfnoid,
-        aggtype: _p?.aggtype,
-        aggcollid: _p?.aggcollid,
-        inputcollid: _p?.inputcollid,
-        aggtranstype: _p?.aggtranstype,
-        aggargtypes: _p?.aggargtypes,
-        aggdirectargs: _p?.aggdirectargs,
-        args: _p?.args,
-        aggorder: _p?.aggorder,
-        aggdistinct: _p?.aggdistinct,
-        aggfilter: _p?.aggfilter,
-        aggstar: _p?.aggstar,
-        aggvariadic: _p?.aggvariadic,
-        aggkind: _p?.aggkind,
-        agglevelsup: _p?.agglevelsup,
-        aggsplit: _p?.aggsplit,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      Aggref: {}
+    } as Aggref);
+    _o.set(_j, "Aggref.xpr", _p?.xpr);
+    _o.set(_j, "Aggref.aggfnoid", _p?.aggfnoid);
+    _o.set(_j, "Aggref.aggtype", _p?.aggtype);
+    _o.set(_j, "Aggref.aggcollid", _p?.aggcollid);
+    _o.set(_j, "Aggref.inputcollid", _p?.inputcollid);
+    _o.set(_j, "Aggref.aggtranstype", _p?.aggtranstype);
+    _o.set(_j, "Aggref.aggargtypes", _p?.aggargtypes);
+    _o.set(_j, "Aggref.aggdirectargs", _p?.aggdirectargs);
+    _o.set(_j, "Aggref.args", _p?.args);
+    _o.set(_j, "Aggref.aggorder", _p?.aggorder);
+    _o.set(_j, "Aggref.aggdistinct", _p?.aggdistinct);
+    _o.set(_j, "Aggref.aggfilter", _p?.aggfilter);
+    _o.set(_j, "Aggref.aggstar", _p?.aggstar);
+    _o.set(_j, "Aggref.aggvariadic", _p?.aggvariadic);
+    _o.set(_j, "Aggref.aggkind", _p?.aggkind);
+    _o.set(_j, "Aggref.agglevelsup", _p?.agglevelsup);
+    _o.set(_j, "Aggref.aggsplit", _p?.aggsplit);
+    _o.set(_j, "Aggref.location", _p?.location);
+    return _j;
   },
   groupingFunc(_p?: GroupingFunc["GroupingFunc"]): GroupingFunc {
-    return {
-      GroupingFunc: {
-        xpr: _p?.xpr,
-        args: _p?.args,
-        refs: _p?.refs,
-        cols: _p?.cols,
-        agglevelsup: _p?.agglevelsup,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      GroupingFunc: {}
+    } as GroupingFunc);
+    _o.set(_j, "GroupingFunc.xpr", _p?.xpr);
+    _o.set(_j, "GroupingFunc.args", _p?.args);
+    _o.set(_j, "GroupingFunc.refs", _p?.refs);
+    _o.set(_j, "GroupingFunc.cols", _p?.cols);
+    _o.set(_j, "GroupingFunc.agglevelsup", _p?.agglevelsup);
+    _o.set(_j, "GroupingFunc.location", _p?.location);
+    return _j;
   },
   windowFunc(_p?: WindowFunc["WindowFunc"]): WindowFunc {
-    return {
-      WindowFunc: {
-        xpr: _p?.xpr,
-        winfnoid: _p?.winfnoid,
-        wintype: _p?.wintype,
-        wincollid: _p?.wincollid,
-        inputcollid: _p?.inputcollid,
-        args: _p?.args,
-        aggfilter: _p?.aggfilter,
-        winref: _p?.winref,
-        winstar: _p?.winstar,
-        winagg: _p?.winagg,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      WindowFunc: {}
+    } as WindowFunc);
+    _o.set(_j, "WindowFunc.xpr", _p?.xpr);
+    _o.set(_j, "WindowFunc.winfnoid", _p?.winfnoid);
+    _o.set(_j, "WindowFunc.wintype", _p?.wintype);
+    _o.set(_j, "WindowFunc.wincollid", _p?.wincollid);
+    _o.set(_j, "WindowFunc.inputcollid", _p?.inputcollid);
+    _o.set(_j, "WindowFunc.args", _p?.args);
+    _o.set(_j, "WindowFunc.aggfilter", _p?.aggfilter);
+    _o.set(_j, "WindowFunc.winref", _p?.winref);
+    _o.set(_j, "WindowFunc.winstar", _p?.winstar);
+    _o.set(_j, "WindowFunc.winagg", _p?.winagg);
+    _o.set(_j, "WindowFunc.location", _p?.location);
+    return _j;
   },
   subscriptingRef(_p?: SubscriptingRef["SubscriptingRef"]): SubscriptingRef {
-    return {
-      SubscriptingRef: {
-        xpr: _p?.xpr,
-        refcontainertype: _p?.refcontainertype,
-        refelemtype: _p?.refelemtype,
-        reftypmod: _p?.reftypmod,
-        refcollid: _p?.refcollid,
-        refupperindexpr: _p?.refupperindexpr,
-        reflowerindexpr: _p?.reflowerindexpr,
-        refexpr: _p?.refexpr,
-        refassgnexpr: _p?.refassgnexpr
-      }
-    };
+    const _j = ({
+      SubscriptingRef: {}
+    } as SubscriptingRef);
+    _o.set(_j, "SubscriptingRef.xpr", _p?.xpr);
+    _o.set(_j, "SubscriptingRef.refcontainertype", _p?.refcontainertype);
+    _o.set(_j, "SubscriptingRef.refelemtype", _p?.refelemtype);
+    _o.set(_j, "SubscriptingRef.reftypmod", _p?.reftypmod);
+    _o.set(_j, "SubscriptingRef.refcollid", _p?.refcollid);
+    _o.set(_j, "SubscriptingRef.refupperindexpr", _p?.refupperindexpr);
+    _o.set(_j, "SubscriptingRef.reflowerindexpr", _p?.reflowerindexpr);
+    _o.set(_j, "SubscriptingRef.refexpr", _p?.refexpr);
+    _o.set(_j, "SubscriptingRef.refassgnexpr", _p?.refassgnexpr);
+    return _j;
   },
   funcExpr(_p?: FuncExpr["FuncExpr"]): FuncExpr {
-    return {
-      FuncExpr: {
-        xpr: _p?.xpr,
-        funcid: _p?.funcid,
-        funcresulttype: _p?.funcresulttype,
-        funcretset: _p?.funcretset,
-        funcvariadic: _p?.funcvariadic,
-        funcformat: _p?.funcformat,
-        funccollid: _p?.funccollid,
-        inputcollid: _p?.inputcollid,
-        args: _p?.args,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      FuncExpr: {}
+    } as FuncExpr);
+    _o.set(_j, "FuncExpr.xpr", _p?.xpr);
+    _o.set(_j, "FuncExpr.funcid", _p?.funcid);
+    _o.set(_j, "FuncExpr.funcresulttype", _p?.funcresulttype);
+    _o.set(_j, "FuncExpr.funcretset", _p?.funcretset);
+    _o.set(_j, "FuncExpr.funcvariadic", _p?.funcvariadic);
+    _o.set(_j, "FuncExpr.funcformat", _p?.funcformat);
+    _o.set(_j, "FuncExpr.funccollid", _p?.funccollid);
+    _o.set(_j, "FuncExpr.inputcollid", _p?.inputcollid);
+    _o.set(_j, "FuncExpr.args", _p?.args);
+    _o.set(_j, "FuncExpr.location", _p?.location);
+    return _j;
   },
   namedArgExpr(_p?: NamedArgExpr["NamedArgExpr"]): NamedArgExpr {
-    return {
-      NamedArgExpr: {
-        xpr: _p?.xpr,
-        arg: _p?.arg,
-        name: _p?.name,
-        argnumber: _p?.argnumber,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      NamedArgExpr: {}
+    } as NamedArgExpr);
+    _o.set(_j, "NamedArgExpr.xpr", _p?.xpr);
+    _o.set(_j, "NamedArgExpr.arg", _p?.arg);
+    _o.set(_j, "NamedArgExpr.name", _p?.name);
+    _o.set(_j, "NamedArgExpr.argnumber", _p?.argnumber);
+    _o.set(_j, "NamedArgExpr.location", _p?.location);
+    return _j;
   },
   opExpr(_p?: OpExpr["OpExpr"]): OpExpr {
-    return {
-      OpExpr: {
-        xpr: _p?.xpr,
-        opno: _p?.opno,
-        opfuncid: _p?.opfuncid,
-        opresulttype: _p?.opresulttype,
-        opretset: _p?.opretset,
-        opcollid: _p?.opcollid,
-        inputcollid: _p?.inputcollid,
-        args: _p?.args,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      OpExpr: {}
+    } as OpExpr);
+    _o.set(_j, "OpExpr.xpr", _p?.xpr);
+    _o.set(_j, "OpExpr.opno", _p?.opno);
+    _o.set(_j, "OpExpr.opfuncid", _p?.opfuncid);
+    _o.set(_j, "OpExpr.opresulttype", _p?.opresulttype);
+    _o.set(_j, "OpExpr.opretset", _p?.opretset);
+    _o.set(_j, "OpExpr.opcollid", _p?.opcollid);
+    _o.set(_j, "OpExpr.inputcollid", _p?.inputcollid);
+    _o.set(_j, "OpExpr.args", _p?.args);
+    _o.set(_j, "OpExpr.location", _p?.location);
+    return _j;
   },
   distinctExpr(_p?: DistinctExpr["DistinctExpr"]): DistinctExpr {
-    return {
-      DistinctExpr: {
-        xpr: _p?.xpr,
-        opno: _p?.opno,
-        opfuncid: _p?.opfuncid,
-        opresulttype: _p?.opresulttype,
-        opretset: _p?.opretset,
-        opcollid: _p?.opcollid,
-        inputcollid: _p?.inputcollid,
-        args: _p?.args,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      DistinctExpr: {}
+    } as DistinctExpr);
+    _o.set(_j, "DistinctExpr.xpr", _p?.xpr);
+    _o.set(_j, "DistinctExpr.opno", _p?.opno);
+    _o.set(_j, "DistinctExpr.opfuncid", _p?.opfuncid);
+    _o.set(_j, "DistinctExpr.opresulttype", _p?.opresulttype);
+    _o.set(_j, "DistinctExpr.opretset", _p?.opretset);
+    _o.set(_j, "DistinctExpr.opcollid", _p?.opcollid);
+    _o.set(_j, "DistinctExpr.inputcollid", _p?.inputcollid);
+    _o.set(_j, "DistinctExpr.args", _p?.args);
+    _o.set(_j, "DistinctExpr.location", _p?.location);
+    return _j;
   },
   nullIfExpr(_p?: NullIfExpr["NullIfExpr"]): NullIfExpr {
-    return {
-      NullIfExpr: {
-        xpr: _p?.xpr,
-        opno: _p?.opno,
-        opfuncid: _p?.opfuncid,
-        opresulttype: _p?.opresulttype,
-        opretset: _p?.opretset,
-        opcollid: _p?.opcollid,
-        inputcollid: _p?.inputcollid,
-        args: _p?.args,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      NullIfExpr: {}
+    } as NullIfExpr);
+    _o.set(_j, "NullIfExpr.xpr", _p?.xpr);
+    _o.set(_j, "NullIfExpr.opno", _p?.opno);
+    _o.set(_j, "NullIfExpr.opfuncid", _p?.opfuncid);
+    _o.set(_j, "NullIfExpr.opresulttype", _p?.opresulttype);
+    _o.set(_j, "NullIfExpr.opretset", _p?.opretset);
+    _o.set(_j, "NullIfExpr.opcollid", _p?.opcollid);
+    _o.set(_j, "NullIfExpr.inputcollid", _p?.inputcollid);
+    _o.set(_j, "NullIfExpr.args", _p?.args);
+    _o.set(_j, "NullIfExpr.location", _p?.location);
+    return _j;
   },
   scalarArrayOpExpr(_p?: ScalarArrayOpExpr["ScalarArrayOpExpr"]): ScalarArrayOpExpr {
-    return {
-      ScalarArrayOpExpr: {
-        xpr: _p?.xpr,
-        opno: _p?.opno,
-        opfuncid: _p?.opfuncid,
-        useOr: _p?.useOr,
-        inputcollid: _p?.inputcollid,
-        args: _p?.args,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      ScalarArrayOpExpr: {}
+    } as ScalarArrayOpExpr);
+    _o.set(_j, "ScalarArrayOpExpr.xpr", _p?.xpr);
+    _o.set(_j, "ScalarArrayOpExpr.opno", _p?.opno);
+    _o.set(_j, "ScalarArrayOpExpr.opfuncid", _p?.opfuncid);
+    _o.set(_j, "ScalarArrayOpExpr.useOr", _p?.useOr);
+    _o.set(_j, "ScalarArrayOpExpr.inputcollid", _p?.inputcollid);
+    _o.set(_j, "ScalarArrayOpExpr.args", _p?.args);
+    _o.set(_j, "ScalarArrayOpExpr.location", _p?.location);
+    return _j;
   },
   boolExpr(_p?: BoolExpr["BoolExpr"]): BoolExpr {
-    return {
-      BoolExpr: {
-        xpr: _p?.xpr,
-        boolop: _p?.boolop,
-        args: _p?.args,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      BoolExpr: {}
+    } as BoolExpr);
+    _o.set(_j, "BoolExpr.xpr", _p?.xpr);
+    _o.set(_j, "BoolExpr.boolop", _p?.boolop);
+    _o.set(_j, "BoolExpr.args", _p?.args);
+    _o.set(_j, "BoolExpr.location", _p?.location);
+    return _j;
   },
   subLink(_p?: SubLink["SubLink"]): SubLink {
-    return {
-      SubLink: {
-        xpr: _p?.xpr,
-        subLinkType: _p?.subLinkType,
-        subLinkId: _p?.subLinkId,
-        testexpr: _p?.testexpr,
-        operName: _p?.operName,
-        subselect: _p?.subselect,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      SubLink: {}
+    } as SubLink);
+    _o.set(_j, "SubLink.xpr", _p?.xpr);
+    _o.set(_j, "SubLink.subLinkType", _p?.subLinkType);
+    _o.set(_j, "SubLink.subLinkId", _p?.subLinkId);
+    _o.set(_j, "SubLink.testexpr", _p?.testexpr);
+    _o.set(_j, "SubLink.operName", _p?.operName);
+    _o.set(_j, "SubLink.subselect", _p?.subselect);
+    _o.set(_j, "SubLink.location", _p?.location);
+    return _j;
   },
   subPlan(_p?: SubPlan["SubPlan"]): SubPlan {
-    return {
-      SubPlan: {
-        xpr: _p?.xpr,
-        subLinkType: _p?.subLinkType,
-        testexpr: _p?.testexpr,
-        paramIds: _p?.paramIds,
-        plan_id: _p?.plan_id,
-        plan_name: _p?.plan_name,
-        firstColType: _p?.firstColType,
-        firstColTypmod: _p?.firstColTypmod,
-        firstColCollation: _p?.firstColCollation,
-        useHashTable: _p?.useHashTable,
-        unknownEqFalse: _p?.unknownEqFalse,
-        parallel_safe: _p?.parallel_safe,
-        setParam: _p?.setParam,
-        parParam: _p?.parParam,
-        args: _p?.args,
-        startup_cost: _p?.startup_cost,
-        per_call_cost: _p?.per_call_cost
-      }
-    };
+    const _j = ({
+      SubPlan: {}
+    } as SubPlan);
+    _o.set(_j, "SubPlan.xpr", _p?.xpr);
+    _o.set(_j, "SubPlan.subLinkType", _p?.subLinkType);
+    _o.set(_j, "SubPlan.testexpr", _p?.testexpr);
+    _o.set(_j, "SubPlan.paramIds", _p?.paramIds);
+    _o.set(_j, "SubPlan.plan_id", _p?.plan_id);
+    _o.set(_j, "SubPlan.plan_name", _p?.plan_name);
+    _o.set(_j, "SubPlan.firstColType", _p?.firstColType);
+    _o.set(_j, "SubPlan.firstColTypmod", _p?.firstColTypmod);
+    _o.set(_j, "SubPlan.firstColCollation", _p?.firstColCollation);
+    _o.set(_j, "SubPlan.useHashTable", _p?.useHashTable);
+    _o.set(_j, "SubPlan.unknownEqFalse", _p?.unknownEqFalse);
+    _o.set(_j, "SubPlan.parallel_safe", _p?.parallel_safe);
+    _o.set(_j, "SubPlan.setParam", _p?.setParam);
+    _o.set(_j, "SubPlan.parParam", _p?.parParam);
+    _o.set(_j, "SubPlan.args", _p?.args);
+    _o.set(_j, "SubPlan.startup_cost", _p?.startup_cost);
+    _o.set(_j, "SubPlan.per_call_cost", _p?.per_call_cost);
+    return _j;
   },
   alternativeSubPlan(_p?: AlternativeSubPlan["AlternativeSubPlan"]): AlternativeSubPlan {
-    return {
-      AlternativeSubPlan: {
-        xpr: _p?.xpr,
-        subplans: _p?.subplans
-      }
-    };
+    const _j = ({
+      AlternativeSubPlan: {}
+    } as AlternativeSubPlan);
+    _o.set(_j, "AlternativeSubPlan.xpr", _p?.xpr);
+    _o.set(_j, "AlternativeSubPlan.subplans", _p?.subplans);
+    return _j;
   },
   fieldSelect(_p?: FieldSelect["FieldSelect"]): FieldSelect {
-    return {
-      FieldSelect: {
-        xpr: _p?.xpr,
-        arg: _p?.arg,
-        fieldnum: _p?.fieldnum,
-        resulttype: _p?.resulttype,
-        resulttypmod: _p?.resulttypmod,
-        resultcollid: _p?.resultcollid
-      }
-    };
+    const _j = ({
+      FieldSelect: {}
+    } as FieldSelect);
+    _o.set(_j, "FieldSelect.xpr", _p?.xpr);
+    _o.set(_j, "FieldSelect.arg", _p?.arg);
+    _o.set(_j, "FieldSelect.fieldnum", _p?.fieldnum);
+    _o.set(_j, "FieldSelect.resulttype", _p?.resulttype);
+    _o.set(_j, "FieldSelect.resulttypmod", _p?.resulttypmod);
+    _o.set(_j, "FieldSelect.resultcollid", _p?.resultcollid);
+    return _j;
   },
   fieldStore(_p?: FieldStore["FieldStore"]): FieldStore {
-    return {
-      FieldStore: {
-        xpr: _p?.xpr,
-        arg: _p?.arg,
-        newvals: _p?.newvals,
-        fieldnums: _p?.fieldnums,
-        resulttype: _p?.resulttype
-      }
-    };
+    const _j = ({
+      FieldStore: {}
+    } as FieldStore);
+    _o.set(_j, "FieldStore.xpr", _p?.xpr);
+    _o.set(_j, "FieldStore.arg", _p?.arg);
+    _o.set(_j, "FieldStore.newvals", _p?.newvals);
+    _o.set(_j, "FieldStore.fieldnums", _p?.fieldnums);
+    _o.set(_j, "FieldStore.resulttype", _p?.resulttype);
+    return _j;
   },
   relabelType(_p?: RelabelType["RelabelType"]): RelabelType {
-    return {
-      RelabelType: {
-        xpr: _p?.xpr,
-        arg: _p?.arg,
-        resulttype: _p?.resulttype,
-        resulttypmod: _p?.resulttypmod,
-        resultcollid: _p?.resultcollid,
-        relabelformat: _p?.relabelformat,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      RelabelType: {}
+    } as RelabelType);
+    _o.set(_j, "RelabelType.xpr", _p?.xpr);
+    _o.set(_j, "RelabelType.arg", _p?.arg);
+    _o.set(_j, "RelabelType.resulttype", _p?.resulttype);
+    _o.set(_j, "RelabelType.resulttypmod", _p?.resulttypmod);
+    _o.set(_j, "RelabelType.resultcollid", _p?.resultcollid);
+    _o.set(_j, "RelabelType.relabelformat", _p?.relabelformat);
+    _o.set(_j, "RelabelType.location", _p?.location);
+    return _j;
   },
   coerceViaio(_p?: CoerceViaIO["CoerceViaIO"]): CoerceViaIO {
-    return {
-      CoerceViaIO: {
-        xpr: _p?.xpr,
-        arg: _p?.arg,
-        resulttype: _p?.resulttype,
-        resultcollid: _p?.resultcollid,
-        coerceformat: _p?.coerceformat,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      CoerceViaIO: {}
+    } as CoerceViaIO);
+    _o.set(_j, "CoerceViaIO.xpr", _p?.xpr);
+    _o.set(_j, "CoerceViaIO.arg", _p?.arg);
+    _o.set(_j, "CoerceViaIO.resulttype", _p?.resulttype);
+    _o.set(_j, "CoerceViaIO.resultcollid", _p?.resultcollid);
+    _o.set(_j, "CoerceViaIO.coerceformat", _p?.coerceformat);
+    _o.set(_j, "CoerceViaIO.location", _p?.location);
+    return _j;
   },
   arrayCoerceExpr(_p?: ArrayCoerceExpr["ArrayCoerceExpr"]): ArrayCoerceExpr {
-    return {
-      ArrayCoerceExpr: {
-        xpr: _p?.xpr,
-        arg: _p?.arg,
-        elemexpr: _p?.elemexpr,
-        resulttype: _p?.resulttype,
-        resulttypmod: _p?.resulttypmod,
-        resultcollid: _p?.resultcollid,
-        coerceformat: _p?.coerceformat,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      ArrayCoerceExpr: {}
+    } as ArrayCoerceExpr);
+    _o.set(_j, "ArrayCoerceExpr.xpr", _p?.xpr);
+    _o.set(_j, "ArrayCoerceExpr.arg", _p?.arg);
+    _o.set(_j, "ArrayCoerceExpr.elemexpr", _p?.elemexpr);
+    _o.set(_j, "ArrayCoerceExpr.resulttype", _p?.resulttype);
+    _o.set(_j, "ArrayCoerceExpr.resulttypmod", _p?.resulttypmod);
+    _o.set(_j, "ArrayCoerceExpr.resultcollid", _p?.resultcollid);
+    _o.set(_j, "ArrayCoerceExpr.coerceformat", _p?.coerceformat);
+    _o.set(_j, "ArrayCoerceExpr.location", _p?.location);
+    return _j;
   },
   convertRowtypeExpr(_p?: ConvertRowtypeExpr["ConvertRowtypeExpr"]): ConvertRowtypeExpr {
-    return {
-      ConvertRowtypeExpr: {
-        xpr: _p?.xpr,
-        arg: _p?.arg,
-        resulttype: _p?.resulttype,
-        convertformat: _p?.convertformat,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      ConvertRowtypeExpr: {}
+    } as ConvertRowtypeExpr);
+    _o.set(_j, "ConvertRowtypeExpr.xpr", _p?.xpr);
+    _o.set(_j, "ConvertRowtypeExpr.arg", _p?.arg);
+    _o.set(_j, "ConvertRowtypeExpr.resulttype", _p?.resulttype);
+    _o.set(_j, "ConvertRowtypeExpr.convertformat", _p?.convertformat);
+    _o.set(_j, "ConvertRowtypeExpr.location", _p?.location);
+    return _j;
   },
   collateExpr(_p?: CollateExpr["CollateExpr"]): CollateExpr {
-    return {
-      CollateExpr: {
-        xpr: _p?.xpr,
-        arg: _p?.arg,
-        collOid: _p?.collOid,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      CollateExpr: {}
+    } as CollateExpr);
+    _o.set(_j, "CollateExpr.xpr", _p?.xpr);
+    _o.set(_j, "CollateExpr.arg", _p?.arg);
+    _o.set(_j, "CollateExpr.collOid", _p?.collOid);
+    _o.set(_j, "CollateExpr.location", _p?.location);
+    return _j;
   },
   caseExpr(_p?: CaseExpr["CaseExpr"]): CaseExpr {
-    return {
-      CaseExpr: {
-        xpr: _p?.xpr,
-        casetype: _p?.casetype,
-        casecollid: _p?.casecollid,
-        arg: _p?.arg,
-        args: _p?.args,
-        defresult: _p?.defresult,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      CaseExpr: {}
+    } as CaseExpr);
+    _o.set(_j, "CaseExpr.xpr", _p?.xpr);
+    _o.set(_j, "CaseExpr.casetype", _p?.casetype);
+    _o.set(_j, "CaseExpr.casecollid", _p?.casecollid);
+    _o.set(_j, "CaseExpr.arg", _p?.arg);
+    _o.set(_j, "CaseExpr.args", _p?.args);
+    _o.set(_j, "CaseExpr.defresult", _p?.defresult);
+    _o.set(_j, "CaseExpr.location", _p?.location);
+    return _j;
   },
   caseWhen(_p?: CaseWhen["CaseWhen"]): CaseWhen {
-    return {
-      CaseWhen: {
-        xpr: _p?.xpr,
-        expr: _p?.expr,
-        result: _p?.result,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      CaseWhen: {}
+    } as CaseWhen);
+    _o.set(_j, "CaseWhen.xpr", _p?.xpr);
+    _o.set(_j, "CaseWhen.expr", _p?.expr);
+    _o.set(_j, "CaseWhen.result", _p?.result);
+    _o.set(_j, "CaseWhen.location", _p?.location);
+    return _j;
   },
   caseTestExpr(_p?: CaseTestExpr["CaseTestExpr"]): CaseTestExpr {
-    return {
-      CaseTestExpr: {
-        xpr: _p?.xpr,
-        typeId: _p?.typeId,
-        typeMod: _p?.typeMod,
-        collation: _p?.collation
-      }
-    };
+    const _j = ({
+      CaseTestExpr: {}
+    } as CaseTestExpr);
+    _o.set(_j, "CaseTestExpr.xpr", _p?.xpr);
+    _o.set(_j, "CaseTestExpr.typeId", _p?.typeId);
+    _o.set(_j, "CaseTestExpr.typeMod", _p?.typeMod);
+    _o.set(_j, "CaseTestExpr.collation", _p?.collation);
+    return _j;
   },
   arrayExpr(_p?: ArrayExpr["ArrayExpr"]): ArrayExpr {
-    return {
-      ArrayExpr: {
-        xpr: _p?.xpr,
-        array_typeid: _p?.array_typeid,
-        array_collid: _p?.array_collid,
-        element_typeid: _p?.element_typeid,
-        elements: _p?.elements,
-        multidims: _p?.multidims,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      ArrayExpr: {}
+    } as ArrayExpr);
+    _o.set(_j, "ArrayExpr.xpr", _p?.xpr);
+    _o.set(_j, "ArrayExpr.array_typeid", _p?.array_typeid);
+    _o.set(_j, "ArrayExpr.array_collid", _p?.array_collid);
+    _o.set(_j, "ArrayExpr.element_typeid", _p?.element_typeid);
+    _o.set(_j, "ArrayExpr.elements", _p?.elements);
+    _o.set(_j, "ArrayExpr.multidims", _p?.multidims);
+    _o.set(_j, "ArrayExpr.location", _p?.location);
+    return _j;
   },
   rowExpr(_p?: RowExpr["RowExpr"]): RowExpr {
-    return {
-      RowExpr: {
-        xpr: _p?.xpr,
-        args: _p?.args,
-        row_typeid: _p?.row_typeid,
-        row_format: _p?.row_format,
-        colnames: _p?.colnames,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      RowExpr: {}
+    } as RowExpr);
+    _o.set(_j, "RowExpr.xpr", _p?.xpr);
+    _o.set(_j, "RowExpr.args", _p?.args);
+    _o.set(_j, "RowExpr.row_typeid", _p?.row_typeid);
+    _o.set(_j, "RowExpr.row_format", _p?.row_format);
+    _o.set(_j, "RowExpr.colnames", _p?.colnames);
+    _o.set(_j, "RowExpr.location", _p?.location);
+    return _j;
   },
   rowCompareExpr(_p?: RowCompareExpr["RowCompareExpr"]): RowCompareExpr {
-    return {
-      RowCompareExpr: {
-        xpr: _p?.xpr,
-        rctype: _p?.rctype,
-        opnos: _p?.opnos,
-        opfamilies: _p?.opfamilies,
-        inputcollids: _p?.inputcollids,
-        largs: _p?.largs,
-        rargs: _p?.rargs
-      }
-    };
+    const _j = ({
+      RowCompareExpr: {}
+    } as RowCompareExpr);
+    _o.set(_j, "RowCompareExpr.xpr", _p?.xpr);
+    _o.set(_j, "RowCompareExpr.rctype", _p?.rctype);
+    _o.set(_j, "RowCompareExpr.opnos", _p?.opnos);
+    _o.set(_j, "RowCompareExpr.opfamilies", _p?.opfamilies);
+    _o.set(_j, "RowCompareExpr.inputcollids", _p?.inputcollids);
+    _o.set(_j, "RowCompareExpr.largs", _p?.largs);
+    _o.set(_j, "RowCompareExpr.rargs", _p?.rargs);
+    return _j;
   },
   coalesceExpr(_p?: CoalesceExpr["CoalesceExpr"]): CoalesceExpr {
-    return {
-      CoalesceExpr: {
-        xpr: _p?.xpr,
-        coalescetype: _p?.coalescetype,
-        coalescecollid: _p?.coalescecollid,
-        args: _p?.args,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      CoalesceExpr: {}
+    } as CoalesceExpr);
+    _o.set(_j, "CoalesceExpr.xpr", _p?.xpr);
+    _o.set(_j, "CoalesceExpr.coalescetype", _p?.coalescetype);
+    _o.set(_j, "CoalesceExpr.coalescecollid", _p?.coalescecollid);
+    _o.set(_j, "CoalesceExpr.args", _p?.args);
+    _o.set(_j, "CoalesceExpr.location", _p?.location);
+    return _j;
   },
   minMaxExpr(_p?: MinMaxExpr["MinMaxExpr"]): MinMaxExpr {
-    return {
-      MinMaxExpr: {
-        xpr: _p?.xpr,
-        minmaxtype: _p?.minmaxtype,
-        minmaxcollid: _p?.minmaxcollid,
-        inputcollid: _p?.inputcollid,
-        op: _p?.op,
-        args: _p?.args,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      MinMaxExpr: {}
+    } as MinMaxExpr);
+    _o.set(_j, "MinMaxExpr.xpr", _p?.xpr);
+    _o.set(_j, "MinMaxExpr.minmaxtype", _p?.minmaxtype);
+    _o.set(_j, "MinMaxExpr.minmaxcollid", _p?.minmaxcollid);
+    _o.set(_j, "MinMaxExpr.inputcollid", _p?.inputcollid);
+    _o.set(_j, "MinMaxExpr.op", _p?.op);
+    _o.set(_j, "MinMaxExpr.args", _p?.args);
+    _o.set(_j, "MinMaxExpr.location", _p?.location);
+    return _j;
   },
   sqlValueFunction(_p?: SQLValueFunction["SQLValueFunction"]): SQLValueFunction {
-    return {
-      SQLValueFunction: {
-        xpr: _p?.xpr,
-        op: _p?.op,
-        type: _p?.type,
-        typmod: _p?.typmod,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      SQLValueFunction: {}
+    } as SQLValueFunction);
+    _o.set(_j, "SQLValueFunction.xpr", _p?.xpr);
+    _o.set(_j, "SQLValueFunction.op", _p?.op);
+    _o.set(_j, "SQLValueFunction.type", _p?.type);
+    _o.set(_j, "SQLValueFunction.typmod", _p?.typmod);
+    _o.set(_j, "SQLValueFunction.location", _p?.location);
+    return _j;
   },
   xmlExpr(_p?: XmlExpr["XmlExpr"]): XmlExpr {
-    return {
-      XmlExpr: {
-        xpr: _p?.xpr,
-        op: _p?.op,
-        name: _p?.name,
-        named_args: _p?.named_args,
-        arg_names: _p?.arg_names,
-        args: _p?.args,
-        xmloption: _p?.xmloption,
-        type: _p?.type,
-        typmod: _p?.typmod,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      XmlExpr: {}
+    } as XmlExpr);
+    _o.set(_j, "XmlExpr.xpr", _p?.xpr);
+    _o.set(_j, "XmlExpr.op", _p?.op);
+    _o.set(_j, "XmlExpr.name", _p?.name);
+    _o.set(_j, "XmlExpr.named_args", _p?.named_args);
+    _o.set(_j, "XmlExpr.arg_names", _p?.arg_names);
+    _o.set(_j, "XmlExpr.args", _p?.args);
+    _o.set(_j, "XmlExpr.xmloption", _p?.xmloption);
+    _o.set(_j, "XmlExpr.type", _p?.type);
+    _o.set(_j, "XmlExpr.typmod", _p?.typmod);
+    _o.set(_j, "XmlExpr.location", _p?.location);
+    return _j;
   },
   nullTest(_p?: NullTest["NullTest"]): NullTest {
-    return {
-      NullTest: {
-        xpr: _p?.xpr,
-        arg: _p?.arg,
-        nulltesttype: _p?.nulltesttype,
-        argisrow: _p?.argisrow,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      NullTest: {}
+    } as NullTest);
+    _o.set(_j, "NullTest.xpr", _p?.xpr);
+    _o.set(_j, "NullTest.arg", _p?.arg);
+    _o.set(_j, "NullTest.nulltesttype", _p?.nulltesttype);
+    _o.set(_j, "NullTest.argisrow", _p?.argisrow);
+    _o.set(_j, "NullTest.location", _p?.location);
+    return _j;
   },
   booleanTest(_p?: BooleanTest["BooleanTest"]): BooleanTest {
-    return {
-      BooleanTest: {
-        xpr: _p?.xpr,
-        arg: _p?.arg,
-        booltesttype: _p?.booltesttype,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      BooleanTest: {}
+    } as BooleanTest);
+    _o.set(_j, "BooleanTest.xpr", _p?.xpr);
+    _o.set(_j, "BooleanTest.arg", _p?.arg);
+    _o.set(_j, "BooleanTest.booltesttype", _p?.booltesttype);
+    _o.set(_j, "BooleanTest.location", _p?.location);
+    return _j;
   },
   coerceToDomain(_p?: CoerceToDomain["CoerceToDomain"]): CoerceToDomain {
-    return {
-      CoerceToDomain: {
-        xpr: _p?.xpr,
-        arg: _p?.arg,
-        resulttype: _p?.resulttype,
-        resulttypmod: _p?.resulttypmod,
-        resultcollid: _p?.resultcollid,
-        coercionformat: _p?.coercionformat,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      CoerceToDomain: {}
+    } as CoerceToDomain);
+    _o.set(_j, "CoerceToDomain.xpr", _p?.xpr);
+    _o.set(_j, "CoerceToDomain.arg", _p?.arg);
+    _o.set(_j, "CoerceToDomain.resulttype", _p?.resulttype);
+    _o.set(_j, "CoerceToDomain.resulttypmod", _p?.resulttypmod);
+    _o.set(_j, "CoerceToDomain.resultcollid", _p?.resultcollid);
+    _o.set(_j, "CoerceToDomain.coercionformat", _p?.coercionformat);
+    _o.set(_j, "CoerceToDomain.location", _p?.location);
+    return _j;
   },
   coerceToDomainValue(_p?: CoerceToDomainValue["CoerceToDomainValue"]): CoerceToDomainValue {
-    return {
-      CoerceToDomainValue: {
-        xpr: _p?.xpr,
-        typeId: _p?.typeId,
-        typeMod: _p?.typeMod,
-        collation: _p?.collation,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      CoerceToDomainValue: {}
+    } as CoerceToDomainValue);
+    _o.set(_j, "CoerceToDomainValue.xpr", _p?.xpr);
+    _o.set(_j, "CoerceToDomainValue.typeId", _p?.typeId);
+    _o.set(_j, "CoerceToDomainValue.typeMod", _p?.typeMod);
+    _o.set(_j, "CoerceToDomainValue.collation", _p?.collation);
+    _o.set(_j, "CoerceToDomainValue.location", _p?.location);
+    return _j;
   },
   setToDefault(_p?: SetToDefault["SetToDefault"]): SetToDefault {
-    return {
-      SetToDefault: {
-        xpr: _p?.xpr,
-        typeId: _p?.typeId,
-        typeMod: _p?.typeMod,
-        collation: _p?.collation,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      SetToDefault: {}
+    } as SetToDefault);
+    _o.set(_j, "SetToDefault.xpr", _p?.xpr);
+    _o.set(_j, "SetToDefault.typeId", _p?.typeId);
+    _o.set(_j, "SetToDefault.typeMod", _p?.typeMod);
+    _o.set(_j, "SetToDefault.collation", _p?.collation);
+    _o.set(_j, "SetToDefault.location", _p?.location);
+    return _j;
   },
   currentOfExpr(_p?: CurrentOfExpr["CurrentOfExpr"]): CurrentOfExpr {
-    return {
-      CurrentOfExpr: {
-        xpr: _p?.xpr,
-        cvarno: _p?.cvarno,
-        cursor_name: _p?.cursor_name,
-        cursor_param: _p?.cursor_param
-      }
-    };
+    const _j = ({
+      CurrentOfExpr: {}
+    } as CurrentOfExpr);
+    _o.set(_j, "CurrentOfExpr.xpr", _p?.xpr);
+    _o.set(_j, "CurrentOfExpr.cvarno", _p?.cvarno);
+    _o.set(_j, "CurrentOfExpr.cursor_name", _p?.cursor_name);
+    _o.set(_j, "CurrentOfExpr.cursor_param", _p?.cursor_param);
+    return _j;
   },
   nextValueExpr(_p?: NextValueExpr["NextValueExpr"]): NextValueExpr {
-    return {
-      NextValueExpr: {
-        xpr: _p?.xpr,
-        seqid: _p?.seqid,
-        typeId: _p?.typeId
-      }
-    };
+    const _j = ({
+      NextValueExpr: {}
+    } as NextValueExpr);
+    _o.set(_j, "NextValueExpr.xpr", _p?.xpr);
+    _o.set(_j, "NextValueExpr.seqid", _p?.seqid);
+    _o.set(_j, "NextValueExpr.typeId", _p?.typeId);
+    return _j;
   },
   inferenceElem(_p?: InferenceElem["InferenceElem"]): InferenceElem {
-    return {
-      InferenceElem: {
-        xpr: _p?.xpr,
-        expr: _p?.expr,
-        infercollid: _p?.infercollid,
-        inferopclass: _p?.inferopclass
-      }
-    };
+    const _j = ({
+      InferenceElem: {}
+    } as InferenceElem);
+    _o.set(_j, "InferenceElem.xpr", _p?.xpr);
+    _o.set(_j, "InferenceElem.expr", _p?.expr);
+    _o.set(_j, "InferenceElem.infercollid", _p?.infercollid);
+    _o.set(_j, "InferenceElem.inferopclass", _p?.inferopclass);
+    return _j;
   },
   targetEntry(_p?: TargetEntry["TargetEntry"]): TargetEntry {
-    return {
-      TargetEntry: {
-        xpr: _p?.xpr,
-        expr: _p?.expr,
-        resno: _p?.resno,
-        resname: _p?.resname,
-        ressortgroupref: _p?.ressortgroupref,
-        resorigtbl: _p?.resorigtbl,
-        resorigcol: _p?.resorigcol,
-        resjunk: _p?.resjunk
-      }
-    };
+    const _j = ({
+      TargetEntry: {}
+    } as TargetEntry);
+    _o.set(_j, "TargetEntry.xpr", _p?.xpr);
+    _o.set(_j, "TargetEntry.expr", _p?.expr);
+    _o.set(_j, "TargetEntry.resno", _p?.resno);
+    _o.set(_j, "TargetEntry.resname", _p?.resname);
+    _o.set(_j, "TargetEntry.ressortgroupref", _p?.ressortgroupref);
+    _o.set(_j, "TargetEntry.resorigtbl", _p?.resorigtbl);
+    _o.set(_j, "TargetEntry.resorigcol", _p?.resorigcol);
+    _o.set(_j, "TargetEntry.resjunk", _p?.resjunk);
+    return _j;
   },
   rangeTblRef(_p?: RangeTblRef["RangeTblRef"]): RangeTblRef {
-    return {
-      RangeTblRef: {
-        rtindex: _p?.rtindex
-      }
-    };
+    const _j = ({
+      RangeTblRef: {}
+    } as RangeTblRef);
+    _o.set(_j, "RangeTblRef.rtindex", _p?.rtindex);
+    return _j;
   },
   joinExpr(_p?: JoinExpr["JoinExpr"]): JoinExpr {
-    return {
-      JoinExpr: {
-        jointype: _p?.jointype,
-        isNatural: _p?.isNatural,
-        larg: _p?.larg,
-        rarg: _p?.rarg,
-        usingClause: _p?.usingClause,
-        quals: _p?.quals,
-        alias: _p?.alias,
-        rtindex: _p?.rtindex
-      }
-    };
+    const _j = ({
+      JoinExpr: {}
+    } as JoinExpr);
+    _o.set(_j, "JoinExpr.jointype", _p?.jointype);
+    _o.set(_j, "JoinExpr.isNatural", _p?.isNatural);
+    _o.set(_j, "JoinExpr.larg", _p?.larg);
+    _o.set(_j, "JoinExpr.rarg", _p?.rarg);
+    _o.set(_j, "JoinExpr.usingClause", _p?.usingClause);
+    _o.set(_j, "JoinExpr.quals", _p?.quals);
+    _o.set(_j, "JoinExpr.alias", _p?.alias);
+    _o.set(_j, "JoinExpr.rtindex", _p?.rtindex);
+    return _j;
   },
   fromExpr(_p?: FromExpr["FromExpr"]): FromExpr {
-    return {
-      FromExpr: {
-        fromlist: _p?.fromlist,
-        quals: _p?.quals
-      }
-    };
+    const _j = ({
+      FromExpr: {}
+    } as FromExpr);
+    _o.set(_j, "FromExpr.fromlist", _p?.fromlist);
+    _o.set(_j, "FromExpr.quals", _p?.quals);
+    return _j;
   },
   onConflictExpr(_p?: OnConflictExpr["OnConflictExpr"]): OnConflictExpr {
-    return {
-      OnConflictExpr: {
-        action: _p?.action,
-        arbiterElems: _p?.arbiterElems,
-        arbiterWhere: _p?.arbiterWhere,
-        constraint: _p?.constraint,
-        onConflictSet: _p?.onConflictSet,
-        onConflictWhere: _p?.onConflictWhere,
-        exclRelIndex: _p?.exclRelIndex,
-        exclRelTlist: _p?.exclRelTlist
-      }
-    };
+    const _j = ({
+      OnConflictExpr: {}
+    } as OnConflictExpr);
+    _o.set(_j, "OnConflictExpr.action", _p?.action);
+    _o.set(_j, "OnConflictExpr.arbiterElems", _p?.arbiterElems);
+    _o.set(_j, "OnConflictExpr.arbiterWhere", _p?.arbiterWhere);
+    _o.set(_j, "OnConflictExpr.constraint", _p?.constraint);
+    _o.set(_j, "OnConflictExpr.onConflictSet", _p?.onConflictSet);
+    _o.set(_j, "OnConflictExpr.onConflictWhere", _p?.onConflictWhere);
+    _o.set(_j, "OnConflictExpr.exclRelIndex", _p?.exclRelIndex);
+    _o.set(_j, "OnConflictExpr.exclRelTlist", _p?.exclRelTlist);
+    return _j;
   },
   intoClause(_p?: IntoClause["IntoClause"]): IntoClause {
-    return {
-      IntoClause: {
-        rel: _p?.rel,
-        colNames: _p?.colNames,
-        accessMethod: _p?.accessMethod,
-        options: _p?.options,
-        onCommit: _p?.onCommit,
-        tableSpaceName: _p?.tableSpaceName,
-        viewQuery: _p?.viewQuery,
-        skipData: _p?.skipData
-      }
-    };
+    const _j = ({
+      IntoClause: {}
+    } as IntoClause);
+    _o.set(_j, "IntoClause.rel", _p?.rel);
+    _o.set(_j, "IntoClause.colNames", _p?.colNames);
+    _o.set(_j, "IntoClause.accessMethod", _p?.accessMethod);
+    _o.set(_j, "IntoClause.options", _p?.options);
+    _o.set(_j, "IntoClause.onCommit", _p?.onCommit);
+    _o.set(_j, "IntoClause.tableSpaceName", _p?.tableSpaceName);
+    _o.set(_j, "IntoClause.viewQuery", _p?.viewQuery);
+    _o.set(_j, "IntoClause.skipData", _p?.skipData);
+    return _j;
   },
   rawStmt(_p?: RawStmt["RawStmt"]): RawStmt {
-    return {
-      RawStmt: {
-        stmt: _p?.stmt,
-        stmt_location: _p?.stmt_location,
-        stmt_len: _p?.stmt_len
-      }
-    };
+    const _j = ({
+      RawStmt: {}
+    } as RawStmt);
+    _o.set(_j, "RawStmt.stmt", _p?.stmt);
+    _o.set(_j, "RawStmt.stmt_location", _p?.stmt_location);
+    _o.set(_j, "RawStmt.stmt_len", _p?.stmt_len);
+    return _j;
   },
   query(_p?: Query["Query"]): Query {
-    return {
-      Query: {
-        commandType: _p?.commandType,
-        querySource: _p?.querySource,
-        canSetTag: _p?.canSetTag,
-        utilityStmt: _p?.utilityStmt,
-        resultRelation: _p?.resultRelation,
-        hasAggs: _p?.hasAggs,
-        hasWindowFuncs: _p?.hasWindowFuncs,
-        hasTargetSRFs: _p?.hasTargetSRFs,
-        hasSubLinks: _p?.hasSubLinks,
-        hasDistinctOn: _p?.hasDistinctOn,
-        hasRecursive: _p?.hasRecursive,
-        hasModifyingCTE: _p?.hasModifyingCTE,
-        hasForUpdate: _p?.hasForUpdate,
-        hasRowSecurity: _p?.hasRowSecurity,
-        cteList: _p?.cteList,
-        rtable: _p?.rtable,
-        jointree: _p?.jointree,
-        targetList: _p?.targetList,
-        override: _p?.override,
-        onConflict: _p?.onConflict,
-        returningList: _p?.returningList,
-        groupClause: _p?.groupClause,
-        groupingSets: _p?.groupingSets,
-        havingQual: _p?.havingQual,
-        windowClause: _p?.windowClause,
-        distinctClause: _p?.distinctClause,
-        sortClause: _p?.sortClause,
-        limitOffset: _p?.limitOffset,
-        limitCount: _p?.limitCount,
-        limitOption: _p?.limitOption,
-        rowMarks: _p?.rowMarks,
-        setOperations: _p?.setOperations,
-        constraintDeps: _p?.constraintDeps,
-        withCheckOptions: _p?.withCheckOptions,
-        stmt_location: _p?.stmt_location,
-        stmt_len: _p?.stmt_len
-      }
-    };
+    const _j = ({
+      Query: {}
+    } as Query);
+    _o.set(_j, "Query.commandType", _p?.commandType);
+    _o.set(_j, "Query.querySource", _p?.querySource);
+    _o.set(_j, "Query.canSetTag", _p?.canSetTag);
+    _o.set(_j, "Query.utilityStmt", _p?.utilityStmt);
+    _o.set(_j, "Query.resultRelation", _p?.resultRelation);
+    _o.set(_j, "Query.hasAggs", _p?.hasAggs);
+    _o.set(_j, "Query.hasWindowFuncs", _p?.hasWindowFuncs);
+    _o.set(_j, "Query.hasTargetSRFs", _p?.hasTargetSRFs);
+    _o.set(_j, "Query.hasSubLinks", _p?.hasSubLinks);
+    _o.set(_j, "Query.hasDistinctOn", _p?.hasDistinctOn);
+    _o.set(_j, "Query.hasRecursive", _p?.hasRecursive);
+    _o.set(_j, "Query.hasModifyingCTE", _p?.hasModifyingCTE);
+    _o.set(_j, "Query.hasForUpdate", _p?.hasForUpdate);
+    _o.set(_j, "Query.hasRowSecurity", _p?.hasRowSecurity);
+    _o.set(_j, "Query.cteList", _p?.cteList);
+    _o.set(_j, "Query.rtable", _p?.rtable);
+    _o.set(_j, "Query.jointree", _p?.jointree);
+    _o.set(_j, "Query.targetList", _p?.targetList);
+    _o.set(_j, "Query.override", _p?.override);
+    _o.set(_j, "Query.onConflict", _p?.onConflict);
+    _o.set(_j, "Query.returningList", _p?.returningList);
+    _o.set(_j, "Query.groupClause", _p?.groupClause);
+    _o.set(_j, "Query.groupingSets", _p?.groupingSets);
+    _o.set(_j, "Query.havingQual", _p?.havingQual);
+    _o.set(_j, "Query.windowClause", _p?.windowClause);
+    _o.set(_j, "Query.distinctClause", _p?.distinctClause);
+    _o.set(_j, "Query.sortClause", _p?.sortClause);
+    _o.set(_j, "Query.limitOffset", _p?.limitOffset);
+    _o.set(_j, "Query.limitCount", _p?.limitCount);
+    _o.set(_j, "Query.limitOption", _p?.limitOption);
+    _o.set(_j, "Query.rowMarks", _p?.rowMarks);
+    _o.set(_j, "Query.setOperations", _p?.setOperations);
+    _o.set(_j, "Query.constraintDeps", _p?.constraintDeps);
+    _o.set(_j, "Query.withCheckOptions", _p?.withCheckOptions);
+    _o.set(_j, "Query.stmt_location", _p?.stmt_location);
+    _o.set(_j, "Query.stmt_len", _p?.stmt_len);
+    return _j;
   },
   insertStmt(_p?: InsertStmt["InsertStmt"]): InsertStmt {
-    return {
-      InsertStmt: {
-        relation: _p?.relation,
-        cols: _p?.cols,
-        selectStmt: _p?.selectStmt,
-        onConflictClause: _p?.onConflictClause,
-        returningList: _p?.returningList,
-        withClause: _p?.withClause,
-        override: _p?.override
-      }
-    };
+    const _j = ({
+      InsertStmt: {}
+    } as InsertStmt);
+    _o.set(_j, "InsertStmt.relation", _p?.relation);
+    _o.set(_j, "InsertStmt.cols", _p?.cols);
+    _o.set(_j, "InsertStmt.selectStmt", _p?.selectStmt);
+    _o.set(_j, "InsertStmt.onConflictClause", _p?.onConflictClause);
+    _o.set(_j, "InsertStmt.returningList", _p?.returningList);
+    _o.set(_j, "InsertStmt.withClause", _p?.withClause);
+    _o.set(_j, "InsertStmt.override", _p?.override);
+    return _j;
   },
   deleteStmt(_p?: DeleteStmt["DeleteStmt"]): DeleteStmt {
-    return {
-      DeleteStmt: {
-        relation: _p?.relation,
-        usingClause: _p?.usingClause,
-        whereClause: _p?.whereClause,
-        returningList: _p?.returningList,
-        withClause: _p?.withClause
-      }
-    };
+    const _j = ({
+      DeleteStmt: {}
+    } as DeleteStmt);
+    _o.set(_j, "DeleteStmt.relation", _p?.relation);
+    _o.set(_j, "DeleteStmt.usingClause", _p?.usingClause);
+    _o.set(_j, "DeleteStmt.whereClause", _p?.whereClause);
+    _o.set(_j, "DeleteStmt.returningList", _p?.returningList);
+    _o.set(_j, "DeleteStmt.withClause", _p?.withClause);
+    return _j;
   },
   updateStmt(_p?: UpdateStmt["UpdateStmt"]): UpdateStmt {
-    return {
-      UpdateStmt: {
-        relation: _p?.relation,
-        targetList: _p?.targetList,
-        whereClause: _p?.whereClause,
-        fromClause: _p?.fromClause,
-        returningList: _p?.returningList,
-        withClause: _p?.withClause
-      }
-    };
+    const _j = ({
+      UpdateStmt: {}
+    } as UpdateStmt);
+    _o.set(_j, "UpdateStmt.relation", _p?.relation);
+    _o.set(_j, "UpdateStmt.targetList", _p?.targetList);
+    _o.set(_j, "UpdateStmt.whereClause", _p?.whereClause);
+    _o.set(_j, "UpdateStmt.fromClause", _p?.fromClause);
+    _o.set(_j, "UpdateStmt.returningList", _p?.returningList);
+    _o.set(_j, "UpdateStmt.withClause", _p?.withClause);
+    return _j;
   },
   selectStmt(_p?: SelectStmt["SelectStmt"]): SelectStmt {
-    return {
-      SelectStmt: {
-        distinctClause: _p?.distinctClause,
-        intoClause: _p?.intoClause,
-        targetList: _p?.targetList,
-        fromClause: _p?.fromClause,
-        whereClause: _p?.whereClause,
-        groupClause: _p?.groupClause,
-        havingClause: _p?.havingClause,
-        windowClause: _p?.windowClause,
-        valuesLists: _p?.valuesLists,
-        sortClause: _p?.sortClause,
-        limitOffset: _p?.limitOffset,
-        limitCount: _p?.limitCount,
-        limitOption: _p?.limitOption,
-        lockingClause: _p?.lockingClause,
-        withClause: _p?.withClause,
-        op: _p?.op,
-        all: _p?.all,
-        larg: _p?.larg,
-        rarg: _p?.rarg
-      }
-    };
+    const _j = ({
+      SelectStmt: {}
+    } as SelectStmt);
+    _o.set(_j, "SelectStmt.distinctClause", _p?.distinctClause);
+    _o.set(_j, "SelectStmt.intoClause", _p?.intoClause);
+    _o.set(_j, "SelectStmt.targetList", _p?.targetList);
+    _o.set(_j, "SelectStmt.fromClause", _p?.fromClause);
+    _o.set(_j, "SelectStmt.whereClause", _p?.whereClause);
+    _o.set(_j, "SelectStmt.groupClause", _p?.groupClause);
+    _o.set(_j, "SelectStmt.havingClause", _p?.havingClause);
+    _o.set(_j, "SelectStmt.windowClause", _p?.windowClause);
+    _o.set(_j, "SelectStmt.valuesLists", _p?.valuesLists);
+    _o.set(_j, "SelectStmt.sortClause", _p?.sortClause);
+    _o.set(_j, "SelectStmt.limitOffset", _p?.limitOffset);
+    _o.set(_j, "SelectStmt.limitCount", _p?.limitCount);
+    _o.set(_j, "SelectStmt.limitOption", _p?.limitOption);
+    _o.set(_j, "SelectStmt.lockingClause", _p?.lockingClause);
+    _o.set(_j, "SelectStmt.withClause", _p?.withClause);
+    _o.set(_j, "SelectStmt.op", _p?.op);
+    _o.set(_j, "SelectStmt.all", _p?.all);
+    _o.set(_j, "SelectStmt.larg", _p?.larg);
+    _o.set(_j, "SelectStmt.rarg", _p?.rarg);
+    return _j;
   },
   alterTableStmt(_p?: AlterTableStmt["AlterTableStmt"]): AlterTableStmt {
-    return {
-      AlterTableStmt: {
-        relation: _p?.relation,
-        cmds: _p?.cmds,
-        relkind: _p?.relkind,
-        missing_ok: _p?.missing_ok
-      }
-    };
+    const _j = ({
+      AlterTableStmt: {}
+    } as AlterTableStmt);
+    _o.set(_j, "AlterTableStmt.relation", _p?.relation);
+    _o.set(_j, "AlterTableStmt.cmds", _p?.cmds);
+    _o.set(_j, "AlterTableStmt.relkind", _p?.relkind);
+    _o.set(_j, "AlterTableStmt.missing_ok", _p?.missing_ok);
+    return _j;
   },
   alterTableCmd(_p?: AlterTableCmd["AlterTableCmd"]): AlterTableCmd {
-    return {
-      AlterTableCmd: {
-        subtype: _p?.subtype,
-        name: _p?.name,
-        num: _p?.num,
-        newowner: _p?.newowner,
-        def: _p?.def,
-        behavior: _p?.behavior,
-        missing_ok: _p?.missing_ok,
-        recurse: _p?.recurse
-      }
-    };
+    const _j = ({
+      AlterTableCmd: {}
+    } as AlterTableCmd);
+    _o.set(_j, "AlterTableCmd.subtype", _p?.subtype);
+    _o.set(_j, "AlterTableCmd.name", _p?.name);
+    _o.set(_j, "AlterTableCmd.num", _p?.num);
+    _o.set(_j, "AlterTableCmd.newowner", _p?.newowner);
+    _o.set(_j, "AlterTableCmd.def", _p?.def);
+    _o.set(_j, "AlterTableCmd.behavior", _p?.behavior);
+    _o.set(_j, "AlterTableCmd.missing_ok", _p?.missing_ok);
+    _o.set(_j, "AlterTableCmd.recurse", _p?.recurse);
+    return _j;
   },
   alterDomainStmt(_p?: AlterDomainStmt["AlterDomainStmt"]): AlterDomainStmt {
-    return {
-      AlterDomainStmt: {
-        subtype: _p?.subtype,
-        typeName: _p?.typeName,
-        name: _p?.name,
-        def: _p?.def,
-        behavior: _p?.behavior,
-        missing_ok: _p?.missing_ok
-      }
-    };
+    const _j = ({
+      AlterDomainStmt: {}
+    } as AlterDomainStmt);
+    _o.set(_j, "AlterDomainStmt.subtype", _p?.subtype);
+    _o.set(_j, "AlterDomainStmt.typeName", _p?.typeName);
+    _o.set(_j, "AlterDomainStmt.name", _p?.name);
+    _o.set(_j, "AlterDomainStmt.def", _p?.def);
+    _o.set(_j, "AlterDomainStmt.behavior", _p?.behavior);
+    _o.set(_j, "AlterDomainStmt.missing_ok", _p?.missing_ok);
+    return _j;
   },
   setOperationStmt(_p?: SetOperationStmt["SetOperationStmt"]): SetOperationStmt {
-    return {
-      SetOperationStmt: {
-        op: _p?.op,
-        all: _p?.all,
-        larg: _p?.larg,
-        rarg: _p?.rarg,
-        colTypes: _p?.colTypes,
-        colTypmods: _p?.colTypmods,
-        colCollations: _p?.colCollations,
-        groupClauses: _p?.groupClauses
-      }
-    };
+    const _j = ({
+      SetOperationStmt: {}
+    } as SetOperationStmt);
+    _o.set(_j, "SetOperationStmt.op", _p?.op);
+    _o.set(_j, "SetOperationStmt.all", _p?.all);
+    _o.set(_j, "SetOperationStmt.larg", _p?.larg);
+    _o.set(_j, "SetOperationStmt.rarg", _p?.rarg);
+    _o.set(_j, "SetOperationStmt.colTypes", _p?.colTypes);
+    _o.set(_j, "SetOperationStmt.colTypmods", _p?.colTypmods);
+    _o.set(_j, "SetOperationStmt.colCollations", _p?.colCollations);
+    _o.set(_j, "SetOperationStmt.groupClauses", _p?.groupClauses);
+    return _j;
   },
   grantStmt(_p?: GrantStmt["GrantStmt"]): GrantStmt {
-    return {
-      GrantStmt: {
-        is_grant: _p?.is_grant,
-        targtype: _p?.targtype,
-        objtype: _p?.objtype,
-        objects: _p?.objects,
-        privileges: _p?.privileges,
-        grantees: _p?.grantees,
-        grant_option: _p?.grant_option,
-        behavior: _p?.behavior
-      }
-    };
+    const _j = ({
+      GrantStmt: {}
+    } as GrantStmt);
+    _o.set(_j, "GrantStmt.is_grant", _p?.is_grant);
+    _o.set(_j, "GrantStmt.targtype", _p?.targtype);
+    _o.set(_j, "GrantStmt.objtype", _p?.objtype);
+    _o.set(_j, "GrantStmt.objects", _p?.objects);
+    _o.set(_j, "GrantStmt.privileges", _p?.privileges);
+    _o.set(_j, "GrantStmt.grantees", _p?.grantees);
+    _o.set(_j, "GrantStmt.grant_option", _p?.grant_option);
+    _o.set(_j, "GrantStmt.behavior", _p?.behavior);
+    return _j;
   },
   grantRoleStmt(_p?: GrantRoleStmt["GrantRoleStmt"]): GrantRoleStmt {
-    return {
-      GrantRoleStmt: {
-        granted_roles: _p?.granted_roles,
-        grantee_roles: _p?.grantee_roles,
-        is_grant: _p?.is_grant,
-        admin_opt: _p?.admin_opt,
-        grantor: _p?.grantor,
-        behavior: _p?.behavior
-      }
-    };
+    const _j = ({
+      GrantRoleStmt: {}
+    } as GrantRoleStmt);
+    _o.set(_j, "GrantRoleStmt.granted_roles", _p?.granted_roles);
+    _o.set(_j, "GrantRoleStmt.grantee_roles", _p?.grantee_roles);
+    _o.set(_j, "GrantRoleStmt.is_grant", _p?.is_grant);
+    _o.set(_j, "GrantRoleStmt.admin_opt", _p?.admin_opt);
+    _o.set(_j, "GrantRoleStmt.grantor", _p?.grantor);
+    _o.set(_j, "GrantRoleStmt.behavior", _p?.behavior);
+    return _j;
   },
   alterDefaultPrivilegesStmt(_p?: AlterDefaultPrivilegesStmt["AlterDefaultPrivilegesStmt"]): AlterDefaultPrivilegesStmt {
-    return {
-      AlterDefaultPrivilegesStmt: {
-        options: _p?.options,
-        action: _p?.action
-      }
-    };
+    const _j = ({
+      AlterDefaultPrivilegesStmt: {}
+    } as AlterDefaultPrivilegesStmt);
+    _o.set(_j, "AlterDefaultPrivilegesStmt.options", _p?.options);
+    _o.set(_j, "AlterDefaultPrivilegesStmt.action", _p?.action);
+    return _j;
   },
   closePortalStmt(_p?: ClosePortalStmt["ClosePortalStmt"]): ClosePortalStmt {
-    return {
-      ClosePortalStmt: {
-        portalname: _p?.portalname
-      }
-    };
+    const _j = ({
+      ClosePortalStmt: {}
+    } as ClosePortalStmt);
+    _o.set(_j, "ClosePortalStmt.portalname", _p?.portalname);
+    return _j;
   },
   clusterStmt(_p?: ClusterStmt["ClusterStmt"]): ClusterStmt {
-    return {
-      ClusterStmt: {
-        relation: _p?.relation,
-        indexname: _p?.indexname,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      ClusterStmt: {}
+    } as ClusterStmt);
+    _o.set(_j, "ClusterStmt.relation", _p?.relation);
+    _o.set(_j, "ClusterStmt.indexname", _p?.indexname);
+    _o.set(_j, "ClusterStmt.options", _p?.options);
+    return _j;
   },
   copyStmt(_p?: CopyStmt["CopyStmt"]): CopyStmt {
-    return {
-      CopyStmt: {
-        relation: _p?.relation,
-        query: _p?.query,
-        attlist: _p?.attlist,
-        is_from: _p?.is_from,
-        is_program: _p?.is_program,
-        filename: _p?.filename,
-        options: _p?.options,
-        whereClause: _p?.whereClause
-      }
-    };
+    const _j = ({
+      CopyStmt: {}
+    } as CopyStmt);
+    _o.set(_j, "CopyStmt.relation", _p?.relation);
+    _o.set(_j, "CopyStmt.query", _p?.query);
+    _o.set(_j, "CopyStmt.attlist", _p?.attlist);
+    _o.set(_j, "CopyStmt.is_from", _p?.is_from);
+    _o.set(_j, "CopyStmt.is_program", _p?.is_program);
+    _o.set(_j, "CopyStmt.filename", _p?.filename);
+    _o.set(_j, "CopyStmt.options", _p?.options);
+    _o.set(_j, "CopyStmt.whereClause", _p?.whereClause);
+    return _j;
   },
   createStmt(_p?: CreateStmt["CreateStmt"]): CreateStmt {
-    return {
-      CreateStmt: {
-        relation: _p?.relation,
-        tableElts: _p?.tableElts,
-        inhRelations: _p?.inhRelations,
-        partbound: _p?.partbound,
-        partspec: _p?.partspec,
-        ofTypename: _p?.ofTypename,
-        constraints: _p?.constraints,
-        options: _p?.options,
-        oncommit: _p?.oncommit,
-        tablespacename: _p?.tablespacename,
-        accessMethod: _p?.accessMethod,
-        if_not_exists: _p?.if_not_exists
-      }
-    };
+    const _j = ({
+      CreateStmt: {}
+    } as CreateStmt);
+    _o.set(_j, "CreateStmt.relation", _p?.relation);
+    _o.set(_j, "CreateStmt.tableElts", _p?.tableElts);
+    _o.set(_j, "CreateStmt.inhRelations", _p?.inhRelations);
+    _o.set(_j, "CreateStmt.partbound", _p?.partbound);
+    _o.set(_j, "CreateStmt.partspec", _p?.partspec);
+    _o.set(_j, "CreateStmt.ofTypename", _p?.ofTypename);
+    _o.set(_j, "CreateStmt.constraints", _p?.constraints);
+    _o.set(_j, "CreateStmt.options", _p?.options);
+    _o.set(_j, "CreateStmt.oncommit", _p?.oncommit);
+    _o.set(_j, "CreateStmt.tablespacename", _p?.tablespacename);
+    _o.set(_j, "CreateStmt.accessMethod", _p?.accessMethod);
+    _o.set(_j, "CreateStmt.if_not_exists", _p?.if_not_exists);
+    return _j;
   },
   defineStmt(_p?: DefineStmt["DefineStmt"]): DefineStmt {
-    return {
-      DefineStmt: {
-        kind: _p?.kind,
-        oldstyle: _p?.oldstyle,
-        defnames: _p?.defnames,
-        args: _p?.args,
-        definition: _p?.definition,
-        if_not_exists: _p?.if_not_exists,
-        replace: _p?.replace
-      }
-    };
+    const _j = ({
+      DefineStmt: {}
+    } as DefineStmt);
+    _o.set(_j, "DefineStmt.kind", _p?.kind);
+    _o.set(_j, "DefineStmt.oldstyle", _p?.oldstyle);
+    _o.set(_j, "DefineStmt.defnames", _p?.defnames);
+    _o.set(_j, "DefineStmt.args", _p?.args);
+    _o.set(_j, "DefineStmt.definition", _p?.definition);
+    _o.set(_j, "DefineStmt.if_not_exists", _p?.if_not_exists);
+    _o.set(_j, "DefineStmt.replace", _p?.replace);
+    return _j;
   },
   dropStmt(_p?: DropStmt["DropStmt"]): DropStmt {
-    return {
-      DropStmt: {
-        objects: _p?.objects,
-        removeType: _p?.removeType,
-        behavior: _p?.behavior,
-        missing_ok: _p?.missing_ok,
-        concurrent: _p?.concurrent
-      }
-    };
+    const _j = ({
+      DropStmt: {}
+    } as DropStmt);
+    _o.set(_j, "DropStmt.objects", _p?.objects);
+    _o.set(_j, "DropStmt.removeType", _p?.removeType);
+    _o.set(_j, "DropStmt.behavior", _p?.behavior);
+    _o.set(_j, "DropStmt.missing_ok", _p?.missing_ok);
+    _o.set(_j, "DropStmt.concurrent", _p?.concurrent);
+    return _j;
   },
   truncateStmt(_p?: TruncateStmt["TruncateStmt"]): TruncateStmt {
-    return {
-      TruncateStmt: {
-        relations: _p?.relations,
-        restart_seqs: _p?.restart_seqs,
-        behavior: _p?.behavior
-      }
-    };
+    const _j = ({
+      TruncateStmt: {}
+    } as TruncateStmt);
+    _o.set(_j, "TruncateStmt.relations", _p?.relations);
+    _o.set(_j, "TruncateStmt.restart_seqs", _p?.restart_seqs);
+    _o.set(_j, "TruncateStmt.behavior", _p?.behavior);
+    return _j;
   },
   commentStmt(_p?: CommentStmt["CommentStmt"]): CommentStmt {
-    return {
-      CommentStmt: {
-        objtype: _p?.objtype,
-        object: _p?.object,
-        comment: _p?.comment
-      }
-    };
+    const _j = ({
+      CommentStmt: {}
+    } as CommentStmt);
+    _o.set(_j, "CommentStmt.objtype", _p?.objtype);
+    _o.set(_j, "CommentStmt.object", _p?.object);
+    _o.set(_j, "CommentStmt.comment", _p?.comment);
+    return _j;
   },
   fetchStmt(_p?: FetchStmt["FetchStmt"]): FetchStmt {
-    return {
-      FetchStmt: {
-        direction: _p?.direction,
-        howMany: _p?.howMany,
-        portalname: _p?.portalname,
-        ismove: _p?.ismove
-      }
-    };
+    const _j = ({
+      FetchStmt: {}
+    } as FetchStmt);
+    _o.set(_j, "FetchStmt.direction", _p?.direction);
+    _o.set(_j, "FetchStmt.howMany", _p?.howMany);
+    _o.set(_j, "FetchStmt.portalname", _p?.portalname);
+    _o.set(_j, "FetchStmt.ismove", _p?.ismove);
+    return _j;
   },
   indexStmt(_p?: IndexStmt["IndexStmt"]): IndexStmt {
-    return {
-      IndexStmt: {
-        idxname: _p?.idxname,
-        relation: _p?.relation,
-        accessMethod: _p?.accessMethod,
-        tableSpace: _p?.tableSpace,
-        indexParams: _p?.indexParams,
-        indexIncludingParams: _p?.indexIncludingParams,
-        options: _p?.options,
-        whereClause: _p?.whereClause,
-        excludeOpNames: _p?.excludeOpNames,
-        idxcomment: _p?.idxcomment,
-        indexOid: _p?.indexOid,
-        oldNode: _p?.oldNode,
-        oldCreateSubid: _p?.oldCreateSubid,
-        oldFirstRelfilenodeSubid: _p?.oldFirstRelfilenodeSubid,
-        unique: _p?.unique,
-        primary: _p?.primary,
-        isconstraint: _p?.isconstraint,
-        deferrable: _p?.deferrable,
-        initdeferred: _p?.initdeferred,
-        transformed: _p?.transformed,
-        concurrent: _p?.concurrent,
-        if_not_exists: _p?.if_not_exists,
-        reset_default_tblspc: _p?.reset_default_tblspc
-      }
-    };
+    const _j = ({
+      IndexStmt: {}
+    } as IndexStmt);
+    _o.set(_j, "IndexStmt.idxname", _p?.idxname);
+    _o.set(_j, "IndexStmt.relation", _p?.relation);
+    _o.set(_j, "IndexStmt.accessMethod", _p?.accessMethod);
+    _o.set(_j, "IndexStmt.tableSpace", _p?.tableSpace);
+    _o.set(_j, "IndexStmt.indexParams", _p?.indexParams);
+    _o.set(_j, "IndexStmt.indexIncludingParams", _p?.indexIncludingParams);
+    _o.set(_j, "IndexStmt.options", _p?.options);
+    _o.set(_j, "IndexStmt.whereClause", _p?.whereClause);
+    _o.set(_j, "IndexStmt.excludeOpNames", _p?.excludeOpNames);
+    _o.set(_j, "IndexStmt.idxcomment", _p?.idxcomment);
+    _o.set(_j, "IndexStmt.indexOid", _p?.indexOid);
+    _o.set(_j, "IndexStmt.oldNode", _p?.oldNode);
+    _o.set(_j, "IndexStmt.oldCreateSubid", _p?.oldCreateSubid);
+    _o.set(_j, "IndexStmt.oldFirstRelfilenodeSubid", _p?.oldFirstRelfilenodeSubid);
+    _o.set(_j, "IndexStmt.unique", _p?.unique);
+    _o.set(_j, "IndexStmt.primary", _p?.primary);
+    _o.set(_j, "IndexStmt.isconstraint", _p?.isconstraint);
+    _o.set(_j, "IndexStmt.deferrable", _p?.deferrable);
+    _o.set(_j, "IndexStmt.initdeferred", _p?.initdeferred);
+    _o.set(_j, "IndexStmt.transformed", _p?.transformed);
+    _o.set(_j, "IndexStmt.concurrent", _p?.concurrent);
+    _o.set(_j, "IndexStmt.if_not_exists", _p?.if_not_exists);
+    _o.set(_j, "IndexStmt.reset_default_tblspc", _p?.reset_default_tblspc);
+    return _j;
   },
   createFunctionStmt(_p?: CreateFunctionStmt["CreateFunctionStmt"]): CreateFunctionStmt {
-    return {
-      CreateFunctionStmt: {
-        is_procedure: _p?.is_procedure,
-        replace: _p?.replace,
-        funcname: _p?.funcname,
-        parameters: _p?.parameters,
-        returnType: _p?.returnType,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      CreateFunctionStmt: {}
+    } as CreateFunctionStmt);
+    _o.set(_j, "CreateFunctionStmt.is_procedure", _p?.is_procedure);
+    _o.set(_j, "CreateFunctionStmt.replace", _p?.replace);
+    _o.set(_j, "CreateFunctionStmt.funcname", _p?.funcname);
+    _o.set(_j, "CreateFunctionStmt.parameters", _p?.parameters);
+    _o.set(_j, "CreateFunctionStmt.returnType", _p?.returnType);
+    _o.set(_j, "CreateFunctionStmt.options", _p?.options);
+    return _j;
   },
   alterFunctionStmt(_p?: AlterFunctionStmt["AlterFunctionStmt"]): AlterFunctionStmt {
-    return {
-      AlterFunctionStmt: {
-        objtype: _p?.objtype,
-        func: _p?.func,
-        actions: _p?.actions
-      }
-    };
+    const _j = ({
+      AlterFunctionStmt: {}
+    } as AlterFunctionStmt);
+    _o.set(_j, "AlterFunctionStmt.objtype", _p?.objtype);
+    _o.set(_j, "AlterFunctionStmt.func", _p?.func);
+    _o.set(_j, "AlterFunctionStmt.actions", _p?.actions);
+    return _j;
   },
   doStmt(_p?: DoStmt["DoStmt"]): DoStmt {
-    return {
-      DoStmt: {
-        args: _p?.args
-      }
-    };
+    const _j = ({
+      DoStmt: {}
+    } as DoStmt);
+    _o.set(_j, "DoStmt.args", _p?.args);
+    return _j;
   },
   renameStmt(_p?: RenameStmt["RenameStmt"]): RenameStmt {
-    return {
-      RenameStmt: {
-        renameType: _p?.renameType,
-        relationType: _p?.relationType,
-        relation: _p?.relation,
-        object: _p?.object,
-        subname: _p?.subname,
-        newname: _p?.newname,
-        behavior: _p?.behavior,
-        missing_ok: _p?.missing_ok
-      }
-    };
+    const _j = ({
+      RenameStmt: {}
+    } as RenameStmt);
+    _o.set(_j, "RenameStmt.renameType", _p?.renameType);
+    _o.set(_j, "RenameStmt.relationType", _p?.relationType);
+    _o.set(_j, "RenameStmt.relation", _p?.relation);
+    _o.set(_j, "RenameStmt.object", _p?.object);
+    _o.set(_j, "RenameStmt.subname", _p?.subname);
+    _o.set(_j, "RenameStmt.newname", _p?.newname);
+    _o.set(_j, "RenameStmt.behavior", _p?.behavior);
+    _o.set(_j, "RenameStmt.missing_ok", _p?.missing_ok);
+    return _j;
   },
   ruleStmt(_p?: RuleStmt["RuleStmt"]): RuleStmt {
-    return {
-      RuleStmt: {
-        relation: _p?.relation,
-        rulename: _p?.rulename,
-        whereClause: _p?.whereClause,
-        event: _p?.event,
-        instead: _p?.instead,
-        actions: _p?.actions,
-        replace: _p?.replace
-      }
-    };
+    const _j = ({
+      RuleStmt: {}
+    } as RuleStmt);
+    _o.set(_j, "RuleStmt.relation", _p?.relation);
+    _o.set(_j, "RuleStmt.rulename", _p?.rulename);
+    _o.set(_j, "RuleStmt.whereClause", _p?.whereClause);
+    _o.set(_j, "RuleStmt.event", _p?.event);
+    _o.set(_j, "RuleStmt.instead", _p?.instead);
+    _o.set(_j, "RuleStmt.actions", _p?.actions);
+    _o.set(_j, "RuleStmt.replace", _p?.replace);
+    return _j;
   },
   notifyStmt(_p?: NotifyStmt["NotifyStmt"]): NotifyStmt {
-    return {
-      NotifyStmt: {
-        conditionname: _p?.conditionname,
-        payload: _p?.payload
-      }
-    };
+    const _j = ({
+      NotifyStmt: {}
+    } as NotifyStmt);
+    _o.set(_j, "NotifyStmt.conditionname", _p?.conditionname);
+    _o.set(_j, "NotifyStmt.payload", _p?.payload);
+    return _j;
   },
   listenStmt(_p?: ListenStmt["ListenStmt"]): ListenStmt {
-    return {
-      ListenStmt: {
-        conditionname: _p?.conditionname
-      }
-    };
+    const _j = ({
+      ListenStmt: {}
+    } as ListenStmt);
+    _o.set(_j, "ListenStmt.conditionname", _p?.conditionname);
+    return _j;
   },
   unlistenStmt(_p?: UnlistenStmt["UnlistenStmt"]): UnlistenStmt {
-    return {
-      UnlistenStmt: {
-        conditionname: _p?.conditionname
-      }
-    };
+    const _j = ({
+      UnlistenStmt: {}
+    } as UnlistenStmt);
+    _o.set(_j, "UnlistenStmt.conditionname", _p?.conditionname);
+    return _j;
   },
   transactionStmt(_p?: TransactionStmt["TransactionStmt"]): TransactionStmt {
-    return {
-      TransactionStmt: {
-        kind: _p?.kind,
-        options: _p?.options,
-        savepoint_name: _p?.savepoint_name,
-        gid: _p?.gid,
-        chain: _p?.chain
-      }
-    };
+    const _j = ({
+      TransactionStmt: {}
+    } as TransactionStmt);
+    _o.set(_j, "TransactionStmt.kind", _p?.kind);
+    _o.set(_j, "TransactionStmt.options", _p?.options);
+    _o.set(_j, "TransactionStmt.savepoint_name", _p?.savepoint_name);
+    _o.set(_j, "TransactionStmt.gid", _p?.gid);
+    _o.set(_j, "TransactionStmt.chain", _p?.chain);
+    return _j;
   },
   viewStmt(_p?: ViewStmt["ViewStmt"]): ViewStmt {
-    return {
-      ViewStmt: {
-        view: _p?.view,
-        aliases: _p?.aliases,
-        query: _p?.query,
-        replace: _p?.replace,
-        options: _p?.options,
-        withCheckOption: _p?.withCheckOption
-      }
-    };
+    const _j = ({
+      ViewStmt: {}
+    } as ViewStmt);
+    _o.set(_j, "ViewStmt.view", _p?.view);
+    _o.set(_j, "ViewStmt.aliases", _p?.aliases);
+    _o.set(_j, "ViewStmt.query", _p?.query);
+    _o.set(_j, "ViewStmt.replace", _p?.replace);
+    _o.set(_j, "ViewStmt.options", _p?.options);
+    _o.set(_j, "ViewStmt.withCheckOption", _p?.withCheckOption);
+    return _j;
   },
   loadStmt(_p?: LoadStmt["LoadStmt"]): LoadStmt {
-    return {
-      LoadStmt: {
-        filename: _p?.filename
-      }
-    };
+    const _j = ({
+      LoadStmt: {}
+    } as LoadStmt);
+    _o.set(_j, "LoadStmt.filename", _p?.filename);
+    return _j;
   },
   createDomainStmt(_p?: CreateDomainStmt["CreateDomainStmt"]): CreateDomainStmt {
-    return {
-      CreateDomainStmt: {
-        domainname: _p?.domainname,
-        typeName: _p?.typeName,
-        collClause: _p?.collClause,
-        constraints: _p?.constraints
-      }
-    };
+    const _j = ({
+      CreateDomainStmt: {}
+    } as CreateDomainStmt);
+    _o.set(_j, "CreateDomainStmt.domainname", _p?.domainname);
+    _o.set(_j, "CreateDomainStmt.typeName", _p?.typeName);
+    _o.set(_j, "CreateDomainStmt.collClause", _p?.collClause);
+    _o.set(_j, "CreateDomainStmt.constraints", _p?.constraints);
+    return _j;
   },
   createdbStmt(_p?: CreatedbStmt["CreatedbStmt"]): CreatedbStmt {
-    return {
-      CreatedbStmt: {
-        dbname: _p?.dbname,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      CreatedbStmt: {}
+    } as CreatedbStmt);
+    _o.set(_j, "CreatedbStmt.dbname", _p?.dbname);
+    _o.set(_j, "CreatedbStmt.options", _p?.options);
+    return _j;
   },
   dropdbStmt(_p?: DropdbStmt["DropdbStmt"]): DropdbStmt {
-    return {
-      DropdbStmt: {
-        dbname: _p?.dbname,
-        missing_ok: _p?.missing_ok,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      DropdbStmt: {}
+    } as DropdbStmt);
+    _o.set(_j, "DropdbStmt.dbname", _p?.dbname);
+    _o.set(_j, "DropdbStmt.missing_ok", _p?.missing_ok);
+    _o.set(_j, "DropdbStmt.options", _p?.options);
+    return _j;
   },
   vacuumStmt(_p?: VacuumStmt["VacuumStmt"]): VacuumStmt {
-    return {
-      VacuumStmt: {
-        options: _p?.options,
-        rels: _p?.rels,
-        is_vacuumcmd: _p?.is_vacuumcmd
-      }
-    };
+    const _j = ({
+      VacuumStmt: {}
+    } as VacuumStmt);
+    _o.set(_j, "VacuumStmt.options", _p?.options);
+    _o.set(_j, "VacuumStmt.rels", _p?.rels);
+    _o.set(_j, "VacuumStmt.is_vacuumcmd", _p?.is_vacuumcmd);
+    return _j;
   },
   explainStmt(_p?: ExplainStmt["ExplainStmt"]): ExplainStmt {
-    return {
-      ExplainStmt: {
-        query: _p?.query,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      ExplainStmt: {}
+    } as ExplainStmt);
+    _o.set(_j, "ExplainStmt.query", _p?.query);
+    _o.set(_j, "ExplainStmt.options", _p?.options);
+    return _j;
   },
   createTableAsStmt(_p?: CreateTableAsStmt["CreateTableAsStmt"]): CreateTableAsStmt {
-    return {
-      CreateTableAsStmt: {
-        query: _p?.query,
-        into: _p?.into,
-        relkind: _p?.relkind,
-        is_select_into: _p?.is_select_into,
-        if_not_exists: _p?.if_not_exists
-      }
-    };
+    const _j = ({
+      CreateTableAsStmt: {}
+    } as CreateTableAsStmt);
+    _o.set(_j, "CreateTableAsStmt.query", _p?.query);
+    _o.set(_j, "CreateTableAsStmt.into", _p?.into);
+    _o.set(_j, "CreateTableAsStmt.relkind", _p?.relkind);
+    _o.set(_j, "CreateTableAsStmt.is_select_into", _p?.is_select_into);
+    _o.set(_j, "CreateTableAsStmt.if_not_exists", _p?.if_not_exists);
+    return _j;
   },
   createSeqStmt(_p?: CreateSeqStmt["CreateSeqStmt"]): CreateSeqStmt {
-    return {
-      CreateSeqStmt: {
-        sequence: _p?.sequence,
-        options: _p?.options,
-        ownerId: _p?.ownerId,
-        for_identity: _p?.for_identity,
-        if_not_exists: _p?.if_not_exists
-      }
-    };
+    const _j = ({
+      CreateSeqStmt: {}
+    } as CreateSeqStmt);
+    _o.set(_j, "CreateSeqStmt.sequence", _p?.sequence);
+    _o.set(_j, "CreateSeqStmt.options", _p?.options);
+    _o.set(_j, "CreateSeqStmt.ownerId", _p?.ownerId);
+    _o.set(_j, "CreateSeqStmt.for_identity", _p?.for_identity);
+    _o.set(_j, "CreateSeqStmt.if_not_exists", _p?.if_not_exists);
+    return _j;
   },
   alterSeqStmt(_p?: AlterSeqStmt["AlterSeqStmt"]): AlterSeqStmt {
-    return {
-      AlterSeqStmt: {
-        sequence: _p?.sequence,
-        options: _p?.options,
-        for_identity: _p?.for_identity,
-        missing_ok: _p?.missing_ok
-      }
-    };
+    const _j = ({
+      AlterSeqStmt: {}
+    } as AlterSeqStmt);
+    _o.set(_j, "AlterSeqStmt.sequence", _p?.sequence);
+    _o.set(_j, "AlterSeqStmt.options", _p?.options);
+    _o.set(_j, "AlterSeqStmt.for_identity", _p?.for_identity);
+    _o.set(_j, "AlterSeqStmt.missing_ok", _p?.missing_ok);
+    return _j;
   },
   variableSetStmt(_p?: VariableSetStmt["VariableSetStmt"]): VariableSetStmt {
-    return {
-      VariableSetStmt: {
-        kind: _p?.kind,
-        name: _p?.name,
-        args: _p?.args,
-        is_local: _p?.is_local
-      }
-    };
+    const _j = ({
+      VariableSetStmt: {}
+    } as VariableSetStmt);
+    _o.set(_j, "VariableSetStmt.kind", _p?.kind);
+    _o.set(_j, "VariableSetStmt.name", _p?.name);
+    _o.set(_j, "VariableSetStmt.args", _p?.args);
+    _o.set(_j, "VariableSetStmt.is_local", _p?.is_local);
+    return _j;
   },
   variableShowStmt(_p?: VariableShowStmt["VariableShowStmt"]): VariableShowStmt {
-    return {
-      VariableShowStmt: {
-        name: _p?.name
-      }
-    };
+    const _j = ({
+      VariableShowStmt: {}
+    } as VariableShowStmt);
+    _o.set(_j, "VariableShowStmt.name", _p?.name);
+    return _j;
   },
   discardStmt(_p?: DiscardStmt["DiscardStmt"]): DiscardStmt {
-    return {
-      DiscardStmt: {
-        target: _p?.target
-      }
-    };
+    const _j = ({
+      DiscardStmt: {}
+    } as DiscardStmt);
+    _o.set(_j, "DiscardStmt.target", _p?.target);
+    return _j;
   },
   createTrigStmt(_p?: CreateTrigStmt["CreateTrigStmt"]): CreateTrigStmt {
-    return {
-      CreateTrigStmt: {
-        trigname: _p?.trigname,
-        relation: _p?.relation,
-        funcname: _p?.funcname,
-        args: _p?.args,
-        row: _p?.row,
-        timing: _p?.timing,
-        events: _p?.events,
-        columns: _p?.columns,
-        whenClause: _p?.whenClause,
-        isconstraint: _p?.isconstraint,
-        transitionRels: _p?.transitionRels,
-        deferrable: _p?.deferrable,
-        initdeferred: _p?.initdeferred,
-        constrrel: _p?.constrrel
-      }
-    };
+    const _j = ({
+      CreateTrigStmt: {}
+    } as CreateTrigStmt);
+    _o.set(_j, "CreateTrigStmt.trigname", _p?.trigname);
+    _o.set(_j, "CreateTrigStmt.relation", _p?.relation);
+    _o.set(_j, "CreateTrigStmt.funcname", _p?.funcname);
+    _o.set(_j, "CreateTrigStmt.args", _p?.args);
+    _o.set(_j, "CreateTrigStmt.row", _p?.row);
+    _o.set(_j, "CreateTrigStmt.timing", _p?.timing);
+    _o.set(_j, "CreateTrigStmt.events", _p?.events);
+    _o.set(_j, "CreateTrigStmt.columns", _p?.columns);
+    _o.set(_j, "CreateTrigStmt.whenClause", _p?.whenClause);
+    _o.set(_j, "CreateTrigStmt.isconstraint", _p?.isconstraint);
+    _o.set(_j, "CreateTrigStmt.transitionRels", _p?.transitionRels);
+    _o.set(_j, "CreateTrigStmt.deferrable", _p?.deferrable);
+    _o.set(_j, "CreateTrigStmt.initdeferred", _p?.initdeferred);
+    _o.set(_j, "CreateTrigStmt.constrrel", _p?.constrrel);
+    return _j;
   },
   createpLangStmt(_p?: CreatePLangStmt["CreatePLangStmt"]): CreatePLangStmt {
-    return {
-      CreatePLangStmt: {
-        replace: _p?.replace,
-        plname: _p?.plname,
-        plhandler: _p?.plhandler,
-        plinline: _p?.plinline,
-        plvalidator: _p?.plvalidator,
-        pltrusted: _p?.pltrusted
-      }
-    };
+    const _j = ({
+      CreatePLangStmt: {}
+    } as CreatePLangStmt);
+    _o.set(_j, "CreatePLangStmt.replace", _p?.replace);
+    _o.set(_j, "CreatePLangStmt.plname", _p?.plname);
+    _o.set(_j, "CreatePLangStmt.plhandler", _p?.plhandler);
+    _o.set(_j, "CreatePLangStmt.plinline", _p?.plinline);
+    _o.set(_j, "CreatePLangStmt.plvalidator", _p?.plvalidator);
+    _o.set(_j, "CreatePLangStmt.pltrusted", _p?.pltrusted);
+    return _j;
   },
   createRoleStmt(_p?: CreateRoleStmt["CreateRoleStmt"]): CreateRoleStmt {
-    return {
-      CreateRoleStmt: {
-        stmt_type: _p?.stmt_type,
-        role: _p?.role,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      CreateRoleStmt: {}
+    } as CreateRoleStmt);
+    _o.set(_j, "CreateRoleStmt.stmt_type", _p?.stmt_type);
+    _o.set(_j, "CreateRoleStmt.role", _p?.role);
+    _o.set(_j, "CreateRoleStmt.options", _p?.options);
+    return _j;
   },
   alterRoleStmt(_p?: AlterRoleStmt["AlterRoleStmt"]): AlterRoleStmt {
-    return {
-      AlterRoleStmt: {
-        role: _p?.role,
-        options: _p?.options,
-        action: _p?.action
-      }
-    };
+    const _j = ({
+      AlterRoleStmt: {}
+    } as AlterRoleStmt);
+    _o.set(_j, "AlterRoleStmt.role", _p?.role);
+    _o.set(_j, "AlterRoleStmt.options", _p?.options);
+    _o.set(_j, "AlterRoleStmt.action", _p?.action);
+    return _j;
   },
   dropRoleStmt(_p?: DropRoleStmt["DropRoleStmt"]): DropRoleStmt {
-    return {
-      DropRoleStmt: {
-        roles: _p?.roles,
-        missing_ok: _p?.missing_ok
-      }
-    };
+    const _j = ({
+      DropRoleStmt: {}
+    } as DropRoleStmt);
+    _o.set(_j, "DropRoleStmt.roles", _p?.roles);
+    _o.set(_j, "DropRoleStmt.missing_ok", _p?.missing_ok);
+    return _j;
   },
   lockStmt(_p?: LockStmt["LockStmt"]): LockStmt {
-    return {
-      LockStmt: {
-        relations: _p?.relations,
-        mode: _p?.mode,
-        nowait: _p?.nowait
-      }
-    };
+    const _j = ({
+      LockStmt: {}
+    } as LockStmt);
+    _o.set(_j, "LockStmt.relations", _p?.relations);
+    _o.set(_j, "LockStmt.mode", _p?.mode);
+    _o.set(_j, "LockStmt.nowait", _p?.nowait);
+    return _j;
   },
   constraintsSetStmt(_p?: ConstraintsSetStmt["ConstraintsSetStmt"]): ConstraintsSetStmt {
-    return {
-      ConstraintsSetStmt: {
-        constraints: _p?.constraints,
-        deferred: _p?.deferred
-      }
-    };
+    const _j = ({
+      ConstraintsSetStmt: {}
+    } as ConstraintsSetStmt);
+    _o.set(_j, "ConstraintsSetStmt.constraints", _p?.constraints);
+    _o.set(_j, "ConstraintsSetStmt.deferred", _p?.deferred);
+    return _j;
   },
   reindexStmt(_p?: ReindexStmt["ReindexStmt"]): ReindexStmt {
-    return {
-      ReindexStmt: {
-        kind: _p?.kind,
-        relation: _p?.relation,
-        name: _p?.name,
-        options: _p?.options,
-        concurrent: _p?.concurrent
-      }
-    };
+    const _j = ({
+      ReindexStmt: {}
+    } as ReindexStmt);
+    _o.set(_j, "ReindexStmt.kind", _p?.kind);
+    _o.set(_j, "ReindexStmt.relation", _p?.relation);
+    _o.set(_j, "ReindexStmt.name", _p?.name);
+    _o.set(_j, "ReindexStmt.options", _p?.options);
+    _o.set(_j, "ReindexStmt.concurrent", _p?.concurrent);
+    return _j;
   },
   checkPointStmt(_p?: CheckPointStmt["CheckPointStmt"]): CheckPointStmt {
-    return {
+    const _j = ({
       CheckPointStmt: {}
-    };
+    } as CheckPointStmt);
+    return _j;
   },
   createSchemaStmt(_p?: CreateSchemaStmt["CreateSchemaStmt"]): CreateSchemaStmt {
-    return {
-      CreateSchemaStmt: {
-        schemaname: _p?.schemaname,
-        authrole: _p?.authrole,
-        schemaElts: _p?.schemaElts,
-        if_not_exists: _p?.if_not_exists
-      }
-    };
+    const _j = ({
+      CreateSchemaStmt: {}
+    } as CreateSchemaStmt);
+    _o.set(_j, "CreateSchemaStmt.schemaname", _p?.schemaname);
+    _o.set(_j, "CreateSchemaStmt.authrole", _p?.authrole);
+    _o.set(_j, "CreateSchemaStmt.schemaElts", _p?.schemaElts);
+    _o.set(_j, "CreateSchemaStmt.if_not_exists", _p?.if_not_exists);
+    return _j;
   },
   alterDatabaseStmt(_p?: AlterDatabaseStmt["AlterDatabaseStmt"]): AlterDatabaseStmt {
-    return {
-      AlterDatabaseStmt: {
-        dbname: _p?.dbname,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      AlterDatabaseStmt: {}
+    } as AlterDatabaseStmt);
+    _o.set(_j, "AlterDatabaseStmt.dbname", _p?.dbname);
+    _o.set(_j, "AlterDatabaseStmt.options", _p?.options);
+    return _j;
   },
   alterDatabaseSetStmt(_p?: AlterDatabaseSetStmt["AlterDatabaseSetStmt"]): AlterDatabaseSetStmt {
-    return {
-      AlterDatabaseSetStmt: {
-        dbname: _p?.dbname,
-        setstmt: _p?.setstmt
-      }
-    };
+    const _j = ({
+      AlterDatabaseSetStmt: {}
+    } as AlterDatabaseSetStmt);
+    _o.set(_j, "AlterDatabaseSetStmt.dbname", _p?.dbname);
+    _o.set(_j, "AlterDatabaseSetStmt.setstmt", _p?.setstmt);
+    return _j;
   },
   alterRoleSetStmt(_p?: AlterRoleSetStmt["AlterRoleSetStmt"]): AlterRoleSetStmt {
-    return {
-      AlterRoleSetStmt: {
-        role: _p?.role,
-        database: _p?.database,
-        setstmt: _p?.setstmt
-      }
-    };
+    const _j = ({
+      AlterRoleSetStmt: {}
+    } as AlterRoleSetStmt);
+    _o.set(_j, "AlterRoleSetStmt.role", _p?.role);
+    _o.set(_j, "AlterRoleSetStmt.database", _p?.database);
+    _o.set(_j, "AlterRoleSetStmt.setstmt", _p?.setstmt);
+    return _j;
   },
   createConversionStmt(_p?: CreateConversionStmt["CreateConversionStmt"]): CreateConversionStmt {
-    return {
-      CreateConversionStmt: {
-        conversion_name: _p?.conversion_name,
-        for_encoding_name: _p?.for_encoding_name,
-        to_encoding_name: _p?.to_encoding_name,
-        func_name: _p?.func_name,
-        def: _p?.def
-      }
-    };
+    const _j = ({
+      CreateConversionStmt: {}
+    } as CreateConversionStmt);
+    _o.set(_j, "CreateConversionStmt.conversion_name", _p?.conversion_name);
+    _o.set(_j, "CreateConversionStmt.for_encoding_name", _p?.for_encoding_name);
+    _o.set(_j, "CreateConversionStmt.to_encoding_name", _p?.to_encoding_name);
+    _o.set(_j, "CreateConversionStmt.func_name", _p?.func_name);
+    _o.set(_j, "CreateConversionStmt.def", _p?.def);
+    return _j;
   },
   createCastStmt(_p?: CreateCastStmt["CreateCastStmt"]): CreateCastStmt {
-    return {
-      CreateCastStmt: {
-        sourcetype: _p?.sourcetype,
-        targettype: _p?.targettype,
-        func: _p?.func,
-        context: _p?.context,
-        inout: _p?.inout
-      }
-    };
+    const _j = ({
+      CreateCastStmt: {}
+    } as CreateCastStmt);
+    _o.set(_j, "CreateCastStmt.sourcetype", _p?.sourcetype);
+    _o.set(_j, "CreateCastStmt.targettype", _p?.targettype);
+    _o.set(_j, "CreateCastStmt.func", _p?.func);
+    _o.set(_j, "CreateCastStmt.context", _p?.context);
+    _o.set(_j, "CreateCastStmt.inout", _p?.inout);
+    return _j;
   },
   createOpClassStmt(_p?: CreateOpClassStmt["CreateOpClassStmt"]): CreateOpClassStmt {
-    return {
-      CreateOpClassStmt: {
-        opclassname: _p?.opclassname,
-        opfamilyname: _p?.opfamilyname,
-        amname: _p?.amname,
-        datatype: _p?.datatype,
-        items: _p?.items,
-        isDefault: _p?.isDefault
-      }
-    };
+    const _j = ({
+      CreateOpClassStmt: {}
+    } as CreateOpClassStmt);
+    _o.set(_j, "CreateOpClassStmt.opclassname", _p?.opclassname);
+    _o.set(_j, "CreateOpClassStmt.opfamilyname", _p?.opfamilyname);
+    _o.set(_j, "CreateOpClassStmt.amname", _p?.amname);
+    _o.set(_j, "CreateOpClassStmt.datatype", _p?.datatype);
+    _o.set(_j, "CreateOpClassStmt.items", _p?.items);
+    _o.set(_j, "CreateOpClassStmt.isDefault", _p?.isDefault);
+    return _j;
   },
   createOpFamilyStmt(_p?: CreateOpFamilyStmt["CreateOpFamilyStmt"]): CreateOpFamilyStmt {
-    return {
-      CreateOpFamilyStmt: {
-        opfamilyname: _p?.opfamilyname,
-        amname: _p?.amname
-      }
-    };
+    const _j = ({
+      CreateOpFamilyStmt: {}
+    } as CreateOpFamilyStmt);
+    _o.set(_j, "CreateOpFamilyStmt.opfamilyname", _p?.opfamilyname);
+    _o.set(_j, "CreateOpFamilyStmt.amname", _p?.amname);
+    return _j;
   },
   alterOpFamilyStmt(_p?: AlterOpFamilyStmt["AlterOpFamilyStmt"]): AlterOpFamilyStmt {
-    return {
-      AlterOpFamilyStmt: {
-        opfamilyname: _p?.opfamilyname,
-        amname: _p?.amname,
-        isDrop: _p?.isDrop,
-        items: _p?.items
-      }
-    };
+    const _j = ({
+      AlterOpFamilyStmt: {}
+    } as AlterOpFamilyStmt);
+    _o.set(_j, "AlterOpFamilyStmt.opfamilyname", _p?.opfamilyname);
+    _o.set(_j, "AlterOpFamilyStmt.amname", _p?.amname);
+    _o.set(_j, "AlterOpFamilyStmt.isDrop", _p?.isDrop);
+    _o.set(_j, "AlterOpFamilyStmt.items", _p?.items);
+    return _j;
   },
   prepareStmt(_p?: PrepareStmt["PrepareStmt"]): PrepareStmt {
-    return {
-      PrepareStmt: {
-        name: _p?.name,
-        argtypes: _p?.argtypes,
-        query: _p?.query
-      }
-    };
+    const _j = ({
+      PrepareStmt: {}
+    } as PrepareStmt);
+    _o.set(_j, "PrepareStmt.name", _p?.name);
+    _o.set(_j, "PrepareStmt.argtypes", _p?.argtypes);
+    _o.set(_j, "PrepareStmt.query", _p?.query);
+    return _j;
   },
   executeStmt(_p?: ExecuteStmt["ExecuteStmt"]): ExecuteStmt {
-    return {
-      ExecuteStmt: {
-        name: _p?.name,
-        params: _p?.params
-      }
-    };
+    const _j = ({
+      ExecuteStmt: {}
+    } as ExecuteStmt);
+    _o.set(_j, "ExecuteStmt.name", _p?.name);
+    _o.set(_j, "ExecuteStmt.params", _p?.params);
+    return _j;
   },
   deallocateStmt(_p?: DeallocateStmt["DeallocateStmt"]): DeallocateStmt {
-    return {
-      DeallocateStmt: {
-        name: _p?.name
-      }
-    };
+    const _j = ({
+      DeallocateStmt: {}
+    } as DeallocateStmt);
+    _o.set(_j, "DeallocateStmt.name", _p?.name);
+    return _j;
   },
   declareCursorStmt(_p?: DeclareCursorStmt["DeclareCursorStmt"]): DeclareCursorStmt {
-    return {
-      DeclareCursorStmt: {
-        portalname: _p?.portalname,
-        options: _p?.options,
-        query: _p?.query
-      }
-    };
+    const _j = ({
+      DeclareCursorStmt: {}
+    } as DeclareCursorStmt);
+    _o.set(_j, "DeclareCursorStmt.portalname", _p?.portalname);
+    _o.set(_j, "DeclareCursorStmt.options", _p?.options);
+    _o.set(_j, "DeclareCursorStmt.query", _p?.query);
+    return _j;
   },
   createTableSpaceStmt(_p?: CreateTableSpaceStmt["CreateTableSpaceStmt"]): CreateTableSpaceStmt {
-    return {
-      CreateTableSpaceStmt: {
-        tablespacename: _p?.tablespacename,
-        owner: _p?.owner,
-        location: _p?.location,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      CreateTableSpaceStmt: {}
+    } as CreateTableSpaceStmt);
+    _o.set(_j, "CreateTableSpaceStmt.tablespacename", _p?.tablespacename);
+    _o.set(_j, "CreateTableSpaceStmt.owner", _p?.owner);
+    _o.set(_j, "CreateTableSpaceStmt.location", _p?.location);
+    _o.set(_j, "CreateTableSpaceStmt.options", _p?.options);
+    return _j;
   },
   dropTableSpaceStmt(_p?: DropTableSpaceStmt["DropTableSpaceStmt"]): DropTableSpaceStmt {
-    return {
-      DropTableSpaceStmt: {
-        tablespacename: _p?.tablespacename,
-        missing_ok: _p?.missing_ok
-      }
-    };
+    const _j = ({
+      DropTableSpaceStmt: {}
+    } as DropTableSpaceStmt);
+    _o.set(_j, "DropTableSpaceStmt.tablespacename", _p?.tablespacename);
+    _o.set(_j, "DropTableSpaceStmt.missing_ok", _p?.missing_ok);
+    return _j;
   },
   alterObjectDependsStmt(_p?: AlterObjectDependsStmt["AlterObjectDependsStmt"]): AlterObjectDependsStmt {
-    return {
-      AlterObjectDependsStmt: {
-        objectType: _p?.objectType,
-        relation: _p?.relation,
-        object: _p?.object,
-        extname: _p?.extname,
-        remove: _p?.remove
-      }
-    };
+    const _j = ({
+      AlterObjectDependsStmt: {}
+    } as AlterObjectDependsStmt);
+    _o.set(_j, "AlterObjectDependsStmt.objectType", _p?.objectType);
+    _o.set(_j, "AlterObjectDependsStmt.relation", _p?.relation);
+    _o.set(_j, "AlterObjectDependsStmt.object", _p?.object);
+    _o.set(_j, "AlterObjectDependsStmt.extname", _p?.extname);
+    _o.set(_j, "AlterObjectDependsStmt.remove", _p?.remove);
+    return _j;
   },
   alterObjectSchemaStmt(_p?: AlterObjectSchemaStmt["AlterObjectSchemaStmt"]): AlterObjectSchemaStmt {
-    return {
-      AlterObjectSchemaStmt: {
-        objectType: _p?.objectType,
-        relation: _p?.relation,
-        object: _p?.object,
-        newschema: _p?.newschema,
-        missing_ok: _p?.missing_ok
-      }
-    };
+    const _j = ({
+      AlterObjectSchemaStmt: {}
+    } as AlterObjectSchemaStmt);
+    _o.set(_j, "AlterObjectSchemaStmt.objectType", _p?.objectType);
+    _o.set(_j, "AlterObjectSchemaStmt.relation", _p?.relation);
+    _o.set(_j, "AlterObjectSchemaStmt.object", _p?.object);
+    _o.set(_j, "AlterObjectSchemaStmt.newschema", _p?.newschema);
+    _o.set(_j, "AlterObjectSchemaStmt.missing_ok", _p?.missing_ok);
+    return _j;
   },
   alterOwnerStmt(_p?: AlterOwnerStmt["AlterOwnerStmt"]): AlterOwnerStmt {
-    return {
-      AlterOwnerStmt: {
-        objectType: _p?.objectType,
-        relation: _p?.relation,
-        object: _p?.object,
-        newowner: _p?.newowner
-      }
-    };
+    const _j = ({
+      AlterOwnerStmt: {}
+    } as AlterOwnerStmt);
+    _o.set(_j, "AlterOwnerStmt.objectType", _p?.objectType);
+    _o.set(_j, "AlterOwnerStmt.relation", _p?.relation);
+    _o.set(_j, "AlterOwnerStmt.object", _p?.object);
+    _o.set(_j, "AlterOwnerStmt.newowner", _p?.newowner);
+    return _j;
   },
   alterOperatorStmt(_p?: AlterOperatorStmt["AlterOperatorStmt"]): AlterOperatorStmt {
-    return {
-      AlterOperatorStmt: {
-        opername: _p?.opername,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      AlterOperatorStmt: {}
+    } as AlterOperatorStmt);
+    _o.set(_j, "AlterOperatorStmt.opername", _p?.opername);
+    _o.set(_j, "AlterOperatorStmt.options", _p?.options);
+    return _j;
   },
   alterTypeStmt(_p?: AlterTypeStmt["AlterTypeStmt"]): AlterTypeStmt {
-    return {
-      AlterTypeStmt: {
-        typeName: _p?.typeName,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      AlterTypeStmt: {}
+    } as AlterTypeStmt);
+    _o.set(_j, "AlterTypeStmt.typeName", _p?.typeName);
+    _o.set(_j, "AlterTypeStmt.options", _p?.options);
+    return _j;
   },
   dropOwnedStmt(_p?: DropOwnedStmt["DropOwnedStmt"]): DropOwnedStmt {
-    return {
-      DropOwnedStmt: {
-        roles: _p?.roles,
-        behavior: _p?.behavior
-      }
-    };
+    const _j = ({
+      DropOwnedStmt: {}
+    } as DropOwnedStmt);
+    _o.set(_j, "DropOwnedStmt.roles", _p?.roles);
+    _o.set(_j, "DropOwnedStmt.behavior", _p?.behavior);
+    return _j;
   },
   reassignOwnedStmt(_p?: ReassignOwnedStmt["ReassignOwnedStmt"]): ReassignOwnedStmt {
-    return {
-      ReassignOwnedStmt: {
-        roles: _p?.roles,
-        newrole: _p?.newrole
-      }
-    };
+    const _j = ({
+      ReassignOwnedStmt: {}
+    } as ReassignOwnedStmt);
+    _o.set(_j, "ReassignOwnedStmt.roles", _p?.roles);
+    _o.set(_j, "ReassignOwnedStmt.newrole", _p?.newrole);
+    return _j;
   },
   compositeTypeStmt(_p?: CompositeTypeStmt["CompositeTypeStmt"]): CompositeTypeStmt {
-    return {
-      CompositeTypeStmt: {
-        typevar: _p?.typevar,
-        coldeflist: _p?.coldeflist
-      }
-    };
+    const _j = ({
+      CompositeTypeStmt: {}
+    } as CompositeTypeStmt);
+    _o.set(_j, "CompositeTypeStmt.typevar", _p?.typevar);
+    _o.set(_j, "CompositeTypeStmt.coldeflist", _p?.coldeflist);
+    return _j;
   },
   createEnumStmt(_p?: CreateEnumStmt["CreateEnumStmt"]): CreateEnumStmt {
-    return {
-      CreateEnumStmt: {
-        typeName: _p?.typeName,
-        vals: _p?.vals
-      }
-    };
+    const _j = ({
+      CreateEnumStmt: {}
+    } as CreateEnumStmt);
+    _o.set(_j, "CreateEnumStmt.typeName", _p?.typeName);
+    _o.set(_j, "CreateEnumStmt.vals", _p?.vals);
+    return _j;
   },
   createRangeStmt(_p?: CreateRangeStmt["CreateRangeStmt"]): CreateRangeStmt {
-    return {
-      CreateRangeStmt: {
-        typeName: _p?.typeName,
-        params: _p?.params
-      }
-    };
+    const _j = ({
+      CreateRangeStmt: {}
+    } as CreateRangeStmt);
+    _o.set(_j, "CreateRangeStmt.typeName", _p?.typeName);
+    _o.set(_j, "CreateRangeStmt.params", _p?.params);
+    return _j;
   },
   alterEnumStmt(_p?: AlterEnumStmt["AlterEnumStmt"]): AlterEnumStmt {
-    return {
-      AlterEnumStmt: {
-        typeName: _p?.typeName,
-        oldVal: _p?.oldVal,
-        newVal: _p?.newVal,
-        newValNeighbor: _p?.newValNeighbor,
-        newValIsAfter: _p?.newValIsAfter,
-        skipIfNewValExists: _p?.skipIfNewValExists
-      }
-    };
+    const _j = ({
+      AlterEnumStmt: {}
+    } as AlterEnumStmt);
+    _o.set(_j, "AlterEnumStmt.typeName", _p?.typeName);
+    _o.set(_j, "AlterEnumStmt.oldVal", _p?.oldVal);
+    _o.set(_j, "AlterEnumStmt.newVal", _p?.newVal);
+    _o.set(_j, "AlterEnumStmt.newValNeighbor", _p?.newValNeighbor);
+    _o.set(_j, "AlterEnumStmt.newValIsAfter", _p?.newValIsAfter);
+    _o.set(_j, "AlterEnumStmt.skipIfNewValExists", _p?.skipIfNewValExists);
+    return _j;
   },
   altertsDictionaryStmt(_p?: AlterTSDictionaryStmt["AlterTSDictionaryStmt"]): AlterTSDictionaryStmt {
-    return {
-      AlterTSDictionaryStmt: {
-        dictname: _p?.dictname,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      AlterTSDictionaryStmt: {}
+    } as AlterTSDictionaryStmt);
+    _o.set(_j, "AlterTSDictionaryStmt.dictname", _p?.dictname);
+    _o.set(_j, "AlterTSDictionaryStmt.options", _p?.options);
+    return _j;
   },
   altertsConfigurationStmt(_p?: AlterTSConfigurationStmt["AlterTSConfigurationStmt"]): AlterTSConfigurationStmt {
-    return {
-      AlterTSConfigurationStmt: {
-        kind: _p?.kind,
-        cfgname: _p?.cfgname,
-        tokentype: _p?.tokentype,
-        dicts: _p?.dicts,
-        override: _p?.override,
-        replace: _p?.replace,
-        missing_ok: _p?.missing_ok
-      }
-    };
+    const _j = ({
+      AlterTSConfigurationStmt: {}
+    } as AlterTSConfigurationStmt);
+    _o.set(_j, "AlterTSConfigurationStmt.kind", _p?.kind);
+    _o.set(_j, "AlterTSConfigurationStmt.cfgname", _p?.cfgname);
+    _o.set(_j, "AlterTSConfigurationStmt.tokentype", _p?.tokentype);
+    _o.set(_j, "AlterTSConfigurationStmt.dicts", _p?.dicts);
+    _o.set(_j, "AlterTSConfigurationStmt.override", _p?.override);
+    _o.set(_j, "AlterTSConfigurationStmt.replace", _p?.replace);
+    _o.set(_j, "AlterTSConfigurationStmt.missing_ok", _p?.missing_ok);
+    return _j;
   },
   createFdwStmt(_p?: CreateFdwStmt["CreateFdwStmt"]): CreateFdwStmt {
-    return {
-      CreateFdwStmt: {
-        fdwname: _p?.fdwname,
-        func_options: _p?.func_options,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      CreateFdwStmt: {}
+    } as CreateFdwStmt);
+    _o.set(_j, "CreateFdwStmt.fdwname", _p?.fdwname);
+    _o.set(_j, "CreateFdwStmt.func_options", _p?.func_options);
+    _o.set(_j, "CreateFdwStmt.options", _p?.options);
+    return _j;
   },
   alterFdwStmt(_p?: AlterFdwStmt["AlterFdwStmt"]): AlterFdwStmt {
-    return {
-      AlterFdwStmt: {
-        fdwname: _p?.fdwname,
-        func_options: _p?.func_options,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      AlterFdwStmt: {}
+    } as AlterFdwStmt);
+    _o.set(_j, "AlterFdwStmt.fdwname", _p?.fdwname);
+    _o.set(_j, "AlterFdwStmt.func_options", _p?.func_options);
+    _o.set(_j, "AlterFdwStmt.options", _p?.options);
+    return _j;
   },
   createForeignServerStmt(_p?: CreateForeignServerStmt["CreateForeignServerStmt"]): CreateForeignServerStmt {
-    return {
-      CreateForeignServerStmt: {
-        servername: _p?.servername,
-        servertype: _p?.servertype,
-        version: _p?.version,
-        fdwname: _p?.fdwname,
-        if_not_exists: _p?.if_not_exists,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      CreateForeignServerStmt: {}
+    } as CreateForeignServerStmt);
+    _o.set(_j, "CreateForeignServerStmt.servername", _p?.servername);
+    _o.set(_j, "CreateForeignServerStmt.servertype", _p?.servertype);
+    _o.set(_j, "CreateForeignServerStmt.version", _p?.version);
+    _o.set(_j, "CreateForeignServerStmt.fdwname", _p?.fdwname);
+    _o.set(_j, "CreateForeignServerStmt.if_not_exists", _p?.if_not_exists);
+    _o.set(_j, "CreateForeignServerStmt.options", _p?.options);
+    return _j;
   },
   alterForeignServerStmt(_p?: AlterForeignServerStmt["AlterForeignServerStmt"]): AlterForeignServerStmt {
-    return {
-      AlterForeignServerStmt: {
-        servername: _p?.servername,
-        version: _p?.version,
-        options: _p?.options,
-        has_version: _p?.has_version
-      }
-    };
+    const _j = ({
+      AlterForeignServerStmt: {}
+    } as AlterForeignServerStmt);
+    _o.set(_j, "AlterForeignServerStmt.servername", _p?.servername);
+    _o.set(_j, "AlterForeignServerStmt.version", _p?.version);
+    _o.set(_j, "AlterForeignServerStmt.options", _p?.options);
+    _o.set(_j, "AlterForeignServerStmt.has_version", _p?.has_version);
+    return _j;
   },
   createUserMappingStmt(_p?: CreateUserMappingStmt["CreateUserMappingStmt"]): CreateUserMappingStmt {
-    return {
-      CreateUserMappingStmt: {
-        user: _p?.user,
-        servername: _p?.servername,
-        if_not_exists: _p?.if_not_exists,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      CreateUserMappingStmt: {}
+    } as CreateUserMappingStmt);
+    _o.set(_j, "CreateUserMappingStmt.user", _p?.user);
+    _o.set(_j, "CreateUserMappingStmt.servername", _p?.servername);
+    _o.set(_j, "CreateUserMappingStmt.if_not_exists", _p?.if_not_exists);
+    _o.set(_j, "CreateUserMappingStmt.options", _p?.options);
+    return _j;
   },
   alterUserMappingStmt(_p?: AlterUserMappingStmt["AlterUserMappingStmt"]): AlterUserMappingStmt {
-    return {
-      AlterUserMappingStmt: {
-        user: _p?.user,
-        servername: _p?.servername,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      AlterUserMappingStmt: {}
+    } as AlterUserMappingStmt);
+    _o.set(_j, "AlterUserMappingStmt.user", _p?.user);
+    _o.set(_j, "AlterUserMappingStmt.servername", _p?.servername);
+    _o.set(_j, "AlterUserMappingStmt.options", _p?.options);
+    return _j;
   },
   dropUserMappingStmt(_p?: DropUserMappingStmt["DropUserMappingStmt"]): DropUserMappingStmt {
-    return {
-      DropUserMappingStmt: {
-        user: _p?.user,
-        servername: _p?.servername,
-        missing_ok: _p?.missing_ok
-      }
-    };
+    const _j = ({
+      DropUserMappingStmt: {}
+    } as DropUserMappingStmt);
+    _o.set(_j, "DropUserMappingStmt.user", _p?.user);
+    _o.set(_j, "DropUserMappingStmt.servername", _p?.servername);
+    _o.set(_j, "DropUserMappingStmt.missing_ok", _p?.missing_ok);
+    return _j;
   },
   alterTableSpaceOptionsStmt(_p?: AlterTableSpaceOptionsStmt["AlterTableSpaceOptionsStmt"]): AlterTableSpaceOptionsStmt {
-    return {
-      AlterTableSpaceOptionsStmt: {
-        tablespacename: _p?.tablespacename,
-        options: _p?.options,
-        isReset: _p?.isReset
-      }
-    };
+    const _j = ({
+      AlterTableSpaceOptionsStmt: {}
+    } as AlterTableSpaceOptionsStmt);
+    _o.set(_j, "AlterTableSpaceOptionsStmt.tablespacename", _p?.tablespacename);
+    _o.set(_j, "AlterTableSpaceOptionsStmt.options", _p?.options);
+    _o.set(_j, "AlterTableSpaceOptionsStmt.isReset", _p?.isReset);
+    return _j;
   },
   alterTableMoveAllStmt(_p?: AlterTableMoveAllStmt["AlterTableMoveAllStmt"]): AlterTableMoveAllStmt {
-    return {
-      AlterTableMoveAllStmt: {
-        orig_tablespacename: _p?.orig_tablespacename,
-        objtype: _p?.objtype,
-        roles: _p?.roles,
-        new_tablespacename: _p?.new_tablespacename,
-        nowait: _p?.nowait
-      }
-    };
+    const _j = ({
+      AlterTableMoveAllStmt: {}
+    } as AlterTableMoveAllStmt);
+    _o.set(_j, "AlterTableMoveAllStmt.orig_tablespacename", _p?.orig_tablespacename);
+    _o.set(_j, "AlterTableMoveAllStmt.objtype", _p?.objtype);
+    _o.set(_j, "AlterTableMoveAllStmt.roles", _p?.roles);
+    _o.set(_j, "AlterTableMoveAllStmt.new_tablespacename", _p?.new_tablespacename);
+    _o.set(_j, "AlterTableMoveAllStmt.nowait", _p?.nowait);
+    return _j;
   },
   secLabelStmt(_p?: SecLabelStmt["SecLabelStmt"]): SecLabelStmt {
-    return {
-      SecLabelStmt: {
-        objtype: _p?.objtype,
-        object: _p?.object,
-        provider: _p?.provider,
-        label: _p?.label
-      }
-    };
+    const _j = ({
+      SecLabelStmt: {}
+    } as SecLabelStmt);
+    _o.set(_j, "SecLabelStmt.objtype", _p?.objtype);
+    _o.set(_j, "SecLabelStmt.object", _p?.object);
+    _o.set(_j, "SecLabelStmt.provider", _p?.provider);
+    _o.set(_j, "SecLabelStmt.label", _p?.label);
+    return _j;
   },
   createForeignTableStmt(_p?: CreateForeignTableStmt["CreateForeignTableStmt"]): CreateForeignTableStmt {
-    return {
-      CreateForeignTableStmt: {
-        base: _p?.base,
-        servername: _p?.servername,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      CreateForeignTableStmt: {}
+    } as CreateForeignTableStmt);
+    _o.set(_j, "CreateForeignTableStmt.base", _p?.base);
+    _o.set(_j, "CreateForeignTableStmt.servername", _p?.servername);
+    _o.set(_j, "CreateForeignTableStmt.options", _p?.options);
+    return _j;
   },
   importForeignSchemaStmt(_p?: ImportForeignSchemaStmt["ImportForeignSchemaStmt"]): ImportForeignSchemaStmt {
-    return {
-      ImportForeignSchemaStmt: {
-        server_name: _p?.server_name,
-        remote_schema: _p?.remote_schema,
-        local_schema: _p?.local_schema,
-        list_type: _p?.list_type,
-        table_list: _p?.table_list,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      ImportForeignSchemaStmt: {}
+    } as ImportForeignSchemaStmt);
+    _o.set(_j, "ImportForeignSchemaStmt.server_name", _p?.server_name);
+    _o.set(_j, "ImportForeignSchemaStmt.remote_schema", _p?.remote_schema);
+    _o.set(_j, "ImportForeignSchemaStmt.local_schema", _p?.local_schema);
+    _o.set(_j, "ImportForeignSchemaStmt.list_type", _p?.list_type);
+    _o.set(_j, "ImportForeignSchemaStmt.table_list", _p?.table_list);
+    _o.set(_j, "ImportForeignSchemaStmt.options", _p?.options);
+    return _j;
   },
   createExtensionStmt(_p?: CreateExtensionStmt["CreateExtensionStmt"]): CreateExtensionStmt {
-    return {
-      CreateExtensionStmt: {
-        extname: _p?.extname,
-        if_not_exists: _p?.if_not_exists,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      CreateExtensionStmt: {}
+    } as CreateExtensionStmt);
+    _o.set(_j, "CreateExtensionStmt.extname", _p?.extname);
+    _o.set(_j, "CreateExtensionStmt.if_not_exists", _p?.if_not_exists);
+    _o.set(_j, "CreateExtensionStmt.options", _p?.options);
+    return _j;
   },
   alterExtensionStmt(_p?: AlterExtensionStmt["AlterExtensionStmt"]): AlterExtensionStmt {
-    return {
-      AlterExtensionStmt: {
-        extname: _p?.extname,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      AlterExtensionStmt: {}
+    } as AlterExtensionStmt);
+    _o.set(_j, "AlterExtensionStmt.extname", _p?.extname);
+    _o.set(_j, "AlterExtensionStmt.options", _p?.options);
+    return _j;
   },
   alterExtensionContentsStmt(_p?: AlterExtensionContentsStmt["AlterExtensionContentsStmt"]): AlterExtensionContentsStmt {
-    return {
-      AlterExtensionContentsStmt: {
-        extname: _p?.extname,
-        action: _p?.action,
-        objtype: _p?.objtype,
-        object: _p?.object
-      }
-    };
+    const _j = ({
+      AlterExtensionContentsStmt: {}
+    } as AlterExtensionContentsStmt);
+    _o.set(_j, "AlterExtensionContentsStmt.extname", _p?.extname);
+    _o.set(_j, "AlterExtensionContentsStmt.action", _p?.action);
+    _o.set(_j, "AlterExtensionContentsStmt.objtype", _p?.objtype);
+    _o.set(_j, "AlterExtensionContentsStmt.object", _p?.object);
+    return _j;
   },
   createEventTrigStmt(_p?: CreateEventTrigStmt["CreateEventTrigStmt"]): CreateEventTrigStmt {
-    return {
-      CreateEventTrigStmt: {
-        trigname: _p?.trigname,
-        eventname: _p?.eventname,
-        whenclause: _p?.whenclause,
-        funcname: _p?.funcname
-      }
-    };
+    const _j = ({
+      CreateEventTrigStmt: {}
+    } as CreateEventTrigStmt);
+    _o.set(_j, "CreateEventTrigStmt.trigname", _p?.trigname);
+    _o.set(_j, "CreateEventTrigStmt.eventname", _p?.eventname);
+    _o.set(_j, "CreateEventTrigStmt.whenclause", _p?.whenclause);
+    _o.set(_j, "CreateEventTrigStmt.funcname", _p?.funcname);
+    return _j;
   },
   alterEventTrigStmt(_p?: AlterEventTrigStmt["AlterEventTrigStmt"]): AlterEventTrigStmt {
-    return {
-      AlterEventTrigStmt: {
-        trigname: _p?.trigname,
-        tgenabled: _p?.tgenabled
-      }
-    };
+    const _j = ({
+      AlterEventTrigStmt: {}
+    } as AlterEventTrigStmt);
+    _o.set(_j, "AlterEventTrigStmt.trigname", _p?.trigname);
+    _o.set(_j, "AlterEventTrigStmt.tgenabled", _p?.tgenabled);
+    return _j;
   },
   refreshMatViewStmt(_p?: RefreshMatViewStmt["RefreshMatViewStmt"]): RefreshMatViewStmt {
-    return {
-      RefreshMatViewStmt: {
-        concurrent: _p?.concurrent,
-        skipData: _p?.skipData,
-        relation: _p?.relation
-      }
-    };
+    const _j = ({
+      RefreshMatViewStmt: {}
+    } as RefreshMatViewStmt);
+    _o.set(_j, "RefreshMatViewStmt.concurrent", _p?.concurrent);
+    _o.set(_j, "RefreshMatViewStmt.skipData", _p?.skipData);
+    _o.set(_j, "RefreshMatViewStmt.relation", _p?.relation);
+    return _j;
   },
   replicaIdentityStmt(_p?: ReplicaIdentityStmt["ReplicaIdentityStmt"]): ReplicaIdentityStmt {
-    return {
-      ReplicaIdentityStmt: {
-        identity_type: _p?.identity_type,
-        name: _p?.name
-      }
-    };
+    const _j = ({
+      ReplicaIdentityStmt: {}
+    } as ReplicaIdentityStmt);
+    _o.set(_j, "ReplicaIdentityStmt.identity_type", _p?.identity_type);
+    _o.set(_j, "ReplicaIdentityStmt.name", _p?.name);
+    return _j;
   },
   alterSystemStmt(_p?: AlterSystemStmt["AlterSystemStmt"]): AlterSystemStmt {
-    return {
-      AlterSystemStmt: {
-        setstmt: _p?.setstmt
-      }
-    };
+    const _j = ({
+      AlterSystemStmt: {}
+    } as AlterSystemStmt);
+    _o.set(_j, "AlterSystemStmt.setstmt", _p?.setstmt);
+    return _j;
   },
   createPolicyStmt(_p?: CreatePolicyStmt["CreatePolicyStmt"]): CreatePolicyStmt {
-    return {
-      CreatePolicyStmt: {
-        policy_name: _p?.policy_name,
-        table: _p?.table,
-        cmd_name: _p?.cmd_name,
-        permissive: _p?.permissive,
-        roles: _p?.roles,
-        qual: _p?.qual,
-        with_check: _p?.with_check
-      }
-    };
+    const _j = ({
+      CreatePolicyStmt: {}
+    } as CreatePolicyStmt);
+    _o.set(_j, "CreatePolicyStmt.policy_name", _p?.policy_name);
+    _o.set(_j, "CreatePolicyStmt.table", _p?.table);
+    _o.set(_j, "CreatePolicyStmt.cmd_name", _p?.cmd_name);
+    _o.set(_j, "CreatePolicyStmt.permissive", _p?.permissive);
+    _o.set(_j, "CreatePolicyStmt.roles", _p?.roles);
+    _o.set(_j, "CreatePolicyStmt.qual", _p?.qual);
+    _o.set(_j, "CreatePolicyStmt.with_check", _p?.with_check);
+    return _j;
   },
   alterPolicyStmt(_p?: AlterPolicyStmt["AlterPolicyStmt"]): AlterPolicyStmt {
-    return {
-      AlterPolicyStmt: {
-        policy_name: _p?.policy_name,
-        table: _p?.table,
-        roles: _p?.roles,
-        qual: _p?.qual,
-        with_check: _p?.with_check
-      }
-    };
+    const _j = ({
+      AlterPolicyStmt: {}
+    } as AlterPolicyStmt);
+    _o.set(_j, "AlterPolicyStmt.policy_name", _p?.policy_name);
+    _o.set(_j, "AlterPolicyStmt.table", _p?.table);
+    _o.set(_j, "AlterPolicyStmt.roles", _p?.roles);
+    _o.set(_j, "AlterPolicyStmt.qual", _p?.qual);
+    _o.set(_j, "AlterPolicyStmt.with_check", _p?.with_check);
+    return _j;
   },
   createTransformStmt(_p?: CreateTransformStmt["CreateTransformStmt"]): CreateTransformStmt {
-    return {
-      CreateTransformStmt: {
-        replace: _p?.replace,
-        type_name: _p?.type_name,
-        lang: _p?.lang,
-        fromsql: _p?.fromsql,
-        tosql: _p?.tosql
-      }
-    };
+    const _j = ({
+      CreateTransformStmt: {}
+    } as CreateTransformStmt);
+    _o.set(_j, "CreateTransformStmt.replace", _p?.replace);
+    _o.set(_j, "CreateTransformStmt.type_name", _p?.type_name);
+    _o.set(_j, "CreateTransformStmt.lang", _p?.lang);
+    _o.set(_j, "CreateTransformStmt.fromsql", _p?.fromsql);
+    _o.set(_j, "CreateTransformStmt.tosql", _p?.tosql);
+    return _j;
   },
   createAmStmt(_p?: CreateAmStmt["CreateAmStmt"]): CreateAmStmt {
-    return {
-      CreateAmStmt: {
-        amname: _p?.amname,
-        handler_name: _p?.handler_name,
-        amtype: _p?.amtype
-      }
-    };
+    const _j = ({
+      CreateAmStmt: {}
+    } as CreateAmStmt);
+    _o.set(_j, "CreateAmStmt.amname", _p?.amname);
+    _o.set(_j, "CreateAmStmt.handler_name", _p?.handler_name);
+    _o.set(_j, "CreateAmStmt.amtype", _p?.amtype);
+    return _j;
   },
   createPublicationStmt(_p?: CreatePublicationStmt["CreatePublicationStmt"]): CreatePublicationStmt {
-    return {
-      CreatePublicationStmt: {
-        pubname: _p?.pubname,
-        options: _p?.options,
-        tables: _p?.tables,
-        for_all_tables: _p?.for_all_tables
-      }
-    };
+    const _j = ({
+      CreatePublicationStmt: {}
+    } as CreatePublicationStmt);
+    _o.set(_j, "CreatePublicationStmt.pubname", _p?.pubname);
+    _o.set(_j, "CreatePublicationStmt.options", _p?.options);
+    _o.set(_j, "CreatePublicationStmt.tables", _p?.tables);
+    _o.set(_j, "CreatePublicationStmt.for_all_tables", _p?.for_all_tables);
+    return _j;
   },
   alterPublicationStmt(_p?: AlterPublicationStmt["AlterPublicationStmt"]): AlterPublicationStmt {
-    return {
-      AlterPublicationStmt: {
-        pubname: _p?.pubname,
-        options: _p?.options,
-        tables: _p?.tables,
-        for_all_tables: _p?.for_all_tables,
-        tableAction: _p?.tableAction
-      }
-    };
+    const _j = ({
+      AlterPublicationStmt: {}
+    } as AlterPublicationStmt);
+    _o.set(_j, "AlterPublicationStmt.pubname", _p?.pubname);
+    _o.set(_j, "AlterPublicationStmt.options", _p?.options);
+    _o.set(_j, "AlterPublicationStmt.tables", _p?.tables);
+    _o.set(_j, "AlterPublicationStmt.for_all_tables", _p?.for_all_tables);
+    _o.set(_j, "AlterPublicationStmt.tableAction", _p?.tableAction);
+    return _j;
   },
   createSubscriptionStmt(_p?: CreateSubscriptionStmt["CreateSubscriptionStmt"]): CreateSubscriptionStmt {
-    return {
-      CreateSubscriptionStmt: {
-        subname: _p?.subname,
-        conninfo: _p?.conninfo,
-        publication: _p?.publication,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      CreateSubscriptionStmt: {}
+    } as CreateSubscriptionStmt);
+    _o.set(_j, "CreateSubscriptionStmt.subname", _p?.subname);
+    _o.set(_j, "CreateSubscriptionStmt.conninfo", _p?.conninfo);
+    _o.set(_j, "CreateSubscriptionStmt.publication", _p?.publication);
+    _o.set(_j, "CreateSubscriptionStmt.options", _p?.options);
+    return _j;
   },
   alterSubscriptionStmt(_p?: AlterSubscriptionStmt["AlterSubscriptionStmt"]): AlterSubscriptionStmt {
-    return {
-      AlterSubscriptionStmt: {
-        kind: _p?.kind,
-        subname: _p?.subname,
-        conninfo: _p?.conninfo,
-        publication: _p?.publication,
-        options: _p?.options
-      }
-    };
+    const _j = ({
+      AlterSubscriptionStmt: {}
+    } as AlterSubscriptionStmt);
+    _o.set(_j, "AlterSubscriptionStmt.kind", _p?.kind);
+    _o.set(_j, "AlterSubscriptionStmt.subname", _p?.subname);
+    _o.set(_j, "AlterSubscriptionStmt.conninfo", _p?.conninfo);
+    _o.set(_j, "AlterSubscriptionStmt.publication", _p?.publication);
+    _o.set(_j, "AlterSubscriptionStmt.options", _p?.options);
+    return _j;
   },
   dropSubscriptionStmt(_p?: DropSubscriptionStmt["DropSubscriptionStmt"]): DropSubscriptionStmt {
-    return {
-      DropSubscriptionStmt: {
-        subname: _p?.subname,
-        missing_ok: _p?.missing_ok,
-        behavior: _p?.behavior
-      }
-    };
+    const _j = ({
+      DropSubscriptionStmt: {}
+    } as DropSubscriptionStmt);
+    _o.set(_j, "DropSubscriptionStmt.subname", _p?.subname);
+    _o.set(_j, "DropSubscriptionStmt.missing_ok", _p?.missing_ok);
+    _o.set(_j, "DropSubscriptionStmt.behavior", _p?.behavior);
+    return _j;
   },
   createStatsStmt(_p?: CreateStatsStmt["CreateStatsStmt"]): CreateStatsStmt {
-    return {
-      CreateStatsStmt: {
-        defnames: _p?.defnames,
-        stat_types: _p?.stat_types,
-        exprs: _p?.exprs,
-        relations: _p?.relations,
-        stxcomment: _p?.stxcomment,
-        if_not_exists: _p?.if_not_exists
-      }
-    };
+    const _j = ({
+      CreateStatsStmt: {}
+    } as CreateStatsStmt);
+    _o.set(_j, "CreateStatsStmt.defnames", _p?.defnames);
+    _o.set(_j, "CreateStatsStmt.stat_types", _p?.stat_types);
+    _o.set(_j, "CreateStatsStmt.exprs", _p?.exprs);
+    _o.set(_j, "CreateStatsStmt.relations", _p?.relations);
+    _o.set(_j, "CreateStatsStmt.stxcomment", _p?.stxcomment);
+    _o.set(_j, "CreateStatsStmt.if_not_exists", _p?.if_not_exists);
+    return _j;
   },
   alterCollationStmt(_p?: AlterCollationStmt["AlterCollationStmt"]): AlterCollationStmt {
-    return {
-      AlterCollationStmt: {
-        collname: _p?.collname
-      }
-    };
+    const _j = ({
+      AlterCollationStmt: {}
+    } as AlterCollationStmt);
+    _o.set(_j, "AlterCollationStmt.collname", _p?.collname);
+    return _j;
   },
   callStmt(_p?: CallStmt["CallStmt"]): CallStmt {
-    return {
-      CallStmt: {
-        funccall: _p?.funccall,
-        funcexpr: _p?.funcexpr
-      }
-    };
+    const _j = ({
+      CallStmt: {}
+    } as CallStmt);
+    _o.set(_j, "CallStmt.funccall", _p?.funccall);
+    _o.set(_j, "CallStmt.funcexpr", _p?.funcexpr);
+    return _j;
   },
   alterStatsStmt(_p?: AlterStatsStmt["AlterStatsStmt"]): AlterStatsStmt {
-    return {
-      AlterStatsStmt: {
-        defnames: _p?.defnames,
-        stxstattarget: _p?.stxstattarget,
-        missing_ok: _p?.missing_ok
-      }
-    };
+    const _j = ({
+      AlterStatsStmt: {}
+    } as AlterStatsStmt);
+    _o.set(_j, "AlterStatsStmt.defnames", _p?.defnames);
+    _o.set(_j, "AlterStatsStmt.stxstattarget", _p?.stxstattarget);
+    _o.set(_j, "AlterStatsStmt.missing_ok", _p?.missing_ok);
+    return _j;
   },
   aExpr(_p?: A_Expr["A_Expr"]): A_Expr {
-    return {
-      A_Expr: {
-        kind: _p?.kind,
-        name: _p?.name,
-        lexpr: _p?.lexpr,
-        rexpr: _p?.rexpr,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      A_Expr: {}
+    } as A_Expr);
+    _o.set(_j, "A_Expr.kind", _p?.kind);
+    _o.set(_j, "A_Expr.name", _p?.name);
+    _o.set(_j, "A_Expr.lexpr", _p?.lexpr);
+    _o.set(_j, "A_Expr.rexpr", _p?.rexpr);
+    _o.set(_j, "A_Expr.location", _p?.location);
+    return _j;
   },
   columnRef(_p?: ColumnRef["ColumnRef"]): ColumnRef {
-    return {
-      ColumnRef: {
-        fields: _p?.fields,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      ColumnRef: {}
+    } as ColumnRef);
+    _o.set(_j, "ColumnRef.fields", _p?.fields);
+    _o.set(_j, "ColumnRef.location", _p?.location);
+    return _j;
   },
   paramRef(_p?: ParamRef["ParamRef"]): ParamRef {
-    return {
-      ParamRef: {
-        number: _p?.number,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      ParamRef: {}
+    } as ParamRef);
+    _o.set(_j, "ParamRef.number", _p?.number);
+    _o.set(_j, "ParamRef.location", _p?.location);
+    return _j;
   },
   aConst(_p?: A_Const["A_Const"]): A_Const {
-    return {
-      A_Const: {
-        val: _p?.val,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      A_Const: {}
+    } as A_Const);
+    _o.set(_j, "A_Const.val", _p?.val);
+    _o.set(_j, "A_Const.location", _p?.location);
+    return _j;
   },
   funcCall(_p?: FuncCall["FuncCall"]): FuncCall {
-    return {
-      FuncCall: {
-        funcname: _p?.funcname,
-        args: _p?.args,
-        agg_order: _p?.agg_order,
-        agg_filter: _p?.agg_filter,
-        agg_within_group: _p?.agg_within_group,
-        agg_star: _p?.agg_star,
-        agg_distinct: _p?.agg_distinct,
-        func_variadic: _p?.func_variadic,
-        over: _p?.over,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      FuncCall: {}
+    } as FuncCall);
+    _o.set(_j, "FuncCall.funcname", _p?.funcname);
+    _o.set(_j, "FuncCall.args", _p?.args);
+    _o.set(_j, "FuncCall.agg_order", _p?.agg_order);
+    _o.set(_j, "FuncCall.agg_filter", _p?.agg_filter);
+    _o.set(_j, "FuncCall.agg_within_group", _p?.agg_within_group);
+    _o.set(_j, "FuncCall.agg_star", _p?.agg_star);
+    _o.set(_j, "FuncCall.agg_distinct", _p?.agg_distinct);
+    _o.set(_j, "FuncCall.func_variadic", _p?.func_variadic);
+    _o.set(_j, "FuncCall.over", _p?.over);
+    _o.set(_j, "FuncCall.location", _p?.location);
+    return _j;
   },
   aStar(_p?: A_Star["A_Star"]): A_Star {
-    return {
+    const _j = ({
       A_Star: {}
-    };
+    } as A_Star);
+    return _j;
   },
   aIndices(_p?: A_Indices["A_Indices"]): A_Indices {
-    return {
-      A_Indices: {
-        is_slice: _p?.is_slice,
-        lidx: _p?.lidx,
-        uidx: _p?.uidx
-      }
-    };
+    const _j = ({
+      A_Indices: {}
+    } as A_Indices);
+    _o.set(_j, "A_Indices.is_slice", _p?.is_slice);
+    _o.set(_j, "A_Indices.lidx", _p?.lidx);
+    _o.set(_j, "A_Indices.uidx", _p?.uidx);
+    return _j;
   },
   aIndirection(_p?: A_Indirection["A_Indirection"]): A_Indirection {
-    return {
-      A_Indirection: {
-        arg: _p?.arg,
-        indirection: _p?.indirection
-      }
-    };
+    const _j = ({
+      A_Indirection: {}
+    } as A_Indirection);
+    _o.set(_j, "A_Indirection.arg", _p?.arg);
+    _o.set(_j, "A_Indirection.indirection", _p?.indirection);
+    return _j;
   },
   aArrayExpr(_p?: A_ArrayExpr["A_ArrayExpr"]): A_ArrayExpr {
-    return {
-      A_ArrayExpr: {
-        elements: _p?.elements,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      A_ArrayExpr: {}
+    } as A_ArrayExpr);
+    _o.set(_j, "A_ArrayExpr.elements", _p?.elements);
+    _o.set(_j, "A_ArrayExpr.location", _p?.location);
+    return _j;
   },
   resTarget(_p?: ResTarget["ResTarget"]): ResTarget {
-    return {
-      ResTarget: {
-        name: _p?.name,
-        indirection: _p?.indirection,
-        val: _p?.val,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      ResTarget: {}
+    } as ResTarget);
+    _o.set(_j, "ResTarget.name", _p?.name);
+    _o.set(_j, "ResTarget.indirection", _p?.indirection);
+    _o.set(_j, "ResTarget.val", _p?.val);
+    _o.set(_j, "ResTarget.location", _p?.location);
+    return _j;
   },
   multiAssignRef(_p?: MultiAssignRef["MultiAssignRef"]): MultiAssignRef {
-    return {
-      MultiAssignRef: {
-        source: _p?.source,
-        colno: _p?.colno,
-        ncolumns: _p?.ncolumns
-      }
-    };
+    const _j = ({
+      MultiAssignRef: {}
+    } as MultiAssignRef);
+    _o.set(_j, "MultiAssignRef.source", _p?.source);
+    _o.set(_j, "MultiAssignRef.colno", _p?.colno);
+    _o.set(_j, "MultiAssignRef.ncolumns", _p?.ncolumns);
+    return _j;
   },
   typeCast(_p?: TypeCast["TypeCast"]): TypeCast {
-    return {
-      TypeCast: {
-        arg: _p?.arg,
-        typeName: _p?.typeName,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      TypeCast: {}
+    } as TypeCast);
+    _o.set(_j, "TypeCast.arg", _p?.arg);
+    _o.set(_j, "TypeCast.typeName", _p?.typeName);
+    _o.set(_j, "TypeCast.location", _p?.location);
+    return _j;
   },
   collateClause(_p?: CollateClause["CollateClause"]): CollateClause {
-    return {
-      CollateClause: {
-        arg: _p?.arg,
-        collname: _p?.collname,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      CollateClause: {}
+    } as CollateClause);
+    _o.set(_j, "CollateClause.arg", _p?.arg);
+    _o.set(_j, "CollateClause.collname", _p?.collname);
+    _o.set(_j, "CollateClause.location", _p?.location);
+    return _j;
   },
   sortBy(_p?: SortBy["SortBy"]): SortBy {
-    return {
-      SortBy: {
-        node: _p?.node,
-        sortby_dir: _p?.sortby_dir,
-        sortby_nulls: _p?.sortby_nulls,
-        useOp: _p?.useOp,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      SortBy: {}
+    } as SortBy);
+    _o.set(_j, "SortBy.node", _p?.node);
+    _o.set(_j, "SortBy.sortby_dir", _p?.sortby_dir);
+    _o.set(_j, "SortBy.sortby_nulls", _p?.sortby_nulls);
+    _o.set(_j, "SortBy.useOp", _p?.useOp);
+    _o.set(_j, "SortBy.location", _p?.location);
+    return _j;
   },
   windowDef(_p?: WindowDef["WindowDef"]): WindowDef {
-    return {
-      WindowDef: {
-        name: _p?.name,
-        refname: _p?.refname,
-        partitionClause: _p?.partitionClause,
-        orderClause: _p?.orderClause,
-        frameOptions: _p?.frameOptions,
-        startOffset: _p?.startOffset,
-        endOffset: _p?.endOffset,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      WindowDef: {}
+    } as WindowDef);
+    _o.set(_j, "WindowDef.name", _p?.name);
+    _o.set(_j, "WindowDef.refname", _p?.refname);
+    _o.set(_j, "WindowDef.partitionClause", _p?.partitionClause);
+    _o.set(_j, "WindowDef.orderClause", _p?.orderClause);
+    _o.set(_j, "WindowDef.frameOptions", _p?.frameOptions);
+    _o.set(_j, "WindowDef.startOffset", _p?.startOffset);
+    _o.set(_j, "WindowDef.endOffset", _p?.endOffset);
+    _o.set(_j, "WindowDef.location", _p?.location);
+    return _j;
   },
   rangeSubselect(_p?: RangeSubselect["RangeSubselect"]): RangeSubselect {
-    return {
-      RangeSubselect: {
-        lateral: _p?.lateral,
-        subquery: _p?.subquery,
-        alias: _p?.alias
-      }
-    };
+    const _j = ({
+      RangeSubselect: {}
+    } as RangeSubselect);
+    _o.set(_j, "RangeSubselect.lateral", _p?.lateral);
+    _o.set(_j, "RangeSubselect.subquery", _p?.subquery);
+    _o.set(_j, "RangeSubselect.alias", _p?.alias);
+    return _j;
   },
   rangeFunction(_p?: RangeFunction["RangeFunction"]): RangeFunction {
-    return {
-      RangeFunction: {
-        lateral: _p?.lateral,
-        ordinality: _p?.ordinality,
-        is_rowsfrom: _p?.is_rowsfrom,
-        functions: _p?.functions,
-        alias: _p?.alias,
-        coldeflist: _p?.coldeflist
-      }
-    };
+    const _j = ({
+      RangeFunction: {}
+    } as RangeFunction);
+    _o.set(_j, "RangeFunction.lateral", _p?.lateral);
+    _o.set(_j, "RangeFunction.ordinality", _p?.ordinality);
+    _o.set(_j, "RangeFunction.is_rowsfrom", _p?.is_rowsfrom);
+    _o.set(_j, "RangeFunction.functions", _p?.functions);
+    _o.set(_j, "RangeFunction.alias", _p?.alias);
+    _o.set(_j, "RangeFunction.coldeflist", _p?.coldeflist);
+    return _j;
   },
   rangeTableSample(_p?: RangeTableSample["RangeTableSample"]): RangeTableSample {
-    return {
-      RangeTableSample: {
-        relation: _p?.relation,
-        method: _p?.method,
-        args: _p?.args,
-        repeatable: _p?.repeatable,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      RangeTableSample: {}
+    } as RangeTableSample);
+    _o.set(_j, "RangeTableSample.relation", _p?.relation);
+    _o.set(_j, "RangeTableSample.method", _p?.method);
+    _o.set(_j, "RangeTableSample.args", _p?.args);
+    _o.set(_j, "RangeTableSample.repeatable", _p?.repeatable);
+    _o.set(_j, "RangeTableSample.location", _p?.location);
+    return _j;
   },
   rangeTableFunc(_p?: RangeTableFunc["RangeTableFunc"]): RangeTableFunc {
-    return {
-      RangeTableFunc: {
-        lateral: _p?.lateral,
-        docexpr: _p?.docexpr,
-        rowexpr: _p?.rowexpr,
-        namespaces: _p?.namespaces,
-        columns: _p?.columns,
-        alias: _p?.alias,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      RangeTableFunc: {}
+    } as RangeTableFunc);
+    _o.set(_j, "RangeTableFunc.lateral", _p?.lateral);
+    _o.set(_j, "RangeTableFunc.docexpr", _p?.docexpr);
+    _o.set(_j, "RangeTableFunc.rowexpr", _p?.rowexpr);
+    _o.set(_j, "RangeTableFunc.namespaces", _p?.namespaces);
+    _o.set(_j, "RangeTableFunc.columns", _p?.columns);
+    _o.set(_j, "RangeTableFunc.alias", _p?.alias);
+    _o.set(_j, "RangeTableFunc.location", _p?.location);
+    return _j;
   },
   rangeTableFuncCol(_p?: RangeTableFuncCol["RangeTableFuncCol"]): RangeTableFuncCol {
-    return {
-      RangeTableFuncCol: {
-        colname: _p?.colname,
-        typeName: _p?.typeName,
-        for_ordinality: _p?.for_ordinality,
-        is_not_null: _p?.is_not_null,
-        colexpr: _p?.colexpr,
-        coldefexpr: _p?.coldefexpr,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      RangeTableFuncCol: {}
+    } as RangeTableFuncCol);
+    _o.set(_j, "RangeTableFuncCol.colname", _p?.colname);
+    _o.set(_j, "RangeTableFuncCol.typeName", _p?.typeName);
+    _o.set(_j, "RangeTableFuncCol.for_ordinality", _p?.for_ordinality);
+    _o.set(_j, "RangeTableFuncCol.is_not_null", _p?.is_not_null);
+    _o.set(_j, "RangeTableFuncCol.colexpr", _p?.colexpr);
+    _o.set(_j, "RangeTableFuncCol.coldefexpr", _p?.coldefexpr);
+    _o.set(_j, "RangeTableFuncCol.location", _p?.location);
+    return _j;
   },
   typeName(_p?: TypeName): TypeName {
-    return {
-      names: _p?.names,
-      typeOid: _p?.typeOid,
-      setof: _p?.setof,
-      pct_type: _p?.pct_type,
-      typmods: _p?.typmods,
-      typemod: _p?.typemod,
-      arrayBounds: _p?.arrayBounds,
-      location: _p?.location
-    };
+    const _j = ({} as TypeName);
+    _o.set(_j, "names", _p?.names);
+    _o.set(_j, "typeOid", _p?.typeOid);
+    _o.set(_j, "setof", _p?.setof);
+    _o.set(_j, "pct_type", _p?.pct_type);
+    _o.set(_j, "typmods", _p?.typmods);
+    _o.set(_j, "typemod", _p?.typemod);
+    _o.set(_j, "arrayBounds", _p?.arrayBounds);
+    _o.set(_j, "location", _p?.location);
+    return _j;
   },
   columnDef(_p?: ColumnDef["ColumnDef"]): ColumnDef {
-    return {
-      ColumnDef: {
-        colname: _p?.colname,
-        typeName: _p?.typeName,
-        inhcount: _p?.inhcount,
-        is_local: _p?.is_local,
-        is_not_null: _p?.is_not_null,
-        is_from_type: _p?.is_from_type,
-        storage: _p?.storage,
-        raw_default: _p?.raw_default,
-        cooked_default: _p?.cooked_default,
-        identity: _p?.identity,
-        identitySequence: _p?.identitySequence,
-        generated: _p?.generated,
-        collClause: _p?.collClause,
-        collOid: _p?.collOid,
-        constraints: _p?.constraints,
-        fdwoptions: _p?.fdwoptions,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      ColumnDef: {}
+    } as ColumnDef);
+    _o.set(_j, "ColumnDef.colname", _p?.colname);
+    _o.set(_j, "ColumnDef.typeName", _p?.typeName);
+    _o.set(_j, "ColumnDef.inhcount", _p?.inhcount);
+    _o.set(_j, "ColumnDef.is_local", _p?.is_local);
+    _o.set(_j, "ColumnDef.is_not_null", _p?.is_not_null);
+    _o.set(_j, "ColumnDef.is_from_type", _p?.is_from_type);
+    _o.set(_j, "ColumnDef.storage", _p?.storage);
+    _o.set(_j, "ColumnDef.raw_default", _p?.raw_default);
+    _o.set(_j, "ColumnDef.cooked_default", _p?.cooked_default);
+    _o.set(_j, "ColumnDef.identity", _p?.identity);
+    _o.set(_j, "ColumnDef.identitySequence", _p?.identitySequence);
+    _o.set(_j, "ColumnDef.generated", _p?.generated);
+    _o.set(_j, "ColumnDef.collClause", _p?.collClause);
+    _o.set(_j, "ColumnDef.collOid", _p?.collOid);
+    _o.set(_j, "ColumnDef.constraints", _p?.constraints);
+    _o.set(_j, "ColumnDef.fdwoptions", _p?.fdwoptions);
+    _o.set(_j, "ColumnDef.location", _p?.location);
+    return _j;
   },
   indexElem(_p?: IndexElem["IndexElem"]): IndexElem {
-    return {
-      IndexElem: {
-        name: _p?.name,
-        expr: _p?.expr,
-        indexcolname: _p?.indexcolname,
-        collation: _p?.collation,
-        opclass: _p?.opclass,
-        opclassopts: _p?.opclassopts,
-        ordering: _p?.ordering,
-        nulls_ordering: _p?.nulls_ordering
-      }
-    };
+    const _j = ({
+      IndexElem: {}
+    } as IndexElem);
+    _o.set(_j, "IndexElem.name", _p?.name);
+    _o.set(_j, "IndexElem.expr", _p?.expr);
+    _o.set(_j, "IndexElem.indexcolname", _p?.indexcolname);
+    _o.set(_j, "IndexElem.collation", _p?.collation);
+    _o.set(_j, "IndexElem.opclass", _p?.opclass);
+    _o.set(_j, "IndexElem.opclassopts", _p?.opclassopts);
+    _o.set(_j, "IndexElem.ordering", _p?.ordering);
+    _o.set(_j, "IndexElem.nulls_ordering", _p?.nulls_ordering);
+    return _j;
   },
   constraint(_p?: Constraint["Constraint"]): Constraint {
-    return {
-      Constraint: {
-        contype: _p?.contype,
-        conname: _p?.conname,
-        deferrable: _p?.deferrable,
-        initdeferred: _p?.initdeferred,
-        location: _p?.location,
-        is_no_inherit: _p?.is_no_inherit,
-        raw_expr: _p?.raw_expr,
-        cooked_expr: _p?.cooked_expr,
-        generated_when: _p?.generated_when,
-        keys: _p?.keys,
-        including: _p?.including,
-        exclusions: _p?.exclusions,
-        options: _p?.options,
-        indexname: _p?.indexname,
-        indexspace: _p?.indexspace,
-        reset_default_tblspc: _p?.reset_default_tblspc,
-        access_method: _p?.access_method,
-        where_clause: _p?.where_clause,
-        pktable: _p?.pktable,
-        fk_attrs: _p?.fk_attrs,
-        pk_attrs: _p?.pk_attrs,
-        fk_matchtype: _p?.fk_matchtype,
-        fk_upd_action: _p?.fk_upd_action,
-        fk_del_action: _p?.fk_del_action,
-        old_conpfeqop: _p?.old_conpfeqop,
-        old_pktable_oid: _p?.old_pktable_oid,
-        skip_validation: _p?.skip_validation,
-        initially_valid: _p?.initially_valid
-      }
-    };
+    const _j = ({
+      Constraint: {}
+    } as Constraint);
+    _o.set(_j, "Constraint.contype", _p?.contype);
+    _o.set(_j, "Constraint.conname", _p?.conname);
+    _o.set(_j, "Constraint.deferrable", _p?.deferrable);
+    _o.set(_j, "Constraint.initdeferred", _p?.initdeferred);
+    _o.set(_j, "Constraint.location", _p?.location);
+    _o.set(_j, "Constraint.is_no_inherit", _p?.is_no_inherit);
+    _o.set(_j, "Constraint.raw_expr", _p?.raw_expr);
+    _o.set(_j, "Constraint.cooked_expr", _p?.cooked_expr);
+    _o.set(_j, "Constraint.generated_when", _p?.generated_when);
+    _o.set(_j, "Constraint.keys", _p?.keys);
+    _o.set(_j, "Constraint.including", _p?.including);
+    _o.set(_j, "Constraint.exclusions", _p?.exclusions);
+    _o.set(_j, "Constraint.options", _p?.options);
+    _o.set(_j, "Constraint.indexname", _p?.indexname);
+    _o.set(_j, "Constraint.indexspace", _p?.indexspace);
+    _o.set(_j, "Constraint.reset_default_tblspc", _p?.reset_default_tblspc);
+    _o.set(_j, "Constraint.access_method", _p?.access_method);
+    _o.set(_j, "Constraint.where_clause", _p?.where_clause);
+    _o.set(_j, "Constraint.pktable", _p?.pktable);
+    _o.set(_j, "Constraint.fk_attrs", _p?.fk_attrs);
+    _o.set(_j, "Constraint.pk_attrs", _p?.pk_attrs);
+    _o.set(_j, "Constraint.fk_matchtype", _p?.fk_matchtype);
+    _o.set(_j, "Constraint.fk_upd_action", _p?.fk_upd_action);
+    _o.set(_j, "Constraint.fk_del_action", _p?.fk_del_action);
+    _o.set(_j, "Constraint.old_conpfeqop", _p?.old_conpfeqop);
+    _o.set(_j, "Constraint.old_pktable_oid", _p?.old_pktable_oid);
+    _o.set(_j, "Constraint.skip_validation", _p?.skip_validation);
+    _o.set(_j, "Constraint.initially_valid", _p?.initially_valid);
+    return _j;
   },
   defElem(_p?: DefElem["DefElem"]): DefElem {
-    return {
-      DefElem: {
-        defnamespace: _p?.defnamespace,
-        defname: _p?.defname,
-        arg: _p?.arg,
-        defaction: _p?.defaction,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      DefElem: {}
+    } as DefElem);
+    _o.set(_j, "DefElem.defnamespace", _p?.defnamespace);
+    _o.set(_j, "DefElem.defname", _p?.defname);
+    _o.set(_j, "DefElem.arg", _p?.arg);
+    _o.set(_j, "DefElem.defaction", _p?.defaction);
+    _o.set(_j, "DefElem.location", _p?.location);
+    return _j;
   },
   rangeTblEntry(_p?: RangeTblEntry["RangeTblEntry"]): RangeTblEntry {
-    return {
-      RangeTblEntry: {
-        rtekind: _p?.rtekind,
-        relid: _p?.relid,
-        relkind: _p?.relkind,
-        rellockmode: _p?.rellockmode,
-        tablesample: _p?.tablesample,
-        subquery: _p?.subquery,
-        security_barrier: _p?.security_barrier,
-        jointype: _p?.jointype,
-        joinmergedcols: _p?.joinmergedcols,
-        joinaliasvars: _p?.joinaliasvars,
-        joinleftcols: _p?.joinleftcols,
-        joinrightcols: _p?.joinrightcols,
-        functions: _p?.functions,
-        funcordinality: _p?.funcordinality,
-        tablefunc: _p?.tablefunc,
-        values_lists: _p?.values_lists,
-        ctename: _p?.ctename,
-        ctelevelsup: _p?.ctelevelsup,
-        self_reference: _p?.self_reference,
-        coltypes: _p?.coltypes,
-        coltypmods: _p?.coltypmods,
-        colcollations: _p?.colcollations,
-        enrname: _p?.enrname,
-        enrtuples: _p?.enrtuples,
-        alias: _p?.alias,
-        eref: _p?.eref,
-        lateral: _p?.lateral,
-        inh: _p?.inh,
-        inFromCl: _p?.inFromCl,
-        requiredPerms: _p?.requiredPerms,
-        checkAsUser: _p?.checkAsUser,
-        selectedCols: _p?.selectedCols,
-        insertedCols: _p?.insertedCols,
-        updatedCols: _p?.updatedCols,
-        extraUpdatedCols: _p?.extraUpdatedCols,
-        securityQuals: _p?.securityQuals
-      }
-    };
+    const _j = ({
+      RangeTblEntry: {}
+    } as RangeTblEntry);
+    _o.set(_j, "RangeTblEntry.rtekind", _p?.rtekind);
+    _o.set(_j, "RangeTblEntry.relid", _p?.relid);
+    _o.set(_j, "RangeTblEntry.relkind", _p?.relkind);
+    _o.set(_j, "RangeTblEntry.rellockmode", _p?.rellockmode);
+    _o.set(_j, "RangeTblEntry.tablesample", _p?.tablesample);
+    _o.set(_j, "RangeTblEntry.subquery", _p?.subquery);
+    _o.set(_j, "RangeTblEntry.security_barrier", _p?.security_barrier);
+    _o.set(_j, "RangeTblEntry.jointype", _p?.jointype);
+    _o.set(_j, "RangeTblEntry.joinmergedcols", _p?.joinmergedcols);
+    _o.set(_j, "RangeTblEntry.joinaliasvars", _p?.joinaliasvars);
+    _o.set(_j, "RangeTblEntry.joinleftcols", _p?.joinleftcols);
+    _o.set(_j, "RangeTblEntry.joinrightcols", _p?.joinrightcols);
+    _o.set(_j, "RangeTblEntry.functions", _p?.functions);
+    _o.set(_j, "RangeTblEntry.funcordinality", _p?.funcordinality);
+    _o.set(_j, "RangeTblEntry.tablefunc", _p?.tablefunc);
+    _o.set(_j, "RangeTblEntry.values_lists", _p?.values_lists);
+    _o.set(_j, "RangeTblEntry.ctename", _p?.ctename);
+    _o.set(_j, "RangeTblEntry.ctelevelsup", _p?.ctelevelsup);
+    _o.set(_j, "RangeTblEntry.self_reference", _p?.self_reference);
+    _o.set(_j, "RangeTblEntry.coltypes", _p?.coltypes);
+    _o.set(_j, "RangeTblEntry.coltypmods", _p?.coltypmods);
+    _o.set(_j, "RangeTblEntry.colcollations", _p?.colcollations);
+    _o.set(_j, "RangeTblEntry.enrname", _p?.enrname);
+    _o.set(_j, "RangeTblEntry.enrtuples", _p?.enrtuples);
+    _o.set(_j, "RangeTblEntry.alias", _p?.alias);
+    _o.set(_j, "RangeTblEntry.eref", _p?.eref);
+    _o.set(_j, "RangeTblEntry.lateral", _p?.lateral);
+    _o.set(_j, "RangeTblEntry.inh", _p?.inh);
+    _o.set(_j, "RangeTblEntry.inFromCl", _p?.inFromCl);
+    _o.set(_j, "RangeTblEntry.requiredPerms", _p?.requiredPerms);
+    _o.set(_j, "RangeTblEntry.checkAsUser", _p?.checkAsUser);
+    _o.set(_j, "RangeTblEntry.selectedCols", _p?.selectedCols);
+    _o.set(_j, "RangeTblEntry.insertedCols", _p?.insertedCols);
+    _o.set(_j, "RangeTblEntry.updatedCols", _p?.updatedCols);
+    _o.set(_j, "RangeTblEntry.extraUpdatedCols", _p?.extraUpdatedCols);
+    _o.set(_j, "RangeTblEntry.securityQuals", _p?.securityQuals);
+    return _j;
   },
   rangeTblFunction(_p?: RangeTblFunction["RangeTblFunction"]): RangeTblFunction {
-    return {
-      RangeTblFunction: {
-        funcexpr: _p?.funcexpr,
-        funccolcount: _p?.funccolcount,
-        funccolnames: _p?.funccolnames,
-        funccoltypes: _p?.funccoltypes,
-        funccoltypmods: _p?.funccoltypmods,
-        funccolcollations: _p?.funccolcollations,
-        funcparams: _p?.funcparams
-      }
-    };
+    const _j = ({
+      RangeTblFunction: {}
+    } as RangeTblFunction);
+    _o.set(_j, "RangeTblFunction.funcexpr", _p?.funcexpr);
+    _o.set(_j, "RangeTblFunction.funccolcount", _p?.funccolcount);
+    _o.set(_j, "RangeTblFunction.funccolnames", _p?.funccolnames);
+    _o.set(_j, "RangeTblFunction.funccoltypes", _p?.funccoltypes);
+    _o.set(_j, "RangeTblFunction.funccoltypmods", _p?.funccoltypmods);
+    _o.set(_j, "RangeTblFunction.funccolcollations", _p?.funccolcollations);
+    _o.set(_j, "RangeTblFunction.funcparams", _p?.funcparams);
+    return _j;
   },
   tableSampleClause(_p?: TableSampleClause["TableSampleClause"]): TableSampleClause {
-    return {
-      TableSampleClause: {
-        tsmhandler: _p?.tsmhandler,
-        args: _p?.args,
-        repeatable: _p?.repeatable
-      }
-    };
+    const _j = ({
+      TableSampleClause: {}
+    } as TableSampleClause);
+    _o.set(_j, "TableSampleClause.tsmhandler", _p?.tsmhandler);
+    _o.set(_j, "TableSampleClause.args", _p?.args);
+    _o.set(_j, "TableSampleClause.repeatable", _p?.repeatable);
+    return _j;
   },
   withCheckOption(_p?: WithCheckOption["WithCheckOption"]): WithCheckOption {
-    return {
-      WithCheckOption: {
-        kind: _p?.kind,
-        relname: _p?.relname,
-        polname: _p?.polname,
-        qual: _p?.qual,
-        cascaded: _p?.cascaded
-      }
-    };
+    const _j = ({
+      WithCheckOption: {}
+    } as WithCheckOption);
+    _o.set(_j, "WithCheckOption.kind", _p?.kind);
+    _o.set(_j, "WithCheckOption.relname", _p?.relname);
+    _o.set(_j, "WithCheckOption.polname", _p?.polname);
+    _o.set(_j, "WithCheckOption.qual", _p?.qual);
+    _o.set(_j, "WithCheckOption.cascaded", _p?.cascaded);
+    return _j;
   },
   sortGroupClause(_p?: SortGroupClause["SortGroupClause"]): SortGroupClause {
-    return {
-      SortGroupClause: {
-        tleSortGroupRef: _p?.tleSortGroupRef,
-        eqop: _p?.eqop,
-        sortop: _p?.sortop,
-        nulls_first: _p?.nulls_first,
-        hashable: _p?.hashable
-      }
-    };
+    const _j = ({
+      SortGroupClause: {}
+    } as SortGroupClause);
+    _o.set(_j, "SortGroupClause.tleSortGroupRef", _p?.tleSortGroupRef);
+    _o.set(_j, "SortGroupClause.eqop", _p?.eqop);
+    _o.set(_j, "SortGroupClause.sortop", _p?.sortop);
+    _o.set(_j, "SortGroupClause.nulls_first", _p?.nulls_first);
+    _o.set(_j, "SortGroupClause.hashable", _p?.hashable);
+    return _j;
   },
   groupingSet(_p?: GroupingSet["GroupingSet"]): GroupingSet {
-    return {
-      GroupingSet: {
-        kind: _p?.kind,
-        content: _p?.content,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      GroupingSet: {}
+    } as GroupingSet);
+    _o.set(_j, "GroupingSet.kind", _p?.kind);
+    _o.set(_j, "GroupingSet.content", _p?.content);
+    _o.set(_j, "GroupingSet.location", _p?.location);
+    return _j;
   },
   windowClause(_p?: WindowClause["WindowClause"]): WindowClause {
-    return {
-      WindowClause: {
-        name: _p?.name,
-        refname: _p?.refname,
-        partitionClause: _p?.partitionClause,
-        orderClause: _p?.orderClause,
-        frameOptions: _p?.frameOptions,
-        startOffset: _p?.startOffset,
-        endOffset: _p?.endOffset,
-        startInRangeFunc: _p?.startInRangeFunc,
-        endInRangeFunc: _p?.endInRangeFunc,
-        inRangeColl: _p?.inRangeColl,
-        inRangeAsc: _p?.inRangeAsc,
-        inRangeNullsFirst: _p?.inRangeNullsFirst,
-        winref: _p?.winref,
-        copiedOrder: _p?.copiedOrder
-      }
-    };
+    const _j = ({
+      WindowClause: {}
+    } as WindowClause);
+    _o.set(_j, "WindowClause.name", _p?.name);
+    _o.set(_j, "WindowClause.refname", _p?.refname);
+    _o.set(_j, "WindowClause.partitionClause", _p?.partitionClause);
+    _o.set(_j, "WindowClause.orderClause", _p?.orderClause);
+    _o.set(_j, "WindowClause.frameOptions", _p?.frameOptions);
+    _o.set(_j, "WindowClause.startOffset", _p?.startOffset);
+    _o.set(_j, "WindowClause.endOffset", _p?.endOffset);
+    _o.set(_j, "WindowClause.startInRangeFunc", _p?.startInRangeFunc);
+    _o.set(_j, "WindowClause.endInRangeFunc", _p?.endInRangeFunc);
+    _o.set(_j, "WindowClause.inRangeColl", _p?.inRangeColl);
+    _o.set(_j, "WindowClause.inRangeAsc", _p?.inRangeAsc);
+    _o.set(_j, "WindowClause.inRangeNullsFirst", _p?.inRangeNullsFirst);
+    _o.set(_j, "WindowClause.winref", _p?.winref);
+    _o.set(_j, "WindowClause.copiedOrder", _p?.copiedOrder);
+    return _j;
   },
   objectWithArgs(_p?: ObjectWithArgs["ObjectWithArgs"]): ObjectWithArgs {
-    return {
-      ObjectWithArgs: {
-        objname: _p?.objname,
-        objargs: _p?.objargs,
-        args_unspecified: _p?.args_unspecified
-      }
-    };
+    const _j = ({
+      ObjectWithArgs: {}
+    } as ObjectWithArgs);
+    _o.set(_j, "ObjectWithArgs.objname", _p?.objname);
+    _o.set(_j, "ObjectWithArgs.objargs", _p?.objargs);
+    _o.set(_j, "ObjectWithArgs.args_unspecified", _p?.args_unspecified);
+    return _j;
   },
   accessPriv(_p?: AccessPriv["AccessPriv"]): AccessPriv {
-    return {
-      AccessPriv: {
-        priv_name: _p?.priv_name,
-        cols: _p?.cols
-      }
-    };
+    const _j = ({
+      AccessPriv: {}
+    } as AccessPriv);
+    _o.set(_j, "AccessPriv.priv_name", _p?.priv_name);
+    _o.set(_j, "AccessPriv.cols", _p?.cols);
+    return _j;
   },
   createOpClassItem(_p?: CreateOpClassItem["CreateOpClassItem"]): CreateOpClassItem {
-    return {
-      CreateOpClassItem: {
-        itemtype: _p?.itemtype,
-        name: _p?.name,
-        number: _p?.number,
-        order_family: _p?.order_family,
-        class_args: _p?.class_args,
-        storedtype: _p?.storedtype
-      }
-    };
+    const _j = ({
+      CreateOpClassItem: {}
+    } as CreateOpClassItem);
+    _o.set(_j, "CreateOpClassItem.itemtype", _p?.itemtype);
+    _o.set(_j, "CreateOpClassItem.name", _p?.name);
+    _o.set(_j, "CreateOpClassItem.number", _p?.number);
+    _o.set(_j, "CreateOpClassItem.order_family", _p?.order_family);
+    _o.set(_j, "CreateOpClassItem.class_args", _p?.class_args);
+    _o.set(_j, "CreateOpClassItem.storedtype", _p?.storedtype);
+    return _j;
   },
   tableLikeClause(_p?: TableLikeClause["TableLikeClause"]): TableLikeClause {
-    return {
-      TableLikeClause: {
-        relation: _p?.relation,
-        options: _p?.options,
-        relationOid: _p?.relationOid
-      }
-    };
+    const _j = ({
+      TableLikeClause: {}
+    } as TableLikeClause);
+    _o.set(_j, "TableLikeClause.relation", _p?.relation);
+    _o.set(_j, "TableLikeClause.options", _p?.options);
+    _o.set(_j, "TableLikeClause.relationOid", _p?.relationOid);
+    return _j;
   },
   functionParameter(_p?: FunctionParameter["FunctionParameter"]): FunctionParameter {
-    return {
-      FunctionParameter: {
-        name: _p?.name,
-        argType: _p?.argType,
-        mode: _p?.mode,
-        defexpr: _p?.defexpr
-      }
-    };
+    const _j = ({
+      FunctionParameter: {}
+    } as FunctionParameter);
+    _o.set(_j, "FunctionParameter.name", _p?.name);
+    _o.set(_j, "FunctionParameter.argType", _p?.argType);
+    _o.set(_j, "FunctionParameter.mode", _p?.mode);
+    _o.set(_j, "FunctionParameter.defexpr", _p?.defexpr);
+    return _j;
   },
   lockingClause(_p?: LockingClause["LockingClause"]): LockingClause {
-    return {
-      LockingClause: {
-        lockedRels: _p?.lockedRels,
-        strength: _p?.strength,
-        waitPolicy: _p?.waitPolicy
-      }
-    };
+    const _j = ({
+      LockingClause: {}
+    } as LockingClause);
+    _o.set(_j, "LockingClause.lockedRels", _p?.lockedRels);
+    _o.set(_j, "LockingClause.strength", _p?.strength);
+    _o.set(_j, "LockingClause.waitPolicy", _p?.waitPolicy);
+    return _j;
   },
   rowMarkClause(_p?: RowMarkClause["RowMarkClause"]): RowMarkClause {
-    return {
-      RowMarkClause: {
-        rti: _p?.rti,
-        strength: _p?.strength,
-        waitPolicy: _p?.waitPolicy,
-        pushedDown: _p?.pushedDown
-      }
-    };
+    const _j = ({
+      RowMarkClause: {}
+    } as RowMarkClause);
+    _o.set(_j, "RowMarkClause.rti", _p?.rti);
+    _o.set(_j, "RowMarkClause.strength", _p?.strength);
+    _o.set(_j, "RowMarkClause.waitPolicy", _p?.waitPolicy);
+    _o.set(_j, "RowMarkClause.pushedDown", _p?.pushedDown);
+    return _j;
   },
   xmlSerialize(_p?: XmlSerialize["XmlSerialize"]): XmlSerialize {
-    return {
-      XmlSerialize: {
-        xmloption: _p?.xmloption,
-        expr: _p?.expr,
-        typeName: _p?.typeName,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      XmlSerialize: {}
+    } as XmlSerialize);
+    _o.set(_j, "XmlSerialize.xmloption", _p?.xmloption);
+    _o.set(_j, "XmlSerialize.expr", _p?.expr);
+    _o.set(_j, "XmlSerialize.typeName", _p?.typeName);
+    _o.set(_j, "XmlSerialize.location", _p?.location);
+    return _j;
   },
   withClause(_p?: WithClause["WithClause"]): WithClause {
-    return {
-      WithClause: {
-        ctes: _p?.ctes,
-        recursive: _p?.recursive,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      WithClause: {}
+    } as WithClause);
+    _o.set(_j, "WithClause.ctes", _p?.ctes);
+    _o.set(_j, "WithClause.recursive", _p?.recursive);
+    _o.set(_j, "WithClause.location", _p?.location);
+    return _j;
   },
   inferClause(_p?: InferClause["InferClause"]): InferClause {
-    return {
-      InferClause: {
-        indexElems: _p?.indexElems,
-        whereClause: _p?.whereClause,
-        conname: _p?.conname,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      InferClause: {}
+    } as InferClause);
+    _o.set(_j, "InferClause.indexElems", _p?.indexElems);
+    _o.set(_j, "InferClause.whereClause", _p?.whereClause);
+    _o.set(_j, "InferClause.conname", _p?.conname);
+    _o.set(_j, "InferClause.location", _p?.location);
+    return _j;
   },
   onConflictClause(_p?: OnConflictClause["OnConflictClause"]): OnConflictClause {
-    return {
-      OnConflictClause: {
-        action: _p?.action,
-        infer: _p?.infer,
-        targetList: _p?.targetList,
-        whereClause: _p?.whereClause,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      OnConflictClause: {}
+    } as OnConflictClause);
+    _o.set(_j, "OnConflictClause.action", _p?.action);
+    _o.set(_j, "OnConflictClause.infer", _p?.infer);
+    _o.set(_j, "OnConflictClause.targetList", _p?.targetList);
+    _o.set(_j, "OnConflictClause.whereClause", _p?.whereClause);
+    _o.set(_j, "OnConflictClause.location", _p?.location);
+    return _j;
   },
   commonTableExpr(_p?: CommonTableExpr["CommonTableExpr"]): CommonTableExpr {
-    return {
-      CommonTableExpr: {
-        ctename: _p?.ctename,
-        aliascolnames: _p?.aliascolnames,
-        ctematerialized: _p?.ctematerialized,
-        ctequery: _p?.ctequery,
-        location: _p?.location,
-        cterecursive: _p?.cterecursive,
-        cterefcount: _p?.cterefcount,
-        ctecolnames: _p?.ctecolnames,
-        ctecoltypes: _p?.ctecoltypes,
-        ctecoltypmods: _p?.ctecoltypmods,
-        ctecolcollations: _p?.ctecolcollations
-      }
-    };
+    const _j = ({
+      CommonTableExpr: {}
+    } as CommonTableExpr);
+    _o.set(_j, "CommonTableExpr.ctename", _p?.ctename);
+    _o.set(_j, "CommonTableExpr.aliascolnames", _p?.aliascolnames);
+    _o.set(_j, "CommonTableExpr.ctematerialized", _p?.ctematerialized);
+    _o.set(_j, "CommonTableExpr.ctequery", _p?.ctequery);
+    _o.set(_j, "CommonTableExpr.location", _p?.location);
+    _o.set(_j, "CommonTableExpr.cterecursive", _p?.cterecursive);
+    _o.set(_j, "CommonTableExpr.cterefcount", _p?.cterefcount);
+    _o.set(_j, "CommonTableExpr.ctecolnames", _p?.ctecolnames);
+    _o.set(_j, "CommonTableExpr.ctecoltypes", _p?.ctecoltypes);
+    _o.set(_j, "CommonTableExpr.ctecoltypmods", _p?.ctecoltypmods);
+    _o.set(_j, "CommonTableExpr.ctecolcollations", _p?.ctecolcollations);
+    return _j;
   },
   roleSpec(_p?: RoleSpec["RoleSpec"]): RoleSpec {
-    return {
-      RoleSpec: {
-        roletype: _p?.roletype,
-        rolename: _p?.rolename,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      RoleSpec: {}
+    } as RoleSpec);
+    _o.set(_j, "RoleSpec.roletype", _p?.roletype);
+    _o.set(_j, "RoleSpec.rolename", _p?.rolename);
+    _o.set(_j, "RoleSpec.location", _p?.location);
+    return _j;
   },
   triggerTransition(_p?: TriggerTransition["TriggerTransition"]): TriggerTransition {
-    return {
-      TriggerTransition: {
-        name: _p?.name,
-        isNew: _p?.isNew,
-        isTable: _p?.isTable
-      }
-    };
+    const _j = ({
+      TriggerTransition: {}
+    } as TriggerTransition);
+    _o.set(_j, "TriggerTransition.name", _p?.name);
+    _o.set(_j, "TriggerTransition.isNew", _p?.isNew);
+    _o.set(_j, "TriggerTransition.isTable", _p?.isTable);
+    return _j;
   },
   partitionElem(_p?: PartitionElem["PartitionElem"]): PartitionElem {
-    return {
-      PartitionElem: {
-        name: _p?.name,
-        expr: _p?.expr,
-        collation: _p?.collation,
-        opclass: _p?.opclass,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      PartitionElem: {}
+    } as PartitionElem);
+    _o.set(_j, "PartitionElem.name", _p?.name);
+    _o.set(_j, "PartitionElem.expr", _p?.expr);
+    _o.set(_j, "PartitionElem.collation", _p?.collation);
+    _o.set(_j, "PartitionElem.opclass", _p?.opclass);
+    _o.set(_j, "PartitionElem.location", _p?.location);
+    return _j;
   },
   partitionSpec(_p?: PartitionSpec["PartitionSpec"]): PartitionSpec {
-    return {
-      PartitionSpec: {
-        strategy: _p?.strategy,
-        partParams: _p?.partParams,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      PartitionSpec: {}
+    } as PartitionSpec);
+    _o.set(_j, "PartitionSpec.strategy", _p?.strategy);
+    _o.set(_j, "PartitionSpec.partParams", _p?.partParams);
+    _o.set(_j, "PartitionSpec.location", _p?.location);
+    return _j;
   },
   partitionBoundSpec(_p?: PartitionBoundSpec["PartitionBoundSpec"]): PartitionBoundSpec {
-    return {
-      PartitionBoundSpec: {
-        strategy: _p?.strategy,
-        is_default: _p?.is_default,
-        modulus: _p?.modulus,
-        remainder: _p?.remainder,
-        listdatums: _p?.listdatums,
-        lowerdatums: _p?.lowerdatums,
-        upperdatums: _p?.upperdatums,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      PartitionBoundSpec: {}
+    } as PartitionBoundSpec);
+    _o.set(_j, "PartitionBoundSpec.strategy", _p?.strategy);
+    _o.set(_j, "PartitionBoundSpec.is_default", _p?.is_default);
+    _o.set(_j, "PartitionBoundSpec.modulus", _p?.modulus);
+    _o.set(_j, "PartitionBoundSpec.remainder", _p?.remainder);
+    _o.set(_j, "PartitionBoundSpec.listdatums", _p?.listdatums);
+    _o.set(_j, "PartitionBoundSpec.lowerdatums", _p?.lowerdatums);
+    _o.set(_j, "PartitionBoundSpec.upperdatums", _p?.upperdatums);
+    _o.set(_j, "PartitionBoundSpec.location", _p?.location);
+    return _j;
   },
   partitionRangeDatum(_p?: PartitionRangeDatum["PartitionRangeDatum"]): PartitionRangeDatum {
-    return {
-      PartitionRangeDatum: {
-        kind: _p?.kind,
-        value: _p?.value,
-        location: _p?.location
-      }
-    };
+    const _j = ({
+      PartitionRangeDatum: {}
+    } as PartitionRangeDatum);
+    _o.set(_j, "PartitionRangeDatum.kind", _p?.kind);
+    _o.set(_j, "PartitionRangeDatum.value", _p?.value);
+    _o.set(_j, "PartitionRangeDatum.location", _p?.location);
+    return _j;
   },
   partitionCmd(_p?: PartitionCmd["PartitionCmd"]): PartitionCmd {
-    return {
-      PartitionCmd: {
-        name: _p?.name,
-        bound: _p?.bound
-      }
-    };
+    const _j = ({
+      PartitionCmd: {}
+    } as PartitionCmd);
+    _o.set(_j, "PartitionCmd.name", _p?.name);
+    _o.set(_j, "PartitionCmd.bound", _p?.bound);
+    return _j;
   },
   vacuumRelation(_p?: VacuumRelation["VacuumRelation"]): VacuumRelation {
-    return {
-      VacuumRelation: {
-        relation: _p?.relation,
-        oid: _p?.oid,
-        va_cols: _p?.va_cols
-      }
-    };
+    const _j = ({
+      VacuumRelation: {}
+    } as VacuumRelation);
+    _o.set(_j, "VacuumRelation.relation", _p?.relation);
+    _o.set(_j, "VacuumRelation.oid", _p?.oid);
+    _o.set(_j, "VacuumRelation.va_cols", _p?.va_cols);
+    return _j;
   },
   inlineCodeBlock(_p?: InlineCodeBlock["InlineCodeBlock"]): InlineCodeBlock {
-    return {
-      InlineCodeBlock: {
-        source_text: _p?.source_text,
-        langOid: _p?.langOid,
-        langIsTrusted: _p?.langIsTrusted,
-        atomic: _p?.atomic
-      }
-    };
+    const _j = ({
+      InlineCodeBlock: {}
+    } as InlineCodeBlock);
+    _o.set(_j, "InlineCodeBlock.source_text", _p?.source_text);
+    _o.set(_j, "InlineCodeBlock.langOid", _p?.langOid);
+    _o.set(_j, "InlineCodeBlock.langIsTrusted", _p?.langIsTrusted);
+    _o.set(_j, "InlineCodeBlock.atomic", _p?.atomic);
+    return _j;
   },
   callContext(_p?: CallContext["CallContext"]): CallContext {
-    return {
-      CallContext: {
-        atomic: _p?.atomic
-      }
-    };
+    const _j = ({
+      CallContext: {}
+    } as CallContext);
+    _o.set(_j, "CallContext.atomic", _p?.atomic);
+    return _j;
   },
   scanToken(_p?: ScanToken["ScanToken"]): ScanToken {
-    return {
-      ScanToken: {
-        start: _p?.start,
-        end: _p?.end,
-        token: _p?.token,
-        keywordKind: _p?.keywordKind
-      }
-    };
+    const _j = ({
+      ScanToken: {}
+    } as ScanToken);
+    _o.set(_j, "ScanToken.start", _p?.start);
+    _o.set(_j, "ScanToken.end", _p?.end);
+    _o.set(_j, "ScanToken.token", _p?.token);
+    _o.set(_j, "ScanToken.keywordKind", _p?.keywordKind);
+    return _j;
   }
 };