@pgsql/transform 17.6.3 → 17.7.1

package/17/enum-to-int.js

@@ -0,0 +1,2501 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnumInt = void 0;
+const getEnumInt = (enumType, key) => {
+    switch (enumType) {
+        case "QuerySource":
+            {
+                switch (key) {
+                    case "QSRC_ORIGINAL":
+                        return 0;
+                    case "QSRC_PARSER":
+                        return 1;
+                    case "QSRC_INSTEAD_RULE":
+                        return 2;
+                    case "QSRC_QUAL_INSTEAD_RULE":
+                        return 3;
+                    case "QSRC_NON_INSTEAD_RULE":
+                        return 4;
+                    default:
+                        throw new Error("Key not recognized in enum QuerySource");
+                }
+            }
+        case "SortByDir":
+            {
+                switch (key) {
+                    case "SORTBY_DEFAULT":
+                        return 0;
+                    case "SORTBY_ASC":
+                        return 1;
+                    case "SORTBY_DESC":
+                        return 2;
+                    case "SORTBY_USING":
+                        return 3;
+                    default:
+                        throw new Error("Key not recognized in enum SortByDir");
+                }
+            }
+        case "SortByNulls":
+            {
+                switch (key) {
+                    case "SORTBY_NULLS_DEFAULT":
+                        return 0;
+                    case "SORTBY_NULLS_FIRST":
+                        return 1;
+                    case "SORTBY_NULLS_LAST":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum SortByNulls");
+                }
+            }
+        case "SetQuantifier":
+            {
+                switch (key) {
+                    case "SET_QUANTIFIER_DEFAULT":
+                        return 0;
+                    case "SET_QUANTIFIER_ALL":
+                        return 1;
+                    case "SET_QUANTIFIER_DISTINCT":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum SetQuantifier");
+                }
+            }
+        case "A_Expr_Kind":
+            {
+                switch (key) {
+                    case "AEXPR_OP":
+                        return 0;
+                    case "AEXPR_OP_ANY":
+                        return 1;
+                    case "AEXPR_OP_ALL":
+                        return 2;
+                    case "AEXPR_DISTINCT":
+                        return 3;
+                    case "AEXPR_NOT_DISTINCT":
+                        return 4;
+                    case "AEXPR_NULLIF":
+                        return 5;
+                    case "AEXPR_IN":
+                        return 6;
+                    case "AEXPR_LIKE":
+                        return 7;
+                    case "AEXPR_ILIKE":
+                        return 8;
+                    case "AEXPR_SIMILAR":
+                        return 9;
+                    case "AEXPR_BETWEEN":
+                        return 10;
+                    case "AEXPR_NOT_BETWEEN":
+                        return 11;
+                    case "AEXPR_BETWEEN_SYM":
+                        return 12;
+                    case "AEXPR_NOT_BETWEEN_SYM":
+                        return 13;
+                    default:
+                        throw new Error("Key not recognized in enum A_Expr_Kind");
+                }
+            }
+        case "RoleSpecType":
+            {
+                switch (key) {
+                    case "ROLESPEC_CSTRING":
+                        return 0;
+                    case "ROLESPEC_CURRENT_ROLE":
+                        return 1;
+                    case "ROLESPEC_CURRENT_USER":
+                        return 2;
+                    case "ROLESPEC_SESSION_USER":
+                        return 3;
+                    case "ROLESPEC_PUBLIC":
+                        return 4;
+                    default:
+                        throw new Error("Key not recognized in enum RoleSpecType");
+                }
+            }
+        case "TableLikeOption":
+            {
+                switch (key) {
+                    case "CREATE_TABLE_LIKE_COMMENTS":
+                        return 0;
+                    case "CREATE_TABLE_LIKE_COMPRESSION":
+                        return 1;
+                    case "CREATE_TABLE_LIKE_CONSTRAINTS":
+                        return 2;
+                    case "CREATE_TABLE_LIKE_DEFAULTS":
+                        return 3;
+                    case "CREATE_TABLE_LIKE_GENERATED":
+                        return 4;
+                    case "CREATE_TABLE_LIKE_IDENTITY":
+                        return 5;
+                    case "CREATE_TABLE_LIKE_INDEXES":
+                        return 6;
+                    case "CREATE_TABLE_LIKE_STATISTICS":
+                        return 7;
+                    case "CREATE_TABLE_LIKE_STORAGE":
+                        return 8;
+                    case "CREATE_TABLE_LIKE_ALL":
+                        return 9;
+                    default:
+                        throw new Error("Key not recognized in enum TableLikeOption");
+                }
+            }
+        case "DefElemAction":
+            {
+                switch (key) {
+                    case "DEFELEM_UNSPEC":
+                        return 0;
+                    case "DEFELEM_SET":
+                        return 1;
+                    case "DEFELEM_ADD":
+                        return 2;
+                    case "DEFELEM_DROP":
+                        return 3;
+                    default:
+                        throw new Error("Key not recognized in enum DefElemAction");
+                }
+            }
+        case "PartitionStrategy":
+            {
+                switch (key) {
+                    case "PARTITION_STRATEGY_LIST":
+                        return 0;
+                    case "PARTITION_STRATEGY_RANGE":
+                        return 1;
+                    case "PARTITION_STRATEGY_HASH":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum PartitionStrategy");
+                }
+            }
+        case "PartitionRangeDatumKind":
+            {
+                switch (key) {
+                    case "PARTITION_RANGE_DATUM_MINVALUE":
+                        return 0;
+                    case "PARTITION_RANGE_DATUM_VALUE":
+                        return 1;
+                    case "PARTITION_RANGE_DATUM_MAXVALUE":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum PartitionRangeDatumKind");
+                }
+            }
+        case "RTEKind":
+            {
+                switch (key) {
+                    case "RTE_RELATION":
+                        return 0;
+                    case "RTE_SUBQUERY":
+                        return 1;
+                    case "RTE_JOIN":
+                        return 2;
+                    case "RTE_FUNCTION":
+                        return 3;
+                    case "RTE_TABLEFUNC":
+                        return 4;
+                    case "RTE_VALUES":
+                        return 5;
+                    case "RTE_CTE":
+                        return 6;
+                    case "RTE_NAMEDTUPLESTORE":
+                        return 7;
+                    case "RTE_RESULT":
+                        return 8;
+                    default:
+                        throw new Error("Key not recognized in enum RTEKind");
+                }
+            }
+        case "WCOKind":
+            {
+                switch (key) {
+                    case "WCO_VIEW_CHECK":
+                        return 0;
+                    case "WCO_RLS_INSERT_CHECK":
+                        return 1;
+                    case "WCO_RLS_UPDATE_CHECK":
+                        return 2;
+                    case "WCO_RLS_CONFLICT_CHECK":
+                        return 3;
+                    case "WCO_RLS_MERGE_UPDATE_CHECK":
+                        return 4;
+                    case "WCO_RLS_MERGE_DELETE_CHECK":
+                        return 5;
+                    default:
+                        throw new Error("Key not recognized in enum WCOKind");
+                }
+            }
+        case "GroupingSetKind":
+            {
+                switch (key) {
+                    case "GROUPING_SET_EMPTY":
+                        return 0;
+                    case "GROUPING_SET_SIMPLE":
+                        return 1;
+                    case "GROUPING_SET_ROLLUP":
+                        return 2;
+                    case "GROUPING_SET_CUBE":
+                        return 3;
+                    case "GROUPING_SET_SETS":
+                        return 4;
+                    default:
+                        throw new Error("Key not recognized in enum GroupingSetKind");
+                }
+            }
+        case "CTEMaterialize":
+            {
+                switch (key) {
+                    case "CTEMaterializeDefault":
+                        return 0;
+                    case "CTEMaterializeAlways":
+                        return 1;
+                    case "CTEMaterializeNever":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum CTEMaterialize");
+                }
+            }
+        case "JsonQuotes":
+            {
+                switch (key) {
+                    case "JS_QUOTES_UNSPEC":
+                        return 0;
+                    case "JS_QUOTES_KEEP":
+                        return 1;
+                    case "JS_QUOTES_OMIT":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum JsonQuotes");
+                }
+            }
+        case "JsonTableColumnType":
+            {
+                switch (key) {
+                    case "JTC_FOR_ORDINALITY":
+                        return 0;
+                    case "JTC_REGULAR":
+                        return 1;
+                    case "JTC_EXISTS":
+                        return 2;
+                    case "JTC_FORMATTED":
+                        return 3;
+                    case "JTC_NESTED":
+                        return 4;
+                    default:
+                        throw new Error("Key not recognized in enum JsonTableColumnType");
+                }
+            }
+        case "SetOperation":
+            {
+                switch (key) {
+                    case "SETOP_NONE":
+                        return 0;
+                    case "SETOP_UNION":
+                        return 1;
+                    case "SETOP_INTERSECT":
+                        return 2;
+                    case "SETOP_EXCEPT":
+                        return 3;
+                    default:
+                        throw new Error("Key not recognized in enum SetOperation");
+                }
+            }
+        case "ObjectType":
+            {
+                switch (key) {
+                    case "OBJECT_ACCESS_METHOD":
+                        return 0;
+                    case "OBJECT_AGGREGATE":
+                        return 1;
+                    case "OBJECT_AMOP":
+                        return 2;
+                    case "OBJECT_AMPROC":
+                        return 3;
+                    case "OBJECT_ATTRIBUTE":
+                        return 4;
+                    case "OBJECT_CAST":
+                        return 5;
+                    case "OBJECT_COLUMN":
+                        return 6;
+                    case "OBJECT_COLLATION":
+                        return 7;
+                    case "OBJECT_CONVERSION":
+                        return 8;
+                    case "OBJECT_DATABASE":
+                        return 9;
+                    case "OBJECT_DEFAULT":
+                        return 10;
+                    case "OBJECT_DEFACL":
+                        return 11;
+                    case "OBJECT_DOMAIN":
+                        return 12;
+                    case "OBJECT_DOMCONSTRAINT":
+                        return 13;
+                    case "OBJECT_EVENT_TRIGGER":
+                        return 14;
+                    case "OBJECT_EXTENSION":
+                        return 15;
+                    case "OBJECT_FDW":
+                        return 16;
+                    case "OBJECT_FOREIGN_SERVER":
+                        return 17;
+                    case "OBJECT_FOREIGN_TABLE":
+                        return 18;
+                    case "OBJECT_FUNCTION":
+                        return 19;
+                    case "OBJECT_INDEX":
+                        return 20;
+                    case "OBJECT_LANGUAGE":
+                        return 21;
+                    case "OBJECT_LARGEOBJECT":
+                        return 22;
+                    case "OBJECT_MATVIEW":
+                        return 23;
+                    case "OBJECT_OPCLASS":
+                        return 24;
+                    case "OBJECT_OPERATOR":
+                        return 25;
+                    case "OBJECT_OPFAMILY":
+                        return 26;
+                    case "OBJECT_PARAMETER_ACL":
+                        return 27;
+                    case "OBJECT_POLICY":
+                        return 28;
+                    case "OBJECT_PROCEDURE":
+                        return 29;
+                    case "OBJECT_PUBLICATION":
+                        return 30;
+                    case "OBJECT_PUBLICATION_NAMESPACE":
+                        return 31;
+                    case "OBJECT_PUBLICATION_REL":
+                        return 32;
+                    case "OBJECT_ROLE":
+                        return 33;
+                    case "OBJECT_ROUTINE":
+                        return 34;
+                    case "OBJECT_RULE":
+                        return 35;
+                    case "OBJECT_SCHEMA":
+                        return 36;
+                    case "OBJECT_SEQUENCE":
+                        return 37;
+                    case "OBJECT_SUBSCRIPTION":
+                        return 38;
+                    case "OBJECT_STATISTIC_EXT":
+                        return 39;
+                    case "OBJECT_TABCONSTRAINT":
+                        return 40;
+                    case "OBJECT_TABLE":
+                        return 41;
+                    case "OBJECT_TABLESPACE":
+                        return 42;
+                    case "OBJECT_TRANSFORM":
+                        return 43;
+                    case "OBJECT_TRIGGER":
+                        return 44;
+                    case "OBJECT_TSCONFIGURATION":
+                        return 45;
+                    case "OBJECT_TSDICTIONARY":
+                        return 46;
+                    case "OBJECT_TSPARSER":
+                        return 47;
+                    case "OBJECT_TSTEMPLATE":
+                        return 48;
+                    case "OBJECT_TYPE":
+                        return 49;
+                    case "OBJECT_USER_MAPPING":
+                        return 50;
+                    case "OBJECT_VIEW":
+                        return 51;
+                    default:
+                        throw new Error("Key not recognized in enum ObjectType");
+                }
+            }
+        case "DropBehavior":
+            {
+                switch (key) {
+                    case "DROP_RESTRICT":
+                        return 0;
+                    case "DROP_CASCADE":
+                        return 1;
+                    default:
+                        throw new Error("Key not recognized in enum DropBehavior");
+                }
+            }
+        case "AlterTableType":
+            {
+                switch (key) {
+                    case "AT_AddColumn":
+                        return 0;
+                    case "AT_AddColumnToView":
+                        return 1;
+                    case "AT_ColumnDefault":
+                        return 2;
+                    case "AT_CookedColumnDefault":
+                        return 3;
+                    case "AT_DropNotNull":
+                        return 4;
+                    case "AT_SetNotNull":
+                        return 5;
+                    case "AT_SetExpression":
+                        return 6;
+                    case "AT_DropExpression":
+                        return 7;
+                    case "AT_CheckNotNull":
+                        return 8;
+                    case "AT_SetStatistics":
+                        return 9;
+                    case "AT_SetOptions":
+                        return 10;
+                    case "AT_ResetOptions":
+                        return 11;
+                    case "AT_SetStorage":
+                        return 12;
+                    case "AT_SetCompression":
+                        return 13;
+                    case "AT_DropColumn":
+                        return 14;
+                    case "AT_AddIndex":
+                        return 15;
+                    case "AT_ReAddIndex":
+                        return 16;
+                    case "AT_AddConstraint":
+                        return 17;
+                    case "AT_ReAddConstraint":
+                        return 18;
+                    case "AT_ReAddDomainConstraint":
+                        return 19;
+                    case "AT_AlterConstraint":
+                        return 20;
+                    case "AT_ValidateConstraint":
+                        return 21;
+                    case "AT_AddIndexConstraint":
+                        return 22;
+                    case "AT_DropConstraint":
+                        return 23;
+                    case "AT_ReAddComment":
+                        return 24;
+                    case "AT_AlterColumnType":
+                        return 25;
+                    case "AT_AlterColumnGenericOptions":
+                        return 26;
+                    case "AT_ChangeOwner":
+                        return 27;
+                    case "AT_ClusterOn":
+                        return 28;
+                    case "AT_DropCluster":
+                        return 29;
+                    case "AT_SetLogged":
+                        return 30;
+                    case "AT_SetUnLogged":
+                        return 31;
+                    case "AT_DropOids":
+                        return 32;
+                    case "AT_SetAccessMethod":
+                        return 33;
+                    case "AT_SetTableSpace":
+                        return 34;
+                    case "AT_SetRelOptions":
+                        return 35;
+                    case "AT_ResetRelOptions":
+                        return 36;
+                    case "AT_ReplaceRelOptions":
+                        return 37;
+                    case "AT_EnableTrig":
+                        return 38;
+                    case "AT_EnableAlwaysTrig":
+                        return 39;
+                    case "AT_EnableReplicaTrig":
+                        return 40;
+                    case "AT_DisableTrig":
+                        return 41;
+                    case "AT_EnableTrigAll":
+                        return 42;
+                    case "AT_DisableTrigAll":
+                        return 43;
+                    case "AT_EnableTrigUser":
+                        return 44;
+                    case "AT_DisableTrigUser":
+                        return 45;
+                    case "AT_EnableRule":
+                        return 46;
+                    case "AT_EnableAlwaysRule":
+                        return 47;
+                    case "AT_EnableReplicaRule":
+                        return 48;
+                    case "AT_DisableRule":
+                        return 49;
+                    case "AT_AddInherit":
+                        return 50;
+                    case "AT_DropInherit":
+                        return 51;
+                    case "AT_AddOf":
+                        return 52;
+                    case "AT_DropOf":
+                        return 53;
+                    case "AT_ReplicaIdentity":
+                        return 54;
+                    case "AT_EnableRowSecurity":
+                        return 55;
+                    case "AT_DisableRowSecurity":
+                        return 56;
+                    case "AT_ForceRowSecurity":
+                        return 57;
+                    case "AT_NoForceRowSecurity":
+                        return 58;
+                    case "AT_GenericOptions":
+                        return 59;
+                    case "AT_AttachPartition":
+                        return 60;
+                    case "AT_DetachPartition":
+                        return 61;
+                    case "AT_DetachPartitionFinalize":
+                        return 62;
+                    case "AT_AddIdentity":
+                        return 63;
+                    case "AT_SetIdentity":
+                        return 64;
+                    case "AT_DropIdentity":
+                        return 65;
+                    case "AT_ReAddStatistics":
+                        return 66;
+                    default:
+                        throw new Error("Key not recognized in enum AlterTableType");
+                }
+            }
+        case "GrantTargetType":
+            {
+                switch (key) {
+                    case "ACL_TARGET_OBJECT":
+                        return 0;
+                    case "ACL_TARGET_ALL_IN_SCHEMA":
+                        return 1;
+                    case "ACL_TARGET_DEFAULTS":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum GrantTargetType");
+                }
+            }
+        case "VariableSetKind":
+            {
+                switch (key) {
+                    case "VAR_SET_VALUE":
+                        return 0;
+                    case "VAR_SET_DEFAULT":
+                        return 1;
+                    case "VAR_SET_CURRENT":
+                        return 2;
+                    case "VAR_SET_MULTI":
+                        return 3;
+                    case "VAR_RESET":
+                        return 4;
+                    case "VAR_RESET_ALL":
+                        return 5;
+                    default:
+                        throw new Error("Key not recognized in enum VariableSetKind");
+                }
+            }
+        case "ConstrType":
+            {
+                switch (key) {
+                    case "CONSTR_NULL":
+                        return 0;
+                    case "CONSTR_NOTNULL":
+                        return 1;
+                    case "CONSTR_DEFAULT":
+                        return 2;
+                    case "CONSTR_IDENTITY":
+                        return 3;
+                    case "CONSTR_GENERATED":
+                        return 4;
+                    case "CONSTR_CHECK":
+                        return 5;
+                    case "CONSTR_PRIMARY":
+                        return 6;
+                    case "CONSTR_UNIQUE":
+                        return 7;
+                    case "CONSTR_EXCLUSION":
+                        return 8;
+                    case "CONSTR_FOREIGN":
+                        return 9;
+                    case "CONSTR_ATTR_DEFERRABLE":
+                        return 10;
+                    case "CONSTR_ATTR_NOT_DEFERRABLE":
+                        return 11;
+                    case "CONSTR_ATTR_DEFERRED":
+                        return 12;
+                    case "CONSTR_ATTR_IMMEDIATE":
+                        return 13;
+                    default:
+                        throw new Error("Key not recognized in enum ConstrType");
+                }
+            }
+        case "ImportForeignSchemaType":
+            {
+                switch (key) {
+                    case "FDW_IMPORT_SCHEMA_ALL":
+                        return 0;
+                    case "FDW_IMPORT_SCHEMA_LIMIT_TO":
+                        return 1;
+                    case "FDW_IMPORT_SCHEMA_EXCEPT":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum ImportForeignSchemaType");
+                }
+            }
+        case "RoleStmtType":
+            {
+                switch (key) {
+                    case "ROLESTMT_ROLE":
+                        return 0;
+                    case "ROLESTMT_USER":
+                        return 1;
+                    case "ROLESTMT_GROUP":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum RoleStmtType");
+                }
+            }
+        case "FetchDirection":
+            {
+                switch (key) {
+                    case "FETCH_FORWARD":
+                        return 0;
+                    case "FETCH_BACKWARD":
+                        return 1;
+                    case "FETCH_ABSOLUTE":
+                        return 2;
+                    case "FETCH_RELATIVE":
+                        return 3;
+                    default:
+                        throw new Error("Key not recognized in enum FetchDirection");
+                }
+            }
+        case "FunctionParameterMode":
+            {
+                switch (key) {
+                    case "FUNC_PARAM_IN":
+                        return 0;
+                    case "FUNC_PARAM_OUT":
+                        return 1;
+                    case "FUNC_PARAM_INOUT":
+                        return 2;
+                    case "FUNC_PARAM_VARIADIC":
+                        return 3;
+                    case "FUNC_PARAM_TABLE":
+                        return 4;
+                    case "FUNC_PARAM_DEFAULT":
+                        return 5;
+                    default:
+                        throw new Error("Key not recognized in enum FunctionParameterMode");
+                }
+            }
+        case "TransactionStmtKind":
+            {
+                switch (key) {
+                    case "TRANS_STMT_BEGIN":
+                        return 0;
+                    case "TRANS_STMT_START":
+                        return 1;
+                    case "TRANS_STMT_COMMIT":
+                        return 2;
+                    case "TRANS_STMT_ROLLBACK":
+                        return 3;
+                    case "TRANS_STMT_SAVEPOINT":
+                        return 4;
+                    case "TRANS_STMT_RELEASE":
+                        return 5;
+                    case "TRANS_STMT_ROLLBACK_TO":
+                        return 6;
+                    case "TRANS_STMT_PREPARE":
+                        return 7;
+                    case "TRANS_STMT_COMMIT_PREPARED":
+                        return 8;
+                    case "TRANS_STMT_ROLLBACK_PREPARED":
+                        return 9;
+                    default:
+                        throw new Error("Key not recognized in enum TransactionStmtKind");
+                }
+            }
+        case "ViewCheckOption":
+            {
+                switch (key) {
+                    case "NO_CHECK_OPTION":
+                        return 0;
+                    case "LOCAL_CHECK_OPTION":
+                        return 1;
+                    case "CASCADED_CHECK_OPTION":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum ViewCheckOption");
+                }
+            }
+        case "DiscardMode":
+            {
+                switch (key) {
+                    case "DISCARD_ALL":
+                        return 0;
+                    case "DISCARD_PLANS":
+                        return 1;
+                    case "DISCARD_SEQUENCES":
+                        return 2;
+                    case "DISCARD_TEMP":
+                        return 3;
+                    default:
+                        throw new Error("Key not recognized in enum DiscardMode");
+                }
+            }
+        case "ReindexObjectType":
+            {
+                switch (key) {
+                    case "REINDEX_OBJECT_INDEX":
+                        return 0;
+                    case "REINDEX_OBJECT_TABLE":
+                        return 1;
+                    case "REINDEX_OBJECT_SCHEMA":
+                        return 2;
+                    case "REINDEX_OBJECT_SYSTEM":
+                        return 3;
+                    case "REINDEX_OBJECT_DATABASE":
+                        return 4;
+                    default:
+                        throw new Error("Key not recognized in enum ReindexObjectType");
+                }
+            }
+        case "AlterTSConfigType":
+            {
+                switch (key) {
+                    case "ALTER_TSCONFIG_ADD_MAPPING":
+                        return 0;
+                    case "ALTER_TSCONFIG_ALTER_MAPPING_FOR_TOKEN":
+                        return 1;
+                    case "ALTER_TSCONFIG_REPLACE_DICT":
+                        return 2;
+                    case "ALTER_TSCONFIG_REPLACE_DICT_FOR_TOKEN":
+                        return 3;
+                    case "ALTER_TSCONFIG_DROP_MAPPING":
+                        return 4;
+                    default:
+                        throw new Error("Key not recognized in enum AlterTSConfigType");
+                }
+            }
+        case "PublicationObjSpecType":
+            {
+                switch (key) {
+                    case "PUBLICATIONOBJ_TABLE":
+                        return 0;
+                    case "PUBLICATIONOBJ_TABLES_IN_SCHEMA":
+                        return 1;
+                    case "PUBLICATIONOBJ_TABLES_IN_CUR_SCHEMA":
+                        return 2;
+                    case "PUBLICATIONOBJ_CONTINUATION":
+                        return 3;
+                    default:
+                        throw new Error("Key not recognized in enum PublicationObjSpecType");
+                }
+            }
+        case "AlterPublicationAction":
+            {
+                switch (key) {
+                    case "AP_AddObjects":
+                        return 0;
+                    case "AP_DropObjects":
+                        return 1;
+                    case "AP_SetObjects":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum AlterPublicationAction");
+                }
+            }
+        case "AlterSubscriptionType":
+            {
+                switch (key) {
+                    case "ALTER_SUBSCRIPTION_OPTIONS":
+                        return 0;
+                    case "ALTER_SUBSCRIPTION_CONNECTION":
+                        return 1;
+                    case "ALTER_SUBSCRIPTION_SET_PUBLICATION":
+                        return 2;
+                    case "ALTER_SUBSCRIPTION_ADD_PUBLICATION":
+                        return 3;
+                    case "ALTER_SUBSCRIPTION_DROP_PUBLICATION":
+                        return 4;
+                    case "ALTER_SUBSCRIPTION_REFRESH":
+                        return 5;
+                    case "ALTER_SUBSCRIPTION_ENABLED":
+                        return 6;
+                    case "ALTER_SUBSCRIPTION_SKIP":
+                        return 7;
+                    default:
+                        throw new Error("Key not recognized in enum AlterSubscriptionType");
+                }
+            }
+        case "OverridingKind":
+            {
+                switch (key) {
+                    case "OVERRIDING_NOT_SET":
+                        return 0;
+                    case "OVERRIDING_USER_VALUE":
+                        return 1;
+                    case "OVERRIDING_SYSTEM_VALUE":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum OverridingKind");
+                }
+            }
+        case "OnCommitAction":
+            {
+                switch (key) {
+                    case "ONCOMMIT_NOOP":
+                        return 0;
+                    case "ONCOMMIT_PRESERVE_ROWS":
+                        return 1;
+                    case "ONCOMMIT_DELETE_ROWS":
+                        return 2;
+                    case "ONCOMMIT_DROP":
+                        return 3;
+                    default:
+                        throw new Error("Key not recognized in enum OnCommitAction");
+                }
+            }
+        case "TableFuncType":
+            {
+                switch (key) {
+                    case "TFT_XMLTABLE":
+                        return 0;
+                    case "TFT_JSON_TABLE":
+                        return 1;
+                    default:
+                        throw new Error("Key not recognized in enum TableFuncType");
+                }
+            }
+        case "ParamKind":
+            {
+                switch (key) {
+                    case "PARAM_EXTERN":
+                        return 0;
+                    case "PARAM_EXEC":
+                        return 1;
+                    case "PARAM_SUBLINK":
+                        return 2;
+                    case "PARAM_MULTIEXPR":
+                        return 3;
+                    default:
+                        throw new Error("Key not recognized in enum ParamKind");
+                }
+            }
+        case "CoercionContext":
+            {
+                switch (key) {
+                    case "COERCION_IMPLICIT":
+                        return 0;
+                    case "COERCION_ASSIGNMENT":
+                        return 1;
+                    case "COERCION_PLPGSQL":
+                        return 2;
+                    case "COERCION_EXPLICIT":
+                        return 3;
+                    default:
+                        throw new Error("Key not recognized in enum CoercionContext");
+                }
+            }
+        case "CoercionForm":
+            {
+                switch (key) {
+                    case "COERCE_EXPLICIT_CALL":
+                        return 0;
+                    case "COERCE_EXPLICIT_CAST":
+                        return 1;
+                    case "COERCE_IMPLICIT_CAST":
+                        return 2;
+                    case "COERCE_SQL_SYNTAX":
+                        return 3;
+                    default:
+                        throw new Error("Key not recognized in enum CoercionForm");
+                }
+            }
+        case "BoolExprType":
+            {
+                switch (key) {
+                    case "AND_EXPR":
+                        return 0;
+                    case "OR_EXPR":
+                        return 1;
+                    case "NOT_EXPR":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum BoolExprType");
+                }
+            }
+        case "SubLinkType":
+            {
+                switch (key) {
+                    case "EXISTS_SUBLINK":
+                        return 0;
+                    case "ALL_SUBLINK":
+                        return 1;
+                    case "ANY_SUBLINK":
+                        return 2;
+                    case "ROWCOMPARE_SUBLINK":
+                        return 3;
+                    case "EXPR_SUBLINK":
+                        return 4;
+                    case "MULTIEXPR_SUBLINK":
+                        return 5;
+                    case "ARRAY_SUBLINK":
+                        return 6;
+                    case "CTE_SUBLINK":
+                        return 7;
+                    default:
+                        throw new Error("Key not recognized in enum SubLinkType");
+                }
+            }
+        case "RowCompareType":
+            {
+                switch (key) {
+                    case "ROWCOMPARE_LT":
+                        return 0;
+                    case "ROWCOMPARE_LE":
+                        return 1;
+                    case "ROWCOMPARE_EQ":
+                        return 2;
+                    case "ROWCOMPARE_GE":
+                        return 3;
+                    case "ROWCOMPARE_GT":
+                        return 4;
+                    case "ROWCOMPARE_NE":
+                        return 5;
+                    default:
+                        throw new Error("Key not recognized in enum RowCompareType");
+                }
+            }
+        case "MinMaxOp":
+            {
+                switch (key) {
+                    case "IS_GREATEST":
+                        return 0;
+                    case "IS_LEAST":
+                        return 1;
+                    default:
+                        throw new Error("Key not recognized in enum MinMaxOp");
+                }
+            }
+        case "SQLValueFunctionOp":
+            {
+                switch (key) {
+                    case "SVFOP_CURRENT_DATE":
+                        return 0;
+                    case "SVFOP_CURRENT_TIME":
+                        return 1;
+                    case "SVFOP_CURRENT_TIME_N":
+                        return 2;
+                    case "SVFOP_CURRENT_TIMESTAMP":
+                        return 3;
+                    case "SVFOP_CURRENT_TIMESTAMP_N":
+                        return 4;
+                    case "SVFOP_LOCALTIME":
+                        return 5;
+                    case "SVFOP_LOCALTIME_N":
+                        return 6;
+                    case "SVFOP_LOCALTIMESTAMP":
+                        return 7;
+                    case "SVFOP_LOCALTIMESTAMP_N":
+                        return 8;
+                    case "SVFOP_CURRENT_ROLE":
+                        return 9;
+                    case "SVFOP_CURRENT_USER":
+                        return 10;
+                    case "SVFOP_USER":
+                        return 11;
+                    case "SVFOP_SESSION_USER":
+                        return 12;
+                    case "SVFOP_CURRENT_CATALOG":
+                        return 13;
+                    case "SVFOP_CURRENT_SCHEMA":
+                        return 14;
+                    default:
+                        throw new Error("Key not recognized in enum SQLValueFunctionOp");
+                }
+            }
+        case "XmlExprOp":
+            {
+                switch (key) {
+                    case "IS_XMLCONCAT":
+                        return 0;
+                    case "IS_XMLELEMENT":
+                        return 1;
+                    case "IS_XMLFOREST":
+                        return 2;
+                    case "IS_XMLPARSE":
+                        return 3;
+                    case "IS_XMLPI":
+                        return 4;
+                    case "IS_XMLROOT":
+                        return 5;
+                    case "IS_XMLSERIALIZE":
+                        return 6;
+                    case "IS_DOCUMENT":
+                        return 7;
+                    default:
+                        throw new Error("Key not recognized in enum XmlExprOp");
+                }
+            }
+        case "XmlOptionType":
+            {
+                switch (key) {
+                    case "XMLOPTION_DOCUMENT":
+                        return 0;
+                    case "XMLOPTION_CONTENT":
+                        return 1;
+                    default:
+                        throw new Error("Key not recognized in enum XmlOptionType");
+                }
+            }
+        case "JsonEncoding":
+            {
+                switch (key) {
+                    case "JS_ENC_DEFAULT":
+                        return 0;
+                    case "JS_ENC_UTF8":
+                        return 1;
+                    case "JS_ENC_UTF16":
+                        return 2;
+                    case "JS_ENC_UTF32":
+                        return 3;
+                    default:
+                        throw new Error("Key not recognized in enum JsonEncoding");
+                }
+            }
+        case "JsonFormatType":
+            {
+                switch (key) {
+                    case "JS_FORMAT_DEFAULT":
+                        return 0;
+                    case "JS_FORMAT_JSON":
+                        return 1;
+                    case "JS_FORMAT_JSONB":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum JsonFormatType");
+                }
+            }
+        case "JsonConstructorType":
+            {
+                switch (key) {
+                    case "JSCTOR_JSON_OBJECT":
+                        return 0;
+                    case "JSCTOR_JSON_ARRAY":
+                        return 1;
+                    case "JSCTOR_JSON_OBJECTAGG":
+                        return 2;
+                    case "JSCTOR_JSON_ARRAYAGG":
+                        return 3;
+                    case "JSCTOR_JSON_PARSE":
+                        return 4;
+                    case "JSCTOR_JSON_SCALAR":
+                        return 5;
+                    case "JSCTOR_JSON_SERIALIZE":
+                        return 6;
+                    default:
+                        throw new Error("Key not recognized in enum JsonConstructorType");
+                }
+            }
+        case "JsonValueType":
+            {
+                switch (key) {
+                    case "JS_TYPE_ANY":
+                        return 0;
+                    case "JS_TYPE_OBJECT":
+                        return 1;
+                    case "JS_TYPE_ARRAY":
+                        return 2;
+                    case "JS_TYPE_SCALAR":
+                        return 3;
+                    default:
+                        throw new Error("Key not recognized in enum JsonValueType");
+                }
+            }
+        case "JsonWrapper":
+            {
+                switch (key) {
+                    case "JSW_UNSPEC":
+                        return 0;
+                    case "JSW_NONE":
+                        return 1;
+                    case "JSW_CONDITIONAL":
+                        return 2;
+                    case "JSW_UNCONDITIONAL":
+                        return 3;
+                    default:
+                        throw new Error("Key not recognized in enum JsonWrapper");
+                }
+            }
+        case "JsonBehaviorType":
+            {
+                switch (key) {
+                    case "JSON_BEHAVIOR_NULL":
+                        return 0;
+                    case "JSON_BEHAVIOR_ERROR":
+                        return 1;
+                    case "JSON_BEHAVIOR_EMPTY":
+                        return 2;
+                    case "JSON_BEHAVIOR_TRUE":
+                        return 3;
+                    case "JSON_BEHAVIOR_FALSE":
+                        return 4;
+                    case "JSON_BEHAVIOR_UNKNOWN":
+                        return 5;
+                    case "JSON_BEHAVIOR_EMPTY_ARRAY":
+                        return 6;
+                    case "JSON_BEHAVIOR_EMPTY_OBJECT":
+                        return 7;
+                    case "JSON_BEHAVIOR_DEFAULT":
+                        return 8;
+                    default:
+                        throw new Error("Key not recognized in enum JsonBehaviorType");
+                }
+            }
+        case "JsonExprOp":
+            {
+                switch (key) {
+                    case "JSON_EXISTS_OP":
+                        return 0;
+                    case "JSON_QUERY_OP":
+                        return 1;
+                    case "JSON_VALUE_OP":
+                        return 2;
+                    case "JSON_TABLE_OP":
+                        return 3;
+                    default:
+                        throw new Error("Key not recognized in enum JsonExprOp");
+                }
+            }
+        case "NullTestType":
+            {
+                switch (key) {
+                    case "IS_NULL":
+                        return 0;
+                    case "IS_NOT_NULL":
+                        return 1;
+                    default:
+                        throw new Error("Key not recognized in enum NullTestType");
+                }
+            }
+        case "BoolTestType":
+            {
+                switch (key) {
+                    case "IS_TRUE":
+                        return 0;
+                    case "IS_NOT_TRUE":
+                        return 1;
+                    case "IS_FALSE":
+                        return 2;
+                    case "IS_NOT_FALSE":
+                        return 3;
+                    case "IS_UNKNOWN":
+                        return 4;
+                    case "IS_NOT_UNKNOWN":
+                        return 5;
+                    default:
+                        throw new Error("Key not recognized in enum BoolTestType");
+                }
+            }
+        case "MergeMatchKind":
+            {
+                switch (key) {
+                    case "MERGE_WHEN_MATCHED":
+                        return 0;
+                    case "MERGE_WHEN_NOT_MATCHED_BY_SOURCE":
+                        return 1;
+                    case "MERGE_WHEN_NOT_MATCHED_BY_TARGET":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum MergeMatchKind");
+                }
+            }
+        case "CmdType":
+            {
+                switch (key) {
+                    case "CMD_UNKNOWN":
+                        return 0;
+                    case "CMD_SELECT":
+                        return 1;
+                    case "CMD_UPDATE":
+                        return 2;
+                    case "CMD_INSERT":
+                        return 3;
+                    case "CMD_DELETE":
+                        return 4;
+                    case "CMD_MERGE":
+                        return 5;
+                    case "CMD_UTILITY":
+                        return 6;
+                    case "CMD_NOTHING":
+                        return 7;
+                    default:
+                        throw new Error("Key not recognized in enum CmdType");
+                }
+            }
+        case "JoinType":
+            {
+                switch (key) {
+                    case "JOIN_INNER":
+                        return 0;
+                    case "JOIN_LEFT":
+                        return 1;
+                    case "JOIN_FULL":
+                        return 2;
+                    case "JOIN_RIGHT":
+                        return 3;
+                    case "JOIN_SEMI":
+                        return 4;
+                    case "JOIN_ANTI":
+                        return 5;
+                    case "JOIN_RIGHT_ANTI":
+                        return 6;
+                    case "JOIN_UNIQUE_OUTER":
+                        return 7;
+                    case "JOIN_UNIQUE_INNER":
+                        return 8;
+                    default:
+                        throw new Error("Key not recognized in enum JoinType");
+                }
+            }
+        case "AggStrategy":
+            {
+                switch (key) {
+                    case "AGG_PLAIN":
+                        return 0;
+                    case "AGG_SORTED":
+                        return 1;
+                    case "AGG_HASHED":
+                        return 2;
+                    case "AGG_MIXED":
+                        return 3;
+                    default:
+                        throw new Error("Key not recognized in enum AggStrategy");
+                }
+            }
+        case "AggSplit":
+            {
+                switch (key) {
+                    case "AGGSPLIT_SIMPLE":
+                        return 0;
+                    case "AGGSPLIT_INITIAL_SERIAL":
+                        return 1;
+                    case "AGGSPLIT_FINAL_DESERIAL":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum AggSplit");
+                }
+            }
+        case "SetOpCmd":
+            {
+                switch (key) {
+                    case "SETOPCMD_INTERSECT":
+                        return 0;
+                    case "SETOPCMD_INTERSECT_ALL":
+                        return 1;
+                    case "SETOPCMD_EXCEPT":
+                        return 2;
+                    case "SETOPCMD_EXCEPT_ALL":
+                        return 3;
+                    default:
+                        throw new Error("Key not recognized in enum SetOpCmd");
+                }
+            }
+        case "SetOpStrategy":
+            {
+                switch (key) {
+                    case "SETOP_SORTED":
+                        return 0;
+                    case "SETOP_HASHED":
+                        return 1;
+                    default:
+                        throw new Error("Key not recognized in enum SetOpStrategy");
+                }
+            }
+        case "OnConflictAction":
+            {
+                switch (key) {
+                    case "ONCONFLICT_NONE":
+                        return 0;
+                    case "ONCONFLICT_NOTHING":
+                        return 1;
+                    case "ONCONFLICT_UPDATE":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum OnConflictAction");
+                }
+            }
+        case "LimitOption":
+            {
+                switch (key) {
+                    case "LIMIT_OPTION_DEFAULT":
+                        return 0;
+                    case "LIMIT_OPTION_COUNT":
+                        return 1;
+                    case "LIMIT_OPTION_WITH_TIES":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum LimitOption");
+                }
+            }
+        case "LockClauseStrength":
+            {
+                switch (key) {
+                    case "LCS_NONE":
+                        return 0;
+                    case "LCS_FORKEYSHARE":
+                        return 1;
+                    case "LCS_FORSHARE":
+                        return 2;
+                    case "LCS_FORNOKEYUPDATE":
+                        return 3;
+                    case "LCS_FORUPDATE":
+                        return 4;
+                    default:
+                        throw new Error("Key not recognized in enum LockClauseStrength");
+                }
+            }
+        case "LockWaitPolicy":
+            {
+                switch (key) {
+                    case "LockWaitBlock":
+                        return 0;
+                    case "LockWaitSkip":
+                        return 1;
+                    case "LockWaitError":
+                        return 2;
+                    default:
+                        throw new Error("Key not recognized in enum LockWaitPolicy");
+                }
+            }
+        case "LockTupleMode":
+            {
+                switch (key) {
+                    case "LockTupleKeyShare":
+                        return 0;
+                    case "LockTupleShare":
+                        return 1;
+                    case "LockTupleNoKeyExclusive":
+                        return 2;
+                    case "LockTupleExclusive":
+                        return 3;
+                    default:
+                        throw new Error("Key not recognized in enum LockTupleMode");
+                }
+            }
+        case "KeywordKind":
+            {
+                switch (key) {
+                    case "NO_KEYWORD":
+                        return 0;
+                    case "UNRESERVED_KEYWORD":
+                        return 1;
+                    case "COL_NAME_KEYWORD":
+                        return 2;
+                    case "TYPE_FUNC_NAME_KEYWORD":
+                        return 3;
+                    case "RESERVED_KEYWORD":
+                        return 4;
+                    default:
+                        throw new Error("Key not recognized in enum KeywordKind");
+                }
+            }
+        case "Token":
+            {
+                switch (key) {
+                    case "NUL":
+                        return 0;
+                    case "ASCII_36":
+                        return 36;
+                    case "ASCII_37":
+                        return 37;
+                    case "ASCII_40":
+                        return 40;
+                    case "ASCII_41":
+                        return 41;
+                    case "ASCII_42":
+                        return 42;
+                    case "ASCII_43":
+                        return 43;
+                    case "ASCII_44":
+                        return 44;
+                    case "ASCII_45":
+                        return 45;
+                    case "ASCII_46":
+                        return 46;
+                    case "ASCII_47":
+                        return 47;
+                    case "ASCII_58":
+                        return 58;
+                    case "ASCII_59":
+                        return 59;
+                    case "ASCII_60":
+                        return 60;
+                    case "ASCII_61":
+                        return 61;
+                    case "ASCII_62":
+                        return 62;
+                    case "ASCII_63":
+                        return 63;
+                    case "ASCII_91":
+                        return 91;
+                    case "ASCII_92":
+                        return 92;
+                    case "ASCII_93":
+                        return 93;
+                    case "ASCII_94":
+                        return 94;
+                    case "IDENT":
+                        return 258;
+                    case "UIDENT":
+                        return 259;
+                    case "FCONST":
+                        return 260;
+                    case "SCONST":
+                        return 261;
+                    case "USCONST":
+                        return 262;
+                    case "BCONST":
+                        return 263;
+                    case "XCONST":
+                        return 264;
+                    case "Op":
+                        return 265;
+                    case "ICONST":
+                        return 266;
+                    case "PARAM":
+                        return 267;
+                    case "TYPECAST":
+                        return 268;
+                    case "DOT_DOT":
+                        return 269;
+                    case "COLON_EQUALS":
+                        return 270;
+                    case "EQUALS_GREATER":
+                        return 271;
+                    case "LESS_EQUALS":
+                        return 272;
+                    case "GREATER_EQUALS":
+                        return 273;
+                    case "NOT_EQUALS":
+                        return 274;
+                    case "SQL_COMMENT":
+                        return 275;
+                    case "C_COMMENT":
+                        return 276;
+                    case "ABORT_P":
+                        return 277;
+                    case "ABSENT":
+                        return 278;
+                    case "ABSOLUTE_P":
+                        return 279;
+                    case "ACCESS":
+                        return 280;
+                    case "ACTION":
+                        return 281;
+                    case "ADD_P":
+                        return 282;
+                    case "ADMIN":
+                        return 283;
+                    case "AFTER":
+                        return 284;
+                    case "AGGREGATE":
+                        return 285;
+                    case "ALL":
+                        return 286;
+                    case "ALSO":
+                        return 287;
+                    case "ALTER":
+                        return 288;
+                    case "ALWAYS":
+                        return 289;
+                    case "ANALYSE":
+                        return 290;
+                    case "ANALYZE":
+                        return 291;
+                    case "AND":
+                        return 292;
+                    case "ANY":
+                        return 293;
+                    case "ARRAY":
+                        return 294;
+                    case "AS":
+                        return 295;
+                    case "ASC":
+                        return 296;
+                    case "ASENSITIVE":
+                        return 297;
+                    case "ASSERTION":
+                        return 298;
+                    case "ASSIGNMENT":
+                        return 299;
+                    case "ASYMMETRIC":
+                        return 300;
+                    case "ATOMIC":
+                        return 301;
+                    case "AT":
+                        return 302;
+                    case "ATTACH":
+                        return 303;
+                    case "ATTRIBUTE":
+                        return 304;
+                    case "AUTHORIZATION":
+                        return 305;
+                    case "BACKWARD":
+                        return 306;
+                    case "BEFORE":
+                        return 307;
+                    case "BEGIN_P":
+                        return 308;
+                    case "BETWEEN":
+                        return 309;
+                    case "BIGINT":
+                        return 310;
+                    case "BINARY":
+                        return 311;
+                    case "BIT":
+                        return 312;
+                    case "BOOLEAN_P":
+                        return 313;
+                    case "BOTH":
+                        return 314;
+                    case "BREADTH":
+                        return 315;
+                    case "BY":
+                        return 316;
+                    case "CACHE":
+                        return 317;
+                    case "CALL":
+                        return 318;
+                    case "CALLED":
+                        return 319;
+                    case "CASCADE":
+                        return 320;
+                    case "CASCADED":
+                        return 321;
+                    case "CASE":
+                        return 322;
+                    case "CAST":
+                        return 323;
+                    case "CATALOG_P":
+                        return 324;
+                    case "CHAIN":
+                        return 325;
+                    case "CHAR_P":
+                        return 326;
+                    case "CHARACTER":
+                        return 327;
+                    case "CHARACTERISTICS":
+                        return 328;
+                    case "CHECK":
+                        return 329;
+                    case "CHECKPOINT":
+                        return 330;
+                    case "CLASS":
+                        return 331;
+                    case "CLOSE":
+                        return 332;
+                    case "CLUSTER":
+                        return 333;
+                    case "COALESCE":
+                        return 334;
+                    case "COLLATE":
+                        return 335;
+                    case "COLLATION":
+                        return 336;
+                    case "COLUMN":
+                        return 337;
+                    case "COLUMNS":
+                        return 338;
+                    case "COMMENT":
+                        return 339;
+                    case "COMMENTS":
+                        return 340;
+                    case "COMMIT":
+                        return 341;
+                    case "COMMITTED":
+                        return 342;
+                    case "COMPRESSION":
+                        return 343;
+                    case "CONCURRENTLY":
+                        return 344;
+                    case "CONDITIONAL":
+                        return 345;
+                    case "CONFIGURATION":
+                        return 346;
+                    case "CONFLICT":
+                        return 347;
+                    case "CONNECTION":
+                        return 348;
+                    case "CONSTRAINT":
+                        return 349;
+                    case "CONSTRAINTS":
+                        return 350;
+                    case "CONTENT_P":
+                        return 351;
+                    case "CONTINUE_P":
+                        return 352;
+                    case "CONVERSION_P":
+                        return 353;
+                    case "COPY":
+                        return 354;
+                    case "COST":
+                        return 355;
+                    case "CREATE":
+                        return 356;
+                    case "CROSS":
+                        return 357;
+                    case "CSV":
+                        return 358;
+                    case "CUBE":
+                        return 359;
+                    case "CURRENT_P":
+                        return 360;
+                    case "CURRENT_CATALOG":
+                        return 361;
+                    case "CURRENT_DATE":
+                        return 362;
+                    case "CURRENT_ROLE":
+                        return 363;
+                    case "CURRENT_SCHEMA":
+                        return 364;
+                    case "CURRENT_TIME":
+                        return 365;
+                    case "CURRENT_TIMESTAMP":
+                        return 366;
+                    case "CURRENT_USER":
+                        return 367;
+                    case "CURSOR":
+                        return 368;
+                    case "CYCLE":
+                        return 369;
+                    case "DATA_P":
+                        return 370;
+                    case "DATABASE":
+                        return 371;
+                    case "DAY_P":
+                        return 372;
+                    case "DEALLOCATE":
+                        return 373;
+                    case "DEC":
+                        return 374;
+                    case "DECIMAL_P":
+                        return 375;
+                    case "DECLARE":
+                        return 376;
+                    case "DEFAULT":
+                        return 377;
+                    case "DEFAULTS":
+                        return 378;
+                    case "DEFERRABLE":
+                        return 379;
+                    case "DEFERRED":
+                        return 380;
+                    case "DEFINER":
+                        return 381;
+                    case "DELETE_P":
+                        return 382;
+                    case "DELIMITER":
+                        return 383;
+                    case "DELIMITERS":
+                        return 384;
+                    case "DEPENDS":
+                        return 385;
+                    case "DEPTH":
+                        return 386;
+                    case "DESC":
+                        return 387;
+                    case "DETACH":
+                        return 388;
+                    case "DICTIONARY":
+                        return 389;
+                    case "DISABLE_P":
+                        return 390;
+                    case "DISCARD":
+                        return 391;
+                    case "DISTINCT":
+                        return 392;
+                    case "DO":
+                        return 393;
+                    case "DOCUMENT_P":
+                        return 394;
+                    case "DOMAIN_P":
+                        return 395;
+                    case "DOUBLE_P":
+                        return 396;
+                    case "DROP":
+                        return 397;
+                    case "EACH":
+                        return 398;
+                    case "ELSE":
+                        return 399;
+                    case "EMPTY_P":
+                        return 400;
+                    case "ENABLE_P":
+                        return 401;
+                    case "ENCODING":
+                        return 402;
+                    case "ENCRYPTED":
+                        return 403;
+                    case "END_P":
+                        return 404;
+                    case "ENUM_P":
+                        return 405;
+                    case "ERROR_P":
+                        return 406;
+                    case "ESCAPE":
+                        return 407;
+                    case "EVENT":
+                        return 408;
+                    case "EXCEPT":
+                        return 409;
+                    case "EXCLUDE":
+                        return 410;
+                    case "EXCLUDING":
+                        return 411;
+                    case "EXCLUSIVE":
+                        return 412;
+                    case "EXECUTE":
+                        return 413;
+                    case "EXISTS":
+                        return 414;
+                    case "EXPLAIN":
+                        return 415;
+                    case "EXPRESSION":
+                        return 416;
+                    case "EXTENSION":
+                        return 417;
+                    case "EXTERNAL":
+                        return 418;
+                    case "EXTRACT":
+                        return 419;
+                    case "FALSE_P":
+                        return 420;
+                    case "FAMILY":
+                        return 421;
+                    case "FETCH":
+                        return 422;
+                    case "FILTER":
+                        return 423;
+                    case "FINALIZE":
+                        return 424;
+                    case "FIRST_P":
+                        return 425;
+                    case "FLOAT_P":
+                        return 426;
+                    case "FOLLOWING":
+                        return 427;
+                    case "FOR":
+                        return 428;
+                    case "FORCE":
+                        return 429;
+                    case "FOREIGN":
+                        return 430;
+                    case "FORMAT":
+                        return 431;
+                    case "FORWARD":
+                        return 432;
+                    case "FREEZE":
+                        return 433;
+                    case "FROM":
+                        return 434;
+                    case "FULL":
+                        return 435;
+                    case "FUNCTION":
+                        return 436;
+                    case "FUNCTIONS":
+                        return 437;
+                    case "GENERATED":
+                        return 438;
+                    case "GLOBAL":
+                        return 439;
+                    case "GRANT":
+                        return 440;
+                    case "GRANTED":
+                        return 441;
+                    case "GREATEST":
+                        return 442;
+                    case "GROUP_P":
+                        return 443;
+                    case "GROUPING":
+                        return 444;
+                    case "GROUPS":
+                        return 445;
+                    case "HANDLER":
+                        return 446;
+                    case "HAVING":
+                        return 447;
+                    case "HEADER_P":
+                        return 448;
+                    case "HOLD":
+                        return 449;
+                    case "HOUR_P":
+                        return 450;
+                    case "IDENTITY_P":
+                        return 451;
+                    case "IF_P":
+                        return 452;
+                    case "ILIKE":
+                        return 453;
+                    case "IMMEDIATE":
+                        return 454;
+                    case "IMMUTABLE":
+                        return 455;
+                    case "IMPLICIT_P":
+                        return 456;
+                    case "IMPORT_P":
+                        return 457;
+                    case "IN_P":
+                        return 458;
+                    case "INCLUDE":
+                        return 459;
+                    case "INCLUDING":
+                        return 460;
+                    case "INCREMENT":
+                        return 461;
+                    case "INDENT":
+                        return 462;
+                    case "INDEX":
+                        return 463;
+                    case "INDEXES":
+                        return 464;
+                    case "INHERIT":
+                        return 465;
+                    case "INHERITS":
+                        return 466;
+                    case "INITIALLY":
+                        return 467;
+                    case "INLINE_P":
+                        return 468;
+                    case "INNER_P":
+                        return 469;
+                    case "INOUT":
+                        return 470;
+                    case "INPUT_P":
+                        return 471;
+                    case "INSENSITIVE":
+                        return 472;
+                    case "INSERT":
+                        return 473;
+                    case "INSTEAD":
+                        return 474;
+                    case "INT_P":
+                        return 475;
+                    case "INTEGER":
+                        return 476;
+                    case "INTERSECT":
+                        return 477;
+                    case "INTERVAL":
+                        return 478;
+                    case "INTO":
+                        return 479;
+                    case "INVOKER":
+                        return 480;
+                    case "IS":
+                        return 481;
+                    case "ISNULL":
+                        return 482;
+                    case "ISOLATION":
+                        return 483;
+                    case "JOIN":
+                        return 484;
+                    case "JSON":
+                        return 485;
+                    case "JSON_ARRAY":
+                        return 486;
+                    case "JSON_ARRAYAGG":
+                        return 487;
+                    case "JSON_EXISTS":
+                        return 488;
+                    case "JSON_OBJECT":
+                        return 489;
+                    case "JSON_OBJECTAGG":
+                        return 490;
+                    case "JSON_QUERY":
+                        return 491;
+                    case "JSON_SCALAR":
+                        return 492;
+                    case "JSON_SERIALIZE":
+                        return 493;
+                    case "JSON_TABLE":
+                        return 494;
+                    case "JSON_VALUE":
+                        return 495;
+                    case "KEEP":
+                        return 496;
+                    case "KEY":
+                        return 497;
+                    case "KEYS":
+                        return 498;
+                    case "LABEL":
+                        return 499;
+                    case "LANGUAGE":
+                        return 500;
+                    case "LARGE_P":
+                        return 501;
+                    case "LAST_P":
+                        return 502;
+                    case "LATERAL_P":
+                        return 503;
+                    case "LEADING":
+                        return 504;
+                    case "LEAKPROOF":
+                        return 505;
+                    case "LEAST":
+                        return 506;
+                    case "LEFT":
+                        return 507;
+                    case "LEVEL":
+                        return 508;
+                    case "LIKE":
+                        return 509;
+                    case "LIMIT":
+                        return 510;
+                    case "LISTEN":
+                        return 511;
+                    case "LOAD":
+                        return 512;
+                    case "LOCAL":
+                        return 513;
+                    case "LOCALTIME":
+                        return 514;
+                    case "LOCALTIMESTAMP":
+                        return 515;
+                    case "LOCATION":
+                        return 516;
+                    case "LOCK_P":
+                        return 517;
+                    case "LOCKED":
+                        return 518;
+                    case "LOGGED":
+                        return 519;
+                    case "MAPPING":
+                        return 520;
+                    case "MATCH":
+                        return 521;
+                    case "MATCHED":
+                        return 522;
+                    case "MATERIALIZED":
+                        return 523;
+                    case "MAXVALUE":
+                        return 524;
+                    case "MERGE":
+                        return 525;
+                    case "MERGE_ACTION":
+                        return 526;
+                    case "METHOD":
+                        return 527;
+                    case "MINUTE_P":
+                        return 528;
+                    case "MINVALUE":
+                        return 529;
+                    case "MODE":
+                        return 530;
+                    case "MONTH_P":
+                        return 531;
+                    case "MOVE":
+                        return 532;
+                    case "NAME_P":
+                        return 533;
+                    case "NAMES":
+                        return 534;
+                    case "NATIONAL":
+                        return 535;
+                    case "NATURAL":
+                        return 536;
+                    case "NCHAR":
+                        return 537;
+                    case "NESTED":
+                        return 538;
+                    case "NEW":
+                        return 539;
+                    case "NEXT":
+                        return 540;
+                    case "NFC":
+                        return 541;
+                    case "NFD":
+                        return 542;
+                    case "NFKC":
+                        return 543;
+                    case "NFKD":
+                        return 544;
+                    case "NO":
+                        return 545;
+                    case "NONE":
+                        return 546;
+                    case "NORMALIZE":
+                        return 547;
+                    case "NORMALIZED":
+                        return 548;
+                    case "NOT":
+                        return 549;
+                    case "NOTHING":
+                        return 550;
+                    case "NOTIFY":
+                        return 551;
+                    case "NOTNULL":
+                        return 552;
+                    case "NOWAIT":
+                        return 553;
+                    case "NULL_P":
+                        return 554;
+                    case "NULLIF":
+                        return 555;
+                    case "NULLS_P":
+                        return 556;
+                    case "NUMERIC":
+                        return 557;
+                    case "OBJECT_P":
+                        return 558;
+                    case "OF":
+                        return 559;
+                    case "OFF":
+                        return 560;
+                    case "OFFSET":
+                        return 561;
+                    case "OIDS":
+                        return 562;
+                    case "OLD":
+                        return 563;
+                    case "OMIT":
+                        return 564;
+                    case "ON":
+                        return 565;
+                    case "ONLY":
+                        return 566;
+                    case "OPERATOR":
+                        return 567;
+                    case "OPTION":
+                        return 568;
+                    case "OPTIONS":
+                        return 569;
+                    case "OR":
+                        return 570;
+                    case "ORDER":
+                        return 571;
+                    case "ORDINALITY":
+                        return 572;
+                    case "OTHERS":
+                        return 573;
+                    case "OUT_P":
+                        return 574;
+                    case "OUTER_P":
+                        return 575;
+                    case "OVER":
+                        return 576;
+                    case "OVERLAPS":
+                        return 577;
+                    case "OVERLAY":
+                        return 578;
+                    case "OVERRIDING":
+                        return 579;
+                    case "OWNED":
+                        return 580;
+                    case "OWNER":
+                        return 581;
+                    case "PARALLEL":
+                        return 582;
+                    case "PARAMETER":
+                        return 583;
+                    case "PARSER":
+                        return 584;
+                    case "PARTIAL":
+                        return 585;
+                    case "PARTITION":
+                        return 586;
+                    case "PASSING":
+                        return 587;
+                    case "PASSWORD":
+                        return 588;
+                    case "PATH":
+                        return 589;
+                    case "PLACING":
+                        return 590;
+                    case "PLAN":
+                        return 591;
+                    case "PLANS":
+                        return 592;
+                    case "POLICY":
+                        return 593;
+                    case "POSITION":
+                        return 594;
+                    case "PRECEDING":
+                        return 595;
+                    case "PRECISION":
+                        return 596;
+                    case "PRESERVE":
+                        return 597;
+                    case "PREPARE":
+                        return 598;
+                    case "PREPARED":
+                        return 599;
+                    case "PRIMARY":
+                        return 600;
+                    case "PRIOR":
+                        return 601;
+                    case "PRIVILEGES":
+                        return 602;
+                    case "PROCEDURAL":
+                        return 603;
+                    case "PROCEDURE":
+                        return 604;
+                    case "PROCEDURES":
+                        return 605;
+                    case "PROGRAM":
+                        return 606;
+                    case "PUBLICATION":
+                        return 607;
+                    case "QUOTE":
+                        return 608;
+                    case "QUOTES":
+                        return 609;
+                    case "RANGE":
+                        return 610;
+                    case "READ":
+                        return 611;
+                    case "REAL":
+                        return 612;
+                    case "REASSIGN":
+                        return 613;
+                    case "RECHECK":
+                        return 614;
+                    case "RECURSIVE":
+                        return 615;
+                    case "REF_P":
+                        return 616;
+                    case "REFERENCES":
+                        return 617;
+                    case "REFERENCING":
+                        return 618;
+                    case "REFRESH":
+                        return 619;
+                    case "REINDEX":
+                        return 620;
+                    case "RELATIVE_P":
+                        return 621;
+                    case "RELEASE":
+                        return 622;
+                    case "RENAME":
+                        return 623;
+                    case "REPEATABLE":
+                        return 624;
+                    case "REPLACE":
+                        return 625;
+                    case "REPLICA":
+                        return 626;
+                    case "RESET":
+                        return 627;
+                    case "RESTART":
+                        return 628;
+                    case "RESTRICT":
+                        return 629;
+                    case "RETURN":
+                        return 630;
+                    case "RETURNING":
+                        return 631;
+                    case "RETURNS":
+                        return 632;
+                    case "REVOKE":
+                        return 633;
+                    case "RIGHT":
+                        return 634;
+                    case "ROLE":
+                        return 635;
+                    case "ROLLBACK":
+                        return 636;
+                    case "ROLLUP":
+                        return 637;
+                    case "ROUTINE":
+                        return 638;
+                    case "ROUTINES":
+                        return 639;
+                    case "ROW":
+                        return 640;
+                    case "ROWS":
+                        return 641;
+                    case "RULE":
+                        return 642;
+                    case "SAVEPOINT":
+                        return 643;
+                    case "SCALAR":
+                        return 644;
+                    case "SCHEMA":
+                        return 645;
+                    case "SCHEMAS":
+                        return 646;
+                    case "SCROLL":
+                        return 647;
+                    case "SEARCH":
+                        return 648;
+                    case "SECOND_P":
+                        return 649;
+                    case "SECURITY":
+                        return 650;
+                    case "SELECT":
+                        return 651;
+                    case "SEQUENCE":
+                        return 652;
+                    case "SEQUENCES":
+                        return 653;
+                    case "SERIALIZABLE":
+                        return 654;
+                    case "SERVER":
+                        return 655;
+                    case "SESSION":
+                        return 656;
+                    case "SESSION_USER":
+                        return 657;
+                    case "SET":
+                        return 658;
+                    case "SETS":
+                        return 659;
+                    case "SETOF":
+                        return 660;
+                    case "SHARE":
+                        return 661;
+                    case "SHOW":
+                        return 662;
+                    case "SIMILAR":
+                        return 663;
+                    case "SIMPLE":
+                        return 664;
+                    case "SKIP":
+                        return 665;
+                    case "SMALLINT":
+                        return 666;
+                    case "SNAPSHOT":
+                        return 667;
+                    case "SOME":
+                        return 668;
+                    case "SOURCE":
+                        return 669;
+                    case "SQL_P":
+                        return 670;
+                    case "STABLE":
+                        return 671;
+                    case "STANDALONE_P":
+                        return 672;
+                    case "START":
+                        return 673;
+                    case "STATEMENT":
+                        return 674;
+                    case "STATISTICS":
+                        return 675;
+                    case "STDIN":
+                        return 676;
+                    case "STDOUT":
+                        return 677;
+                    case "STORAGE":
+                        return 678;
+                    case "STORED":
+                        return 679;
+                    case "STRICT_P":
+                        return 680;
+                    case "STRING_P":
+                        return 681;
+                    case "STRIP_P":
+                        return 682;
+                    case "SUBSCRIPTION":
+                        return 683;
+                    case "SUBSTRING":
+                        return 684;
+                    case "SUPPORT":
+                        return 685;
+                    case "SYMMETRIC":
+                        return 686;
+                    case "SYSID":
+                        return 687;
+                    case "SYSTEM_P":
+                        return 688;
+                    case "SYSTEM_USER":
+                        return 689;
+                    case "TABLE":
+                        return 690;
+                    case "TABLES":
+                        return 691;
+                    case "TABLESAMPLE":
+                        return 692;
+                    case "TABLESPACE":
+                        return 693;
+                    case "TARGET":
+                        return 694;
+                    case "TEMP":
+                        return 695;
+                    case "TEMPLATE":
+                        return 696;
+                    case "TEMPORARY":
+                        return 697;
+                    case "TEXT_P":
+                        return 698;
+                    case "THEN":
+                        return 699;
+                    case "TIES":
+                        return 700;
+                    case "TIME":
+                        return 701;
+                    case "TIMESTAMP":
+                        return 702;
+                    case "TO":
+                        return 703;
+                    case "TRAILING":
+                        return 704;
+                    case "TRANSACTION":
+                        return 705;
+                    case "TRANSFORM":
+                        return 706;
+                    case "TREAT":
+                        return 707;
+                    case "TRIGGER":
+                        return 708;
+                    case "TRIM":
+                        return 709;
+                    case "TRUE_P":
+                        return 710;
+                    case "TRUNCATE":
+                        return 711;
+                    case "TRUSTED":
+                        return 712;
+                    case "TYPE_P":
+                        return 713;
+                    case "TYPES_P":
+                        return 714;
+                    case "UESCAPE":
+                        return 715;
+                    case "UNBOUNDED":
+                        return 716;
+                    case "UNCONDITIONAL":
+                        return 717;
+                    case "UNCOMMITTED":
+                        return 718;
+                    case "UNENCRYPTED":
+                        return 719;
+                    case "UNION":
+                        return 720;
+                    case "UNIQUE":
+                        return 721;
+                    case "UNKNOWN":
+                        return 722;
+                    case "UNLISTEN":
+                        return 723;
+                    case "UNLOGGED":
+                        return 724;
+                    case "UNTIL":
+                        return 725;
+                    case "UPDATE":
+                        return 726;
+                    case "USER":
+                        return 727;
+                    case "USING":
+                        return 728;
+                    case "VACUUM":
+                        return 729;
+                    case "VALID":
+                        return 730;
+                    case "VALIDATE":
+                        return 731;
+                    case "VALIDATOR":
+                        return 732;
+                    case "VALUE_P":
+                        return 733;
+                    case "VALUES":
+                        return 734;
+                    case "VARCHAR":
+                        return 735;
+                    case "VARIADIC":
+                        return 736;
+                    case "VARYING":
+                        return 737;
+                    case "VERBOSE":
+                        return 738;
+                    case "VERSION_P":
+                        return 739;
+                    case "VIEW":
+                        return 740;
+                    case "VIEWS":
+                        return 741;
+                    case "VOLATILE":
+                        return 742;
+                    case "WHEN":
+                        return 743;
+                    case "WHERE":
+                        return 744;
+                    case "WHITESPACE_P":
+                        return 745;
+                    case "WINDOW":
+                        return 746;
+                    case "WITH":
+                        return 747;
+                    case "WITHIN":
+                        return 748;
+                    case "WITHOUT":
+                        return 749;
+                    case "WORK":
+                        return 750;
+                    case "WRAPPER":
+                        return 751;
+                    case "WRITE":
+                        return 752;
+                    case "XML_P":
+                        return 753;
+                    case "XMLATTRIBUTES":
+                        return 754;
+                    case "XMLCONCAT":
+                        return 755;
+                    case "XMLELEMENT":
+                        return 756;
+                    case "XMLEXISTS":
+                        return 757;
+                    case "XMLFOREST":
+                        return 758;
+                    case "XMLNAMESPACES":
+                        return 759;
+                    case "XMLPARSE":
+                        return 760;
+                    case "XMLPI":
+                        return 761;
+                    case "XMLROOT":
+                        return 762;
+                    case "XMLSERIALIZE":
+                        return 763;
+                    case "XMLTABLE":
+                        return 764;
+                    case "YEAR_P":
+                        return 765;
+                    case "YES_P":
+                        return 766;
+                    case "ZONE":
+                        return 767;
+                    case "FORMAT_LA":
+                        return 768;
+                    case "NOT_LA":
+                        return 769;
+                    case "NULLS_LA":
+                        return 770;
+                    case "WITH_LA":
+                        return 771;
+                    case "WITHOUT_LA":
+                        return 772;
+                    case "MODE_TYPE_NAME":
+                        return 773;
+                    case "MODE_PLPGSQL_EXPR":
+                        return 774;
+                    case "MODE_PLPGSQL_ASSIGN1":
+                        return 775;
+                    case "MODE_PLPGSQL_ASSIGN2":
+                        return 776;
+                    case "MODE_PLPGSQL_ASSIGN3":
+                        return 777;
+                    case "UMINUS":
+                        return 778;
+                    default:
+                        throw new Error("Key not recognized in enum Token");
+                }
+            }
+        default:
+            throw new Error("Enum type not recognized");
+    }
+};
+exports.getEnumInt = getEnumInt;