diff --git a/gstreamer/src/event.rs b/gstreamer/src/event.rs
index b295c0139..e4e30d290 100644
--- a/gstreamer/src/event.rs
+++ b/gstreamer/src/event.rs
@@ -81,22 +81,27 @@ impl GroupId {
 }
 
 impl EventType {
+    #[doc(alias = "GST_EVENT_IS_UPSTREAM")]
     pub fn is_upstream(self) -> bool {
         (self.into_glib() as u32) & ffi::GST_EVENT_TYPE_UPSTREAM != 0
     }
 
+    #[doc(alias = "GST_EVENT_IS_DOWNSTREAM")]
     pub fn is_downstream(self) -> bool {
         (self.into_glib() as u32) & ffi::GST_EVENT_TYPE_DOWNSTREAM != 0
     }
 
+    #[doc(alias = "GST_EVENT_IS_SERIALIZED")]
     pub fn is_serialized(self) -> bool {
         (self.into_glib() as u32) & ffi::GST_EVENT_TYPE_SERIALIZED != 0
     }
 
+    #[doc(alias = "GST_EVENT_IS_STICKY")]
     pub fn is_sticky(self) -> bool {
         (self.into_glib() as u32) & ffi::GST_EVENT_TYPE_STICKY != 0
     }
 
+    #[doc(alias = "GST_EVENT_IS_STICKY_MULTI")]
     pub fn is_sticky_multi(self) -> bool {
         (self.into_glib() as u32) & ffi::GST_EVENT_TYPE_STICKY_MULTI != 0
     }
@@ -173,33 +178,40 @@ impl EventRef {
         }
     }
 
+    #[doc(alias = "gst_event_writable_structure")]
     pub fn structure_mut(&mut self) -> &mut StructureRef {
         unsafe {
             StructureRef::from_glib_borrow_mut(ffi::gst_event_writable_structure(self.as_mut_ptr()))
         }
     }
 
+    #[doc(alias = "GST_EVENT_IS_UPSTREAM")]
     pub fn is_upstream(&self) -> bool {
         self.type_().is_upstream()
     }
 
+    #[doc(alias = "GST_EVENT_IS_DOWNSTREAM")]
     pub fn is_downstream(&self) -> bool {
         self.type_().is_downstream()
     }
 
+    #[doc(alias = "GST_EVENT_IS_SERIALIZED")]
     pub fn is_serialized(&self) -> bool {
         self.type_().is_serialized()
     }
 
+    #[doc(alias = "GST_EVENT_IS_STICKY")]
     pub fn is_sticky(&self) -> bool {
         self.type_().is_sticky()
     }
 
+    #[doc(alias = "GST_EVENT_IS_STICKY_MULTI")]
     pub fn is_sticky_multi(&self) -> bool {
         self.type_().is_sticky_multi()
     }
 
     #[doc(alias = "get_type")]
+    #[doc(alias = "GST_EVENT_TYPE")]
     pub fn type_(&self) -> EventType {
         unsafe { from_glib((*self.as_ptr()).type_) }
     }
@@ -398,6 +410,7 @@ macro_rules! declare_concrete_event {
 
 declare_concrete_event!(FlushStart, T);
 impl FlushStart<Event> {
+    #[doc(alias = "gst_event_new_flush_start")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new() -> Event {
         skip_assert_initialized!();
@@ -412,6 +425,7 @@ impl FlushStart<Event> {
 
 declare_concrete_event!(FlushStop, T);
 impl FlushStop<Event> {
+    #[doc(alias = "gst_event_new_flush_stop")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(reset_time: bool) -> Event {
         skip_assert_initialized!();
@@ -426,6 +440,7 @@ impl FlushStop<Event> {
 
 impl<T: AsPtr> FlushStop<T> {
     #[doc(alias = "get_reset_time")]
+    #[doc(alias = "gst_event_parse_flush_stop")]
     pub fn resets_time(&self) -> bool {
         unsafe {
             let mut reset_time = mem::MaybeUninit::uninit();
@@ -439,6 +454,7 @@ impl<T: AsPtr> FlushStop<T> {
 
 declare_concrete_event!(@sticky StreamStart, T);
 impl StreamStart<Event> {
+    #[doc(alias = "gst_event_new_stream_start")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(stream_id: &str) -> Event {
         skip_assert_initialized!();
@@ -453,6 +469,7 @@ impl StreamStart<Event> {
 
 impl<T: AsPtr> StreamStart<T> {
     #[doc(alias = "get_stream_id")]
+    #[doc(alias = "gst_event_parse_stream_start")]
     pub fn stream_id(&self) -> &str {
         unsafe {
             let mut stream_id = ptr::null();
@@ -506,6 +523,7 @@ impl<T: AsPtr> StreamStart<T> {
 
 declare_concrete_event!(@sticky Caps, T);
 impl Caps<Event> {
+    #[doc(alias = "gst_event_new_caps")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(caps: &crate::Caps) -> Event {
         skip_assert_initialized!();
@@ -531,6 +549,7 @@ impl<T: AsPtr> Caps<T> {
     }
 
     #[doc(alias = "get_caps_owned")]
+    #[doc(alias = "gst_event_parse_caps")]
     pub fn caps_owned(&self) -> crate::Caps {
         unsafe { from_glib_none(self.caps().as_ptr()) }
     }
@@ -538,6 +557,7 @@ impl<T: AsPtr> Caps<T> {
 
 declare_concrete_event!(@sticky Segment, T);
 impl Segment<Event> {
+    #[doc(alias = "gst_event_new_segment")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new<F: crate::FormattedValueIntrinsic>(segment: &crate::FormattedSegment<F>) -> Event {
         skip_assert_initialized!();
@@ -573,6 +593,7 @@ declare_concrete_event!(@sticky StreamCollection, T);
 impl StreamCollection<Event> {
     #[cfg(any(feature = "v1_10", feature = "dox"))]
     #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
+    #[doc(alias = "gst_event_new_stream_collection")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(stream_collection: &crate::StreamCollection) -> Event {
         skip_assert_initialized!();
@@ -606,6 +627,7 @@ impl<T: AsPtr> StreamCollection<T> {
 
 declare_concrete_event!(@sticky Tag, T);
 impl Tag<Event> {
+    #[doc(alias = "gst_event_new_tag")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(tags: crate::TagList) -> Event {
         skip_assert_initialized!();
@@ -631,6 +653,7 @@ impl<T: AsPtr> Tag<T> {
     }
 
     #[doc(alias = "get_tag_owned")]
+    #[doc(alias = "gst_event_parse_tag")]
     pub fn tag_owned(&self) -> crate::TagList {
         unsafe { from_glib_none(self.tag().as_ptr()) }
     }
@@ -638,6 +661,7 @@ impl<T: AsPtr> Tag<T> {
 
 declare_concrete_event!(@sticky Buffersize, T);
 impl Buffersize<Event> {
+    #[doc(alias = "gst_event_new_buffer_size")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new<V: Into<GenericFormattedValue>>(minsize: V, maxsize: V, r#async: bool) -> Event {
         skip_assert_initialized!();
@@ -659,6 +683,7 @@ impl Buffersize<Event> {
 }
 
 impl<T: AsPtr> Buffersize<T> {
+    #[doc(alias = "gst_event_parse_buffer_size")]
     pub fn get(&self) -> (GenericFormattedValue, GenericFormattedValue, bool) {
         unsafe {
             let mut fmt = mem::MaybeUninit::uninit();
@@ -684,6 +709,7 @@ impl<T: AsPtr> Buffersize<T> {
 
 declare_concrete_event!(@sticky SinkMessage, T);
 impl SinkMessage<Event> {
+    #[doc(alias = "gst_event_new_sink_message")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(name: &str, msg: &crate::Message) -> Event {
         skip_assert_initialized!();
@@ -717,6 +743,7 @@ declare_concrete_event!(@sticky StreamGroupDone, T);
 impl StreamGroupDone<Event> {
     #[cfg(any(feature = "v1_10", feature = "dox"))]
     #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
+    #[doc(alias = "gst_event_new_stream_group_done")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(group_id: GroupId) -> Event {
         skip_assert_initialized!();
@@ -737,6 +764,7 @@ impl<T: AsPtr> StreamGroupDone<T> {
     #[cfg(any(feature = "v1_10", feature = "dox"))]
     #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
     #[doc(alias = "get_group_id")]
+    #[doc(alias = "gst_event_parse_stream_group_done")]
     pub fn group_id(&self) -> GroupId {
         unsafe {
             let mut group_id = mem::MaybeUninit::uninit();
@@ -752,6 +780,7 @@ impl<T: AsPtr> StreamGroupDone<T> {
 
 declare_concrete_event!(@sticky Eos, T);
 impl Eos<Event> {
+    #[doc(alias = "gst_event_new_eos")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new() -> Event {
         skip_assert_initialized!();
@@ -768,6 +797,7 @@ declare_concrete_event!(@sticky Toc, T);
 impl Toc<Event> {
     // FIXME could use false for updated as default
     // Even better: use an enum for updated so that it is more explicit than true / false
+    #[doc(alias = "gst_event_new_toc")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(toc: &crate::Toc, updated: bool) -> Event {
         skip_assert_initialized!();
@@ -797,6 +827,7 @@ impl<T: AsPtr> Toc<T> {
     }
 
     #[doc(alias = "get_toc_owned")]
+    #[doc(alias = "gst_event_parse_toc")]
     pub fn toc_owned(&self) -> (crate::Toc, bool) {
         unsafe {
             let (toc, updated) = self.toc();
@@ -807,6 +838,7 @@ impl<T: AsPtr> Toc<T> {
 
 declare_concrete_event!(@sticky Protection, T);
 impl Protection<Event> {
+    #[doc(alias = "gst_event_new_protection")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(system_id: &str, data: &crate::Buffer) -> Event {
         skip_assert_initialized!();
@@ -820,6 +852,7 @@ impl Protection<Event> {
 }
 
 impl<T: AsPtr> Protection<T> {
+    #[doc(alias = "gst_event_parse_protection")]
     pub fn get(&self) -> (&str, &crate::BufferRef, Option<&str>) {
         unsafe {
             let mut system_id = ptr::null();
@@ -845,6 +878,7 @@ impl<T: AsPtr> Protection<T> {
         }
     }
 
+    #[doc(alias = "gst_event_parse_protection")]
     pub fn get_owned(&self) -> (&str, crate::Buffer, Option<&str>) {
         unsafe {
             let (system_id, buffer, origin) = self.get();
@@ -855,6 +889,7 @@ impl<T: AsPtr> Protection<T> {
 
 declare_concrete_event!(SegmentDone, T);
 impl SegmentDone<Event> {
+    #[doc(alias = "gst_event_new_segment_done")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new<V: Into<GenericFormattedValue>>(position: V) -> Event {
         skip_assert_initialized!();
@@ -869,6 +904,7 @@ impl SegmentDone<Event> {
 }
 
 impl<T: AsPtr> SegmentDone<T> {
+    #[doc(alias = "gst_event_parse_segment_done")]
     pub fn get(&self) -> GenericFormattedValue {
         unsafe {
             let mut fmt = mem::MaybeUninit::uninit();
@@ -887,6 +923,7 @@ impl<T: AsPtr> SegmentDone<T> {
 
 declare_concrete_event!(Gap, T);
 impl Gap<Event> {
+    #[doc(alias = "gst_event_new_gap")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(timestamp: ClockTime, duration: impl Into<Option<ClockTime>>) -> Event {
         skip_assert_initialized!();
@@ -900,6 +937,7 @@ impl Gap<Event> {
 }
 
 impl<T: AsPtr> Gap<T> {
+    #[doc(alias = "gst_event_parse_gap")]
     pub fn get(&self) -> (ClockTime, Option<ClockTime>) {
         unsafe {
             let mut timestamp = mem::MaybeUninit::uninit();
@@ -936,6 +974,7 @@ declare_concrete_event!(@sticky InstantRateChange, T);
 #[cfg(any(feature = "v1_18", feature = "dox"))]
 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
 impl InstantRateChange<Event> {
+    #[doc(alias = "gst_event_new_instant_rate_change")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(multiplier: f64, new_flags: crate::SegmentFlags) -> Event {
         skip_assert_initialized!();
@@ -954,6 +993,7 @@ impl InstantRateChange<Event> {
 #[cfg(any(feature = "v1_18", feature = "dox"))]
 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
 impl<T: AsPtr> InstantRateChange<T> {
+    #[doc(alias = "gst_event_parse_instant_rate_change")]
     pub fn get(&self) -> (f64, crate::SegmentFlags) {
         unsafe {
             let mut multiplier = mem::MaybeUninit::uninit();
@@ -972,6 +1012,7 @@ impl<T: AsPtr> InstantRateChange<T> {
 
 declare_concrete_event!(Qos, T);
 impl Qos<Event> {
+    #[doc(alias = "gst_event_new_qos")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(
         type_: crate::QOSType,
@@ -992,6 +1033,7 @@ impl Qos<Event> {
 }
 
 impl<T: AsPtr> Qos<T> {
+    #[doc(alias = "gst_event_parse_qos")]
     pub fn get(&self) -> (crate::QOSType, f64, i64, Option<ClockTime>) {
         unsafe {
             let mut type_ = mem::MaybeUninit::uninit();
@@ -1019,6 +1061,7 @@ impl<T: AsPtr> Qos<T> {
 
 declare_concrete_event!(Seek, T);
 impl Seek<Event> {
+    #[doc(alias = "gst_event_new_seek")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new<V: Into<GenericFormattedValue>>(
         rate: f64,
@@ -1050,6 +1093,7 @@ impl Seek<Event> {
 }
 
 impl<T: AsPtr> Seek<T> {
+    #[doc(alias = "gst_event_parse_seek")]
     pub fn get(
         &self,
     ) -> (
@@ -1111,6 +1155,7 @@ impl<T: AsPtr> Seek<T> {
 
 declare_concrete_event!(Navigation, T);
 impl Navigation<Event> {
+    #[doc(alias = "gst_event_new_navigation")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(structure: crate::Structure) -> Event {
         skip_assert_initialized!();
@@ -1125,6 +1170,7 @@ impl Navigation<Event> {
 
 declare_concrete_event!(Latency, T);
 impl Latency<Event> {
+    #[doc(alias = "gst_event_new_latency")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(latency: ClockTime) -> Event {
         skip_assert_initialized!();
@@ -1153,6 +1199,7 @@ impl<T: AsPtr> Latency<T> {
 
 declare_concrete_event!(Step, T);
 impl Step<Event> {
+    #[doc(alias = "gst_event_new_step")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new<V: Into<GenericFormattedValue>>(
         amount: V,
@@ -1176,6 +1223,7 @@ impl Step<Event> {
 }
 
 impl<T: AsPtr> Step<T> {
+    #[doc(alias = "gst_event_parse_step")]
     pub fn get(&self) -> (GenericFormattedValue, f64, bool, bool) {
         unsafe {
             let mut fmt = mem::MaybeUninit::uninit();
@@ -1208,6 +1256,7 @@ impl<T: AsPtr> Step<T> {
 
 declare_concrete_event!(Reconfigure, T);
 impl Reconfigure<Event> {
+    #[doc(alias = "gst_event_new_reconfigure")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new() -> Event {
         skip_assert_initialized!();
@@ -1222,6 +1271,7 @@ impl Reconfigure<Event> {
 
 declare_concrete_event!(TocSelect, T);
 impl TocSelect<Event> {
+    #[doc(alias = "gst_event_new_toc_select")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(uid: &str) -> Event {
         skip_assert_initialized!();
@@ -1255,6 +1305,7 @@ declare_concrete_event!(SelectStreams, T);
 impl SelectStreams<Event> {
     #[cfg(any(feature = "v1_10", feature = "dox"))]
     #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
+    #[doc(alias = "gst_event_new_select_streams")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(streams: &[&str]) -> Event {
         skip_assert_initialized!();
@@ -1295,6 +1346,7 @@ declare_concrete_event!(InstantRateSyncTime, T);
 impl InstantRateSyncTime<Event> {
     #[cfg(any(feature = "v1_18", feature = "dox"))]
     #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
+    #[doc(alias = "gst_event_new_instant_rate_sync_time")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(
         rate_multiplier: f64,
@@ -1348,6 +1400,7 @@ impl<T: AsPtr> InstantRateSyncTime<T> {
 
 declare_concrete_event!(CustomUpstream, T);
 impl CustomUpstream<Event> {
+    #[doc(alias = "gst_event_new_custom")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(structure: crate::Structure) -> Event {
         skip_assert_initialized!();
@@ -1362,6 +1415,7 @@ impl CustomUpstream<Event> {
 
 declare_concrete_event!(CustomDownstream, T);
 impl CustomDownstream<Event> {
+    #[doc(alias = "gst_event_new_custom")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(structure: crate::Structure) -> Event {
         skip_assert_initialized!();
@@ -1376,6 +1430,7 @@ impl CustomDownstream<Event> {
 
 declare_concrete_event!(CustomDownstreamOob, T);
 impl CustomDownstreamOob<Event> {
+    #[doc(alias = "gst_event_new_custom")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(structure: crate::Structure) -> Event {
         skip_assert_initialized!();
@@ -1390,6 +1445,7 @@ impl CustomDownstreamOob<Event> {
 
 declare_concrete_event!(@sticky CustomDownstreamSticky, T);
 impl CustomDownstreamSticky<Event> {
+    #[doc(alias = "gst_event_new_custom")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(structure: crate::Structure) -> Event {
         skip_assert_initialized!();
@@ -1404,6 +1460,7 @@ impl CustomDownstreamSticky<Event> {
 
 declare_concrete_event!(CustomBoth, T);
 impl CustomBoth<Event> {
+    #[doc(alias = "gst_event_new_custom")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(structure: crate::Structure) -> Event {
         skip_assert_initialized!();
@@ -1418,6 +1475,7 @@ impl CustomBoth<Event> {
 
 declare_concrete_event!(CustomBothOob, T);
 impl CustomBothOob<Event> {
+    #[doc(alias = "gst_event_new_custom")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(structure: crate::Structure) -> Event {
         skip_assert_initialized!();
@@ -1476,6 +1534,7 @@ impl<'a> EventBuilder<'a> {
 
 macro_rules! event_builder_generic_impl {
     ($new_fn:expr) => {
+        #[doc(alias = "gst_event_set_seqnum")]
         #[allow(clippy::needless_update)]
         pub fn seqnum(self, seqnum: Seqnum) -> Self {
             Self {
@@ -1484,6 +1543,7 @@ macro_rules! event_builder_generic_impl {
             }
         }
 
+        #[doc(alias = "gst_event_set_running_time_offset")]
         #[allow(clippy::needless_update)]
         pub fn running_time_offset(self, running_time_offset: i64) -> Self {
             Self {
diff --git a/gstreamer/src/message.rs b/gstreamer/src/message.rs
index a4196d397..843782bce 100644
--- a/gstreamer/src/message.rs
+++ b/gstreamer/src/message.rs
@@ -249,6 +249,7 @@ macro_rules! declare_concrete_message(
 
 declare_concrete_message!(Eos);
 impl<'a> Eos<'a> {
+    #[doc(alias = "gst_message_new_eos")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new() -> Message {
         skip_assert_initialized!();
@@ -263,6 +264,7 @@ impl<'a> Eos<'a> {
 
 declare_concrete_message!(Error);
 impl<'a> Error<'a> {
+    #[doc(alias = "gst_message_new_error")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new<T: MessageErrorDomain>(error: T, message: &str) -> Message {
         skip_assert_initialized!();
@@ -287,6 +289,7 @@ impl<'a> Error<'a> {
     }
 
     #[doc(alias = "get_debug")]
+    #[doc(alias = "gst_message_parse_error")]
     pub fn debug(&self) -> Option<String> {
         unsafe {
             let mut debug = ptr::null_mut();
@@ -318,6 +321,7 @@ impl<'a> Error<'a> {
 
 declare_concrete_message!(Warning);
 impl<'a> Warning<'a> {
+    #[doc(alias = "gst_message_new_warning")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new<T: MessageErrorDomain>(error: T, message: &str) -> Message {
         skip_assert_initialized!();
@@ -330,6 +334,7 @@ impl<'a> Warning<'a> {
     }
 
     #[doc(alias = "get_error")]
+    #[doc(alias = "gst_message_parse_warning")]
     pub fn error(&self) -> glib::Error {
         unsafe {
             let mut error = ptr::null_mut();
@@ -341,6 +346,7 @@ impl<'a> Warning<'a> {
     }
 
     #[doc(alias = "get_debug")]
+    #[doc(alias = "gst_message_parse_warning")]
     pub fn debug(&self) -> Option<String> {
         unsafe {
             let mut debug = ptr::null_mut();
@@ -354,12 +360,12 @@ impl<'a> Warning<'a> {
     #[cfg(any(feature = "v1_10", feature = "dox"))]
     #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
     #[doc(alias = "get_details")]
-    #[doc(alias = "gst_message_parse_error_details")]
+    #[doc(alias = "gst_message_parse_warning_details")]
     pub fn details(&self) -> Option<&StructureRef> {
         unsafe {
             let mut details = ptr::null();
 
-            ffi::gst_message_parse_error_details(self.as_mut_ptr(), &mut details);
+            ffi::gst_message_parse_warning_details(self.as_mut_ptr(), &mut details);
 
             if details.is_null() {
                 None
@@ -372,6 +378,7 @@ impl<'a> Warning<'a> {
 
 declare_concrete_message!(Info);
 impl<'a> Info<'a> {
+    #[doc(alias = "gst_message_new_info")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new<T: MessageErrorDomain>(error: T, message: &str) -> Message {
         skip_assert_initialized!();
@@ -384,6 +391,7 @@ impl<'a> Info<'a> {
     }
 
     #[doc(alias = "get_error")]
+    #[doc(alias = "gst_message_parse_info")]
     pub fn error(&self) -> glib::Error {
         unsafe {
             let mut error = ptr::null_mut();
@@ -395,6 +403,7 @@ impl<'a> Info<'a> {
     }
 
     #[doc(alias = "get_debug")]
+    #[doc(alias = "gst_message_parse_info")]
     pub fn debug(&self) -> Option<String> {
         unsafe {
             let mut debug = ptr::null_mut();
@@ -408,12 +417,12 @@ impl<'a> Info<'a> {
     #[cfg(any(feature = "v1_10", feature = "dox"))]
     #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
     #[doc(alias = "get_details")]
-    #[doc(alias = "gst_message_parse_error_details")]
+    #[doc(alias = "gst_message_parse_info_details")]
     pub fn details(&self) -> Option<&StructureRef> {
         unsafe {
             let mut details = ptr::null();
 
-            ffi::gst_message_parse_error_details(self.as_mut_ptr(), &mut details);
+            ffi::gst_message_parse_info_details(self.as_mut_ptr(), &mut details);
 
             if details.is_null() {
                 None
@@ -426,6 +435,7 @@ impl<'a> Info<'a> {
 
 declare_concrete_message!(Tag);
 impl<'a> Tag<'a> {
+    #[doc(alias = "gst_message_new_tag")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(tags: &TagList) -> Message {
         skip_assert_initialized!();
@@ -438,6 +448,7 @@ impl<'a> Tag<'a> {
     }
 
     #[doc(alias = "get_tags")]
+    #[doc(alias = "gst_message_parse_tag")]
     pub fn tags(&self) -> TagList {
         unsafe {
             let mut tags = ptr::null_mut();
@@ -449,6 +460,7 @@ impl<'a> Tag<'a> {
 
 declare_concrete_message!(Buffering);
 impl<'a> Buffering<'a> {
+    #[doc(alias = "gst_message_new_buffering")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(percent: i32) -> Message {
         skip_assert_initialized!();
@@ -461,6 +473,7 @@ impl<'a> Buffering<'a> {
     }
 
     #[doc(alias = "get_percent")]
+    #[doc(alias = "gst_message_parse_buffering")]
     pub fn percent(&self) -> i32 {
         unsafe {
             let mut p = mem::MaybeUninit::uninit();
@@ -498,6 +511,7 @@ impl<'a> Buffering<'a> {
 
 declare_concrete_message!(StateChanged);
 impl<'a> StateChanged<'a> {
+    #[doc(alias = "gst_message_new_state_changed")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(old: crate::State, new: crate::State, pending: crate::State) -> Message {
         skip_assert_initialized!();
@@ -514,6 +528,7 @@ impl<'a> StateChanged<'a> {
     }
 
     #[doc(alias = "get_old")]
+    #[doc(alias = "gst_message_parse_state_changed")]
     pub fn old(&self) -> crate::State {
         unsafe {
             let mut state = mem::MaybeUninit::uninit();
@@ -530,6 +545,7 @@ impl<'a> StateChanged<'a> {
     }
 
     #[doc(alias = "get_current")]
+    #[doc(alias = "gst_message_parse_state_changed")]
     pub fn current(&self) -> crate::State {
         unsafe {
             let mut state = mem::MaybeUninit::uninit();
@@ -546,6 +562,7 @@ impl<'a> StateChanged<'a> {
     }
 
     #[doc(alias = "get_pending")]
+    #[doc(alias = "gst_message_parse_state_changed")]
     pub fn pending(&self) -> crate::State {
         unsafe {
             let mut state = mem::MaybeUninit::uninit();
@@ -564,6 +581,7 @@ impl<'a> StateChanged<'a> {
 
 declare_concrete_message!(StateDirty);
 impl<'a> StateDirty<'a> {
+    #[doc(alias = "gst_message_new_state_dirty")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new() -> Message {
         skip_assert_initialized!();
@@ -578,6 +596,7 @@ impl<'a> StateDirty<'a> {
 
 declare_concrete_message!(StepDone);
 impl<'a> StepDone<'a> {
+    #[doc(alias = "gst_message_new_step_done")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new<V: Into<GenericFormattedValue>>(
         amount: V,
@@ -618,6 +637,7 @@ impl<'a> StepDone<'a> {
         )
     }
 
+    #[doc(alias = "gst_message_parse_step_done")]
     pub fn get(
         &self,
     ) -> (
@@ -668,6 +688,7 @@ impl<'a> StepDone<'a> {
 
 declare_concrete_message!(ClockProvide);
 impl<'a> ClockProvide<'a> {
+    #[doc(alias = "gst_message_new_clock_provide")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(clock: &crate::Clock, ready: bool) -> Message {
         skip_assert_initialized!();
@@ -692,6 +713,7 @@ impl<'a> ClockProvide<'a> {
     }
 
     #[doc(alias = "get_ready")]
+    #[doc(alias = "gst_message_parse_clock_provide")]
     pub fn is_ready(&self) -> bool {
         unsafe {
             let mut ready = mem::MaybeUninit::uninit();
@@ -709,6 +731,7 @@ impl<'a> ClockProvide<'a> {
 
 declare_concrete_message!(ClockLost);
 impl<'a> ClockLost<'a> {
+    #[doc(alias = "gst_message_new_clock_lost")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(clock: &crate::Clock) -> Message {
         skip_assert_initialized!();
@@ -735,6 +758,7 @@ impl<'a> ClockLost<'a> {
 
 declare_concrete_message!(NewClock);
 impl<'a> NewClock<'a> {
+    #[doc(alias = "gst_message_new_new_clock")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(clock: &crate::Clock) -> Message {
         skip_assert_initialized!();
@@ -761,6 +785,7 @@ impl<'a> NewClock<'a> {
 
 declare_concrete_message!(StructureChange);
 impl<'a> StructureChange<'a> {
+    #[doc(alias = "gst_message_new_structure_change")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(type_: crate::StructureChangeType, owner: &crate::Element, busy: bool) -> Message {
         skip_assert_initialized!();
@@ -776,6 +801,7 @@ impl<'a> StructureChange<'a> {
         StructureChangeBuilder::new(type_, owner, busy)
     }
 
+    #[doc(alias = "gst_message_parse_structure_change")]
     pub fn get(&self) -> (crate::StructureChangeType, crate::Element, bool) {
         unsafe {
             let mut type_ = mem::MaybeUninit::uninit();
@@ -800,6 +826,7 @@ impl<'a> StructureChange<'a> {
 
 declare_concrete_message!(StreamStatus);
 impl<'a> StreamStatus<'a> {
+    #[doc(alias = "gst_message_new_stream_status")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(type_: crate::StreamStatusType, owner: &crate::Element) -> Message {
         skip_assert_initialized!();
@@ -811,6 +838,7 @@ impl<'a> StreamStatus<'a> {
         StreamStatusBuilder::new(type_, owner)
     }
 
+    #[doc(alias = "gst_message_parse_stream_status")]
     pub fn get(&self) -> (crate::StreamStatusType, crate::Element) {
         unsafe {
             let mut type_ = mem::MaybeUninit::uninit();
@@ -835,6 +863,7 @@ impl<'a> StreamStatus<'a> {
 
 declare_concrete_message!(Application);
 impl<'a> Application<'a> {
+    #[doc(alias = "gst_message_new_application")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(structure: crate::Structure) -> Message {
         skip_assert_initialized!();
@@ -849,6 +878,7 @@ impl<'a> Application<'a> {
 
 declare_concrete_message!(Element);
 impl<'a> Element<'a> {
+    #[doc(alias = "gst_message_new_element")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(structure: crate::Structure) -> Message {
         skip_assert_initialized!();
@@ -863,6 +893,7 @@ impl<'a> Element<'a> {
 
 declare_concrete_message!(SegmentStart);
 impl<'a> SegmentStart<'a> {
+    #[doc(alias = "gst_message_new_segment_start")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new<V: Into<GenericFormattedValue>>(position: V) -> Message {
         skip_assert_initialized!();
@@ -875,6 +906,7 @@ impl<'a> SegmentStart<'a> {
         SegmentStartBuilder::new(position)
     }
 
+    #[doc(alias = "gst_message_parse_segment_start")]
     pub fn get(&self) -> GenericFormattedValue {
         unsafe {
             let mut format = mem::MaybeUninit::uninit();
@@ -893,6 +925,7 @@ impl<'a> SegmentStart<'a> {
 
 declare_concrete_message!(SegmentDone);
 impl<'a> SegmentDone<'a> {
+    #[doc(alias = "gst_message_new_segment_done")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new<V: Into<GenericFormattedValue>>(position: V) -> Message {
         skip_assert_initialized!();
@@ -905,6 +938,7 @@ impl<'a> SegmentDone<'a> {
         SegmentDoneBuilder::new(position)
     }
 
+    #[doc(alias = "gst_message_parse_segment_done")]
     pub fn get(&self) -> GenericFormattedValue {
         unsafe {
             let mut format = mem::MaybeUninit::uninit();
@@ -923,6 +957,7 @@ impl<'a> SegmentDone<'a> {
 
 declare_concrete_message!(DurationChanged);
 impl<'a> DurationChanged<'a> {
+    #[doc(alias = "gst_message_new_duration_changed")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new() -> Message {
         skip_assert_initialized!();
@@ -937,6 +972,7 @@ impl<'a> DurationChanged<'a> {
 
 declare_concrete_message!(Latency);
 impl<'a> Latency<'a> {
+    #[doc(alias = "gst_message_new_latency")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new() -> Message {
         skip_assert_initialized!();
@@ -951,6 +987,7 @@ impl<'a> Latency<'a> {
 
 declare_concrete_message!(AsyncStart);
 impl<'a> AsyncStart<'a> {
+    #[doc(alias = "gst_message_new_async_start")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new() -> Message {
         skip_assert_initialized!();
@@ -965,6 +1002,7 @@ impl<'a> AsyncStart<'a> {
 
 declare_concrete_message!(AsyncDone);
 impl<'a> AsyncDone<'a> {
+    #[doc(alias = "gst_message_new_async_done")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(running_time: impl Into<Option<crate::ClockTime>>) -> Message {
         skip_assert_initialized!();
@@ -977,6 +1015,7 @@ impl<'a> AsyncDone<'a> {
     }
 
     #[doc(alias = "get_running_time")]
+    #[doc(alias = "gst_message_parse_async_done")]
     pub fn running_time(&self) -> Option<crate::ClockTime> {
         unsafe {
             let mut running_time = mem::MaybeUninit::uninit();
@@ -990,6 +1029,7 @@ impl<'a> AsyncDone<'a> {
 
 declare_concrete_message!(RequestState);
 impl<'a> RequestState<'a> {
+    #[doc(alias = "gst_message_new_request_state")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(state: crate::State) -> Message {
         skip_assert_initialized!();
@@ -1002,6 +1042,7 @@ impl<'a> RequestState<'a> {
     }
 
     #[doc(alias = "get_requested_state")]
+    #[doc(alias = "gst_message_parse_request_state")]
     pub fn requested_state(&self) -> crate::State {
         unsafe {
             let mut state = mem::MaybeUninit::uninit();
@@ -1015,6 +1056,7 @@ impl<'a> RequestState<'a> {
 
 declare_concrete_message!(StepStart);
 impl<'a> StepStart<'a> {
+    #[doc(alias = "gst_message_new_step_start")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new<V: Into<GenericFormattedValue>>(
         active: bool,
@@ -1038,6 +1080,7 @@ impl<'a> StepStart<'a> {
         StepStartBuilder::new(active, amount.into(), rate, flush, intermediate)
     }
 
+    #[doc(alias = "gst_message_parse_step_start")]
     pub fn get(&self) -> (bool, GenericFormattedValue, f64, bool, bool) {
         unsafe {
             let mut active = mem::MaybeUninit::uninit();
@@ -1073,6 +1116,7 @@ impl<'a> StepStart<'a> {
 
 declare_concrete_message!(Qos);
 impl<'a> Qos<'a> {
+    #[doc(alias = "gst_message_new_qos")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(
         live: bool,
@@ -1095,6 +1139,7 @@ impl<'a> Qos<'a> {
         QosBuilder::new(live)
     }
 
+    #[doc(alias = "gst_message_parse_qos")]
     pub fn get(
         &self,
     ) -> (
@@ -1184,6 +1229,7 @@ impl<'a> Qos<'a> {
 
 declare_concrete_message!(Progress);
 impl<'a> Progress<'a> {
+    #[doc(alias = "gst_message_new_progress")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(type_: crate::ProgressType, code: &'a str, text: &'a str) -> Message {
         skip_assert_initialized!();
@@ -1199,6 +1245,7 @@ impl<'a> Progress<'a> {
         ProgressBuilder::new(type_, code, text)
     }
 
+    #[doc(alias = "gst_message_parse_progress")]
     pub fn get(&self) -> (crate::ProgressType, &'a str, &'a str) {
         unsafe {
             let mut type_ = mem::MaybeUninit::uninit();
@@ -1224,6 +1271,7 @@ declare_concrete_message!(Toc);
 impl<'a> Toc<'a> {
     // FIXME could use false for updated as default
     // Even better: use an enum for updated so that it is more explicit than true / false
+    #[doc(alias = "gst_message_new_toc")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(toc: &crate::Toc, updated: bool) -> Message {
         skip_assert_initialized!();
@@ -1249,6 +1297,7 @@ impl<'a> Toc<'a> {
 
 declare_concrete_message!(ResetTime);
 impl<'a> ResetTime<'a> {
+    #[doc(alias = "gst_message_new_reset_time")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(running_time: crate::ClockTime) -> Message {
         skip_assert_initialized!();
@@ -1261,6 +1310,7 @@ impl<'a> ResetTime<'a> {
     }
 
     #[doc(alias = "get_running_time")]
+    #[doc(alias = "gst_message_parse_reset_time")]
     pub fn running_time(&self) -> crate::ClockTime {
         unsafe {
             let mut running_time = mem::MaybeUninit::uninit();
@@ -1274,6 +1324,7 @@ impl<'a> ResetTime<'a> {
 
 declare_concrete_message!(StreamStart);
 impl<'a> StreamStart<'a> {
+    #[doc(alias = "gst_message_new_stream_start")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new() -> Message {
         skip_assert_initialized!();
@@ -1310,6 +1361,7 @@ impl<'a> StreamStart<'a> {
 
 declare_concrete_message!(NeedContext);
 impl<'a> NeedContext<'a> {
+    #[doc(alias = "gst_message_new_need_context")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(context_type: &str) -> Message {
         skip_assert_initialized!();
@@ -1336,6 +1388,7 @@ impl<'a> NeedContext<'a> {
 
 declare_concrete_message!(HaveContext);
 impl<'a> HaveContext<'a> {
+    #[doc(alias = "gst_message_new_have_context")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(context: crate::Context) -> Message {
         skip_assert_initialized!();
@@ -1360,6 +1413,7 @@ impl<'a> HaveContext<'a> {
 
 declare_concrete_message!(DeviceAdded);
 impl<'a> DeviceAdded<'a> {
+    #[doc(alias = "gst_message_new_device_added")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(device: &crate::Device) -> Message {
         skip_assert_initialized!();
@@ -1386,6 +1440,7 @@ impl<'a> DeviceAdded<'a> {
 
 declare_concrete_message!(DeviceRemoved);
 impl<'a> DeviceRemoved<'a> {
+    #[doc(alias = "gst_message_new_device_removed")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(device: &crate::Device) -> Message {
         skip_assert_initialized!();
@@ -1416,6 +1471,7 @@ declare_concrete_message!(PropertyNotify);
 #[cfg(any(feature = "v1_10", feature = "dox"))]
 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
 impl<'a> PropertyNotify<'a> {
+    #[doc(alias = "gst_message_new_property_notify")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(property_name: &str) -> Message {
         skip_assert_initialized!();
@@ -1427,6 +1483,7 @@ impl<'a> PropertyNotify<'a> {
         PropertyNotifyBuilder::new(property_name)
     }
 
+    #[doc(alias = "gst_message_parse_property_notify")]
     pub fn get(&self) -> (Object, &str, Option<&'a glib::Value>) {
         unsafe {
             let mut object = ptr::null_mut();
@@ -1459,6 +1516,7 @@ declare_concrete_message!(StreamCollection);
 #[cfg(any(feature = "v1_10", feature = "dox"))]
 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
 impl<'a> StreamCollection<'a> {
+    #[doc(alias = "gst_message_new_stream_collection")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(collection: &crate::StreamCollection) -> Message {
         skip_assert_initialized!();
@@ -1489,6 +1547,7 @@ declare_concrete_message!(StreamsSelected);
 #[cfg(any(feature = "v1_10", feature = "dox"))]
 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
 impl<'a> StreamsSelected<'a> {
+    #[doc(alias = "gst_message_new_streams_selected")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(collection: &crate::StreamCollection) -> Message {
         skip_assert_initialized!();
@@ -1501,6 +1560,7 @@ impl<'a> StreamsSelected<'a> {
     }
 
     #[doc(alias = "get_stream_collection")]
+    #[doc(alias = "gst_message_parse_streams_selected")]
     pub fn stream_collection(&self) -> crate::StreamCollection {
         unsafe {
             let mut collection = ptr::null_mut();
@@ -1536,6 +1596,7 @@ declare_concrete_message!(Redirect);
 #[cfg(any(feature = "v1_10", feature = "dox"))]
 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
 impl<'a> Redirect<'a> {
+    #[doc(alias = "gst_message_new_redirect")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(location: &str) -> Message {
         skip_assert_initialized!();
@@ -1549,6 +1610,7 @@ impl<'a> Redirect<'a> {
 
     #[doc(alias = "get_entries")]
     #[doc(alias = "gst_message_get_num_redirect_entries")]
+    #[doc(alias = "gst_message_parse_redirect_entry")]
     pub fn entries(&self) -> Vec<(&str, Option<TagList>, Option<&StructureRef>)> {
         unsafe {
             let n = ffi::gst_message_get_num_redirect_entries(self.as_mut_ptr());
@@ -1590,6 +1652,7 @@ declare_concrete_message!(DeviceChanged);
 #[cfg(any(feature = "v1_16", feature = "dox"))]
 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
 impl<'a> DeviceChanged<'a> {
+    #[doc(alias = "gst_message_new_device_changed")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(device: &'a crate::Device, changed_device: &'a crate::Device) -> Message {
         skip_assert_initialized!();
@@ -1628,6 +1691,7 @@ declare_concrete_message!(InstantRateRequest);
 #[cfg(any(feature = "v1_18", feature = "dox"))]
 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
 impl<'a> InstantRateRequest<'a> {
+    #[doc(alias = "gst_message_new_instant_rate_request")]
     #[allow(clippy::new_ret_no_self)]
     pub fn new(rate_multiplier: f64) -> Message {
         skip_assert_initialized!();
@@ -1710,6 +1774,7 @@ macro_rules! message_builder_generic_impl {
             }
         }
 
+        #[doc(alias = "gst_message_set_seqnum")]
         #[allow(clippy::needless_update)]
         pub fn seqnum(self, seqnum: Seqnum) -> Self {
             Self {
diff --git a/gstreamer/src/query.rs b/gstreamer/src/query.rs
index 90a6519ef..12b975134 100644
--- a/gstreamer/src/query.rs
+++ b/gstreamer/src/query.rs
@@ -31,6 +31,7 @@ impl QueryRef {
     }
 
     #[doc(alias = "get_mut_structure")]
+    #[doc(alias = "gst_query_writable_structure")]
     pub fn structure_mut(&mut self) -> &mut StructureRef {
         unsafe {
             let structure = ffi::gst_query_writable_structure(self.as_mut_ptr());
@@ -38,14 +39,17 @@ impl QueryRef {
         }
     }
 
+    #[doc(alias = "GST_QUERY_IS_DOWNSTREAM")]
     pub fn is_downstream(&self) -> bool {
         unsafe { ((*self.as_ptr()).type_ as u32) & ffi::GST_QUERY_TYPE_DOWNSTREAM != 0 }
     }
 
+    #[doc(alias = "GST_QUERY_IS_UPSTREAM")]
     pub fn is_upstream(&self) -> bool {
         unsafe { ((*self.as_ptr()).type_ as u32) & ffi::GST_QUERY_TYPE_UPSTREAM != 0 }
     }
 
+    #[doc(alias = "GST_QUERY_IS_SERIALIZED")]
     pub fn is_serialized(&self) -> bool {
         unsafe { ((*self.as_ptr()).type_ as u32) & ffi::GST_QUERY_TYPE_SERIALIZED != 0 }
     }
@@ -229,6 +233,7 @@ impl Position<Query> {
 
 impl<T: AsPtr> Position<T> {
     #[doc(alias = "get_result")]
+    #[doc(alias = "gst_query_parse_position")]
     pub fn result(&self) -> GenericFormattedValue {
         unsafe {
             let mut fmt = mem::MaybeUninit::uninit();
@@ -241,6 +246,7 @@ impl<T: AsPtr> Position<T> {
     }
 
     #[doc(alias = "get_format")]
+    #[doc(alias = "gst_query_parse_position")]
     pub fn format(&self) -> crate::Format {
         unsafe {
             let mut fmt = mem::MaybeUninit::uninit();
@@ -274,6 +280,7 @@ impl Duration<Query> {
 
 impl<T: AsPtr> Duration<T> {
     #[doc(alias = "get_result")]
+    #[doc(alias = "gst_query_parse_duration")]
     pub fn result(&self) -> GenericFormattedValue {
         unsafe {
             let mut fmt = mem::MaybeUninit::uninit();
@@ -286,6 +293,7 @@ impl<T: AsPtr> Duration<T> {
     }
 
     #[doc(alias = "get_format")]
+    #[doc(alias = "gst_query_parse_duration")]
     pub fn format(&self) -> crate::Format {
         unsafe {
             let mut fmt = mem::MaybeUninit::uninit();
@@ -325,6 +333,7 @@ impl Default for Latency<Query> {
 
 impl<T: AsPtr> Latency<T> {
     #[doc(alias = "get_result")]
+    #[doc(alias = "gst_query_parse_latency")]
     pub fn result(&self) -> (bool, crate::ClockTime, Option<crate::ClockTime>) {
         unsafe {
             let mut live = mem::MaybeUninit::uninit();
@@ -377,6 +386,7 @@ impl Seeking<Query> {
 
 impl<T: AsPtr> Seeking<T> {
     #[doc(alias = "get_result")]
+    #[doc(alias = "gst_query_parse_seeking")]
     pub fn result(&self) -> (bool, GenericFormattedValue, GenericFormattedValue) {
         unsafe {
             let mut fmt = mem::MaybeUninit::uninit();
@@ -400,6 +410,7 @@ impl<T: AsPtr> Seeking<T> {
     }
 
     #[doc(alias = "get_format")]
+    #[doc(alias = "gst_query_parse_seeking")]
     pub fn format(&self) -> crate::Format {
         unsafe {
             let mut fmt = mem::MaybeUninit::uninit();
@@ -448,6 +459,7 @@ impl Segment<Query> {
 
 impl<T: AsPtr> Segment<T> {
     #[doc(alias = "get_result")]
+    #[doc(alias = "gst_query_parse_segment")]
     pub fn result(&self) -> (f64, GenericFormattedValue, GenericFormattedValue) {
         unsafe {
             let mut rate = mem::MaybeUninit::uninit();
@@ -471,6 +483,7 @@ impl<T: AsPtr> Segment<T> {
     }
 
     #[doc(alias = "get_format")]
+    #[doc(alias = "gst_query_parse_segment")]
     pub fn format(&self) -> crate::Format {
         unsafe {
             let mut fmt = mem::MaybeUninit::uninit();
@@ -525,6 +538,7 @@ impl Convert<Query> {
 
 impl<T: AsPtr> Convert<T> {
     #[doc(alias = "get_result")]
+    #[doc(alias = "gst_query_parse_convert")]
     pub fn result(&self) -> (GenericFormattedValue, GenericFormattedValue) {
         unsafe {
             let mut src_fmt = mem::MaybeUninit::uninit();
@@ -546,6 +560,7 @@ impl<T: AsPtr> Convert<T> {
         }
     }
 
+    #[doc(alias = "gst_query_parse_convert")]
     pub fn get(&self) -> (GenericFormattedValue, crate::Format) {
         unsafe {
             let mut src_fmt = mem::MaybeUninit::uninit();
@@ -602,6 +617,8 @@ impl Default for Formats<Query> {
 
 impl<T: AsPtr> Formats<T> {
     #[doc(alias = "get_result")]
+    #[doc(alias = "gst_query_parse_n_formats")]
+    #[doc(alias = "gst_query_parse_nth_format")]
     pub fn result(&self) -> Vec<crate::Format> {
         unsafe {
             let mut n = mem::MaybeUninit::uninit();
@@ -621,6 +638,7 @@ impl<T: AsPtr> Formats<T> {
 }
 
 impl<T: AsMutPtr> Formats<T> {
+    #[doc(alias = "gst_query_set_formats")]
     #[doc(alias = "gst_query_set_formatsv")]
     pub fn set(&mut self, formats: &[crate::Format]) {
         unsafe {
@@ -645,6 +663,7 @@ impl Buffering<Query> {
 
 impl<T: AsPtr> Buffering<T> {
     #[doc(alias = "get_format")]
+    #[doc(alias = "gst_query_parse_buffering_range")]
     pub fn format(&self) -> crate::Format {
         unsafe {
             let mut fmt = mem::MaybeUninit::uninit();
@@ -730,6 +749,7 @@ impl<T: AsPtr> Buffering<T> {
 
     #[doc(alias = "get_ranges")]
     #[doc(alias = "gst_query_get_n_buffering_ranges")]
+    #[doc(alias = "gst_query_parse_nth_buffering_range")]
     pub fn ranges(&self) -> Vec<(GenericFormattedValue, GenericFormattedValue)> {
         unsafe {
             let mut fmt = mem::MaybeUninit::uninit();
@@ -767,12 +787,14 @@ impl<T: AsPtr> Buffering<T> {
 }
 
 impl<T: AsMutPtr> Buffering<T> {
+    #[doc(alias = "gst_query_set_buffering_percent")]
     pub fn set_percent(&mut self, busy: bool, percent: i32) {
         unsafe {
             ffi::gst_query_set_buffering_percent(self.0.as_mut_ptr(), busy.into_glib(), percent);
         }
     }
 
+    #[doc(alias = "gst_query_set_buffering_range")]
     pub fn set_range<V: Into<GenericFormattedValue>>(
         &mut self,
         start: V,
@@ -796,6 +818,7 @@ impl<T: AsMutPtr> Buffering<T> {
         }
     }
 
+    #[doc(alias = "gst_query_set_buffering_stats")]
     pub fn set_stats(
         &mut self,
         mode: crate::BufferingMode,
@@ -815,6 +838,7 @@ impl<T: AsMutPtr> Buffering<T> {
         }
     }
 
+    #[doc(alias = "gst_query_add_buffering_range")]
     pub fn add_buffering_ranges<V: Into<GenericFormattedValue> + Copy>(
         &mut self,
         ranges: &[(V, V)],
@@ -900,6 +924,8 @@ impl<T: AsMutPtr> Uri<T> {
         }
     }
 
+    #[doc(alias = "gst_query_set_uri_redirection")]
+    #[doc(alias = "gst_query_set_uri_redirection_permanent")]
     pub fn set_redirection(&mut self, uri: &str, permanent: bool) {
         unsafe {
             ffi::gst_query_set_uri_redirection(self.0.as_mut_ptr(), uri.to_glib_none().0);
@@ -926,6 +952,7 @@ impl Allocation<Query> {
 }
 
 impl<T: AsPtr> Allocation<T> {
+    #[doc(alias = "gst_query_parse_allocation")]
     pub fn get(&self) -> (&crate::CapsRef, bool) {
         unsafe {
             let mut caps = ptr::null_mut();
@@ -939,6 +966,7 @@ impl<T: AsPtr> Allocation<T> {
         }
     }
 
+    #[doc(alias = "gst_query_parse_allocation")]
     pub fn get_owned(&self) -> (crate::Caps, bool) {
         unsafe {
             let (caps, need_pool) = self.get();
@@ -948,6 +976,7 @@ impl<T: AsPtr> Allocation<T> {
 
     #[doc(alias = "gst_allocation_params")]
     #[doc(alias = "gst_query_get_n_allocation_params")]
+    #[doc(alias = "gst_query_parse_nth_allocation_param")]
     pub fn allocation_params(&self) -> Vec<(Option<crate::Allocator>, crate::AllocationParams)> {
         unsafe {
             let n = ffi::gst_query_get_n_allocation_params(self.0.as_ptr());
@@ -970,6 +999,7 @@ impl<T: AsPtr> Allocation<T> {
 
     #[doc(alias = "get_allocation_pools")]
     #[doc(alias = "gst_query_get_n_allocation_pools")]
+    #[doc(alias = "gst_query_parse_nth_allocation_pool")]
     pub fn allocation_pools(&self) -> Vec<(Option<crate::BufferPool>, u32, u32, u32)> {
         unsafe {
             let n = ffi::gst_query_get_n_allocation_pools(self.0.as_ptr());
@@ -1002,6 +1032,7 @@ impl<T: AsPtr> Allocation<T> {
 
     #[doc(alias = "get_allocation_metas")]
     #[doc(alias = "gst_query_get_n_allocation_metas")]
+    #[doc(alias = "gst_query_parse_nth_allocation_meta")]
     pub fn allocation_metas(&self) -> Vec<(glib::Type, Option<&crate::StructureRef>)> {
         unsafe {
             let n = ffi::gst_query_get_n_allocation_metas(self.0.as_ptr());
@@ -1226,6 +1257,7 @@ impl<T: AsPtr> Scheduling<T> {
     }
 
     #[doc(alias = "get_result")]
+    #[doc(alias = "gst_query_parse_scheduling")]
     pub fn result(&self) -> (crate::SchedulingFlags, i32, i32, i32) {
         unsafe {
             let mut flags = mem::MaybeUninit::uninit();
@@ -1252,6 +1284,7 @@ impl<T: AsPtr> Scheduling<T> {
 }
 
 impl<T: AsMutPtr> Scheduling<T> {
+    #[doc(alias = "gst_query_add_scheduling_mode")]
     pub fn add_scheduling_modes(&mut self, modes: &[crate::PadMode]) {
         unsafe {
             for mode in modes {
@@ -1299,6 +1332,7 @@ impl<T: AsPtr> AcceptCaps<T> {
     }
 
     #[doc(alias = "get_caps_owned")]
+    #[doc(alias = "gst_query_parse_accept_caps")]
     pub fn caps_owned(&self) -> crate::Caps {
         unsafe { from_glib_none(self.caps().as_ptr()) }
     }
@@ -1315,6 +1349,7 @@ impl<T: AsPtr> AcceptCaps<T> {
 }
 
 impl<T: AsMutPtr> AcceptCaps<T> {
+    #[doc(alias = "gst_query_set_accept_caps_result")]
     pub fn set_result(&mut self, accepted: bool) {
         unsafe {
             ffi::gst_query_set_accept_caps_result(self.0.as_mut_ptr(), accepted.into_glib());
@@ -1337,6 +1372,7 @@ impl Caps<Query> {
 
 impl<T: AsPtr> Caps<T> {
     #[doc(alias = "get_filter")]
+    #[doc(alias = "gst_query_parse_caps")]
     pub fn filter(&self) -> Option<&crate::CapsRef> {
         unsafe {
             let mut caps = ptr::null_mut();
@@ -1350,6 +1386,7 @@ impl<T: AsPtr> Caps<T> {
     }
 
     #[doc(alias = "get_filter_owned")]
+    #[doc(alias = "gst_query_parse_caps")]
     pub fn filter_owned(&self) -> Option<crate::Caps> {
         unsafe { self.filter().map(|caps| from_glib_none(caps.as_ptr())) }
     }
@@ -1369,12 +1406,14 @@ impl<T: AsPtr> Caps<T> {
     }
 
     #[doc(alias = "get_result_owned")]
+    #[doc(alias = "gst_query_parse_caps_result")]
     pub fn result_owned(&self) -> Option<crate::Caps> {
         unsafe { self.result().map(|caps| from_glib_none(caps.as_ptr())) }
     }
 }
 
 impl<T: AsMutPtr> Caps<T> {
+    #[doc(alias = "gst_query_set_caps_result")]
     pub fn set_result(&mut self, caps: &crate::Caps) {
         unsafe {
             ffi::gst_query_set_caps_result(self.0.as_mut_ptr(), caps.as_mut_ptr());
@@ -1426,6 +1465,7 @@ impl<T: AsPtr> Context<T> {
     }
 
     #[doc(alias = "get_context_owned")]
+    #[doc(alias = "gst_query_parse_context")]
     pub fn context_owned(&self) -> Option<crate::Context> {
         unsafe {
             self.context()