diff --git a/cidre/src/cf/set.rs b/cidre/src/cf/set.rs
index 1f0aaf21..1717cee2 100644
--- a/cidre/src/cf/set.rs
+++ b/cidre/src/cf/set.rs
@@ -1,4 +1,3 @@
-use std::mem::MaybeUninit;
 use std::{ffi::c_void, marker::PhantomData, ops::Deref};
 
 use crate::{arc, cf, define_cf_type};
@@ -49,7 +48,7 @@ where
 {
     pub fn values(&self) -> Vec<arc::R<T>> {
         let len = self.len();
-        let mut vec: Vec<MaybeUninit<arc::R<T>>> = Vec::with_capacity(len);
+        let mut vec: Vec<std::mem::MaybeUninit<arc::R<T>>> = Vec::with_capacity(len);
         unsafe {
             self.get_values(vec.as_mut_ptr() as _);
             vec.set_len(len);
diff --git a/cidre/src/cg/affine_transform.rs b/cidre/src/cg/affine_transform.rs
index 901b5e78..66705d91 100644
--- a/cidre/src/cg/affine_transform.rs
+++ b/cidre/src/cg/affine_transform.rs
@@ -1,5 +1,7 @@
 use crate::cg;
 
+/// An affine transformation.
+#[doc(alias = "CGAffineTransform")]
 #[derive(Debug, Copy, Clone)]
 #[repr(C)]
 pub struct AffineTransform {
@@ -19,6 +21,8 @@ pub struct AffineTransform {
  *    AffineTransform      scale           shear            rotation          translation
  */
 
+/// The components of an affine transformation.
+#[doc(alias = "CGAffineTransformComponents")]
 #[derive(Debug, Copy, Clone, PartialEq)]
 #[repr(C)]
 pub struct Components {
diff --git a/cidre/src/cg/color.rs b/cidre/src/cg/color.rs
index efbac968..9f96448f 100644
--- a/cidre/src/cg/color.rs
+++ b/cidre/src/cg/color.rs
@@ -1,6 +1,9 @@
 use crate::{arc, cf, cg, define_cf_type};
 
-define_cf_type!(Color(cf::Type));
+define_cf_type!(
+    #[doc(alias = "CGColorRef")]
+    Color(cf::Type)
+);
 
 impl Color {
     /// ```
@@ -8,6 +11,7 @@ impl Color {
     ///
     /// let c = cg::Color::generic_gray(0.5, 0.5);
     /// ```
+    #[doc(alias = "CGColorCreateGenericGray")]
     #[inline]
     pub fn generic_gray(gray: cg::Float, alpha: cg::Float) -> arc::R<Color> {
         unsafe { CGColorCreateGenericGray(gray, alpha) }
@@ -16,12 +20,13 @@ impl Color {
     /// ```
     /// use cidre::cg;
     ///
-    /// let c = cg::Color::generic_rgb(0.5, 0.5, 0.5, 0.5);
+    /// let c = cg::Color::generic_rgba(0.5, 0.5, 0.5, 0.5);
     ///
     /// assert_eq!(c.alpha(), 0.5);
     /// ```
+    #[doc(alias = "CGColorCreateGenericRGB")]
     #[inline]
-    pub fn generic_rgb(
+    pub fn generic_rgba(
         red: cg::Float,
         green: cg::Float,
         blue: cg::Float,
@@ -30,6 +35,7 @@ impl Color {
         unsafe { CGColorCreateGenericRGB(red, green, blue, alpha) }
     }
 
+    #[doc(alias = "CGColorGetAlpha")]
     #[inline]
     pub fn alpha(&self) -> cg::Float {
         unsafe { CGColorGetAlpha(self) }
@@ -37,7 +43,7 @@ impl Color {
 }
 
 #[link(name = "CoreGraphics", kind = "framework")]
-unsafe extern "C" {
+unsafe extern "C-unwind" {
     fn CGColorCreateGenericGray(gray: cg::Float, alpha: cg::Float) -> arc::R<Color>;
     fn CGColorCreateGenericRGB(
         red: cg::Float,
diff --git a/cidre/src/cg/color_space.rs b/cidre/src/cg/color_space.rs
index a77805af..766281ba 100644
--- a/cidre/src/cg/color_space.rs
+++ b/cidre/src/cg/color_space.rs
@@ -1,5 +1,7 @@
 use crate::{arc, cf, define_cf_type};
 
+/// Color rendering intents.
+#[doc(alias = "CGColorRenderingIntent")]
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 #[repr(i32)]
 pub enum ColorRenderingIntent {
@@ -10,21 +12,26 @@ pub enum ColorRenderingIntent {
     Saturation = 4,
 }
 
+/// The model of a color space.
+#[doc(alias = "CGColorSpaceModel")]
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 #[repr(i32)]
 pub enum ColorSpaceModel {
     Unknown = -1,
     Monochrome,
-    RGB,
-    CMYK,
+    Rgb,
+    Cmyk,
     Lab,
     DeviceN,
     Indexed,
     Pattern,
-    XYZ,
+    Xyz,
 }
 
-define_cf_type!(ColorSpace(cf::Type));
+define_cf_type!(
+    #[doc(alias = "CGColorSpaceRef")]
+    ColorSpace(cf::Type)
+);
 
 impl ColorSpace {
     /// ```
@@ -104,7 +111,7 @@ impl ColorSpace {
     /// let name = space.name().unwrap();
     /// assert_eq!("kCGColorSpaceDeviceRGB", name.to_string());
     ///
-    /// assert_eq!(cg::ColorSpaceModel::RGB, space.model());
+    /// assert_eq!(cg::ColorSpaceModel::Rgb, space.model());
     /// ```
     #[inline]
     pub fn device_rgb() -> Option<arc::R<ColorSpace>> {
@@ -121,7 +128,7 @@ impl ColorSpace {
     /// let name = space.name().unwrap();
     /// assert_eq!("kCGColorSpaceDeviceCMYK", name.to_string());
     ///
-    /// assert_eq!(cg::ColorSpaceModel::CMYK, space.model());
+    /// assert_eq!(cg::ColorSpaceModel::Cmyk, space.model());
     /// ```
     #[inline]
     pub fn device_cmyk() -> Option<arc::R<ColorSpace>> {
@@ -170,16 +177,19 @@ pub mod names {
     /// please use Generic Gray Gamma 2.2, i.e. use
     /// generic_gray_gamma_2_2() name instead of
     /// generic_gray().
+    #[doc(alias = "kCGColorSpaceGenericGray")]
     #[inline]
     pub fn generic_gray() -> &'static cf::String {
         unsafe { kCGColorSpaceGenericGray }
     }
 
+    #[doc(alias = "kCGColorSpaceGenericRGB")]
     #[inline]
     pub fn generic_rgb() -> &'static cf::String {
         unsafe { kCGColorSpaceGenericRGB }
     }
 
+    #[doc(alias = "kCGColorSpaceGenericCMYK")]
     #[inline]
     pub fn generic_cmyk() -> &'static cf::String {
         unsafe { kCGColorSpaceGenericCMYK }
@@ -188,16 +198,19 @@ pub mod names {
     /// The Display P3 color space, created by Apple.
     ///
     /// This color space uses the DCI P3 primaries, a D65 white point, and the sRGB transfer function.
+    #[doc(alias = "kCGColorSpaceDisplayP3")]
     #[inline]
     pub fn display_p3() -> &'static cf::String {
         unsafe { kCGColorSpaceDisplayP3 }
     }
 
+    #[doc(alias = "kCGColorSpaceGenericRGBLinear")]
     #[inline]
     pub fn generic_rgb_linear() -> &'static cf::String {
         unsafe { kCGColorSpaceGenericRGBLinear }
     }
 
+    #[doc(alias = "kCGColorSpaceAdobeRGB1998")]
     #[inline]
     pub fn adobe_rgb_1998() -> &'static cf::String {
         unsafe { kCGColorSpaceAdobeRGB1998 }
@@ -206,137 +219,163 @@ pub mod names {
     /// The standard Red Green Blue (sRGB) color space.
     ///
     /// The sRGB colorimetry and non-linear transfer function are specified in IEC 61966-2-1.
+    #[doc(alias = "kCGColorSpaceSRGB")]
     #[inline]
     pub fn srgb() -> &'static cf::String {
         unsafe { kCGColorSpaceSRGB }
     }
 
+    #[doc(alias = "kCGColorSpaceGenericGrayGamma2_2")]
     #[inline]
     pub fn generic_gray_gamma_2_2() -> &'static cf::String {
         unsafe { kCGColorSpaceGenericGrayGamma2_2 }
     }
 
+    #[doc(alias = "kCGColorSpaceGenericXYZ")]
     #[inline]
     pub fn generic_xyz() -> &'static cf::String {
         unsafe { kCGColorSpaceGenericXYZ }
     }
 
+    #[doc(alias = "kCGColorSpaceGenericLab")]
     #[inline]
     pub fn generic_lab() -> &'static cf::String {
         unsafe { kCGColorSpaceGenericLab }
     }
 
+    #[doc(alias = "kCGColorSpaceACESCGLinear")]
     #[inline]
     pub fn acescg_linear() -> &'static cf::String {
         unsafe { kCGColorSpaceACESCGLinear }
     }
 
+    #[doc(alias = "kCGColorSpaceITUR_709")]
     #[inline]
     pub fn itur_709() -> &'static cf::String {
         unsafe { kCGColorSpaceITUR_709 }
     }
 
+    #[doc(alias = "kCGColorSpaceITUR_709_PQ")]
     #[inline]
     pub fn itur_709_pq() -> &'static cf::String {
         unsafe { kCGColorSpaceITUR_709_PQ }
     }
 
+    #[doc(alias = "kCGColorSpaceITUR_2020")]
     #[inline]
     pub fn itur_2020() -> &'static cf::String {
         unsafe { kCGColorSpaceITUR_2020 }
     }
 
+    #[doc(alias = "kCGColorSpaceITUR_2020_sRGBGamma")]
     #[inline]
     pub fn itur_2020_srgb_gamma() -> &'static cf::String {
         unsafe { kCGColorSpaceITUR_2020_sRGBGamma }
     }
-
+    
+    #[doc(alias = "kCGColorSpaceROMMRGB")]
     #[inline]
     pub fn rommrgb() -> &'static cf::String {
         unsafe { kCGColorSpaceROMMRGB }
     }
 
-    /// This color space was created by Digital Cinema Initiatives.
+    #[doc(alias = "kCGColorSpaceDCIP3")]
     #[inline]
     pub fn dci_p3() -> &'static cf::String {
         unsafe { kCGColorSpaceDCIP3 }
     }
 
+    #[doc(alias = "kCGColorSpaceLinearITUR_2020")]
     #[inline]
     pub fn linerar_itur_2020() -> &'static cf::String {
         unsafe { kCGColorSpaceLinearITUR_2020 }
     }
 
+    #[doc(alias = "kCGColorSpaceExtendedITUR_2020")]
     #[inline]
     pub fn extended_itur_2020() -> &'static cf::String {
         unsafe { kCGColorSpaceExtendedITUR_2020 }
     }
 
+    #[doc(alias = "kCGColorSpaceExtendedLinearITUR_2020")]
     #[inline]
     pub fn extended_linear_itur_2020() -> &'static cf::String {
         unsafe { kCGColorSpaceExtendedLinearITUR_2020 }
     }
 
+    #[doc(alias = "kCGColorSpaceLinearDisplayP3")]
     #[inline]
     pub fn linear_display_p3() -> &'static cf::String {
         unsafe { kCGColorSpaceLinearDisplayP3 }
     }
 
+    #[doc(alias = "kCGColorSpaceExtendedDisplayP3")]
     #[inline]
     pub fn extended_display_p3() -> &'static cf::String {
         unsafe { kCGColorSpaceExtendedDisplayP3 }
     }
 
+    #[doc(alias = "kCGColorSpaceExtendedLinearDisplayP3")]
     #[inline]
     pub fn extended_linear_display_p3() -> &'static cf::String {
         unsafe { kCGColorSpaceExtendedLinearDisplayP3 }
     }
 
+    #[doc(alias = "kCGColorSpaceITUR_2100_PQ")]
     #[inline]
     pub fn itur_2100_pq() -> &'static cf::String {
         unsafe { kCGColorSpaceITUR_2100_PQ }
     }
 
+    #[doc(alias = "kCGColorSpaceITUR_2100_HLG")]
     #[inline]
     pub fn itur_2100_hlg() -> &'static cf::String {
         unsafe { kCGColorSpaceITUR_2100_HLG }
     }
 
+    #[doc(alias = "kCGColorSpaceDisplayP3_PQ")]
     #[inline]
     pub fn display_p3_pq() -> &'static cf::String {
         unsafe { kCGColorSpaceDisplayP3_PQ }
     }
 
+    #[doc(alias = "kCGColorSpaceDisplayP3_HLG")]
     #[inline]
     pub fn display_p3_hlg() -> &'static cf::String {
         unsafe { kCGColorSpaceDisplayP3_HLG }
     }
 
+    #[doc(alias = "kCGColorSpaceExtendedSRGB")]
     #[inline]
     pub fn extended_srgb() -> &'static cf::String {
         unsafe { kCGColorSpaceExtendedSRGB }
     }
 
+    #[doc(alias = "kCGColorSpaceLinearSRGB")]
     #[inline]
     pub fn linear_srgb() -> &'static cf::String {
         unsafe { kCGColorSpaceLinearSRGB }
     }
 
+    #[doc(alias = "kCGColorSpaceExtendedLinearSRGB")]
     #[inline]
     pub fn extended_linear_srgb() -> &'static cf::String {
         unsafe { kCGColorSpaceExtendedLinearSRGB }
     }
 
+    #[doc(alias = "kCGColorSpaceExtendedGray")]
     #[inline]
     pub fn extended_gray() -> &'static cf::String {
         unsafe { kCGColorSpaceExtendedGray }
     }
 
+    #[doc(alias = "kCGColorSpaceLinearGray")]
     #[inline]
     pub fn linear_gray() -> &'static cf::String {
         unsafe { kCGColorSpaceLinearGray }
     }
 
+    #[doc(alias = "kCGColorSpaceExtendedLinearGray")]
     #[inline]
     pub fn extended_linear_gray() -> &'static cf::String {
         unsafe { kCGColorSpaceExtendedLinearGray }
diff --git a/cidre/src/cg/path.rs b/cidre/src/cg/path.rs
index 3f1e19ae..fc29f9f7 100644
--- a/cidre/src/cg/path.rs
+++ b/cidre/src/cg/path.rs
@@ -11,6 +11,7 @@ pub type ApplyBlock<Attr> = blocks::Block<fn(&cg::PathElement), Attr>;
 
 pub type PathApplierFn<T> = extern "C" fn(info: *mut T, element: *mut Element);
 
+#[doc(alias = "CGLineJoin")]
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 #[repr(i32)]
 pub enum LineJoin {
@@ -19,6 +20,7 @@ pub enum LineJoin {
     Bevel,
 }
 
+#[doc(alias = "CGLineCap")]
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 #[repr(i32)]
 pub enum LineCap {
@@ -27,6 +29,7 @@ pub enum LineCap {
     Square,
 }
 
+#[doc(alias = "CGPathElementType")]
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 #[repr(i32)]
 pub enum ElementType {
@@ -37,6 +40,7 @@ pub enum ElementType {
     CloseSubpath,
 }
 
+#[doc(alias = "CGPathElement")]
 #[derive(Debug)]
 #[repr(C)]
 pub struct Element {
@@ -70,28 +74,37 @@ impl Element {
     }
 }
 
-define_cf_type!(Path(cf::Type));
+define_cf_type!(
+    #[doc(alias = "CGPathRef")]
+    Path(cf::Type)
+);
+
 impl Path {
+    #[doc(alias = "CGPathGetTypeID")]
     #[inline]
     pub fn type_id() -> cf::TypeId {
         unsafe { CGPathGetTypeID() }
     }
 
+    #[doc(alias = "CGPathCreateCopy")]
     #[inline]
     pub fn copy(&self) -> arc::R<Self> {
         unsafe { CGPathCreateCopy(self) }
     }
 
+    #[doc(alias = "CGPathCreateMutableCopy")]
     #[inline]
     pub fn copy_mut(&self) -> arc::R<PathMut> {
         unsafe { CGPathCreateMutableCopy(self) }
     }
 
+    #[doc(alias = "CGPathCreateCopyByTransformingPath")]
     #[inline]
     pub fn copy_transforming_path(&self, transform: Option<&cg::AffineTransform>) -> arc::R<Self> {
         unsafe { CGPathCreateCopyByTransformingPath(self, transform) }
     }
 
+    #[doc(alias = "CGPathCreateMutableCopyByTransformingPath")]
     #[inline]
     pub fn copy_mut_transforming_path(
         &self,
@@ -100,6 +113,7 @@ impl Path {
         unsafe { CGPathCreateMutableCopyByTransformingPath(self, transform) }
     }
 
+    #[doc(alias = "CGPathCreateCopyByDashingPath")]
     #[inline]
     pub fn copy_dashing_path(
         &self,
@@ -112,6 +126,7 @@ impl Path {
         }
     }
 
+    #[doc(alias = "CGPathCreateCopyByStrokingPath")]
     #[inline]
     pub fn copy_stroking_path(
         &self,
@@ -133,16 +148,19 @@ impl Path {
         }
     }
 
+    #[doc(alias = "CGPathEqualToPath")]
     #[inline]
     pub fn equal(&self, other: &Path) -> bool {
         unsafe { CGPathEqualToPath(self, other) }
     }
 
+    #[doc(alias = "CGPathCreateWithRect")]
     #[inline]
     pub fn with_rect(rect: cg::Rect, transform: Option<&cg::AffineTransform>) -> arc::R<Self> {
         unsafe { CGPathCreateWithRect(rect, transform) }
     }
 
+    #[doc(alias = "CGPathCreateWithEllipseInRect")]
     #[inline]
     pub fn with_ellipse_in_rect(
         rect: cg::Rect,
@@ -151,6 +169,7 @@ impl Path {
         unsafe { CGPathCreateWithEllipseInRect(rect, transform) }
     }
 
+    #[doc(alias = "CGPathCreateWithRoundedRect")]
     #[inline]
     pub fn with_rounded_rect(
         rect: cg::Rect,
@@ -161,26 +180,31 @@ impl Path {
         unsafe { CGPathCreateWithRoundedRect(rect, corner_width, corner_height, transform) }
     }
 
+    #[doc(alias = "CGPathIsEmpty")]
     #[inline]
     pub fn is_empty(&self) -> bool {
         unsafe { CGPathIsEmpty(self) }
     }
 
+    #[doc(alias = "CGPathIsRect")]
     #[inline]
     pub fn is_rect(&self) -> bool {
         unsafe { CGPathIsRect(self) }
     }
 
+    #[doc(alias = "CGPathGetCurrentPoint")]
     #[inline]
     pub fn current_point(&self) -> cg::Point {
         unsafe { CGPathGetCurrentPoint(self) }
     }
 
+    #[doc(alias = "CGPathGetBoundingBox")]
     #[inline]
     pub fn bounding_box(&self) -> cg::Rect {
         unsafe { CGPathGetBoundingBox(self) }
     }
-
+    
+    #[doc(alias = "CGPathGetPathBoundingBox")]
     #[inline]
     pub fn path_bounding_box(&self) -> cg::Rect {
         unsafe { CGPathGetPathBoundingBox(self) }