@pgsql/transform-ast 18.3.0

package/transformers/v15-to-v16.d.ts

@@ -0,0 +1,632 @@
+import * as PG15 from '../15/types';
+import * as PG16 from '../16/types';
+import { TransformerContext } from './context';
+/**
+ * V15 to V16 AST Transformer
+ * Transforms PostgreSQL v15 AST nodes to v16 format
+ */
+export declare class V15ToV16Transformer {
+    transform(node: PG15.Node, context?: TransformerContext): any;
+    visit(node: PG15.Node, context?: TransformerContext): any;
+    getNodeType(node: PG15.Node): any;
+    getNodeData(node: PG15.Node): any;
+    ParseResult(node: PG15.ParseResult, context: TransformerContext): PG16.ParseResult;
+    RawStmt(node: PG15.RawStmt, context: TransformerContext): {
+        RawStmt: PG16.RawStmt;
+    };
+    SelectStmt(node: PG15.SelectStmt, context: TransformerContext): {
+        SelectStmt: PG16.SelectStmt;
+    };
+    A_Expr(node: PG15.A_Expr, context: TransformerContext): {
+        A_Expr: PG16.A_Expr;
+    };
+    InsertStmt(node: PG15.InsertStmt, context: TransformerContext): {
+        InsertStmt: PG16.InsertStmt;
+    };
+    UpdateStmt(node: PG15.UpdateStmt, context: TransformerContext): {
+        UpdateStmt: PG16.UpdateStmt;
+    };
+    DeleteStmt(node: PG15.DeleteStmt, context: TransformerContext): {
+        DeleteStmt: PG16.DeleteStmt;
+    };
+    WithClause(node: PG15.WithClause, context: TransformerContext): {
+        WithClause: PG16.WithClause;
+    };
+    ResTarget(node: PG15.ResTarget, context: TransformerContext): {
+        ResTarget: PG16.ResTarget;
+    };
+    BoolExpr(node: PG15.BoolExpr, context: TransformerContext): {
+        BoolExpr: PG16.BoolExpr;
+    };
+    FuncCall(node: PG15.FuncCall, context: TransformerContext): {
+        FuncCall: PG16.FuncCall;
+    } | {
+        ColumnRef: PG16.ColumnRef;
+    };
+    FuncExpr(node: PG15.FuncExpr, context: TransformerContext): {
+        FuncExpr: PG16.FuncExpr;
+    };
+    A_Const(node: PG15.A_Const, context: TransformerContext): {
+        A_Const: PG16.A_Const;
+    };
+    ColumnRef(node: PG15.ColumnRef, context: TransformerContext): {
+        ColumnRef: PG16.ColumnRef;
+    } | {
+        FuncCall: PG16.FuncCall;
+    };
+    TypeName(node: PG15.TypeName, context: TransformerContext): {
+        TypeName: PG16.TypeName;
+    };
+    Alias(node: PG15.Alias, context: TransformerContext): {
+        Alias: PG16.Alias;
+    };
+    RangeVar(node: PG15.RangeVar, context: TransformerContext): {
+        RangeVar: PG16.RangeVar;
+    } | {
+        RangeFunction: PG16.RangeFunction;
+    };
+    A_ArrayExpr(node: PG15.A_ArrayExpr, context: TransformerContext): {
+        A_ArrayExpr: PG16.A_ArrayExpr;
+    };
+    A_Indices(node: PG15.A_Indices, context: TransformerContext): {
+        A_Indices: PG16.A_Indices;
+    };
+    A_Indirection(node: PG15.A_Indirection, context: TransformerContext): {
+        A_Indirection: PG16.A_Indirection;
+    };
+    A_Star(node: PG15.A_Star, context: TransformerContext): {
+        A_Star: PG16.A_Star;
+    };
+    CaseExpr(node: PG15.CaseExpr, context: TransformerContext): {
+        CaseExpr: PG16.CaseExpr;
+    };
+    CoalesceExpr(node: PG15.CoalesceExpr, context: TransformerContext): {
+        CoalesceExpr: PG16.CoalesceExpr;
+    };
+    TypeCast(node: PG15.TypeCast, context: TransformerContext): {
+        TypeCast: PG16.TypeCast;
+    };
+    CollateClause(node: PG15.CollateClause, context: TransformerContext): {
+        CollateClause: PG16.CollateClause;
+    };
+    BooleanTest(node: PG15.BooleanTest, context: TransformerContext): {
+        BooleanTest: PG16.BooleanTest;
+    };
+    NullTest(node: PG15.NullTest, context: TransformerContext): {
+        NullTest: PG16.NullTest;
+    };
+    String(node: PG15.String, context: TransformerContext): {
+        String: PG16.String;
+    };
+    Integer(node: PG15.Integer, context: TransformerContext): {
+        Integer: PG16.Integer;
+    };
+    Float(node: PG15.Float, context: TransformerContext): {
+        Float: PG16.Float;
+    };
+    Boolean(node: PG15.Boolean, context: TransformerContext): {
+        Boolean: PG16.Boolean;
+    };
+    BitString(node: PG15.BitString, context: TransformerContext): {
+        BitString: PG16.BitString;
+    };
+    Null(node: PG15.Node, context: TransformerContext): {
+        Null: {};
+    };
+    List(node: PG15.List, context: TransformerContext): {
+        List: PG16.List;
+    };
+    CreateStmt(node: PG15.CreateStmt, context: TransformerContext): {
+        CreateStmt: PG16.CreateStmt;
+    };
+    ColumnDef(node: PG15.ColumnDef, context: TransformerContext): {
+        ColumnDef: PG16.ColumnDef;
+    };
+    Constraint(node: PG15.Constraint, context: TransformerContext): {
+        Constraint: PG16.Constraint;
+    };
+    SubLink(node: PG15.SubLink, context: TransformerContext): {
+        SubLink: PG16.SubLink;
+    };
+    CaseWhen(node: PG15.CaseWhen, context: TransformerContext): {
+        CaseWhen: PG16.CaseWhen;
+    };
+    WindowDef(node: PG15.WindowDef, context: TransformerContext): {
+        WindowDef: PG16.WindowDef;
+    };
+    SortBy(node: PG15.SortBy, context: TransformerContext): {
+        SortBy: PG16.SortBy;
+    };
+    GroupingSet(node: PG15.GroupingSet, context: TransformerContext): {
+        GroupingSet: PG16.GroupingSet;
+    };
+    CommonTableExpr(node: PG15.CommonTableExpr, context: TransformerContext): {
+        CommonTableExpr: PG16.CommonTableExpr;
+    };
+    ParamRef(node: PG15.ParamRef, context: TransformerContext): {
+        ParamRef: PG16.ParamRef;
+    };
+    LockingClause(node: PG15.LockingClause, context: TransformerContext): {
+        LockingClause: PG16.LockingClause;
+    };
+    MinMaxExpr(node: PG15.MinMaxExpr, context: TransformerContext): {
+        MinMaxExpr: PG16.MinMaxExpr;
+    };
+    RowExpr(node: PG15.RowExpr, context: TransformerContext): {
+        RowExpr: PG16.RowExpr;
+    };
+    OpExpr(node: PG15.OpExpr, context: TransformerContext): {
+        OpExpr: PG16.OpExpr;
+    };
+    DistinctExpr(node: PG15.DistinctExpr, context: TransformerContext): {
+        DistinctExpr: PG16.DistinctExpr;
+    };
+    NullIfExpr(node: PG15.NullIfExpr, context: TransformerContext): {
+        NullIfExpr: PG16.NullIfExpr;
+    };
+    ScalarArrayOpExpr(node: PG15.ScalarArrayOpExpr, context: TransformerContext): {
+        ScalarArrayOpExpr: PG16.ScalarArrayOpExpr;
+    };
+    Aggref(node: PG15.Aggref, context: TransformerContext): {
+        Aggref: PG16.Aggref;
+    };
+    WindowFunc(node: PG15.WindowFunc, context: TransformerContext): {
+        WindowFunc: PG16.WindowFunc;
+    };
+    FieldSelect(node: PG15.FieldSelect, context: TransformerContext): {
+        FieldSelect: PG16.FieldSelect;
+    };
+    RelabelType(node: PG15.RelabelType, context: TransformerContext): {
+        RelabelType: PG16.RelabelType;
+    };
+    CoerceViaIO(node: PG15.CoerceViaIO, context: TransformerContext): {
+        CoerceViaIO: PG16.CoerceViaIO;
+    };
+    ArrayCoerceExpr(node: PG15.ArrayCoerceExpr, context: TransformerContext): {
+        ArrayCoerceExpr: PG16.ArrayCoerceExpr;
+    };
+    ConvertRowtypeExpr(node: PG15.ConvertRowtypeExpr, context: TransformerContext): {
+        ConvertRowtypeExpr: PG16.ConvertRowtypeExpr;
+    };
+    NamedArgExpr(node: PG15.NamedArgExpr, context: TransformerContext): {
+        NamedArgExpr: PG16.NamedArgExpr;
+    };
+    ViewStmt(node: PG15.ViewStmt, context: TransformerContext): {
+        ViewStmt: PG16.ViewStmt;
+    };
+    IndexStmt(node: PG15.IndexStmt, context: TransformerContext): {
+        IndexStmt: PG16.IndexStmt;
+    };
+    IndexElem(node: PG15.IndexElem, context: TransformerContext): {
+        IndexElem: PG16.IndexElem;
+    };
+    PartitionElem(node: PG15.PartitionElem, context: TransformerContext): {
+        PartitionElem: PG16.PartitionElem;
+    };
+    PartitionCmd(node: PG15.PartitionCmd, context: TransformerContext): {
+        PartitionCmd: PG16.PartitionCmd;
+    };
+    JoinExpr(node: PG15.JoinExpr, context: TransformerContext): {
+        JoinExpr: PG16.JoinExpr;
+    };
+    FromExpr(node: PG15.FromExpr, context: TransformerContext): {
+        FromExpr: PG16.FromExpr;
+    };
+    TransactionStmt(node: PG15.TransactionStmt, context: TransformerContext): {
+        TransactionStmt: PG16.TransactionStmt;
+    };
+    VariableSetStmt(node: PG15.VariableSetStmt, context: TransformerContext): {
+        VariableSetStmt: PG16.VariableSetStmt;
+    };
+    VariableShowStmt(node: PG15.VariableShowStmt, context: TransformerContext): {
+        VariableShowStmt: PG16.VariableShowStmt;
+    };
+    CreateSchemaStmt(node: PG15.CreateSchemaStmt, context: TransformerContext): {
+        CreateSchemaStmt: PG16.CreateSchemaStmt;
+    };
+    RoleSpec(node: PG15.RoleSpec, context: TransformerContext): {
+        RoleSpec: PG16.RoleSpec;
+    };
+    DropStmt(node: PG15.DropStmt, context: TransformerContext): {
+        DropStmt: PG16.DropStmt;
+    };
+    TruncateStmt(node: PG15.TruncateStmt, context: TransformerContext): {
+        TruncateStmt: PG16.TruncateStmt;
+    };
+    ReturnStmt(node: PG15.ReturnStmt, context: TransformerContext): {
+        ReturnStmt: PG16.ReturnStmt;
+    };
+    PLAssignStmt(node: PG15.PLAssignStmt, context: TransformerContext): {
+        PLAssignStmt: PG16.PLAssignStmt;
+    };
+    CopyStmt(node: PG15.CopyStmt, context: TransformerContext): {
+        CopyStmt: PG16.CopyStmt;
+    };
+    AlterTableStmt(node: PG15.AlterTableStmt, context: TransformerContext): {
+        AlterTableStmt: PG16.AlterTableStmt;
+    };
+    AlterTableCmd(node: PG15.AlterTableCmd, context: TransformerContext): {
+        AlterTableCmd: PG16.AlterTableCmd;
+    };
+    CreateFunctionStmt(node: PG15.CreateFunctionStmt, context: TransformerContext): {
+        CreateFunctionStmt: PG16.CreateFunctionStmt;
+    };
+    FunctionParameter(node: PG15.FunctionParameter, context: TransformerContext): {
+        FunctionParameter: PG16.FunctionParameter;
+    };
+    CompositeTypeStmt(node: PG15.CompositeTypeStmt, context: TransformerContext): {
+        CompositeTypeStmt: PG16.CompositeTypeStmt;
+    };
+    DoStmt(node: PG15.DoStmt, context: TransformerContext): {
+        DoStmt: PG16.DoStmt;
+    };
+    DefineStmt(node: PG15.DefineStmt, context: TransformerContext): {
+        DefineStmt: PG16.DefineStmt;
+    };
+    RangeSubselect(node: PG15.RangeSubselect, context: TransformerContext): {
+        RangeSubselect: PG16.RangeSubselect;
+    };
+    CreateEnumStmt(node: PG15.CreateEnumStmt, context: TransformerContext): {
+        CreateEnumStmt: PG16.CreateEnumStmt;
+    };
+    CreateDomainStmt(node: PG15.CreateDomainStmt, context: TransformerContext): {
+        CreateDomainStmt: PG16.CreateDomainStmt;
+    };
+    CreateRoleStmt(node: PG15.CreateRoleStmt, context: TransformerContext): {
+        CreateRoleStmt: PG16.CreateRoleStmt;
+    };
+    DefElem(node: PG15.DefElem, context: TransformerContext): {
+        DefElem: PG16.DefElem;
+    };
+    CreateTableSpaceStmt(node: PG15.CreateTableSpaceStmt, context: TransformerContext): {
+        CreateTableSpaceStmt: PG16.CreateTableSpaceStmt;
+    };
+    DropTableSpaceStmt(node: PG15.DropTableSpaceStmt, context: TransformerContext): {
+        DropTableSpaceStmt: PG16.DropTableSpaceStmt;
+    };
+    AlterTableSpaceOptionsStmt(node: PG15.AlterTableSpaceOptionsStmt, context: TransformerContext): {
+        AlterTableSpaceOptionsStmt: PG16.AlterTableSpaceOptionsStmt;
+    };
+    CreateExtensionStmt(node: PG15.CreateExtensionStmt, context: TransformerContext): {
+        CreateExtensionStmt: PG16.CreateExtensionStmt;
+    };
+    AlterExtensionStmt(node: PG15.AlterExtensionStmt, context: TransformerContext): {
+        AlterExtensionStmt: PG16.AlterExtensionStmt;
+    };
+    CreateFdwStmt(node: PG15.CreateFdwStmt, context: TransformerContext): {
+        CreateFdwStmt: PG16.CreateFdwStmt;
+    };
+    SetOperationStmt(node: PG15.SetOperationStmt, context: TransformerContext): {
+        SetOperationStmt: PG16.SetOperationStmt;
+    };
+    ReplicaIdentityStmt(node: PG15.ReplicaIdentityStmt, context: TransformerContext): {
+        ReplicaIdentityStmt: PG16.ReplicaIdentityStmt;
+    };
+    AlterCollationStmt(node: PG15.AlterCollationStmt, context: TransformerContext): {
+        AlterCollationStmt: PG16.AlterCollationStmt;
+    };
+    AlterDomainStmt(node: PG15.AlterDomainStmt, context: TransformerContext): {
+        AlterDomainStmt: PG16.AlterDomainStmt;
+    };
+    PrepareStmt(node: PG15.PrepareStmt, context: TransformerContext): {
+        PrepareStmt: PG16.PrepareStmt;
+    };
+    ExecuteStmt(node: PG15.ExecuteStmt, context: TransformerContext): {
+        ExecuteStmt: PG16.ExecuteStmt;
+    };
+    DeallocateStmt(node: PG15.DeallocateStmt, context: TransformerContext): {
+        DeallocateStmt: PG16.DeallocateStmt;
+    };
+    NotifyStmt(node: PG15.NotifyStmt, context: TransformerContext): {
+        NotifyStmt: PG16.NotifyStmt;
+    };
+    ListenStmt(node: PG15.ListenStmt, context: TransformerContext): {
+        ListenStmt: PG16.ListenStmt;
+    };
+    UnlistenStmt(node: PG15.UnlistenStmt, context: TransformerContext): {
+        UnlistenStmt: PG16.UnlistenStmt;
+    };
+    CheckPointStmt(node: PG15.CheckPointStmt, context: TransformerContext): {
+        CheckPointStmt: PG16.CheckPointStmt;
+    };
+    LoadStmt(node: PG15.LoadStmt, context: TransformerContext): {
+        LoadStmt: PG16.LoadStmt;
+    };
+    DiscardStmt(node: PG15.DiscardStmt, context: TransformerContext): {
+        DiscardStmt: PG16.DiscardStmt;
+    };
+    CommentStmt(node: PG15.CommentStmt, context: TransformerContext): {
+        CommentStmt: PG16.CommentStmt;
+    };
+    LockStmt(node: PG15.LockStmt, context: TransformerContext): {
+        LockStmt: PG16.LockStmt;
+    };
+    CreatePolicyStmt(node: PG15.CreatePolicyStmt, context: TransformerContext): {
+        CreatePolicyStmt: PG16.CreatePolicyStmt;
+    };
+    AlterPolicyStmt(node: PG15.AlterPolicyStmt, context: TransformerContext): {
+        AlterPolicyStmt: PG16.AlterPolicyStmt;
+    };
+    CreateUserMappingStmt(node: PG15.CreateUserMappingStmt, context: TransformerContext): {
+        CreateUserMappingStmt: PG16.CreateUserMappingStmt;
+    };
+    CreateStatsStmt(node: PG15.CreateStatsStmt, context: TransformerContext): {
+        CreateStatsStmt: PG16.CreateStatsStmt;
+    };
+    StatsElem(node: PG15.StatsElem, context: TransformerContext): {
+        StatsElem: PG16.StatsElem;
+    };
+    CreatePublicationStmt(node: PG15.CreatePublicationStmt, context: TransformerContext): {
+        CreatePublicationStmt: PG16.CreatePublicationStmt;
+    };
+    CreateSubscriptionStmt(node: PG15.CreateSubscriptionStmt, context: TransformerContext): {
+        CreateSubscriptionStmt: PG16.CreateSubscriptionStmt;
+    };
+    AlterPublicationStmt(node: PG15.AlterPublicationStmt, context: TransformerContext): {
+        AlterPublicationStmt: PG16.AlterPublicationStmt;
+    };
+    AlterSubscriptionStmt(node: PG15.AlterSubscriptionStmt, context: TransformerContext): {
+        AlterSubscriptionStmt: PG16.AlterSubscriptionStmt;
+    };
+    DropSubscriptionStmt(node: PG15.DropSubscriptionStmt, context: TransformerContext): {
+        DropSubscriptionStmt: PG16.DropSubscriptionStmt;
+    };
+    InlineCodeBlock(node: PG15.InlineCodeBlock, context: TransformerContext): {
+        InlineCodeBlock: PG16.InlineCodeBlock;
+    };
+    CallContext(node: PG15.CallContext, context: TransformerContext): {
+        CallContext: PG16.CallContext;
+    };
+    ConstraintsSetStmt(node: PG15.ConstraintsSetStmt, context: TransformerContext): {
+        ConstraintsSetStmt: PG16.ConstraintsSetStmt;
+    };
+    AlterSystemStmt(node: PG15.AlterSystemStmt, context: TransformerContext): {
+        AlterSystemStmt: PG16.AlterSystemStmt;
+    };
+    VacuumRelation(node: PG15.VacuumRelation, context: TransformerContext): {
+        VacuumRelation: PG16.VacuumRelation;
+    };
+    DropOwnedStmt(node: PG15.DropOwnedStmt, context: TransformerContext): {
+        DropOwnedStmt: PG16.DropOwnedStmt;
+    };
+    ReassignOwnedStmt(node: PG15.ReassignOwnedStmt, context: TransformerContext): {
+        ReassignOwnedStmt: PG16.ReassignOwnedStmt;
+    };
+    AlterTSDictionaryStmt(node: PG15.AlterTSDictionaryStmt, context: TransformerContext): {
+        AlterTSDictionaryStmt: PG16.AlterTSDictionaryStmt;
+    };
+    AlterTSConfigurationStmt(node: PG15.AlterTSConfigurationStmt, context: TransformerContext): {
+        AlterTSConfigurationStmt: PG16.AlterTSConfigurationStmt;
+    };
+    ClosePortalStmt(node: PG15.ClosePortalStmt, context: TransformerContext): {
+        ClosePortalStmt: PG16.ClosePortalStmt;
+    };
+    FetchStmt(node: PG15.FetchStmt, context: TransformerContext): {
+        FetchStmt: PG16.FetchStmt;
+    };
+    AlterStatsStmt(node: PG15.AlterStatsStmt, context: TransformerContext): {
+        AlterStatsStmt: PG16.AlterStatsStmt;
+    };
+    ObjectWithArgs(node: PG15.ObjectWithArgs, context: TransformerContext): {
+        ObjectWithArgs: PG16.ObjectWithArgs;
+    };
+    AlterOperatorStmt(node: PG15.AlterOperatorStmt, context: TransformerContext): {
+        AlterOperatorStmt: PG16.AlterOperatorStmt;
+    };
+    AlterFdwStmt(node: PG15.AlterFdwStmt, context: TransformerContext): {
+        AlterFdwStmt: PG16.AlterFdwStmt;
+    };
+    CreateForeignServerStmt(node: PG15.CreateForeignServerStmt, context: TransformerContext): {
+        CreateForeignServerStmt: PG16.CreateForeignServerStmt;
+    };
+    AlterForeignServerStmt(node: PG15.AlterForeignServerStmt, context: TransformerContext): {
+        AlterForeignServerStmt: PG16.AlterForeignServerStmt;
+    };
+    AlterUserMappingStmt(node: PG15.AlterUserMappingStmt, context: TransformerContext): {
+        AlterUserMappingStmt: PG16.AlterUserMappingStmt;
+    };
+    DropUserMappingStmt(node: PG15.DropUserMappingStmt, context: TransformerContext): {
+        DropUserMappingStmt: PG16.DropUserMappingStmt;
+    };
+    ImportForeignSchemaStmt(node: PG15.ImportForeignSchemaStmt, context: TransformerContext): {
+        ImportForeignSchemaStmt: PG16.ImportForeignSchemaStmt;
+    };
+    ClusterStmt(node: PG15.ClusterStmt, context: TransformerContext): {
+        ClusterStmt: PG16.ClusterStmt;
+    };
+    VacuumStmt(node: PG15.VacuumStmt, context: TransformerContext): {
+        VacuumStmt: PG16.VacuumStmt;
+    };
+    ExplainStmt(node: PG15.ExplainStmt, context: TransformerContext): {
+        ExplainStmt: PG16.ExplainStmt;
+    };
+    ReindexStmt(node: PG15.ReindexStmt, context: TransformerContext): {
+        ReindexStmt: PG16.ReindexStmt;
+    };
+    CallStmt(node: PG15.CallStmt, context: TransformerContext): {
+        CallStmt: PG16.CallStmt;
+    };
+    CreatedbStmt(node: PG15.CreatedbStmt, context: TransformerContext): {
+        CreatedbStmt: PG16.CreatedbStmt;
+    };
+    DropdbStmt(node: PG15.DropdbStmt, context: TransformerContext): {
+        DropdbStmt: PG16.DropdbStmt;
+    };
+    RenameStmt(node: PG15.RenameStmt, context: TransformerContext): {
+        RenameStmt: PG16.RenameStmt;
+    };
+    AlterOwnerStmt(node: PG15.AlterOwnerStmt, context: TransformerContext): {
+        AlterOwnerStmt: PG16.AlterOwnerStmt;
+    };
+    GrantRoleStmt(node: PG15.GrantRoleStmt, context: TransformerContext): {
+        GrantRoleStmt: PG16.GrantRoleStmt;
+    };
+    SecLabelStmt(node: PG15.SecLabelStmt, context: TransformerContext): {
+        SecLabelStmt: PG16.SecLabelStmt;
+    };
+    AlterDefaultPrivilegesStmt(node: PG15.AlterDefaultPrivilegesStmt, context: TransformerContext): {
+        AlterDefaultPrivilegesStmt: PG16.AlterDefaultPrivilegesStmt;
+    };
+    CreateConversionStmt(node: PG15.CreateConversionStmt, context: TransformerContext): {
+        CreateConversionStmt: PG16.CreateConversionStmt;
+    };
+    CreateCastStmt(node: PG15.CreateCastStmt, context: TransformerContext): {
+        CreateCastStmt: PG16.CreateCastStmt;
+    };
+    CreatePLangStmt(node: PG15.CreatePLangStmt, context: TransformerContext): {
+        CreatePLangStmt: PG16.CreatePLangStmt;
+    };
+    CreateTransformStmt(node: PG15.CreateTransformStmt, context: TransformerContext): {
+        CreateTransformStmt: PG16.CreateTransformStmt;
+    };
+    CreateTrigStmt(node: PG15.CreateTrigStmt, context: TransformerContext): {
+        CreateTrigStmt: PG16.CreateTrigStmt;
+    };
+    TriggerTransition(node: PG15.TriggerTransition, context: TransformerContext): {
+        TriggerTransition: PG16.TriggerTransition;
+    };
+    CreateEventTrigStmt(node: PG15.CreateEventTrigStmt, context: TransformerContext): {
+        CreateEventTrigStmt: PG16.CreateEventTrigStmt;
+    };
+    AlterEventTrigStmt(node: PG15.AlterEventTrigStmt, context: TransformerContext): {
+        AlterEventTrigStmt: PG16.AlterEventTrigStmt;
+    };
+    CreateOpClassStmt(node: PG15.CreateOpClassStmt, context: TransformerContext): {
+        CreateOpClassStmt: PG16.CreateOpClassStmt;
+    };
+    CreateOpFamilyStmt(node: PG15.CreateOpFamilyStmt, context: TransformerContext): {
+        CreateOpFamilyStmt: PG16.CreateOpFamilyStmt;
+    };
+    AlterOpFamilyStmt(node: PG15.AlterOpFamilyStmt, context: TransformerContext): {
+        AlterOpFamilyStmt: PG16.AlterOpFamilyStmt;
+    };
+    MergeStmt(node: PG15.MergeStmt, context: TransformerContext): {
+        MergeStmt: PG16.MergeStmt;
+    };
+    AlterTableMoveAllStmt(node: PG15.AlterTableMoveAllStmt, context: TransformerContext): {
+        AlterTableMoveAllStmt: PG16.AlterTableMoveAllStmt;
+    };
+    CreateSeqStmt(node: PG15.CreateSeqStmt, context: TransformerContext): {
+        CreateSeqStmt: PG16.CreateSeqStmt;
+    };
+    AlterSeqStmt(node: PG15.AlterSeqStmt, context: TransformerContext): {
+        AlterSeqStmt: PG16.AlterSeqStmt;
+    };
+    CreateRangeStmt(node: PG15.CreateRangeStmt, context: TransformerContext): {
+        CreateRangeStmt: PG16.CreateRangeStmt;
+    };
+    AlterEnumStmt(node: PG15.AlterEnumStmt, context: TransformerContext): {
+        AlterEnumStmt: PG16.AlterEnumStmt;
+    };
+    AlterTypeStmt(node: PG15.AlterTypeStmt, context: TransformerContext): {
+        AlterTypeStmt: PG16.AlterTypeStmt;
+    };
+    AlterRoleStmt(node: PG15.AlterRoleStmt, context: TransformerContext): {
+        AlterRoleStmt: PG16.AlterRoleStmt;
+    };
+    CreateTableAsStmt(node: PG15.CreateTableAsStmt, context: TransformerContext): {
+        CreateTableAsStmt: PG16.CreateTableAsStmt;
+    };
+    RefreshMatViewStmt(node: PG15.RefreshMatViewStmt, context: TransformerContext): {
+        RefreshMatViewStmt: PG16.RefreshMatViewStmt;
+    };
+    AccessPriv(node: PG15.AccessPriv, context: TransformerContext): {
+        AccessPriv: PG16.AccessPriv;
+    };
+    AlterDatabaseStmt(node: PG15.AlterDatabaseStmt, context: TransformerContext): {
+        AlterDatabaseStmt: PG16.AlterDatabaseStmt;
+    };
+    AlterDatabaseRefreshCollStmt(node: PG15.AlterDatabaseRefreshCollStmt, context: TransformerContext): {
+        AlterDatabaseRefreshCollStmt: PG16.AlterDatabaseRefreshCollStmt;
+    };
+    AlterDatabaseSetStmt(node: PG15.AlterDatabaseSetStmt, context: TransformerContext): {
+        AlterDatabaseSetStmt: PG16.AlterDatabaseSetStmt;
+    };
+    DeclareCursorStmt(node: PG15.DeclareCursorStmt, context: TransformerContext): {
+        DeclareCursorStmt: PG16.DeclareCursorStmt;
+    };
+    PublicationObjSpec(node: PG15.PublicationObjSpec, context: TransformerContext): {
+        PublicationObjSpec: PG16.PublicationObjSpec;
+    };
+    PublicationTable(node: PG15.PublicationTable, context: TransformerContext): {
+        PublicationTable: PG16.PublicationTable;
+    };
+    CreateAmStmt(node: PG15.CreateAmStmt, context: TransformerContext): {
+        CreateAmStmt: PG16.CreateAmStmt;
+    };
+    IntoClause(node: PG15.IntoClause, context: TransformerContext): {
+        IntoClause: PG16.IntoClause;
+    };
+    OnConflictExpr(node: PG15.OnConflictExpr, context: TransformerContext): {
+        OnConflictExpr: PG16.OnConflictExpr;
+    };
+    ScanToken(node: PG15.ScanToken, context: TransformerContext): {
+        ScanToken: PG16.ScanToken;
+    };
+    CreateOpClassItem(node: PG15.CreateOpClassItem, context: TransformerContext): {
+        CreateOpClassItem: PG16.CreateOpClassItem;
+    };
+    Var(node: PG15.Var, context: TransformerContext): {
+        Var: PG16.Var;
+    };
+    TableFunc(node: PG15.TableFunc, context: TransformerContext): {
+        TableFunc: PG16.TableFunc;
+    };
+    RangeTableFunc(node: PG15.RangeTableFunc, context: TransformerContext): {
+        RangeTableFunc: PG16.RangeTableFunc;
+    };
+    RangeTableFuncCol(node: PG15.RangeTableFuncCol, context: TransformerContext): {
+        RangeTableFuncCol: PG16.RangeTableFuncCol;
+    };
+    RangeFunction(node: PG15.RangeFunction, context: TransformerContext): {
+        RangeFunction: PG16.RangeFunction;
+    };
+    RangeTableSample(node: PG15.RangeTableSample, context: TransformerContext): {
+        RangeTableSample: PG16.RangeTableSample;
+    };
+    XmlSerialize(node: PG15.XmlSerialize, context: TransformerContext): {
+        XmlSerialize: PG16.XmlSerialize;
+    };
+    RuleStmt(node: PG15.RuleStmt, context: TransformerContext): {
+        RuleStmt: PG16.RuleStmt;
+    };
+    SQLValueFunction(node: PG15.SQLValueFunction, context: TransformerContext): {
+        SQLValueFunction: PG16.SQLValueFunction;
+    };
+    GroupingFunc(node: PG15.GroupingFunc, context: TransformerContext): {
+        GroupingFunc: PG16.GroupingFunc;
+    };
+    MultiAssignRef(node: PG15.MultiAssignRef, context: TransformerContext): {
+        MultiAssignRef: PG16.MultiAssignRef;
+    };
+    SetToDefault(node: PG15.SetToDefault, context: TransformerContext): {
+        SetToDefault: PG16.SetToDefault;
+    };
+    CurrentOfExpr(node: PG15.CurrentOfExpr, context: TransformerContext): {
+        CurrentOfExpr: PG16.CurrentOfExpr;
+    };
+    TableLikeClause(node: PG15.TableLikeClause, context: TransformerContext): {
+        TableLikeClause: PG16.TableLikeClause;
+    };
+    AlterFunctionStmt(node: PG15.AlterFunctionStmt, context: TransformerContext): {
+        AlterFunctionStmt: PG16.AlterFunctionStmt;
+    };
+    AlterObjectSchemaStmt(node: PG15.AlterObjectSchemaStmt, context: TransformerContext): {
+        AlterObjectSchemaStmt: PG16.AlterObjectSchemaStmt;
+    };
+    CreateForeignTableStmt(node: PG15.CreateForeignTableStmt, context: TransformerContext): {
+        CreateForeignTableStmt: PG16.CreateForeignTableStmt;
+    };
+    DropRoleStmt(node: PG15.DropRoleStmt, context: TransformerContext): {
+        DropRoleStmt: PG16.DropRoleStmt;
+    };
+    XmlExpr(node: PG15.XmlExpr, context: TransformerContext): {
+        XmlExpr: PG16.XmlExpr;
+    };
+    AlterRoleSetStmt(node: PG15.AlterRoleSetStmt, context: TransformerContext): {
+        AlterRoleSetStmt: PG16.AlterRoleSetStmt;
+    };
+    GrantStmt(node: PG15.GrantStmt, context: TransformerContext): {
+        GrantStmt: PG16.GrantStmt;
+    };
+}