// This file was generated by gir (https://github.com/gtk-rs/gir)
// from ../../gir-files
// from ../../pps-girs
// DO NOT EDIT

#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(
    clippy::approx_constant,
    clippy::type_complexity,
    clippy::unreadable_literal,
    clippy::upper_case_acronyms
)]
#![cfg_attr(docsrs, feature(doc_cfg))]

use cairo_sys as cairo;
use gdk_pixbuf_sys as gdk_pixbuf;
use gdk_sys as gdk;
use gio_sys as gio;
use glib_sys as glib;
use gobject_sys as gobject;
use gtk_sys as gtk;
use pango_sys as pango;

#[cfg(unix)]
#[allow(unused_imports)]
use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
#[allow(unused_imports)]
use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
#[allow(unused_imports)]
use std::ffi::{
    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
};

#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};

// Aliases
pub type PpsBackendPage = gpointer;
pub type PpsBackendPageDestroyFunc = glib::GDestroyNotify;

// Enums
pub type PpsAnnotationTextIcon = c_int;
pub const PPS_ANNOTATION_TEXT_ICON_NOTE: PpsAnnotationTextIcon = 0;
pub const PPS_ANNOTATION_TEXT_ICON_COMMENT: PpsAnnotationTextIcon = 1;
pub const PPS_ANNOTATION_TEXT_ICON_KEY: PpsAnnotationTextIcon = 2;
pub const PPS_ANNOTATION_TEXT_ICON_HELP: PpsAnnotationTextIcon = 3;
pub const PPS_ANNOTATION_TEXT_ICON_NEW_PARAGRAPH: PpsAnnotationTextIcon = 4;
pub const PPS_ANNOTATION_TEXT_ICON_PARAGRAPH: PpsAnnotationTextIcon = 5;
pub const PPS_ANNOTATION_TEXT_ICON_INSERT: PpsAnnotationTextIcon = 6;
pub const PPS_ANNOTATION_TEXT_ICON_CROSS: PpsAnnotationTextIcon = 7;
pub const PPS_ANNOTATION_TEXT_ICON_CIRCLE: PpsAnnotationTextIcon = 8;
pub const PPS_ANNOTATION_TEXT_ICON_UNKNOWN: PpsAnnotationTextIcon = 9;

pub type PpsAnnotationTextMarkupType = c_int;
pub const PPS_ANNOTATION_TEXT_MARKUP_HIGHLIGHT: PpsAnnotationTextMarkupType = 0;
pub const PPS_ANNOTATION_TEXT_MARKUP_STRIKE_OUT: PpsAnnotationTextMarkupType = 1;
pub const PPS_ANNOTATION_TEXT_MARKUP_UNDERLINE: PpsAnnotationTextMarkupType = 2;
pub const PPS_ANNOTATION_TEXT_MARKUP_SQUIGGLY: PpsAnnotationTextMarkupType = 3;

pub type PpsAnnotationType = c_int;
pub const PPS_ANNOTATION_TYPE_UNKNOWN: PpsAnnotationType = 0;
pub const PPS_ANNOTATION_TYPE_TEXT: PpsAnnotationType = 1;
pub const PPS_ANNOTATION_TYPE_FREE_TEXT: PpsAnnotationType = 2;
pub const PPS_ANNOTATION_TYPE_ATTACHMENT: PpsAnnotationType = 3;
pub const PPS_ANNOTATION_TYPE_TEXT_MARKUP: PpsAnnotationType = 4;
pub const PPS_ANNOTATION_TYPE_STAMP: PpsAnnotationType = 5;

pub type PpsAnnotationsOverMarkup = c_int;
pub const PPS_ANNOTATION_OVER_MARKUP_NOT_IMPLEMENTED: PpsAnnotationsOverMarkup = 0;
pub const PPS_ANNOTATION_OVER_MARKUP_UNKNOWN: PpsAnnotationsOverMarkup = 1;
pub const PPS_ANNOTATION_OVER_MARKUP_YES: PpsAnnotationsOverMarkup = 2;
pub const PPS_ANNOTATION_OVER_MARKUP_NOT: PpsAnnotationsOverMarkup = 3;

pub type PpsCertificateStatus = c_int;
pub const PPS_CERTIFICATE_STATUS_TRUSTED: PpsCertificateStatus = 0;
pub const PPS_CERTIFICATE_STATUS_UNTRUSTED_ISSUER: PpsCertificateStatus = 1;
pub const PPS_CERTIFICATE_STATUS_UNKNOWN_ISSUER: PpsCertificateStatus = 2;
pub const PPS_CERTIFICATE_STATUS_REVOKED: PpsCertificateStatus = 3;
pub const PPS_CERTIFICATE_STATUS_EXPIRED: PpsCertificateStatus = 4;
pub const PPS_CERTIFICATE_STATUS_GENERIC_ERROR: PpsCertificateStatus = 5;
pub const PPS_CERTIFICATE_STATUS_NOT_VERIFIED: PpsCertificateStatus = 6;

pub type PpsCompressionType = c_int;
pub const PPS_COMPRESSION_NONE: PpsCompressionType = 0;
pub const PPS_COMPRESSION_BZIP2: PpsCompressionType = 1;
pub const PPS_COMPRESSION_GZIP: PpsCompressionType = 2;
pub const PPS_COMPRESSION_LZMA: PpsCompressionType = 3;

pub type PpsDocumentContainsJS = c_int;
pub const PPS_DOCUMENT_CONTAINS_JS_UNKNOWN: PpsDocumentContainsJS = 0;
pub const PPS_DOCUMENT_CONTAINS_JS_NO: PpsDocumentContainsJS = 1;
pub const PPS_DOCUMENT_CONTAINS_JS_YES: PpsDocumentContainsJS = 2;

pub type PpsDocumentError = c_int;
pub const PPS_DOCUMENT_ERROR_INVALID: PpsDocumentError = 0;
pub const PPS_DOCUMENT_ERROR_UNSUPPORTED_CONTENT: PpsDocumentError = 1;
pub const PPS_DOCUMENT_ERROR_ENCRYPTED: PpsDocumentError = 2;

pub type PpsDocumentLayout = c_int;
pub const PPS_DOCUMENT_LAYOUT_SINGLE_PAGE: PpsDocumentLayout = 0;
pub const PPS_DOCUMENT_LAYOUT_ONE_COLUMN: PpsDocumentLayout = 1;
pub const PPS_DOCUMENT_LAYOUT_TWO_COLUMN_LEFT: PpsDocumentLayout = 2;
pub const PPS_DOCUMENT_LAYOUT_TWO_COLUMN_RIGHT: PpsDocumentLayout = 3;
pub const PPS_DOCUMENT_LAYOUT_TWO_PAGE_LEFT: PpsDocumentLayout = 4;
pub const PPS_DOCUMENT_LAYOUT_TWO_PAGE_RIGHT: PpsDocumentLayout = 5;

pub type PpsDocumentMode = c_int;
pub const PPS_DOCUMENT_MODE_NONE: PpsDocumentMode = 0;
pub const PPS_DOCUMENT_MODE_USE_OC: PpsDocumentMode = 1;
pub const PPS_DOCUMENT_MODE_USE_THUMBS: PpsDocumentMode = 2;
pub const PPS_DOCUMENT_MODE_FULL_SCREEN: PpsDocumentMode = 3;
pub const PPS_DOCUMENT_MODE_USE_ATTACHMENTS: PpsDocumentMode = 4;
pub const PPS_DOCUMENT_MODE_PRESENTATION: PpsDocumentMode = 3;

pub type PpsFileExporterFormat = c_int;
pub const PPS_FILE_FORMAT_UNKNOWN: PpsFileExporterFormat = 0;
pub const PPS_FILE_FORMAT_PS: PpsFileExporterFormat = 1;
pub const PPS_FILE_FORMAT_PDF: PpsFileExporterFormat = 2;

pub type PpsFormFieldButtonType = c_int;
pub const PPS_FORM_FIELD_BUTTON_PUSH: PpsFormFieldButtonType = 0;
pub const PPS_FORM_FIELD_BUTTON_CHECK: PpsFormFieldButtonType = 1;
pub const PPS_FORM_FIELD_BUTTON_RADIO: PpsFormFieldButtonType = 2;

pub type PpsFormFieldChoiceType = c_int;
pub const PPS_FORM_FIELD_CHOICE_COMBO: PpsFormFieldChoiceType = 0;
pub const PPS_FORM_FIELD_CHOICE_LIST: PpsFormFieldChoiceType = 1;

pub type PpsFormFieldTextType = c_int;
pub const PPS_FORM_FIELD_TEXT_NORMAL: PpsFormFieldTextType = 0;
pub const PPS_FORM_FIELD_TEXT_MULTILINE: PpsFormFieldTextType = 1;
pub const PPS_FORM_FIELD_TEXT_FILE_SELECT: PpsFormFieldTextType = 2;

pub type PpsLinkActionType = c_int;
pub const PPS_LINK_ACTION_TYPE_GOTO_DEST: PpsLinkActionType = 0;
pub const PPS_LINK_ACTION_TYPE_GOTO_REMOTE: PpsLinkActionType = 1;
pub const PPS_LINK_ACTION_TYPE_EXTERNAL_URI: PpsLinkActionType = 2;
pub const PPS_LINK_ACTION_TYPE_LAUNCH: PpsLinkActionType = 3;
pub const PPS_LINK_ACTION_TYPE_NAMED: PpsLinkActionType = 4;
pub const PPS_LINK_ACTION_TYPE_LAYERS_STATE: PpsLinkActionType = 5;
pub const PPS_LINK_ACTION_TYPE_RESET_FORM: PpsLinkActionType = 6;

pub type PpsLinkDestType = c_int;
pub const PPS_LINK_DEST_TYPE_PAGE: PpsLinkDestType = 0;
pub const PPS_LINK_DEST_TYPE_XYZ: PpsLinkDestType = 1;
pub const PPS_LINK_DEST_TYPE_FIT: PpsLinkDestType = 2;
pub const PPS_LINK_DEST_TYPE_FITH: PpsLinkDestType = 3;
pub const PPS_LINK_DEST_TYPE_FITV: PpsLinkDestType = 4;
pub const PPS_LINK_DEST_TYPE_FITR: PpsLinkDestType = 5;
pub const PPS_LINK_DEST_TYPE_NAMED: PpsLinkDestType = 6;
pub const PPS_LINK_DEST_TYPE_PAGE_LABEL: PpsLinkDestType = 7;
pub const PPS_LINK_DEST_TYPE_UNKNOWN: PpsLinkDestType = 8;

pub type PpsSelectionStyle = c_int;
pub const PPS_SELECTION_STYLE_GLYPH: PpsSelectionStyle = 0;
pub const PPS_SELECTION_STYLE_WORD: PpsSelectionStyle = 1;
pub const PPS_SELECTION_STYLE_LINE: PpsSelectionStyle = 2;

pub type PpsSignatureStatus = c_int;
pub const PPS_SIGNATURE_STATUS_VALID: PpsSignatureStatus = 0;
pub const PPS_SIGNATURE_STATUS_INVALID: PpsSignatureStatus = 1;
pub const PPS_SIGNATURE_STATUS_DIGEST_MISMATCH: PpsSignatureStatus = 2;
pub const PPS_SIGNATURE_STATUS_DECODING_ERROR: PpsSignatureStatus = 3;
pub const PPS_SIGNATURE_STATUS_GENERIC_ERROR: PpsSignatureStatus = 4;

pub type PpsTransitionEffectAlignment = c_int;
pub const PPS_TRANSITION_ALIGNMENT_HORIZONTAL: PpsTransitionEffectAlignment = 0;
pub const PPS_TRANSITION_ALIGNMENT_VERTICAL: PpsTransitionEffectAlignment = 1;

pub type PpsTransitionEffectDirection = c_int;
pub const PPS_TRANSITION_DIRECTION_INWARD: PpsTransitionEffectDirection = 0;
pub const PPS_TRANSITION_DIRECTION_OUTWARD: PpsTransitionEffectDirection = 1;

pub type PpsTransitionEffectType = c_int;
pub const PPS_TRANSITION_EFFECT_REPLACE: PpsTransitionEffectType = 0;
pub const PPS_TRANSITION_EFFECT_SPLIT: PpsTransitionEffectType = 1;
pub const PPS_TRANSITION_EFFECT_BLINDS: PpsTransitionEffectType = 2;
pub const PPS_TRANSITION_EFFECT_BOX: PpsTransitionEffectType = 3;
pub const PPS_TRANSITION_EFFECT_WIPE: PpsTransitionEffectType = 4;
pub const PPS_TRANSITION_EFFECT_DISSOLVE: PpsTransitionEffectType = 5;
pub const PPS_TRANSITION_EFFECT_GLITTER: PpsTransitionEffectType = 6;
pub const PPS_TRANSITION_EFFECT_FLY: PpsTransitionEffectType = 7;
pub const PPS_TRANSITION_EFFECT_PUSH: PpsTransitionEffectType = 8;
pub const PPS_TRANSITION_EFFECT_COVER: PpsTransitionEffectType = 9;
pub const PPS_TRANSITION_EFFECT_UNCOVER: PpsTransitionEffectType = 10;
pub const PPS_TRANSITION_EFFECT_FADE: PpsTransitionEffectType = 11;

// Constants
pub const PPS_MAJOR_VERSION: c_int = 49;

// Flags
pub type PpsDocumentInfoFields = c_uint;
pub const PPS_DOCUMENT_INFO_TITLE: PpsDocumentInfoFields = 1;
pub const PPS_DOCUMENT_INFO_FORMAT: PpsDocumentInfoFields = 2;
pub const PPS_DOCUMENT_INFO_AUTHOR: PpsDocumentInfoFields = 4;
pub const PPS_DOCUMENT_INFO_SUBJECT: PpsDocumentInfoFields = 8;
pub const PPS_DOCUMENT_INFO_KEYWORDS: PpsDocumentInfoFields = 16;
pub const PPS_DOCUMENT_INFO_LAYOUT: PpsDocumentInfoFields = 32;
pub const PPS_DOCUMENT_INFO_CREATOR: PpsDocumentInfoFields = 64;
pub const PPS_DOCUMENT_INFO_PRODUCER: PpsDocumentInfoFields = 128;
pub const PPS_DOCUMENT_INFO_CREATION_DATETIME: PpsDocumentInfoFields = 256;
pub const PPS_DOCUMENT_INFO_MOD_DATETIME: PpsDocumentInfoFields = 512;
pub const PPS_DOCUMENT_INFO_LINEARIZED: PpsDocumentInfoFields = 1024;
pub const PPS_DOCUMENT_INFO_START_MODE: PpsDocumentInfoFields = 2048;
pub const PPS_DOCUMENT_INFO_UI_HINTS: PpsDocumentInfoFields = 4096;
pub const PPS_DOCUMENT_INFO_PERMISSIONS: PpsDocumentInfoFields = 8192;
pub const PPS_DOCUMENT_INFO_N_PAGES: PpsDocumentInfoFields = 16384;
pub const PPS_DOCUMENT_INFO_SECURITY: PpsDocumentInfoFields = 32768;
pub const PPS_DOCUMENT_INFO_PAPER_SIZE: PpsDocumentInfoFields = 65536;
pub const PPS_DOCUMENT_INFO_LICENSE: PpsDocumentInfoFields = 131072;
pub const PPS_DOCUMENT_INFO_CONTAINS_JS: PpsDocumentInfoFields = 262144;

pub type PpsDocumentLoadFlags = c_uint;
pub const PPS_DOCUMENT_LOAD_FLAG_NONE: PpsDocumentLoadFlags = 0;
pub const PPS_DOCUMENT_LOAD_FLAG_NO_CACHE: PpsDocumentLoadFlags = 1;

pub type PpsDocumentPermissions = c_uint;
pub const PPS_DOCUMENT_PERMISSIONS_OK_TO_PRINT: PpsDocumentPermissions = 1;
pub const PPS_DOCUMENT_PERMISSIONS_OK_TO_MODIFY: PpsDocumentPermissions = 2;
pub const PPS_DOCUMENT_PERMISSIONS_OK_TO_COPY: PpsDocumentPermissions = 4;
pub const PPS_DOCUMENT_PERMISSIONS_OK_TO_ADD_NOTES: PpsDocumentPermissions = 8;
pub const PPS_DOCUMENT_PERMISSIONS_FULL: PpsDocumentPermissions = 15;

pub type PpsDocumentUIHints = c_uint;
pub const PPS_DOCUMENT_UI_HINT_HIDE_TOOLBAR: PpsDocumentUIHints = 1;
pub const PPS_DOCUMENT_UI_HINT_HIDE_MENUBAR: PpsDocumentUIHints = 2;
pub const PPS_DOCUMENT_UI_HINT_HIDE_WINDOWUI: PpsDocumentUIHints = 4;
pub const PPS_DOCUMENT_UI_HINT_FIT_WINDOW: PpsDocumentUIHints = 8;
pub const PPS_DOCUMENT_UI_HINT_CENTER_WINDOW: PpsDocumentUIHints = 16;
pub const PPS_DOCUMENT_UI_HINT_DISPLAY_DOC_TITLE: PpsDocumentUIHints = 32;
pub const PPS_DOCUMENT_UI_HINT_DIRECTION_RTL: PpsDocumentUIHints = 64;

pub type PpsFileExporterCapabilities = c_uint;
pub const PPS_FILE_EXPORTER_CAN_PAGE_SET: PpsFileExporterCapabilities = 1;
pub const PPS_FILE_EXPORTER_CAN_COPIES: PpsFileExporterCapabilities = 2;
pub const PPS_FILE_EXPORTER_CAN_COLLATE: PpsFileExporterCapabilities = 4;
pub const PPS_FILE_EXPORTER_CAN_REVERSE: PpsFileExporterCapabilities = 8;
pub const PPS_FILE_EXPORTER_CAN_SCALE: PpsFileExporterCapabilities = 16;
pub const PPS_FILE_EXPORTER_CAN_GENERATE_PDF: PpsFileExporterCapabilities = 32;
pub const PPS_FILE_EXPORTER_CAN_GENERATE_PS: PpsFileExporterCapabilities = 64;
pub const PPS_FILE_EXPORTER_CAN_PREVIEW: PpsFileExporterCapabilities = 128;
pub const PPS_FILE_EXPORTER_CAN_NUMBER_UP: PpsFileExporterCapabilities = 256;

pub type PpsFindOptions = c_uint;
pub const PPS_FIND_DEFAULT: PpsFindOptions = 0;
pub const PPS_FIND_CASE_SENSITIVE: PpsFindOptions = 1;
pub const PPS_FIND_WHOLE_WORDS_ONLY: PpsFindOptions = 2;

pub type PpsRenderAnnotsFlags = c_uint;
pub const PPS_RENDER_ANNOTS_NONE: PpsRenderAnnotsFlags = 0;
pub const PPS_RENDER_ANNOTS_TEXT: PpsRenderAnnotsFlags = 1;
pub const PPS_RENDER_ANNOTS_LINK: PpsRenderAnnotsFlags = 2;
pub const PPS_RENDER_ANNOTS_FREETEXT: PpsRenderAnnotsFlags = 4;
pub const PPS_RENDER_ANNOTS_LINE: PpsRenderAnnotsFlags = 8;
pub const PPS_RENDER_ANNOTS_SQUARE: PpsRenderAnnotsFlags = 16;
pub const PPS_RENDER_ANNOTS_CIRCLE: PpsRenderAnnotsFlags = 32;
pub const PPS_RENDER_ANNOTS_POLYGON: PpsRenderAnnotsFlags = 64;
pub const PPS_RENDER_ANNOTS_POLYLINE: PpsRenderAnnotsFlags = 128;
pub const PPS_RENDER_ANNOTS_HIGHLIGHT: PpsRenderAnnotsFlags = 256;
pub const PPS_RENDER_ANNOTS_UNDERLINE: PpsRenderAnnotsFlags = 512;
pub const PPS_RENDER_ANNOTS_SQUIGGLY: PpsRenderAnnotsFlags = 1024;
pub const PPS_RENDER_ANNOTS_STRIKEOUT: PpsRenderAnnotsFlags = 2048;
pub const PPS_RENDER_ANNOTS_STAMP: PpsRenderAnnotsFlags = 4096;
pub const PPS_RENDER_ANNOTS_CARET: PpsRenderAnnotsFlags = 8192;
pub const PPS_RENDER_ANNOTS_INK: PpsRenderAnnotsFlags = 16384;
pub const PPS_RENDER_ANNOTS_POPUP: PpsRenderAnnotsFlags = 32768;
pub const PPS_RENDER_ANNOTS_FILEATTACHMENT: PpsRenderAnnotsFlags = 65536;
pub const PPS_RENDER_ANNOTS_SOUND: PpsRenderAnnotsFlags = 131072;
pub const PPS_RENDER_ANNOTS_MOVIE: PpsRenderAnnotsFlags = 262144;
pub const PPS_RENDER_ANNOTS_WIDGET: PpsRenderAnnotsFlags = 524288;
pub const PPS_RENDER_ANNOTS_SCREEN: PpsRenderAnnotsFlags = 1048576;
pub const PPS_RENDER_ANNOTS_PRINTERMARK: PpsRenderAnnotsFlags = 2097152;
pub const PPS_RENDER_ANNOTS_TRAPNET: PpsRenderAnnotsFlags = 4194304;
pub const PPS_RENDER_ANNOTS_WATERMARK: PpsRenderAnnotsFlags = 8388608;
pub const PPS_RENDER_ANNOTS_3D: PpsRenderAnnotsFlags = 16777216;
pub const PPS_RENDER_ANNOTS_RICHMEDIA: PpsRenderAnnotsFlags = 33554432;
pub const PPS_RENDER_ANNOTS_PRINT_DOCUMENT: PpsRenderAnnotsFlags = 524288;
pub const PPS_RENDER_ANNOTS_PRINT_MARKUP: PpsRenderAnnotsFlags = 4262166525;
pub const PPS_RENDER_ANNOTS_PRINT_STAMP: PpsRenderAnnotsFlags = 528384;
pub const PPS_RENDER_ANNOTS_PRINT_ALL: PpsRenderAnnotsFlags = 4262166525;
pub const PPS_RENDER_ANNOTS_ALL: PpsRenderAnnotsFlags = 67108863;

// Callbacks
pub type PpsSignaturePasswordCallback =
    Option<unsafe extern "C" fn(*const c_char, gpointer) -> *mut c_char>;

// Records
#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsAnnotationAttachmentClass {
    pub parent_class: PpsAnnotationClass,
}

impl ::std::fmt::Debug for PpsAnnotationAttachmentClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsAnnotationAttachmentClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsAnnotationClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PpsAnnotationClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsAnnotationClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsAnnotationFreeTextClass {
    pub parent_class: PpsAnnotationClass,
}

impl ::std::fmt::Debug for PpsAnnotationFreeTextClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsAnnotationFreeTextClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsAnnotationMarkupClass {
    pub parent_class: PpsAnnotationClass,
}

impl ::std::fmt::Debug for PpsAnnotationMarkupClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsAnnotationMarkupClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsAnnotationStampClass {
    pub parent_class: PpsAnnotationClass,
}

impl ::std::fmt::Debug for PpsAnnotationStampClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsAnnotationStampClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsAnnotationTextClass {
    pub parent_class: PpsAnnotationClass,
}

impl ::std::fmt::Debug for PpsAnnotationTextClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsAnnotationTextClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsAnnotationTextMarkupClass {
    pub parent_class: PpsAnnotationClass,
}

impl ::std::fmt::Debug for PpsAnnotationTextMarkupClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsAnnotationTextMarkupClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsAttachmentClass {
    pub base_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PpsAttachmentClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsAttachmentClass @ {self:p}"))
            .field("base_class", &self.base_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsCertificateInfoClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PpsCertificateInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsCertificateInfoClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentAnnotationsInterface {
    pub base_iface: gobject::GTypeInterface,
    pub get_annotations:
        Option<unsafe extern "C" fn(*mut PpsDocumentAnnotations, *mut PpsPage) -> *mut glib::GList>,
    pub document_is_modified: Option<unsafe extern "C" fn(*mut PpsDocumentAnnotations) -> gboolean>,
    pub add_annotation:
        Option<unsafe extern "C" fn(*mut PpsDocumentAnnotations, *mut PpsAnnotation)>,
    pub remove_annotation:
        Option<unsafe extern "C" fn(*mut PpsDocumentAnnotations, *mut PpsAnnotation)>,
    pub over_markup: Option<
        unsafe extern "C" fn(
            *mut PpsDocumentAnnotations,
            *mut PpsAnnotation,
            c_double,
            c_double,
        ) -> PpsAnnotationsOverMarkup,
    >,
}

impl ::std::fmt::Debug for PpsDocumentAnnotationsInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentAnnotationsInterface @ {self:p}"))
            .field("base_iface", &self.base_iface)
            .field("get_annotations", &self.get_annotations)
            .field("document_is_modified", &self.document_is_modified)
            .field("add_annotation", &self.add_annotation)
            .field("remove_annotation", &self.remove_annotation)
            .field("over_markup", &self.over_markup)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentAttachmentsInterface {
    pub base_iface: gobject::GTypeInterface,
    pub has_attachments: Option<unsafe extern "C" fn(*mut PpsDocumentAttachments) -> gboolean>,
    pub get_attachments:
        Option<unsafe extern "C" fn(*mut PpsDocumentAttachments) -> *mut glib::GList>,
}

impl ::std::fmt::Debug for PpsDocumentAttachmentsInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentAttachmentsInterface @ {self:p}"))
            .field("base_iface", &self.base_iface)
            .field("has_attachments", &self.has_attachments)
            .field("get_attachments", &self.get_attachments)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentBackendInfo {
    pub name: *const c_char,
    pub version: *const c_char,
}

impl ::std::fmt::Debug for PpsDocumentBackendInfo {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentBackendInfo @ {self:p}"))
            .field("name", &self.name)
            .field("version", &self.version)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentClass {
    pub base_class: gobject::GObjectClass,
    pub load: Option<
        unsafe extern "C" fn(*mut PpsDocument, *const c_char, *mut *mut glib::GError) -> gboolean,
    >,
    pub load_fd:
        Option<unsafe extern "C" fn(*mut PpsDocument, c_int, *mut *mut glib::GError) -> gboolean>,
    pub save: Option<
        unsafe extern "C" fn(*mut PpsDocument, *const c_char, *mut *mut glib::GError) -> gboolean,
    >,
    pub get_n_pages: Option<unsafe extern "C" fn(*mut PpsDocument) -> c_int>,
    pub get_page: Option<unsafe extern "C" fn(*mut PpsDocument, c_int) -> *mut PpsPage>,
    pub get_page_size:
        Option<unsafe extern "C" fn(*mut PpsDocument, *mut PpsPage, *mut c_double, *mut c_double)>,
    pub get_page_label: Option<unsafe extern "C" fn(*mut PpsDocument, *mut PpsPage) -> *mut c_char>,
    pub render: Option<
        unsafe extern "C" fn(
            *mut PpsDocument,
            *mut PpsRenderContext,
        ) -> *mut cairo::cairo_surface_t,
    >,
    pub get_thumbnail: Option<
        unsafe extern "C" fn(*mut PpsDocument, *mut PpsRenderContext) -> *mut gdk_pixbuf::GdkPixbuf,
    >,
    pub get_thumbnail_surface: Option<
        unsafe extern "C" fn(
            *mut PpsDocument,
            *mut PpsRenderContext,
        ) -> *mut cairo::cairo_surface_t,
    >,
    pub get_info: Option<unsafe extern "C" fn(*mut PpsDocument) -> *mut PpsDocumentInfo>,
    pub get_backend_info:
        Option<unsafe extern "C" fn(*mut PpsDocument, *mut PpsDocumentBackendInfo) -> gboolean>,
}

impl ::std::fmt::Debug for PpsDocumentClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentClass @ {self:p}"))
            .field("base_class", &self.base_class)
            .field("load", &self.load)
            .field("load_fd", &self.load_fd)
            .field("save", &self.save)
            .field("get_n_pages", &self.get_n_pages)
            .field("get_page", &self.get_page)
            .field("get_page_size", &self.get_page_size)
            .field("get_page_label", &self.get_page_label)
            .field("render", &self.render)
            .field("get_thumbnail", &self.get_thumbnail)
            .field("get_thumbnail_surface", &self.get_thumbnail_surface)
            .field("get_info", &self.get_info)
            .field("get_backend_info", &self.get_backend_info)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentFindInterface {
    pub base_iface: gobject::GTypeInterface,
    pub get_supported_options: Option<unsafe extern "C" fn(*mut PpsDocumentFind) -> PpsFindOptions>,
    pub find_text: Option<
        unsafe extern "C" fn(
            *mut PpsDocumentFind,
            *mut PpsPage,
            *const c_char,
            PpsFindOptions,
        ) -> *mut glib::GList,
    >,
}

impl ::std::fmt::Debug for PpsDocumentFindInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentFindInterface @ {self:p}"))
            .field("base_iface", &self.base_iface)
            .field("get_supported_options", &self.get_supported_options)
            .field("find_text", &self.find_text)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentFontsInterface {
    pub base_iface: gobject::GTypeInterface,
    pub scan: Option<unsafe extern "C" fn(*mut PpsDocumentFonts)>,
    pub get_model: Option<unsafe extern "C" fn(*mut PpsDocumentFonts) -> *mut gio::GListModel>,
    pub get_fonts_summary: Option<unsafe extern "C" fn(*mut PpsDocumentFonts) -> *const c_char>,
}

impl ::std::fmt::Debug for PpsDocumentFontsInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentFontsInterface @ {self:p}"))
            .field("base_iface", &self.base_iface)
            .field("scan", &self.scan)
            .field("get_model", &self.get_model)
            .field("get_fonts_summary", &self.get_fonts_summary)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentFormsInterface {
    pub base_iface: gobject::GTypeInterface,
    pub get_form_fields:
        Option<unsafe extern "C" fn(*mut PpsDocumentForms, *mut PpsPage) -> *mut PpsMappingList>,
    pub document_is_modified: Option<unsafe extern "C" fn(*mut PpsDocumentForms) -> gboolean>,
    pub form_field_text_get_text:
        Option<unsafe extern "C" fn(*mut PpsDocumentForms, *mut PpsFormField) -> *mut c_char>,
    pub form_field_text_set_text:
        Option<unsafe extern "C" fn(*mut PpsDocumentForms, *mut PpsFormField, *const c_char)>,
    pub form_field_button_get_state:
        Option<unsafe extern "C" fn(*mut PpsDocumentForms, *mut PpsFormField) -> gboolean>,
    pub form_field_button_set_state:
        Option<unsafe extern "C" fn(*mut PpsDocumentForms, *mut PpsFormField, gboolean)>,
    pub form_field_choice_get_item: Option<
        unsafe extern "C" fn(*mut PpsDocumentForms, *mut PpsFormField, c_int) -> *mut c_char,
    >,
    pub form_field_choice_get_n_items:
        Option<unsafe extern "C" fn(*mut PpsDocumentForms, *mut PpsFormField) -> c_int>,
    pub form_field_choice_is_item_selected:
        Option<unsafe extern "C" fn(*mut PpsDocumentForms, *mut PpsFormField, c_int) -> gboolean>,
    pub form_field_choice_select_item:
        Option<unsafe extern "C" fn(*mut PpsDocumentForms, *mut PpsFormField, c_int)>,
    pub form_field_choice_toggle_item:
        Option<unsafe extern "C" fn(*mut PpsDocumentForms, *mut PpsFormField, c_int)>,
    pub form_field_choice_unselect_all:
        Option<unsafe extern "C" fn(*mut PpsDocumentForms, *mut PpsFormField)>,
    pub form_field_choice_set_text:
        Option<unsafe extern "C" fn(*mut PpsDocumentForms, *mut PpsFormField, *const c_char)>,
    pub form_field_choice_get_text:
        Option<unsafe extern "C" fn(*mut PpsDocumentForms, *mut PpsFormField) -> *mut c_char>,
    pub reset_form: Option<unsafe extern "C" fn(*mut PpsDocumentForms, *mut PpsLinkAction)>,
}

impl ::std::fmt::Debug for PpsDocumentFormsInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentFormsInterface @ {self:p}"))
            .field("base_iface", &self.base_iface)
            .field("get_form_fields", &self.get_form_fields)
            .field("document_is_modified", &self.document_is_modified)
            .field("form_field_text_get_text", &self.form_field_text_get_text)
            .field("form_field_text_set_text", &self.form_field_text_set_text)
            .field(
                "form_field_button_get_state",
                &self.form_field_button_get_state,
            )
            .field(
                "form_field_button_set_state",
                &self.form_field_button_set_state,
            )
            .field(
                "form_field_choice_get_item",
                &self.form_field_choice_get_item,
            )
            .field(
                "form_field_choice_get_n_items",
                &self.form_field_choice_get_n_items,
            )
            .field(
                "form_field_choice_is_item_selected",
                &self.form_field_choice_is_item_selected,
            )
            .field(
                "form_field_choice_select_item",
                &self.form_field_choice_select_item,
            )
            .field(
                "form_field_choice_toggle_item",
                &self.form_field_choice_toggle_item,
            )
            .field(
                "form_field_choice_unselect_all",
                &self.form_field_choice_unselect_all,
            )
            .field(
                "form_field_choice_set_text",
                &self.form_field_choice_set_text,
            )
            .field(
                "form_field_choice_get_text",
                &self.form_field_choice_get_text,
            )
            .field("reset_form", &self.reset_form)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentImagesInterface {
    pub base_iface: gobject::GTypeInterface,
    pub get_image_mapping:
        Option<unsafe extern "C" fn(*mut PpsDocumentImages, *mut PpsPage) -> *mut PpsMappingList>,
    pub get_image: Option<
        unsafe extern "C" fn(*mut PpsDocumentImages, *mut PpsImage) -> *mut gdk_pixbuf::GdkPixbuf,
    >,
}

impl ::std::fmt::Debug for PpsDocumentImagesInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentImagesInterface @ {self:p}"))
            .field("base_iface", &self.base_iface)
            .field("get_image_mapping", &self.get_image_mapping)
            .field("get_image", &self.get_image)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentInfo {
    pub title: *mut c_char,
    pub format: *mut c_char,
    pub author: *mut c_char,
    pub subject: *mut c_char,
    pub keywords: *mut c_char,
    pub creator: *mut c_char,
    pub producer: *mut c_char,
    pub linearized: *mut c_char,
    pub security: *mut c_char,
    pub creation_datetime: *mut glib::GDateTime,
    pub modified_datetime: *mut glib::GDateTime,
    pub layout: PpsDocumentLayout,
    pub mode: PpsDocumentMode,
    pub ui_hints: c_uint,
    pub permissions: c_uint,
    pub n_pages: c_int,
    pub paper_height: c_double,
    pub paper_width: c_double,
    pub license: *mut PpsDocumentLicense,
    pub contains_js: PpsDocumentContainsJS,
    pub fields_mask: c_uint,
}

impl ::std::fmt::Debug for PpsDocumentInfo {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentInfo @ {self:p}"))
            .field("title", &self.title)
            .field("format", &self.format)
            .field("author", &self.author)
            .field("subject", &self.subject)
            .field("keywords", &self.keywords)
            .field("creator", &self.creator)
            .field("producer", &self.producer)
            .field("linearized", &self.linearized)
            .field("security", &self.security)
            .field("creation_datetime", &self.creation_datetime)
            .field("modified_datetime", &self.modified_datetime)
            .field("layout", &self.layout)
            .field("mode", &self.mode)
            .field("ui_hints", &self.ui_hints)
            .field("permissions", &self.permissions)
            .field("n_pages", &self.n_pages)
            .field("paper_height", &self.paper_height)
            .field("paper_width", &self.paper_width)
            .field("license", &self.license)
            .field("contains_js", &self.contains_js)
            .field("fields_mask", &self.fields_mask)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentLayersInterface {
    pub base_iface: gobject::GTypeInterface,
    pub has_layers: Option<unsafe extern "C" fn(*mut PpsDocumentLayers) -> gboolean>,
    pub get_layers: Option<unsafe extern "C" fn(*mut PpsDocumentLayers) -> *mut gio::GListModel>,
    pub show_layer: Option<unsafe extern "C" fn(*mut PpsDocumentLayers, *mut PpsLayer)>,
    pub hide_layer: Option<unsafe extern "C" fn(*mut PpsDocumentLayers, *mut PpsLayer)>,
    pub layer_is_visible:
        Option<unsafe extern "C" fn(*mut PpsDocumentLayers, *mut PpsLayer) -> gboolean>,
}

impl ::std::fmt::Debug for PpsDocumentLayersInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentLayersInterface @ {self:p}"))
            .field("base_iface", &self.base_iface)
            .field("has_layers", &self.has_layers)
            .field("get_layers", &self.get_layers)
            .field("show_layer", &self.show_layer)
            .field("hide_layer", &self.hide_layer)
            .field("layer_is_visible", &self.layer_is_visible)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentLicense {
    pub text: *mut c_char,
    pub uri: *mut c_char,
    pub web_statement: *mut c_char,
}

impl ::std::fmt::Debug for PpsDocumentLicense {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentLicense @ {self:p}"))
            .field("text", &self.text)
            .field("uri", &self.uri)
            .field("web_statement", &self.web_statement)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentLinksInterface {
    pub base_iface: gobject::GTypeInterface,
    pub has_document_links: Option<unsafe extern "C" fn(*mut PpsDocumentLinks) -> gboolean>,
    pub get_links_model:
        Option<unsafe extern "C" fn(*mut PpsDocumentLinks) -> *mut gio::GListModel>,
    pub get_links:
        Option<unsafe extern "C" fn(*mut PpsDocumentLinks, *mut PpsPage) -> *mut PpsMappingList>,
    pub find_link_dest:
        Option<unsafe extern "C" fn(*mut PpsDocumentLinks, *const c_char) -> *mut PpsLinkDest>,
    pub find_link_page: Option<unsafe extern "C" fn(*mut PpsDocumentLinks, *const c_char) -> c_int>,
}

impl ::std::fmt::Debug for PpsDocumentLinksInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentLinksInterface @ {self:p}"))
            .field("base_iface", &self.base_iface)
            .field("has_document_links", &self.has_document_links)
            .field("get_links_model", &self.get_links_model)
            .field("get_links", &self.get_links)
            .field("find_link_dest", &self.find_link_dest)
            .field("find_link_page", &self.find_link_page)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentMediaInterface {
    pub base_iface: gobject::GTypeInterface,
    pub get_media_mapping:
        Option<unsafe extern "C" fn(*mut PpsDocumentMedia, *mut PpsPage) -> *mut PpsMappingList>,
}

impl ::std::fmt::Debug for PpsDocumentMediaInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentMediaInterface @ {self:p}"))
            .field("base_iface", &self.base_iface)
            .field("get_media_mapping", &self.get_media_mapping)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentPoint {
    pub page_index: c_int,
    pub point_on_page: PpsPoint,
}

impl ::std::fmt::Debug for PpsDocumentPoint {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentPoint @ {self:p}"))
            .field("page_index", &self.page_index)
            .field("point_on_page", &self.point_on_page)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentPrintInterface {
    pub base_iface: gobject::GTypeInterface,
    pub print_page:
        Option<unsafe extern "C" fn(*mut PpsDocumentPrint, *mut PpsPage, *mut cairo::cairo_t)>,
}

impl ::std::fmt::Debug for PpsDocumentPrintInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentPrintInterface @ {self:p}"))
            .field("base_iface", &self.base_iface)
            .field("print_page", &self.print_page)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentSecurityInterface {
    pub base_iface: gobject::GTypeInterface,
    pub has_document_security: Option<unsafe extern "C" fn(*mut PpsDocumentSecurity) -> gboolean>,
    pub set_password: Option<unsafe extern "C" fn(*mut PpsDocumentSecurity, *const c_char)>,
}

impl ::std::fmt::Debug for PpsDocumentSecurityInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentSecurityInterface @ {self:p}"))
            .field("base_iface", &self.base_iface)
            .field("has_document_security", &self.has_document_security)
            .field("set_password", &self.set_password)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentSignaturesInterface {
    pub base_iface: gobject::GTypeInterface,
    pub set_password_callback: Option<
        unsafe extern "C" fn(*mut PpsDocumentSignatures, PpsSignaturePasswordCallback, gpointer),
    >,
    pub get_available_signing_certificates:
        Option<unsafe extern "C" fn(*mut PpsDocumentSignatures) -> *mut glib::GList>,
    pub get_certificate_info: Option<
        unsafe extern "C" fn(*mut PpsDocumentSignatures, *const c_char) -> *mut PpsCertificateInfo,
    >,
    pub sign: Option<
        unsafe extern "C" fn(
            *mut PpsDocumentSignatures,
            *mut PpsSignature,
            *mut gio::GCancellable,
            gio::GAsyncReadyCallback,
            gpointer,
        ),
    >,
    pub sign_finish: Option<
        unsafe extern "C" fn(
            *mut PpsDocumentSignatures,
            *mut gio::GAsyncResult,
            *mut *mut glib::GError,
        ) -> gboolean,
    >,
    pub can_sign: Option<unsafe extern "C" fn(*mut PpsDocumentSignatures) -> gboolean>,
    pub has_signatures: Option<unsafe extern "C" fn(*mut PpsDocumentSignatures) -> gboolean>,
    pub get_signatures:
        Option<unsafe extern "C" fn(*mut PpsDocumentSignatures) -> *mut glib::GList>,
}

impl ::std::fmt::Debug for PpsDocumentSignaturesInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentSignaturesInterface @ {self:p}"))
            .field("base_iface", &self.base_iface)
            .field("set_password_callback", &self.set_password_callback)
            .field(
                "get_available_signing_certificates",
                &self.get_available_signing_certificates,
            )
            .field("get_certificate_info", &self.get_certificate_info)
            .field("sign", &self.sign)
            .field("sign_finish", &self.sign_finish)
            .field("can_sign", &self.can_sign)
            .field("has_signatures", &self.has_signatures)
            .field("get_signatures", &self.get_signatures)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentTextInterface {
    pub base_iface: gobject::GTypeInterface,
    pub get_text_mapping: Option<
        unsafe extern "C" fn(*mut PpsDocumentText, *mut PpsPage) -> *mut cairo::cairo_region_t,
    >,
    pub get_text: Option<unsafe extern "C" fn(*mut PpsDocumentText, *mut PpsPage) -> *mut c_char>,
    pub get_text_layout: Option<
        unsafe extern "C" fn(
            *mut PpsDocumentText,
            *mut PpsPage,
            *mut *mut PpsRectangle,
            *mut c_uint,
        ) -> gboolean,
    >,
    pub get_text_in_area: Option<
        unsafe extern "C" fn(*mut PpsDocumentText, *mut PpsPage, *mut PpsRectangle) -> *mut c_char,
    >,
    pub get_text_attrs: Option<
        unsafe extern "C" fn(*mut PpsDocumentText, *mut PpsPage) -> *mut pango::PangoAttrList,
    >,
}

impl ::std::fmt::Debug for PpsDocumentTextInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentTextInterface @ {self:p}"))
            .field("base_iface", &self.base_iface)
            .field("get_text_mapping", &self.get_text_mapping)
            .field("get_text", &self.get_text)
            .field("get_text_layout", &self.get_text_layout)
            .field("get_text_in_area", &self.get_text_in_area)
            .field("get_text_attrs", &self.get_text_attrs)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocumentTransitionInterface {
    pub base_iface: gobject::GTypeInterface,
    pub get_page_duration:
        Option<unsafe extern "C" fn(*mut PpsDocumentTransition, c_int) -> c_double>,
    pub get_effect:
        Option<unsafe extern "C" fn(*mut PpsDocumentTransition, c_int) -> *mut PpsTransitionEffect>,
}

impl ::std::fmt::Debug for PpsDocumentTransitionInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocumentTransitionInterface @ {self:p}"))
            .field("base_iface", &self.base_iface)
            .field("get_page_duration", &self.get_page_duration)
            .field("get_effect", &self.get_effect)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsFileExporterContext {
    pub format: PpsFileExporterFormat,
    pub filename: *const c_char,
    pub first_page: c_int,
    pub last_page: c_int,
    pub paper_width: c_double,
    pub paper_height: c_double,
    pub duplex: gboolean,
    pub pages_per_sheet: c_int,
}

impl ::std::fmt::Debug for PpsFileExporterContext {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsFileExporterContext @ {self:p}"))
            .field("format", &self.format)
            .field("filename", &self.filename)
            .field("first_page", &self.first_page)
            .field("last_page", &self.last_page)
            .field("paper_width", &self.paper_width)
            .field("paper_height", &self.paper_height)
            .field("duplex", &self.duplex)
            .field("pages_per_sheet", &self.pages_per_sheet)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsFileExporterInterface {
    pub base_iface: gobject::GTypeInterface,
    pub begin: Option<unsafe extern "C" fn(*mut PpsFileExporter, *mut PpsFileExporterContext)>,
    pub begin_page: Option<unsafe extern "C" fn(*mut PpsFileExporter)>,
    pub do_page: Option<unsafe extern "C" fn(*mut PpsFileExporter, *mut PpsRenderContext)>,
    pub end_page: Option<unsafe extern "C" fn(*mut PpsFileExporter)>,
    pub end: Option<unsafe extern "C" fn(*mut PpsFileExporter)>,
    pub get_capabilities:
        Option<unsafe extern "C" fn(*mut PpsFileExporter) -> PpsFileExporterCapabilities>,
}

impl ::std::fmt::Debug for PpsFileExporterInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsFileExporterInterface @ {self:p}"))
            .field("base_iface", &self.base_iface)
            .field("begin", &self.begin)
            .field("begin_page", &self.begin_page)
            .field("do_page", &self.do_page)
            .field("end_page", &self.end_page)
            .field("end", &self.end)
            .field("get_capabilities", &self.get_capabilities)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsFindRectangle {
    pub x1: c_double,
    pub y1: c_double,
    pub x2: c_double,
    pub y2: c_double,
    pub next_line: gboolean,
    pub after_hyphen: gboolean,
    pub _pps_reserved1: Option<unsafe extern "C" fn()>,
    pub _pps_reserved2: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for PpsFindRectangle {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsFindRectangle @ {self:p}"))
            .field("x1", &self.x1)
            .field("y1", &self.y1)
            .field("x2", &self.x2)
            .field("y2", &self.y2)
            .field("next_line", &self.next_line)
            .field("after_hyphen", &self.after_hyphen)
            .field("_pps_reserved1", &self._pps_reserved1)
            .field("_pps_reserved2", &self._pps_reserved2)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsFontDescriptionClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PpsFontDescriptionClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsFontDescriptionClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsFormFieldButtonClass {
    pub parent_class: PpsFormFieldClass,
}

impl ::std::fmt::Debug for PpsFormFieldButtonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsFormFieldButtonClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsFormFieldChoiceClass {
    pub parent_class: PpsFormFieldClass,
}

impl ::std::fmt::Debug for PpsFormFieldChoiceClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsFormFieldChoiceClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsFormFieldClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PpsFormFieldClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsFormFieldClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsFormFieldSignatureClass {
    pub parent_class: PpsFormFieldClass,
}

impl ::std::fmt::Debug for PpsFormFieldSignatureClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsFormFieldSignatureClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsFormFieldTextClass {
    pub parent_class: PpsFormFieldClass,
}

impl ::std::fmt::Debug for PpsFormFieldTextClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsFormFieldTextClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsImageClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PpsImageClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsImageClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsLayerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PpsLayerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsLayerClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsLinkActionClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PpsLinkActionClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsLinkActionClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsLinkClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PpsLinkClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsLinkClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsLinkDestClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PpsLinkDestClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsLinkDestClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsMapping {
    pub area: PpsRectangle,
    pub data: gpointer,
}

impl ::std::fmt::Debug for PpsMapping {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsMapping @ {self:p}"))
            .field("area", &self.area)
            .field("data", &self.data)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsMappingList {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsMappingList {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsMappingList @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsMediaClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PpsMediaClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsMediaClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsOutlinesClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PpsOutlinesClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsOutlinesClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsPageClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PpsPageClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsPageClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsPoint {
    pub x: c_double,
    pub y: c_double,
}

impl ::std::fmt::Debug for PpsPoint {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsPoint @ {self:p}"))
            .field("x", &self.x)
            .field("y", &self.y)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsRectangle {
    pub x1: c_double,
    pub y1: c_double,
    pub x2: c_double,
    pub y2: c_double,
}

impl ::std::fmt::Debug for PpsRectangle {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsRectangle @ {self:p}"))
            .field("x1", &self.x1)
            .field("y1", &self.y1)
            .field("x2", &self.x2)
            .field("y2", &self.y2)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsRenderContextClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PpsRenderContextClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsRenderContextClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsSelectionInterface {
    pub base_iface: gobject::GTypeInterface,
    pub render_selection: Option<
        unsafe extern "C" fn(
            *mut PpsSelection,
            *mut PpsRenderContext,
            *mut *mut cairo::cairo_surface_t,
            *mut PpsRectangle,
            *mut PpsRectangle,
            PpsSelectionStyle,
            *mut gdk::GdkRGBA,
            *mut gdk::GdkRGBA,
        ),
    >,
    pub get_selected_text: Option<
        unsafe extern "C" fn(
            *mut PpsSelection,
            *mut PpsPage,
            PpsSelectionStyle,
            *mut PpsRectangle,
        ) -> *mut c_char,
    >,
    pub get_selection_region: Option<
        unsafe extern "C" fn(
            *mut PpsSelection,
            *mut PpsRenderContext,
            PpsSelectionStyle,
            *mut PpsRectangle,
        ) -> *mut cairo::cairo_region_t,
    >,
}

impl ::std::fmt::Debug for PpsSelectionInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsSelectionInterface @ {self:p}"))
            .field("base_iface", &self.base_iface)
            .field("render_selection", &self.render_selection)
            .field("get_selected_text", &self.get_selected_text)
            .field("get_selection_region", &self.get_selection_region)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsSignatureClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PpsSignatureClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsSignatureClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsTransitionEffectClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PpsTransitionEffectClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsTransitionEffectClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

// Classes
#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsAnnotation {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for PpsAnnotation {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsAnnotation @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsAnnotationAttachment {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsAnnotationAttachment {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsAnnotationAttachment @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsAnnotationFreeText {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsAnnotationFreeText {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsAnnotationFreeText @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsAnnotationMarkup {
    pub parent_instance: PpsAnnotation,
}

impl ::std::fmt::Debug for PpsAnnotationMarkup {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsAnnotationMarkup @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsAnnotationStamp {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsAnnotationStamp {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsAnnotationStamp @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsAnnotationText {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsAnnotationText {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsAnnotationText @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsAnnotationTextMarkup {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsAnnotationTextMarkup {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsAnnotationTextMarkup @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsAttachment {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for PpsAttachment {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsAttachment @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsCertificateInfo {
    pub base_instance: gobject::GObject,
}

impl ::std::fmt::Debug for PpsCertificateInfo {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsCertificateInfo @ {self:p}"))
            .field("base_instance", &self.base_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsDocument {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for PpsDocument {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsDocument @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsFontDescription {
    pub parent: gobject::GObject,
}

impl ::std::fmt::Debug for PpsFontDescription {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsFontDescription @ {self:p}"))
            .field("parent", &self.parent)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsFormField {
    pub parent: gobject::GObject,
    pub id: c_int,
    pub is_read_only: gboolean,
    pub font_size: c_double,
    pub activation_link: *mut PpsLink,
    pub page: *mut PpsPage,
    pub changed: gboolean,
}

impl ::std::fmt::Debug for PpsFormField {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsFormField @ {self:p}"))
            .field("parent", &self.parent)
            .field("id", &self.id)
            .field("is_read_only", &self.is_read_only)
            .field("font_size", &self.font_size)
            .field("activation_link", &self.activation_link)
            .field("page", &self.page)
            .field("changed", &self.changed)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsFormFieldButton {
    pub parent: PpsFormField,
    pub type_: PpsFormFieldButtonType,
    pub state: gboolean,
}

impl ::std::fmt::Debug for PpsFormFieldButton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsFormFieldButton @ {self:p}"))
            .field("parent", &self.parent)
            .field("type_", &self.type_)
            .field("state", &self.state)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsFormFieldChoice {
    pub parent: PpsFormField,
    pub type_: PpsFormFieldChoiceType,
    pub multi_select: gboolean,
    _truncated_record_marker: c_void,
    // field is_editable has incomplete type
}

impl ::std::fmt::Debug for PpsFormFieldChoice {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsFormFieldChoice @ {self:p}"))
            .field("parent", &self.parent)
            .field("type_", &self.type_)
            .field("multi_select", &self.multi_select)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsFormFieldSignature {
    pub parent: PpsFormField,
}

impl ::std::fmt::Debug for PpsFormFieldSignature {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsFormFieldSignature @ {self:p}"))
            .field("parent", &self.parent)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsFormFieldText {
    pub parent: PpsFormField,
    pub type_: PpsFormFieldTextType,
    pub do_spell_check: gboolean,
    _truncated_record_marker: c_void,
    // field do_scroll has incomplete type
}

impl ::std::fmt::Debug for PpsFormFieldText {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsFormFieldText @ {self:p}"))
            .field("parent", &self.parent)
            .field("type_", &self.type_)
            .field("do_spell_check", &self.do_spell_check)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsImage {
    pub base_instance: gobject::GObject,
}

impl ::std::fmt::Debug for PpsImage {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsImage @ {self:p}"))
            .field("base_instance", &self.base_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsLayer {
    pub base_instance: gobject::GObject,
}

impl ::std::fmt::Debug for PpsLayer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsLayer @ {self:p}"))
            .field("base_instance", &self.base_instance)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsLink {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsLink {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsLink @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsLinkAction {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsLinkAction {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsLinkAction @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsLinkDest {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsLinkDest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsLinkDest @ {self:p}")).finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsMedia {
    pub base_instance: gobject::GObject,
}

impl ::std::fmt::Debug for PpsMedia {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsMedia @ {self:p}"))
            .field("base_instance", &self.base_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsOutlines {
    pub parent: gobject::GObject,
}

impl ::std::fmt::Debug for PpsOutlines {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsOutlines @ {self:p}"))
            .field("parent", &self.parent)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsPage {
    pub base_instance: gobject::GObject,
    pub index: c_int,
    pub backend_page: PpsBackendPage,
    pub backend_destroy_func: PpsBackendPageDestroyFunc,
}

impl ::std::fmt::Debug for PpsPage {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsPage @ {self:p}"))
            .field("base_instance", &self.base_instance)
            .field("index", &self.index)
            .field("backend_page", &self.backend_page)
            .field("backend_destroy_func", &self.backend_destroy_func)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsRenderContext {
    pub parent: gobject::GObject,
    pub page: *mut PpsPage,
    pub rotation: c_int,
    pub scale: c_double,
    pub target_width: c_int,
    pub target_height: c_int,
    pub annot_flags: PpsRenderAnnotsFlags,
}

impl ::std::fmt::Debug for PpsRenderContext {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsRenderContext @ {self:p}"))
            .field("parent", &self.parent)
            .field("page", &self.page)
            .field("rotation", &self.rotation)
            .field("scale", &self.scale)
            .field("target_width", &self.target_width)
            .field("target_height", &self.target_height)
            .field("annot_flags", &self.annot_flags)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsSignature {
    pub base_instance: gobject::GObject,
}

impl ::std::fmt::Debug for PpsSignature {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsSignature @ {self:p}"))
            .field("base_instance", &self.base_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PpsTransitionEffect {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for PpsTransitionEffect {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PpsTransitionEffect @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

// Interfaces
#[repr(C)]
#[allow(dead_code)]
pub struct PpsDocumentAnnotations {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsDocumentAnnotations {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PpsDocumentAnnotations @ {self:p}")
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsDocumentAttachments {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsDocumentAttachments {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PpsDocumentAttachments @ {self:p}")
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsDocumentFind {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsDocumentFind {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PpsDocumentFind @ {self:p}")
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsDocumentFonts {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsDocumentFonts {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PpsDocumentFonts @ {self:p}")
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsDocumentForms {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsDocumentForms {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PpsDocumentForms @ {self:p}")
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsDocumentImages {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsDocumentImages {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PpsDocumentImages @ {self:p}")
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsDocumentLayers {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsDocumentLayers {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PpsDocumentLayers @ {self:p}")
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsDocumentLinks {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsDocumentLinks {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PpsDocumentLinks @ {self:p}")
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsDocumentMedia {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsDocumentMedia {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PpsDocumentMedia @ {self:p}")
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsDocumentPrint {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsDocumentPrint {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PpsDocumentPrint @ {self:p}")
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsDocumentSecurity {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsDocumentSecurity {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PpsDocumentSecurity @ {self:p}")
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsDocumentSignatures {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsDocumentSignatures {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PpsDocumentSignatures @ {self:p}")
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsDocumentText {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsDocumentText {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PpsDocumentText @ {self:p}")
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsDocumentTransition {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsDocumentTransition {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PpsDocumentTransition @ {self:p}")
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsFileExporter {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsFileExporter {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PpsFileExporter @ {self:p}")
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PpsSelection {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PpsSelection {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PpsSelection @ {self:p}")
    }
}

extern "C" {

    //=========================================================================
    // PpsAnnotationTextIcon
    //=========================================================================
    pub fn pps_annotation_text_icon_get_type() -> GType;

    //=========================================================================
    // PpsAnnotationTextMarkupType
    //=========================================================================
    pub fn pps_annotation_text_markup_type_get_type() -> GType;

    //=========================================================================
    // PpsAnnotationType
    //=========================================================================
    pub fn pps_annotation_type_get_type() -> GType;

    //=========================================================================
    // PpsAnnotationsOverMarkup
    //=========================================================================
    pub fn pps_annotations_over_markup_get_type() -> GType;

    //=========================================================================
    // PpsCertificateStatus
    //=========================================================================
    pub fn pps_certificate_status_get_type() -> GType;

    //=========================================================================
    // PpsCompressionType
    //=========================================================================
    pub fn pps_compression_type_get_type() -> GType;

    //=========================================================================
    // PpsDocumentContainsJS
    //=========================================================================
    pub fn pps_document_contains_js_get_type() -> GType;

    //=========================================================================
    // PpsDocumentError
    //=========================================================================
    pub fn pps_document_error_get_type() -> GType;
    pub fn pps_document_error_quark() -> glib::GQuark;

    //=========================================================================
    // PpsDocumentLayout
    //=========================================================================
    pub fn pps_document_layout_get_type() -> GType;

    //=========================================================================
    // PpsDocumentMode
    //=========================================================================
    pub fn pps_document_mode_get_type() -> GType;

    //=========================================================================
    // PpsFileExporterFormat
    //=========================================================================
    pub fn pps_file_exporter_format_get_type() -> GType;

    //=========================================================================
    // PpsFormFieldButtonType
    //=========================================================================
    pub fn pps_form_field_button_type_get_type() -> GType;

    //=========================================================================
    // PpsFormFieldChoiceType
    //=========================================================================
    pub fn pps_form_field_choice_type_get_type() -> GType;

    //=========================================================================
    // PpsFormFieldTextType
    //=========================================================================
    pub fn pps_form_field_text_type_get_type() -> GType;

    //=========================================================================
    // PpsLinkActionType
    //=========================================================================
    pub fn pps_link_action_type_get_type() -> GType;

    //=========================================================================
    // PpsLinkDestType
    //=========================================================================
    pub fn pps_link_dest_type_get_type() -> GType;

    //=========================================================================
    // PpsSelectionStyle
    //=========================================================================
    pub fn pps_selection_style_get_type() -> GType;

    //=========================================================================
    // PpsSignatureStatus
    //=========================================================================
    pub fn pps_signature_status_get_type() -> GType;

    //=========================================================================
    // PpsTransitionEffectAlignment
    //=========================================================================
    pub fn pps_transition_effect_alignment_get_type() -> GType;

    //=========================================================================
    // PpsTransitionEffectDirection
    //=========================================================================
    pub fn pps_transition_effect_direction_get_type() -> GType;

    //=========================================================================
    // PpsTransitionEffectType
    //=========================================================================
    pub fn pps_transition_effect_type_get_type() -> GType;

    //=========================================================================
    // PpsDocumentInfoFields
    //=========================================================================
    pub fn pps_document_info_fields_get_type() -> GType;

    //=========================================================================
    // PpsDocumentLoadFlags
    //=========================================================================
    pub fn pps_document_load_flags_get_type() -> GType;

    //=========================================================================
    // PpsDocumentPermissions
    //=========================================================================
    pub fn pps_document_permissions_get_type() -> GType;

    //=========================================================================
    // PpsDocumentUIHints
    //=========================================================================
    pub fn pps_document_ui_hints_get_type() -> GType;

    //=========================================================================
    // PpsFileExporterCapabilities
    //=========================================================================
    pub fn pps_file_exporter_capabilities_get_type() -> GType;

    //=========================================================================
    // PpsFindOptions
    //=========================================================================
    pub fn pps_find_options_get_type() -> GType;

    //=========================================================================
    // PpsRenderAnnotsFlags
    //=========================================================================
    pub fn pps_render_annots_flags_get_type() -> GType;

    //=========================================================================
    // PpsDocumentInfo
    //=========================================================================
    pub fn pps_document_info_get_type() -> GType;
    pub fn pps_document_info_new() -> *mut PpsDocumentInfo;
    pub fn pps_document_info_author(
        info: *const PpsDocumentInfo,
        author: *mut *mut c_char,
    ) -> gboolean;
    pub fn pps_document_info_contains_js(
        info: *const PpsDocumentInfo,
        contains_js: *mut PpsDocumentContainsJS,
    ) -> gboolean;
    pub fn pps_document_info_copy(info: *const PpsDocumentInfo) -> *mut PpsDocumentInfo;
    pub fn pps_document_info_creator(
        info: *const PpsDocumentInfo,
        creator: *mut *mut c_char,
    ) -> gboolean;
    pub fn pps_document_info_format(
        info: *const PpsDocumentInfo,
        format: *mut *mut c_char,
    ) -> gboolean;
    pub fn pps_document_info_free(info: *mut PpsDocumentInfo);
    pub fn pps_document_info_get_created_datetime(
        info: *const PpsDocumentInfo,
    ) -> *mut glib::GDateTime;
    pub fn pps_document_info_get_modified_datetime(
        info: *const PpsDocumentInfo,
    ) -> *mut glib::GDateTime;
    pub fn pps_document_info_keywords(
        info: *const PpsDocumentInfo,
        keywords: *mut *mut c_char,
    ) -> gboolean;
    pub fn pps_document_info_license(
        info: *const PpsDocumentInfo,
        license: *mut *mut PpsDocumentLicense,
    ) -> gboolean;
    pub fn pps_document_info_linearized(
        info: *const PpsDocumentInfo,
        linearized: *mut *mut c_char,
    ) -> gboolean;
    pub fn pps_document_info_pages(info: *const PpsDocumentInfo, pages: *mut c_int) -> gboolean;
    pub fn pps_document_info_permissions(
        info: *const PpsDocumentInfo,
        permissions: *mut PpsDocumentPermissions,
    ) -> gboolean;
    pub fn pps_document_info_producer(
        info: *const PpsDocumentInfo,
        producer: *mut *mut c_char,
    ) -> gboolean;
    pub fn pps_document_info_regular_paper_size(info: *const PpsDocumentInfo) -> *mut c_char;
    pub fn pps_document_info_security(
        info: *const PpsDocumentInfo,
        security: *mut *mut c_char,
    ) -> gboolean;
    pub fn pps_document_info_set_from_xmp(
        info: *mut PpsDocumentInfo,
        xmp: *const c_char,
        size: ssize_t,
    ) -> gboolean;
    pub fn pps_document_info_start_mode(
        info: *const PpsDocumentInfo,
        mode: *mut PpsDocumentMode,
    ) -> gboolean;
    pub fn pps_document_info_subject(
        info: *const PpsDocumentInfo,
        subject: *mut *mut c_char,
    ) -> gboolean;
    pub fn pps_document_info_take_created_datetime(
        info: *mut PpsDocumentInfo,
        datetime: *mut glib::GDateTime,
    );
    pub fn pps_document_info_take_modified_datetime(
        info: *mut PpsDocumentInfo,
        datetime: *mut glib::GDateTime,
    );
    pub fn pps_document_info_title(
        info: *const PpsDocumentInfo,
        title: *mut *mut c_char,
    ) -> gboolean;

    //=========================================================================
    // PpsDocumentLicense
    //=========================================================================
    pub fn pps_document_license_get_type() -> GType;
    pub fn pps_document_license_new() -> *mut PpsDocumentLicense;
    pub fn pps_document_license_copy(license: *mut PpsDocumentLicense) -> *mut PpsDocumentLicense;
    pub fn pps_document_license_free(license: *mut PpsDocumentLicense);
    pub fn pps_document_license_get_text(license: *mut PpsDocumentLicense) -> *const c_char;
    pub fn pps_document_license_get_uri(license: *mut PpsDocumentLicense) -> *const c_char;
    pub fn pps_document_license_get_web_statement(
        license: *mut PpsDocumentLicense,
    ) -> *const c_char;

    //=========================================================================
    // PpsDocumentPoint
    //=========================================================================
    #[cfg(feature = "v48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v48")))]
    pub fn pps_document_point_get_type() -> GType;
    #[cfg(feature = "v48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v48")))]
    pub fn pps_document_point_copy(mark: *mut PpsDocumentPoint) -> *mut PpsDocumentPoint;

    //=========================================================================
    // PpsFindRectangle
    //=========================================================================
    pub fn pps_find_rectangle_get_type() -> GType;
    pub fn pps_find_rectangle_new() -> *mut PpsFindRectangle;
    pub fn pps_find_rectangle_copy(pps_find_rect: *mut PpsFindRectangle) -> *mut PpsFindRectangle;
    pub fn pps_find_rectangle_free(pps_find_rect: *mut PpsFindRectangle);

    //=========================================================================
    // PpsMapping
    //=========================================================================
    pub fn pps_mapping_get_type() -> GType;
    pub fn pps_mapping_new() -> *mut PpsMapping;
    pub fn pps_mapping_copy(pps_mapping: *const PpsMapping) -> *mut PpsMapping;
    pub fn pps_mapping_free(pps_mapping: *mut PpsMapping);
    pub fn pps_mapping_get_area(pps_mapping: *mut PpsMapping) -> *mut PpsRectangle;
    pub fn pps_mapping_get_data(pps_mapping: *const PpsMapping) -> *mut gobject::GObject;
    pub fn pps_mapping_set_area(pps_mapping: *mut PpsMapping, area: *mut PpsRectangle);
    pub fn pps_mapping_set_data(pps_mapping: *mut PpsMapping, data: *mut gobject::GObject);

    //=========================================================================
    // PpsMappingList
    //=========================================================================
    pub fn pps_mapping_list_get_type() -> GType;
    pub fn pps_mapping_list_new(
        page: c_uint,
        list: *mut glib::GList,
        data_destroy_func: glib::GDestroyNotify,
    ) -> *mut PpsMappingList;
    pub fn pps_mapping_list_find(
        mapping_list: *mut PpsMappingList,
        data: gconstpointer,
    ) -> *mut PpsMapping;
    pub fn pps_mapping_list_get(
        mapping_list: *mut PpsMappingList,
        point: *const PpsPoint,
    ) -> *mut PpsMapping;
    pub fn pps_mapping_list_get_data(
        mapping_list: *mut PpsMappingList,
        point: *const PpsPoint,
    ) -> gpointer;
    pub fn pps_mapping_list_get_list(mapping_list: *mut PpsMappingList) -> *mut glib::GList;
    pub fn pps_mapping_list_get_page(mapping_list: *mut PpsMappingList) -> c_uint;
    pub fn pps_mapping_list_length(mapping_list: *mut PpsMappingList) -> c_uint;
    pub fn pps_mapping_list_nth(mapping_list: *mut PpsMappingList, n: c_uint) -> *mut PpsMapping;
    pub fn pps_mapping_list_ref(mapping_list: *mut PpsMappingList) -> *mut PpsMappingList;
    pub fn pps_mapping_list_remove(mapping_list: *mut PpsMappingList, mapping: *mut PpsMapping);
    pub fn pps_mapping_list_unref(mapping_list: *mut PpsMappingList);

    //=========================================================================
    // PpsPoint
    //=========================================================================
    pub fn pps_point_get_type() -> GType;
    pub fn pps_point_new() -> *mut PpsPoint;
    pub fn pps_point_copy(point: *mut PpsPoint) -> *mut PpsPoint;

    //=========================================================================
    // PpsRectangle
    //=========================================================================
    pub fn pps_rectangle_get_type() -> GType;
    pub fn pps_rectangle_new() -> *mut PpsRectangle;
    pub fn pps_rectangle_copy(pps_rect: *mut PpsRectangle) -> *mut PpsRectangle;

    //=========================================================================
    // PpsAnnotation
    //=========================================================================
    pub fn pps_annotation_get_type() -> GType;
    pub fn pps_annotation_equal(annot: *mut PpsAnnotation, other: *mut PpsAnnotation) -> gboolean;
    pub fn pps_annotation_get_annotation_type(annot: *mut PpsAnnotation) -> PpsAnnotationType;
    pub fn pps_annotation_get_area(annot: *mut PpsAnnotation, area: *mut PpsRectangle);
    #[cfg(feature = "v48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v48")))]
    pub fn pps_annotation_get_border_width(annot: *mut PpsAnnotation) -> c_double;
    pub fn pps_annotation_get_contents(annot: *mut PpsAnnotation) -> *const c_char;
    #[cfg(feature = "v48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v48")))]
    pub fn pps_annotation_get_hidden(annot: *mut PpsAnnotation) -> gboolean;
    pub fn pps_annotation_get_modified(annot: *mut PpsAnnotation) -> *const c_char;
    pub fn pps_annotation_get_name(annot: *mut PpsAnnotation) -> *const c_char;
    pub fn pps_annotation_get_page(annot: *mut PpsAnnotation) -> *mut PpsPage;
    pub fn pps_annotation_get_page_index(annot: *mut PpsAnnotation) -> c_uint;
    pub fn pps_annotation_get_rgba(annot: *mut PpsAnnotation, rgba: *mut gdk::GdkRGBA);
    pub fn pps_annotation_get_value_last_property(
        annot: *mut PpsAnnotation,
        value: *mut gobject::GValue,
    );
    pub fn pps_annotation_set_area(
        annot: *mut PpsAnnotation,
        area: *const PpsRectangle,
    ) -> gboolean;
    #[cfg(feature = "v48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v48")))]
    pub fn pps_annotation_set_border_width(annot: *mut PpsAnnotation, width: c_double) -> gboolean;
    pub fn pps_annotation_set_contents(
        annot: *mut PpsAnnotation,
        contents: *const c_char,
    ) -> gboolean;
    #[cfg(feature = "v48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v48")))]
    pub fn pps_annotation_set_hidden(annot: *mut PpsAnnotation, hidden: gboolean) -> gboolean;
    pub fn pps_annotation_set_modified(
        annot: *mut PpsAnnotation,
        modified: *const c_char,
    ) -> gboolean;
    pub fn pps_annotation_set_modified_from_time_t(
        annot: *mut PpsAnnotation,
        utime: time_t,
    ) -> gboolean;
    pub fn pps_annotation_set_name(annot: *mut PpsAnnotation, name: *const c_char) -> gboolean;
    pub fn pps_annotation_set_rgba(
        annot: *mut PpsAnnotation,
        rgba: *const gdk::GdkRGBA,
    ) -> gboolean;

    //=========================================================================
    // PpsAnnotationAttachment
    //=========================================================================
    pub fn pps_annotation_attachment_get_type() -> GType;
    pub fn pps_annotation_attachment_new(
        page: *mut PpsPage,
        attachment: *mut PpsAttachment,
    ) -> *mut PpsAnnotation;
    pub fn pps_annotation_attachment_get_attachment(
        annot: *mut PpsAnnotationAttachment,
    ) -> *mut PpsAttachment;
    pub fn pps_annotation_attachment_set_attachment(
        annot: *mut PpsAnnotationAttachment,
        attachment: *mut PpsAttachment,
    ) -> gboolean;

    //=========================================================================
    // PpsAnnotationFreeText
    //=========================================================================
    pub fn pps_annotation_free_text_get_type() -> GType;
    #[cfg(feature = "v48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v48")))]
    pub fn pps_annotation_free_text_new(page: *mut PpsPage) -> *mut PpsAnnotation;
    #[cfg(feature = "v48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v48")))]
    pub fn pps_annotation_free_text_auto_resize(
        annot: *mut PpsAnnotationFreeText,
        ctx: *mut pango::PangoContext,
    );
    #[cfg(feature = "v48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v48")))]
    pub fn pps_annotation_free_text_get_font_description(
        annot: *mut PpsAnnotationFreeText,
    ) -> *mut pango::PangoFontDescription;
    #[cfg(feature = "v48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v48")))]
    pub fn pps_annotation_free_text_get_font_rgba(
        annot: *mut PpsAnnotationFreeText,
    ) -> *mut gdk::GdkRGBA;
    #[cfg(feature = "v48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v48")))]
    pub fn pps_annotation_free_text_set_font_description(
        annot: *mut PpsAnnotationFreeText,
        font_desc: *const pango::PangoFontDescription,
    ) -> gboolean;
    #[cfg(feature = "v48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v48")))]
    pub fn pps_annotation_free_text_set_font_rgba(
        annot: *mut PpsAnnotationFreeText,
        rgba: *const gdk::GdkRGBA,
    ) -> gboolean;

    //=========================================================================
    // PpsAnnotationMarkup
    //=========================================================================
    pub fn pps_annotation_markup_get_type() -> GType;
    pub fn pps_annotation_markup_can_have_popup(markup: *mut PpsAnnotationMarkup) -> gboolean;
    pub fn pps_annotation_markup_get_label(markup: *mut PpsAnnotationMarkup) -> *const c_char;
    pub fn pps_annotation_markup_get_opacity(markup: *mut PpsAnnotationMarkup) -> c_double;
    pub fn pps_annotation_markup_get_popup_is_open(markup: *mut PpsAnnotationMarkup) -> gboolean;
    pub fn pps_annotation_markup_get_rectangle(
        markup: *mut PpsAnnotationMarkup,
        pps_rect: *mut PpsRectangle,
    );
    pub fn pps_annotation_markup_has_popup(markup: *mut PpsAnnotationMarkup) -> gboolean;
    pub fn pps_annotation_markup_set_has_popup(
        markup: *mut PpsAnnotationMarkup,
        has_popup: gboolean,
    ) -> gboolean;
    pub fn pps_annotation_markup_set_label(
        markup: *mut PpsAnnotationMarkup,
        label: *const c_char,
    ) -> gboolean;
    pub fn pps_annotation_markup_set_opacity(
        markup: *mut PpsAnnotationMarkup,
        opacity: c_double,
    ) -> gboolean;
    pub fn pps_annotation_markup_set_popup_is_open(
        markup: *mut PpsAnnotationMarkup,
        is_open: gboolean,
    ) -> gboolean;
    pub fn pps_annotation_markup_set_rectangle(
        markup: *mut PpsAnnotationMarkup,
        pps_rect: *const PpsRectangle,
    ) -> gboolean;

    //=========================================================================
    // PpsAnnotationStamp
    //=========================================================================
    pub fn pps_annotation_stamp_get_type() -> GType;
    #[cfg(feature = "v48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v48")))]
    pub fn pps_annotation_stamp_new(page: *mut PpsPage) -> *mut PpsAnnotation;
    #[cfg(feature = "v48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v48")))]
    pub fn pps_annotation_stamp_get_surface(
        stamp: *mut PpsAnnotationStamp,
    ) -> *mut cairo::cairo_surface_t;
    #[cfg(feature = "v48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v48")))]
    pub fn pps_annotation_stamp_set_surface(
        stamp: *mut PpsAnnotationStamp,
        surface: *mut cairo::cairo_surface_t,
    );

    //=========================================================================
    // PpsAnnotationText
    //=========================================================================
    pub fn pps_annotation_text_get_type() -> GType;
    pub fn pps_annotation_text_new(page: *mut PpsPage) -> *mut PpsAnnotation;
    pub fn pps_annotation_text_get_icon(text: *mut PpsAnnotationText) -> PpsAnnotationTextIcon;
    pub fn pps_annotation_text_get_is_open(text: *mut PpsAnnotationText) -> gboolean;
    pub fn pps_annotation_text_set_icon(
        text: *mut PpsAnnotationText,
        icon: PpsAnnotationTextIcon,
    ) -> gboolean;
    pub fn pps_annotation_text_set_is_open(
        text: *mut PpsAnnotationText,
        is_open: gboolean,
    ) -> gboolean;

    //=========================================================================
    // PpsAnnotationTextMarkup
    //=========================================================================
    pub fn pps_annotation_text_markup_get_type() -> GType;
    pub fn pps_annotation_text_markup_highlight_new(page: *mut PpsPage) -> *mut PpsAnnotation;
    pub fn pps_annotation_text_markup_new(
        page: *mut PpsPage,
        markup_type: PpsAnnotationTextMarkupType,
    ) -> *mut PpsAnnotation;
    pub fn pps_annotation_text_markup_squiggly_new(page: *mut PpsPage) -> *mut PpsAnnotation;
    pub fn pps_annotation_text_markup_strike_out_new(page: *mut PpsPage) -> *mut PpsAnnotation;
    pub fn pps_annotation_text_markup_underline_new(page: *mut PpsPage) -> *mut PpsAnnotation;
    pub fn pps_annotation_text_markup_get_markup_type(
        annot: *mut PpsAnnotationTextMarkup,
    ) -> PpsAnnotationTextMarkupType;
    pub fn pps_annotation_text_markup_set_markup_type(
        annot: *mut PpsAnnotationTextMarkup,
        markup_type: PpsAnnotationTextMarkupType,
    ) -> gboolean;

    //=========================================================================
    // PpsAttachment
    //=========================================================================
    pub fn pps_attachment_get_type() -> GType;
    pub fn pps_attachment_new(
        name: *const c_char,
        description: *const c_char,
        mtime: *mut glib::GDateTime,
        ctime: *mut glib::GDateTime,
        size: size_t,
        data: gpointer,
    ) -> *mut PpsAttachment;
    pub fn pps_attachment_error_quark() -> glib::GQuark;
    pub fn pps_attachment_get_creation_datetime(
        attachment: *mut PpsAttachment,
    ) -> *mut glib::GDateTime;
    pub fn pps_attachment_get_description(attachment: *mut PpsAttachment) -> *const c_char;
    pub fn pps_attachment_get_mime_type(attachment: *mut PpsAttachment) -> *const c_char;
    pub fn pps_attachment_get_modification_datetime(
        attachment: *mut PpsAttachment,
    ) -> *mut glib::GDateTime;
    pub fn pps_attachment_get_name(attachment: *mut PpsAttachment) -> *const c_char;
    pub fn pps_attachment_open(
        attachment: *mut PpsAttachment,
        context: *mut gio::GAppLaunchContext,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn pps_attachment_save(
        attachment: *mut PpsAttachment,
        file: *mut gio::GFile,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // PpsCertificateInfo
    //=========================================================================
    pub fn pps_certificate_info_get_type() -> GType;
    pub fn pps_certificate_info_new(
        id: *const c_char,
        subject_common_name: *const c_char,
    ) -> *mut PpsCertificateInfo;

    //=========================================================================
    // PpsDocument
    //=========================================================================
    pub fn pps_document_get_type() -> GType;
    pub fn pps_document_factory_add_filters(
        dialog: *mut gtk::GtkFileDialog,
        document: *mut PpsDocument,
    );
    pub fn pps_document_factory_get_document(
        uri: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut PpsDocument;
    #[cfg(feature = "v42")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v42")))]
    pub fn pps_document_factory_get_document_for_fd(
        fd: c_int,
        mime_type: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut PpsDocument;
    pub fn pps_document_misc_format_datetime(dt: *mut glib::GDateTime) -> *mut c_char;
    pub fn pps_document_misc_get_pointer_position(
        widget: *mut gtk::GtkWidget,
        x: *mut c_int,
        y: *mut c_int,
    ) -> gboolean;
    pub fn pps_document_misc_get_widget_dpi(widget: *mut gtk::GtkWidget) -> c_double;
    pub fn pps_document_misc_pixbuf_from_surface(
        surface: *mut cairo::cairo_surface_t,
    ) -> *mut gdk_pixbuf::GdkPixbuf;
    pub fn pps_document_misc_surface_from_pixbuf(
        pixbuf: *mut gdk_pixbuf::GdkPixbuf,
    ) -> *mut cairo::cairo_surface_t;
    pub fn pps_document_misc_surface_rotate_and_scale(
        surface: *mut cairo::cairo_surface_t,
        dest_width: c_int,
        dest_height: c_int,
        dest_rotation: c_int,
    ) -> *mut cairo::cairo_surface_t;
    pub fn pps_document_misc_texture_from_surface(
        surface: *mut cairo::cairo_surface_t,
    ) -> *mut gdk::GdkTexture;
    pub fn pps_document_check_dimensions(document: *mut PpsDocument) -> gboolean;
    pub fn pps_document_find_page_by_label(
        document: *mut PpsDocument,
        page_label: *const c_char,
        page_index: *mut c_int,
    ) -> gboolean;
    pub fn pps_document_get_backend_info(
        document: *mut PpsDocument,
        info: *mut PpsDocumentBackendInfo,
    ) -> gboolean;
    pub fn pps_document_get_info(document: *mut PpsDocument) -> *mut PpsDocumentInfo;
    pub fn pps_document_get_max_label_len(document: *mut PpsDocument) -> c_int;
    pub fn pps_document_get_max_page_size(
        document: *mut PpsDocument,
        width: *mut c_double,
        height: *mut c_double,
    );
    pub fn pps_document_get_min_page_size(
        document: *mut PpsDocument,
        width: *mut c_double,
        height: *mut c_double,
    );
    pub fn pps_document_get_modified(document: *mut PpsDocument) -> gboolean;
    pub fn pps_document_get_n_pages(document: *mut PpsDocument) -> c_int;
    pub fn pps_document_get_page(document: *mut PpsDocument, index: c_int) -> *mut PpsPage;
    pub fn pps_document_get_page_label(
        document: *mut PpsDocument,
        page_index: c_int,
    ) -> *mut c_char;
    pub fn pps_document_get_page_size(
        document: *mut PpsDocument,
        page_index: c_int,
        width: *mut c_double,
        height: *mut c_double,
    );
    #[cfg(feature = "v49")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v49")))]
    pub fn pps_document_get_page_size_uncached(
        document: *mut PpsDocument,
        page: *mut PpsPage,
        width: *mut c_double,
        height: *mut c_double,
    );
    pub fn pps_document_get_size(document: *mut PpsDocument) -> u64;
    pub fn pps_document_get_thumbnail(
        document: *mut PpsDocument,
        rc: *mut PpsRenderContext,
    ) -> *mut gdk_pixbuf::GdkPixbuf;
    pub fn pps_document_get_thumbnail_surface(
        document: *mut PpsDocument,
        rc: *mut PpsRenderContext,
    ) -> *mut cairo::cairo_surface_t;
    pub fn pps_document_get_title(document: *mut PpsDocument) -> *const c_char;
    pub fn pps_document_get_uri(document: *mut PpsDocument) -> *const c_char;
    pub fn pps_document_has_text_page_labels(document: *mut PpsDocument) -> gboolean;
    pub fn pps_document_is_page_size_uniform(document: *mut PpsDocument) -> gboolean;
    pub fn pps_document_load(
        document: *mut PpsDocument,
        uri: *const c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    #[cfg(feature = "v42")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v42")))]
    pub fn pps_document_load_fd(
        document: *mut PpsDocument,
        fd: c_int,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn pps_document_render(
        document: *mut PpsDocument,
        rc: *mut PpsRenderContext,
    ) -> *mut cairo::cairo_surface_t;
    pub fn pps_document_save(
        document: *mut PpsDocument,
        uri: *const c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn pps_document_set_modified(document: *mut PpsDocument, modified: gboolean);
    pub fn pps_document_setup_cache(document: *mut PpsDocument);

    //=========================================================================
    // PpsFontDescription
    //=========================================================================
    pub fn pps_font_description_get_type() -> GType;
    pub fn pps_font_description_new() -> *mut PpsFontDescription;

    //=========================================================================
    // PpsFormField
    //=========================================================================
    pub fn pps_form_field_get_type() -> GType;

    //=========================================================================
    // PpsFormFieldButton
    //=========================================================================
    pub fn pps_form_field_button_get_type() -> GType;
    pub fn pps_form_field_button_new(id: c_int, type_: PpsFormFieldButtonType)
        -> *mut PpsFormField;

    //=========================================================================
    // PpsFormFieldChoice
    //=========================================================================
    pub fn pps_form_field_choice_get_type() -> GType;
    pub fn pps_form_field_choice_new(id: c_int, type_: PpsFormFieldChoiceType)
        -> *mut PpsFormField;

    //=========================================================================
    // PpsFormFieldSignature
    //=========================================================================
    pub fn pps_form_field_signature_get_type() -> GType;
    pub fn pps_form_field_signature_new(id: c_int) -> *mut PpsFormField;

    //=========================================================================
    // PpsFormFieldText
    //=========================================================================
    pub fn pps_form_field_text_get_type() -> GType;
    pub fn pps_form_field_text_new(id: c_int, type_: PpsFormFieldTextType) -> *mut PpsFormField;

    //=========================================================================
    // PpsImage
    //=========================================================================
    pub fn pps_image_get_type() -> GType;
    pub fn pps_image_new(page: c_int, img_id: c_int) -> *mut PpsImage;
    pub fn pps_image_new_from_pixbuf(pixbuf: *mut gdk_pixbuf::GdkPixbuf) -> *mut PpsImage;
    pub fn pps_image_get_id(image: *mut PpsImage) -> c_int;
    pub fn pps_image_get_page(image: *mut PpsImage) -> c_int;
    pub fn pps_image_get_pixbuf(image: *mut PpsImage) -> *mut gdk_pixbuf::GdkPixbuf;
    pub fn pps_image_get_tmp_uri(image: *mut PpsImage) -> *const c_char;
    pub fn pps_image_save_tmp(
        image: *mut PpsImage,
        pixbuf: *mut gdk_pixbuf::GdkPixbuf,
    ) -> *const c_char;

    //=========================================================================
    // PpsLayer
    //=========================================================================
    pub fn pps_layer_get_type() -> GType;
    pub fn pps_layer_new(rb_group: c_int) -> *mut PpsLayer;
    pub fn pps_layer_get_children(pps_layer: *mut PpsLayer) -> *mut gio::GListModel;
    pub fn pps_layer_get_rb_group(layer: *mut PpsLayer) -> c_int;
    pub fn pps_layer_set_children(pps_layer: *mut PpsLayer, children: *mut gio::GListModel);

    //=========================================================================
    // PpsLink
    //=========================================================================
    pub fn pps_link_get_type() -> GType;
    pub fn pps_link_new(title: *const c_char, action: *mut PpsLinkAction) -> *mut PpsLink;
    pub fn pps_link_get_action(self_: *mut PpsLink) -> *mut PpsLinkAction;
    pub fn pps_link_get_title(self_: *mut PpsLink) -> *const c_char;

    //=========================================================================
    // PpsLinkAction
    //=========================================================================
    pub fn pps_link_action_get_type() -> GType;
    pub fn pps_link_action_new_dest(dest: *mut PpsLinkDest) -> *mut PpsLinkAction;
    pub fn pps_link_action_new_external_uri(uri: *const c_char) -> *mut PpsLinkAction;
    pub fn pps_link_action_new_launch(
        filename: *const c_char,
        params: *const c_char,
    ) -> *mut PpsLinkAction;
    pub fn pps_link_action_new_layers_state(
        show_list: *mut glib::GList,
        hide_list: *mut glib::GList,
        toggle_list: *mut glib::GList,
    ) -> *mut PpsLinkAction;
    pub fn pps_link_action_new_named(name: *const c_char) -> *mut PpsLinkAction;
    pub fn pps_link_action_new_remote(
        dest: *mut PpsLinkDest,
        filename: *const c_char,
    ) -> *mut PpsLinkAction;
    pub fn pps_link_action_new_reset_form(
        fields: *mut glib::GList,
        exclude_fields: gboolean,
    ) -> *mut PpsLinkAction;
    pub fn pps_link_action_equal(a: *mut PpsLinkAction, b: *mut PpsLinkAction) -> gboolean;
    pub fn pps_link_action_get_action_type(self_: *mut PpsLinkAction) -> PpsLinkActionType;
    pub fn pps_link_action_get_dest(self_: *mut PpsLinkAction) -> *mut PpsLinkDest;
    pub fn pps_link_action_get_exclude_reset_fields(self_: *mut PpsLinkAction) -> gboolean;
    pub fn pps_link_action_get_filename(self_: *mut PpsLinkAction) -> *const c_char;
    pub fn pps_link_action_get_hide_list(self_: *mut PpsLinkAction) -> *mut glib::GList;
    pub fn pps_link_action_get_name(self_: *mut PpsLinkAction) -> *const c_char;
    pub fn pps_link_action_get_params(self_: *mut PpsLinkAction) -> *const c_char;
    pub fn pps_link_action_get_reset_fields(self_: *mut PpsLinkAction) -> *mut glib::GList;
    pub fn pps_link_action_get_show_list(self_: *mut PpsLinkAction) -> *mut glib::GList;
    pub fn pps_link_action_get_toggle_list(self_: *mut PpsLinkAction) -> *mut glib::GList;
    pub fn pps_link_action_get_uri(self_: *mut PpsLinkAction) -> *const c_char;

    //=========================================================================
    // PpsLinkDest
    //=========================================================================
    pub fn pps_link_dest_get_type() -> GType;
    pub fn pps_link_dest_new_fit(page: c_int) -> *mut PpsLinkDest;
    pub fn pps_link_dest_new_fith(
        page: c_int,
        top: c_double,
        change_top: gboolean,
    ) -> *mut PpsLinkDest;
    pub fn pps_link_dest_new_fitr(
        page: c_int,
        left: c_double,
        bottom: c_double,
        right: c_double,
        top: c_double,
    ) -> *mut PpsLinkDest;
    pub fn pps_link_dest_new_fitv(
        page: c_int,
        left: c_double,
        change_left: gboolean,
    ) -> *mut PpsLinkDest;
    pub fn pps_link_dest_new_named(named_dest: *const c_char) -> *mut PpsLinkDest;
    pub fn pps_link_dest_new_page(page: c_int) -> *mut PpsLinkDest;
    pub fn pps_link_dest_new_page_label(page_label: *const c_char) -> *mut PpsLinkDest;
    pub fn pps_link_dest_new_xyz(
        page: c_int,
        left: c_double,
        top: c_double,
        zoom: c_double,
        change_left: gboolean,
        change_top: gboolean,
        change_zoom: gboolean,
    ) -> *mut PpsLinkDest;
    pub fn pps_link_dest_equal(a: *mut PpsLinkDest, b: *mut PpsLinkDest) -> gboolean;
    pub fn pps_link_dest_get_bottom(self_: *mut PpsLinkDest) -> c_double;
    pub fn pps_link_dest_get_dest_type(self_: *mut PpsLinkDest) -> PpsLinkDestType;
    pub fn pps_link_dest_get_left(self_: *mut PpsLinkDest, change_left: *mut gboolean) -> c_double;
    pub fn pps_link_dest_get_named_dest(self_: *mut PpsLinkDest) -> *const c_char;
    pub fn pps_link_dest_get_page(self_: *mut PpsLinkDest) -> c_int;
    pub fn pps_link_dest_get_page_label(self_: *mut PpsLinkDest) -> *const c_char;
    pub fn pps_link_dest_get_right(self_: *mut PpsLinkDest) -> c_double;
    pub fn pps_link_dest_get_top(self_: *mut PpsLinkDest, change_top: *mut gboolean) -> c_double;
    pub fn pps_link_dest_get_zoom(self_: *mut PpsLinkDest, change_zoom: *mut gboolean) -> c_double;

    //=========================================================================
    // PpsMedia
    //=========================================================================
    pub fn pps_media_get_type() -> GType;
    pub fn pps_media_new_for_uri(page: *mut PpsPage, uri: *const c_char) -> *mut PpsMedia;
    pub fn pps_media_get_page_index(media: *mut PpsMedia) -> c_uint;
    pub fn pps_media_get_show_controls(media: *mut PpsMedia) -> gboolean;
    pub fn pps_media_get_uri(media: *mut PpsMedia) -> *const c_char;
    pub fn pps_media_set_show_controls(media: *mut PpsMedia, show_controls: gboolean);

    //=========================================================================
    // PpsOutlines
    //=========================================================================
    pub fn pps_outlines_get_type() -> GType;
    pub fn pps_outlines_new() -> *mut PpsOutlines;
    pub fn pps_outlines_get_children(pps_outlines: *mut PpsOutlines) -> *mut gio::GListModel;
    pub fn pps_outlines_get_expand(pps_outlines: *mut PpsOutlines) -> gboolean;
    pub fn pps_outlines_get_link(pps_outlines: *mut PpsOutlines) -> *mut PpsLink;
    pub fn pps_outlines_set_children(
        pps_outlines: *mut PpsOutlines,
        children: *mut gio::GListModel,
    );
    pub fn pps_outlines_set_expand(pps_outlines: *mut PpsOutlines, expand: gboolean);
    pub fn pps_outlines_set_label(pps_outlines: *mut PpsOutlines, label: *const c_char);
    pub fn pps_outlines_set_link(pps_outlines: *mut PpsOutlines, link: *mut PpsLink);
    pub fn pps_outlines_set_markup(pps_outlines: *mut PpsOutlines, markup: *const c_char);

    //=========================================================================
    // PpsPage
    //=========================================================================
    pub fn pps_page_get_type() -> GType;
    pub fn pps_page_new(index: c_int) -> *mut PpsPage;

    //=========================================================================
    // PpsRenderContext
    //=========================================================================
    pub fn pps_render_context_get_type() -> GType;
    pub fn pps_render_context_new(
        page: *mut PpsPage,
        rotation: c_int,
        scale: c_double,
        annot_flags: PpsRenderAnnotsFlags,
    ) -> *mut PpsRenderContext;
    pub fn pps_render_context_compute_scaled_size(
        rc: *mut PpsRenderContext,
        width_points: c_double,
        height_points: c_double,
        scaled_width: *mut c_int,
        scaled_height: *mut c_int,
    );
    pub fn pps_render_context_compute_scales(
        rc: *mut PpsRenderContext,
        width_points: c_double,
        height_points: c_double,
        scale_x: *mut c_double,
        scale_y: *mut c_double,
    );
    pub fn pps_render_context_compute_transformed_size(
        rc: *mut PpsRenderContext,
        width_points: c_double,
        height_points: c_double,
        transformed_width: *mut c_int,
        transformed_height: *mut c_int,
    );
    pub fn pps_render_context_set_page(rc: *mut PpsRenderContext, page: *mut PpsPage);
    pub fn pps_render_context_set_rotation(rc: *mut PpsRenderContext, rotation: c_int);
    pub fn pps_render_context_set_scale(rc: *mut PpsRenderContext, scale: c_double);
    pub fn pps_render_context_set_target_size(
        rc: *mut PpsRenderContext,
        target_width: c_int,
        target_height: c_int,
    );

    //=========================================================================
    // PpsSignature
    //=========================================================================
    pub fn pps_signature_get_type() -> GType;
    pub fn pps_signature_new(
        status: PpsSignatureStatus,
        info: *mut PpsCertificateInfo,
    ) -> *mut PpsSignature;
    pub fn pps_signature_get_background_color(self_: *mut PpsSignature, color: *mut gdk::GdkRGBA);
    pub fn pps_signature_get_border_color(self_: *mut PpsSignature, color: *mut gdk::GdkRGBA);
    pub fn pps_signature_get_border_width(self_: *mut PpsSignature) -> c_int;
    pub fn pps_signature_get_destination_file(self_: *mut PpsSignature) -> *const c_char;
    pub fn pps_signature_get_font_color(self_: *mut PpsSignature, color: *mut gdk::GdkRGBA);
    pub fn pps_signature_get_font_size(self_: *mut PpsSignature) -> c_int;
    pub fn pps_signature_get_left_font_size(self_: *mut PpsSignature) -> c_int;
    pub fn pps_signature_get_owner_password(self_: *mut PpsSignature) -> *const c_char;
    pub fn pps_signature_get_page(self_: *mut PpsSignature) -> c_int;
    pub fn pps_signature_get_password(self_: *mut PpsSignature) -> *const c_char;
    pub fn pps_signature_get_rect(self_: *mut PpsSignature) -> *mut PpsRectangle;
    pub fn pps_signature_get_signature(self_: *mut PpsSignature) -> *const c_char;
    pub fn pps_signature_get_signature_left(self_: *mut PpsSignature) -> *const c_char;
    pub fn pps_signature_get_user_password(self_: *mut PpsSignature) -> *const c_char;
    pub fn pps_signature_is_valid(self_: *mut PpsSignature) -> gboolean;
    pub fn pps_signature_set_background_color(self_: *mut PpsSignature, color: *mut gdk::GdkRGBA);
    pub fn pps_signature_set_border_color(self_: *mut PpsSignature, color: *mut gdk::GdkRGBA);
    pub fn pps_signature_set_border_width(self_: *mut PpsSignature, width: c_int);
    pub fn pps_signature_set_destination_file(self_: *mut PpsSignature, file: *const c_char);
    pub fn pps_signature_set_font_color(self_: *mut PpsSignature, color: *mut gdk::GdkRGBA);
    pub fn pps_signature_set_font_size(self_: *mut PpsSignature, size: c_int);
    pub fn pps_signature_set_left_font_size(self_: *mut PpsSignature, size: c_int);
    pub fn pps_signature_set_owner_password(self_: *mut PpsSignature, password: *const c_char);
    pub fn pps_signature_set_page(self_: *mut PpsSignature, page: c_uint);
    pub fn pps_signature_set_password(self_: *mut PpsSignature, password: *const c_char);
    pub fn pps_signature_set_rect(self_: *mut PpsSignature, rect: *const PpsRectangle);
    pub fn pps_signature_set_signature(self_: *mut PpsSignature, signature: *const c_char);
    pub fn pps_signature_set_signature_left(
        self_: *mut PpsSignature,
        signature_left: *const c_char,
    );
    pub fn pps_signature_set_user_password(self_: *mut PpsSignature, password: *const c_char);

    //=========================================================================
    // PpsTransitionEffect
    //=========================================================================
    pub fn pps_transition_effect_get_type() -> GType;
    pub fn pps_transition_effect_new(
        type_: PpsTransitionEffectType,
        first_property_name: *const c_char,
        ...
    ) -> *mut PpsTransitionEffect;

    //=========================================================================
    // PpsDocumentAnnotations
    //=========================================================================
    pub fn pps_document_annotations_get_type() -> GType;
    pub fn pps_document_annotations_add_annotation(
        document_annots: *mut PpsDocumentAnnotations,
        annot: *mut PpsAnnotation,
    );
    pub fn pps_document_annotations_can_add_annotation(
        document_annots: *mut PpsDocumentAnnotations,
    ) -> gboolean;
    pub fn pps_document_annotations_can_remove_annotation(
        document_annots: *mut PpsDocumentAnnotations,
    ) -> gboolean;
    pub fn pps_document_annotations_document_is_modified(
        document_annots: *mut PpsDocumentAnnotations,
    ) -> gboolean;
    pub fn pps_document_annotations_get_annotations(
        document_annots: *mut PpsDocumentAnnotations,
        page: *mut PpsPage,
    ) -> *mut glib::GList;
    pub fn pps_document_annotations_over_markup(
        document_annots: *mut PpsDocumentAnnotations,
        annot: *mut PpsAnnotation,
        x: c_double,
        y: c_double,
    ) -> PpsAnnotationsOverMarkup;
    pub fn pps_document_annotations_remove_annotation(
        document_annots: *mut PpsDocumentAnnotations,
        annot: *mut PpsAnnotation,
    );

    //=========================================================================
    // PpsDocumentAttachments
    //=========================================================================
    pub fn pps_document_attachments_get_type() -> GType;
    pub fn pps_document_attachments_get_attachments(
        document_attachments: *mut PpsDocumentAttachments,
    ) -> *mut glib::GList;
    pub fn pps_document_attachments_has_attachments(
        document_attachments: *mut PpsDocumentAttachments,
    ) -> gboolean;

    //=========================================================================
    // PpsDocumentFind
    //=========================================================================
    pub fn pps_document_find_get_type() -> GType;
    pub fn pps_document_find_find_text(
        document_find: *mut PpsDocumentFind,
        page: *mut PpsPage,
        text: *const c_char,
        options: PpsFindOptions,
    ) -> *mut glib::GList;
    pub fn pps_document_find_get_supported_options(
        document_find: *mut PpsDocumentFind,
    ) -> PpsFindOptions;

    //=========================================================================
    // PpsDocumentFonts
    //=========================================================================
    pub fn pps_document_fonts_get_type() -> GType;
    pub fn pps_document_fonts_get_fonts_summary(
        document_fonts: *mut PpsDocumentFonts,
    ) -> *const c_char;
    pub fn pps_document_fonts_get_model(
        document_fonts: *mut PpsDocumentFonts,
    ) -> *mut gio::GListModel;
    pub fn pps_document_fonts_scan(document_fonts: *mut PpsDocumentFonts);

    //=========================================================================
    // PpsDocumentForms
    //=========================================================================
    pub fn pps_document_forms_get_type() -> GType;
    pub fn pps_document_forms_document_is_modified(
        document_forms: *mut PpsDocumentForms,
    ) -> gboolean;
    pub fn pps_document_forms_form_field_button_get_state(
        document_forms: *mut PpsDocumentForms,
        field: *mut PpsFormField,
    ) -> gboolean;
    pub fn pps_document_forms_form_field_button_set_state(
        document_forms: *mut PpsDocumentForms,
        field: *mut PpsFormField,
        state: gboolean,
    );
    pub fn pps_document_forms_form_field_choice_get_item(
        document_forms: *mut PpsDocumentForms,
        field: *mut PpsFormField,
        index: c_int,
    ) -> *mut c_char;
    pub fn pps_document_forms_form_field_choice_get_n_items(
        document_forms: *mut PpsDocumentForms,
        field: *mut PpsFormField,
    ) -> c_int;
    pub fn pps_document_forms_form_field_choice_get_text(
        document_forms: *mut PpsDocumentForms,
        field: *mut PpsFormField,
    ) -> *mut c_char;
    pub fn pps_document_forms_form_field_choice_is_item_selected(
        document_forms: *mut PpsDocumentForms,
        field: *mut PpsFormField,
        index: c_int,
    ) -> gboolean;
    pub fn pps_document_forms_form_field_choice_select_item(
        document_forms: *mut PpsDocumentForms,
        field: *mut PpsFormField,
        index: c_int,
    );
    pub fn pps_document_forms_form_field_choice_set_text(
        document_forms: *mut PpsDocumentForms,
        field: *mut PpsFormField,
        text: *const c_char,
    );
    pub fn pps_document_forms_form_field_choice_toggle_item(
        document_forms: *mut PpsDocumentForms,
        field: *mut PpsFormField,
        index: c_int,
    );
    pub fn pps_document_forms_form_field_choice_unselect_all(
        document_forms: *mut PpsDocumentForms,
        field: *mut PpsFormField,
    );
    pub fn pps_document_forms_form_field_text_get_text(
        document_forms: *mut PpsDocumentForms,
        field: *mut PpsFormField,
    ) -> *mut c_char;
    pub fn pps_document_forms_form_field_text_set_text(
        document_forms: *mut PpsDocumentForms,
        field: *mut PpsFormField,
        text: *const c_char,
    );
    pub fn pps_document_forms_get_form_fields(
        document_forms: *mut PpsDocumentForms,
        page: *mut PpsPage,
    ) -> *mut PpsMappingList;
    pub fn pps_document_forms_reset_form(
        document_forms: *mut PpsDocumentForms,
        action: *mut PpsLinkAction,
    );

    //=========================================================================
    // PpsDocumentImages
    //=========================================================================
    pub fn pps_document_images_get_type() -> GType;
    pub fn pps_document_images_get_image(
        document_images: *mut PpsDocumentImages,
        image: *mut PpsImage,
    ) -> *mut gdk_pixbuf::GdkPixbuf;
    pub fn pps_document_images_get_image_mapping(
        document_images: *mut PpsDocumentImages,
        page: *mut PpsPage,
    ) -> *mut PpsMappingList;

    //=========================================================================
    // PpsDocumentLayers
    //=========================================================================
    pub fn pps_document_layers_get_type() -> GType;
    pub fn pps_document_layers_get_layers(
        document_layers: *mut PpsDocumentLayers,
    ) -> *mut gio::GListModel;
    pub fn pps_document_layers_has_layers(document_layers: *mut PpsDocumentLayers) -> gboolean;
    pub fn pps_document_layers_hide_layer(
        document_layers: *mut PpsDocumentLayers,
        layer: *mut PpsLayer,
    );
    pub fn pps_document_layers_layer_is_visible(
        document_layers: *mut PpsDocumentLayers,
        layer: *mut PpsLayer,
    ) -> gboolean;
    pub fn pps_document_layers_show_layer(
        document_layers: *mut PpsDocumentLayers,
        layer: *mut PpsLayer,
    );

    //=========================================================================
    // PpsDocumentLinks
    //=========================================================================
    pub fn pps_document_links_get_type() -> GType;
    pub fn pps_document_links_find_link_dest(
        document_links: *mut PpsDocumentLinks,
        link_name: *const c_char,
    ) -> *mut PpsLinkDest;
    pub fn pps_document_links_find_link_page(
        document_links: *mut PpsDocumentLinks,
        link_name: *const c_char,
    ) -> c_int;
    pub fn pps_document_links_get_dest_page(
        document_links: *mut PpsDocumentLinks,
        dest: *mut PpsLinkDest,
    ) -> c_int;
    pub fn pps_document_links_get_dest_page_label(
        document_links: *mut PpsDocumentLinks,
        dest: *mut PpsLinkDest,
    ) -> *mut c_char;
    pub fn pps_document_links_get_link_page(
        document_links: *mut PpsDocumentLinks,
        link: *mut PpsLink,
    ) -> c_int;
    pub fn pps_document_links_get_link_page_label(
        document_links: *mut PpsDocumentLinks,
        link: *mut PpsLink,
    ) -> *mut c_char;
    pub fn pps_document_links_get_links(
        document_links: *mut PpsDocumentLinks,
        page: *mut PpsPage,
    ) -> *mut PpsMappingList;
    pub fn pps_document_links_get_links_model(
        document_links: *mut PpsDocumentLinks,
    ) -> *mut gio::GListModel;
    pub fn pps_document_links_has_document_links(document_links: *mut PpsDocumentLinks)
        -> gboolean;

    //=========================================================================
    // PpsDocumentMedia
    //=========================================================================
    pub fn pps_document_media_get_type() -> GType;
    pub fn pps_document_media_get_media_mapping(
        document_media: *mut PpsDocumentMedia,
        page: *mut PpsPage,
    ) -> *mut PpsMappingList;

    //=========================================================================
    // PpsDocumentPrint
    //=========================================================================
    pub fn pps_document_print_get_type() -> GType;
    pub fn pps_document_print_print_page(
        document_print: *mut PpsDocumentPrint,
        page: *mut PpsPage,
        cr: *mut cairo::cairo_t,
    );

    //=========================================================================
    // PpsDocumentSecurity
    //=========================================================================
    pub fn pps_document_security_get_type() -> GType;
    pub fn pps_document_security_has_document_security(
        document_security: *mut PpsDocumentSecurity,
    ) -> gboolean;
    pub fn pps_document_security_set_password(
        document_security: *mut PpsDocumentSecurity,
        password: *const c_char,
    );

    //=========================================================================
    // PpsDocumentSignatures
    //=========================================================================
    pub fn pps_document_signatures_get_type() -> GType;
    pub fn pps_document_signatures_can_sign(
        document_signatures: *mut PpsDocumentSignatures,
    ) -> gboolean;
    pub fn pps_document_signatures_get_available_signing_certificates(
        document_signatures: *mut PpsDocumentSignatures,
    ) -> *mut glib::GList;
    pub fn pps_document_signatures_get_certificate_info(
        document_signatures: *mut PpsDocumentSignatures,
        nick_name: *const c_char,
    ) -> *mut PpsCertificateInfo;
    pub fn pps_document_signatures_get_signatures(
        document_signatures: *mut PpsDocumentSignatures,
    ) -> *mut glib::GList;
    pub fn pps_document_signatures_has_signatures(
        document_signatures: *mut PpsDocumentSignatures,
    ) -> gboolean;
    pub fn pps_document_signatures_set_password_callback(
        document_signatures: *mut PpsDocumentSignatures,
        cb: PpsSignaturePasswordCallback,
        user_data: gpointer,
    );
    pub fn pps_document_signatures_sign(
        document_signatures: *mut PpsDocumentSignatures,
        signature: *mut PpsSignature,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    ) -> gboolean;
    pub fn pps_document_signatures_sign_finish(
        document_signatures: *mut PpsDocumentSignatures,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // PpsDocumentText
    //=========================================================================
    pub fn pps_document_text_get_type() -> GType;
    pub fn pps_document_text_get_text(
        document_text: *mut PpsDocumentText,
        page: *mut PpsPage,
    ) -> *mut c_char;
    pub fn pps_document_text_get_text_attrs(
        document_text: *mut PpsDocumentText,
        page: *mut PpsPage,
    ) -> *mut pango::PangoAttrList;
    #[cfg(feature = "v47")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v47")))]
    pub fn pps_document_text_get_text_in_area(
        document_text: *mut PpsDocumentText,
        page: *mut PpsPage,
        area: *mut PpsRectangle,
    ) -> *mut c_char;
    pub fn pps_document_text_get_text_layout(
        document_text: *mut PpsDocumentText,
        page: *mut PpsPage,
        areas: *mut *mut PpsRectangle,
        n_areas: *mut c_uint,
    ) -> gboolean;
    pub fn pps_document_text_get_text_mapping(
        document_text: *mut PpsDocumentText,
        page: *mut PpsPage,
    ) -> *mut cairo::cairo_region_t;

    //=========================================================================
    // PpsDocumentTransition
    //=========================================================================
    pub fn pps_document_transition_get_type() -> GType;
    pub fn pps_document_transition_get_effect(
        document_trans: *mut PpsDocumentTransition,
        page: c_int,
    ) -> *mut PpsTransitionEffect;
    pub fn pps_document_transition_get_page_duration(
        document_trans: *mut PpsDocumentTransition,
        page: c_int,
    ) -> c_double;

    //=========================================================================
    // PpsFileExporter
    //=========================================================================
    pub fn pps_file_exporter_get_type() -> GType;
    pub fn pps_file_exporter_begin(exporter: *mut PpsFileExporter, fc: *mut PpsFileExporterContext);
    pub fn pps_file_exporter_begin_page(exporter: *mut PpsFileExporter);
    pub fn pps_file_exporter_do_page(exporter: *mut PpsFileExporter, rc: *mut PpsRenderContext);
    pub fn pps_file_exporter_end(exporter: *mut PpsFileExporter);
    pub fn pps_file_exporter_end_page(exporter: *mut PpsFileExporter);
    pub fn pps_file_exporter_get_capabilities(
        exporter: *mut PpsFileExporter,
    ) -> PpsFileExporterCapabilities;

    //=========================================================================
    // PpsSelection
    //=========================================================================
    pub fn pps_selection_get_type() -> GType;
    pub fn pps_selection_get_selected_text(
        selection: *mut PpsSelection,
        page: *mut PpsPage,
        style: PpsSelectionStyle,
        points: *mut PpsRectangle,
    ) -> *mut c_char;
    pub fn pps_selection_get_selection_region(
        selection: *mut PpsSelection,
        rc: *mut PpsRenderContext,
        style: PpsSelectionStyle,
        points: *mut PpsRectangle,
    ) -> *mut cairo::cairo_region_t;
    pub fn pps_selection_render_selection(
        selection: *mut PpsSelection,
        rc: *mut PpsRenderContext,
        surface: *mut *mut cairo::cairo_surface_t,
        points: *mut PpsRectangle,
        old_points: *mut PpsRectangle,
        style: PpsSelectionStyle,
        text: *mut gdk::GdkRGBA,
        base: *mut gdk::GdkRGBA,
    );

    //=========================================================================
    // Other functions
    //=========================================================================
    pub fn pps_backend_query_type() -> GType;
    pub fn pps_file_compress(
        uri: *const c_char,
        type_: PpsCompressionType,
        error: *mut *mut glib::GError,
    ) -> *mut c_char;
    pub fn pps_file_copy_metadata(
        from: *const c_char,
        to: *const c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn pps_file_get_mime_type(
        uri: *const c_char,
        fast: gboolean,
        error: *mut *mut glib::GError,
    ) -> *mut c_char;
    pub fn pps_file_get_mime_type_from_fd(fd: c_int, error: *mut *mut glib::GError) -> *mut c_char;
    pub fn pps_file_is_temp(file: *mut gio::GFile) -> gboolean;
    pub fn pps_file_uncompress(
        uri: *const c_char,
        type_: PpsCompressionType,
        error: *mut *mut glib::GError,
    ) -> *mut c_char;
    pub fn pps_init() -> gboolean;
    pub fn pps_mkstemp(
        tmpl: *const c_char,
        file_name: *mut *mut c_char,
        error: *mut *mut glib::GError,
    ) -> c_int;
    pub fn pps_mkstemp_file(tmpl: *const c_char, error: *mut *mut glib::GError) -> *mut gio::GFile;
    pub fn pps_rect_cmp(a: *mut PpsRectangle, b: *mut PpsRectangle) -> c_int;
    pub fn pps_shutdown();
    pub fn pps_tmp_file_unlink(file: *mut gio::GFile);
    pub fn pps_tmp_filename_unlink(filename: *const c_char);
    pub fn pps_tmp_uri_unlink(uri: *const c_char);
    pub fn pps_xfer_uri_simple(
        from: *const c_char,
        to: *const c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn pps_xmp_parse(
        metadata: *const c_char,
        size: size_t,
        info: *mut PpsDocumentInfo,
    ) -> gboolean;

}
