libheif-hs-0.1.0.0: src-native/Codec/HEIF/Bindings/Generated.hs

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE EmptyDataDecls #-}
{-# LANGUAGE ExplicitForAll #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UnboxedTuples #-}
{-# LANGUAGE UndecidableInstances #-}

module Codec.HEIF.Bindings.Generated
    ( Codec.HEIF.Bindings.Generated.lIBHEIF_NUMERIC_VERSION
    , Codec.HEIF.Bindings.Generated.lIBHEIF_VERSION
    , Codec.HEIF.Bindings.Generated.lIBHEIF_PLUGIN_DIRECTORY
    , Codec.HEIF.Bindings.Generated.Heif_error_code(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_error_Ok
    , pattern Codec.HEIF.Bindings.Generated.Heif_error_Input_does_not_exist
    , pattern Codec.HEIF.Bindings.Generated.Heif_error_Invalid_input
    , pattern Codec.HEIF.Bindings.Generated.Heif_error_Unsupported_filetype
    , pattern Codec.HEIF.Bindings.Generated.Heif_error_Unsupported_feature
    , pattern Codec.HEIF.Bindings.Generated.Heif_error_Usage_error
    , pattern Codec.HEIF.Bindings.Generated.Heif_error_Memory_allocation_error
    , pattern Codec.HEIF.Bindings.Generated.Heif_error_Decoder_plugin_error
    , pattern Codec.HEIF.Bindings.Generated.Heif_error_Encoder_plugin_error
    , pattern Codec.HEIF.Bindings.Generated.Heif_error_Encoding_error
    , pattern Codec.HEIF.Bindings.Generated.Heif_error_Color_profile_does_not_exist
    , pattern Codec.HEIF.Bindings.Generated.Heif_error_Plugin_loading_error
    , pattern Codec.HEIF.Bindings.Generated.Heif_error_Canceled
    , pattern Codec.HEIF.Bindings.Generated.Heif_error_End_of_sequence
    , Codec.HEIF.Bindings.Generated.Heif_suberror_code(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Unspecified
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_End_of_data
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Invalid_box_size
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_ftyp_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_idat_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_meta_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_hdlr_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_hvcC_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_pitm_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_ipco_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_ipma_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_iloc_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_iinf_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_iprp_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_iref_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_pict_handler
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Ipma_box_references_nonexisting_property
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_properties_assigned_to_item
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_item_data
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Invalid_grid_data
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Missing_grid_images
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Invalid_clean_aperture
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Invalid_overlay_data
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Overlay_image_outside_of_canvas
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Auxiliary_image_type_unspecified
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_or_invalid_primary_item
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_infe_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Unknown_color_profile_type
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Wrong_tile_image_chroma_format
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Invalid_fractional_number
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Invalid_image_size
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Invalid_pixi_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_av1C_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Wrong_tile_image_pixel_depth
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Unknown_NCLX_color_primaries
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Unknown_NCLX_transfer_characteristics
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Unknown_NCLX_matrix_coefficients
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Invalid_region_data
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_ispe_property
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Camera_intrinsic_matrix_undefined
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Camera_extrinsic_matrix_undefined
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Invalid_J2K_codestream
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_vvcC_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_icbr_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_avcC_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Invalid_mini_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Decompression_invalid_data
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_moov_box
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_NCLX_colr_VUI_mismatch
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Security_limit_exceeded
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Compression_initialisation_error
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Nonexisting_item_referenced
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Null_pointer_argument
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Nonexisting_image_channel_referenced
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Unsupported_plugin_version
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Unsupported_writer_version
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Unsupported_parameter
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Invalid_parameter_value
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Invalid_property
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Item_reference_cycle
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Unsupported_codec
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Unsupported_image_type
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Unsupported_data_version
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Unsupported_color_conversion
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Unsupported_item_construction_method
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Unsupported_header_compression_method
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Unsupported_generic_compression_method
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Unsupported_essential_property
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Unsupported_track_type
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Unsupported_bit_depth
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Cannot_write_output_data
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Encoder_initialization
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Encoder_encoding
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Encoder_cleanup
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Too_many_regions
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Plugin_loading_error
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Plugin_is_not_loaded
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_Cannot_read_plugin_directory
    , pattern Codec.HEIF.Bindings.Generated.Heif_suberror_No_matching_decoder_installed
    , Codec.HEIF.Bindings.Generated.Heif_error(..)
    , Codec.HEIF.Bindings.Generated.lIBHEIF_MAKE_VERSION
    , Codec.HEIF.Bindings.Generated.lIBHEIF_HAVE_VERSION
    , Codec.HEIF.Bindings.Generated.Heif_context
    , Codec.HEIF.Bindings.Generated.Heif_image_handle
    , Codec.HEIF.Bindings.Generated.Heif_item_id(..)
    , Codec.HEIF.Bindings.Generated.Heif_property_id(..)
    , Codec.HEIF.Bindings.Generated.Heif_init_params(..)
    , Codec.HEIF.Bindings.Generated.Heif_plugin_type(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_plugin_type_encoder
    , pattern Codec.HEIF.Bindings.Generated.Heif_plugin_type_decoder
    , Codec.HEIF.Bindings.Generated.Heif_plugin_info(..)
    , Codec.HEIF.Bindings.Generated.Heif_decoder_plugin
    , Codec.HEIF.Bindings.Generated.Heif_encoder_plugin
    , Codec.HEIF.Bindings.Generated.Heif_chroma(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_chroma_undefined
    , pattern Codec.HEIF.Bindings.Generated.Heif_chroma_planar
    , pattern Codec.HEIF.Bindings.Generated.Heif_chroma_420
    , pattern Codec.HEIF.Bindings.Generated.Heif_chroma_422
    , pattern Codec.HEIF.Bindings.Generated.Heif_chroma_444
    , pattern Codec.HEIF.Bindings.Generated.Heif_chroma_interleaved_RGB
    , pattern Codec.HEIF.Bindings.Generated.Heif_chroma_interleaved_RGBA
    , pattern Codec.HEIF.Bindings.Generated.Heif_chroma_interleaved_RRGGBB_BE
    , pattern Codec.HEIF.Bindings.Generated.Heif_chroma_interleaved_RRGGBBAA_BE
    , pattern Codec.HEIF.Bindings.Generated.Heif_chroma_interleaved_RRGGBB_LE
    , pattern Codec.HEIF.Bindings.Generated.Heif_chroma_interleaved_RRGGBBAA_LE
    , Codec.HEIF.Bindings.Generated.Heif_colorspace(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_colorspace_undefined
    , pattern Codec.HEIF.Bindings.Generated.Heif_colorspace_YCbCr
    , pattern Codec.HEIF.Bindings.Generated.Heif_colorspace_RGB
    , pattern Codec.HEIF.Bindings.Generated.Heif_colorspace_monochrome
    , pattern Codec.HEIF.Bindings.Generated.Heif_colorspace_custom
    , pattern Codec.HEIF.Bindings.Generated.Heif_colorspace_filter_array
    , Codec.HEIF.Bindings.Generated.Heif_channel(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_channel_Y
    , pattern Codec.HEIF.Bindings.Generated.Heif_channel_Cb
    , pattern Codec.HEIF.Bindings.Generated.Heif_channel_Cr
    , pattern Codec.HEIF.Bindings.Generated.Heif_channel_R
    , pattern Codec.HEIF.Bindings.Generated.Heif_channel_G
    , pattern Codec.HEIF.Bindings.Generated.Heif_channel_B
    , pattern Codec.HEIF.Bindings.Generated.Heif_channel_Alpha
    , pattern Codec.HEIF.Bindings.Generated.Heif_channel_interleaved
    , pattern Codec.HEIF.Bindings.Generated.Heif_channel_filter_array
    , pattern Codec.HEIF.Bindings.Generated.Heif_channel_depth
    , pattern Codec.HEIF.Bindings.Generated.Heif_channel_disparity
    , pattern Codec.HEIF.Bindings.Generated.Heif_channel_unknown
    , Codec.HEIF.Bindings.Generated.Heif_image
    , Codec.HEIF.Bindings.Generated.Heif_scaling_options
    , Codec.HEIF.Bindings.Generated.Heif_chroma_downsampling_algorithm(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_chroma_downsampling_nearest_neighbor
    , pattern Codec.HEIF.Bindings.Generated.Heif_chroma_downsampling_average
    , pattern Codec.HEIF.Bindings.Generated.Heif_chroma_downsampling_sharp_yuv
    , Codec.HEIF.Bindings.Generated.Heif_chroma_upsampling_algorithm(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_chroma_upsampling_nearest_neighbor
    , pattern Codec.HEIF.Bindings.Generated.Heif_chroma_upsampling_bilinear
    , Codec.HEIF.Bindings.Generated.Heif_color_conversion_options(..)
    , Codec.HEIF.Bindings.Generated.Heif_alpha_composition_mode(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_alpha_composition_mode_none
    , pattern Codec.HEIF.Bindings.Generated.Heif_alpha_composition_mode_solid_color
    , pattern Codec.HEIF.Bindings.Generated.Heif_alpha_composition_mode_checkerboard
    , Codec.HEIF.Bindings.Generated.Heif_color_conversion_options_ext(..)
    , Codec.HEIF.Bindings.Generated.Heif_color_profile_type(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_color_profile_type_not_present
    , pattern Codec.HEIF.Bindings.Generated.Heif_color_profile_type_nclx
    , pattern Codec.HEIF.Bindings.Generated.Heif_color_profile_type_rICC
    , pattern Codec.HEIF.Bindings.Generated.Heif_color_profile_type_prof
    , Codec.HEIF.Bindings.Generated.Heif_color_primaries(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_color_primaries_ITU_R_BT_709_5
    , pattern Codec.HEIF.Bindings.Generated.Heif_color_primaries_unspecified
    , pattern Codec.HEIF.Bindings.Generated.Heif_color_primaries_ITU_R_BT_470_6_System_M
    , pattern Codec.HEIF.Bindings.Generated.Heif_color_primaries_ITU_R_BT_470_6_System_B_G
    , pattern Codec.HEIF.Bindings.Generated.Heif_color_primaries_ITU_R_BT_601_6
    , pattern Codec.HEIF.Bindings.Generated.Heif_color_primaries_SMPTE_240M
    , pattern Codec.HEIF.Bindings.Generated.Heif_color_primaries_generic_film
    , pattern Codec.HEIF.Bindings.Generated.Heif_color_primaries_ITU_R_BT_2020_2_and_2100_0
    , pattern Codec.HEIF.Bindings.Generated.Heif_color_primaries_SMPTE_ST_428_1
    , pattern Codec.HEIF.Bindings.Generated.Heif_color_primaries_SMPTE_RP_431_2
    , pattern Codec.HEIF.Bindings.Generated.Heif_color_primaries_SMPTE_EG_432_1
    , pattern Codec.HEIF.Bindings.Generated.Heif_color_primaries_EBU_Tech_3213_E
    , Codec.HEIF.Bindings.Generated.Heif_transfer_characteristics(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_transfer_characteristic_ITU_R_BT_709_5
    , pattern Codec.HEIF.Bindings.Generated.Heif_transfer_characteristic_unspecified
    , pattern Codec.HEIF.Bindings.Generated.Heif_transfer_characteristic_ITU_R_BT_470_6_System_M
    , pattern Codec.HEIF.Bindings.Generated.Heif_transfer_characteristic_ITU_R_BT_470_6_System_B_G
    , pattern Codec.HEIF.Bindings.Generated.Heif_transfer_characteristic_ITU_R_BT_601_6
    , pattern Codec.HEIF.Bindings.Generated.Heif_transfer_characteristic_SMPTE_240M
    , pattern Codec.HEIF.Bindings.Generated.Heif_transfer_characteristic_linear
    , pattern Codec.HEIF.Bindings.Generated.Heif_transfer_characteristic_logarithmic_100
    , pattern Codec.HEIF.Bindings.Generated.Heif_transfer_characteristic_logarithmic_100_sqrt10
    , pattern Codec.HEIF.Bindings.Generated.Heif_transfer_characteristic_IEC_61966_2_4
    , pattern Codec.HEIF.Bindings.Generated.Heif_transfer_characteristic_ITU_R_BT_1361
    , pattern Codec.HEIF.Bindings.Generated.Heif_transfer_characteristic_IEC_61966_2_1
    , pattern Codec.HEIF.Bindings.Generated.Heif_transfer_characteristic_ITU_R_BT_2020_2_10bit
    , pattern Codec.HEIF.Bindings.Generated.Heif_transfer_characteristic_ITU_R_BT_2020_2_12bit
    , pattern Codec.HEIF.Bindings.Generated.Heif_transfer_characteristic_ITU_R_BT_2100_0_PQ
    , pattern Codec.HEIF.Bindings.Generated.Heif_transfer_characteristic_SMPTE_ST_428_1
    , pattern Codec.HEIF.Bindings.Generated.Heif_transfer_characteristic_ITU_R_BT_2100_0_HLG
    , Codec.HEIF.Bindings.Generated.Heif_matrix_coefficients(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_matrix_coefficients_RGB_GBR
    , pattern Codec.HEIF.Bindings.Generated.Heif_matrix_coefficients_ITU_R_BT_709_5
    , pattern Codec.HEIF.Bindings.Generated.Heif_matrix_coefficients_unspecified
    , pattern Codec.HEIF.Bindings.Generated.Heif_matrix_coefficients_US_FCC_T47
    , pattern Codec.HEIF.Bindings.Generated.Heif_matrix_coefficients_ITU_R_BT_470_6_System_B_G
    , pattern Codec.HEIF.Bindings.Generated.Heif_matrix_coefficients_ITU_R_BT_601_6
    , pattern Codec.HEIF.Bindings.Generated.Heif_matrix_coefficients_SMPTE_240M
    , pattern Codec.HEIF.Bindings.Generated.Heif_matrix_coefficients_YCgCo
    , pattern Codec.HEIF.Bindings.Generated.Heif_matrix_coefficients_ITU_R_BT_2020_2_non_constant_luminance
    , pattern Codec.HEIF.Bindings.Generated.Heif_matrix_coefficients_ITU_R_BT_2020_2_constant_luminance
    , pattern Codec.HEIF.Bindings.Generated.Heif_matrix_coefficients_SMPTE_ST_2085
    , pattern Codec.HEIF.Bindings.Generated.Heif_matrix_coefficients_chromaticity_derived_non_constant_luminance
    , pattern Codec.HEIF.Bindings.Generated.Heif_matrix_coefficients_chromaticity_derived_constant_luminance
    , pattern Codec.HEIF.Bindings.Generated.Heif_matrix_coefficients_ICtCp
    , Codec.HEIF.Bindings.Generated.Heif_color_profile_nclx(..)
    , Codec.HEIF.Bindings.Generated.Heif_content_light_level(..)
    , Codec.HEIF.Bindings.Generated.Heif_mastering_display_colour_volume(..)
    , Codec.HEIF.Bindings.Generated.Heif_decoded_mastering_display_colour_volume(..)
    , Codec.HEIF.Bindings.Generated.Heif_ambient_viewing_environment(..)
    , Codec.HEIF.Bindings.Generated.Heif_brand2(..)
    , Codec.HEIF.Bindings.Generated.Heif_filetype_result(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_filetype_no
    , pattern Codec.HEIF.Bindings.Generated.Heif_filetype_yes_supported
    , pattern Codec.HEIF.Bindings.Generated.Heif_filetype_yes_unsupported
    , pattern Codec.HEIF.Bindings.Generated.Heif_filetype_maybe
    , Codec.HEIF.Bindings.Generated.Heif_brand(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_unknown_brand
    , pattern Codec.HEIF.Bindings.Generated.Heif_heic
    , pattern Codec.HEIF.Bindings.Generated.Heif_heix
    , pattern Codec.HEIF.Bindings.Generated.Heif_hevc
    , pattern Codec.HEIF.Bindings.Generated.Heif_hevx
    , pattern Codec.HEIF.Bindings.Generated.Heif_heim
    , pattern Codec.HEIF.Bindings.Generated.Heif_heis
    , pattern Codec.HEIF.Bindings.Generated.Heif_hevm
    , pattern Codec.HEIF.Bindings.Generated.Heif_hevs
    , pattern Codec.HEIF.Bindings.Generated.Heif_mif1
    , pattern Codec.HEIF.Bindings.Generated.Heif_msf1
    , pattern Codec.HEIF.Bindings.Generated.Heif_avif
    , pattern Codec.HEIF.Bindings.Generated.Heif_avis
    , pattern Codec.HEIF.Bindings.Generated.Heif_vvic
    , pattern Codec.HEIF.Bindings.Generated.Heif_vvis
    , pattern Codec.HEIF.Bindings.Generated.Heif_evbi
    , pattern Codec.HEIF.Bindings.Generated.Heif_evbs
    , pattern Codec.HEIF.Bindings.Generated.Heif_j2ki
    , pattern Codec.HEIF.Bindings.Generated.Heif_j2is
    , Codec.HEIF.Bindings.Generated.Heif_metadata_compression(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_metadata_compression_off
    , pattern Codec.HEIF.Bindings.Generated.Heif_metadata_compression_auto
    , pattern Codec.HEIF.Bindings.Generated.Heif_metadata_compression_unknown
    , pattern Codec.HEIF.Bindings.Generated.Heif_metadata_compression_deflate
    , pattern Codec.HEIF.Bindings.Generated.Heif_metadata_compression_zlib
    , pattern Codec.HEIF.Bindings.Generated.Heif_metadata_compression_brotli
    , Codec.HEIF.Bindings.Generated.Heif_encoder
    , Codec.HEIF.Bindings.Generated.Heif_depth_representation_type(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_depth_representation_type_uniform_inverse_Z
    , pattern Codec.HEIF.Bindings.Generated.Heif_depth_representation_type_uniform_disparity
    , pattern Codec.HEIF.Bindings.Generated.Heif_depth_representation_type_uniform_Z
    , pattern Codec.HEIF.Bindings.Generated.Heif_depth_representation_type_nonuniform_disparity
    , Codec.HEIF.Bindings.Generated.Heif_depth_representation_info(..)
    , Codec.HEIF.Bindings.Generated.lIBHEIF_AUX_IMAGE_FILTER_OMIT_ALPHA
    , Codec.HEIF.Bindings.Generated.lIBHEIF_AUX_IMAGE_FILTER_OMIT_DEPTH
    , Codec.HEIF.Bindings.Generated.Heif_entity_group_id(..)
    , Codec.HEIF.Bindings.Generated.Heif_entity_group(..)
    , Codec.HEIF.Bindings.Generated.Heif_security_limits(..)
    , Codec.HEIF.Bindings.Generated.Heif_compression_format(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_compression_undefined
    , pattern Codec.HEIF.Bindings.Generated.Heif_compression_HEVC
    , pattern Codec.HEIF.Bindings.Generated.Heif_compression_AVC
    , pattern Codec.HEIF.Bindings.Generated.Heif_compression_JPEG
    , pattern Codec.HEIF.Bindings.Generated.Heif_compression_AV1
    , pattern Codec.HEIF.Bindings.Generated.Heif_compression_VVC
    , pattern Codec.HEIF.Bindings.Generated.Heif_compression_EVC
    , pattern Codec.HEIF.Bindings.Generated.Heif_compression_JPEG2000
    , pattern Codec.HEIF.Bindings.Generated.Heif_compression_uncompressed
    , pattern Codec.HEIF.Bindings.Generated.Heif_compression_mask
    , pattern Codec.HEIF.Bindings.Generated.Heif_compression_HTJ2K
    , Codec.HEIF.Bindings.Generated.Heif_reading_options
    , Codec.HEIF.Bindings.Generated.Heif_reader_grow_status(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_reader_grow_status_size_reached
    , pattern Codec.HEIF.Bindings.Generated.Heif_reader_grow_status_timeout
    , pattern Codec.HEIF.Bindings.Generated.Heif_reader_grow_status_size_beyond_eof
    , pattern Codec.HEIF.Bindings.Generated.Heif_reader_grow_status_error
    , Codec.HEIF.Bindings.Generated.Heif_reader_range_request_result(..)
    , Codec.HEIF.Bindings.Generated.Heif_reader(..)
    , Codec.HEIF.Bindings.Generated.Heif_writer(..)
    , Codec.HEIF.Bindings.Generated.Heif_unci_image_parameters
    , Codec.HEIF.Bindings.Generated.Heif_encoder_descriptor
    , Codec.HEIF.Bindings.Generated.Heif_encoder_parameter
    , Codec.HEIF.Bindings.Generated.Heif_encoder_parameter_type(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_encoder_parameter_type_integer
    , pattern Codec.HEIF.Bindings.Generated.Heif_encoder_parameter_type_boolean
    , pattern Codec.HEIF.Bindings.Generated.Heif_encoder_parameter_type_string
    , Codec.HEIF.Bindings.Generated.Heif_orientation(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_orientation_normal
    , pattern Codec.HEIF.Bindings.Generated.Heif_orientation_flip_horizontally
    , pattern Codec.HEIF.Bindings.Generated.Heif_orientation_rotate_180
    , pattern Codec.HEIF.Bindings.Generated.Heif_orientation_flip_vertically
    , pattern Codec.HEIF.Bindings.Generated.Heif_orientation_rotate_90_cw_then_flip_horizontally
    , pattern Codec.HEIF.Bindings.Generated.Heif_orientation_rotate_90_cw
    , pattern Codec.HEIF.Bindings.Generated.Heif_orientation_rotate_90_cw_then_flip_vertically
    , pattern Codec.HEIF.Bindings.Generated.Heif_orientation_rotate_270_cw
    , Codec.HEIF.Bindings.Generated.Heif_encoding_options(..)
    , Codec.HEIF.Bindings.Generated.Heif_progress_step(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_progress_step_total
    , pattern Codec.HEIF.Bindings.Generated.Heif_progress_step_load_tile
    , Codec.HEIF.Bindings.Generated.Heif_decoding_options(..)
    , Codec.HEIF.Bindings.Generated.Heif_decoder_descriptor
    , Codec.HEIF.Bindings.Generated.Heif_image_tiling(..)
    , Codec.HEIF.Bindings.Generated.Heif_component_datatype(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_component_datatype_unsigned_integer
    , pattern Codec.HEIF.Bindings.Generated.Heif_component_datatype_floating_point
    , pattern Codec.HEIF.Bindings.Generated.Heif_component_datatype_complex_number
    , pattern Codec.HEIF.Bindings.Generated.Heif_component_datatype_signed_integer
    , pattern Codec.HEIF.Bindings.Generated.Heif_component_datatype_undefined
    , Codec.HEIF.Bindings.Generated.Heif_complex32(..)
    , Codec.HEIF.Bindings.Generated.Heif_complex64(..)
    , Codec.HEIF.Bindings.Generated.Heif_cmpd_component_type(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_cmpd_component_type_monochrome
    , pattern Codec.HEIF.Bindings.Generated.Heif_cmpd_component_type_Y
    , pattern Codec.HEIF.Bindings.Generated.Heif_cmpd_component_type_Cb
    , pattern Codec.HEIF.Bindings.Generated.Heif_cmpd_component_type_Cr
    , pattern Codec.HEIF.Bindings.Generated.Heif_cmpd_component_type_red
    , pattern Codec.HEIF.Bindings.Generated.Heif_cmpd_component_type_green
    , pattern Codec.HEIF.Bindings.Generated.Heif_cmpd_component_type_blue
    , pattern Codec.HEIF.Bindings.Generated.Heif_cmpd_component_type_alpha
    , pattern Codec.HEIF.Bindings.Generated.Heif_cmpd_component_type_depth
    , pattern Codec.HEIF.Bindings.Generated.Heif_cmpd_component_type_disparity
    , pattern Codec.HEIF.Bindings.Generated.Heif_cmpd_component_type_palette
    , pattern Codec.HEIF.Bindings.Generated.Heif_cmpd_component_type_filter_array
    , pattern Codec.HEIF.Bindings.Generated.Heif_cmpd_component_type_padded
    , pattern Codec.HEIF.Bindings.Generated.Heif_cmpd_component_type_cyan
    , pattern Codec.HEIF.Bindings.Generated.Heif_cmpd_component_type_magenta
    , pattern Codec.HEIF.Bindings.Generated.Heif_cmpd_component_type_yellow
    , pattern Codec.HEIF.Bindings.Generated.Heif_cmpd_component_type_key_black
    , Codec.HEIF.Bindings.Generated.Heif_omaf_image_projection(..)
    , pattern Codec.HEIF.Bindings.Generated.Heif_omaf_image_projection_equirectangular
    , pattern Codec.HEIF.Bindings.Generated.Heif_omaf_image_projection_cube_map
    , pattern Codec.HEIF.Bindings.Generated.Heif_omaf_image_projection_flat
    )
  where

import qualified C.Expr.HostPlatform
import qualified HsBindgen.Runtime.CEnum as CEnum
import qualified HsBindgen.Runtime.ConstantArray as CA
import qualified HsBindgen.Runtime.HasCField as HasCField
import qualified HsBindgen.Runtime.LibC
import qualified HsBindgen.Runtime.Marshal as Marshal
import qualified HsBindgen.Runtime.PtrConst as PtrConst
import qualified HsBindgen.Runtime.Struct as Struct
import qualified HsBindgen.Runtime.Support as BG
import qualified HsBindgen.Runtime.Support.CompatHasField as BG.CompatHasField

{-| __C declaration:__ @macro LIBHEIF_NUMERIC_VERSION@

    __defined at:__ @libheif\/heif_version.h 31:9@

    __exported by:__ @libheif\/heif.h@
-}
lIBHEIF_NUMERIC_VERSION :: BG.CInt
lIBHEIF_NUMERIC_VERSION =
  (C.Expr.HostPlatform..|.) ((C.Expr.HostPlatform..|.) ((C.Expr.HostPlatform..|.) ((C.Expr.HostPlatform.<<) (1 :: BG.CInt) (24 :: BG.CInt)) ((C.Expr.HostPlatform.<<) (23 :: BG.CInt) (16 :: BG.CInt))) ((C.Expr.HostPlatform.<<) (1 :: BG.CInt) (8 :: BG.CInt))) (0 :: BG.CInt)

{-| __C declaration:__ @macro LIBHEIF_VERSION@

    __C literal:__ @\"1.23.1\"@

    __defined at:__ @libheif\/heif_version.h 34:9@

    __exported by:__ @libheif\/heif.h@
-}
lIBHEIF_VERSION :: BG.ByteString
lIBHEIF_VERSION =
  BG.pack [0x31, 0x2E, 0x32, 0x33, 0x2E, 0x31]

{-| __C declaration:__ @macro LIBHEIF_PLUGIN_DIRECTORY@

    __C literal:__ @\"\/nix\/store\/52p937jmw0wmmvszl0s8nh9jyxajva6g-libheif-1.23.1-lib\/lib\/libheif\"@

    __defined at:__ @libheif\/heif_version.h 36:9@

    __exported by:__ @libheif\/heif.h@
-}
lIBHEIF_PLUGIN_DIRECTORY :: BG.ByteString
lIBHEIF_PLUGIN_DIRECTORY =
  BG.pack [0x2F, 0x6E, 0x69, 0x78, 0x2F, 0x73, 0x74, 0x6F, 0x72, 0x65, 0x2F, 0x35, 0x32, 0x70, 0x39, 0x33, 0x37, 0x6A, 0x6D, 0x77, 0x30, 0x77, 0x6D, 0x6D, 0x76, 0x73, 0x7A, 0x6C, 0x30, 0x73, 0x38, 0x6E, 0x68, 0x39, 0x6A, 0x79, 0x78, 0x61, 0x6A, 0x76, 0x61, 0x36, 0x67, 0x2D, 0x6C, 0x69, 0x62, 0x68, 0x65, 0x69, 0x66, 0x2D, 0x31, 0x2E, 0x32, 0x33, 0x2E, 0x31, 0x2D, 0x6C, 0x69, 0x62, 0x2F, 0x6C, 0x69, 0x62, 0x2F, 0x6C, 0x69, 0x62, 0x68, 0x65, 0x69, 0x66]

{-| __C declaration:__ @enum heif_error_code@

    __defined at:__ @libheif\/heif_error.h 34:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_error_code = Heif_error_code
  { unwrapHeif_error_code :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_error_code where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_error_code where

  readRaw =
    \ptr0 ->
          pure Heif_error_code
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_error_code where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_error_code unwrapHeif_error_code2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_error_code2

deriving via Marshal.EquivStorable Heif_error_code instance BG.Storable Heif_error_code

deriving via BG.CUInt instance BG.Prim Heif_error_code

instance CEnum.CEnum Heif_error_code where

  type CEnumZ Heif_error_code = BG.CUInt

  toCEnum = Heif_error_code

  fromCEnum = BG.getField @"unwrapHeif_error_code"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_error_Ok")
                                   , (1, BG.singleton "Heif_error_Input_does_not_exist")
                                   , (2, BG.singleton "Heif_error_Invalid_input")
                                   , (3, BG.singleton "Heif_error_Unsupported_filetype")
                                   , (4, BG.singleton "Heif_error_Unsupported_feature")
                                   , (5, BG.singleton "Heif_error_Usage_error")
                                   , (6, BG.singleton "Heif_error_Memory_allocation_error")
                                   , (7, BG.singleton "Heif_error_Decoder_plugin_error")
                                   , (8, BG.singleton "Heif_error_Encoder_plugin_error")
                                   , (9, BG.singleton "Heif_error_Encoding_error")
                                   , (10, BG.singleton "Heif_error_Color_profile_does_not_exist")
                                   , (11, BG.singleton "Heif_error_Plugin_loading_error")
                                   , (12, BG.singleton "Heif_error_Canceled")
                                   , (13, BG.singleton "Heif_error_End_of_sequence")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_error_code"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_error_code"

  isDeclared = CEnum.seqIsDeclared

  mkDeclared = CEnum.seqMkDeclared

instance CEnum.SequentialCEnum Heif_error_code where

  minDeclaredValue = Heif_error_Ok

  maxDeclaredValue = Heif_error_End_of_sequence

instance Show Heif_error_code where

  showsPrec = CEnum.shows

instance Read Heif_error_code where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_error_code" Heif_error_code ty where

  hasField =
    \x0 ->
      ( \y1 -> Heif_error_code {unwrapHeif_error_code = y1}
      , BG.getField @"unwrapHeif_error_code" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_error_code" (BG.Ptr Heif_error_code) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_error_code")

instance HasCField.HasCField Heif_error_code "unwrapHeif_error_code" where

  type CFieldType Heif_error_code "unwrapHeif_error_code" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_error_Ok@

    __defined at:__ @libheif\/heif_error.h 37:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_error_Ok :: Heif_error_code
pattern Heif_error_Ok = Heif_error_code 0

{-| __C declaration:__ @heif_error_Input_does_not_exist@

    __defined at:__ @libheif\/heif_error.h 40:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_error_Input_does_not_exist :: Heif_error_code
pattern Heif_error_Input_does_not_exist = Heif_error_code 1

{-| __C declaration:__ @heif_error_Invalid_input@

    __defined at:__ @libheif\/heif_error.h 43:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_error_Invalid_input :: Heif_error_code
pattern Heif_error_Invalid_input = Heif_error_code 2

{-| __C declaration:__ @heif_error_Unsupported_filetype@

    __defined at:__ @libheif\/heif_error.h 46:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_error_Unsupported_filetype :: Heif_error_code
pattern Heif_error_Unsupported_filetype = Heif_error_code 3

{-| __C declaration:__ @heif_error_Unsupported_feature@

    __defined at:__ @libheif\/heif_error.h 49:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_error_Unsupported_feature :: Heif_error_code
pattern Heif_error_Unsupported_feature = Heif_error_code 4

{-| __C declaration:__ @heif_error_Usage_error@

    __defined at:__ @libheif\/heif_error.h 52:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_error_Usage_error :: Heif_error_code
pattern Heif_error_Usage_error = Heif_error_code 5

{-| __C declaration:__ @heif_error_Memory_allocation_error@

    __defined at:__ @libheif\/heif_error.h 55:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_error_Memory_allocation_error :: Heif_error_code
pattern Heif_error_Memory_allocation_error = Heif_error_code 6

{-| __C declaration:__ @heif_error_Decoder_plugin_error@

    __defined at:__ @libheif\/heif_error.h 58:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_error_Decoder_plugin_error :: Heif_error_code
pattern Heif_error_Decoder_plugin_error = Heif_error_code 7

{-| __C declaration:__ @heif_error_Encoder_plugin_error@

    __defined at:__ @libheif\/heif_error.h 61:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_error_Encoder_plugin_error :: Heif_error_code
pattern Heif_error_Encoder_plugin_error = Heif_error_code 8

{-| __C declaration:__ @heif_error_Encoding_error@

    __defined at:__ @libheif\/heif_error.h 64:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_error_Encoding_error :: Heif_error_code
pattern Heif_error_Encoding_error = Heif_error_code 9

{-| __C declaration:__ @heif_error_Color_profile_does_not_exist@

    __defined at:__ @libheif\/heif_error.h 67:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_error_Color_profile_does_not_exist :: Heif_error_code
pattern Heif_error_Color_profile_does_not_exist = Heif_error_code 10

{-| __C declaration:__ @heif_error_Plugin_loading_error@

    __defined at:__ @libheif\/heif_error.h 70:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_error_Plugin_loading_error :: Heif_error_code
pattern Heif_error_Plugin_loading_error = Heif_error_code 11

{-| __C declaration:__ @heif_error_Canceled@

    __defined at:__ @libheif\/heif_error.h 73:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_error_Canceled :: Heif_error_code
pattern Heif_error_Canceled = Heif_error_code 12

{-| __C declaration:__ @heif_error_End_of_sequence@

    __defined at:__ @libheif\/heif_error.h 75:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_error_End_of_sequence :: Heif_error_code
pattern Heif_error_End_of_sequence = Heif_error_code 13

{-# COMPLETE
      Heif_error_Ok
    , Heif_error_Input_does_not_exist
    , Heif_error_Invalid_input
    , Heif_error_Unsupported_filetype
    , Heif_error_Unsupported_feature
    , Heif_error_Usage_error
    , Heif_error_Memory_allocation_error
    , Heif_error_Decoder_plugin_error
    , Heif_error_Encoder_plugin_error
    , Heif_error_Encoding_error
    , Heif_error_Color_profile_does_not_exist
    , Heif_error_Plugin_loading_error
    , Heif_error_Canceled
    , Heif_error_End_of_sequence
  #-}

{-| __C declaration:__ @enum heif_suberror_code@

    __defined at:__ @libheif\/heif_error.h 79:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_suberror_code = Heif_suberror_code
  { unwrapHeif_suberror_code :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_suberror_code where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_suberror_code where

  readRaw =
    \ptr0 ->
          pure Heif_suberror_code
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_suberror_code where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_suberror_code unwrapHeif_suberror_code2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_suberror_code2

deriving via Marshal.EquivStorable Heif_suberror_code instance BG.Storable Heif_suberror_code

deriving via BG.CUInt instance BG.Prim Heif_suberror_code

instance CEnum.CEnum Heif_suberror_code where

  type CEnumZ Heif_suberror_code = BG.CUInt

  toCEnum = Heif_suberror_code

  fromCEnum = BG.getField @"unwrapHeif_suberror_code"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_suberror_Unspecified")
                                   , (100, BG.singleton "Heif_suberror_End_of_data")
                                   , (101, BG.singleton "Heif_suberror_Invalid_box_size")
                                   , (102, BG.singleton "Heif_suberror_No_ftyp_box")
                                   , (103, BG.singleton "Heif_suberror_No_idat_box")
                                   , (104, BG.singleton "Heif_suberror_No_meta_box")
                                   , (105, BG.singleton "Heif_suberror_No_hdlr_box")
                                   , (106, BG.singleton "Heif_suberror_No_hvcC_box")
                                   , (107, BG.singleton "Heif_suberror_No_pitm_box")
                                   , (108, BG.singleton "Heif_suberror_No_ipco_box")
                                   , (109, BG.singleton "Heif_suberror_No_ipma_box")
                                   , (110, BG.singleton "Heif_suberror_No_iloc_box")
                                   , (111, BG.singleton "Heif_suberror_No_iinf_box")
                                   , (112, BG.singleton "Heif_suberror_No_iprp_box")
                                   , (113, BG.singleton "Heif_suberror_No_iref_box")
                                   , (114, BG.singleton "Heif_suberror_No_pict_handler")
                                   , (115, BG.singleton "Heif_suberror_Ipma_box_references_nonexisting_property")
                                   , (116, BG.singleton "Heif_suberror_No_properties_assigned_to_item")
                                   , (117, BG.singleton "Heif_suberror_No_item_data")
                                   , (118, BG.singleton "Heif_suberror_Invalid_grid_data")
                                   , (119, BG.singleton "Heif_suberror_Missing_grid_images")
                                   , (120, BG.singleton "Heif_suberror_Invalid_clean_aperture")
                                   , (121, BG.singleton "Heif_suberror_Invalid_overlay_data")
                                   , (122, BG.singleton "Heif_suberror_Overlay_image_outside_of_canvas")
                                   , (123, BG.singleton "Heif_suberror_Auxiliary_image_type_unspecified")
                                   , (124, BG.singleton "Heif_suberror_No_or_invalid_primary_item")
                                   , (125, BG.singleton "Heif_suberror_No_infe_box")
                                   , (126, BG.singleton "Heif_suberror_Unknown_color_profile_type")
                                   , (127, BG.singleton "Heif_suberror_Wrong_tile_image_chroma_format")
                                   , (128, BG.singleton "Heif_suberror_Invalid_fractional_number")
                                   , (129, BG.singleton "Heif_suberror_Invalid_image_size")
                                   , (130, BG.singleton "Heif_suberror_Invalid_pixi_box")
                                   , (131, BG.singleton "Heif_suberror_No_av1C_box")
                                   , (132, BG.singleton "Heif_suberror_Wrong_tile_image_pixel_depth")
                                   , (133, BG.singleton "Heif_suberror_Unknown_NCLX_color_primaries")
                                   , (134, BG.singleton "Heif_suberror_Unknown_NCLX_transfer_characteristics")
                                   , (135, BG.singleton "Heif_suberror_Unknown_NCLX_matrix_coefficients")
                                   , (136, BG.singleton "Heif_suberror_Invalid_region_data")
                                   , (137, BG.singleton "Heif_suberror_No_ispe_property")
                                   , (138, BG.singleton "Heif_suberror_Camera_intrinsic_matrix_undefined")
                                   , (139, BG.singleton "Heif_suberror_Camera_extrinsic_matrix_undefined")
                                   , (140, BG.singleton "Heif_suberror_Invalid_J2K_codestream")
                                   , (141, BG.singleton "Heif_suberror_No_vvcC_box")
                                   , (142, BG.singleton "Heif_suberror_No_icbr_box")
                                   , (143, BG.singleton "Heif_suberror_No_avcC_box")
                                   , (149, BG.singleton "Heif_suberror_Invalid_mini_box")
                                   , (150, BG.singleton "Heif_suberror_Decompression_invalid_data")
                                   , (151, BG.singleton "Heif_suberror_No_moov_box")
                                   , (152, BG.singleton "Heif_suberror_NCLX_colr_VUI_mismatch")
                                   , (1000, BG.singleton "Heif_suberror_Security_limit_exceeded")
                                   , (1001, BG.singleton "Heif_suberror_Compression_initialisation_error")
                                   , (2000, BG.singleton "Heif_suberror_Nonexisting_item_referenced")
                                   , (2001, BG.singleton "Heif_suberror_Null_pointer_argument")
                                   , (2002, BG.singleton "Heif_suberror_Nonexisting_image_channel_referenced")
                                   , (2003, BG.singleton "Heif_suberror_Unsupported_plugin_version")
                                   , (2004, BG.singleton "Heif_suberror_Unsupported_writer_version")
                                   , (2005, BG.singleton "Heif_suberror_Unsupported_parameter")
                                   , (2006, BG.singleton "Heif_suberror_Invalid_parameter_value")
                                   , (2007, BG.singleton "Heif_suberror_Invalid_property")
                                   , (2008, BG.singleton "Heif_suberror_Item_reference_cycle")
                                   , (3000, BG.singleton "Heif_suberror_Unsupported_codec")
                                   , (3001, BG.singleton "Heif_suberror_Unsupported_image_type")
                                   , (3002, BG.singleton "Heif_suberror_Unsupported_data_version")
                                   , (3003, BG.singleton "Heif_suberror_Unsupported_color_conversion")
                                   , (3004, BG.singleton "Heif_suberror_Unsupported_item_construction_method")
                                   , (3005, BG.singleton "Heif_suberror_Unsupported_header_compression_method")
                                   , (3006, BG.singleton "Heif_suberror_Unsupported_generic_compression_method")
                                   , (3007, BG.singleton "Heif_suberror_Unsupported_essential_property")
                                   , (3008, BG.singleton "Heif_suberror_Unsupported_track_type")
                                   , (4000, BG.singleton "Heif_suberror_Unsupported_bit_depth")
                                   , (5000, BG.singleton "Heif_suberror_Cannot_write_output_data")
                                   , (5001, BG.singleton "Heif_suberror_Encoder_initialization")
                                   , (5002, BG.singleton "Heif_suberror_Encoder_encoding")
                                   , (5003, BG.singleton "Heif_suberror_Encoder_cleanup")
                                   , (5004, BG.singleton "Heif_suberror_Too_many_regions")
                                   , (6000, BG.singleton "Heif_suberror_Plugin_loading_error")
                                   , (6001, BG.singleton "Heif_suberror_Plugin_is_not_loaded")
                                   , (6002, BG.singleton "Heif_suberror_Cannot_read_plugin_directory")
                                   , (6003, BG.singleton "Heif_suberror_No_matching_decoder_installed")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_suberror_code"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_suberror_code"

instance Show Heif_suberror_code where

  showsPrec = CEnum.shows

instance Read Heif_suberror_code where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_suberror_code" Heif_suberror_code ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_suberror_code {unwrapHeif_suberror_code = y1}
      , BG.getField @"unwrapHeif_suberror_code" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_suberror_code" (BG.Ptr Heif_suberror_code) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_suberror_code")

instance HasCField.HasCField Heif_suberror_code "unwrapHeif_suberror_code" where

  type CFieldType Heif_suberror_code "unwrapHeif_suberror_code" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_suberror_Unspecified@

    __defined at:__ @libheif\/heif_error.h 82:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Unspecified :: Heif_suberror_code
pattern Heif_suberror_Unspecified = Heif_suberror_code 0

{-| __C declaration:__ @heif_suberror_End_of_data@

    __defined at:__ @libheif\/heif_error.h 87:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_End_of_data :: Heif_suberror_code
pattern Heif_suberror_End_of_data = Heif_suberror_code 100

{-| __C declaration:__ @heif_suberror_Invalid_box_size@

    __defined at:__ @libheif\/heif_error.h 90:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Invalid_box_size :: Heif_suberror_code
pattern Heif_suberror_Invalid_box_size = Heif_suberror_code 101

{-| __C declaration:__ @heif_suberror_No_ftyp_box@

    __defined at:__ @libheif\/heif_error.h 93:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_ftyp_box :: Heif_suberror_code
pattern Heif_suberror_No_ftyp_box = Heif_suberror_code 102

{-| __C declaration:__ @heif_suberror_No_idat_box@

    __defined at:__ @libheif\/heif_error.h 95:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_idat_box :: Heif_suberror_code
pattern Heif_suberror_No_idat_box = Heif_suberror_code 103

{-| __C declaration:__ @heif_suberror_No_meta_box@

    __defined at:__ @libheif\/heif_error.h 97:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_meta_box :: Heif_suberror_code
pattern Heif_suberror_No_meta_box = Heif_suberror_code 104

{-| __C declaration:__ @heif_suberror_No_hdlr_box@

    __defined at:__ @libheif\/heif_error.h 99:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_hdlr_box :: Heif_suberror_code
pattern Heif_suberror_No_hdlr_box = Heif_suberror_code 105

{-| __C declaration:__ @heif_suberror_No_hvcC_box@

    __defined at:__ @libheif\/heif_error.h 101:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_hvcC_box :: Heif_suberror_code
pattern Heif_suberror_No_hvcC_box = Heif_suberror_code 106

{-| __C declaration:__ @heif_suberror_No_pitm_box@

    __defined at:__ @libheif\/heif_error.h 103:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_pitm_box :: Heif_suberror_code
pattern Heif_suberror_No_pitm_box = Heif_suberror_code 107

{-| __C declaration:__ @heif_suberror_No_ipco_box@

    __defined at:__ @libheif\/heif_error.h 105:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_ipco_box :: Heif_suberror_code
pattern Heif_suberror_No_ipco_box = Heif_suberror_code 108

{-| __C declaration:__ @heif_suberror_No_ipma_box@

    __defined at:__ @libheif\/heif_error.h 107:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_ipma_box :: Heif_suberror_code
pattern Heif_suberror_No_ipma_box = Heif_suberror_code 109

{-| __C declaration:__ @heif_suberror_No_iloc_box@

    __defined at:__ @libheif\/heif_error.h 109:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_iloc_box :: Heif_suberror_code
pattern Heif_suberror_No_iloc_box = Heif_suberror_code 110

{-| __C declaration:__ @heif_suberror_No_iinf_box@

    __defined at:__ @libheif\/heif_error.h 111:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_iinf_box :: Heif_suberror_code
pattern Heif_suberror_No_iinf_box = Heif_suberror_code 111

{-| __C declaration:__ @heif_suberror_No_iprp_box@

    __defined at:__ @libheif\/heif_error.h 113:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_iprp_box :: Heif_suberror_code
pattern Heif_suberror_No_iprp_box = Heif_suberror_code 112

{-| __C declaration:__ @heif_suberror_No_iref_box@

    __defined at:__ @libheif\/heif_error.h 115:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_iref_box :: Heif_suberror_code
pattern Heif_suberror_No_iref_box = Heif_suberror_code 113

{-| __C declaration:__ @heif_suberror_No_pict_handler@

    __defined at:__ @libheif\/heif_error.h 117:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_pict_handler :: Heif_suberror_code
pattern Heif_suberror_No_pict_handler = Heif_suberror_code 114

{-| __C declaration:__ @heif_suberror_Ipma_box_references_nonexisting_property@

    __defined at:__ @libheif\/heif_error.h 120:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Ipma_box_references_nonexisting_property :: Heif_suberror_code
pattern Heif_suberror_Ipma_box_references_nonexisting_property = Heif_suberror_code 115

{-| __C declaration:__ @heif_suberror_No_properties_assigned_to_item@

    __defined at:__ @libheif\/heif_error.h 123:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_properties_assigned_to_item :: Heif_suberror_code
pattern Heif_suberror_No_properties_assigned_to_item = Heif_suberror_code 116

{-| __C declaration:__ @heif_suberror_No_item_data@

    __defined at:__ @libheif\/heif_error.h 126:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_item_data :: Heif_suberror_code
pattern Heif_suberror_No_item_data = Heif_suberror_code 117

{-| __C declaration:__ @heif_suberror_Invalid_grid_data@

    __defined at:__ @libheif\/heif_error.h 129:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Invalid_grid_data :: Heif_suberror_code
pattern Heif_suberror_Invalid_grid_data = Heif_suberror_code 118

{-| __C declaration:__ @heif_suberror_Missing_grid_images@

    __defined at:__ @libheif\/heif_error.h 132:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Missing_grid_images :: Heif_suberror_code
pattern Heif_suberror_Missing_grid_images = Heif_suberror_code 119

{-| __C declaration:__ @heif_suberror_Invalid_clean_aperture@

    __defined at:__ @libheif\/heif_error.h 134:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Invalid_clean_aperture :: Heif_suberror_code
pattern Heif_suberror_Invalid_clean_aperture = Heif_suberror_code 120

{-| __C declaration:__ @heif_suberror_Invalid_overlay_data@

    __defined at:__ @libheif\/heif_error.h 137:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Invalid_overlay_data :: Heif_suberror_code
pattern Heif_suberror_Invalid_overlay_data = Heif_suberror_code 121

{-| __C declaration:__ @heif_suberror_Overlay_image_outside_of_canvas@

    __defined at:__ @libheif\/heif_error.h 140:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Overlay_image_outside_of_canvas :: Heif_suberror_code
pattern Heif_suberror_Overlay_image_outside_of_canvas = Heif_suberror_code 122

{-| __C declaration:__ @heif_suberror_Auxiliary_image_type_unspecified@

    __defined at:__ @libheif\/heif_error.h 142:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Auxiliary_image_type_unspecified :: Heif_suberror_code
pattern Heif_suberror_Auxiliary_image_type_unspecified = Heif_suberror_code 123

{-| __C declaration:__ @heif_suberror_No_or_invalid_primary_item@

    __defined at:__ @libheif\/heif_error.h 144:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_or_invalid_primary_item :: Heif_suberror_code
pattern Heif_suberror_No_or_invalid_primary_item = Heif_suberror_code 124

{-| __C declaration:__ @heif_suberror_No_infe_box@

    __defined at:__ @libheif\/heif_error.h 146:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_infe_box :: Heif_suberror_code
pattern Heif_suberror_No_infe_box = Heif_suberror_code 125

{-| __C declaration:__ @heif_suberror_Unknown_color_profile_type@

    __defined at:__ @libheif\/heif_error.h 148:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Unknown_color_profile_type :: Heif_suberror_code
pattern Heif_suberror_Unknown_color_profile_type = Heif_suberror_code 126

{-| __C declaration:__ @heif_suberror_Wrong_tile_image_chroma_format@

    __defined at:__ @libheif\/heif_error.h 150:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Wrong_tile_image_chroma_format :: Heif_suberror_code
pattern Heif_suberror_Wrong_tile_image_chroma_format = Heif_suberror_code 127

{-| __C declaration:__ @heif_suberror_Invalid_fractional_number@

    __defined at:__ @libheif\/heif_error.h 152:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Invalid_fractional_number :: Heif_suberror_code
pattern Heif_suberror_Invalid_fractional_number = Heif_suberror_code 128

{-| __C declaration:__ @heif_suberror_Invalid_image_size@

    __defined at:__ @libheif\/heif_error.h 154:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Invalid_image_size :: Heif_suberror_code
pattern Heif_suberror_Invalid_image_size = Heif_suberror_code 129

{-| __C declaration:__ @heif_suberror_Invalid_pixi_box@

    __defined at:__ @libheif\/heif_error.h 156:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Invalid_pixi_box :: Heif_suberror_code
pattern Heif_suberror_Invalid_pixi_box = Heif_suberror_code 130

{-| __C declaration:__ @heif_suberror_No_av1C_box@

    __defined at:__ @libheif\/heif_error.h 158:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_av1C_box :: Heif_suberror_code
pattern Heif_suberror_No_av1C_box = Heif_suberror_code 131

{-| __C declaration:__ @heif_suberror_Wrong_tile_image_pixel_depth@

    __defined at:__ @libheif\/heif_error.h 160:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Wrong_tile_image_pixel_depth :: Heif_suberror_code
pattern Heif_suberror_Wrong_tile_image_pixel_depth = Heif_suberror_code 132

{-| __C declaration:__ @heif_suberror_Unknown_NCLX_color_primaries@

    __defined at:__ @libheif\/heif_error.h 162:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Unknown_NCLX_color_primaries :: Heif_suberror_code
pattern Heif_suberror_Unknown_NCLX_color_primaries = Heif_suberror_code 133

{-| __C declaration:__ @heif_suberror_Unknown_NCLX_transfer_characteristics@

    __defined at:__ @libheif\/heif_error.h 164:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Unknown_NCLX_transfer_characteristics :: Heif_suberror_code
pattern Heif_suberror_Unknown_NCLX_transfer_characteristics = Heif_suberror_code 134

{-| __C declaration:__ @heif_suberror_Unknown_NCLX_matrix_coefficients@

    __defined at:__ @libheif\/heif_error.h 166:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Unknown_NCLX_matrix_coefficients :: Heif_suberror_code
pattern Heif_suberror_Unknown_NCLX_matrix_coefficients = Heif_suberror_code 135

{-| __C declaration:__ @heif_suberror_Invalid_region_data@

    __defined at:__ @libheif\/heif_error.h 169:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Invalid_region_data :: Heif_suberror_code
pattern Heif_suberror_Invalid_region_data = Heif_suberror_code 136

{-| __C declaration:__ @heif_suberror_No_ispe_property@

    __defined at:__ @libheif\/heif_error.h 172:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_ispe_property :: Heif_suberror_code
pattern Heif_suberror_No_ispe_property = Heif_suberror_code 137

{-| __C declaration:__ @heif_suberror_Camera_intrinsic_matrix_undefined@

    __defined at:__ @libheif\/heif_error.h 174:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Camera_intrinsic_matrix_undefined :: Heif_suberror_code
pattern Heif_suberror_Camera_intrinsic_matrix_undefined = Heif_suberror_code 138

{-| __C declaration:__ @heif_suberror_Camera_extrinsic_matrix_undefined@

    __defined at:__ @libheif\/heif_error.h 176:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Camera_extrinsic_matrix_undefined :: Heif_suberror_code
pattern Heif_suberror_Camera_extrinsic_matrix_undefined = Heif_suberror_code 139

{-| __C declaration:__ @heif_suberror_Invalid_J2K_codestream@

    __defined at:__ @libheif\/heif_error.h 179:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Invalid_J2K_codestream :: Heif_suberror_code
pattern Heif_suberror_Invalid_J2K_codestream = Heif_suberror_code 140

{-| __C declaration:__ @heif_suberror_No_vvcC_box@

    __defined at:__ @libheif\/heif_error.h 181:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_vvcC_box :: Heif_suberror_code
pattern Heif_suberror_No_vvcC_box = Heif_suberror_code 141

{-| __C declaration:__ @heif_suberror_No_icbr_box@

    __defined at:__ @libheif\/heif_error.h 184:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_icbr_box :: Heif_suberror_code
pattern Heif_suberror_No_icbr_box = Heif_suberror_code 142

{-| __C declaration:__ @heif_suberror_No_avcC_box@

    __defined at:__ @libheif\/heif_error.h 186:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_avcC_box :: Heif_suberror_code
pattern Heif_suberror_No_avcC_box = Heif_suberror_code 143

{-| __C declaration:__ @heif_suberror_Invalid_mini_box@

    __defined at:__ @libheif\/heif_error.h 189:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Invalid_mini_box :: Heif_suberror_code
pattern Heif_suberror_Invalid_mini_box = Heif_suberror_code 149

{-| __C declaration:__ @heif_suberror_Decompression_invalid_data@

    __defined at:__ @libheif\/heif_error.h 192:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Decompression_invalid_data :: Heif_suberror_code
pattern Heif_suberror_Decompression_invalid_data = Heif_suberror_code 150

{-| __C declaration:__ @heif_suberror_No_moov_box@

    __defined at:__ @libheif\/heif_error.h 194:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_moov_box :: Heif_suberror_code
pattern Heif_suberror_No_moov_box = Heif_suberror_code 151

{-| __C declaration:__ @heif_suberror_NCLX_colr_VUI_mismatch@

    __defined at:__ @libheif\/heif_error.h 199:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_NCLX_colr_VUI_mismatch :: Heif_suberror_code
pattern Heif_suberror_NCLX_colr_VUI_mismatch = Heif_suberror_code 152

{-| __C declaration:__ @heif_suberror_Security_limit_exceeded@

    __defined at:__ @libheif\/heif_error.h 206:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Security_limit_exceeded :: Heif_suberror_code
pattern Heif_suberror_Security_limit_exceeded = Heif_suberror_code 1000

{-| __C declaration:__ @heif_suberror_Compression_initialisation_error@

    __defined at:__ @libheif\/heif_error.h 210:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Compression_initialisation_error :: Heif_suberror_code
pattern Heif_suberror_Compression_initialisation_error = Heif_suberror_code 1001

{-| __C declaration:__ @heif_suberror_Nonexisting_item_referenced@

    __defined at:__ @libheif\/heif_error.h 215:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Nonexisting_item_referenced :: Heif_suberror_code
pattern Heif_suberror_Nonexisting_item_referenced = Heif_suberror_code 2000

{-| __C declaration:__ @heif_suberror_Null_pointer_argument@

    __defined at:__ @libheif\/heif_error.h 218:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Null_pointer_argument :: Heif_suberror_code
pattern Heif_suberror_Null_pointer_argument = Heif_suberror_code 2001

{-| __C declaration:__ @heif_suberror_Nonexisting_image_channel_referenced@

    __defined at:__ @libheif\/heif_error.h 221:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Nonexisting_image_channel_referenced :: Heif_suberror_code
pattern Heif_suberror_Nonexisting_image_channel_referenced = Heif_suberror_code 2002

{-| __C declaration:__ @heif_suberror_Unsupported_plugin_version@

    __defined at:__ @libheif\/heif_error.h 224:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Unsupported_plugin_version :: Heif_suberror_code
pattern Heif_suberror_Unsupported_plugin_version = Heif_suberror_code 2003

{-| __C declaration:__ @heif_suberror_Unsupported_writer_version@

    __defined at:__ @libheif\/heif_error.h 227:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Unsupported_writer_version :: Heif_suberror_code
pattern Heif_suberror_Unsupported_writer_version = Heif_suberror_code 2004

{-| __C declaration:__ @heif_suberror_Unsupported_parameter@

    __defined at:__ @libheif\/heif_error.h 230:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Unsupported_parameter :: Heif_suberror_code
pattern Heif_suberror_Unsupported_parameter = Heif_suberror_code 2005

{-| __C declaration:__ @heif_suberror_Invalid_parameter_value@

    __defined at:__ @libheif\/heif_error.h 233:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Invalid_parameter_value :: Heif_suberror_code
pattern Heif_suberror_Invalid_parameter_value = Heif_suberror_code 2006

{-| __C declaration:__ @heif_suberror_Invalid_property@

    __defined at:__ @libheif\/heif_error.h 236:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Invalid_property :: Heif_suberror_code
pattern Heif_suberror_Invalid_property = Heif_suberror_code 2007

{-| __C declaration:__ @heif_suberror_Item_reference_cycle@

    __defined at:__ @libheif\/heif_error.h 239:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Item_reference_cycle :: Heif_suberror_code
pattern Heif_suberror_Item_reference_cycle = Heif_suberror_code 2008

{-| __C declaration:__ @heif_suberror_Unsupported_codec@

    __defined at:__ @libheif\/heif_error.h 245:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Unsupported_codec :: Heif_suberror_code
pattern Heif_suberror_Unsupported_codec = Heif_suberror_code 3000

{-| __C declaration:__ @heif_suberror_Unsupported_image_type@

    __defined at:__ @libheif\/heif_error.h 248:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Unsupported_image_type :: Heif_suberror_code
pattern Heif_suberror_Unsupported_image_type = Heif_suberror_code 3001

{-| __C declaration:__ @heif_suberror_Unsupported_data_version@

    __defined at:__ @libheif\/heif_error.h 250:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Unsupported_data_version :: Heif_suberror_code
pattern Heif_suberror_Unsupported_data_version = Heif_suberror_code 3002

{-| __C declaration:__ @heif_suberror_Unsupported_color_conversion@

    __defined at:__ @libheif\/heif_error.h 253:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Unsupported_color_conversion :: Heif_suberror_code
pattern Heif_suberror_Unsupported_color_conversion = Heif_suberror_code 3003

{-| __C declaration:__ @heif_suberror_Unsupported_item_construction_method@

    __defined at:__ @libheif\/heif_error.h 255:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Unsupported_item_construction_method :: Heif_suberror_code
pattern Heif_suberror_Unsupported_item_construction_method = Heif_suberror_code 3004

{-| __C declaration:__ @heif_suberror_Unsupported_header_compression_method@

    __defined at:__ @libheif\/heif_error.h 257:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Unsupported_header_compression_method :: Heif_suberror_code
pattern Heif_suberror_Unsupported_header_compression_method = Heif_suberror_code 3005

{-| __C declaration:__ @heif_suberror_Unsupported_generic_compression_method@

    __defined at:__ @libheif\/heif_error.h 260:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Unsupported_generic_compression_method :: Heif_suberror_code
pattern Heif_suberror_Unsupported_generic_compression_method = Heif_suberror_code 3006

{-| __C declaration:__ @heif_suberror_Unsupported_essential_property@

    __defined at:__ @libheif\/heif_error.h 262:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Unsupported_essential_property :: Heif_suberror_code
pattern Heif_suberror_Unsupported_essential_property = Heif_suberror_code 3007

{-| __C declaration:__ @heif_suberror_Unsupported_track_type@

    __defined at:__ @libheif\/heif_error.h 264:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Unsupported_track_type :: Heif_suberror_code
pattern Heif_suberror_Unsupported_track_type = Heif_suberror_code 3008

{-| __C declaration:__ @heif_suberror_Unsupported_bit_depth@

    __defined at:__ @libheif\/heif_error.h 268:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Unsupported_bit_depth :: Heif_suberror_code
pattern Heif_suberror_Unsupported_bit_depth = Heif_suberror_code 4000

{-| __C declaration:__ @heif_suberror_Cannot_write_output_data@

    __defined at:__ @libheif\/heif_error.h 273:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Cannot_write_output_data :: Heif_suberror_code
pattern Heif_suberror_Cannot_write_output_data = Heif_suberror_code 5000

{-| __C declaration:__ @heif_suberror_Encoder_initialization@

    __defined at:__ @libheif\/heif_error.h 275:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Encoder_initialization :: Heif_suberror_code
pattern Heif_suberror_Encoder_initialization = Heif_suberror_code 5001

{-| __C declaration:__ @heif_suberror_Encoder_encoding@

    __defined at:__ @libheif\/heif_error.h 276:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Encoder_encoding :: Heif_suberror_code
pattern Heif_suberror_Encoder_encoding = Heif_suberror_code 5002

{-| __C declaration:__ @heif_suberror_Encoder_cleanup@

    __defined at:__ @libheif\/heif_error.h 277:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Encoder_cleanup :: Heif_suberror_code
pattern Heif_suberror_Encoder_cleanup = Heif_suberror_code 5003

{-| __C declaration:__ @heif_suberror_Too_many_regions@

    __defined at:__ @libheif\/heif_error.h 279:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Too_many_regions :: Heif_suberror_code
pattern Heif_suberror_Too_many_regions = Heif_suberror_code 5004

{-| __C declaration:__ @heif_suberror_Plugin_loading_error@

    __defined at:__ @libheif\/heif_error.h 284:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Plugin_loading_error :: Heif_suberror_code
pattern Heif_suberror_Plugin_loading_error = Heif_suberror_code 6000

{-| __C declaration:__ @heif_suberror_Plugin_is_not_loaded@

    __defined at:__ @libheif\/heif_error.h 285:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Plugin_is_not_loaded :: Heif_suberror_code
pattern Heif_suberror_Plugin_is_not_loaded = Heif_suberror_code 6001

{-| __C declaration:__ @heif_suberror_Cannot_read_plugin_directory@

    __defined at:__ @libheif\/heif_error.h 286:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_Cannot_read_plugin_directory :: Heif_suberror_code
pattern Heif_suberror_Cannot_read_plugin_directory = Heif_suberror_code 6002

{-| __C declaration:__ @heif_suberror_No_matching_decoder_installed@

    __defined at:__ @libheif\/heif_error.h 287:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_suberror_No_matching_decoder_installed :: Heif_suberror_code
pattern Heif_suberror_No_matching_decoder_installed = Heif_suberror_code 6003

{-# COMPLETE
      Heif_suberror_Unspecified
    , Heif_suberror_End_of_data
    , Heif_suberror_Invalid_box_size
    , Heif_suberror_No_ftyp_box
    , Heif_suberror_No_idat_box
    , Heif_suberror_No_meta_box
    , Heif_suberror_No_hdlr_box
    , Heif_suberror_No_hvcC_box
    , Heif_suberror_No_pitm_box
    , Heif_suberror_No_ipco_box
    , Heif_suberror_No_ipma_box
    , Heif_suberror_No_iloc_box
    , Heif_suberror_No_iinf_box
    , Heif_suberror_No_iprp_box
    , Heif_suberror_No_iref_box
    , Heif_suberror_No_pict_handler
    , Heif_suberror_Ipma_box_references_nonexisting_property
    , Heif_suberror_No_properties_assigned_to_item
    , Heif_suberror_No_item_data
    , Heif_suberror_Invalid_grid_data
    , Heif_suberror_Missing_grid_images
    , Heif_suberror_Invalid_clean_aperture
    , Heif_suberror_Invalid_overlay_data
    , Heif_suberror_Overlay_image_outside_of_canvas
    , Heif_suberror_Auxiliary_image_type_unspecified
    , Heif_suberror_No_or_invalid_primary_item
    , Heif_suberror_No_infe_box
    , Heif_suberror_Unknown_color_profile_type
    , Heif_suberror_Wrong_tile_image_chroma_format
    , Heif_suberror_Invalid_fractional_number
    , Heif_suberror_Invalid_image_size
    , Heif_suberror_Invalid_pixi_box
    , Heif_suberror_No_av1C_box
    , Heif_suberror_Wrong_tile_image_pixel_depth
    , Heif_suberror_Unknown_NCLX_color_primaries
    , Heif_suberror_Unknown_NCLX_transfer_characteristics
    , Heif_suberror_Unknown_NCLX_matrix_coefficients
    , Heif_suberror_Invalid_region_data
    , Heif_suberror_No_ispe_property
    , Heif_suberror_Camera_intrinsic_matrix_undefined
    , Heif_suberror_Camera_extrinsic_matrix_undefined
    , Heif_suberror_Invalid_J2K_codestream
    , Heif_suberror_No_vvcC_box
    , Heif_suberror_No_icbr_box
    , Heif_suberror_No_avcC_box
    , Heif_suberror_Invalid_mini_box
    , Heif_suberror_Decompression_invalid_data
    , Heif_suberror_No_moov_box
    , Heif_suberror_NCLX_colr_VUI_mismatch
    , Heif_suberror_Security_limit_exceeded
    , Heif_suberror_Compression_initialisation_error
    , Heif_suberror_Nonexisting_item_referenced
    , Heif_suberror_Null_pointer_argument
    , Heif_suberror_Nonexisting_image_channel_referenced
    , Heif_suberror_Unsupported_plugin_version
    , Heif_suberror_Unsupported_writer_version
    , Heif_suberror_Unsupported_parameter
    , Heif_suberror_Invalid_parameter_value
    , Heif_suberror_Invalid_property
    , Heif_suberror_Item_reference_cycle
    , Heif_suberror_Unsupported_codec
    , Heif_suberror_Unsupported_image_type
    , Heif_suberror_Unsupported_data_version
    , Heif_suberror_Unsupported_color_conversion
    , Heif_suberror_Unsupported_item_construction_method
    , Heif_suberror_Unsupported_header_compression_method
    , Heif_suberror_Unsupported_generic_compression_method
    , Heif_suberror_Unsupported_essential_property
    , Heif_suberror_Unsupported_track_type
    , Heif_suberror_Unsupported_bit_depth
    , Heif_suberror_Cannot_write_output_data
    , Heif_suberror_Encoder_initialization
    , Heif_suberror_Encoder_encoding
    , Heif_suberror_Encoder_cleanup
    , Heif_suberror_Too_many_regions
    , Heif_suberror_Plugin_loading_error
    , Heif_suberror_Plugin_is_not_loaded
    , Heif_suberror_Cannot_read_plugin_directory
    , Heif_suberror_No_matching_decoder_installed
  #-}

{-| __C declaration:__ @struct heif_error@

    __defined at:__ @libheif\/heif_error.h 291:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_error = Heif_error
  { heif_error_code :: Heif_error_code
    {- ^ __C declaration:__ @code@

         __defined at:__ @libheif\/heif_error.h 294:19@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_error_subcode :: Heif_suberror_code
    {- ^ __C declaration:__ @subcode@

         __defined at:__ @libheif\/heif_error.h 297:22@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_error_message :: PtrConst.PtrConst BG.CChar
    {- ^ __C declaration:__ @message@

         __defined at:__ @libheif\/heif_error.h 300:15@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_error where

  staticSizeOf = \_ -> (16 :: Int)

  staticAlignment = \_ -> (8 :: Int)

instance Marshal.ReadRaw Heif_error where

  readRaw =
    \ptr0 ->
          pure Heif_error
      <*> HasCField.readRaw (BG.Proxy @"heif_error_code") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_error_subcode") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_error_message") ptr0

instance Marshal.WriteRaw Heif_error where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_error heif_error_code2 heif_error_subcode3 heif_error_message4 ->
               HasCField.writeRaw (BG.Proxy @"heif_error_code") ptr0 heif_error_code2
            >> HasCField.writeRaw (BG.Proxy @"heif_error_subcode") ptr0 heif_error_subcode3
            >> HasCField.writeRaw (BG.Proxy @"heif_error_message") ptr0 heif_error_message4

deriving via Marshal.EquivStorable Heif_error instance BG.Storable Heif_error

deriving via Struct.IsStructViaReadRaw Heif_error instance Struct.IsStruct Heif_error

{-| __C declaration:__ @code@

    __defined at:__ @libheif\/heif_error.h 294:19@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ Heif_error_code
         ) => BG.CompatHasField.HasField "heif_error_code" Heif_error ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_error { heif_error_code = y1
                     , heif_error_subcode = BG.getField @"heif_error_subcode" x0
                     , heif_error_message = BG.getField @"heif_error_message" x0
                     }
      , BG.getField @"heif_error_code" x0
      )

instance ( ty ~ Heif_error_code
         ) => BG.HasField "heif_error_code" (BG.Ptr Heif_error) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_error_code")

instance HasCField.HasCField Heif_error "heif_error_code" where

  type CFieldType Heif_error "heif_error_code" =
    Heif_error_code

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @subcode@

    __defined at:__ @libheif\/heif_error.h 297:22@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ Heif_suberror_code
         ) => BG.CompatHasField.HasField "heif_error_subcode" Heif_error ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_error { heif_error_subcode = y1
                     , heif_error_code = BG.getField @"heif_error_code" x0
                     , heif_error_message = BG.getField @"heif_error_message" x0
                     }
      , BG.getField @"heif_error_subcode" x0
      )

instance ( ty ~ Heif_suberror_code
         ) => BG.HasField "heif_error_subcode" (BG.Ptr Heif_error) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_error_subcode")

instance HasCField.HasCField Heif_error "heif_error_subcode" where

  type CFieldType Heif_error "heif_error_subcode" =
    Heif_suberror_code

  offset# = \_ -> \_ -> 4

{-| __C declaration:__ @message@

    __defined at:__ @libheif\/heif_error.h 300:15@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ PtrConst.PtrConst BG.CChar
         ) => BG.CompatHasField.HasField "heif_error_message" Heif_error ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_error { heif_error_message = y1
                     , heif_error_code = BG.getField @"heif_error_code" x0
                     , heif_error_subcode = BG.getField @"heif_error_subcode" x0
                     }
      , BG.getField @"heif_error_message" x0
      )

instance ( ty ~ PtrConst.PtrConst BG.CChar
         ) => BG.HasField "heif_error_message" (BG.Ptr Heif_error) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_error_message")

instance HasCField.HasCField Heif_error "heif_error_message" where

  type CFieldType Heif_error "heif_error_message" =
    PtrConst.PtrConst BG.CChar

  offset# = \_ -> \_ -> 8

{-| __C declaration:__ @macro LIBHEIF_MAKE_VERSION@

    __defined at:__ @libheif\/heif_library.h 86:9@

    __exported by:__ @libheif\/heif.h@
-}
lIBHEIF_MAKE_VERSION :: forall a0 b1 c2. C.Expr.HostPlatform.Bitwise (C.Expr.HostPlatform.ShiftRes a0) (C.Expr.HostPlatform.ShiftRes b1) => C.Expr.HostPlatform.Bitwise (C.Expr.HostPlatform.BitsRes (C.Expr.HostPlatform.ShiftRes a0) (C.Expr.HostPlatform.ShiftRes b1)) (C.Expr.HostPlatform.ShiftRes c2) => C.Expr.HostPlatform.Shift c2 BG.CInt => C.Expr.HostPlatform.Shift b1 BG.CInt => C.Expr.HostPlatform.Shift a0 BG.CInt => a0 -> b1 -> c2 -> C.Expr.HostPlatform.BitsRes (C.Expr.HostPlatform.BitsRes (C.Expr.HostPlatform.ShiftRes a0) (C.Expr.HostPlatform.ShiftRes b1)) (C.Expr.HostPlatform.ShiftRes c2)
lIBHEIF_MAKE_VERSION =
  \h0 ->
    \m1 ->
      \l2 ->
        (C.Expr.HostPlatform..|.) ((C.Expr.HostPlatform..|.) ((C.Expr.HostPlatform.<<) h0 (24 :: BG.CInt)) ((C.Expr.HostPlatform.<<) m1 (16 :: BG.CInt))) ((C.Expr.HostPlatform.<<) l2 (8 :: BG.CInt))

{-| __C declaration:__ @macro LIBHEIF_HAVE_VERSION@

    __defined at:__ @libheif\/heif_library.h 87:9@

    __exported by:__ @libheif\/heif.h@
-}
lIBHEIF_HAVE_VERSION :: forall a0 b1 c2. C.Expr.HostPlatform.RelOrd BG.CInt (C.Expr.HostPlatform.BitsRes (C.Expr.HostPlatform.BitsRes (C.Expr.HostPlatform.ShiftRes a0) (C.Expr.HostPlatform.ShiftRes b1)) (C.Expr.HostPlatform.ShiftRes c2)) => C.Expr.HostPlatform.Bitwise (C.Expr.HostPlatform.BitsRes (C.Expr.HostPlatform.ShiftRes a0) (C.Expr.HostPlatform.ShiftRes b1)) (C.Expr.HostPlatform.ShiftRes c2) => C.Expr.HostPlatform.Bitwise (C.Expr.HostPlatform.ShiftRes a0) (C.Expr.HostPlatform.ShiftRes b1) => C.Expr.HostPlatform.Shift a0 BG.CInt => C.Expr.HostPlatform.Shift b1 BG.CInt => C.Expr.HostPlatform.Shift c2 BG.CInt => a0 -> b1 -> c2 -> BG.CInt
lIBHEIF_HAVE_VERSION =
  \h0 ->
    \m1 ->
      \l2 ->
        (C.Expr.HostPlatform.>=) lIBHEIF_NUMERIC_VERSION (lIBHEIF_MAKE_VERSION h0 m1 l2)

{-| __C declaration:__ @struct heif_context@

    __defined at:__ @libheif\/heif_library.h 89:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_context

{-| __C declaration:__ @struct heif_image_handle@

    __defined at:__ @libheif\/heif_library.h 90:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_image_handle

{-| __C declaration:__ @heif_item_id@

    __defined at:__ @libheif\/heif_library.h 92:18@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_item_id = Heif_item_id
  { unwrapHeif_item_id :: HsBindgen.Runtime.LibC.Word32
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "unwrapHeif_item_id" Heif_item_id ty where

  hasField =
    \x0 ->
      ( \y1 -> Heif_item_id {unwrapHeif_item_id = y1}
      , BG.getField @"unwrapHeif_item_id" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "unwrapHeif_item_id" (BG.Ptr Heif_item_id) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_item_id")

instance HasCField.HasCField Heif_item_id "unwrapHeif_item_id" where

  type CFieldType Heif_item_id "unwrapHeif_item_id" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_property_id@

    __defined at:__ @libheif\/heif_library.h 93:18@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_property_id = Heif_property_id
  { unwrapHeif_property_id :: HsBindgen.Runtime.LibC.Word32
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "unwrapHeif_property_id" Heif_property_id ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_property_id {unwrapHeif_property_id = y1}
      , BG.getField @"unwrapHeif_property_id" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "unwrapHeif_property_id" (BG.Ptr Heif_property_id) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_property_id")

instance HasCField.HasCField Heif_property_id "unwrapHeif_property_id" where

  type CFieldType Heif_property_id "unwrapHeif_property_id" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @struct heif_init_params@

    __defined at:__ @libheif\/heif_library.h 105:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_init_params = Heif_init_params
  { heif_init_params_version :: BG.CInt
    {- ^ __C declaration:__ @version@

         __defined at:__ @libheif\/heif_library.h 107:7@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_init_params where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_init_params where

  readRaw =
    \ptr0 ->
          pure Heif_init_params
      <*> HasCField.readRaw (BG.Proxy @"heif_init_params_version") ptr0

instance Marshal.WriteRaw Heif_init_params where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_init_params heif_init_params_version2 ->
            HasCField.writeRaw (BG.Proxy @"heif_init_params_version") ptr0 heif_init_params_version2

deriving via Marshal.EquivStorable Heif_init_params instance BG.Storable Heif_init_params

deriving via Struct.IsStructViaReadRaw Heif_init_params instance Struct.IsStruct Heif_init_params

{-| __C declaration:__ @version@

    __defined at:__ @libheif\/heif_library.h 107:7@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CInt
         ) => BG.CompatHasField.HasField "heif_init_params_version" Heif_init_params ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_init_params {heif_init_params_version = y1}
      , BG.getField @"heif_init_params_version" x0
      )

instance ( ty ~ BG.CInt
         ) => BG.HasField "heif_init_params_version" (BG.Ptr Heif_init_params) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_init_params_version")

instance HasCField.HasCField Heif_init_params "heif_init_params_version" where

  type CFieldType Heif_init_params "heif_init_params_version" =
    BG.CInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @enum heif_plugin_type@

    __defined at:__ @libheif\/heif_library.h 155:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_plugin_type = Heif_plugin_type
  { unwrapHeif_plugin_type :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_plugin_type where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_plugin_type where

  readRaw =
    \ptr0 ->
          pure Heif_plugin_type
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_plugin_type where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_plugin_type unwrapHeif_plugin_type2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_plugin_type2

deriving via Marshal.EquivStorable Heif_plugin_type instance BG.Storable Heif_plugin_type

deriving via BG.CUInt instance BG.Prim Heif_plugin_type

instance CEnum.CEnum Heif_plugin_type where

  type CEnumZ Heif_plugin_type = BG.CUInt

  toCEnum = Heif_plugin_type

  fromCEnum = BG.getField @"unwrapHeif_plugin_type"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_plugin_type_encoder")
                                   , (1, BG.singleton "Heif_plugin_type_decoder")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_plugin_type"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_plugin_type"

  isDeclared = CEnum.seqIsDeclared

  mkDeclared = CEnum.seqMkDeclared

instance CEnum.SequentialCEnum Heif_plugin_type where

  minDeclaredValue = Heif_plugin_type_encoder

  maxDeclaredValue = Heif_plugin_type_decoder

instance Show Heif_plugin_type where

  showsPrec = CEnum.shows

instance Read Heif_plugin_type where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_plugin_type" Heif_plugin_type ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_plugin_type {unwrapHeif_plugin_type = y1}
      , BG.getField @"unwrapHeif_plugin_type" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_plugin_type" (BG.Ptr Heif_plugin_type) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_plugin_type")

instance HasCField.HasCField Heif_plugin_type "unwrapHeif_plugin_type" where

  type CFieldType Heif_plugin_type "unwrapHeif_plugin_type" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_plugin_type_encoder@

    __defined at:__ @libheif\/heif_library.h 157:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_plugin_type_encoder :: Heif_plugin_type
pattern Heif_plugin_type_encoder = Heif_plugin_type 0

{-| __C declaration:__ @heif_plugin_type_decoder@

    __defined at:__ @libheif\/heif_library.h 158:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_plugin_type_decoder :: Heif_plugin_type
pattern Heif_plugin_type_decoder = Heif_plugin_type 1

{-| __C declaration:__ @struct heif_plugin_info@

    __defined at:__ @libheif\/heif_library.h 161:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_plugin_info = Heif_plugin_info
  { heif_plugin_info_version :: BG.CInt
    {- ^ __C declaration:__ @version@

         __defined at:__ @libheif\/heif_library.h 163:7@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_plugin_info_type :: Heif_plugin_type
    {- ^ __C declaration:__ @type@

         __defined at:__ @libheif\/heif_library.h 164:20@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_plugin_info_plugin :: PtrConst.PtrConst BG.Void
    {- ^ __C declaration:__ @plugin@

         __defined at:__ @libheif\/heif_library.h 165:15@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_plugin_info_internal_handle :: BG.Ptr BG.Void
    {- ^ __C declaration:__ @internal_handle@

         __defined at:__ @libheif\/heif_library.h 166:9@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_plugin_info where

  staticSizeOf = \_ -> (24 :: Int)

  staticAlignment = \_ -> (8 :: Int)

instance Marshal.ReadRaw Heif_plugin_info where

  readRaw =
    \ptr0 ->
          pure Heif_plugin_info
      <*> HasCField.readRaw (BG.Proxy @"heif_plugin_info_version") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_plugin_info_type") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_plugin_info_plugin") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_plugin_info_internal_handle") ptr0

instance Marshal.WriteRaw Heif_plugin_info where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_plugin_info
            heif_plugin_info_version2
            heif_plugin_info_type3
            heif_plugin_info_plugin4
            heif_plugin_info_internal_handle5 ->
                 HasCField.writeRaw (BG.Proxy @"heif_plugin_info_version") ptr0 heif_plugin_info_version2
              >> HasCField.writeRaw (BG.Proxy @"heif_plugin_info_type") ptr0 heif_plugin_info_type3
              >> HasCField.writeRaw (BG.Proxy @"heif_plugin_info_plugin") ptr0 heif_plugin_info_plugin4
              >> HasCField.writeRaw (BG.Proxy @"heif_plugin_info_internal_handle") ptr0 heif_plugin_info_internal_handle5

deriving via Marshal.EquivStorable Heif_plugin_info instance BG.Storable Heif_plugin_info

deriving via Struct.IsStructViaReadRaw Heif_plugin_info instance Struct.IsStruct Heif_plugin_info

{-| __C declaration:__ @version@

    __defined at:__ @libheif\/heif_library.h 163:7@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CInt
         ) => BG.CompatHasField.HasField "heif_plugin_info_version" Heif_plugin_info ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_plugin_info { heif_plugin_info_version = y1
                           , heif_plugin_info_type = BG.getField @"heif_plugin_info_type" x0
                           , heif_plugin_info_plugin = BG.getField @"heif_plugin_info_plugin" x0
                           , heif_plugin_info_internal_handle = BG.getField @"heif_plugin_info_internal_handle" x0
                           }
      , BG.getField @"heif_plugin_info_version" x0
      )

instance ( ty ~ BG.CInt
         ) => BG.HasField "heif_plugin_info_version" (BG.Ptr Heif_plugin_info) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_plugin_info_version")

instance HasCField.HasCField Heif_plugin_info "heif_plugin_info_version" where

  type CFieldType Heif_plugin_info "heif_plugin_info_version" =
    BG.CInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @type@

    __defined at:__ @libheif\/heif_library.h 164:20@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ Heif_plugin_type
         ) => BG.CompatHasField.HasField "heif_plugin_info_type" Heif_plugin_info ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_plugin_info { heif_plugin_info_type = y1
                           , heif_plugin_info_version = BG.getField @"heif_plugin_info_version" x0
                           , heif_plugin_info_plugin = BG.getField @"heif_plugin_info_plugin" x0
                           , heif_plugin_info_internal_handle = BG.getField @"heif_plugin_info_internal_handle" x0
                           }
      , BG.getField @"heif_plugin_info_type" x0
      )

instance ( ty ~ Heif_plugin_type
         ) => BG.HasField "heif_plugin_info_type" (BG.Ptr Heif_plugin_info) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_plugin_info_type")

instance HasCField.HasCField Heif_plugin_info "heif_plugin_info_type" where

  type CFieldType Heif_plugin_info "heif_plugin_info_type" =
    Heif_plugin_type

  offset# = \_ -> \_ -> 4

{-| __C declaration:__ @plugin@

    __defined at:__ @libheif\/heif_library.h 165:15@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ PtrConst.PtrConst BG.Void
         ) => BG.CompatHasField.HasField "heif_plugin_info_plugin" Heif_plugin_info ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_plugin_info { heif_plugin_info_plugin = y1
                           , heif_plugin_info_version = BG.getField @"heif_plugin_info_version" x0
                           , heif_plugin_info_type = BG.getField @"heif_plugin_info_type" x0
                           , heif_plugin_info_internal_handle = BG.getField @"heif_plugin_info_internal_handle" x0
                           }
      , BG.getField @"heif_plugin_info_plugin" x0
      )

instance ( ty ~ PtrConst.PtrConst BG.Void
         ) => BG.HasField "heif_plugin_info_plugin" (BG.Ptr Heif_plugin_info) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_plugin_info_plugin")

instance HasCField.HasCField Heif_plugin_info "heif_plugin_info_plugin" where

  type CFieldType Heif_plugin_info "heif_plugin_info_plugin" =
    PtrConst.PtrConst BG.Void

  offset# = \_ -> \_ -> 8

{-| __C declaration:__ @internal_handle@

    __defined at:__ @libheif\/heif_library.h 166:9@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.Ptr BG.Void
         ) => BG.CompatHasField.HasField "heif_plugin_info_internal_handle" Heif_plugin_info ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_plugin_info { heif_plugin_info_internal_handle = y1
                           , heif_plugin_info_version = BG.getField @"heif_plugin_info_version" x0
                           , heif_plugin_info_type = BG.getField @"heif_plugin_info_type" x0
                           , heif_plugin_info_plugin = BG.getField @"heif_plugin_info_plugin" x0
                           }
      , BG.getField @"heif_plugin_info_internal_handle" x0
      )

instance ( ty ~ BG.Ptr BG.Void
         ) => BG.HasField "heif_plugin_info_internal_handle" (BG.Ptr Heif_plugin_info) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_plugin_info_internal_handle")

instance HasCField.HasCField Heif_plugin_info "heif_plugin_info_internal_handle" where

  type CFieldType Heif_plugin_info "heif_plugin_info_internal_handle" =
    BG.Ptr BG.Void

  offset# = \_ -> \_ -> 16

{-| __C declaration:__ @struct heif_decoder_plugin@

    __defined at:__ @libheif\/heif_library.h 193:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_decoder_plugin

{-| __C declaration:__ @struct heif_encoder_plugin@

    __defined at:__ @libheif\/heif_library.h 194:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_encoder_plugin

{-| __C declaration:__ @enum heif_chroma@

    __defined at:__ @libheif\/heif_image.h 53:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_chroma = Heif_chroma
  { unwrapHeif_chroma :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_chroma where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_chroma where

  readRaw =
    \ptr0 ->
          pure Heif_chroma
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_chroma where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_chroma unwrapHeif_chroma2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_chroma2

deriving via Marshal.EquivStorable Heif_chroma instance BG.Storable Heif_chroma

deriving via BG.CUInt instance BG.Prim Heif_chroma

instance CEnum.CEnum Heif_chroma where

  type CEnumZ Heif_chroma = BG.CUInt

  toCEnum = Heif_chroma

  fromCEnum = BG.getField @"unwrapHeif_chroma"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_chroma_planar")
                                   , (1, BG.singleton "Heif_chroma_420")
                                   , (2, BG.singleton "Heif_chroma_422")
                                   , (3, BG.singleton "Heif_chroma_444")
                                   , (10, BG.singleton "Heif_chroma_interleaved_RGB")
                                   , (11, BG.singleton "Heif_chroma_interleaved_RGBA")
                                   , (12, BG.singleton "Heif_chroma_interleaved_RRGGBB_BE")
                                   , (13, BG.singleton "Heif_chroma_interleaved_RRGGBBAA_BE")
                                   , (14, BG.singleton "Heif_chroma_interleaved_RRGGBB_LE")
                                   , (15, BG.singleton "Heif_chroma_interleaved_RRGGBBAA_LE")
                                   , (99, BG.singleton "Heif_chroma_undefined")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_chroma"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_chroma"

instance Show Heif_chroma where

  showsPrec = CEnum.shows

instance Read Heif_chroma where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_chroma" Heif_chroma ty where

  hasField =
    \x0 ->
      ( \y1 -> Heif_chroma {unwrapHeif_chroma = y1}
      , BG.getField @"unwrapHeif_chroma" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_chroma" (BG.Ptr Heif_chroma) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_chroma")

instance HasCField.HasCField Heif_chroma "unwrapHeif_chroma" where

  type CFieldType Heif_chroma "unwrapHeif_chroma" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_chroma_undefined@

    __defined at:__ @libheif\/heif_image.h 55:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_chroma_undefined :: Heif_chroma
pattern Heif_chroma_undefined = Heif_chroma 99

{-| __C declaration:__ @heif_chroma_planar@

    __defined at:__ @libheif\/heif_image.h 56:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_chroma_planar :: Heif_chroma
pattern Heif_chroma_planar = Heif_chroma 0

{-| __C declaration:__ @heif_chroma_420@

    __defined at:__ @libheif\/heif_image.h 57:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_chroma_420 :: Heif_chroma
pattern Heif_chroma_420 = Heif_chroma 1

{-| __C declaration:__ @heif_chroma_422@

    __defined at:__ @libheif\/heif_image.h 58:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_chroma_422 :: Heif_chroma
pattern Heif_chroma_422 = Heif_chroma 2

{-| __C declaration:__ @heif_chroma_444@

    __defined at:__ @libheif\/heif_image.h 59:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_chroma_444 :: Heif_chroma
pattern Heif_chroma_444 = Heif_chroma 3

{-| __C declaration:__ @heif_chroma_interleaved_RGB@

    __defined at:__ @libheif\/heif_image.h 60:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_chroma_interleaved_RGB :: Heif_chroma
pattern Heif_chroma_interleaved_RGB = Heif_chroma 10

{-| __C declaration:__ @heif_chroma_interleaved_RGBA@

    __defined at:__ @libheif\/heif_image.h 61:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_chroma_interleaved_RGBA :: Heif_chroma
pattern Heif_chroma_interleaved_RGBA = Heif_chroma 11

{-| __C declaration:__ @heif_chroma_interleaved_RRGGBB_BE@

    __defined at:__ @libheif\/heif_image.h 62:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_chroma_interleaved_RRGGBB_BE :: Heif_chroma
pattern Heif_chroma_interleaved_RRGGBB_BE = Heif_chroma 12

{-| __C declaration:__ @heif_chroma_interleaved_RRGGBBAA_BE@

    __defined at:__ @libheif\/heif_image.h 63:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_chroma_interleaved_RRGGBBAA_BE :: Heif_chroma
pattern Heif_chroma_interleaved_RRGGBBAA_BE = Heif_chroma 13

{-| __C declaration:__ @heif_chroma_interleaved_RRGGBB_LE@

    __defined at:__ @libheif\/heif_image.h 64:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_chroma_interleaved_RRGGBB_LE :: Heif_chroma
pattern Heif_chroma_interleaved_RRGGBB_LE = Heif_chroma 14

{-| __C declaration:__ @heif_chroma_interleaved_RRGGBBAA_LE@

    __defined at:__ @libheif\/heif_image.h 65:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_chroma_interleaved_RRGGBBAA_LE :: Heif_chroma
pattern Heif_chroma_interleaved_RRGGBBAA_LE = Heif_chroma 15

{-| __C declaration:__ @enum heif_colorspace@

    __defined at:__ @libheif\/heif_image.h 78:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_colorspace = Heif_colorspace
  { unwrapHeif_colorspace :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_colorspace where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_colorspace where

  readRaw =
    \ptr0 ->
          pure Heif_colorspace
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_colorspace where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_colorspace unwrapHeif_colorspace2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_colorspace2

deriving via Marshal.EquivStorable Heif_colorspace instance BG.Storable Heif_colorspace

deriving via BG.CUInt instance BG.Prim Heif_colorspace

instance CEnum.CEnum Heif_colorspace where

  type CEnumZ Heif_colorspace = BG.CUInt

  toCEnum = Heif_colorspace

  fromCEnum = BG.getField @"unwrapHeif_colorspace"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_colorspace_YCbCr")
                                   , (1, BG.singleton "Heif_colorspace_RGB")
                                   , (2, BG.singleton "Heif_colorspace_monochrome")
                                   , (3, BG.singleton "Heif_colorspace_custom")
                                   , (4, BG.singleton "Heif_colorspace_filter_array")
                                   , (99, BG.singleton "Heif_colorspace_undefined")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_colorspace"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_colorspace"

instance Show Heif_colorspace where

  showsPrec = CEnum.shows

instance Read Heif_colorspace where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_colorspace" Heif_colorspace ty where

  hasField =
    \x0 ->
      ( \y1 -> Heif_colorspace {unwrapHeif_colorspace = y1}
      , BG.getField @"unwrapHeif_colorspace" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_colorspace" (BG.Ptr Heif_colorspace) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_colorspace")

instance HasCField.HasCField Heif_colorspace "unwrapHeif_colorspace" where

  type CFieldType Heif_colorspace "unwrapHeif_colorspace" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_colorspace_undefined@

    __defined at:__ @libheif\/heif_image.h 80:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_colorspace_undefined :: Heif_colorspace
pattern Heif_colorspace_undefined = Heif_colorspace 99

{-| __C declaration:__ @heif_colorspace_YCbCr@

    __defined at:__ @libheif\/heif_image.h 86:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_colorspace_YCbCr :: Heif_colorspace
pattern Heif_colorspace_YCbCr = Heif_colorspace 0

{-| __C declaration:__ @heif_colorspace_RGB@

    __defined at:__ @libheif\/heif_image.h 98:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_colorspace_RGB :: Heif_colorspace
pattern Heif_colorspace_RGB = Heif_colorspace 1

{-| __C declaration:__ @heif_colorspace_monochrome@

    __defined at:__ @libheif\/heif_image.h 101:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_colorspace_monochrome :: Heif_colorspace
pattern Heif_colorspace_monochrome = Heif_colorspace 2

{-| __C declaration:__ @heif_colorspace_custom@

    __defined at:__ @libheif\/heif_image.h 106:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_colorspace_custom :: Heif_colorspace
pattern Heif_colorspace_custom = Heif_colorspace 3

{-| __C declaration:__ @heif_colorspace_filter_array@

    __defined at:__ @libheif\/heif_image.h 110:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_colorspace_filter_array :: Heif_colorspace
pattern Heif_colorspace_filter_array = Heif_colorspace 4

{-| __C declaration:__ @enum heif_channel@

    __defined at:__ @libheif\/heif_image.h 115:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_channel = Heif_channel
  { unwrapHeif_channel :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_channel where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_channel where

  readRaw =
    \ptr0 ->
          pure Heif_channel
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_channel where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_channel unwrapHeif_channel2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_channel2

deriving via Marshal.EquivStorable Heif_channel instance BG.Storable Heif_channel

deriving via BG.CUInt instance BG.Prim Heif_channel

instance CEnum.CEnum Heif_channel where

  type CEnumZ Heif_channel = BG.CUInt

  toCEnum = Heif_channel

  fromCEnum = BG.getField @"unwrapHeif_channel"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_channel_Y")
                                   , (1, BG.singleton "Heif_channel_Cb")
                                   , (2, BG.singleton "Heif_channel_Cr")
                                   , (3, BG.singleton "Heif_channel_R")
                                   , (4, BG.singleton "Heif_channel_G")
                                   , (5, BG.singleton "Heif_channel_B")
                                   , (6, BG.singleton "Heif_channel_Alpha")
                                   , (10, BG.singleton "Heif_channel_interleaved")
                                   , (11, BG.singleton "Heif_channel_filter_array")
                                   , (12, BG.singleton "Heif_channel_depth")
                                   , (13, BG.singleton "Heif_channel_disparity")
                                   , (65535, BG.singleton "Heif_channel_unknown")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_channel"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_channel"

instance Show Heif_channel where

  showsPrec = CEnum.shows

instance Read Heif_channel where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_channel" Heif_channel ty where

  hasField =
    \x0 ->
      ( \y1 -> Heif_channel {unwrapHeif_channel = y1}
      , BG.getField @"unwrapHeif_channel" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_channel" (BG.Ptr Heif_channel) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_channel")

instance HasCField.HasCField Heif_channel "unwrapHeif_channel" where

  type CFieldType Heif_channel "unwrapHeif_channel" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_channel_Y@

    __defined at:__ @libheif\/heif_image.h 117:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_channel_Y :: Heif_channel
pattern Heif_channel_Y = Heif_channel 0

{-| __C declaration:__ @heif_channel_Cb@

    __defined at:__ @libheif\/heif_image.h 118:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_channel_Cb :: Heif_channel
pattern Heif_channel_Cb = Heif_channel 1

{-| __C declaration:__ @heif_channel_Cr@

    __defined at:__ @libheif\/heif_image.h 119:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_channel_Cr :: Heif_channel
pattern Heif_channel_Cr = Heif_channel 2

{-| __C declaration:__ @heif_channel_R@

    __defined at:__ @libheif\/heif_image.h 120:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_channel_R :: Heif_channel
pattern Heif_channel_R = Heif_channel 3

{-| __C declaration:__ @heif_channel_G@

    __defined at:__ @libheif\/heif_image.h 121:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_channel_G :: Heif_channel
pattern Heif_channel_G = Heif_channel 4

{-| __C declaration:__ @heif_channel_B@

    __defined at:__ @libheif\/heif_image.h 122:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_channel_B :: Heif_channel
pattern Heif_channel_B = Heif_channel 5

{-| __C declaration:__ @heif_channel_Alpha@

    __defined at:__ @libheif\/heif_image.h 123:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_channel_Alpha :: Heif_channel
pattern Heif_channel_Alpha = Heif_channel 6

{-| __C declaration:__ @heif_channel_interleaved@

    __defined at:__ @libheif\/heif_image.h 124:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_channel_interleaved :: Heif_channel
pattern Heif_channel_interleaved = Heif_channel 10

{-| __C declaration:__ @heif_channel_filter_array@

    __defined at:__ @libheif\/heif_image.h 125:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_channel_filter_array :: Heif_channel
pattern Heif_channel_filter_array = Heif_channel 11

{-| __C declaration:__ @heif_channel_depth@

    __defined at:__ @libheif\/heif_image.h 126:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_channel_depth :: Heif_channel
pattern Heif_channel_depth = Heif_channel 12

{-| __C declaration:__ @heif_channel_disparity@

    __defined at:__ @libheif\/heif_image.h 127:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_channel_disparity :: Heif_channel
pattern Heif_channel_disparity = Heif_channel 13

{-| __C declaration:__ @heif_channel_unknown@

    __defined at:__ @libheif\/heif_image.h 128:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_channel_unknown :: Heif_channel
pattern Heif_channel_unknown = Heif_channel 65535

{-| __C declaration:__ @struct heif_image@

    __defined at:__ @libheif\/heif_image.h 143:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_image

{-| __C declaration:__ @struct heif_scaling_options@

    __defined at:__ @libheif\/heif_image.h 283:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_scaling_options

{-| __C declaration:__ @enum heif_chroma_downsampling_algorithm@

    __defined at:__ @libheif\/heif_color.h 34:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_chroma_downsampling_algorithm = Heif_chroma_downsampling_algorithm
  { unwrapHeif_chroma_downsampling_algorithm :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_chroma_downsampling_algorithm where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_chroma_downsampling_algorithm where

  readRaw =
    \ptr0 ->
          pure Heif_chroma_downsampling_algorithm
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_chroma_downsampling_algorithm where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_chroma_downsampling_algorithm unwrapHeif_chroma_downsampling_algorithm2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_chroma_downsampling_algorithm2

deriving via Marshal.EquivStorable Heif_chroma_downsampling_algorithm instance BG.Storable Heif_chroma_downsampling_algorithm

deriving via BG.CUInt instance BG.Prim Heif_chroma_downsampling_algorithm

instance CEnum.CEnum Heif_chroma_downsampling_algorithm where

  type CEnumZ Heif_chroma_downsampling_algorithm =
    BG.CUInt

  toCEnum = Heif_chroma_downsampling_algorithm

  fromCEnum =
    BG.getField @"unwrapHeif_chroma_downsampling_algorithm"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (1, BG.singleton "Heif_chroma_downsampling_nearest_neighbor")
                                   , (2, BG.singleton "Heif_chroma_downsampling_average")
                                   , (3, BG.singleton "Heif_chroma_downsampling_sharp_yuv")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_chroma_downsampling_algorithm"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_chroma_downsampling_algorithm"

  isDeclared = CEnum.seqIsDeclared

  mkDeclared = CEnum.seqMkDeclared

instance CEnum.SequentialCEnum Heif_chroma_downsampling_algorithm where

  minDeclaredValue =
    Heif_chroma_downsampling_nearest_neighbor

  maxDeclaredValue = Heif_chroma_downsampling_sharp_yuv

instance Show Heif_chroma_downsampling_algorithm where

  showsPrec = CEnum.shows

instance Read Heif_chroma_downsampling_algorithm where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_chroma_downsampling_algorithm" Heif_chroma_downsampling_algorithm ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_chroma_downsampling_algorithm {unwrapHeif_chroma_downsampling_algorithm = y1}
      , BG.getField @"unwrapHeif_chroma_downsampling_algorithm" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_chroma_downsampling_algorithm" (BG.Ptr Heif_chroma_downsampling_algorithm) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_chroma_downsampling_algorithm")

instance HasCField.HasCField Heif_chroma_downsampling_algorithm "unwrapHeif_chroma_downsampling_algorithm" where

  type CFieldType Heif_chroma_downsampling_algorithm "unwrapHeif_chroma_downsampling_algorithm" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_chroma_downsampling_nearest_neighbor@

    __defined at:__ @libheif\/heif_color.h 36:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_chroma_downsampling_nearest_neighbor :: Heif_chroma_downsampling_algorithm
pattern Heif_chroma_downsampling_nearest_neighbor = Heif_chroma_downsampling_algorithm 1

{-| __C declaration:__ @heif_chroma_downsampling_average@

    __defined at:__ @libheif\/heif_color.h 37:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_chroma_downsampling_average :: Heif_chroma_downsampling_algorithm
pattern Heif_chroma_downsampling_average = Heif_chroma_downsampling_algorithm 2

{-| __C declaration:__ @heif_chroma_downsampling_sharp_yuv@

    __defined at:__ @libheif\/heif_color.h 41:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_chroma_downsampling_sharp_yuv :: Heif_chroma_downsampling_algorithm
pattern Heif_chroma_downsampling_sharp_yuv = Heif_chroma_downsampling_algorithm 3

{-| __C declaration:__ @enum heif_chroma_upsampling_algorithm@

    __defined at:__ @libheif\/heif_color.h 44:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_chroma_upsampling_algorithm = Heif_chroma_upsampling_algorithm
  { unwrapHeif_chroma_upsampling_algorithm :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_chroma_upsampling_algorithm where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_chroma_upsampling_algorithm where

  readRaw =
    \ptr0 ->
          pure Heif_chroma_upsampling_algorithm
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_chroma_upsampling_algorithm where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_chroma_upsampling_algorithm unwrapHeif_chroma_upsampling_algorithm2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_chroma_upsampling_algorithm2

deriving via Marshal.EquivStorable Heif_chroma_upsampling_algorithm instance BG.Storable Heif_chroma_upsampling_algorithm

deriving via BG.CUInt instance BG.Prim Heif_chroma_upsampling_algorithm

instance CEnum.CEnum Heif_chroma_upsampling_algorithm where

  type CEnumZ Heif_chroma_upsampling_algorithm =
    BG.CUInt

  toCEnum = Heif_chroma_upsampling_algorithm

  fromCEnum =
    BG.getField @"unwrapHeif_chroma_upsampling_algorithm"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (1, BG.singleton "Heif_chroma_upsampling_nearest_neighbor")
                                   , (2, BG.singleton "Heif_chroma_upsampling_bilinear")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_chroma_upsampling_algorithm"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_chroma_upsampling_algorithm"

  isDeclared = CEnum.seqIsDeclared

  mkDeclared = CEnum.seqMkDeclared

instance CEnum.SequentialCEnum Heif_chroma_upsampling_algorithm where

  minDeclaredValue =
    Heif_chroma_upsampling_nearest_neighbor

  maxDeclaredValue = Heif_chroma_upsampling_bilinear

instance Show Heif_chroma_upsampling_algorithm where

  showsPrec = CEnum.shows

instance Read Heif_chroma_upsampling_algorithm where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_chroma_upsampling_algorithm" Heif_chroma_upsampling_algorithm ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_chroma_upsampling_algorithm {unwrapHeif_chroma_upsampling_algorithm = y1}
      , BG.getField @"unwrapHeif_chroma_upsampling_algorithm" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_chroma_upsampling_algorithm" (BG.Ptr Heif_chroma_upsampling_algorithm) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_chroma_upsampling_algorithm")

instance HasCField.HasCField Heif_chroma_upsampling_algorithm "unwrapHeif_chroma_upsampling_algorithm" where

  type CFieldType Heif_chroma_upsampling_algorithm "unwrapHeif_chroma_upsampling_algorithm" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_chroma_upsampling_nearest_neighbor@

    __defined at:__ @libheif\/heif_color.h 46:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_chroma_upsampling_nearest_neighbor :: Heif_chroma_upsampling_algorithm
pattern Heif_chroma_upsampling_nearest_neighbor = Heif_chroma_upsampling_algorithm 1

{-| __C declaration:__ @heif_chroma_upsampling_bilinear@

    __defined at:__ @libheif\/heif_color.h 47:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_chroma_upsampling_bilinear :: Heif_chroma_upsampling_algorithm
pattern Heif_chroma_upsampling_bilinear = Heif_chroma_upsampling_algorithm 2

{-| __C declaration:__ @struct heif_color_conversion_options@

    __defined at:__ @libheif\/heif_color.h 51:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_color_conversion_options = Heif_color_conversion_options
  { heif_color_conversion_options_version :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @version@

         __defined at:__ @libheif\/heif_color.h 54:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_conversion_options_preferred_chroma_downsampling_algorithm :: Heif_chroma_downsampling_algorithm
    {- ^ __C declaration:__ @preferred_chroma_downsampling_algorithm@

         __defined at:__ @libheif\/heif_color.h 58:38@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_conversion_options_preferred_chroma_upsampling_algorithm :: Heif_chroma_upsampling_algorithm
    {- ^ __C declaration:__ @preferred_chroma_upsampling_algorithm@

         __defined at:__ @libheif\/heif_color.h 59:36@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_conversion_options_only_use_preferred_chroma_algorithm :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @only_use_preferred_chroma_algorithm@

         __defined at:__ @libheif\/heif_color.h 67:11@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_color_conversion_options where

  staticSizeOf = \_ -> (16 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_color_conversion_options where

  readRaw =
    \ptr0 ->
          pure Heif_color_conversion_options
      <*> HasCField.readRaw (BG.Proxy @"heif_color_conversion_options_version") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_conversion_options_preferred_chroma_downsampling_algorithm") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_conversion_options_preferred_chroma_upsampling_algorithm") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_conversion_options_only_use_preferred_chroma_algorithm") ptr0

instance Marshal.WriteRaw Heif_color_conversion_options where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_color_conversion_options
            heif_color_conversion_options_version2
            heif_color_conversion_options_preferred_chroma_downsampling_algorithm3
            heif_color_conversion_options_preferred_chroma_upsampling_algorithm4
            heif_color_conversion_options_only_use_preferred_chroma_algorithm5 ->
                 HasCField.writeRaw (BG.Proxy @"heif_color_conversion_options_version") ptr0 heif_color_conversion_options_version2
              >> HasCField.writeRaw (BG.Proxy @"heif_color_conversion_options_preferred_chroma_downsampling_algorithm") ptr0 heif_color_conversion_options_preferred_chroma_downsampling_algorithm3
              >> HasCField.writeRaw (BG.Proxy @"heif_color_conversion_options_preferred_chroma_upsampling_algorithm") ptr0 heif_color_conversion_options_preferred_chroma_upsampling_algorithm4
              >> HasCField.writeRaw (BG.Proxy @"heif_color_conversion_options_only_use_preferred_chroma_algorithm") ptr0 heif_color_conversion_options_only_use_preferred_chroma_algorithm5

deriving via Marshal.EquivStorable Heif_color_conversion_options instance BG.Storable Heif_color_conversion_options

deriving via Struct.IsStructViaReadRaw Heif_color_conversion_options instance Struct.IsStruct Heif_color_conversion_options

{-| __C declaration:__ @version@

    __defined at:__ @libheif\/heif_color.h 54:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_color_conversion_options_version" Heif_color_conversion_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_conversion_options { heif_color_conversion_options_version = y1
                                        , heif_color_conversion_options_preferred_chroma_downsampling_algorithm = BG.getField @"heif_color_conversion_options_preferred_chroma_downsampling_algorithm" x0
                                        , heif_color_conversion_options_preferred_chroma_upsampling_algorithm = BG.getField @"heif_color_conversion_options_preferred_chroma_upsampling_algorithm" x0
                                        , heif_color_conversion_options_only_use_preferred_chroma_algorithm = BG.getField @"heif_color_conversion_options_only_use_preferred_chroma_algorithm" x0
                                        }
      , BG.getField @"heif_color_conversion_options_version" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_color_conversion_options_version" (BG.Ptr Heif_color_conversion_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_conversion_options_version")

instance HasCField.HasCField Heif_color_conversion_options "heif_color_conversion_options_version" where

  type CFieldType Heif_color_conversion_options "heif_color_conversion_options_version" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @preferred_chroma_downsampling_algorithm@

    __defined at:__ @libheif\/heif_color.h 58:38@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ Heif_chroma_downsampling_algorithm
         ) => BG.CompatHasField.HasField "heif_color_conversion_options_preferred_chroma_downsampling_algorithm" Heif_color_conversion_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_conversion_options { heif_color_conversion_options_preferred_chroma_downsampling_algorithm = y1
                                        , heif_color_conversion_options_version = BG.getField @"heif_color_conversion_options_version" x0
                                        , heif_color_conversion_options_preferred_chroma_upsampling_algorithm = BG.getField @"heif_color_conversion_options_preferred_chroma_upsampling_algorithm" x0
                                        , heif_color_conversion_options_only_use_preferred_chroma_algorithm = BG.getField @"heif_color_conversion_options_only_use_preferred_chroma_algorithm" x0
                                        }
      , BG.getField @"heif_color_conversion_options_preferred_chroma_downsampling_algorithm" x0
      )

instance ( ty ~ Heif_chroma_downsampling_algorithm
         ) => BG.HasField "heif_color_conversion_options_preferred_chroma_downsampling_algorithm" (BG.Ptr Heif_color_conversion_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_conversion_options_preferred_chroma_downsampling_algorithm")

instance HasCField.HasCField Heif_color_conversion_options "heif_color_conversion_options_preferred_chroma_downsampling_algorithm" where

  type CFieldType Heif_color_conversion_options "heif_color_conversion_options_preferred_chroma_downsampling_algorithm" =
    Heif_chroma_downsampling_algorithm

  offset# = \_ -> \_ -> 4

{-| __C declaration:__ @preferred_chroma_upsampling_algorithm@

    __defined at:__ @libheif\/heif_color.h 59:36@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ Heif_chroma_upsampling_algorithm
         ) => BG.CompatHasField.HasField "heif_color_conversion_options_preferred_chroma_upsampling_algorithm" Heif_color_conversion_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_conversion_options { heif_color_conversion_options_preferred_chroma_upsampling_algorithm = y1
                                        , heif_color_conversion_options_version = BG.getField @"heif_color_conversion_options_version" x0
                                        , heif_color_conversion_options_preferred_chroma_downsampling_algorithm = BG.getField @"heif_color_conversion_options_preferred_chroma_downsampling_algorithm" x0
                                        , heif_color_conversion_options_only_use_preferred_chroma_algorithm = BG.getField @"heif_color_conversion_options_only_use_preferred_chroma_algorithm" x0
                                        }
      , BG.getField @"heif_color_conversion_options_preferred_chroma_upsampling_algorithm" x0
      )

instance ( ty ~ Heif_chroma_upsampling_algorithm
         ) => BG.HasField "heif_color_conversion_options_preferred_chroma_upsampling_algorithm" (BG.Ptr Heif_color_conversion_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_conversion_options_preferred_chroma_upsampling_algorithm")

instance HasCField.HasCField Heif_color_conversion_options "heif_color_conversion_options_preferred_chroma_upsampling_algorithm" where

  type CFieldType Heif_color_conversion_options "heif_color_conversion_options_preferred_chroma_upsampling_algorithm" =
    Heif_chroma_upsampling_algorithm

  offset# = \_ -> \_ -> 8

{-| __C declaration:__ @only_use_preferred_chroma_algorithm@

    __defined at:__ @libheif\/heif_color.h 67:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_color_conversion_options_only_use_preferred_chroma_algorithm" Heif_color_conversion_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_conversion_options { heif_color_conversion_options_only_use_preferred_chroma_algorithm = y1
                                        , heif_color_conversion_options_version = BG.getField @"heif_color_conversion_options_version" x0
                                        , heif_color_conversion_options_preferred_chroma_downsampling_algorithm = BG.getField @"heif_color_conversion_options_preferred_chroma_downsampling_algorithm" x0
                                        , heif_color_conversion_options_preferred_chroma_upsampling_algorithm = BG.getField @"heif_color_conversion_options_preferred_chroma_upsampling_algorithm" x0
                                        }
      , BG.getField @"heif_color_conversion_options_only_use_preferred_chroma_algorithm" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_color_conversion_options_only_use_preferred_chroma_algorithm" (BG.Ptr Heif_color_conversion_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_conversion_options_only_use_preferred_chroma_algorithm")

instance HasCField.HasCField Heif_color_conversion_options "heif_color_conversion_options_only_use_preferred_chroma_algorithm" where

  type CFieldType Heif_color_conversion_options "heif_color_conversion_options_only_use_preferred_chroma_algorithm" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 12

{-| __C declaration:__ @enum heif_alpha_composition_mode@

    __defined at:__ @libheif\/heif_color.h 74:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_alpha_composition_mode = Heif_alpha_composition_mode
  { unwrapHeif_alpha_composition_mode :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_alpha_composition_mode where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_alpha_composition_mode where

  readRaw =
    \ptr0 ->
          pure Heif_alpha_composition_mode
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_alpha_composition_mode where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_alpha_composition_mode unwrapHeif_alpha_composition_mode2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_alpha_composition_mode2

deriving via Marshal.EquivStorable Heif_alpha_composition_mode instance BG.Storable Heif_alpha_composition_mode

deriving via BG.CUInt instance BG.Prim Heif_alpha_composition_mode

instance CEnum.CEnum Heif_alpha_composition_mode where

  type CEnumZ Heif_alpha_composition_mode = BG.CUInt

  toCEnum = Heif_alpha_composition_mode

  fromCEnum =
    BG.getField @"unwrapHeif_alpha_composition_mode"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_alpha_composition_mode_none")
                                   , (1, BG.singleton "Heif_alpha_composition_mode_solid_color")
                                   , (2, BG.singleton "Heif_alpha_composition_mode_checkerboard")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_alpha_composition_mode"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_alpha_composition_mode"

  isDeclared = CEnum.seqIsDeclared

  mkDeclared = CEnum.seqMkDeclared

instance CEnum.SequentialCEnum Heif_alpha_composition_mode where

  minDeclaredValue = Heif_alpha_composition_mode_none

  maxDeclaredValue =
    Heif_alpha_composition_mode_checkerboard

instance Show Heif_alpha_composition_mode where

  showsPrec = CEnum.shows

instance Read Heif_alpha_composition_mode where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_alpha_composition_mode" Heif_alpha_composition_mode ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_alpha_composition_mode {unwrapHeif_alpha_composition_mode = y1}
      , BG.getField @"unwrapHeif_alpha_composition_mode" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_alpha_composition_mode" (BG.Ptr Heif_alpha_composition_mode) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_alpha_composition_mode")

instance HasCField.HasCField Heif_alpha_composition_mode "unwrapHeif_alpha_composition_mode" where

  type CFieldType Heif_alpha_composition_mode "unwrapHeif_alpha_composition_mode" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_alpha_composition_mode_none@

    __defined at:__ @libheif\/heif_color.h 76:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_alpha_composition_mode_none :: Heif_alpha_composition_mode
pattern Heif_alpha_composition_mode_none = Heif_alpha_composition_mode 0

{-| __C declaration:__ @heif_alpha_composition_mode_solid_color@

    __defined at:__ @libheif\/heif_color.h 77:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_alpha_composition_mode_solid_color :: Heif_alpha_composition_mode
pattern Heif_alpha_composition_mode_solid_color = Heif_alpha_composition_mode 1

{-| __C declaration:__ @heif_alpha_composition_mode_checkerboard@

    __defined at:__ @libheif\/heif_color.h 78:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_alpha_composition_mode_checkerboard :: Heif_alpha_composition_mode
pattern Heif_alpha_composition_mode_checkerboard = Heif_alpha_composition_mode 2

{-| __C declaration:__ @struct heif_color_conversion_options_ext@

    __defined at:__ @libheif\/heif_color.h 82:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_color_conversion_options_ext = Heif_color_conversion_options_ext
  { heif_color_conversion_options_ext_version :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @version@

         __defined at:__ @libheif\/heif_color.h 84:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_conversion_options_ext_alpha_composition_mode :: Heif_alpha_composition_mode
    {- ^ __C declaration:__ @alpha_composition_mode@

         __defined at:__ @libheif\/heif_color.h 88:31@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_conversion_options_ext_background_red :: HsBindgen.Runtime.LibC.Word16
    {- ^ __C declaration:__ @background_red@

         __defined at:__ @libheif\/heif_color.h 91:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_conversion_options_ext_background_green :: HsBindgen.Runtime.LibC.Word16
    {- ^ __C declaration:__ @background_green@

         __defined at:__ @libheif\/heif_color.h 91:28@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_conversion_options_ext_background_blue :: HsBindgen.Runtime.LibC.Word16
    {- ^ __C declaration:__ @background_blue@

         __defined at:__ @libheif\/heif_color.h 91:46@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_conversion_options_ext_secondary_background_red :: HsBindgen.Runtime.LibC.Word16
    {- ^ __C declaration:__ @secondary_background_red@

         __defined at:__ @libheif\/heif_color.h 92:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_conversion_options_ext_secondary_background_green :: HsBindgen.Runtime.LibC.Word16
    {- ^ __C declaration:__ @secondary_background_green@

         __defined at:__ @libheif\/heif_color.h 92:38@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_conversion_options_ext_secondary_background_blue :: HsBindgen.Runtime.LibC.Word16
    {- ^ __C declaration:__ @secondary_background_blue@

         __defined at:__ @libheif\/heif_color.h 92:66@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_conversion_options_ext_checkerboard_square_size :: HsBindgen.Runtime.LibC.Word16
    {- ^ __C declaration:__ @checkerboard_square_size@

         __defined at:__ @libheif\/heif_color.h 93:12@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_color_conversion_options_ext where

  staticSizeOf = \_ -> (24 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_color_conversion_options_ext where

  readRaw =
    \ptr0 ->
          pure Heif_color_conversion_options_ext
      <*> HasCField.readRaw (BG.Proxy @"heif_color_conversion_options_ext_version") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_conversion_options_ext_alpha_composition_mode") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_conversion_options_ext_background_red") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_conversion_options_ext_background_green") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_conversion_options_ext_background_blue") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_conversion_options_ext_secondary_background_red") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_conversion_options_ext_secondary_background_green") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_conversion_options_ext_secondary_background_blue") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_conversion_options_ext_checkerboard_square_size") ptr0

instance Marshal.WriteRaw Heif_color_conversion_options_ext where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_color_conversion_options_ext
            heif_color_conversion_options_ext_version2
            heif_color_conversion_options_ext_alpha_composition_mode3
            heif_color_conversion_options_ext_background_red4
            heif_color_conversion_options_ext_background_green5
            heif_color_conversion_options_ext_background_blue6
            heif_color_conversion_options_ext_secondary_background_red7
            heif_color_conversion_options_ext_secondary_background_green8
            heif_color_conversion_options_ext_secondary_background_blue9
            heif_color_conversion_options_ext_checkerboard_square_size10 ->
                 HasCField.writeRaw (BG.Proxy @"heif_color_conversion_options_ext_version") ptr0 heif_color_conversion_options_ext_version2
              >> HasCField.writeRaw (BG.Proxy @"heif_color_conversion_options_ext_alpha_composition_mode") ptr0 heif_color_conversion_options_ext_alpha_composition_mode3
              >> HasCField.writeRaw (BG.Proxy @"heif_color_conversion_options_ext_background_red") ptr0 heif_color_conversion_options_ext_background_red4
              >> HasCField.writeRaw (BG.Proxy @"heif_color_conversion_options_ext_background_green") ptr0 heif_color_conversion_options_ext_background_green5
              >> HasCField.writeRaw (BG.Proxy @"heif_color_conversion_options_ext_background_blue") ptr0 heif_color_conversion_options_ext_background_blue6
              >> HasCField.writeRaw (BG.Proxy @"heif_color_conversion_options_ext_secondary_background_red") ptr0 heif_color_conversion_options_ext_secondary_background_red7
              >> HasCField.writeRaw (BG.Proxy @"heif_color_conversion_options_ext_secondary_background_green") ptr0 heif_color_conversion_options_ext_secondary_background_green8
              >> HasCField.writeRaw (BG.Proxy @"heif_color_conversion_options_ext_secondary_background_blue") ptr0 heif_color_conversion_options_ext_secondary_background_blue9
              >> HasCField.writeRaw (BG.Proxy @"heif_color_conversion_options_ext_checkerboard_square_size") ptr0 heif_color_conversion_options_ext_checkerboard_square_size10

deriving via Marshal.EquivStorable Heif_color_conversion_options_ext instance BG.Storable Heif_color_conversion_options_ext

deriving via Struct.IsStructViaReadRaw Heif_color_conversion_options_ext instance Struct.IsStruct Heif_color_conversion_options_ext

{-| __C declaration:__ @version@

    __defined at:__ @libheif\/heif_color.h 84:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_color_conversion_options_ext_version" Heif_color_conversion_options_ext ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_conversion_options_ext { heif_color_conversion_options_ext_version = y1
                                            , heif_color_conversion_options_ext_alpha_composition_mode = BG.getField @"heif_color_conversion_options_ext_alpha_composition_mode" x0
                                            , heif_color_conversion_options_ext_background_red = BG.getField @"heif_color_conversion_options_ext_background_red" x0
                                            , heif_color_conversion_options_ext_background_green = BG.getField @"heif_color_conversion_options_ext_background_green" x0
                                            , heif_color_conversion_options_ext_background_blue = BG.getField @"heif_color_conversion_options_ext_background_blue" x0
                                            , heif_color_conversion_options_ext_secondary_background_red = BG.getField @"heif_color_conversion_options_ext_secondary_background_red" x0
                                            , heif_color_conversion_options_ext_secondary_background_green = BG.getField @"heif_color_conversion_options_ext_secondary_background_green" x0
                                            , heif_color_conversion_options_ext_secondary_background_blue = BG.getField @"heif_color_conversion_options_ext_secondary_background_blue" x0
                                            , heif_color_conversion_options_ext_checkerboard_square_size = BG.getField @"heif_color_conversion_options_ext_checkerboard_square_size" x0
                                            }
      , BG.getField @"heif_color_conversion_options_ext_version" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_color_conversion_options_ext_version" (BG.Ptr Heif_color_conversion_options_ext) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_conversion_options_ext_version")

instance HasCField.HasCField Heif_color_conversion_options_ext "heif_color_conversion_options_ext_version" where

  type CFieldType Heif_color_conversion_options_ext "heif_color_conversion_options_ext_version" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @alpha_composition_mode@

    __defined at:__ @libheif\/heif_color.h 88:31@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ Heif_alpha_composition_mode
         ) => BG.CompatHasField.HasField "heif_color_conversion_options_ext_alpha_composition_mode" Heif_color_conversion_options_ext ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_conversion_options_ext { heif_color_conversion_options_ext_alpha_composition_mode = y1
                                            , heif_color_conversion_options_ext_version = BG.getField @"heif_color_conversion_options_ext_version" x0
                                            , heif_color_conversion_options_ext_background_red = BG.getField @"heif_color_conversion_options_ext_background_red" x0
                                            , heif_color_conversion_options_ext_background_green = BG.getField @"heif_color_conversion_options_ext_background_green" x0
                                            , heif_color_conversion_options_ext_background_blue = BG.getField @"heif_color_conversion_options_ext_background_blue" x0
                                            , heif_color_conversion_options_ext_secondary_background_red = BG.getField @"heif_color_conversion_options_ext_secondary_background_red" x0
                                            , heif_color_conversion_options_ext_secondary_background_green = BG.getField @"heif_color_conversion_options_ext_secondary_background_green" x0
                                            , heif_color_conversion_options_ext_secondary_background_blue = BG.getField @"heif_color_conversion_options_ext_secondary_background_blue" x0
                                            , heif_color_conversion_options_ext_checkerboard_square_size = BG.getField @"heif_color_conversion_options_ext_checkerboard_square_size" x0
                                            }
      , BG.getField @"heif_color_conversion_options_ext_alpha_composition_mode" x0
      )

instance ( ty ~ Heif_alpha_composition_mode
         ) => BG.HasField "heif_color_conversion_options_ext_alpha_composition_mode" (BG.Ptr Heif_color_conversion_options_ext) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_conversion_options_ext_alpha_composition_mode")

instance HasCField.HasCField Heif_color_conversion_options_ext "heif_color_conversion_options_ext_alpha_composition_mode" where

  type CFieldType Heif_color_conversion_options_ext "heif_color_conversion_options_ext_alpha_composition_mode" =
    Heif_alpha_composition_mode

  offset# = \_ -> \_ -> 4

{-| __C declaration:__ @background_red@

    __defined at:__ @libheif\/heif_color.h 91:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.CompatHasField.HasField "heif_color_conversion_options_ext_background_red" Heif_color_conversion_options_ext ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_conversion_options_ext { heif_color_conversion_options_ext_background_red = y1
                                            , heif_color_conversion_options_ext_version = BG.getField @"heif_color_conversion_options_ext_version" x0
                                            , heif_color_conversion_options_ext_alpha_composition_mode = BG.getField @"heif_color_conversion_options_ext_alpha_composition_mode" x0
                                            , heif_color_conversion_options_ext_background_green = BG.getField @"heif_color_conversion_options_ext_background_green" x0
                                            , heif_color_conversion_options_ext_background_blue = BG.getField @"heif_color_conversion_options_ext_background_blue" x0
                                            , heif_color_conversion_options_ext_secondary_background_red = BG.getField @"heif_color_conversion_options_ext_secondary_background_red" x0
                                            , heif_color_conversion_options_ext_secondary_background_green = BG.getField @"heif_color_conversion_options_ext_secondary_background_green" x0
                                            , heif_color_conversion_options_ext_secondary_background_blue = BG.getField @"heif_color_conversion_options_ext_secondary_background_blue" x0
                                            , heif_color_conversion_options_ext_checkerboard_square_size = BG.getField @"heif_color_conversion_options_ext_checkerboard_square_size" x0
                                            }
      , BG.getField @"heif_color_conversion_options_ext_background_red" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.HasField "heif_color_conversion_options_ext_background_red" (BG.Ptr Heif_color_conversion_options_ext) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_conversion_options_ext_background_red")

instance HasCField.HasCField Heif_color_conversion_options_ext "heif_color_conversion_options_ext_background_red" where

  type CFieldType Heif_color_conversion_options_ext "heif_color_conversion_options_ext_background_red" =
    HsBindgen.Runtime.LibC.Word16

  offset# = \_ -> \_ -> 8

{-| __C declaration:__ @background_green@

    __defined at:__ @libheif\/heif_color.h 91:28@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.CompatHasField.HasField "heif_color_conversion_options_ext_background_green" Heif_color_conversion_options_ext ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_conversion_options_ext { heif_color_conversion_options_ext_background_green = y1
                                            , heif_color_conversion_options_ext_version = BG.getField @"heif_color_conversion_options_ext_version" x0
                                            , heif_color_conversion_options_ext_alpha_composition_mode = BG.getField @"heif_color_conversion_options_ext_alpha_composition_mode" x0
                                            , heif_color_conversion_options_ext_background_red = BG.getField @"heif_color_conversion_options_ext_background_red" x0
                                            , heif_color_conversion_options_ext_background_blue = BG.getField @"heif_color_conversion_options_ext_background_blue" x0
                                            , heif_color_conversion_options_ext_secondary_background_red = BG.getField @"heif_color_conversion_options_ext_secondary_background_red" x0
                                            , heif_color_conversion_options_ext_secondary_background_green = BG.getField @"heif_color_conversion_options_ext_secondary_background_green" x0
                                            , heif_color_conversion_options_ext_secondary_background_blue = BG.getField @"heif_color_conversion_options_ext_secondary_background_blue" x0
                                            , heif_color_conversion_options_ext_checkerboard_square_size = BG.getField @"heif_color_conversion_options_ext_checkerboard_square_size" x0
                                            }
      , BG.getField @"heif_color_conversion_options_ext_background_green" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.HasField "heif_color_conversion_options_ext_background_green" (BG.Ptr Heif_color_conversion_options_ext) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_conversion_options_ext_background_green")

instance HasCField.HasCField Heif_color_conversion_options_ext "heif_color_conversion_options_ext_background_green" where

  type CFieldType Heif_color_conversion_options_ext "heif_color_conversion_options_ext_background_green" =
    HsBindgen.Runtime.LibC.Word16

  offset# = \_ -> \_ -> 10

{-| __C declaration:__ @background_blue@

    __defined at:__ @libheif\/heif_color.h 91:46@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.CompatHasField.HasField "heif_color_conversion_options_ext_background_blue" Heif_color_conversion_options_ext ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_conversion_options_ext { heif_color_conversion_options_ext_background_blue = y1
                                            , heif_color_conversion_options_ext_version = BG.getField @"heif_color_conversion_options_ext_version" x0
                                            , heif_color_conversion_options_ext_alpha_composition_mode = BG.getField @"heif_color_conversion_options_ext_alpha_composition_mode" x0
                                            , heif_color_conversion_options_ext_background_red = BG.getField @"heif_color_conversion_options_ext_background_red" x0
                                            , heif_color_conversion_options_ext_background_green = BG.getField @"heif_color_conversion_options_ext_background_green" x0
                                            , heif_color_conversion_options_ext_secondary_background_red = BG.getField @"heif_color_conversion_options_ext_secondary_background_red" x0
                                            , heif_color_conversion_options_ext_secondary_background_green = BG.getField @"heif_color_conversion_options_ext_secondary_background_green" x0
                                            , heif_color_conversion_options_ext_secondary_background_blue = BG.getField @"heif_color_conversion_options_ext_secondary_background_blue" x0
                                            , heif_color_conversion_options_ext_checkerboard_square_size = BG.getField @"heif_color_conversion_options_ext_checkerboard_square_size" x0
                                            }
      , BG.getField @"heif_color_conversion_options_ext_background_blue" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.HasField "heif_color_conversion_options_ext_background_blue" (BG.Ptr Heif_color_conversion_options_ext) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_conversion_options_ext_background_blue")

instance HasCField.HasCField Heif_color_conversion_options_ext "heif_color_conversion_options_ext_background_blue" where

  type CFieldType Heif_color_conversion_options_ext "heif_color_conversion_options_ext_background_blue" =
    HsBindgen.Runtime.LibC.Word16

  offset# = \_ -> \_ -> 12

{-| __C declaration:__ @secondary_background_red@

    __defined at:__ @libheif\/heif_color.h 92:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.CompatHasField.HasField "heif_color_conversion_options_ext_secondary_background_red" Heif_color_conversion_options_ext ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_conversion_options_ext { heif_color_conversion_options_ext_secondary_background_red = y1
                                            , heif_color_conversion_options_ext_version = BG.getField @"heif_color_conversion_options_ext_version" x0
                                            , heif_color_conversion_options_ext_alpha_composition_mode = BG.getField @"heif_color_conversion_options_ext_alpha_composition_mode" x0
                                            , heif_color_conversion_options_ext_background_red = BG.getField @"heif_color_conversion_options_ext_background_red" x0
                                            , heif_color_conversion_options_ext_background_green = BG.getField @"heif_color_conversion_options_ext_background_green" x0
                                            , heif_color_conversion_options_ext_background_blue = BG.getField @"heif_color_conversion_options_ext_background_blue" x0
                                            , heif_color_conversion_options_ext_secondary_background_green = BG.getField @"heif_color_conversion_options_ext_secondary_background_green" x0
                                            , heif_color_conversion_options_ext_secondary_background_blue = BG.getField @"heif_color_conversion_options_ext_secondary_background_blue" x0
                                            , heif_color_conversion_options_ext_checkerboard_square_size = BG.getField @"heif_color_conversion_options_ext_checkerboard_square_size" x0
                                            }
      , BG.getField @"heif_color_conversion_options_ext_secondary_background_red" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.HasField "heif_color_conversion_options_ext_secondary_background_red" (BG.Ptr Heif_color_conversion_options_ext) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_conversion_options_ext_secondary_background_red")

instance HasCField.HasCField Heif_color_conversion_options_ext "heif_color_conversion_options_ext_secondary_background_red" where

  type CFieldType Heif_color_conversion_options_ext "heif_color_conversion_options_ext_secondary_background_red" =
    HsBindgen.Runtime.LibC.Word16

  offset# = \_ -> \_ -> 14

{-| __C declaration:__ @secondary_background_green@

    __defined at:__ @libheif\/heif_color.h 92:38@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.CompatHasField.HasField "heif_color_conversion_options_ext_secondary_background_green" Heif_color_conversion_options_ext ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_conversion_options_ext { heif_color_conversion_options_ext_secondary_background_green = y1
                                            , heif_color_conversion_options_ext_version = BG.getField @"heif_color_conversion_options_ext_version" x0
                                            , heif_color_conversion_options_ext_alpha_composition_mode = BG.getField @"heif_color_conversion_options_ext_alpha_composition_mode" x0
                                            , heif_color_conversion_options_ext_background_red = BG.getField @"heif_color_conversion_options_ext_background_red" x0
                                            , heif_color_conversion_options_ext_background_green = BG.getField @"heif_color_conversion_options_ext_background_green" x0
                                            , heif_color_conversion_options_ext_background_blue = BG.getField @"heif_color_conversion_options_ext_background_blue" x0
                                            , heif_color_conversion_options_ext_secondary_background_red = BG.getField @"heif_color_conversion_options_ext_secondary_background_red" x0
                                            , heif_color_conversion_options_ext_secondary_background_blue = BG.getField @"heif_color_conversion_options_ext_secondary_background_blue" x0
                                            , heif_color_conversion_options_ext_checkerboard_square_size = BG.getField @"heif_color_conversion_options_ext_checkerboard_square_size" x0
                                            }
      , BG.getField @"heif_color_conversion_options_ext_secondary_background_green" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.HasField "heif_color_conversion_options_ext_secondary_background_green" (BG.Ptr Heif_color_conversion_options_ext) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_conversion_options_ext_secondary_background_green")

instance HasCField.HasCField Heif_color_conversion_options_ext "heif_color_conversion_options_ext_secondary_background_green" where

  type CFieldType Heif_color_conversion_options_ext "heif_color_conversion_options_ext_secondary_background_green" =
    HsBindgen.Runtime.LibC.Word16

  offset# = \_ -> \_ -> 16

{-| __C declaration:__ @secondary_background_blue@

    __defined at:__ @libheif\/heif_color.h 92:66@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.CompatHasField.HasField "heif_color_conversion_options_ext_secondary_background_blue" Heif_color_conversion_options_ext ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_conversion_options_ext { heif_color_conversion_options_ext_secondary_background_blue = y1
                                            , heif_color_conversion_options_ext_version = BG.getField @"heif_color_conversion_options_ext_version" x0
                                            , heif_color_conversion_options_ext_alpha_composition_mode = BG.getField @"heif_color_conversion_options_ext_alpha_composition_mode" x0
                                            , heif_color_conversion_options_ext_background_red = BG.getField @"heif_color_conversion_options_ext_background_red" x0
                                            , heif_color_conversion_options_ext_background_green = BG.getField @"heif_color_conversion_options_ext_background_green" x0
                                            , heif_color_conversion_options_ext_background_blue = BG.getField @"heif_color_conversion_options_ext_background_blue" x0
                                            , heif_color_conversion_options_ext_secondary_background_red = BG.getField @"heif_color_conversion_options_ext_secondary_background_red" x0
                                            , heif_color_conversion_options_ext_secondary_background_green = BG.getField @"heif_color_conversion_options_ext_secondary_background_green" x0
                                            , heif_color_conversion_options_ext_checkerboard_square_size = BG.getField @"heif_color_conversion_options_ext_checkerboard_square_size" x0
                                            }
      , BG.getField @"heif_color_conversion_options_ext_secondary_background_blue" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.HasField "heif_color_conversion_options_ext_secondary_background_blue" (BG.Ptr Heif_color_conversion_options_ext) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_conversion_options_ext_secondary_background_blue")

instance HasCField.HasCField Heif_color_conversion_options_ext "heif_color_conversion_options_ext_secondary_background_blue" where

  type CFieldType Heif_color_conversion_options_ext "heif_color_conversion_options_ext_secondary_background_blue" =
    HsBindgen.Runtime.LibC.Word16

  offset# = \_ -> \_ -> 18

{-| __C declaration:__ @checkerboard_square_size@

    __defined at:__ @libheif\/heif_color.h 93:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.CompatHasField.HasField "heif_color_conversion_options_ext_checkerboard_square_size" Heif_color_conversion_options_ext ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_conversion_options_ext { heif_color_conversion_options_ext_checkerboard_square_size = y1
                                            , heif_color_conversion_options_ext_version = BG.getField @"heif_color_conversion_options_ext_version" x0
                                            , heif_color_conversion_options_ext_alpha_composition_mode = BG.getField @"heif_color_conversion_options_ext_alpha_composition_mode" x0
                                            , heif_color_conversion_options_ext_background_red = BG.getField @"heif_color_conversion_options_ext_background_red" x0
                                            , heif_color_conversion_options_ext_background_green = BG.getField @"heif_color_conversion_options_ext_background_green" x0
                                            , heif_color_conversion_options_ext_background_blue = BG.getField @"heif_color_conversion_options_ext_background_blue" x0
                                            , heif_color_conversion_options_ext_secondary_background_red = BG.getField @"heif_color_conversion_options_ext_secondary_background_red" x0
                                            , heif_color_conversion_options_ext_secondary_background_green = BG.getField @"heif_color_conversion_options_ext_secondary_background_green" x0
                                            , heif_color_conversion_options_ext_secondary_background_blue = BG.getField @"heif_color_conversion_options_ext_secondary_background_blue" x0
                                            }
      , BG.getField @"heif_color_conversion_options_ext_checkerboard_square_size" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.HasField "heif_color_conversion_options_ext_checkerboard_square_size" (BG.Ptr Heif_color_conversion_options_ext) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_conversion_options_ext_checkerboard_square_size")

instance HasCField.HasCField Heif_color_conversion_options_ext "heif_color_conversion_options_ext_checkerboard_square_size" where

  type CFieldType Heif_color_conversion_options_ext "heif_color_conversion_options_ext_checkerboard_square_size" =
    HsBindgen.Runtime.LibC.Word16

  offset# = \_ -> \_ -> 20

{-| __C declaration:__ @enum heif_color_profile_type@

    __defined at:__ @libheif\/heif_color.h 114:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_color_profile_type = Heif_color_profile_type
  { unwrapHeif_color_profile_type :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_color_profile_type where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_color_profile_type where

  readRaw =
    \ptr0 ->
          pure Heif_color_profile_type
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_color_profile_type where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_color_profile_type unwrapHeif_color_profile_type2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_color_profile_type2

deriving via Marshal.EquivStorable Heif_color_profile_type instance BG.Storable Heif_color_profile_type

deriving via BG.CUInt instance BG.Prim Heif_color_profile_type

instance CEnum.CEnum Heif_color_profile_type where

  type CEnumZ Heif_color_profile_type = BG.CUInt

  toCEnum = Heif_color_profile_type

  fromCEnum =
    BG.getField @"unwrapHeif_color_profile_type"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_color_profile_type_not_present")
                                   , (1852009592, BG.singleton "Heif_color_profile_type_nclx")
                                   , (1886547814, BG.singleton "Heif_color_profile_type_prof")
                                   , (1917403971, BG.singleton "Heif_color_profile_type_rICC")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_color_profile_type"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_color_profile_type"

instance Show Heif_color_profile_type where

  showsPrec = CEnum.shows

instance Read Heif_color_profile_type where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_color_profile_type" Heif_color_profile_type ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_profile_type {unwrapHeif_color_profile_type = y1}
      , BG.getField @"unwrapHeif_color_profile_type" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_color_profile_type" (BG.Ptr Heif_color_profile_type) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_color_profile_type")

instance HasCField.HasCField Heif_color_profile_type "unwrapHeif_color_profile_type" where

  type CFieldType Heif_color_profile_type "unwrapHeif_color_profile_type" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_color_profile_type_not_present@

    __defined at:__ @libheif\/heif_color.h 116:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_color_profile_type_not_present :: Heif_color_profile_type
pattern Heif_color_profile_type_not_present = Heif_color_profile_type 0

{-| __C declaration:__ @heif_color_profile_type_nclx@

    __defined at:__ @libheif\/heif_color.h 117:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_color_profile_type_nclx :: Heif_color_profile_type
pattern Heif_color_profile_type_nclx = Heif_color_profile_type 1852009592

{-| __C declaration:__ @heif_color_profile_type_rICC@

    __defined at:__ @libheif\/heif_color.h 118:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_color_profile_type_rICC :: Heif_color_profile_type
pattern Heif_color_profile_type_rICC = Heif_color_profile_type 1917403971

{-| __C declaration:__ @heif_color_profile_type_prof@

    __defined at:__ @libheif\/heif_color.h 119:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_color_profile_type_prof :: Heif_color_profile_type
pattern Heif_color_profile_type_prof = Heif_color_profile_type 1886547814

{-| __C declaration:__ @enum heif_color_primaries@

    __defined at:__ @libheif\/heif_color.h 140:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_color_primaries = Heif_color_primaries
  { unwrapHeif_color_primaries :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_color_primaries where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_color_primaries where

  readRaw =
    \ptr0 ->
          pure Heif_color_primaries
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_color_primaries where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_color_primaries unwrapHeif_color_primaries2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_color_primaries2

deriving via Marshal.EquivStorable Heif_color_primaries instance BG.Storable Heif_color_primaries

deriving via BG.CUInt instance BG.Prim Heif_color_primaries

instance CEnum.CEnum Heif_color_primaries where

  type CEnumZ Heif_color_primaries = BG.CUInt

  toCEnum = Heif_color_primaries

  fromCEnum = BG.getField @"unwrapHeif_color_primaries"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (1, BG.singleton "Heif_color_primaries_ITU_R_BT_709_5")
                                   , (2, BG.singleton "Heif_color_primaries_unspecified")
                                   , (4, BG.singleton "Heif_color_primaries_ITU_R_BT_470_6_System_M")
                                   , (5, BG.singleton "Heif_color_primaries_ITU_R_BT_470_6_System_B_G")
                                   , (6, BG.singleton "Heif_color_primaries_ITU_R_BT_601_6")
                                   , (7, BG.singleton "Heif_color_primaries_SMPTE_240M")
                                   , (8, BG.singleton "Heif_color_primaries_generic_film")
                                   , (9, BG.singleton "Heif_color_primaries_ITU_R_BT_2020_2_and_2100_0")
                                   , (10, BG.singleton "Heif_color_primaries_SMPTE_ST_428_1")
                                   , (11, BG.singleton "Heif_color_primaries_SMPTE_RP_431_2")
                                   , (12, BG.singleton "Heif_color_primaries_SMPTE_EG_432_1")
                                   , (22, BG.singleton "Heif_color_primaries_EBU_Tech_3213_E")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_color_primaries"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_color_primaries"

instance Show Heif_color_primaries where

  showsPrec = CEnum.shows

instance Read Heif_color_primaries where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_color_primaries" Heif_color_primaries ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_primaries {unwrapHeif_color_primaries = y1}
      , BG.getField @"unwrapHeif_color_primaries" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_color_primaries" (BG.Ptr Heif_color_primaries) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_color_primaries")

instance HasCField.HasCField Heif_color_primaries "unwrapHeif_color_primaries" where

  type CFieldType Heif_color_primaries "unwrapHeif_color_primaries" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_color_primaries_ITU_R_BT_709_5@

    __defined at:__ @libheif\/heif_color.h 142:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_color_primaries_ITU_R_BT_709_5 :: Heif_color_primaries
pattern Heif_color_primaries_ITU_R_BT_709_5 = Heif_color_primaries 1

{-| __C declaration:__ @heif_color_primaries_unspecified@

    __defined at:__ @libheif\/heif_color.h 143:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_color_primaries_unspecified :: Heif_color_primaries
pattern Heif_color_primaries_unspecified = Heif_color_primaries 2

{-| __C declaration:__ @heif_color_primaries_ITU_R_BT_470_6_System_M@

    __defined at:__ @libheif\/heif_color.h 144:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_color_primaries_ITU_R_BT_470_6_System_M :: Heif_color_primaries
pattern Heif_color_primaries_ITU_R_BT_470_6_System_M = Heif_color_primaries 4

{-| __C declaration:__ @heif_color_primaries_ITU_R_BT_470_6_System_B_G@

    __defined at:__ @libheif\/heif_color.h 145:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_color_primaries_ITU_R_BT_470_6_System_B_G :: Heif_color_primaries
pattern Heif_color_primaries_ITU_R_BT_470_6_System_B_G = Heif_color_primaries 5

{-| __C declaration:__ @heif_color_primaries_ITU_R_BT_601_6@

    __defined at:__ @libheif\/heif_color.h 146:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_color_primaries_ITU_R_BT_601_6 :: Heif_color_primaries
pattern Heif_color_primaries_ITU_R_BT_601_6 = Heif_color_primaries 6

{-| __C declaration:__ @heif_color_primaries_SMPTE_240M@

    __defined at:__ @libheif\/heif_color.h 147:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_color_primaries_SMPTE_240M :: Heif_color_primaries
pattern Heif_color_primaries_SMPTE_240M = Heif_color_primaries 7

{-| __C declaration:__ @heif_color_primaries_generic_film@

    __defined at:__ @libheif\/heif_color.h 148:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_color_primaries_generic_film :: Heif_color_primaries
pattern Heif_color_primaries_generic_film = Heif_color_primaries 8

{-| __C declaration:__ @heif_color_primaries_ITU_R_BT_2020_2_and_2100_0@

    __defined at:__ @libheif\/heif_color.h 149:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_color_primaries_ITU_R_BT_2020_2_and_2100_0 :: Heif_color_primaries
pattern Heif_color_primaries_ITU_R_BT_2020_2_and_2100_0 = Heif_color_primaries 9

{-| __C declaration:__ @heif_color_primaries_SMPTE_ST_428_1@

    __defined at:__ @libheif\/heif_color.h 150:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_color_primaries_SMPTE_ST_428_1 :: Heif_color_primaries
pattern Heif_color_primaries_SMPTE_ST_428_1 = Heif_color_primaries 10

{-| __C declaration:__ @heif_color_primaries_SMPTE_RP_431_2@

    __defined at:__ @libheif\/heif_color.h 151:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_color_primaries_SMPTE_RP_431_2 :: Heif_color_primaries
pattern Heif_color_primaries_SMPTE_RP_431_2 = Heif_color_primaries 11

{-| __C declaration:__ @heif_color_primaries_SMPTE_EG_432_1@

    __defined at:__ @libheif\/heif_color.h 152:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_color_primaries_SMPTE_EG_432_1 :: Heif_color_primaries
pattern Heif_color_primaries_SMPTE_EG_432_1 = Heif_color_primaries 12

{-| __C declaration:__ @heif_color_primaries_EBU_Tech_3213_E@

    __defined at:__ @libheif\/heif_color.h 153:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_color_primaries_EBU_Tech_3213_E :: Heif_color_primaries
pattern Heif_color_primaries_EBU_Tech_3213_E = Heif_color_primaries 22

{-| __C declaration:__ @enum heif_transfer_characteristics@

    __defined at:__ @libheif\/heif_color.h 156:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_transfer_characteristics = Heif_transfer_characteristics
  { unwrapHeif_transfer_characteristics :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_transfer_characteristics where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_transfer_characteristics where

  readRaw =
    \ptr0 ->
          pure Heif_transfer_characteristics
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_transfer_characteristics where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_transfer_characteristics unwrapHeif_transfer_characteristics2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_transfer_characteristics2

deriving via Marshal.EquivStorable Heif_transfer_characteristics instance BG.Storable Heif_transfer_characteristics

deriving via BG.CUInt instance BG.Prim Heif_transfer_characteristics

instance CEnum.CEnum Heif_transfer_characteristics where

  type CEnumZ Heif_transfer_characteristics = BG.CUInt

  toCEnum = Heif_transfer_characteristics

  fromCEnum =
    BG.getField @"unwrapHeif_transfer_characteristics"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (1, BG.singleton "Heif_transfer_characteristic_ITU_R_BT_709_5")
                                   , (2, BG.singleton "Heif_transfer_characteristic_unspecified")
                                   , (4, BG.singleton "Heif_transfer_characteristic_ITU_R_BT_470_6_System_M")
                                   , (5, BG.singleton "Heif_transfer_characteristic_ITU_R_BT_470_6_System_B_G")
                                   , (6, BG.singleton "Heif_transfer_characteristic_ITU_R_BT_601_6")
                                   , (7, BG.singleton "Heif_transfer_characteristic_SMPTE_240M")
                                   , (8, BG.singleton "Heif_transfer_characteristic_linear")
                                   , (9, BG.singleton "Heif_transfer_characteristic_logarithmic_100")
                                   , (10, BG.singleton "Heif_transfer_characteristic_logarithmic_100_sqrt10")
                                   , (11, BG.singleton "Heif_transfer_characteristic_IEC_61966_2_4")
                                   , (12, BG.singleton "Heif_transfer_characteristic_ITU_R_BT_1361")
                                   , (13, BG.singleton "Heif_transfer_characteristic_IEC_61966_2_1")
                                   , (14, BG.singleton "Heif_transfer_characteristic_ITU_R_BT_2020_2_10bit")
                                   , (15, BG.singleton "Heif_transfer_characteristic_ITU_R_BT_2020_2_12bit")
                                   , (16, BG.singleton "Heif_transfer_characteristic_ITU_R_BT_2100_0_PQ")
                                   , (17, BG.singleton "Heif_transfer_characteristic_SMPTE_ST_428_1")
                                   , (18, BG.singleton "Heif_transfer_characteristic_ITU_R_BT_2100_0_HLG")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_transfer_characteristics"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_transfer_characteristics"

instance Show Heif_transfer_characteristics where

  showsPrec = CEnum.shows

instance Read Heif_transfer_characteristics where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_transfer_characteristics" Heif_transfer_characteristics ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_transfer_characteristics {unwrapHeif_transfer_characteristics = y1}
      , BG.getField @"unwrapHeif_transfer_characteristics" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_transfer_characteristics" (BG.Ptr Heif_transfer_characteristics) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_transfer_characteristics")

instance HasCField.HasCField Heif_transfer_characteristics "unwrapHeif_transfer_characteristics" where

  type CFieldType Heif_transfer_characteristics "unwrapHeif_transfer_characteristics" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_transfer_characteristic_ITU_R_BT_709_5@

    __defined at:__ @libheif\/heif_color.h 158:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_transfer_characteristic_ITU_R_BT_709_5 :: Heif_transfer_characteristics
pattern Heif_transfer_characteristic_ITU_R_BT_709_5 = Heif_transfer_characteristics 1

{-| __C declaration:__ @heif_transfer_characteristic_unspecified@

    __defined at:__ @libheif\/heif_color.h 159:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_transfer_characteristic_unspecified :: Heif_transfer_characteristics
pattern Heif_transfer_characteristic_unspecified = Heif_transfer_characteristics 2

{-| __C declaration:__ @heif_transfer_characteristic_ITU_R_BT_470_6_System_M@

    __defined at:__ @libheif\/heif_color.h 160:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_transfer_characteristic_ITU_R_BT_470_6_System_M :: Heif_transfer_characteristics
pattern Heif_transfer_characteristic_ITU_R_BT_470_6_System_M = Heif_transfer_characteristics 4

{-| __C declaration:__ @heif_transfer_characteristic_ITU_R_BT_470_6_System_B_G@

    __defined at:__ @libheif\/heif_color.h 161:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_transfer_characteristic_ITU_R_BT_470_6_System_B_G :: Heif_transfer_characteristics
pattern Heif_transfer_characteristic_ITU_R_BT_470_6_System_B_G = Heif_transfer_characteristics 5

{-| __C declaration:__ @heif_transfer_characteristic_ITU_R_BT_601_6@

    __defined at:__ @libheif\/heif_color.h 162:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_transfer_characteristic_ITU_R_BT_601_6 :: Heif_transfer_characteristics
pattern Heif_transfer_characteristic_ITU_R_BT_601_6 = Heif_transfer_characteristics 6

{-| __C declaration:__ @heif_transfer_characteristic_SMPTE_240M@

    __defined at:__ @libheif\/heif_color.h 163:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_transfer_characteristic_SMPTE_240M :: Heif_transfer_characteristics
pattern Heif_transfer_characteristic_SMPTE_240M = Heif_transfer_characteristics 7

{-| __C declaration:__ @heif_transfer_characteristic_linear@

    __defined at:__ @libheif\/heif_color.h 164:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_transfer_characteristic_linear :: Heif_transfer_characteristics
pattern Heif_transfer_characteristic_linear = Heif_transfer_characteristics 8

{-| __C declaration:__ @heif_transfer_characteristic_logarithmic_100@

    __defined at:__ @libheif\/heif_color.h 165:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_transfer_characteristic_logarithmic_100 :: Heif_transfer_characteristics
pattern Heif_transfer_characteristic_logarithmic_100 = Heif_transfer_characteristics 9

{-| __C declaration:__ @heif_transfer_characteristic_logarithmic_100_sqrt10@

    __defined at:__ @libheif\/heif_color.h 166:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_transfer_characteristic_logarithmic_100_sqrt10 :: Heif_transfer_characteristics
pattern Heif_transfer_characteristic_logarithmic_100_sqrt10 = Heif_transfer_characteristics 10

{-| __C declaration:__ @heif_transfer_characteristic_IEC_61966_2_4@

    __defined at:__ @libheif\/heif_color.h 167:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_transfer_characteristic_IEC_61966_2_4 :: Heif_transfer_characteristics
pattern Heif_transfer_characteristic_IEC_61966_2_4 = Heif_transfer_characteristics 11

{-| __C declaration:__ @heif_transfer_characteristic_ITU_R_BT_1361@

    __defined at:__ @libheif\/heif_color.h 168:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_transfer_characteristic_ITU_R_BT_1361 :: Heif_transfer_characteristics
pattern Heif_transfer_characteristic_ITU_R_BT_1361 = Heif_transfer_characteristics 12

{-| __C declaration:__ @heif_transfer_characteristic_IEC_61966_2_1@

    __defined at:__ @libheif\/heif_color.h 169:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_transfer_characteristic_IEC_61966_2_1 :: Heif_transfer_characteristics
pattern Heif_transfer_characteristic_IEC_61966_2_1 = Heif_transfer_characteristics 13

{-| __C declaration:__ @heif_transfer_characteristic_ITU_R_BT_2020_2_10bit@

    __defined at:__ @libheif\/heif_color.h 170:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_transfer_characteristic_ITU_R_BT_2020_2_10bit :: Heif_transfer_characteristics
pattern Heif_transfer_characteristic_ITU_R_BT_2020_2_10bit = Heif_transfer_characteristics 14

{-| __C declaration:__ @heif_transfer_characteristic_ITU_R_BT_2020_2_12bit@

    __defined at:__ @libheif\/heif_color.h 171:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_transfer_characteristic_ITU_R_BT_2020_2_12bit :: Heif_transfer_characteristics
pattern Heif_transfer_characteristic_ITU_R_BT_2020_2_12bit = Heif_transfer_characteristics 15

{-| __C declaration:__ @heif_transfer_characteristic_ITU_R_BT_2100_0_PQ@

    __defined at:__ @libheif\/heif_color.h 172:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_transfer_characteristic_ITU_R_BT_2100_0_PQ :: Heif_transfer_characteristics
pattern Heif_transfer_characteristic_ITU_R_BT_2100_0_PQ = Heif_transfer_characteristics 16

{-| __C declaration:__ @heif_transfer_characteristic_SMPTE_ST_428_1@

    __defined at:__ @libheif\/heif_color.h 173:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_transfer_characteristic_SMPTE_ST_428_1 :: Heif_transfer_characteristics
pattern Heif_transfer_characteristic_SMPTE_ST_428_1 = Heif_transfer_characteristics 17

{-| __C declaration:__ @heif_transfer_characteristic_ITU_R_BT_2100_0_HLG@

    __defined at:__ @libheif\/heif_color.h 174:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_transfer_characteristic_ITU_R_BT_2100_0_HLG :: Heif_transfer_characteristics
pattern Heif_transfer_characteristic_ITU_R_BT_2100_0_HLG = Heif_transfer_characteristics 18

{-| __C declaration:__ @enum heif_matrix_coefficients@

    __defined at:__ @libheif\/heif_color.h 177:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_matrix_coefficients = Heif_matrix_coefficients
  { unwrapHeif_matrix_coefficients :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_matrix_coefficients where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_matrix_coefficients where

  readRaw =
    \ptr0 ->
          pure Heif_matrix_coefficients
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_matrix_coefficients where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_matrix_coefficients unwrapHeif_matrix_coefficients2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_matrix_coefficients2

deriving via Marshal.EquivStorable Heif_matrix_coefficients instance BG.Storable Heif_matrix_coefficients

deriving via BG.CUInt instance BG.Prim Heif_matrix_coefficients

instance CEnum.CEnum Heif_matrix_coefficients where

  type CEnumZ Heif_matrix_coefficients = BG.CUInt

  toCEnum = Heif_matrix_coefficients

  fromCEnum =
    BG.getField @"unwrapHeif_matrix_coefficients"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_matrix_coefficients_RGB_GBR")
                                   , (1, BG.singleton "Heif_matrix_coefficients_ITU_R_BT_709_5")
                                   , (2, BG.singleton "Heif_matrix_coefficients_unspecified")
                                   , (4, BG.singleton "Heif_matrix_coefficients_US_FCC_T47")
                                   , (5, BG.singleton "Heif_matrix_coefficients_ITU_R_BT_470_6_System_B_G")
                                   , (6, BG.singleton "Heif_matrix_coefficients_ITU_R_BT_601_6")
                                   , (7, BG.singleton "Heif_matrix_coefficients_SMPTE_240M")
                                   , (8, BG.singleton "Heif_matrix_coefficients_YCgCo")
                                   , ( 9
                                     , BG.singleton "Heif_matrix_coefficients_ITU_R_BT_2020_2_non_constant_luminance"
                                     )
                                   , (10, BG.singleton "Heif_matrix_coefficients_ITU_R_BT_2020_2_constant_luminance")
                                   , (11, BG.singleton "Heif_matrix_coefficients_SMPTE_ST_2085")
                                   , ( 12
                                     , BG.singleton "Heif_matrix_coefficients_chromaticity_derived_non_constant_luminance"
                                     )
                                   , ( 13
                                     , BG.singleton "Heif_matrix_coefficients_chromaticity_derived_constant_luminance"
                                     )
                                   , (14, BG.singleton "Heif_matrix_coefficients_ICtCp")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_matrix_coefficients"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_matrix_coefficients"

instance Show Heif_matrix_coefficients where

  showsPrec = CEnum.shows

instance Read Heif_matrix_coefficients where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_matrix_coefficients" Heif_matrix_coefficients ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_matrix_coefficients {unwrapHeif_matrix_coefficients = y1}
      , BG.getField @"unwrapHeif_matrix_coefficients" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_matrix_coefficients" (BG.Ptr Heif_matrix_coefficients) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_matrix_coefficients")

instance HasCField.HasCField Heif_matrix_coefficients "unwrapHeif_matrix_coefficients" where

  type CFieldType Heif_matrix_coefficients "unwrapHeif_matrix_coefficients" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_matrix_coefficients_RGB_GBR@

    __defined at:__ @libheif\/heif_color.h 179:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_matrix_coefficients_RGB_GBR :: Heif_matrix_coefficients
pattern Heif_matrix_coefficients_RGB_GBR = Heif_matrix_coefficients 0

{-| __C declaration:__ @heif_matrix_coefficients_ITU_R_BT_709_5@

    __defined at:__ @libheif\/heif_color.h 180:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_matrix_coefficients_ITU_R_BT_709_5 :: Heif_matrix_coefficients
pattern Heif_matrix_coefficients_ITU_R_BT_709_5 = Heif_matrix_coefficients 1

{-| __C declaration:__ @heif_matrix_coefficients_unspecified@

    __defined at:__ @libheif\/heif_color.h 181:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_matrix_coefficients_unspecified :: Heif_matrix_coefficients
pattern Heif_matrix_coefficients_unspecified = Heif_matrix_coefficients 2

{-| __C declaration:__ @heif_matrix_coefficients_US_FCC_T47@

    __defined at:__ @libheif\/heif_color.h 182:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_matrix_coefficients_US_FCC_T47 :: Heif_matrix_coefficients
pattern Heif_matrix_coefficients_US_FCC_T47 = Heif_matrix_coefficients 4

{-| __C declaration:__ @heif_matrix_coefficients_ITU_R_BT_470_6_System_B_G@

    __defined at:__ @libheif\/heif_color.h 183:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_matrix_coefficients_ITU_R_BT_470_6_System_B_G :: Heif_matrix_coefficients
pattern Heif_matrix_coefficients_ITU_R_BT_470_6_System_B_G = Heif_matrix_coefficients 5

{-| __C declaration:__ @heif_matrix_coefficients_ITU_R_BT_601_6@

    __defined at:__ @libheif\/heif_color.h 184:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_matrix_coefficients_ITU_R_BT_601_6 :: Heif_matrix_coefficients
pattern Heif_matrix_coefficients_ITU_R_BT_601_6 = Heif_matrix_coefficients 6

{-| __C declaration:__ @heif_matrix_coefficients_SMPTE_240M@

    __defined at:__ @libheif\/heif_color.h 185:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_matrix_coefficients_SMPTE_240M :: Heif_matrix_coefficients
pattern Heif_matrix_coefficients_SMPTE_240M = Heif_matrix_coefficients 7

{-| __C declaration:__ @heif_matrix_coefficients_YCgCo@

    __defined at:__ @libheif\/heif_color.h 186:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_matrix_coefficients_YCgCo :: Heif_matrix_coefficients
pattern Heif_matrix_coefficients_YCgCo = Heif_matrix_coefficients 8

{-| __C declaration:__ @heif_matrix_coefficients_ITU_R_BT_2020_2_non_constant_luminance@

    __defined at:__ @libheif\/heif_color.h 187:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_matrix_coefficients_ITU_R_BT_2020_2_non_constant_luminance :: Heif_matrix_coefficients
pattern Heif_matrix_coefficients_ITU_R_BT_2020_2_non_constant_luminance = Heif_matrix_coefficients 9

{-| __C declaration:__ @heif_matrix_coefficients_ITU_R_BT_2020_2_constant_luminance@

    __defined at:__ @libheif\/heif_color.h 188:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_matrix_coefficients_ITU_R_BT_2020_2_constant_luminance :: Heif_matrix_coefficients
pattern Heif_matrix_coefficients_ITU_R_BT_2020_2_constant_luminance = Heif_matrix_coefficients 10

{-| __C declaration:__ @heif_matrix_coefficients_SMPTE_ST_2085@

    __defined at:__ @libheif\/heif_color.h 189:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_matrix_coefficients_SMPTE_ST_2085 :: Heif_matrix_coefficients
pattern Heif_matrix_coefficients_SMPTE_ST_2085 = Heif_matrix_coefficients 11

{-| __C declaration:__ @heif_matrix_coefficients_chromaticity_derived_non_constant_luminance@

    __defined at:__ @libheif\/heif_color.h 190:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_matrix_coefficients_chromaticity_derived_non_constant_luminance :: Heif_matrix_coefficients
pattern Heif_matrix_coefficients_chromaticity_derived_non_constant_luminance = Heif_matrix_coefficients 12

{-| __C declaration:__ @heif_matrix_coefficients_chromaticity_derived_constant_luminance@

    __defined at:__ @libheif\/heif_color.h 191:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_matrix_coefficients_chromaticity_derived_constant_luminance :: Heif_matrix_coefficients
pattern Heif_matrix_coefficients_chromaticity_derived_constant_luminance = Heif_matrix_coefficients 13

{-| __C declaration:__ @heif_matrix_coefficients_ICtCp@

    __defined at:__ @libheif\/heif_color.h 192:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_matrix_coefficients_ICtCp :: Heif_matrix_coefficients
pattern Heif_matrix_coefficients_ICtCp = Heif_matrix_coefficients 14

{-| __C declaration:__ @struct heif_color_profile_nclx@

    __defined at:__ @libheif\/heif_color.h 195:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_color_profile_nclx = Heif_color_profile_nclx
  { heif_color_profile_nclx_version :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @version@

         __defined at:__ @libheif\/heif_color.h 199:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_profile_nclx_color_primaries :: Heif_color_primaries
    {- ^ __C declaration:__ @color_primaries@

         __defined at:__ @libheif\/heif_color.h 201:24@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_profile_nclx_transfer_characteristics :: Heif_transfer_characteristics
    {- ^ __C declaration:__ @transfer_characteristics@

         __defined at:__ @libheif\/heif_color.h 202:33@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_profile_nclx_matrix_coefficients :: Heif_matrix_coefficients
    {- ^ __C declaration:__ @matrix_coefficients@

         __defined at:__ @libheif\/heif_color.h 203:28@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_profile_nclx_full_range_flag :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @full_range_flag@

         __defined at:__ @libheif\/heif_color.h 204:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_profile_nclx_color_primary_red_x :: BG.CFloat
    {- ^ __C declaration:__ @color_primary_red_x@

         __defined at:__ @libheif\/heif_color.h 208:9@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_profile_nclx_color_primary_red_y :: BG.CFloat
    {- ^ __C declaration:__ @color_primary_red_y@

         __defined at:__ @libheif\/heif_color.h 208:30@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_profile_nclx_color_primary_green_x :: BG.CFloat
    {- ^ __C declaration:__ @color_primary_green_x@

         __defined at:__ @libheif\/heif_color.h 209:9@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_profile_nclx_color_primary_green_y :: BG.CFloat
    {- ^ __C declaration:__ @color_primary_green_y@

         __defined at:__ @libheif\/heif_color.h 209:32@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_profile_nclx_color_primary_blue_x :: BG.CFloat
    {- ^ __C declaration:__ @color_primary_blue_x@

         __defined at:__ @libheif\/heif_color.h 210:9@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_profile_nclx_color_primary_blue_y :: BG.CFloat
    {- ^ __C declaration:__ @color_primary_blue_y@

         __defined at:__ @libheif\/heif_color.h 210:31@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_profile_nclx_color_primary_white_x :: BG.CFloat
    {- ^ __C declaration:__ @color_primary_white_x@

         __defined at:__ @libheif\/heif_color.h 211:9@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_color_profile_nclx_color_primary_white_y :: BG.CFloat
    {- ^ __C declaration:__ @color_primary_white_y@

         __defined at:__ @libheif\/heif_color.h 211:32@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_color_profile_nclx where

  staticSizeOf = \_ -> (52 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_color_profile_nclx where

  readRaw =
    \ptr0 ->
          pure Heif_color_profile_nclx
      <*> HasCField.readRaw (BG.Proxy @"heif_color_profile_nclx_version") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_profile_nclx_color_primaries") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_profile_nclx_transfer_characteristics") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_profile_nclx_matrix_coefficients") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_profile_nclx_full_range_flag") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_profile_nclx_color_primary_red_x") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_profile_nclx_color_primary_red_y") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_profile_nclx_color_primary_green_x") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_profile_nclx_color_primary_green_y") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_profile_nclx_color_primary_blue_x") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_profile_nclx_color_primary_blue_y") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_profile_nclx_color_primary_white_x") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_color_profile_nclx_color_primary_white_y") ptr0

instance Marshal.WriteRaw Heif_color_profile_nclx where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_color_profile_nclx
            heif_color_profile_nclx_version2
            heif_color_profile_nclx_color_primaries3
            heif_color_profile_nclx_transfer_characteristics4
            heif_color_profile_nclx_matrix_coefficients5
            heif_color_profile_nclx_full_range_flag6
            heif_color_profile_nclx_color_primary_red_x7
            heif_color_profile_nclx_color_primary_red_y8
            heif_color_profile_nclx_color_primary_green_x9
            heif_color_profile_nclx_color_primary_green_y10
            heif_color_profile_nclx_color_primary_blue_x11
            heif_color_profile_nclx_color_primary_blue_y12
            heif_color_profile_nclx_color_primary_white_x13
            heif_color_profile_nclx_color_primary_white_y14 ->
                 HasCField.writeRaw (BG.Proxy @"heif_color_profile_nclx_version") ptr0 heif_color_profile_nclx_version2
              >> HasCField.writeRaw (BG.Proxy @"heif_color_profile_nclx_color_primaries") ptr0 heif_color_profile_nclx_color_primaries3
              >> HasCField.writeRaw (BG.Proxy @"heif_color_profile_nclx_transfer_characteristics") ptr0 heif_color_profile_nclx_transfer_characteristics4
              >> HasCField.writeRaw (BG.Proxy @"heif_color_profile_nclx_matrix_coefficients") ptr0 heif_color_profile_nclx_matrix_coefficients5
              >> HasCField.writeRaw (BG.Proxy @"heif_color_profile_nclx_full_range_flag") ptr0 heif_color_profile_nclx_full_range_flag6
              >> HasCField.writeRaw (BG.Proxy @"heif_color_profile_nclx_color_primary_red_x") ptr0 heif_color_profile_nclx_color_primary_red_x7
              >> HasCField.writeRaw (BG.Proxy @"heif_color_profile_nclx_color_primary_red_y") ptr0 heif_color_profile_nclx_color_primary_red_y8
              >> HasCField.writeRaw (BG.Proxy @"heif_color_profile_nclx_color_primary_green_x") ptr0 heif_color_profile_nclx_color_primary_green_x9
              >> HasCField.writeRaw (BG.Proxy @"heif_color_profile_nclx_color_primary_green_y") ptr0 heif_color_profile_nclx_color_primary_green_y10
              >> HasCField.writeRaw (BG.Proxy @"heif_color_profile_nclx_color_primary_blue_x") ptr0 heif_color_profile_nclx_color_primary_blue_x11
              >> HasCField.writeRaw (BG.Proxy @"heif_color_profile_nclx_color_primary_blue_y") ptr0 heif_color_profile_nclx_color_primary_blue_y12
              >> HasCField.writeRaw (BG.Proxy @"heif_color_profile_nclx_color_primary_white_x") ptr0 heif_color_profile_nclx_color_primary_white_x13
              >> HasCField.writeRaw (BG.Proxy @"heif_color_profile_nclx_color_primary_white_y") ptr0 heif_color_profile_nclx_color_primary_white_y14

deriving via Marshal.EquivStorable Heif_color_profile_nclx instance BG.Storable Heif_color_profile_nclx

deriving via Struct.IsStructViaReadRaw Heif_color_profile_nclx instance Struct.IsStruct Heif_color_profile_nclx

{-| __C declaration:__ @version@

    __defined at:__ @libheif\/heif_color.h 199:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_color_profile_nclx_version" Heif_color_profile_nclx ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_profile_nclx { heif_color_profile_nclx_version = y1
                                  , heif_color_profile_nclx_color_primaries = BG.getField @"heif_color_profile_nclx_color_primaries" x0
                                  , heif_color_profile_nclx_transfer_characteristics = BG.getField @"heif_color_profile_nclx_transfer_characteristics" x0
                                  , heif_color_profile_nclx_matrix_coefficients = BG.getField @"heif_color_profile_nclx_matrix_coefficients" x0
                                  , heif_color_profile_nclx_full_range_flag = BG.getField @"heif_color_profile_nclx_full_range_flag" x0
                                  , heif_color_profile_nclx_color_primary_red_x = BG.getField @"heif_color_profile_nclx_color_primary_red_x" x0
                                  , heif_color_profile_nclx_color_primary_red_y = BG.getField @"heif_color_profile_nclx_color_primary_red_y" x0
                                  , heif_color_profile_nclx_color_primary_green_x = BG.getField @"heif_color_profile_nclx_color_primary_green_x" x0
                                  , heif_color_profile_nclx_color_primary_green_y = BG.getField @"heif_color_profile_nclx_color_primary_green_y" x0
                                  , heif_color_profile_nclx_color_primary_blue_x = BG.getField @"heif_color_profile_nclx_color_primary_blue_x" x0
                                  , heif_color_profile_nclx_color_primary_blue_y = BG.getField @"heif_color_profile_nclx_color_primary_blue_y" x0
                                  , heif_color_profile_nclx_color_primary_white_x = BG.getField @"heif_color_profile_nclx_color_primary_white_x" x0
                                  , heif_color_profile_nclx_color_primary_white_y = BG.getField @"heif_color_profile_nclx_color_primary_white_y" x0
                                  }
      , BG.getField @"heif_color_profile_nclx_version" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_color_profile_nclx_version" (BG.Ptr Heif_color_profile_nclx) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_profile_nclx_version")

instance HasCField.HasCField Heif_color_profile_nclx "heif_color_profile_nclx_version" where

  type CFieldType Heif_color_profile_nclx "heif_color_profile_nclx_version" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @color_primaries@

    __defined at:__ @libheif\/heif_color.h 201:24@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ Heif_color_primaries
         ) => BG.CompatHasField.HasField "heif_color_profile_nclx_color_primaries" Heif_color_profile_nclx ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_profile_nclx { heif_color_profile_nclx_color_primaries = y1
                                  , heif_color_profile_nclx_version = BG.getField @"heif_color_profile_nclx_version" x0
                                  , heif_color_profile_nclx_transfer_characteristics = BG.getField @"heif_color_profile_nclx_transfer_characteristics" x0
                                  , heif_color_profile_nclx_matrix_coefficients = BG.getField @"heif_color_profile_nclx_matrix_coefficients" x0
                                  , heif_color_profile_nclx_full_range_flag = BG.getField @"heif_color_profile_nclx_full_range_flag" x0
                                  , heif_color_profile_nclx_color_primary_red_x = BG.getField @"heif_color_profile_nclx_color_primary_red_x" x0
                                  , heif_color_profile_nclx_color_primary_red_y = BG.getField @"heif_color_profile_nclx_color_primary_red_y" x0
                                  , heif_color_profile_nclx_color_primary_green_x = BG.getField @"heif_color_profile_nclx_color_primary_green_x" x0
                                  , heif_color_profile_nclx_color_primary_green_y = BG.getField @"heif_color_profile_nclx_color_primary_green_y" x0
                                  , heif_color_profile_nclx_color_primary_blue_x = BG.getField @"heif_color_profile_nclx_color_primary_blue_x" x0
                                  , heif_color_profile_nclx_color_primary_blue_y = BG.getField @"heif_color_profile_nclx_color_primary_blue_y" x0
                                  , heif_color_profile_nclx_color_primary_white_x = BG.getField @"heif_color_profile_nclx_color_primary_white_x" x0
                                  , heif_color_profile_nclx_color_primary_white_y = BG.getField @"heif_color_profile_nclx_color_primary_white_y" x0
                                  }
      , BG.getField @"heif_color_profile_nclx_color_primaries" x0
      )

instance ( ty ~ Heif_color_primaries
         ) => BG.HasField "heif_color_profile_nclx_color_primaries" (BG.Ptr Heif_color_profile_nclx) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_profile_nclx_color_primaries")

instance HasCField.HasCField Heif_color_profile_nclx "heif_color_profile_nclx_color_primaries" where

  type CFieldType Heif_color_profile_nclx "heif_color_profile_nclx_color_primaries" =
    Heif_color_primaries

  offset# = \_ -> \_ -> 4

{-| __C declaration:__ @transfer_characteristics@

    __defined at:__ @libheif\/heif_color.h 202:33@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ Heif_transfer_characteristics
         ) => BG.CompatHasField.HasField "heif_color_profile_nclx_transfer_characteristics" Heif_color_profile_nclx ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_profile_nclx { heif_color_profile_nclx_transfer_characteristics = y1
                                  , heif_color_profile_nclx_version = BG.getField @"heif_color_profile_nclx_version" x0
                                  , heif_color_profile_nclx_color_primaries = BG.getField @"heif_color_profile_nclx_color_primaries" x0
                                  , heif_color_profile_nclx_matrix_coefficients = BG.getField @"heif_color_profile_nclx_matrix_coefficients" x0
                                  , heif_color_profile_nclx_full_range_flag = BG.getField @"heif_color_profile_nclx_full_range_flag" x0
                                  , heif_color_profile_nclx_color_primary_red_x = BG.getField @"heif_color_profile_nclx_color_primary_red_x" x0
                                  , heif_color_profile_nclx_color_primary_red_y = BG.getField @"heif_color_profile_nclx_color_primary_red_y" x0
                                  , heif_color_profile_nclx_color_primary_green_x = BG.getField @"heif_color_profile_nclx_color_primary_green_x" x0
                                  , heif_color_profile_nclx_color_primary_green_y = BG.getField @"heif_color_profile_nclx_color_primary_green_y" x0
                                  , heif_color_profile_nclx_color_primary_blue_x = BG.getField @"heif_color_profile_nclx_color_primary_blue_x" x0
                                  , heif_color_profile_nclx_color_primary_blue_y = BG.getField @"heif_color_profile_nclx_color_primary_blue_y" x0
                                  , heif_color_profile_nclx_color_primary_white_x = BG.getField @"heif_color_profile_nclx_color_primary_white_x" x0
                                  , heif_color_profile_nclx_color_primary_white_y = BG.getField @"heif_color_profile_nclx_color_primary_white_y" x0
                                  }
      , BG.getField @"heif_color_profile_nclx_transfer_characteristics" x0
      )

instance ( ty ~ Heif_transfer_characteristics
         ) => BG.HasField "heif_color_profile_nclx_transfer_characteristics" (BG.Ptr Heif_color_profile_nclx) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_profile_nclx_transfer_characteristics")

instance HasCField.HasCField Heif_color_profile_nclx "heif_color_profile_nclx_transfer_characteristics" where

  type CFieldType Heif_color_profile_nclx "heif_color_profile_nclx_transfer_characteristics" =
    Heif_transfer_characteristics

  offset# = \_ -> \_ -> 8

{-| __C declaration:__ @matrix_coefficients@

    __defined at:__ @libheif\/heif_color.h 203:28@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ Heif_matrix_coefficients
         ) => BG.CompatHasField.HasField "heif_color_profile_nclx_matrix_coefficients" Heif_color_profile_nclx ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_profile_nclx { heif_color_profile_nclx_matrix_coefficients = y1
                                  , heif_color_profile_nclx_version = BG.getField @"heif_color_profile_nclx_version" x0
                                  , heif_color_profile_nclx_color_primaries = BG.getField @"heif_color_profile_nclx_color_primaries" x0
                                  , heif_color_profile_nclx_transfer_characteristics = BG.getField @"heif_color_profile_nclx_transfer_characteristics" x0
                                  , heif_color_profile_nclx_full_range_flag = BG.getField @"heif_color_profile_nclx_full_range_flag" x0
                                  , heif_color_profile_nclx_color_primary_red_x = BG.getField @"heif_color_profile_nclx_color_primary_red_x" x0
                                  , heif_color_profile_nclx_color_primary_red_y = BG.getField @"heif_color_profile_nclx_color_primary_red_y" x0
                                  , heif_color_profile_nclx_color_primary_green_x = BG.getField @"heif_color_profile_nclx_color_primary_green_x" x0
                                  , heif_color_profile_nclx_color_primary_green_y = BG.getField @"heif_color_profile_nclx_color_primary_green_y" x0
                                  , heif_color_profile_nclx_color_primary_blue_x = BG.getField @"heif_color_profile_nclx_color_primary_blue_x" x0
                                  , heif_color_profile_nclx_color_primary_blue_y = BG.getField @"heif_color_profile_nclx_color_primary_blue_y" x0
                                  , heif_color_profile_nclx_color_primary_white_x = BG.getField @"heif_color_profile_nclx_color_primary_white_x" x0
                                  , heif_color_profile_nclx_color_primary_white_y = BG.getField @"heif_color_profile_nclx_color_primary_white_y" x0
                                  }
      , BG.getField @"heif_color_profile_nclx_matrix_coefficients" x0
      )

instance ( ty ~ Heif_matrix_coefficients
         ) => BG.HasField "heif_color_profile_nclx_matrix_coefficients" (BG.Ptr Heif_color_profile_nclx) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_profile_nclx_matrix_coefficients")

instance HasCField.HasCField Heif_color_profile_nclx "heif_color_profile_nclx_matrix_coefficients" where

  type CFieldType Heif_color_profile_nclx "heif_color_profile_nclx_matrix_coefficients" =
    Heif_matrix_coefficients

  offset# = \_ -> \_ -> 12

{-| __C declaration:__ @full_range_flag@

    __defined at:__ @libheif\/heif_color.h 204:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_color_profile_nclx_full_range_flag" Heif_color_profile_nclx ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_profile_nclx { heif_color_profile_nclx_full_range_flag = y1
                                  , heif_color_profile_nclx_version = BG.getField @"heif_color_profile_nclx_version" x0
                                  , heif_color_profile_nclx_color_primaries = BG.getField @"heif_color_profile_nclx_color_primaries" x0
                                  , heif_color_profile_nclx_transfer_characteristics = BG.getField @"heif_color_profile_nclx_transfer_characteristics" x0
                                  , heif_color_profile_nclx_matrix_coefficients = BG.getField @"heif_color_profile_nclx_matrix_coefficients" x0
                                  , heif_color_profile_nclx_color_primary_red_x = BG.getField @"heif_color_profile_nclx_color_primary_red_x" x0
                                  , heif_color_profile_nclx_color_primary_red_y = BG.getField @"heif_color_profile_nclx_color_primary_red_y" x0
                                  , heif_color_profile_nclx_color_primary_green_x = BG.getField @"heif_color_profile_nclx_color_primary_green_x" x0
                                  , heif_color_profile_nclx_color_primary_green_y = BG.getField @"heif_color_profile_nclx_color_primary_green_y" x0
                                  , heif_color_profile_nclx_color_primary_blue_x = BG.getField @"heif_color_profile_nclx_color_primary_blue_x" x0
                                  , heif_color_profile_nclx_color_primary_blue_y = BG.getField @"heif_color_profile_nclx_color_primary_blue_y" x0
                                  , heif_color_profile_nclx_color_primary_white_x = BG.getField @"heif_color_profile_nclx_color_primary_white_x" x0
                                  , heif_color_profile_nclx_color_primary_white_y = BG.getField @"heif_color_profile_nclx_color_primary_white_y" x0
                                  }
      , BG.getField @"heif_color_profile_nclx_full_range_flag" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_color_profile_nclx_full_range_flag" (BG.Ptr Heif_color_profile_nclx) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_profile_nclx_full_range_flag")

instance HasCField.HasCField Heif_color_profile_nclx "heif_color_profile_nclx_full_range_flag" where

  type CFieldType Heif_color_profile_nclx "heif_color_profile_nclx_full_range_flag" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 16

{-| __C declaration:__ @color_primary_red_x@

    __defined at:__ @libheif\/heif_color.h 208:9@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CFloat
         ) => BG.CompatHasField.HasField "heif_color_profile_nclx_color_primary_red_x" Heif_color_profile_nclx ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_profile_nclx { heif_color_profile_nclx_color_primary_red_x = y1
                                  , heif_color_profile_nclx_version = BG.getField @"heif_color_profile_nclx_version" x0
                                  , heif_color_profile_nclx_color_primaries = BG.getField @"heif_color_profile_nclx_color_primaries" x0
                                  , heif_color_profile_nclx_transfer_characteristics = BG.getField @"heif_color_profile_nclx_transfer_characteristics" x0
                                  , heif_color_profile_nclx_matrix_coefficients = BG.getField @"heif_color_profile_nclx_matrix_coefficients" x0
                                  , heif_color_profile_nclx_full_range_flag = BG.getField @"heif_color_profile_nclx_full_range_flag" x0
                                  , heif_color_profile_nclx_color_primary_red_y = BG.getField @"heif_color_profile_nclx_color_primary_red_y" x0
                                  , heif_color_profile_nclx_color_primary_green_x = BG.getField @"heif_color_profile_nclx_color_primary_green_x" x0
                                  , heif_color_profile_nclx_color_primary_green_y = BG.getField @"heif_color_profile_nclx_color_primary_green_y" x0
                                  , heif_color_profile_nclx_color_primary_blue_x = BG.getField @"heif_color_profile_nclx_color_primary_blue_x" x0
                                  , heif_color_profile_nclx_color_primary_blue_y = BG.getField @"heif_color_profile_nclx_color_primary_blue_y" x0
                                  , heif_color_profile_nclx_color_primary_white_x = BG.getField @"heif_color_profile_nclx_color_primary_white_x" x0
                                  , heif_color_profile_nclx_color_primary_white_y = BG.getField @"heif_color_profile_nclx_color_primary_white_y" x0
                                  }
      , BG.getField @"heif_color_profile_nclx_color_primary_red_x" x0
      )

instance ( ty ~ BG.CFloat
         ) => BG.HasField "heif_color_profile_nclx_color_primary_red_x" (BG.Ptr Heif_color_profile_nclx) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_profile_nclx_color_primary_red_x")

instance HasCField.HasCField Heif_color_profile_nclx "heif_color_profile_nclx_color_primary_red_x" where

  type CFieldType Heif_color_profile_nclx "heif_color_profile_nclx_color_primary_red_x" =
    BG.CFloat

  offset# = \_ -> \_ -> 20

{-| __C declaration:__ @color_primary_red_y@

    __defined at:__ @libheif\/heif_color.h 208:30@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CFloat
         ) => BG.CompatHasField.HasField "heif_color_profile_nclx_color_primary_red_y" Heif_color_profile_nclx ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_profile_nclx { heif_color_profile_nclx_color_primary_red_y = y1
                                  , heif_color_profile_nclx_version = BG.getField @"heif_color_profile_nclx_version" x0
                                  , heif_color_profile_nclx_color_primaries = BG.getField @"heif_color_profile_nclx_color_primaries" x0
                                  , heif_color_profile_nclx_transfer_characteristics = BG.getField @"heif_color_profile_nclx_transfer_characteristics" x0
                                  , heif_color_profile_nclx_matrix_coefficients = BG.getField @"heif_color_profile_nclx_matrix_coefficients" x0
                                  , heif_color_profile_nclx_full_range_flag = BG.getField @"heif_color_profile_nclx_full_range_flag" x0
                                  , heif_color_profile_nclx_color_primary_red_x = BG.getField @"heif_color_profile_nclx_color_primary_red_x" x0
                                  , heif_color_profile_nclx_color_primary_green_x = BG.getField @"heif_color_profile_nclx_color_primary_green_x" x0
                                  , heif_color_profile_nclx_color_primary_green_y = BG.getField @"heif_color_profile_nclx_color_primary_green_y" x0
                                  , heif_color_profile_nclx_color_primary_blue_x = BG.getField @"heif_color_profile_nclx_color_primary_blue_x" x0
                                  , heif_color_profile_nclx_color_primary_blue_y = BG.getField @"heif_color_profile_nclx_color_primary_blue_y" x0
                                  , heif_color_profile_nclx_color_primary_white_x = BG.getField @"heif_color_profile_nclx_color_primary_white_x" x0
                                  , heif_color_profile_nclx_color_primary_white_y = BG.getField @"heif_color_profile_nclx_color_primary_white_y" x0
                                  }
      , BG.getField @"heif_color_profile_nclx_color_primary_red_y" x0
      )

instance ( ty ~ BG.CFloat
         ) => BG.HasField "heif_color_profile_nclx_color_primary_red_y" (BG.Ptr Heif_color_profile_nclx) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_profile_nclx_color_primary_red_y")

instance HasCField.HasCField Heif_color_profile_nclx "heif_color_profile_nclx_color_primary_red_y" where

  type CFieldType Heif_color_profile_nclx "heif_color_profile_nclx_color_primary_red_y" =
    BG.CFloat

  offset# = \_ -> \_ -> 24

{-| __C declaration:__ @color_primary_green_x@

    __defined at:__ @libheif\/heif_color.h 209:9@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CFloat
         ) => BG.CompatHasField.HasField "heif_color_profile_nclx_color_primary_green_x" Heif_color_profile_nclx ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_profile_nclx { heif_color_profile_nclx_color_primary_green_x = y1
                                  , heif_color_profile_nclx_version = BG.getField @"heif_color_profile_nclx_version" x0
                                  , heif_color_profile_nclx_color_primaries = BG.getField @"heif_color_profile_nclx_color_primaries" x0
                                  , heif_color_profile_nclx_transfer_characteristics = BG.getField @"heif_color_profile_nclx_transfer_characteristics" x0
                                  , heif_color_profile_nclx_matrix_coefficients = BG.getField @"heif_color_profile_nclx_matrix_coefficients" x0
                                  , heif_color_profile_nclx_full_range_flag = BG.getField @"heif_color_profile_nclx_full_range_flag" x0
                                  , heif_color_profile_nclx_color_primary_red_x = BG.getField @"heif_color_profile_nclx_color_primary_red_x" x0
                                  , heif_color_profile_nclx_color_primary_red_y = BG.getField @"heif_color_profile_nclx_color_primary_red_y" x0
                                  , heif_color_profile_nclx_color_primary_green_y = BG.getField @"heif_color_profile_nclx_color_primary_green_y" x0
                                  , heif_color_profile_nclx_color_primary_blue_x = BG.getField @"heif_color_profile_nclx_color_primary_blue_x" x0
                                  , heif_color_profile_nclx_color_primary_blue_y = BG.getField @"heif_color_profile_nclx_color_primary_blue_y" x0
                                  , heif_color_profile_nclx_color_primary_white_x = BG.getField @"heif_color_profile_nclx_color_primary_white_x" x0
                                  , heif_color_profile_nclx_color_primary_white_y = BG.getField @"heif_color_profile_nclx_color_primary_white_y" x0
                                  }
      , BG.getField @"heif_color_profile_nclx_color_primary_green_x" x0
      )

instance ( ty ~ BG.CFloat
         ) => BG.HasField "heif_color_profile_nclx_color_primary_green_x" (BG.Ptr Heif_color_profile_nclx) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_profile_nclx_color_primary_green_x")

instance HasCField.HasCField Heif_color_profile_nclx "heif_color_profile_nclx_color_primary_green_x" where

  type CFieldType Heif_color_profile_nclx "heif_color_profile_nclx_color_primary_green_x" =
    BG.CFloat

  offset# = \_ -> \_ -> 28

{-| __C declaration:__ @color_primary_green_y@

    __defined at:__ @libheif\/heif_color.h 209:32@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CFloat
         ) => BG.CompatHasField.HasField "heif_color_profile_nclx_color_primary_green_y" Heif_color_profile_nclx ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_profile_nclx { heif_color_profile_nclx_color_primary_green_y = y1
                                  , heif_color_profile_nclx_version = BG.getField @"heif_color_profile_nclx_version" x0
                                  , heif_color_profile_nclx_color_primaries = BG.getField @"heif_color_profile_nclx_color_primaries" x0
                                  , heif_color_profile_nclx_transfer_characteristics = BG.getField @"heif_color_profile_nclx_transfer_characteristics" x0
                                  , heif_color_profile_nclx_matrix_coefficients = BG.getField @"heif_color_profile_nclx_matrix_coefficients" x0
                                  , heif_color_profile_nclx_full_range_flag = BG.getField @"heif_color_profile_nclx_full_range_flag" x0
                                  , heif_color_profile_nclx_color_primary_red_x = BG.getField @"heif_color_profile_nclx_color_primary_red_x" x0
                                  , heif_color_profile_nclx_color_primary_red_y = BG.getField @"heif_color_profile_nclx_color_primary_red_y" x0
                                  , heif_color_profile_nclx_color_primary_green_x = BG.getField @"heif_color_profile_nclx_color_primary_green_x" x0
                                  , heif_color_profile_nclx_color_primary_blue_x = BG.getField @"heif_color_profile_nclx_color_primary_blue_x" x0
                                  , heif_color_profile_nclx_color_primary_blue_y = BG.getField @"heif_color_profile_nclx_color_primary_blue_y" x0
                                  , heif_color_profile_nclx_color_primary_white_x = BG.getField @"heif_color_profile_nclx_color_primary_white_x" x0
                                  , heif_color_profile_nclx_color_primary_white_y = BG.getField @"heif_color_profile_nclx_color_primary_white_y" x0
                                  }
      , BG.getField @"heif_color_profile_nclx_color_primary_green_y" x0
      )

instance ( ty ~ BG.CFloat
         ) => BG.HasField "heif_color_profile_nclx_color_primary_green_y" (BG.Ptr Heif_color_profile_nclx) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_profile_nclx_color_primary_green_y")

instance HasCField.HasCField Heif_color_profile_nclx "heif_color_profile_nclx_color_primary_green_y" where

  type CFieldType Heif_color_profile_nclx "heif_color_profile_nclx_color_primary_green_y" =
    BG.CFloat

  offset# = \_ -> \_ -> 32

{-| __C declaration:__ @color_primary_blue_x@

    __defined at:__ @libheif\/heif_color.h 210:9@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CFloat
         ) => BG.CompatHasField.HasField "heif_color_profile_nclx_color_primary_blue_x" Heif_color_profile_nclx ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_profile_nclx { heif_color_profile_nclx_color_primary_blue_x = y1
                                  , heif_color_profile_nclx_version = BG.getField @"heif_color_profile_nclx_version" x0
                                  , heif_color_profile_nclx_color_primaries = BG.getField @"heif_color_profile_nclx_color_primaries" x0
                                  , heif_color_profile_nclx_transfer_characteristics = BG.getField @"heif_color_profile_nclx_transfer_characteristics" x0
                                  , heif_color_profile_nclx_matrix_coefficients = BG.getField @"heif_color_profile_nclx_matrix_coefficients" x0
                                  , heif_color_profile_nclx_full_range_flag = BG.getField @"heif_color_profile_nclx_full_range_flag" x0
                                  , heif_color_profile_nclx_color_primary_red_x = BG.getField @"heif_color_profile_nclx_color_primary_red_x" x0
                                  , heif_color_profile_nclx_color_primary_red_y = BG.getField @"heif_color_profile_nclx_color_primary_red_y" x0
                                  , heif_color_profile_nclx_color_primary_green_x = BG.getField @"heif_color_profile_nclx_color_primary_green_x" x0
                                  , heif_color_profile_nclx_color_primary_green_y = BG.getField @"heif_color_profile_nclx_color_primary_green_y" x0
                                  , heif_color_profile_nclx_color_primary_blue_y = BG.getField @"heif_color_profile_nclx_color_primary_blue_y" x0
                                  , heif_color_profile_nclx_color_primary_white_x = BG.getField @"heif_color_profile_nclx_color_primary_white_x" x0
                                  , heif_color_profile_nclx_color_primary_white_y = BG.getField @"heif_color_profile_nclx_color_primary_white_y" x0
                                  }
      , BG.getField @"heif_color_profile_nclx_color_primary_blue_x" x0
      )

instance ( ty ~ BG.CFloat
         ) => BG.HasField "heif_color_profile_nclx_color_primary_blue_x" (BG.Ptr Heif_color_profile_nclx) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_profile_nclx_color_primary_blue_x")

instance HasCField.HasCField Heif_color_profile_nclx "heif_color_profile_nclx_color_primary_blue_x" where

  type CFieldType Heif_color_profile_nclx "heif_color_profile_nclx_color_primary_blue_x" =
    BG.CFloat

  offset# = \_ -> \_ -> 36

{-| __C declaration:__ @color_primary_blue_y@

    __defined at:__ @libheif\/heif_color.h 210:31@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CFloat
         ) => BG.CompatHasField.HasField "heif_color_profile_nclx_color_primary_blue_y" Heif_color_profile_nclx ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_profile_nclx { heif_color_profile_nclx_color_primary_blue_y = y1
                                  , heif_color_profile_nclx_version = BG.getField @"heif_color_profile_nclx_version" x0
                                  , heif_color_profile_nclx_color_primaries = BG.getField @"heif_color_profile_nclx_color_primaries" x0
                                  , heif_color_profile_nclx_transfer_characteristics = BG.getField @"heif_color_profile_nclx_transfer_characteristics" x0
                                  , heif_color_profile_nclx_matrix_coefficients = BG.getField @"heif_color_profile_nclx_matrix_coefficients" x0
                                  , heif_color_profile_nclx_full_range_flag = BG.getField @"heif_color_profile_nclx_full_range_flag" x0
                                  , heif_color_profile_nclx_color_primary_red_x = BG.getField @"heif_color_profile_nclx_color_primary_red_x" x0
                                  , heif_color_profile_nclx_color_primary_red_y = BG.getField @"heif_color_profile_nclx_color_primary_red_y" x0
                                  , heif_color_profile_nclx_color_primary_green_x = BG.getField @"heif_color_profile_nclx_color_primary_green_x" x0
                                  , heif_color_profile_nclx_color_primary_green_y = BG.getField @"heif_color_profile_nclx_color_primary_green_y" x0
                                  , heif_color_profile_nclx_color_primary_blue_x = BG.getField @"heif_color_profile_nclx_color_primary_blue_x" x0
                                  , heif_color_profile_nclx_color_primary_white_x = BG.getField @"heif_color_profile_nclx_color_primary_white_x" x0
                                  , heif_color_profile_nclx_color_primary_white_y = BG.getField @"heif_color_profile_nclx_color_primary_white_y" x0
                                  }
      , BG.getField @"heif_color_profile_nclx_color_primary_blue_y" x0
      )

instance ( ty ~ BG.CFloat
         ) => BG.HasField "heif_color_profile_nclx_color_primary_blue_y" (BG.Ptr Heif_color_profile_nclx) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_profile_nclx_color_primary_blue_y")

instance HasCField.HasCField Heif_color_profile_nclx "heif_color_profile_nclx_color_primary_blue_y" where

  type CFieldType Heif_color_profile_nclx "heif_color_profile_nclx_color_primary_blue_y" =
    BG.CFloat

  offset# = \_ -> \_ -> 40

{-| __C declaration:__ @color_primary_white_x@

    __defined at:__ @libheif\/heif_color.h 211:9@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CFloat
         ) => BG.CompatHasField.HasField "heif_color_profile_nclx_color_primary_white_x" Heif_color_profile_nclx ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_profile_nclx { heif_color_profile_nclx_color_primary_white_x = y1
                                  , heif_color_profile_nclx_version = BG.getField @"heif_color_profile_nclx_version" x0
                                  , heif_color_profile_nclx_color_primaries = BG.getField @"heif_color_profile_nclx_color_primaries" x0
                                  , heif_color_profile_nclx_transfer_characteristics = BG.getField @"heif_color_profile_nclx_transfer_characteristics" x0
                                  , heif_color_profile_nclx_matrix_coefficients = BG.getField @"heif_color_profile_nclx_matrix_coefficients" x0
                                  , heif_color_profile_nclx_full_range_flag = BG.getField @"heif_color_profile_nclx_full_range_flag" x0
                                  , heif_color_profile_nclx_color_primary_red_x = BG.getField @"heif_color_profile_nclx_color_primary_red_x" x0
                                  , heif_color_profile_nclx_color_primary_red_y = BG.getField @"heif_color_profile_nclx_color_primary_red_y" x0
                                  , heif_color_profile_nclx_color_primary_green_x = BG.getField @"heif_color_profile_nclx_color_primary_green_x" x0
                                  , heif_color_profile_nclx_color_primary_green_y = BG.getField @"heif_color_profile_nclx_color_primary_green_y" x0
                                  , heif_color_profile_nclx_color_primary_blue_x = BG.getField @"heif_color_profile_nclx_color_primary_blue_x" x0
                                  , heif_color_profile_nclx_color_primary_blue_y = BG.getField @"heif_color_profile_nclx_color_primary_blue_y" x0
                                  , heif_color_profile_nclx_color_primary_white_y = BG.getField @"heif_color_profile_nclx_color_primary_white_y" x0
                                  }
      , BG.getField @"heif_color_profile_nclx_color_primary_white_x" x0
      )

instance ( ty ~ BG.CFloat
         ) => BG.HasField "heif_color_profile_nclx_color_primary_white_x" (BG.Ptr Heif_color_profile_nclx) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_profile_nclx_color_primary_white_x")

instance HasCField.HasCField Heif_color_profile_nclx "heif_color_profile_nclx_color_primary_white_x" where

  type CFieldType Heif_color_profile_nclx "heif_color_profile_nclx_color_primary_white_x" =
    BG.CFloat

  offset# = \_ -> \_ -> 44

{-| __C declaration:__ @color_primary_white_y@

    __defined at:__ @libheif\/heif_color.h 211:32@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CFloat
         ) => BG.CompatHasField.HasField "heif_color_profile_nclx_color_primary_white_y" Heif_color_profile_nclx ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_color_profile_nclx { heif_color_profile_nclx_color_primary_white_y = y1
                                  , heif_color_profile_nclx_version = BG.getField @"heif_color_profile_nclx_version" x0
                                  , heif_color_profile_nclx_color_primaries = BG.getField @"heif_color_profile_nclx_color_primaries" x0
                                  , heif_color_profile_nclx_transfer_characteristics = BG.getField @"heif_color_profile_nclx_transfer_characteristics" x0
                                  , heif_color_profile_nclx_matrix_coefficients = BG.getField @"heif_color_profile_nclx_matrix_coefficients" x0
                                  , heif_color_profile_nclx_full_range_flag = BG.getField @"heif_color_profile_nclx_full_range_flag" x0
                                  , heif_color_profile_nclx_color_primary_red_x = BG.getField @"heif_color_profile_nclx_color_primary_red_x" x0
                                  , heif_color_profile_nclx_color_primary_red_y = BG.getField @"heif_color_profile_nclx_color_primary_red_y" x0
                                  , heif_color_profile_nclx_color_primary_green_x = BG.getField @"heif_color_profile_nclx_color_primary_green_x" x0
                                  , heif_color_profile_nclx_color_primary_green_y = BG.getField @"heif_color_profile_nclx_color_primary_green_y" x0
                                  , heif_color_profile_nclx_color_primary_blue_x = BG.getField @"heif_color_profile_nclx_color_primary_blue_x" x0
                                  , heif_color_profile_nclx_color_primary_blue_y = BG.getField @"heif_color_profile_nclx_color_primary_blue_y" x0
                                  , heif_color_profile_nclx_color_primary_white_x = BG.getField @"heif_color_profile_nclx_color_primary_white_x" x0
                                  }
      , BG.getField @"heif_color_profile_nclx_color_primary_white_y" x0
      )

instance ( ty ~ BG.CFloat
         ) => BG.HasField "heif_color_profile_nclx_color_primary_white_y" (BG.Ptr Heif_color_profile_nclx) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_color_profile_nclx_color_primary_white_y")

instance HasCField.HasCField Heif_color_profile_nclx "heif_color_profile_nclx_color_primary_white_y" where

  type CFieldType Heif_color_profile_nclx "heif_color_profile_nclx_color_primary_white_y" =
    BG.CFloat

  offset# = \_ -> \_ -> 48

{-| __C declaration:__ @struct heif_content_light_level@

    __defined at:__ @libheif\/heif_color.h 285:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_content_light_level = Heif_content_light_level
  { heif_content_light_level_max_content_light_level :: HsBindgen.Runtime.LibC.Word16
    {- ^ __C declaration:__ @max_content_light_level@

         __defined at:__ @libheif\/heif_color.h 290:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_content_light_level_max_pic_average_light_level :: HsBindgen.Runtime.LibC.Word16
    {- ^ __C declaration:__ @max_pic_average_light_level@

         __defined at:__ @libheif\/heif_color.h 297:12@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_content_light_level where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (2 :: Int)

instance Marshal.ReadRaw Heif_content_light_level where

  readRaw =
    \ptr0 ->
          pure Heif_content_light_level
      <*> HasCField.readRaw (BG.Proxy @"heif_content_light_level_max_content_light_level") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_content_light_level_max_pic_average_light_level") ptr0

instance Marshal.WriteRaw Heif_content_light_level where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_content_light_level
            heif_content_light_level_max_content_light_level2
            heif_content_light_level_max_pic_average_light_level3 ->
                 HasCField.writeRaw (BG.Proxy @"heif_content_light_level_max_content_light_level") ptr0 heif_content_light_level_max_content_light_level2
              >> HasCField.writeRaw (BG.Proxy @"heif_content_light_level_max_pic_average_light_level") ptr0 heif_content_light_level_max_pic_average_light_level3

deriving via Marshal.EquivStorable Heif_content_light_level instance BG.Storable Heif_content_light_level

deriving via Struct.IsStructViaReadRaw Heif_content_light_level instance Struct.IsStruct Heif_content_light_level

{-| __C declaration:__ @max_content_light_level@

    __defined at:__ @libheif\/heif_color.h 290:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.CompatHasField.HasField "heif_content_light_level_max_content_light_level" Heif_content_light_level ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_content_light_level { heif_content_light_level_max_content_light_level = y1
                                   , heif_content_light_level_max_pic_average_light_level = BG.getField @"heif_content_light_level_max_pic_average_light_level" x0
                                   }
      , BG.getField @"heif_content_light_level_max_content_light_level" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.HasField "heif_content_light_level_max_content_light_level" (BG.Ptr Heif_content_light_level) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_content_light_level_max_content_light_level")

instance HasCField.HasCField Heif_content_light_level "heif_content_light_level_max_content_light_level" where

  type CFieldType Heif_content_light_level "heif_content_light_level_max_content_light_level" =
    HsBindgen.Runtime.LibC.Word16

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @max_pic_average_light_level@

    __defined at:__ @libheif\/heif_color.h 297:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.CompatHasField.HasField "heif_content_light_level_max_pic_average_light_level" Heif_content_light_level ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_content_light_level { heif_content_light_level_max_pic_average_light_level = y1
                                   , heif_content_light_level_max_content_light_level = BG.getField @"heif_content_light_level_max_content_light_level" x0
                                   }
      , BG.getField @"heif_content_light_level_max_pic_average_light_level" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.HasField "heif_content_light_level_max_pic_average_light_level" (BG.Ptr Heif_content_light_level) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_content_light_level_max_pic_average_light_level")

instance HasCField.HasCField Heif_content_light_level "heif_content_light_level_max_pic_average_light_level" where

  type CFieldType Heif_content_light_level "heif_content_light_level_max_pic_average_light_level" =
    HsBindgen.Runtime.LibC.Word16

  offset# = \_ -> \_ -> 2

{-| __C declaration:__ @struct heif_mastering_display_colour_volume@

    __defined at:__ @libheif\/heif_color.h 332:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_mastering_display_colour_volume = Heif_mastering_display_colour_volume
  { heif_mastering_display_colour_volume_display_primaries_x :: CA.ConstantArray 3 HsBindgen.Runtime.LibC.Word16
    {- ^ __C declaration:__ @display_primaries_x@

         __defined at:__ @libheif\/heif_color.h 340:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_mastering_display_colour_volume_display_primaries_y :: CA.ConstantArray 3 HsBindgen.Runtime.LibC.Word16
    {- ^ __C declaration:__ @display_primaries_y@

         __defined at:__ @libheif\/heif_color.h 341:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_mastering_display_colour_volume_white_point_x :: HsBindgen.Runtime.LibC.Word16
    {- ^ __C declaration:__ @white_point_x@

         __defined at:__ @libheif\/heif_color.h 348:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_mastering_display_colour_volume_white_point_y :: HsBindgen.Runtime.LibC.Word16
    {- ^ __C declaration:__ @white_point_y@

         __defined at:__ @libheif\/heif_color.h 349:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_mastering_display_colour_volume_max_display_mastering_luminance :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @max_display_mastering_luminance@

         __defined at:__ @libheif\/heif_color.h 360:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_mastering_display_colour_volume_min_display_mastering_luminance :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @min_display_mastering_luminance@

         __defined at:__ @libheif\/heif_color.h 361:12@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_mastering_display_colour_volume where

  staticSizeOf = \_ -> (24 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_mastering_display_colour_volume where

  readRaw =
    \ptr0 ->
          pure Heif_mastering_display_colour_volume
      <*> HasCField.readRaw (BG.Proxy @"heif_mastering_display_colour_volume_display_primaries_x") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_mastering_display_colour_volume_display_primaries_y") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_mastering_display_colour_volume_white_point_x") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_mastering_display_colour_volume_white_point_y") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_mastering_display_colour_volume_max_display_mastering_luminance") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_mastering_display_colour_volume_min_display_mastering_luminance") ptr0

instance Marshal.WriteRaw Heif_mastering_display_colour_volume where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_mastering_display_colour_volume
            heif_mastering_display_colour_volume_display_primaries_x2
            heif_mastering_display_colour_volume_display_primaries_y3
            heif_mastering_display_colour_volume_white_point_x4
            heif_mastering_display_colour_volume_white_point_y5
            heif_mastering_display_colour_volume_max_display_mastering_luminance6
            heif_mastering_display_colour_volume_min_display_mastering_luminance7 ->
                 HasCField.writeRaw (BG.Proxy @"heif_mastering_display_colour_volume_display_primaries_x") ptr0 heif_mastering_display_colour_volume_display_primaries_x2
              >> HasCField.writeRaw (BG.Proxy @"heif_mastering_display_colour_volume_display_primaries_y") ptr0 heif_mastering_display_colour_volume_display_primaries_y3
              >> HasCField.writeRaw (BG.Proxy @"heif_mastering_display_colour_volume_white_point_x") ptr0 heif_mastering_display_colour_volume_white_point_x4
              >> HasCField.writeRaw (BG.Proxy @"heif_mastering_display_colour_volume_white_point_y") ptr0 heif_mastering_display_colour_volume_white_point_y5
              >> HasCField.writeRaw (BG.Proxy @"heif_mastering_display_colour_volume_max_display_mastering_luminance") ptr0 heif_mastering_display_colour_volume_max_display_mastering_luminance6
              >> HasCField.writeRaw (BG.Proxy @"heif_mastering_display_colour_volume_min_display_mastering_luminance") ptr0 heif_mastering_display_colour_volume_min_display_mastering_luminance7

deriving via Marshal.EquivStorable Heif_mastering_display_colour_volume instance BG.Storable Heif_mastering_display_colour_volume

deriving via Struct.IsStructViaReadRaw Heif_mastering_display_colour_volume instance Struct.IsStruct Heif_mastering_display_colour_volume

{-| __C declaration:__ @display_primaries_x@

    __defined at:__ @libheif\/heif_color.h 340:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ CA.ConstantArray 3 HsBindgen.Runtime.LibC.Word16
         ) => BG.CompatHasField.HasField "heif_mastering_display_colour_volume_display_primaries_x" Heif_mastering_display_colour_volume ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_mastering_display_colour_volume { heif_mastering_display_colour_volume_display_primaries_x = y1
                                               , heif_mastering_display_colour_volume_display_primaries_y = BG.getField @"heif_mastering_display_colour_volume_display_primaries_y" x0
                                               , heif_mastering_display_colour_volume_white_point_x = BG.getField @"heif_mastering_display_colour_volume_white_point_x" x0
                                               , heif_mastering_display_colour_volume_white_point_y = BG.getField @"heif_mastering_display_colour_volume_white_point_y" x0
                                               , heif_mastering_display_colour_volume_max_display_mastering_luminance = BG.getField @"heif_mastering_display_colour_volume_max_display_mastering_luminance" x0
                                               , heif_mastering_display_colour_volume_min_display_mastering_luminance = BG.getField @"heif_mastering_display_colour_volume_min_display_mastering_luminance" x0
                                               }
      , BG.getField @"heif_mastering_display_colour_volume_display_primaries_x" x0
      )

instance ( ty ~ CA.ConstantArray 3 HsBindgen.Runtime.LibC.Word16
         ) => BG.HasField "heif_mastering_display_colour_volume_display_primaries_x" (BG.Ptr Heif_mastering_display_colour_volume) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_mastering_display_colour_volume_display_primaries_x")

instance HasCField.HasCField Heif_mastering_display_colour_volume "heif_mastering_display_colour_volume_display_primaries_x" where

  type CFieldType Heif_mastering_display_colour_volume "heif_mastering_display_colour_volume_display_primaries_x" =
    CA.ConstantArray 3 HsBindgen.Runtime.LibC.Word16

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @display_primaries_y@

    __defined at:__ @libheif\/heif_color.h 341:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ CA.ConstantArray 3 HsBindgen.Runtime.LibC.Word16
         ) => BG.CompatHasField.HasField "heif_mastering_display_colour_volume_display_primaries_y" Heif_mastering_display_colour_volume ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_mastering_display_colour_volume { heif_mastering_display_colour_volume_display_primaries_y = y1
                                               , heif_mastering_display_colour_volume_display_primaries_x = BG.getField @"heif_mastering_display_colour_volume_display_primaries_x" x0
                                               , heif_mastering_display_colour_volume_white_point_x = BG.getField @"heif_mastering_display_colour_volume_white_point_x" x0
                                               , heif_mastering_display_colour_volume_white_point_y = BG.getField @"heif_mastering_display_colour_volume_white_point_y" x0
                                               , heif_mastering_display_colour_volume_max_display_mastering_luminance = BG.getField @"heif_mastering_display_colour_volume_max_display_mastering_luminance" x0
                                               , heif_mastering_display_colour_volume_min_display_mastering_luminance = BG.getField @"heif_mastering_display_colour_volume_min_display_mastering_luminance" x0
                                               }
      , BG.getField @"heif_mastering_display_colour_volume_display_primaries_y" x0
      )

instance ( ty ~ CA.ConstantArray 3 HsBindgen.Runtime.LibC.Word16
         ) => BG.HasField "heif_mastering_display_colour_volume_display_primaries_y" (BG.Ptr Heif_mastering_display_colour_volume) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_mastering_display_colour_volume_display_primaries_y")

instance HasCField.HasCField Heif_mastering_display_colour_volume "heif_mastering_display_colour_volume_display_primaries_y" where

  type CFieldType Heif_mastering_display_colour_volume "heif_mastering_display_colour_volume_display_primaries_y" =
    CA.ConstantArray 3 HsBindgen.Runtime.LibC.Word16

  offset# = \_ -> \_ -> 6

{-| __C declaration:__ @white_point_x@

    __defined at:__ @libheif\/heif_color.h 348:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.CompatHasField.HasField "heif_mastering_display_colour_volume_white_point_x" Heif_mastering_display_colour_volume ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_mastering_display_colour_volume { heif_mastering_display_colour_volume_white_point_x = y1
                                               , heif_mastering_display_colour_volume_display_primaries_x = BG.getField @"heif_mastering_display_colour_volume_display_primaries_x" x0
                                               , heif_mastering_display_colour_volume_display_primaries_y = BG.getField @"heif_mastering_display_colour_volume_display_primaries_y" x0
                                               , heif_mastering_display_colour_volume_white_point_y = BG.getField @"heif_mastering_display_colour_volume_white_point_y" x0
                                               , heif_mastering_display_colour_volume_max_display_mastering_luminance = BG.getField @"heif_mastering_display_colour_volume_max_display_mastering_luminance" x0
                                               , heif_mastering_display_colour_volume_min_display_mastering_luminance = BG.getField @"heif_mastering_display_colour_volume_min_display_mastering_luminance" x0
                                               }
      , BG.getField @"heif_mastering_display_colour_volume_white_point_x" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.HasField "heif_mastering_display_colour_volume_white_point_x" (BG.Ptr Heif_mastering_display_colour_volume) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_mastering_display_colour_volume_white_point_x")

instance HasCField.HasCField Heif_mastering_display_colour_volume "heif_mastering_display_colour_volume_white_point_x" where

  type CFieldType Heif_mastering_display_colour_volume "heif_mastering_display_colour_volume_white_point_x" =
    HsBindgen.Runtime.LibC.Word16

  offset# = \_ -> \_ -> 12

{-| __C declaration:__ @white_point_y@

    __defined at:__ @libheif\/heif_color.h 349:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.CompatHasField.HasField "heif_mastering_display_colour_volume_white_point_y" Heif_mastering_display_colour_volume ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_mastering_display_colour_volume { heif_mastering_display_colour_volume_white_point_y = y1
                                               , heif_mastering_display_colour_volume_display_primaries_x = BG.getField @"heif_mastering_display_colour_volume_display_primaries_x" x0
                                               , heif_mastering_display_colour_volume_display_primaries_y = BG.getField @"heif_mastering_display_colour_volume_display_primaries_y" x0
                                               , heif_mastering_display_colour_volume_white_point_x = BG.getField @"heif_mastering_display_colour_volume_white_point_x" x0
                                               , heif_mastering_display_colour_volume_max_display_mastering_luminance = BG.getField @"heif_mastering_display_colour_volume_max_display_mastering_luminance" x0
                                               , heif_mastering_display_colour_volume_min_display_mastering_luminance = BG.getField @"heif_mastering_display_colour_volume_min_display_mastering_luminance" x0
                                               }
      , BG.getField @"heif_mastering_display_colour_volume_white_point_y" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.HasField "heif_mastering_display_colour_volume_white_point_y" (BG.Ptr Heif_mastering_display_colour_volume) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_mastering_display_colour_volume_white_point_y")

instance HasCField.HasCField Heif_mastering_display_colour_volume "heif_mastering_display_colour_volume_white_point_y" where

  type CFieldType Heif_mastering_display_colour_volume "heif_mastering_display_colour_volume_white_point_y" =
    HsBindgen.Runtime.LibC.Word16

  offset# = \_ -> \_ -> 14

{-| __C declaration:__ @max_display_mastering_luminance@

    __defined at:__ @libheif\/heif_color.h 360:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_mastering_display_colour_volume_max_display_mastering_luminance" Heif_mastering_display_colour_volume ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_mastering_display_colour_volume { heif_mastering_display_colour_volume_max_display_mastering_luminance = y1
                                               , heif_mastering_display_colour_volume_display_primaries_x = BG.getField @"heif_mastering_display_colour_volume_display_primaries_x" x0
                                               , heif_mastering_display_colour_volume_display_primaries_y = BG.getField @"heif_mastering_display_colour_volume_display_primaries_y" x0
                                               , heif_mastering_display_colour_volume_white_point_x = BG.getField @"heif_mastering_display_colour_volume_white_point_x" x0
                                               , heif_mastering_display_colour_volume_white_point_y = BG.getField @"heif_mastering_display_colour_volume_white_point_y" x0
                                               , heif_mastering_display_colour_volume_min_display_mastering_luminance = BG.getField @"heif_mastering_display_colour_volume_min_display_mastering_luminance" x0
                                               }
      , BG.getField @"heif_mastering_display_colour_volume_max_display_mastering_luminance" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_mastering_display_colour_volume_max_display_mastering_luminance" (BG.Ptr Heif_mastering_display_colour_volume) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_mastering_display_colour_volume_max_display_mastering_luminance")

instance HasCField.HasCField Heif_mastering_display_colour_volume "heif_mastering_display_colour_volume_max_display_mastering_luminance" where

  type CFieldType Heif_mastering_display_colour_volume "heif_mastering_display_colour_volume_max_display_mastering_luminance" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 16

{-| __C declaration:__ @min_display_mastering_luminance@

    __defined at:__ @libheif\/heif_color.h 361:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_mastering_display_colour_volume_min_display_mastering_luminance" Heif_mastering_display_colour_volume ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_mastering_display_colour_volume { heif_mastering_display_colour_volume_min_display_mastering_luminance = y1
                                               , heif_mastering_display_colour_volume_display_primaries_x = BG.getField @"heif_mastering_display_colour_volume_display_primaries_x" x0
                                               , heif_mastering_display_colour_volume_display_primaries_y = BG.getField @"heif_mastering_display_colour_volume_display_primaries_y" x0
                                               , heif_mastering_display_colour_volume_white_point_x = BG.getField @"heif_mastering_display_colour_volume_white_point_x" x0
                                               , heif_mastering_display_colour_volume_white_point_y = BG.getField @"heif_mastering_display_colour_volume_white_point_y" x0
                                               , heif_mastering_display_colour_volume_max_display_mastering_luminance = BG.getField @"heif_mastering_display_colour_volume_max_display_mastering_luminance" x0
                                               }
      , BG.getField @"heif_mastering_display_colour_volume_min_display_mastering_luminance" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_mastering_display_colour_volume_min_display_mastering_luminance" (BG.Ptr Heif_mastering_display_colour_volume) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_mastering_display_colour_volume_min_display_mastering_luminance")

instance HasCField.HasCField Heif_mastering_display_colour_volume "heif_mastering_display_colour_volume_min_display_mastering_luminance" where

  type CFieldType Heif_mastering_display_colour_volume "heif_mastering_display_colour_volume_min_display_mastering_luminance" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 20

{-| __C declaration:__ @struct heif_decoded_mastering_display_colour_volume@

    __defined at:__ @libheif\/heif_color.h 365:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_decoded_mastering_display_colour_volume = Heif_decoded_mastering_display_colour_volume
  { heif_decoded_mastering_display_colour_volume_display_primaries_x :: CA.ConstantArray 3 BG.CFloat
    {- ^ __C declaration:__ @display_primaries_x@

         __defined at:__ @libheif\/heif_color.h 367:9@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoded_mastering_display_colour_volume_display_primaries_y :: CA.ConstantArray 3 BG.CFloat
    {- ^ __C declaration:__ @display_primaries_y@

         __defined at:__ @libheif\/heif_color.h 368:9@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoded_mastering_display_colour_volume_white_point_x :: BG.CFloat
    {- ^ __C declaration:__ @white_point_x@

         __defined at:__ @libheif\/heif_color.h 369:9@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoded_mastering_display_colour_volume_white_point_y :: BG.CFloat
    {- ^ __C declaration:__ @white_point_y@

         __defined at:__ @libheif\/heif_color.h 370:9@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance :: BG.CDouble
    {- ^ __C declaration:__ @max_display_mastering_luminance@

         __defined at:__ @libheif\/heif_color.h 371:10@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance :: BG.CDouble
    {- ^ __C declaration:__ @min_display_mastering_luminance@

         __defined at:__ @libheif\/heif_color.h 372:10@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_decoded_mastering_display_colour_volume where

  staticSizeOf = \_ -> (48 :: Int)

  staticAlignment = \_ -> (8 :: Int)

instance Marshal.ReadRaw Heif_decoded_mastering_display_colour_volume where

  readRaw =
    \ptr0 ->
          pure Heif_decoded_mastering_display_colour_volume
      <*> HasCField.readRaw (BG.Proxy @"heif_decoded_mastering_display_colour_volume_display_primaries_x") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoded_mastering_display_colour_volume_display_primaries_y") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoded_mastering_display_colour_volume_white_point_x") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoded_mastering_display_colour_volume_white_point_y") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance") ptr0

instance Marshal.WriteRaw Heif_decoded_mastering_display_colour_volume where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_decoded_mastering_display_colour_volume
            heif_decoded_mastering_display_colour_volume_display_primaries_x2
            heif_decoded_mastering_display_colour_volume_display_primaries_y3
            heif_decoded_mastering_display_colour_volume_white_point_x4
            heif_decoded_mastering_display_colour_volume_white_point_y5
            heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance6
            heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance7 ->
                 HasCField.writeRaw (BG.Proxy @"heif_decoded_mastering_display_colour_volume_display_primaries_x") ptr0 heif_decoded_mastering_display_colour_volume_display_primaries_x2
              >> HasCField.writeRaw (BG.Proxy @"heif_decoded_mastering_display_colour_volume_display_primaries_y") ptr0 heif_decoded_mastering_display_colour_volume_display_primaries_y3
              >> HasCField.writeRaw (BG.Proxy @"heif_decoded_mastering_display_colour_volume_white_point_x") ptr0 heif_decoded_mastering_display_colour_volume_white_point_x4
              >> HasCField.writeRaw (BG.Proxy @"heif_decoded_mastering_display_colour_volume_white_point_y") ptr0 heif_decoded_mastering_display_colour_volume_white_point_y5
              >> HasCField.writeRaw (BG.Proxy @"heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance") ptr0 heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance6
              >> HasCField.writeRaw (BG.Proxy @"heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance") ptr0 heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance7

deriving via Marshal.EquivStorable Heif_decoded_mastering_display_colour_volume instance BG.Storable Heif_decoded_mastering_display_colour_volume

deriving via Struct.IsStructViaReadRaw Heif_decoded_mastering_display_colour_volume instance Struct.IsStruct Heif_decoded_mastering_display_colour_volume

{-| __C declaration:__ @display_primaries_x@

    __defined at:__ @libheif\/heif_color.h 367:9@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ CA.ConstantArray 3 BG.CFloat
         ) => BG.CompatHasField.HasField "heif_decoded_mastering_display_colour_volume_display_primaries_x" Heif_decoded_mastering_display_colour_volume ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoded_mastering_display_colour_volume { heif_decoded_mastering_display_colour_volume_display_primaries_x = y1
                                                       , heif_decoded_mastering_display_colour_volume_display_primaries_y = BG.getField @"heif_decoded_mastering_display_colour_volume_display_primaries_y" x0
                                                       , heif_decoded_mastering_display_colour_volume_white_point_x = BG.getField @"heif_decoded_mastering_display_colour_volume_white_point_x" x0
                                                       , heif_decoded_mastering_display_colour_volume_white_point_y = BG.getField @"heif_decoded_mastering_display_colour_volume_white_point_y" x0
                                                       , heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance = BG.getField @"heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance" x0
                                                       , heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance = BG.getField @"heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance" x0
                                                       }
      , BG.getField @"heif_decoded_mastering_display_colour_volume_display_primaries_x" x0
      )

instance ( ty ~ CA.ConstantArray 3 BG.CFloat
         ) => BG.HasField "heif_decoded_mastering_display_colour_volume_display_primaries_x" (BG.Ptr Heif_decoded_mastering_display_colour_volume) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoded_mastering_display_colour_volume_display_primaries_x")

instance HasCField.HasCField Heif_decoded_mastering_display_colour_volume "heif_decoded_mastering_display_colour_volume_display_primaries_x" where

  type CFieldType Heif_decoded_mastering_display_colour_volume "heif_decoded_mastering_display_colour_volume_display_primaries_x" =
    CA.ConstantArray 3 BG.CFloat

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @display_primaries_y@

    __defined at:__ @libheif\/heif_color.h 368:9@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ CA.ConstantArray 3 BG.CFloat
         ) => BG.CompatHasField.HasField "heif_decoded_mastering_display_colour_volume_display_primaries_y" Heif_decoded_mastering_display_colour_volume ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoded_mastering_display_colour_volume { heif_decoded_mastering_display_colour_volume_display_primaries_y = y1
                                                       , heif_decoded_mastering_display_colour_volume_display_primaries_x = BG.getField @"heif_decoded_mastering_display_colour_volume_display_primaries_x" x0
                                                       , heif_decoded_mastering_display_colour_volume_white_point_x = BG.getField @"heif_decoded_mastering_display_colour_volume_white_point_x" x0
                                                       , heif_decoded_mastering_display_colour_volume_white_point_y = BG.getField @"heif_decoded_mastering_display_colour_volume_white_point_y" x0
                                                       , heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance = BG.getField @"heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance" x0
                                                       , heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance = BG.getField @"heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance" x0
                                                       }
      , BG.getField @"heif_decoded_mastering_display_colour_volume_display_primaries_y" x0
      )

instance ( ty ~ CA.ConstantArray 3 BG.CFloat
         ) => BG.HasField "heif_decoded_mastering_display_colour_volume_display_primaries_y" (BG.Ptr Heif_decoded_mastering_display_colour_volume) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoded_mastering_display_colour_volume_display_primaries_y")

instance HasCField.HasCField Heif_decoded_mastering_display_colour_volume "heif_decoded_mastering_display_colour_volume_display_primaries_y" where

  type CFieldType Heif_decoded_mastering_display_colour_volume "heif_decoded_mastering_display_colour_volume_display_primaries_y" =
    CA.ConstantArray 3 BG.CFloat

  offset# = \_ -> \_ -> 12

{-| __C declaration:__ @white_point_x@

    __defined at:__ @libheif\/heif_color.h 369:9@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CFloat
         ) => BG.CompatHasField.HasField "heif_decoded_mastering_display_colour_volume_white_point_x" Heif_decoded_mastering_display_colour_volume ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoded_mastering_display_colour_volume { heif_decoded_mastering_display_colour_volume_white_point_x = y1
                                                       , heif_decoded_mastering_display_colour_volume_display_primaries_x = BG.getField @"heif_decoded_mastering_display_colour_volume_display_primaries_x" x0
                                                       , heif_decoded_mastering_display_colour_volume_display_primaries_y = BG.getField @"heif_decoded_mastering_display_colour_volume_display_primaries_y" x0
                                                       , heif_decoded_mastering_display_colour_volume_white_point_y = BG.getField @"heif_decoded_mastering_display_colour_volume_white_point_y" x0
                                                       , heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance = BG.getField @"heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance" x0
                                                       , heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance = BG.getField @"heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance" x0
                                                       }
      , BG.getField @"heif_decoded_mastering_display_colour_volume_white_point_x" x0
      )

instance ( ty ~ BG.CFloat
         ) => BG.HasField "heif_decoded_mastering_display_colour_volume_white_point_x" (BG.Ptr Heif_decoded_mastering_display_colour_volume) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoded_mastering_display_colour_volume_white_point_x")

instance HasCField.HasCField Heif_decoded_mastering_display_colour_volume "heif_decoded_mastering_display_colour_volume_white_point_x" where

  type CFieldType Heif_decoded_mastering_display_colour_volume "heif_decoded_mastering_display_colour_volume_white_point_x" =
    BG.CFloat

  offset# = \_ -> \_ -> 24

{-| __C declaration:__ @white_point_y@

    __defined at:__ @libheif\/heif_color.h 370:9@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CFloat
         ) => BG.CompatHasField.HasField "heif_decoded_mastering_display_colour_volume_white_point_y" Heif_decoded_mastering_display_colour_volume ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoded_mastering_display_colour_volume { heif_decoded_mastering_display_colour_volume_white_point_y = y1
                                                       , heif_decoded_mastering_display_colour_volume_display_primaries_x = BG.getField @"heif_decoded_mastering_display_colour_volume_display_primaries_x" x0
                                                       , heif_decoded_mastering_display_colour_volume_display_primaries_y = BG.getField @"heif_decoded_mastering_display_colour_volume_display_primaries_y" x0
                                                       , heif_decoded_mastering_display_colour_volume_white_point_x = BG.getField @"heif_decoded_mastering_display_colour_volume_white_point_x" x0
                                                       , heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance = BG.getField @"heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance" x0
                                                       , heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance = BG.getField @"heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance" x0
                                                       }
      , BG.getField @"heif_decoded_mastering_display_colour_volume_white_point_y" x0
      )

instance ( ty ~ BG.CFloat
         ) => BG.HasField "heif_decoded_mastering_display_colour_volume_white_point_y" (BG.Ptr Heif_decoded_mastering_display_colour_volume) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoded_mastering_display_colour_volume_white_point_y")

instance HasCField.HasCField Heif_decoded_mastering_display_colour_volume "heif_decoded_mastering_display_colour_volume_white_point_y" where

  type CFieldType Heif_decoded_mastering_display_colour_volume "heif_decoded_mastering_display_colour_volume_white_point_y" =
    BG.CFloat

  offset# = \_ -> \_ -> 28

{-| __C declaration:__ @max_display_mastering_luminance@

    __defined at:__ @libheif\/heif_color.h 371:10@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CDouble
         ) => BG.CompatHasField.HasField "heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance" Heif_decoded_mastering_display_colour_volume ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoded_mastering_display_colour_volume { heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance = y1
                                                       , heif_decoded_mastering_display_colour_volume_display_primaries_x = BG.getField @"heif_decoded_mastering_display_colour_volume_display_primaries_x" x0
                                                       , heif_decoded_mastering_display_colour_volume_display_primaries_y = BG.getField @"heif_decoded_mastering_display_colour_volume_display_primaries_y" x0
                                                       , heif_decoded_mastering_display_colour_volume_white_point_x = BG.getField @"heif_decoded_mastering_display_colour_volume_white_point_x" x0
                                                       , heif_decoded_mastering_display_colour_volume_white_point_y = BG.getField @"heif_decoded_mastering_display_colour_volume_white_point_y" x0
                                                       , heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance = BG.getField @"heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance" x0
                                                       }
      , BG.getField @"heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance" x0
      )

instance ( ty ~ BG.CDouble
         ) => BG.HasField "heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance" (BG.Ptr Heif_decoded_mastering_display_colour_volume) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance")

instance HasCField.HasCField Heif_decoded_mastering_display_colour_volume "heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance" where

  type CFieldType Heif_decoded_mastering_display_colour_volume "heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance" =
    BG.CDouble

  offset# = \_ -> \_ -> 32

{-| __C declaration:__ @min_display_mastering_luminance@

    __defined at:__ @libheif\/heif_color.h 372:10@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CDouble
         ) => BG.CompatHasField.HasField "heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance" Heif_decoded_mastering_display_colour_volume ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoded_mastering_display_colour_volume { heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance = y1
                                                       , heif_decoded_mastering_display_colour_volume_display_primaries_x = BG.getField @"heif_decoded_mastering_display_colour_volume_display_primaries_x" x0
                                                       , heif_decoded_mastering_display_colour_volume_display_primaries_y = BG.getField @"heif_decoded_mastering_display_colour_volume_display_primaries_y" x0
                                                       , heif_decoded_mastering_display_colour_volume_white_point_x = BG.getField @"heif_decoded_mastering_display_colour_volume_white_point_x" x0
                                                       , heif_decoded_mastering_display_colour_volume_white_point_y = BG.getField @"heif_decoded_mastering_display_colour_volume_white_point_y" x0
                                                       , heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance = BG.getField @"heif_decoded_mastering_display_colour_volume_max_display_mastering_luminance" x0
                                                       }
      , BG.getField @"heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance" x0
      )

instance ( ty ~ BG.CDouble
         ) => BG.HasField "heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance" (BG.Ptr Heif_decoded_mastering_display_colour_volume) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance")

instance HasCField.HasCField Heif_decoded_mastering_display_colour_volume "heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance" where

  type CFieldType Heif_decoded_mastering_display_colour_volume "heif_decoded_mastering_display_colour_volume_min_display_mastering_luminance" =
    BG.CDouble

  offset# = \_ -> \_ -> 40

{-| __C declaration:__ @struct heif_ambient_viewing_environment@

    __defined at:__ @libheif\/heif_color.h 378:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_ambient_viewing_environment = Heif_ambient_viewing_environment
  { heif_ambient_viewing_environment_ambient_illumination :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @ambient_illumination@

         __defined at:__ @libheif\/heif_color.h 384:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_ambient_viewing_environment_ambient_light_x :: HsBindgen.Runtime.LibC.Word16
    {- ^ __C declaration:__ @ambient_light_x@

         __defined at:__ @libheif\/heif_color.h 393:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_ambient_viewing_environment_ambient_light_y :: HsBindgen.Runtime.LibC.Word16
    {- ^ __C declaration:__ @ambient_light_y@

         __defined at:__ @libheif\/heif_color.h 394:12@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_ambient_viewing_environment where

  staticSizeOf = \_ -> (8 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_ambient_viewing_environment where

  readRaw =
    \ptr0 ->
          pure Heif_ambient_viewing_environment
      <*> HasCField.readRaw (BG.Proxy @"heif_ambient_viewing_environment_ambient_illumination") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_ambient_viewing_environment_ambient_light_x") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_ambient_viewing_environment_ambient_light_y") ptr0

instance Marshal.WriteRaw Heif_ambient_viewing_environment where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_ambient_viewing_environment
            heif_ambient_viewing_environment_ambient_illumination2
            heif_ambient_viewing_environment_ambient_light_x3
            heif_ambient_viewing_environment_ambient_light_y4 ->
                 HasCField.writeRaw (BG.Proxy @"heif_ambient_viewing_environment_ambient_illumination") ptr0 heif_ambient_viewing_environment_ambient_illumination2
              >> HasCField.writeRaw (BG.Proxy @"heif_ambient_viewing_environment_ambient_light_x") ptr0 heif_ambient_viewing_environment_ambient_light_x3
              >> HasCField.writeRaw (BG.Proxy @"heif_ambient_viewing_environment_ambient_light_y") ptr0 heif_ambient_viewing_environment_ambient_light_y4

deriving via Marshal.EquivStorable Heif_ambient_viewing_environment instance BG.Storable Heif_ambient_viewing_environment

deriving via Struct.IsStructViaReadRaw Heif_ambient_viewing_environment instance Struct.IsStruct Heif_ambient_viewing_environment

{-| __C declaration:__ @ambient_illumination@

    __defined at:__ @libheif\/heif_color.h 384:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_ambient_viewing_environment_ambient_illumination" Heif_ambient_viewing_environment ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_ambient_viewing_environment { heif_ambient_viewing_environment_ambient_illumination = y1
                                           , heif_ambient_viewing_environment_ambient_light_x = BG.getField @"heif_ambient_viewing_environment_ambient_light_x" x0
                                           , heif_ambient_viewing_environment_ambient_light_y = BG.getField @"heif_ambient_viewing_environment_ambient_light_y" x0
                                           }
      , BG.getField @"heif_ambient_viewing_environment_ambient_illumination" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_ambient_viewing_environment_ambient_illumination" (BG.Ptr Heif_ambient_viewing_environment) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_ambient_viewing_environment_ambient_illumination")

instance HasCField.HasCField Heif_ambient_viewing_environment "heif_ambient_viewing_environment_ambient_illumination" where

  type CFieldType Heif_ambient_viewing_environment "heif_ambient_viewing_environment_ambient_illumination" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @ambient_light_x@

    __defined at:__ @libheif\/heif_color.h 393:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.CompatHasField.HasField "heif_ambient_viewing_environment_ambient_light_x" Heif_ambient_viewing_environment ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_ambient_viewing_environment { heif_ambient_viewing_environment_ambient_light_x = y1
                                           , heif_ambient_viewing_environment_ambient_illumination = BG.getField @"heif_ambient_viewing_environment_ambient_illumination" x0
                                           , heif_ambient_viewing_environment_ambient_light_y = BG.getField @"heif_ambient_viewing_environment_ambient_light_y" x0
                                           }
      , BG.getField @"heif_ambient_viewing_environment_ambient_light_x" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.HasField "heif_ambient_viewing_environment_ambient_light_x" (BG.Ptr Heif_ambient_viewing_environment) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_ambient_viewing_environment_ambient_light_x")

instance HasCField.HasCField Heif_ambient_viewing_environment "heif_ambient_viewing_environment_ambient_light_x" where

  type CFieldType Heif_ambient_viewing_environment "heif_ambient_viewing_environment_ambient_light_x" =
    HsBindgen.Runtime.LibC.Word16

  offset# = \_ -> \_ -> 4

{-| __C declaration:__ @ambient_light_y@

    __defined at:__ @libheif\/heif_color.h 394:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.CompatHasField.HasField "heif_ambient_viewing_environment_ambient_light_y" Heif_ambient_viewing_environment ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_ambient_viewing_environment { heif_ambient_viewing_environment_ambient_light_y = y1
                                           , heif_ambient_viewing_environment_ambient_illumination = BG.getField @"heif_ambient_viewing_environment_ambient_illumination" x0
                                           , heif_ambient_viewing_environment_ambient_light_x = BG.getField @"heif_ambient_viewing_environment_ambient_light_x" x0
                                           }
      , BG.getField @"heif_ambient_viewing_environment_ambient_light_y" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.HasField "heif_ambient_viewing_environment_ambient_light_y" (BG.Ptr Heif_ambient_viewing_environment) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_ambient_viewing_environment_ambient_light_y")

instance HasCField.HasCField Heif_ambient_viewing_environment "heif_ambient_viewing_environment_ambient_light_y" where

  type CFieldType Heif_ambient_viewing_environment "heif_ambient_viewing_environment_ambient_light_y" =
    HsBindgen.Runtime.LibC.Word16

  offset# = \_ -> \_ -> 6

{-| __C declaration:__ @heif_brand2@

    __defined at:__ @libheif\/heif_brands.h 35:18@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_brand2 = Heif_brand2
  { unwrapHeif_brand2 :: HsBindgen.Runtime.LibC.Word32
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "unwrapHeif_brand2" Heif_brand2 ty where

  hasField =
    \x0 ->
      ( \y1 -> Heif_brand2 {unwrapHeif_brand2 = y1}
      , BG.getField @"unwrapHeif_brand2" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "unwrapHeif_brand2" (BG.Ptr Heif_brand2) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_brand2")

instance HasCField.HasCField Heif_brand2 "unwrapHeif_brand2" where

  type CFieldType Heif_brand2 "unwrapHeif_brand2" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @enum heif_filetype_result@

    __defined at:__ @libheif\/heif_brands.h 323:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_filetype_result = Heif_filetype_result
  { unwrapHeif_filetype_result :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_filetype_result where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_filetype_result where

  readRaw =
    \ptr0 ->
          pure Heif_filetype_result
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_filetype_result where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_filetype_result unwrapHeif_filetype_result2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_filetype_result2

deriving via Marshal.EquivStorable Heif_filetype_result instance BG.Storable Heif_filetype_result

deriving via BG.CUInt instance BG.Prim Heif_filetype_result

instance CEnum.CEnum Heif_filetype_result where

  type CEnumZ Heif_filetype_result = BG.CUInt

  toCEnum = Heif_filetype_result

  fromCEnum = BG.getField @"unwrapHeif_filetype_result"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_filetype_no")
                                   , (1, BG.singleton "Heif_filetype_yes_supported")
                                   , (2, BG.singleton "Heif_filetype_yes_unsupported")
                                   , (3, BG.singleton "Heif_filetype_maybe")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_filetype_result"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_filetype_result"

  isDeclared = CEnum.seqIsDeclared

  mkDeclared = CEnum.seqMkDeclared

instance CEnum.SequentialCEnum Heif_filetype_result where

  minDeclaredValue = Heif_filetype_no

  maxDeclaredValue = Heif_filetype_maybe

instance Show Heif_filetype_result where

  showsPrec = CEnum.shows

instance Read Heif_filetype_result where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_filetype_result" Heif_filetype_result ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_filetype_result {unwrapHeif_filetype_result = y1}
      , BG.getField @"unwrapHeif_filetype_result" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_filetype_result" (BG.Ptr Heif_filetype_result) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_filetype_result")

instance HasCField.HasCField Heif_filetype_result "unwrapHeif_filetype_result" where

  type CFieldType Heif_filetype_result "unwrapHeif_filetype_result" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_filetype_no@

    __defined at:__ @libheif\/heif_brands.h 325:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_filetype_no :: Heif_filetype_result
pattern Heif_filetype_no = Heif_filetype_result 0

{-| __C declaration:__ @heif_filetype_yes_supported@

    __defined at:__ @libheif\/heif_brands.h 326:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_filetype_yes_supported :: Heif_filetype_result
pattern Heif_filetype_yes_supported = Heif_filetype_result 1

{-| __C declaration:__ @heif_filetype_yes_unsupported@

    __defined at:__ @libheif\/heif_brands.h 327:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_filetype_yes_unsupported :: Heif_filetype_result
pattern Heif_filetype_yes_unsupported = Heif_filetype_result 2

{-| __C declaration:__ @heif_filetype_maybe@

    __defined at:__ @libheif\/heif_brands.h 328:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_filetype_maybe :: Heif_filetype_result
pattern Heif_filetype_maybe = Heif_filetype_result 3

{-| __C declaration:__ @enum heif_brand@

    __defined at:__ @libheif\/heif_brands.h 354:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_brand = Heif_brand
  { unwrapHeif_brand :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_brand where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_brand where

  readRaw =
    \ptr0 ->
          pure Heif_brand
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_brand where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_brand unwrapHeif_brand2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_brand2

deriving via Marshal.EquivStorable Heif_brand instance BG.Storable Heif_brand

deriving via BG.CUInt instance BG.Prim Heif_brand

instance CEnum.CEnum Heif_brand where

  type CEnumZ Heif_brand = BG.CUInt

  toCEnum = Heif_brand

  fromCEnum = BG.getField @"unwrapHeif_brand"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_unknown_brand")
                                   , (1, BG.singleton "Heif_heic")
                                   , (2, BG.singleton "Heif_heix")
                                   , (3, BG.singleton "Heif_hevc")
                                   , (4, BG.singleton "Heif_hevx")
                                   , (5, BG.singleton "Heif_heim")
                                   , (6, BG.singleton "Heif_heis")
                                   , (7, BG.singleton "Heif_hevm")
                                   , (8, BG.singleton "Heif_hevs")
                                   , (9, BG.singleton "Heif_mif1")
                                   , (10, BG.singleton "Heif_msf1")
                                   , (11, BG.singleton "Heif_avif")
                                   , (12, BG.singleton "Heif_avis")
                                   , (13, BG.singleton "Heif_vvic")
                                   , (14, BG.singleton "Heif_vvis")
                                   , (15, BG.singleton "Heif_evbi")
                                   , (16, BG.singleton "Heif_evbs")
                                   , (17, BG.singleton "Heif_j2ki")
                                   , (18, BG.singleton "Heif_j2is")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_brand"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_brand"

  isDeclared = CEnum.seqIsDeclared

  mkDeclared = CEnum.seqMkDeclared

instance CEnum.SequentialCEnum Heif_brand where

  minDeclaredValue = Heif_unknown_brand

  maxDeclaredValue = Heif_j2is

instance Show Heif_brand where

  showsPrec = CEnum.shows

instance Read Heif_brand where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_brand" Heif_brand ty where

  hasField =
    \x0 ->
      ( \y1 -> Heif_brand {unwrapHeif_brand = y1}
      , BG.getField @"unwrapHeif_brand" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_brand" (BG.Ptr Heif_brand) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_brand")

instance HasCField.HasCField Heif_brand "unwrapHeif_brand" where

  type CFieldType Heif_brand "unwrapHeif_brand" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_unknown_brand@

    __defined at:__ @libheif\/heif_brands.h 356:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_unknown_brand :: Heif_brand
pattern Heif_unknown_brand = Heif_brand 0

{-| __C declaration:__ @heif_heic@

    __defined at:__ @libheif\/heif_brands.h 357:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_heic :: Heif_brand
pattern Heif_heic = Heif_brand 1

{-| __C declaration:__ @heif_heix@

    __defined at:__ @libheif\/heif_brands.h 358:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_heix :: Heif_brand
pattern Heif_heix = Heif_brand 2

{-| __C declaration:__ @heif_hevc@

    __defined at:__ @libheif\/heif_brands.h 359:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_hevc :: Heif_brand
pattern Heif_hevc = Heif_brand 3

{-| __C declaration:__ @heif_hevx@

    __defined at:__ @libheif\/heif_brands.h 359:14@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_hevx :: Heif_brand
pattern Heif_hevx = Heif_brand 4

{-| __C declaration:__ @heif_heim@

    __defined at:__ @libheif\/heif_brands.h 360:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_heim :: Heif_brand
pattern Heif_heim = Heif_brand 5

{-| __C declaration:__ @heif_heis@

    __defined at:__ @libheif\/heif_brands.h 361:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_heis :: Heif_brand
pattern Heif_heis = Heif_brand 6

{-| __C declaration:__ @heif_hevm@

    __defined at:__ @libheif\/heif_brands.h 362:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_hevm :: Heif_brand
pattern Heif_hevm = Heif_brand 7

{-| __C declaration:__ @heif_hevs@

    __defined at:__ @libheif\/heif_brands.h 363:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_hevs :: Heif_brand
pattern Heif_hevs = Heif_brand 8

{-| __C declaration:__ @heif_mif1@

    __defined at:__ @libheif\/heif_brands.h 364:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_mif1 :: Heif_brand
pattern Heif_mif1 = Heif_brand 9

{-| __C declaration:__ @heif_msf1@

    __defined at:__ @libheif\/heif_brands.h 365:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_msf1 :: Heif_brand
pattern Heif_msf1 = Heif_brand 10

{-| __C declaration:__ @heif_avif@

    __defined at:__ @libheif\/heif_brands.h 366:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_avif :: Heif_brand
pattern Heif_avif = Heif_brand 11

{-| __C declaration:__ @heif_avis@

    __defined at:__ @libheif\/heif_brands.h 367:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_avis :: Heif_brand
pattern Heif_avis = Heif_brand 12

{-| __C declaration:__ @heif_vvic@

    __defined at:__ @libheif\/heif_brands.h 368:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_vvic :: Heif_brand
pattern Heif_vvic = Heif_brand 13

{-| __C declaration:__ @heif_vvis@

    __defined at:__ @libheif\/heif_brands.h 369:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_vvis :: Heif_brand
pattern Heif_vvis = Heif_brand 14

{-| __C declaration:__ @heif_evbi@

    __defined at:__ @libheif\/heif_brands.h 370:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_evbi :: Heif_brand
pattern Heif_evbi = Heif_brand 15

{-| __C declaration:__ @heif_evbs@

    __defined at:__ @libheif\/heif_brands.h 371:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_evbs :: Heif_brand
pattern Heif_evbs = Heif_brand 16

{-| __C declaration:__ @heif_j2ki@

    __defined at:__ @libheif\/heif_brands.h 372:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_j2ki :: Heif_brand
pattern Heif_j2ki = Heif_brand 17

{-| __C declaration:__ @heif_j2is@

    __defined at:__ @libheif\/heif_brands.h 373:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_j2is :: Heif_brand
pattern Heif_j2is = Heif_brand 18

{-| __C declaration:__ @enum heif_metadata_compression@

    __defined at:__ @libheif\/heif_metadata.h 31:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_metadata_compression = Heif_metadata_compression
  { unwrapHeif_metadata_compression :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_metadata_compression where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_metadata_compression where

  readRaw =
    \ptr0 ->
          pure Heif_metadata_compression
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_metadata_compression where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_metadata_compression unwrapHeif_metadata_compression2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_metadata_compression2

deriving via Marshal.EquivStorable Heif_metadata_compression instance BG.Storable Heif_metadata_compression

deriving via BG.CUInt instance BG.Prim Heif_metadata_compression

instance CEnum.CEnum Heif_metadata_compression where

  type CEnumZ Heif_metadata_compression = BG.CUInt

  toCEnum = Heif_metadata_compression

  fromCEnum =
    BG.getField @"unwrapHeif_metadata_compression"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_metadata_compression_off")
                                   , (1, BG.singleton "Heif_metadata_compression_auto")
                                   , (2, BG.singleton "Heif_metadata_compression_unknown")
                                   , (3, BG.singleton "Heif_metadata_compression_deflate")
                                   , (4, BG.singleton "Heif_metadata_compression_zlib")
                                   , (5, BG.singleton "Heif_metadata_compression_brotli")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_metadata_compression"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_metadata_compression"

  isDeclared = CEnum.seqIsDeclared

  mkDeclared = CEnum.seqMkDeclared

instance CEnum.SequentialCEnum Heif_metadata_compression where

  minDeclaredValue = Heif_metadata_compression_off

  maxDeclaredValue = Heif_metadata_compression_brotli

instance Show Heif_metadata_compression where

  showsPrec = CEnum.shows

instance Read Heif_metadata_compression where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_metadata_compression" Heif_metadata_compression ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_metadata_compression {unwrapHeif_metadata_compression = y1}
      , BG.getField @"unwrapHeif_metadata_compression" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_metadata_compression" (BG.Ptr Heif_metadata_compression) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_metadata_compression")

instance HasCField.HasCField Heif_metadata_compression "unwrapHeif_metadata_compression" where

  type CFieldType Heif_metadata_compression "unwrapHeif_metadata_compression" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_metadata_compression_off@

    __defined at:__ @libheif\/heif_metadata.h 33:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_metadata_compression_off :: Heif_metadata_compression
pattern Heif_metadata_compression_off = Heif_metadata_compression 0

{-| __C declaration:__ @heif_metadata_compression_auto@

    __defined at:__ @libheif\/heif_metadata.h 34:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_metadata_compression_auto :: Heif_metadata_compression
pattern Heif_metadata_compression_auto = Heif_metadata_compression 1

{-| __C declaration:__ @heif_metadata_compression_unknown@

    __defined at:__ @libheif\/heif_metadata.h 35:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_metadata_compression_unknown :: Heif_metadata_compression
pattern Heif_metadata_compression_unknown = Heif_metadata_compression 2

{-| __C declaration:__ @heif_metadata_compression_deflate@

    __defined at:__ @libheif\/heif_metadata.h 36:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_metadata_compression_deflate :: Heif_metadata_compression
pattern Heif_metadata_compression_deflate = Heif_metadata_compression 3

{-| __C declaration:__ @heif_metadata_compression_zlib@

    __defined at:__ @libheif\/heif_metadata.h 37:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_metadata_compression_zlib :: Heif_metadata_compression
pattern Heif_metadata_compression_zlib = Heif_metadata_compression 4

{-| __C declaration:__ @heif_metadata_compression_brotli@

    __defined at:__ @libheif\/heif_metadata.h 38:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_metadata_compression_brotli :: Heif_metadata_compression
pattern Heif_metadata_compression_brotli = Heif_metadata_compression 5

{-| __C declaration:__ @struct heif_encoder@

    __defined at:__ @libheif\/heif_aux_images.h 32:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_encoder

{-| __C declaration:__ @enum heif_depth_representation_type@

    __defined at:__ @libheif\/heif_aux_images.h 54:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_depth_representation_type = Heif_depth_representation_type
  { unwrapHeif_depth_representation_type :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_depth_representation_type where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_depth_representation_type where

  readRaw =
    \ptr0 ->
          pure Heif_depth_representation_type
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_depth_representation_type where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_depth_representation_type unwrapHeif_depth_representation_type2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_depth_representation_type2

deriving via Marshal.EquivStorable Heif_depth_representation_type instance BG.Storable Heif_depth_representation_type

deriving via BG.CUInt instance BG.Prim Heif_depth_representation_type

instance CEnum.CEnum Heif_depth_representation_type where

  type CEnumZ Heif_depth_representation_type = BG.CUInt

  toCEnum = Heif_depth_representation_type

  fromCEnum =
    BG.getField @"unwrapHeif_depth_representation_type"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_depth_representation_type_uniform_inverse_Z")
                                   , (1, BG.singleton "Heif_depth_representation_type_uniform_disparity")
                                   , (2, BG.singleton "Heif_depth_representation_type_uniform_Z")
                                   , (3, BG.singleton "Heif_depth_representation_type_nonuniform_disparity")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_depth_representation_type"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_depth_representation_type"

  isDeclared = CEnum.seqIsDeclared

  mkDeclared = CEnum.seqMkDeclared

instance CEnum.SequentialCEnum Heif_depth_representation_type where

  minDeclaredValue =
    Heif_depth_representation_type_uniform_inverse_Z

  maxDeclaredValue =
    Heif_depth_representation_type_nonuniform_disparity

instance Show Heif_depth_representation_type where

  showsPrec = CEnum.shows

instance Read Heif_depth_representation_type where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_depth_representation_type" Heif_depth_representation_type ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_depth_representation_type {unwrapHeif_depth_representation_type = y1}
      , BG.getField @"unwrapHeif_depth_representation_type" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_depth_representation_type" (BG.Ptr Heif_depth_representation_type) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_depth_representation_type")

instance HasCField.HasCField Heif_depth_representation_type "unwrapHeif_depth_representation_type" where

  type CFieldType Heif_depth_representation_type "unwrapHeif_depth_representation_type" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_depth_representation_type_uniform_inverse_Z@

    __defined at:__ @libheif\/heif_aux_images.h 55:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_depth_representation_type_uniform_inverse_Z :: Heif_depth_representation_type
pattern Heif_depth_representation_type_uniform_inverse_Z = Heif_depth_representation_type 0

{-| __C declaration:__ @heif_depth_representation_type_uniform_disparity@

    __defined at:__ @libheif\/heif_aux_images.h 56:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_depth_representation_type_uniform_disparity :: Heif_depth_representation_type
pattern Heif_depth_representation_type_uniform_disparity = Heif_depth_representation_type 1

{-| __C declaration:__ @heif_depth_representation_type_uniform_Z@

    __defined at:__ @libheif\/heif_aux_images.h 57:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_depth_representation_type_uniform_Z :: Heif_depth_representation_type
pattern Heif_depth_representation_type_uniform_Z = Heif_depth_representation_type 2

{-| __C declaration:__ @heif_depth_representation_type_nonuniform_disparity@

    __defined at:__ @libheif\/heif_aux_images.h 58:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_depth_representation_type_nonuniform_disparity :: Heif_depth_representation_type
pattern Heif_depth_representation_type_nonuniform_disparity = Heif_depth_representation_type 3

{-| __C declaration:__ @struct heif_depth_representation_info@

    __defined at:__ @libheif\/heif_aux_images.h 61:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_depth_representation_info = Heif_depth_representation_info
  { heif_depth_representation_info_version :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @version@

         __defined at:__ @libheif\/heif_aux_images.h 62:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_depth_representation_info_has_z_near :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @has_z_near@

         __defined at:__ @libheif\/heif_aux_images.h 66:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_depth_representation_info_has_z_far :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @has_z_far@

         __defined at:__ @libheif\/heif_aux_images.h 67:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_depth_representation_info_has_d_min :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @has_d_min@

         __defined at:__ @libheif\/heif_aux_images.h 68:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_depth_representation_info_has_d_max :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @has_d_max@

         __defined at:__ @libheif\/heif_aux_images.h 69:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_depth_representation_info_z_near :: BG.CDouble
    {- ^ __C declaration:__ @z_near@

         __defined at:__ @libheif\/heif_aux_images.h 71:10@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_depth_representation_info_z_far :: BG.CDouble
    {- ^ __C declaration:__ @z_far@

         __defined at:__ @libheif\/heif_aux_images.h 72:10@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_depth_representation_info_d_min :: BG.CDouble
    {- ^ __C declaration:__ @d_min@

         __defined at:__ @libheif\/heif_aux_images.h 73:10@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_depth_representation_info_d_max :: BG.CDouble
    {- ^ __C declaration:__ @d_max@

         __defined at:__ @libheif\/heif_aux_images.h 74:10@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_depth_representation_info_depth_representation_type :: Heif_depth_representation_type
    {- ^ __C declaration:__ @depth_representation_type@

         __defined at:__ @libheif\/heif_aux_images.h 76:39@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_depth_representation_info_disparity_reference_view :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @disparity_reference_view@

         __defined at:__ @libheif\/heif_aux_images.h 77:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_depth_representation_info_depth_nonlinear_representation_model_size :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @depth_nonlinear_representation_model_size@

         __defined at:__ @libheif\/heif_aux_images.h 79:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_depth_representation_info_depth_nonlinear_representation_model :: BG.Ptr HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @depth_nonlinear_representation_model@

         __defined at:__ @libheif\/heif_aux_images.h 80:12@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_depth_representation_info where

  staticSizeOf = \_ -> (64 :: Int)

  staticAlignment = \_ -> (8 :: Int)

instance Marshal.ReadRaw Heif_depth_representation_info where

  readRaw =
    \ptr0 ->
          pure Heif_depth_representation_info
      <*> HasCField.readRaw (BG.Proxy @"heif_depth_representation_info_version") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_depth_representation_info_has_z_near") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_depth_representation_info_has_z_far") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_depth_representation_info_has_d_min") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_depth_representation_info_has_d_max") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_depth_representation_info_z_near") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_depth_representation_info_z_far") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_depth_representation_info_d_min") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_depth_representation_info_d_max") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_depth_representation_info_depth_representation_type") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_depth_representation_info_disparity_reference_view") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_depth_representation_info_depth_nonlinear_representation_model_size") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_depth_representation_info_depth_nonlinear_representation_model") ptr0

instance Marshal.WriteRaw Heif_depth_representation_info where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_depth_representation_info
            heif_depth_representation_info_version2
            heif_depth_representation_info_has_z_near3
            heif_depth_representation_info_has_z_far4
            heif_depth_representation_info_has_d_min5
            heif_depth_representation_info_has_d_max6
            heif_depth_representation_info_z_near7
            heif_depth_representation_info_z_far8
            heif_depth_representation_info_d_min9
            heif_depth_representation_info_d_max10
            heif_depth_representation_info_depth_representation_type11
            heif_depth_representation_info_disparity_reference_view12
            heif_depth_representation_info_depth_nonlinear_representation_model_size13
            heif_depth_representation_info_depth_nonlinear_representation_model14 ->
                 HasCField.writeRaw (BG.Proxy @"heif_depth_representation_info_version") ptr0 heif_depth_representation_info_version2
              >> HasCField.writeRaw (BG.Proxy @"heif_depth_representation_info_has_z_near") ptr0 heif_depth_representation_info_has_z_near3
              >> HasCField.writeRaw (BG.Proxy @"heif_depth_representation_info_has_z_far") ptr0 heif_depth_representation_info_has_z_far4
              >> HasCField.writeRaw (BG.Proxy @"heif_depth_representation_info_has_d_min") ptr0 heif_depth_representation_info_has_d_min5
              >> HasCField.writeRaw (BG.Proxy @"heif_depth_representation_info_has_d_max") ptr0 heif_depth_representation_info_has_d_max6
              >> HasCField.writeRaw (BG.Proxy @"heif_depth_representation_info_z_near") ptr0 heif_depth_representation_info_z_near7
              >> HasCField.writeRaw (BG.Proxy @"heif_depth_representation_info_z_far") ptr0 heif_depth_representation_info_z_far8
              >> HasCField.writeRaw (BG.Proxy @"heif_depth_representation_info_d_min") ptr0 heif_depth_representation_info_d_min9
              >> HasCField.writeRaw (BG.Proxy @"heif_depth_representation_info_d_max") ptr0 heif_depth_representation_info_d_max10
              >> HasCField.writeRaw (BG.Proxy @"heif_depth_representation_info_depth_representation_type") ptr0 heif_depth_representation_info_depth_representation_type11
              >> HasCField.writeRaw (BG.Proxy @"heif_depth_representation_info_disparity_reference_view") ptr0 heif_depth_representation_info_disparity_reference_view12
              >> HasCField.writeRaw (BG.Proxy @"heif_depth_representation_info_depth_nonlinear_representation_model_size") ptr0 heif_depth_representation_info_depth_nonlinear_representation_model_size13
              >> HasCField.writeRaw (BG.Proxy @"heif_depth_representation_info_depth_nonlinear_representation_model") ptr0 heif_depth_representation_info_depth_nonlinear_representation_model14

deriving via Marshal.EquivStorable Heif_depth_representation_info instance BG.Storable Heif_depth_representation_info

deriving via Struct.IsStructViaReadRaw Heif_depth_representation_info instance Struct.IsStruct Heif_depth_representation_info

{-| __C declaration:__ @version@

    __defined at:__ @libheif\/heif_aux_images.h 62:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_depth_representation_info_version" Heif_depth_representation_info ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_depth_representation_info { heif_depth_representation_info_version = y1
                                         , heif_depth_representation_info_has_z_near = BG.getField @"heif_depth_representation_info_has_z_near" x0
                                         , heif_depth_representation_info_has_z_far = BG.getField @"heif_depth_representation_info_has_z_far" x0
                                         , heif_depth_representation_info_has_d_min = BG.getField @"heif_depth_representation_info_has_d_min" x0
                                         , heif_depth_representation_info_has_d_max = BG.getField @"heif_depth_representation_info_has_d_max" x0
                                         , heif_depth_representation_info_z_near = BG.getField @"heif_depth_representation_info_z_near" x0
                                         , heif_depth_representation_info_z_far = BG.getField @"heif_depth_representation_info_z_far" x0
                                         , heif_depth_representation_info_d_min = BG.getField @"heif_depth_representation_info_d_min" x0
                                         , heif_depth_representation_info_d_max = BG.getField @"heif_depth_representation_info_d_max" x0
                                         , heif_depth_representation_info_depth_representation_type = BG.getField @"heif_depth_representation_info_depth_representation_type" x0
                                         , heif_depth_representation_info_disparity_reference_view = BG.getField @"heif_depth_representation_info_disparity_reference_view" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model_size = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model_size" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model" x0
                                         }
      , BG.getField @"heif_depth_representation_info_version" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_depth_representation_info_version" (BG.Ptr Heif_depth_representation_info) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_depth_representation_info_version")

instance HasCField.HasCField Heif_depth_representation_info "heif_depth_representation_info_version" where

  type CFieldType Heif_depth_representation_info "heif_depth_representation_info_version" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @has_z_near@

    __defined at:__ @libheif\/heif_aux_images.h 66:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_depth_representation_info_has_z_near" Heif_depth_representation_info ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_depth_representation_info { heif_depth_representation_info_has_z_near = y1
                                         , heif_depth_representation_info_version = BG.getField @"heif_depth_representation_info_version" x0
                                         , heif_depth_representation_info_has_z_far = BG.getField @"heif_depth_representation_info_has_z_far" x0
                                         , heif_depth_representation_info_has_d_min = BG.getField @"heif_depth_representation_info_has_d_min" x0
                                         , heif_depth_representation_info_has_d_max = BG.getField @"heif_depth_representation_info_has_d_max" x0
                                         , heif_depth_representation_info_z_near = BG.getField @"heif_depth_representation_info_z_near" x0
                                         , heif_depth_representation_info_z_far = BG.getField @"heif_depth_representation_info_z_far" x0
                                         , heif_depth_representation_info_d_min = BG.getField @"heif_depth_representation_info_d_min" x0
                                         , heif_depth_representation_info_d_max = BG.getField @"heif_depth_representation_info_d_max" x0
                                         , heif_depth_representation_info_depth_representation_type = BG.getField @"heif_depth_representation_info_depth_representation_type" x0
                                         , heif_depth_representation_info_disparity_reference_view = BG.getField @"heif_depth_representation_info_disparity_reference_view" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model_size = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model_size" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model" x0
                                         }
      , BG.getField @"heif_depth_representation_info_has_z_near" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_depth_representation_info_has_z_near" (BG.Ptr Heif_depth_representation_info) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_depth_representation_info_has_z_near")

instance HasCField.HasCField Heif_depth_representation_info "heif_depth_representation_info_has_z_near" where

  type CFieldType Heif_depth_representation_info "heif_depth_representation_info_has_z_near" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 1

{-| __C declaration:__ @has_z_far@

    __defined at:__ @libheif\/heif_aux_images.h 67:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_depth_representation_info_has_z_far" Heif_depth_representation_info ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_depth_representation_info { heif_depth_representation_info_has_z_far = y1
                                         , heif_depth_representation_info_version = BG.getField @"heif_depth_representation_info_version" x0
                                         , heif_depth_representation_info_has_z_near = BG.getField @"heif_depth_representation_info_has_z_near" x0
                                         , heif_depth_representation_info_has_d_min = BG.getField @"heif_depth_representation_info_has_d_min" x0
                                         , heif_depth_representation_info_has_d_max = BG.getField @"heif_depth_representation_info_has_d_max" x0
                                         , heif_depth_representation_info_z_near = BG.getField @"heif_depth_representation_info_z_near" x0
                                         , heif_depth_representation_info_z_far = BG.getField @"heif_depth_representation_info_z_far" x0
                                         , heif_depth_representation_info_d_min = BG.getField @"heif_depth_representation_info_d_min" x0
                                         , heif_depth_representation_info_d_max = BG.getField @"heif_depth_representation_info_d_max" x0
                                         , heif_depth_representation_info_depth_representation_type = BG.getField @"heif_depth_representation_info_depth_representation_type" x0
                                         , heif_depth_representation_info_disparity_reference_view = BG.getField @"heif_depth_representation_info_disparity_reference_view" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model_size = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model_size" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model" x0
                                         }
      , BG.getField @"heif_depth_representation_info_has_z_far" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_depth_representation_info_has_z_far" (BG.Ptr Heif_depth_representation_info) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_depth_representation_info_has_z_far")

instance HasCField.HasCField Heif_depth_representation_info "heif_depth_representation_info_has_z_far" where

  type CFieldType Heif_depth_representation_info "heif_depth_representation_info_has_z_far" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 2

{-| __C declaration:__ @has_d_min@

    __defined at:__ @libheif\/heif_aux_images.h 68:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_depth_representation_info_has_d_min" Heif_depth_representation_info ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_depth_representation_info { heif_depth_representation_info_has_d_min = y1
                                         , heif_depth_representation_info_version = BG.getField @"heif_depth_representation_info_version" x0
                                         , heif_depth_representation_info_has_z_near = BG.getField @"heif_depth_representation_info_has_z_near" x0
                                         , heif_depth_representation_info_has_z_far = BG.getField @"heif_depth_representation_info_has_z_far" x0
                                         , heif_depth_representation_info_has_d_max = BG.getField @"heif_depth_representation_info_has_d_max" x0
                                         , heif_depth_representation_info_z_near = BG.getField @"heif_depth_representation_info_z_near" x0
                                         , heif_depth_representation_info_z_far = BG.getField @"heif_depth_representation_info_z_far" x0
                                         , heif_depth_representation_info_d_min = BG.getField @"heif_depth_representation_info_d_min" x0
                                         , heif_depth_representation_info_d_max = BG.getField @"heif_depth_representation_info_d_max" x0
                                         , heif_depth_representation_info_depth_representation_type = BG.getField @"heif_depth_representation_info_depth_representation_type" x0
                                         , heif_depth_representation_info_disparity_reference_view = BG.getField @"heif_depth_representation_info_disparity_reference_view" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model_size = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model_size" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model" x0
                                         }
      , BG.getField @"heif_depth_representation_info_has_d_min" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_depth_representation_info_has_d_min" (BG.Ptr Heif_depth_representation_info) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_depth_representation_info_has_d_min")

instance HasCField.HasCField Heif_depth_representation_info "heif_depth_representation_info_has_d_min" where

  type CFieldType Heif_depth_representation_info "heif_depth_representation_info_has_d_min" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 3

{-| __C declaration:__ @has_d_max@

    __defined at:__ @libheif\/heif_aux_images.h 69:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_depth_representation_info_has_d_max" Heif_depth_representation_info ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_depth_representation_info { heif_depth_representation_info_has_d_max = y1
                                         , heif_depth_representation_info_version = BG.getField @"heif_depth_representation_info_version" x0
                                         , heif_depth_representation_info_has_z_near = BG.getField @"heif_depth_representation_info_has_z_near" x0
                                         , heif_depth_representation_info_has_z_far = BG.getField @"heif_depth_representation_info_has_z_far" x0
                                         , heif_depth_representation_info_has_d_min = BG.getField @"heif_depth_representation_info_has_d_min" x0
                                         , heif_depth_representation_info_z_near = BG.getField @"heif_depth_representation_info_z_near" x0
                                         , heif_depth_representation_info_z_far = BG.getField @"heif_depth_representation_info_z_far" x0
                                         , heif_depth_representation_info_d_min = BG.getField @"heif_depth_representation_info_d_min" x0
                                         , heif_depth_representation_info_d_max = BG.getField @"heif_depth_representation_info_d_max" x0
                                         , heif_depth_representation_info_depth_representation_type = BG.getField @"heif_depth_representation_info_depth_representation_type" x0
                                         , heif_depth_representation_info_disparity_reference_view = BG.getField @"heif_depth_representation_info_disparity_reference_view" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model_size = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model_size" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model" x0
                                         }
      , BG.getField @"heif_depth_representation_info_has_d_max" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_depth_representation_info_has_d_max" (BG.Ptr Heif_depth_representation_info) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_depth_representation_info_has_d_max")

instance HasCField.HasCField Heif_depth_representation_info "heif_depth_representation_info_has_d_max" where

  type CFieldType Heif_depth_representation_info "heif_depth_representation_info_has_d_max" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 4

{-| __C declaration:__ @z_near@

    __defined at:__ @libheif\/heif_aux_images.h 71:10@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CDouble
         ) => BG.CompatHasField.HasField "heif_depth_representation_info_z_near" Heif_depth_representation_info ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_depth_representation_info { heif_depth_representation_info_z_near = y1
                                         , heif_depth_representation_info_version = BG.getField @"heif_depth_representation_info_version" x0
                                         , heif_depth_representation_info_has_z_near = BG.getField @"heif_depth_representation_info_has_z_near" x0
                                         , heif_depth_representation_info_has_z_far = BG.getField @"heif_depth_representation_info_has_z_far" x0
                                         , heif_depth_representation_info_has_d_min = BG.getField @"heif_depth_representation_info_has_d_min" x0
                                         , heif_depth_representation_info_has_d_max = BG.getField @"heif_depth_representation_info_has_d_max" x0
                                         , heif_depth_representation_info_z_far = BG.getField @"heif_depth_representation_info_z_far" x0
                                         , heif_depth_representation_info_d_min = BG.getField @"heif_depth_representation_info_d_min" x0
                                         , heif_depth_representation_info_d_max = BG.getField @"heif_depth_representation_info_d_max" x0
                                         , heif_depth_representation_info_depth_representation_type = BG.getField @"heif_depth_representation_info_depth_representation_type" x0
                                         , heif_depth_representation_info_disparity_reference_view = BG.getField @"heif_depth_representation_info_disparity_reference_view" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model_size = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model_size" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model" x0
                                         }
      , BG.getField @"heif_depth_representation_info_z_near" x0
      )

instance ( ty ~ BG.CDouble
         ) => BG.HasField "heif_depth_representation_info_z_near" (BG.Ptr Heif_depth_representation_info) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_depth_representation_info_z_near")

instance HasCField.HasCField Heif_depth_representation_info "heif_depth_representation_info_z_near" where

  type CFieldType Heif_depth_representation_info "heif_depth_representation_info_z_near" =
    BG.CDouble

  offset# = \_ -> \_ -> 8

{-| __C declaration:__ @z_far@

    __defined at:__ @libheif\/heif_aux_images.h 72:10@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CDouble
         ) => BG.CompatHasField.HasField "heif_depth_representation_info_z_far" Heif_depth_representation_info ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_depth_representation_info { heif_depth_representation_info_z_far = y1
                                         , heif_depth_representation_info_version = BG.getField @"heif_depth_representation_info_version" x0
                                         , heif_depth_representation_info_has_z_near = BG.getField @"heif_depth_representation_info_has_z_near" x0
                                         , heif_depth_representation_info_has_z_far = BG.getField @"heif_depth_representation_info_has_z_far" x0
                                         , heif_depth_representation_info_has_d_min = BG.getField @"heif_depth_representation_info_has_d_min" x0
                                         , heif_depth_representation_info_has_d_max = BG.getField @"heif_depth_representation_info_has_d_max" x0
                                         , heif_depth_representation_info_z_near = BG.getField @"heif_depth_representation_info_z_near" x0
                                         , heif_depth_representation_info_d_min = BG.getField @"heif_depth_representation_info_d_min" x0
                                         , heif_depth_representation_info_d_max = BG.getField @"heif_depth_representation_info_d_max" x0
                                         , heif_depth_representation_info_depth_representation_type = BG.getField @"heif_depth_representation_info_depth_representation_type" x0
                                         , heif_depth_representation_info_disparity_reference_view = BG.getField @"heif_depth_representation_info_disparity_reference_view" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model_size = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model_size" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model" x0
                                         }
      , BG.getField @"heif_depth_representation_info_z_far" x0
      )

instance ( ty ~ BG.CDouble
         ) => BG.HasField "heif_depth_representation_info_z_far" (BG.Ptr Heif_depth_representation_info) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_depth_representation_info_z_far")

instance HasCField.HasCField Heif_depth_representation_info "heif_depth_representation_info_z_far" where

  type CFieldType Heif_depth_representation_info "heif_depth_representation_info_z_far" =
    BG.CDouble

  offset# = \_ -> \_ -> 16

{-| __C declaration:__ @d_min@

    __defined at:__ @libheif\/heif_aux_images.h 73:10@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CDouble
         ) => BG.CompatHasField.HasField "heif_depth_representation_info_d_min" Heif_depth_representation_info ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_depth_representation_info { heif_depth_representation_info_d_min = y1
                                         , heif_depth_representation_info_version = BG.getField @"heif_depth_representation_info_version" x0
                                         , heif_depth_representation_info_has_z_near = BG.getField @"heif_depth_representation_info_has_z_near" x0
                                         , heif_depth_representation_info_has_z_far = BG.getField @"heif_depth_representation_info_has_z_far" x0
                                         , heif_depth_representation_info_has_d_min = BG.getField @"heif_depth_representation_info_has_d_min" x0
                                         , heif_depth_representation_info_has_d_max = BG.getField @"heif_depth_representation_info_has_d_max" x0
                                         , heif_depth_representation_info_z_near = BG.getField @"heif_depth_representation_info_z_near" x0
                                         , heif_depth_representation_info_z_far = BG.getField @"heif_depth_representation_info_z_far" x0
                                         , heif_depth_representation_info_d_max = BG.getField @"heif_depth_representation_info_d_max" x0
                                         , heif_depth_representation_info_depth_representation_type = BG.getField @"heif_depth_representation_info_depth_representation_type" x0
                                         , heif_depth_representation_info_disparity_reference_view = BG.getField @"heif_depth_representation_info_disparity_reference_view" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model_size = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model_size" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model" x0
                                         }
      , BG.getField @"heif_depth_representation_info_d_min" x0
      )

instance ( ty ~ BG.CDouble
         ) => BG.HasField "heif_depth_representation_info_d_min" (BG.Ptr Heif_depth_representation_info) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_depth_representation_info_d_min")

instance HasCField.HasCField Heif_depth_representation_info "heif_depth_representation_info_d_min" where

  type CFieldType Heif_depth_representation_info "heif_depth_representation_info_d_min" =
    BG.CDouble

  offset# = \_ -> \_ -> 24

{-| __C declaration:__ @d_max@

    __defined at:__ @libheif\/heif_aux_images.h 74:10@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CDouble
         ) => BG.CompatHasField.HasField "heif_depth_representation_info_d_max" Heif_depth_representation_info ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_depth_representation_info { heif_depth_representation_info_d_max = y1
                                         , heif_depth_representation_info_version = BG.getField @"heif_depth_representation_info_version" x0
                                         , heif_depth_representation_info_has_z_near = BG.getField @"heif_depth_representation_info_has_z_near" x0
                                         , heif_depth_representation_info_has_z_far = BG.getField @"heif_depth_representation_info_has_z_far" x0
                                         , heif_depth_representation_info_has_d_min = BG.getField @"heif_depth_representation_info_has_d_min" x0
                                         , heif_depth_representation_info_has_d_max = BG.getField @"heif_depth_representation_info_has_d_max" x0
                                         , heif_depth_representation_info_z_near = BG.getField @"heif_depth_representation_info_z_near" x0
                                         , heif_depth_representation_info_z_far = BG.getField @"heif_depth_representation_info_z_far" x0
                                         , heif_depth_representation_info_d_min = BG.getField @"heif_depth_representation_info_d_min" x0
                                         , heif_depth_representation_info_depth_representation_type = BG.getField @"heif_depth_representation_info_depth_representation_type" x0
                                         , heif_depth_representation_info_disparity_reference_view = BG.getField @"heif_depth_representation_info_disparity_reference_view" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model_size = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model_size" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model" x0
                                         }
      , BG.getField @"heif_depth_representation_info_d_max" x0
      )

instance ( ty ~ BG.CDouble
         ) => BG.HasField "heif_depth_representation_info_d_max" (BG.Ptr Heif_depth_representation_info) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_depth_representation_info_d_max")

instance HasCField.HasCField Heif_depth_representation_info "heif_depth_representation_info_d_max" where

  type CFieldType Heif_depth_representation_info "heif_depth_representation_info_d_max" =
    BG.CDouble

  offset# = \_ -> \_ -> 32

{-| __C declaration:__ @depth_representation_type@

    __defined at:__ @libheif\/heif_aux_images.h 76:39@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ Heif_depth_representation_type
         ) => BG.CompatHasField.HasField "heif_depth_representation_info_depth_representation_type" Heif_depth_representation_info ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_depth_representation_info { heif_depth_representation_info_depth_representation_type = y1
                                         , heif_depth_representation_info_version = BG.getField @"heif_depth_representation_info_version" x0
                                         , heif_depth_representation_info_has_z_near = BG.getField @"heif_depth_representation_info_has_z_near" x0
                                         , heif_depth_representation_info_has_z_far = BG.getField @"heif_depth_representation_info_has_z_far" x0
                                         , heif_depth_representation_info_has_d_min = BG.getField @"heif_depth_representation_info_has_d_min" x0
                                         , heif_depth_representation_info_has_d_max = BG.getField @"heif_depth_representation_info_has_d_max" x0
                                         , heif_depth_representation_info_z_near = BG.getField @"heif_depth_representation_info_z_near" x0
                                         , heif_depth_representation_info_z_far = BG.getField @"heif_depth_representation_info_z_far" x0
                                         , heif_depth_representation_info_d_min = BG.getField @"heif_depth_representation_info_d_min" x0
                                         , heif_depth_representation_info_d_max = BG.getField @"heif_depth_representation_info_d_max" x0
                                         , heif_depth_representation_info_disparity_reference_view = BG.getField @"heif_depth_representation_info_disparity_reference_view" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model_size = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model_size" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model" x0
                                         }
      , BG.getField @"heif_depth_representation_info_depth_representation_type" x0
      )

instance ( ty ~ Heif_depth_representation_type
         ) => BG.HasField "heif_depth_representation_info_depth_representation_type" (BG.Ptr Heif_depth_representation_info) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_depth_representation_info_depth_representation_type")

instance HasCField.HasCField Heif_depth_representation_info "heif_depth_representation_info_depth_representation_type" where

  type CFieldType Heif_depth_representation_info "heif_depth_representation_info_depth_representation_type" =
    Heif_depth_representation_type

  offset# = \_ -> \_ -> 40

{-| __C declaration:__ @disparity_reference_view@

    __defined at:__ @libheif\/heif_aux_images.h 77:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_depth_representation_info_disparity_reference_view" Heif_depth_representation_info ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_depth_representation_info { heif_depth_representation_info_disparity_reference_view = y1
                                         , heif_depth_representation_info_version = BG.getField @"heif_depth_representation_info_version" x0
                                         , heif_depth_representation_info_has_z_near = BG.getField @"heif_depth_representation_info_has_z_near" x0
                                         , heif_depth_representation_info_has_z_far = BG.getField @"heif_depth_representation_info_has_z_far" x0
                                         , heif_depth_representation_info_has_d_min = BG.getField @"heif_depth_representation_info_has_d_min" x0
                                         , heif_depth_representation_info_has_d_max = BG.getField @"heif_depth_representation_info_has_d_max" x0
                                         , heif_depth_representation_info_z_near = BG.getField @"heif_depth_representation_info_z_near" x0
                                         , heif_depth_representation_info_z_far = BG.getField @"heif_depth_representation_info_z_far" x0
                                         , heif_depth_representation_info_d_min = BG.getField @"heif_depth_representation_info_d_min" x0
                                         , heif_depth_representation_info_d_max = BG.getField @"heif_depth_representation_info_d_max" x0
                                         , heif_depth_representation_info_depth_representation_type = BG.getField @"heif_depth_representation_info_depth_representation_type" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model_size = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model_size" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model" x0
                                         }
      , BG.getField @"heif_depth_representation_info_disparity_reference_view" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_depth_representation_info_disparity_reference_view" (BG.Ptr Heif_depth_representation_info) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_depth_representation_info_disparity_reference_view")

instance HasCField.HasCField Heif_depth_representation_info "heif_depth_representation_info_disparity_reference_view" where

  type CFieldType Heif_depth_representation_info "heif_depth_representation_info_disparity_reference_view" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 44

{-| __C declaration:__ @depth_nonlinear_representation_model_size@

    __defined at:__ @libheif\/heif_aux_images.h 79:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_depth_representation_info_depth_nonlinear_representation_model_size" Heif_depth_representation_info ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_depth_representation_info { heif_depth_representation_info_depth_nonlinear_representation_model_size = y1
                                         , heif_depth_representation_info_version = BG.getField @"heif_depth_representation_info_version" x0
                                         , heif_depth_representation_info_has_z_near = BG.getField @"heif_depth_representation_info_has_z_near" x0
                                         , heif_depth_representation_info_has_z_far = BG.getField @"heif_depth_representation_info_has_z_far" x0
                                         , heif_depth_representation_info_has_d_min = BG.getField @"heif_depth_representation_info_has_d_min" x0
                                         , heif_depth_representation_info_has_d_max = BG.getField @"heif_depth_representation_info_has_d_max" x0
                                         , heif_depth_representation_info_z_near = BG.getField @"heif_depth_representation_info_z_near" x0
                                         , heif_depth_representation_info_z_far = BG.getField @"heif_depth_representation_info_z_far" x0
                                         , heif_depth_representation_info_d_min = BG.getField @"heif_depth_representation_info_d_min" x0
                                         , heif_depth_representation_info_d_max = BG.getField @"heif_depth_representation_info_d_max" x0
                                         , heif_depth_representation_info_depth_representation_type = BG.getField @"heif_depth_representation_info_depth_representation_type" x0
                                         , heif_depth_representation_info_disparity_reference_view = BG.getField @"heif_depth_representation_info_disparity_reference_view" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model" x0
                                         }
      , BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model_size" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_depth_representation_info_depth_nonlinear_representation_model_size" (BG.Ptr Heif_depth_representation_info) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_depth_representation_info_depth_nonlinear_representation_model_size")

instance HasCField.HasCField Heif_depth_representation_info "heif_depth_representation_info_depth_nonlinear_representation_model_size" where

  type CFieldType Heif_depth_representation_info "heif_depth_representation_info_depth_nonlinear_representation_model_size" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 48

{-| __C declaration:__ @depth_nonlinear_representation_model@

    __defined at:__ @libheif\/heif_aux_images.h 80:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.Ptr HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_depth_representation_info_depth_nonlinear_representation_model" Heif_depth_representation_info ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_depth_representation_info { heif_depth_representation_info_depth_nonlinear_representation_model = y1
                                         , heif_depth_representation_info_version = BG.getField @"heif_depth_representation_info_version" x0
                                         , heif_depth_representation_info_has_z_near = BG.getField @"heif_depth_representation_info_has_z_near" x0
                                         , heif_depth_representation_info_has_z_far = BG.getField @"heif_depth_representation_info_has_z_far" x0
                                         , heif_depth_representation_info_has_d_min = BG.getField @"heif_depth_representation_info_has_d_min" x0
                                         , heif_depth_representation_info_has_d_max = BG.getField @"heif_depth_representation_info_has_d_max" x0
                                         , heif_depth_representation_info_z_near = BG.getField @"heif_depth_representation_info_z_near" x0
                                         , heif_depth_representation_info_z_far = BG.getField @"heif_depth_representation_info_z_far" x0
                                         , heif_depth_representation_info_d_min = BG.getField @"heif_depth_representation_info_d_min" x0
                                         , heif_depth_representation_info_d_max = BG.getField @"heif_depth_representation_info_d_max" x0
                                         , heif_depth_representation_info_depth_representation_type = BG.getField @"heif_depth_representation_info_depth_representation_type" x0
                                         , heif_depth_representation_info_disparity_reference_view = BG.getField @"heif_depth_representation_info_disparity_reference_view" x0
                                         , heif_depth_representation_info_depth_nonlinear_representation_model_size = BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model_size" x0
                                         }
      , BG.getField @"heif_depth_representation_info_depth_nonlinear_representation_model" x0
      )

instance ( ty ~ BG.Ptr HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_depth_representation_info_depth_nonlinear_representation_model" (BG.Ptr Heif_depth_representation_info) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_depth_representation_info_depth_nonlinear_representation_model")

instance HasCField.HasCField Heif_depth_representation_info "heif_depth_representation_info_depth_nonlinear_representation_model" where

  type CFieldType Heif_depth_representation_info "heif_depth_representation_info_depth_nonlinear_representation_model" =
    BG.Ptr HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 56

{-| __C declaration:__ @macro LIBHEIF_AUX_IMAGE_FILTER_OMIT_ALPHA@

    __defined at:__ @libheif\/heif_aux_images.h 143:9@

    __exported by:__ @libheif\/heif.h@
-}
lIBHEIF_AUX_IMAGE_FILTER_OMIT_ALPHA :: BG.CULong
lIBHEIF_AUX_IMAGE_FILTER_OMIT_ALPHA =
  (C.Expr.HostPlatform.<<) (1 :: BG.CULong) (1 :: BG.CInt)

{-| __C declaration:__ @macro LIBHEIF_AUX_IMAGE_FILTER_OMIT_DEPTH@

    __defined at:__ @libheif\/heif_aux_images.h 144:9@

    __exported by:__ @libheif\/heif.h@
-}
lIBHEIF_AUX_IMAGE_FILTER_OMIT_DEPTH :: BG.CULong
lIBHEIF_AUX_IMAGE_FILTER_OMIT_DEPTH =
  (C.Expr.HostPlatform.<<) (2 :: BG.CULong) (1 :: BG.CInt)

{-| __C declaration:__ @heif_entity_group_id@

    __defined at:__ @libheif\/heif_entity_groups.h 33:18@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_entity_group_id = Heif_entity_group_id
  { unwrapHeif_entity_group_id :: HsBindgen.Runtime.LibC.Word32
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "unwrapHeif_entity_group_id" Heif_entity_group_id ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_entity_group_id {unwrapHeif_entity_group_id = y1}
      , BG.getField @"unwrapHeif_entity_group_id" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "unwrapHeif_entity_group_id" (BG.Ptr Heif_entity_group_id) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_entity_group_id")

instance HasCField.HasCField Heif_entity_group_id "unwrapHeif_entity_group_id" where

  type CFieldType Heif_entity_group_id "unwrapHeif_entity_group_id" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @struct heif_entity_group@

    __defined at:__ @libheif\/heif_entity_groups.h 35:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_entity_group = Heif_entity_group
  { heif_entity_group_entity_group_id :: Heif_entity_group_id
    {- ^ __C declaration:__ @entity_group_id@

         __defined at:__ @libheif\/heif_entity_groups.h 37:24@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_entity_group_entity_group_type :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @entity_group_type@

         __defined at:__ @libheif\/heif_entity_groups.h 38:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_entity_group_entities :: BG.Ptr Heif_item_id
    {- ^ __C declaration:__ @entities@

         __defined at:__ @libheif\/heif_entity_groups.h 39:17@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_entity_group_num_entities :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @num_entities@

         __defined at:__ @libheif\/heif_entity_groups.h 40:12@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_entity_group where

  staticSizeOf = \_ -> (24 :: Int)

  staticAlignment = \_ -> (8 :: Int)

instance Marshal.ReadRaw Heif_entity_group where

  readRaw =
    \ptr0 ->
          pure Heif_entity_group
      <*> HasCField.readRaw (BG.Proxy @"heif_entity_group_entity_group_id") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_entity_group_entity_group_type") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_entity_group_entities") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_entity_group_num_entities") ptr0

instance Marshal.WriteRaw Heif_entity_group where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_entity_group
            heif_entity_group_entity_group_id2
            heif_entity_group_entity_group_type3
            heif_entity_group_entities4
            heif_entity_group_num_entities5 ->
                 HasCField.writeRaw (BG.Proxy @"heif_entity_group_entity_group_id") ptr0 heif_entity_group_entity_group_id2
              >> HasCField.writeRaw (BG.Proxy @"heif_entity_group_entity_group_type") ptr0 heif_entity_group_entity_group_type3
              >> HasCField.writeRaw (BG.Proxy @"heif_entity_group_entities") ptr0 heif_entity_group_entities4
              >> HasCField.writeRaw (BG.Proxy @"heif_entity_group_num_entities") ptr0 heif_entity_group_num_entities5

deriving via Marshal.EquivStorable Heif_entity_group instance BG.Storable Heif_entity_group

deriving via Struct.IsStructViaReadRaw Heif_entity_group instance Struct.IsStruct Heif_entity_group

{-| __C declaration:__ @entity_group_id@

    __defined at:__ @libheif\/heif_entity_groups.h 37:24@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ Heif_entity_group_id
         ) => BG.CompatHasField.HasField "heif_entity_group_entity_group_id" Heif_entity_group ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_entity_group { heif_entity_group_entity_group_id = y1
                            , heif_entity_group_entity_group_type = BG.getField @"heif_entity_group_entity_group_type" x0
                            , heif_entity_group_entities = BG.getField @"heif_entity_group_entities" x0
                            , heif_entity_group_num_entities = BG.getField @"heif_entity_group_num_entities" x0
                            }
      , BG.getField @"heif_entity_group_entity_group_id" x0
      )

instance ( ty ~ Heif_entity_group_id
         ) => BG.HasField "heif_entity_group_entity_group_id" (BG.Ptr Heif_entity_group) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_entity_group_entity_group_id")

instance HasCField.HasCField Heif_entity_group "heif_entity_group_entity_group_id" where

  type CFieldType Heif_entity_group "heif_entity_group_entity_group_id" =
    Heif_entity_group_id

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @entity_group_type@

    __defined at:__ @libheif\/heif_entity_groups.h 38:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_entity_group_entity_group_type" Heif_entity_group ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_entity_group { heif_entity_group_entity_group_type = y1
                            , heif_entity_group_entity_group_id = BG.getField @"heif_entity_group_entity_group_id" x0
                            , heif_entity_group_entities = BG.getField @"heif_entity_group_entities" x0
                            , heif_entity_group_num_entities = BG.getField @"heif_entity_group_num_entities" x0
                            }
      , BG.getField @"heif_entity_group_entity_group_type" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_entity_group_entity_group_type" (BG.Ptr Heif_entity_group) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_entity_group_entity_group_type")

instance HasCField.HasCField Heif_entity_group "heif_entity_group_entity_group_type" where

  type CFieldType Heif_entity_group "heif_entity_group_entity_group_type" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 4

{-| __C declaration:__ @entities@

    __defined at:__ @libheif\/heif_entity_groups.h 39:17@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.Ptr Heif_item_id
         ) => BG.CompatHasField.HasField "heif_entity_group_entities" Heif_entity_group ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_entity_group { heif_entity_group_entities = y1
                            , heif_entity_group_entity_group_id = BG.getField @"heif_entity_group_entity_group_id" x0
                            , heif_entity_group_entity_group_type = BG.getField @"heif_entity_group_entity_group_type" x0
                            , heif_entity_group_num_entities = BG.getField @"heif_entity_group_num_entities" x0
                            }
      , BG.getField @"heif_entity_group_entities" x0
      )

instance ( ty ~ BG.Ptr Heif_item_id
         ) => BG.HasField "heif_entity_group_entities" (BG.Ptr Heif_entity_group) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_entity_group_entities")

instance HasCField.HasCField Heif_entity_group "heif_entity_group_entities" where

  type CFieldType Heif_entity_group "heif_entity_group_entities" =
    BG.Ptr Heif_item_id

  offset# = \_ -> \_ -> 8

{-| __C declaration:__ @num_entities@

    __defined at:__ @libheif\/heif_entity_groups.h 40:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_entity_group_num_entities" Heif_entity_group ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_entity_group { heif_entity_group_num_entities = y1
                            , heif_entity_group_entity_group_id = BG.getField @"heif_entity_group_entity_group_id" x0
                            , heif_entity_group_entity_group_type = BG.getField @"heif_entity_group_entity_group_type" x0
                            , heif_entity_group_entities = BG.getField @"heif_entity_group_entities" x0
                            }
      , BG.getField @"heif_entity_group_num_entities" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_entity_group_num_entities" (BG.Ptr Heif_entity_group) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_entity_group_num_entities")

instance HasCField.HasCField Heif_entity_group "heif_entity_group_num_entities" where

  type CFieldType Heif_entity_group "heif_entity_group_num_entities" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 16

{-| __C declaration:__ @struct heif_security_limits@

    __defined at:__ @libheif\/heif_security.h 37:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_security_limits = Heif_security_limits
  { heif_security_limits_version :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @version@

         __defined at:__ @libheif\/heif_security.h 39:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_security_limits_max_image_size_pixels :: HsBindgen.Runtime.LibC.Word64
    {- ^ __C declaration:__ @max_image_size_pixels@

         __defined at:__ @libheif\/heif_security.h 46:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_security_limits_max_number_of_tiles :: HsBindgen.Runtime.LibC.Word64
    {- ^ __C declaration:__ @max_number_of_tiles@

         __defined at:__ @libheif\/heif_security.h 47:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_security_limits_max_bayer_pattern_pixels :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @max_bayer_pattern_pixels@

         __defined at:__ @libheif\/heif_security.h 49:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_security_limits_max_items :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @max_items@

         __defined at:__ @libheif\/heif_security.h 50:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_security_limits_max_color_profile_size :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @max_color_profile_size@

         __defined at:__ @libheif\/heif_security.h 52:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_security_limits_max_memory_block_size :: HsBindgen.Runtime.LibC.Word64
    {- ^ __C declaration:__ @max_memory_block_size@

         __defined at:__ @libheif\/heif_security.h 53:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_security_limits_max_components :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @max_components@

         __defined at:__ @libheif\/heif_security.h 55:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_security_limits_max_iloc_extents_per_item :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @max_iloc_extents_per_item@

         __defined at:__ @libheif\/heif_security.h 57:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_security_limits_max_size_entity_group :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @max_size_entity_group@

         __defined at:__ @libheif\/heif_security.h 58:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_security_limits_max_children_per_box :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @max_children_per_box@

         __defined at:__ @libheif\/heif_security.h 60:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_security_limits_max_total_memory :: HsBindgen.Runtime.LibC.Word64
    {- ^ __C declaration:__ @max_total_memory@

         __defined at:__ @libheif\/heif_security.h 64:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_security_limits_max_sample_description_box_entries :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @max_sample_description_box_entries@

         __defined at:__ @libheif\/heif_security.h 65:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_security_limits_max_sample_group_description_box_entries :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @max_sample_group_description_box_entries@

         __defined at:__ @libheif\/heif_security.h 66:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_security_limits_max_sequence_frames :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @max_sequence_frames@

         __defined at:__ @libheif\/heif_security.h 70:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_security_limits_max_number_of_file_brands :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @max_number_of_file_brands@

         __defined at:__ @libheif\/heif_security.h 71:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_security_limits_max_bad_pixels :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @max_bad_pixels@

         __defined at:__ @libheif\/heif_security.h 75:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_security_limits_max_iso23001_17_pixel_size_bytes :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @max_iso23001_17_pixel_size_bytes@

         __defined at:__ @libheif\/heif_security.h 80:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_security_limits_parent :: PtrConst.PtrConst Heif_security_limits
    {- ^ __C declaration:__ @parent@

         __defined at:__ @libheif\/heif_security.h 87:38@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_security_limits where

  staticSizeOf = \_ -> (104 :: Int)

  staticAlignment = \_ -> (8 :: Int)

instance Marshal.ReadRaw Heif_security_limits where

  readRaw =
    \ptr0 ->
          pure Heif_security_limits
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_version") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_max_image_size_pixels") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_max_number_of_tiles") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_max_bayer_pattern_pixels") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_max_items") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_max_color_profile_size") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_max_memory_block_size") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_max_components") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_max_iloc_extents_per_item") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_max_size_entity_group") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_max_children_per_box") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_max_total_memory") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_max_sample_description_box_entries") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_max_sample_group_description_box_entries") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_max_sequence_frames") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_max_number_of_file_brands") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_max_bad_pixels") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_max_iso23001_17_pixel_size_bytes") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_security_limits_parent") ptr0

instance Marshal.WriteRaw Heif_security_limits where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_security_limits
            heif_security_limits_version2
            heif_security_limits_max_image_size_pixels3
            heif_security_limits_max_number_of_tiles4
            heif_security_limits_max_bayer_pattern_pixels5
            heif_security_limits_max_items6
            heif_security_limits_max_color_profile_size7
            heif_security_limits_max_memory_block_size8
            heif_security_limits_max_components9
            heif_security_limits_max_iloc_extents_per_item10
            heif_security_limits_max_size_entity_group11
            heif_security_limits_max_children_per_box12
            heif_security_limits_max_total_memory13
            heif_security_limits_max_sample_description_box_entries14
            heif_security_limits_max_sample_group_description_box_entries15
            heif_security_limits_max_sequence_frames16
            heif_security_limits_max_number_of_file_brands17
            heif_security_limits_max_bad_pixels18
            heif_security_limits_max_iso23001_17_pixel_size_bytes19
            heif_security_limits_parent20 ->
                 HasCField.writeRaw (BG.Proxy @"heif_security_limits_version") ptr0 heif_security_limits_version2
              >> HasCField.writeRaw (BG.Proxy @"heif_security_limits_max_image_size_pixels") ptr0 heif_security_limits_max_image_size_pixels3
              >> HasCField.writeRaw (BG.Proxy @"heif_security_limits_max_number_of_tiles") ptr0 heif_security_limits_max_number_of_tiles4
              >> HasCField.writeRaw (BG.Proxy @"heif_security_limits_max_bayer_pattern_pixels") ptr0 heif_security_limits_max_bayer_pattern_pixels5
              >> HasCField.writeRaw (BG.Proxy @"heif_security_limits_max_items") ptr0 heif_security_limits_max_items6
              >> HasCField.writeRaw (BG.Proxy @"heif_security_limits_max_color_profile_size") ptr0 heif_security_limits_max_color_profile_size7
              >> HasCField.writeRaw (BG.Proxy @"heif_security_limits_max_memory_block_size") ptr0 heif_security_limits_max_memory_block_size8
              >> HasCField.writeRaw (BG.Proxy @"heif_security_limits_max_components") ptr0 heif_security_limits_max_components9
              >> HasCField.writeRaw (BG.Proxy @"heif_security_limits_max_iloc_extents_per_item") ptr0 heif_security_limits_max_iloc_extents_per_item10
              >> HasCField.writeRaw (BG.Proxy @"heif_security_limits_max_size_entity_group") ptr0 heif_security_limits_max_size_entity_group11
              >> HasCField.writeRaw (BG.Proxy @"heif_security_limits_max_children_per_box") ptr0 heif_security_limits_max_children_per_box12
              >> HasCField.writeRaw (BG.Proxy @"heif_security_limits_max_total_memory") ptr0 heif_security_limits_max_total_memory13
              >> HasCField.writeRaw (BG.Proxy @"heif_security_limits_max_sample_description_box_entries") ptr0 heif_security_limits_max_sample_description_box_entries14
              >> HasCField.writeRaw (BG.Proxy @"heif_security_limits_max_sample_group_description_box_entries") ptr0 heif_security_limits_max_sample_group_description_box_entries15
              >> HasCField.writeRaw (BG.Proxy @"heif_security_limits_max_sequence_frames") ptr0 heif_security_limits_max_sequence_frames16
              >> HasCField.writeRaw (BG.Proxy @"heif_security_limits_max_number_of_file_brands") ptr0 heif_security_limits_max_number_of_file_brands17
              >> HasCField.writeRaw (BG.Proxy @"heif_security_limits_max_bad_pixels") ptr0 heif_security_limits_max_bad_pixels18
              >> HasCField.writeRaw (BG.Proxy @"heif_security_limits_max_iso23001_17_pixel_size_bytes") ptr0 heif_security_limits_max_iso23001_17_pixel_size_bytes19
              >> HasCField.writeRaw (BG.Proxy @"heif_security_limits_parent") ptr0 heif_security_limits_parent20

deriving via Marshal.EquivStorable Heif_security_limits instance BG.Storable Heif_security_limits

deriving via Struct.IsStructViaReadRaw Heif_security_limits instance Struct.IsStruct Heif_security_limits

{-| __C declaration:__ @version@

    __defined at:__ @libheif\/heif_security.h 39:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_security_limits_version" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_version = y1
                               , heif_security_limits_max_image_size_pixels = BG.getField @"heif_security_limits_max_image_size_pixels" x0
                               , heif_security_limits_max_number_of_tiles = BG.getField @"heif_security_limits_max_number_of_tiles" x0
                               , heif_security_limits_max_bayer_pattern_pixels = BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
                               , heif_security_limits_max_items = BG.getField @"heif_security_limits_max_items" x0
                               , heif_security_limits_max_color_profile_size = BG.getField @"heif_security_limits_max_color_profile_size" x0
                               , heif_security_limits_max_memory_block_size = BG.getField @"heif_security_limits_max_memory_block_size" x0
                               , heif_security_limits_max_components = BG.getField @"heif_security_limits_max_components" x0
                               , heif_security_limits_max_iloc_extents_per_item = BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
                               , heif_security_limits_max_size_entity_group = BG.getField @"heif_security_limits_max_size_entity_group" x0
                               , heif_security_limits_max_children_per_box = BG.getField @"heif_security_limits_max_children_per_box" x0
                               , heif_security_limits_max_total_memory = BG.getField @"heif_security_limits_max_total_memory" x0
                               , heif_security_limits_max_sample_description_box_entries = BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
                               , heif_security_limits_max_sample_group_description_box_entries = BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
                               , heif_security_limits_max_sequence_frames = BG.getField @"heif_security_limits_max_sequence_frames" x0
                               , heif_security_limits_max_number_of_file_brands = BG.getField @"heif_security_limits_max_number_of_file_brands" x0
                               , heif_security_limits_max_bad_pixels = BG.getField @"heif_security_limits_max_bad_pixels" x0
                               , heif_security_limits_max_iso23001_17_pixel_size_bytes = BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
                               , heif_security_limits_parent = BG.getField @"heif_security_limits_parent" x0
                               }
      , BG.getField @"heif_security_limits_version" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_security_limits_version" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_version")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_version" where

  type CFieldType Heif_security_limits "heif_security_limits_version" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @max_image_size_pixels@

    __defined at:__ @libheif\/heif_security.h 46:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word64
         ) => BG.CompatHasField.HasField "heif_security_limits_max_image_size_pixels" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_max_image_size_pixels = y1
                               , heif_security_limits_version = BG.getField @"heif_security_limits_version" x0
                               , heif_security_limits_max_number_of_tiles = BG.getField @"heif_security_limits_max_number_of_tiles" x0
                               , heif_security_limits_max_bayer_pattern_pixels = BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
                               , heif_security_limits_max_items = BG.getField @"heif_security_limits_max_items" x0
                               , heif_security_limits_max_color_profile_size = BG.getField @"heif_security_limits_max_color_profile_size" x0
                               , heif_security_limits_max_memory_block_size = BG.getField @"heif_security_limits_max_memory_block_size" x0
                               , heif_security_limits_max_components = BG.getField @"heif_security_limits_max_components" x0
                               , heif_security_limits_max_iloc_extents_per_item = BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
                               , heif_security_limits_max_size_entity_group = BG.getField @"heif_security_limits_max_size_entity_group" x0
                               , heif_security_limits_max_children_per_box = BG.getField @"heif_security_limits_max_children_per_box" x0
                               , heif_security_limits_max_total_memory = BG.getField @"heif_security_limits_max_total_memory" x0
                               , heif_security_limits_max_sample_description_box_entries = BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
                               , heif_security_limits_max_sample_group_description_box_entries = BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
                               , heif_security_limits_max_sequence_frames = BG.getField @"heif_security_limits_max_sequence_frames" x0
                               , heif_security_limits_max_number_of_file_brands = BG.getField @"heif_security_limits_max_number_of_file_brands" x0
                               , heif_security_limits_max_bad_pixels = BG.getField @"heif_security_limits_max_bad_pixels" x0
                               , heif_security_limits_max_iso23001_17_pixel_size_bytes = BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
                               , heif_security_limits_parent = BG.getField @"heif_security_limits_parent" x0
                               }
      , BG.getField @"heif_security_limits_max_image_size_pixels" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word64
         ) => BG.HasField "heif_security_limits_max_image_size_pixels" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_max_image_size_pixels")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_max_image_size_pixels" where

  type CFieldType Heif_security_limits "heif_security_limits_max_image_size_pixels" =
    HsBindgen.Runtime.LibC.Word64

  offset# = \_ -> \_ -> 8

{-| __C declaration:__ @max_number_of_tiles@

    __defined at:__ @libheif\/heif_security.h 47:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word64
         ) => BG.CompatHasField.HasField "heif_security_limits_max_number_of_tiles" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_max_number_of_tiles = y1
                               , heif_security_limits_version = BG.getField @"heif_security_limits_version" x0
                               , heif_security_limits_max_image_size_pixels = BG.getField @"heif_security_limits_max_image_size_pixels" x0
                               , heif_security_limits_max_bayer_pattern_pixels = BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
                               , heif_security_limits_max_items = BG.getField @"heif_security_limits_max_items" x0
                               , heif_security_limits_max_color_profile_size = BG.getField @"heif_security_limits_max_color_profile_size" x0
                               , heif_security_limits_max_memory_block_size = BG.getField @"heif_security_limits_max_memory_block_size" x0
                               , heif_security_limits_max_components = BG.getField @"heif_security_limits_max_components" x0
                               , heif_security_limits_max_iloc_extents_per_item = BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
                               , heif_security_limits_max_size_entity_group = BG.getField @"heif_security_limits_max_size_entity_group" x0
                               , heif_security_limits_max_children_per_box = BG.getField @"heif_security_limits_max_children_per_box" x0
                               , heif_security_limits_max_total_memory = BG.getField @"heif_security_limits_max_total_memory" x0
                               , heif_security_limits_max_sample_description_box_entries = BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
                               , heif_security_limits_max_sample_group_description_box_entries = BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
                               , heif_security_limits_max_sequence_frames = BG.getField @"heif_security_limits_max_sequence_frames" x0
                               , heif_security_limits_max_number_of_file_brands = BG.getField @"heif_security_limits_max_number_of_file_brands" x0
                               , heif_security_limits_max_bad_pixels = BG.getField @"heif_security_limits_max_bad_pixels" x0
                               , heif_security_limits_max_iso23001_17_pixel_size_bytes = BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
                               , heif_security_limits_parent = BG.getField @"heif_security_limits_parent" x0
                               }
      , BG.getField @"heif_security_limits_max_number_of_tiles" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word64
         ) => BG.HasField "heif_security_limits_max_number_of_tiles" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_max_number_of_tiles")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_max_number_of_tiles" where

  type CFieldType Heif_security_limits "heif_security_limits_max_number_of_tiles" =
    HsBindgen.Runtime.LibC.Word64

  offset# = \_ -> \_ -> 16

{-| __C declaration:__ @max_bayer_pattern_pixels@

    __defined at:__ @libheif\/heif_security.h 49:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_security_limits_max_bayer_pattern_pixels" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_max_bayer_pattern_pixels = y1
                               , heif_security_limits_version = BG.getField @"heif_security_limits_version" x0
                               , heif_security_limits_max_image_size_pixels = BG.getField @"heif_security_limits_max_image_size_pixels" x0
                               , heif_security_limits_max_number_of_tiles = BG.getField @"heif_security_limits_max_number_of_tiles" x0
                               , heif_security_limits_max_items = BG.getField @"heif_security_limits_max_items" x0
                               , heif_security_limits_max_color_profile_size = BG.getField @"heif_security_limits_max_color_profile_size" x0
                               , heif_security_limits_max_memory_block_size = BG.getField @"heif_security_limits_max_memory_block_size" x0
                               , heif_security_limits_max_components = BG.getField @"heif_security_limits_max_components" x0
                               , heif_security_limits_max_iloc_extents_per_item = BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
                               , heif_security_limits_max_size_entity_group = BG.getField @"heif_security_limits_max_size_entity_group" x0
                               , heif_security_limits_max_children_per_box = BG.getField @"heif_security_limits_max_children_per_box" x0
                               , heif_security_limits_max_total_memory = BG.getField @"heif_security_limits_max_total_memory" x0
                               , heif_security_limits_max_sample_description_box_entries = BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
                               , heif_security_limits_max_sample_group_description_box_entries = BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
                               , heif_security_limits_max_sequence_frames = BG.getField @"heif_security_limits_max_sequence_frames" x0
                               , heif_security_limits_max_number_of_file_brands = BG.getField @"heif_security_limits_max_number_of_file_brands" x0
                               , heif_security_limits_max_bad_pixels = BG.getField @"heif_security_limits_max_bad_pixels" x0
                               , heif_security_limits_max_iso23001_17_pixel_size_bytes = BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
                               , heif_security_limits_parent = BG.getField @"heif_security_limits_parent" x0
                               }
      , BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_security_limits_max_bayer_pattern_pixels" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_max_bayer_pattern_pixels")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_max_bayer_pattern_pixels" where

  type CFieldType Heif_security_limits "heif_security_limits_max_bayer_pattern_pixels" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 24

{-| __C declaration:__ @max_items@

    __defined at:__ @libheif\/heif_security.h 50:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_security_limits_max_items" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_max_items = y1
                               , heif_security_limits_version = BG.getField @"heif_security_limits_version" x0
                               , heif_security_limits_max_image_size_pixels = BG.getField @"heif_security_limits_max_image_size_pixels" x0
                               , heif_security_limits_max_number_of_tiles = BG.getField @"heif_security_limits_max_number_of_tiles" x0
                               , heif_security_limits_max_bayer_pattern_pixels = BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
                               , heif_security_limits_max_color_profile_size = BG.getField @"heif_security_limits_max_color_profile_size" x0
                               , heif_security_limits_max_memory_block_size = BG.getField @"heif_security_limits_max_memory_block_size" x0
                               , heif_security_limits_max_components = BG.getField @"heif_security_limits_max_components" x0
                               , heif_security_limits_max_iloc_extents_per_item = BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
                               , heif_security_limits_max_size_entity_group = BG.getField @"heif_security_limits_max_size_entity_group" x0
                               , heif_security_limits_max_children_per_box = BG.getField @"heif_security_limits_max_children_per_box" x0
                               , heif_security_limits_max_total_memory = BG.getField @"heif_security_limits_max_total_memory" x0
                               , heif_security_limits_max_sample_description_box_entries = BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
                               , heif_security_limits_max_sample_group_description_box_entries = BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
                               , heif_security_limits_max_sequence_frames = BG.getField @"heif_security_limits_max_sequence_frames" x0
                               , heif_security_limits_max_number_of_file_brands = BG.getField @"heif_security_limits_max_number_of_file_brands" x0
                               , heif_security_limits_max_bad_pixels = BG.getField @"heif_security_limits_max_bad_pixels" x0
                               , heif_security_limits_max_iso23001_17_pixel_size_bytes = BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
                               , heif_security_limits_parent = BG.getField @"heif_security_limits_parent" x0
                               }
      , BG.getField @"heif_security_limits_max_items" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_security_limits_max_items" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_max_items")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_max_items" where

  type CFieldType Heif_security_limits "heif_security_limits_max_items" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 28

{-| __C declaration:__ @max_color_profile_size@

    __defined at:__ @libheif\/heif_security.h 52:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_security_limits_max_color_profile_size" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_max_color_profile_size = y1
                               , heif_security_limits_version = BG.getField @"heif_security_limits_version" x0
                               , heif_security_limits_max_image_size_pixels = BG.getField @"heif_security_limits_max_image_size_pixels" x0
                               , heif_security_limits_max_number_of_tiles = BG.getField @"heif_security_limits_max_number_of_tiles" x0
                               , heif_security_limits_max_bayer_pattern_pixels = BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
                               , heif_security_limits_max_items = BG.getField @"heif_security_limits_max_items" x0
                               , heif_security_limits_max_memory_block_size = BG.getField @"heif_security_limits_max_memory_block_size" x0
                               , heif_security_limits_max_components = BG.getField @"heif_security_limits_max_components" x0
                               , heif_security_limits_max_iloc_extents_per_item = BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
                               , heif_security_limits_max_size_entity_group = BG.getField @"heif_security_limits_max_size_entity_group" x0
                               , heif_security_limits_max_children_per_box = BG.getField @"heif_security_limits_max_children_per_box" x0
                               , heif_security_limits_max_total_memory = BG.getField @"heif_security_limits_max_total_memory" x0
                               , heif_security_limits_max_sample_description_box_entries = BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
                               , heif_security_limits_max_sample_group_description_box_entries = BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
                               , heif_security_limits_max_sequence_frames = BG.getField @"heif_security_limits_max_sequence_frames" x0
                               , heif_security_limits_max_number_of_file_brands = BG.getField @"heif_security_limits_max_number_of_file_brands" x0
                               , heif_security_limits_max_bad_pixels = BG.getField @"heif_security_limits_max_bad_pixels" x0
                               , heif_security_limits_max_iso23001_17_pixel_size_bytes = BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
                               , heif_security_limits_parent = BG.getField @"heif_security_limits_parent" x0
                               }
      , BG.getField @"heif_security_limits_max_color_profile_size" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_security_limits_max_color_profile_size" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_max_color_profile_size")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_max_color_profile_size" where

  type CFieldType Heif_security_limits "heif_security_limits_max_color_profile_size" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 32

{-| __C declaration:__ @max_memory_block_size@

    __defined at:__ @libheif\/heif_security.h 53:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word64
         ) => BG.CompatHasField.HasField "heif_security_limits_max_memory_block_size" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_max_memory_block_size = y1
                               , heif_security_limits_version = BG.getField @"heif_security_limits_version" x0
                               , heif_security_limits_max_image_size_pixels = BG.getField @"heif_security_limits_max_image_size_pixels" x0
                               , heif_security_limits_max_number_of_tiles = BG.getField @"heif_security_limits_max_number_of_tiles" x0
                               , heif_security_limits_max_bayer_pattern_pixels = BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
                               , heif_security_limits_max_items = BG.getField @"heif_security_limits_max_items" x0
                               , heif_security_limits_max_color_profile_size = BG.getField @"heif_security_limits_max_color_profile_size" x0
                               , heif_security_limits_max_components = BG.getField @"heif_security_limits_max_components" x0
                               , heif_security_limits_max_iloc_extents_per_item = BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
                               , heif_security_limits_max_size_entity_group = BG.getField @"heif_security_limits_max_size_entity_group" x0
                               , heif_security_limits_max_children_per_box = BG.getField @"heif_security_limits_max_children_per_box" x0
                               , heif_security_limits_max_total_memory = BG.getField @"heif_security_limits_max_total_memory" x0
                               , heif_security_limits_max_sample_description_box_entries = BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
                               , heif_security_limits_max_sample_group_description_box_entries = BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
                               , heif_security_limits_max_sequence_frames = BG.getField @"heif_security_limits_max_sequence_frames" x0
                               , heif_security_limits_max_number_of_file_brands = BG.getField @"heif_security_limits_max_number_of_file_brands" x0
                               , heif_security_limits_max_bad_pixels = BG.getField @"heif_security_limits_max_bad_pixels" x0
                               , heif_security_limits_max_iso23001_17_pixel_size_bytes = BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
                               , heif_security_limits_parent = BG.getField @"heif_security_limits_parent" x0
                               }
      , BG.getField @"heif_security_limits_max_memory_block_size" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word64
         ) => BG.HasField "heif_security_limits_max_memory_block_size" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_max_memory_block_size")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_max_memory_block_size" where

  type CFieldType Heif_security_limits "heif_security_limits_max_memory_block_size" =
    HsBindgen.Runtime.LibC.Word64

  offset# = \_ -> \_ -> 40

{-| __C declaration:__ @max_components@

    __defined at:__ @libheif\/heif_security.h 55:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_security_limits_max_components" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_max_components = y1
                               , heif_security_limits_version = BG.getField @"heif_security_limits_version" x0
                               , heif_security_limits_max_image_size_pixels = BG.getField @"heif_security_limits_max_image_size_pixels" x0
                               , heif_security_limits_max_number_of_tiles = BG.getField @"heif_security_limits_max_number_of_tiles" x0
                               , heif_security_limits_max_bayer_pattern_pixels = BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
                               , heif_security_limits_max_items = BG.getField @"heif_security_limits_max_items" x0
                               , heif_security_limits_max_color_profile_size = BG.getField @"heif_security_limits_max_color_profile_size" x0
                               , heif_security_limits_max_memory_block_size = BG.getField @"heif_security_limits_max_memory_block_size" x0
                               , heif_security_limits_max_iloc_extents_per_item = BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
                               , heif_security_limits_max_size_entity_group = BG.getField @"heif_security_limits_max_size_entity_group" x0
                               , heif_security_limits_max_children_per_box = BG.getField @"heif_security_limits_max_children_per_box" x0
                               , heif_security_limits_max_total_memory = BG.getField @"heif_security_limits_max_total_memory" x0
                               , heif_security_limits_max_sample_description_box_entries = BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
                               , heif_security_limits_max_sample_group_description_box_entries = BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
                               , heif_security_limits_max_sequence_frames = BG.getField @"heif_security_limits_max_sequence_frames" x0
                               , heif_security_limits_max_number_of_file_brands = BG.getField @"heif_security_limits_max_number_of_file_brands" x0
                               , heif_security_limits_max_bad_pixels = BG.getField @"heif_security_limits_max_bad_pixels" x0
                               , heif_security_limits_max_iso23001_17_pixel_size_bytes = BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
                               , heif_security_limits_parent = BG.getField @"heif_security_limits_parent" x0
                               }
      , BG.getField @"heif_security_limits_max_components" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_security_limits_max_components" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_max_components")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_max_components" where

  type CFieldType Heif_security_limits "heif_security_limits_max_components" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 48

{-| __C declaration:__ @max_iloc_extents_per_item@

    __defined at:__ @libheif\/heif_security.h 57:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_security_limits_max_iloc_extents_per_item" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_max_iloc_extents_per_item = y1
                               , heif_security_limits_version = BG.getField @"heif_security_limits_version" x0
                               , heif_security_limits_max_image_size_pixels = BG.getField @"heif_security_limits_max_image_size_pixels" x0
                               , heif_security_limits_max_number_of_tiles = BG.getField @"heif_security_limits_max_number_of_tiles" x0
                               , heif_security_limits_max_bayer_pattern_pixels = BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
                               , heif_security_limits_max_items = BG.getField @"heif_security_limits_max_items" x0
                               , heif_security_limits_max_color_profile_size = BG.getField @"heif_security_limits_max_color_profile_size" x0
                               , heif_security_limits_max_memory_block_size = BG.getField @"heif_security_limits_max_memory_block_size" x0
                               , heif_security_limits_max_components = BG.getField @"heif_security_limits_max_components" x0
                               , heif_security_limits_max_size_entity_group = BG.getField @"heif_security_limits_max_size_entity_group" x0
                               , heif_security_limits_max_children_per_box = BG.getField @"heif_security_limits_max_children_per_box" x0
                               , heif_security_limits_max_total_memory = BG.getField @"heif_security_limits_max_total_memory" x0
                               , heif_security_limits_max_sample_description_box_entries = BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
                               , heif_security_limits_max_sample_group_description_box_entries = BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
                               , heif_security_limits_max_sequence_frames = BG.getField @"heif_security_limits_max_sequence_frames" x0
                               , heif_security_limits_max_number_of_file_brands = BG.getField @"heif_security_limits_max_number_of_file_brands" x0
                               , heif_security_limits_max_bad_pixels = BG.getField @"heif_security_limits_max_bad_pixels" x0
                               , heif_security_limits_max_iso23001_17_pixel_size_bytes = BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
                               , heif_security_limits_parent = BG.getField @"heif_security_limits_parent" x0
                               }
      , BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_security_limits_max_iloc_extents_per_item" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_max_iloc_extents_per_item")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_max_iloc_extents_per_item" where

  type CFieldType Heif_security_limits "heif_security_limits_max_iloc_extents_per_item" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 52

{-| __C declaration:__ @max_size_entity_group@

    __defined at:__ @libheif\/heif_security.h 58:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_security_limits_max_size_entity_group" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_max_size_entity_group = y1
                               , heif_security_limits_version = BG.getField @"heif_security_limits_version" x0
                               , heif_security_limits_max_image_size_pixels = BG.getField @"heif_security_limits_max_image_size_pixels" x0
                               , heif_security_limits_max_number_of_tiles = BG.getField @"heif_security_limits_max_number_of_tiles" x0
                               , heif_security_limits_max_bayer_pattern_pixels = BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
                               , heif_security_limits_max_items = BG.getField @"heif_security_limits_max_items" x0
                               , heif_security_limits_max_color_profile_size = BG.getField @"heif_security_limits_max_color_profile_size" x0
                               , heif_security_limits_max_memory_block_size = BG.getField @"heif_security_limits_max_memory_block_size" x0
                               , heif_security_limits_max_components = BG.getField @"heif_security_limits_max_components" x0
                               , heif_security_limits_max_iloc_extents_per_item = BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
                               , heif_security_limits_max_children_per_box = BG.getField @"heif_security_limits_max_children_per_box" x0
                               , heif_security_limits_max_total_memory = BG.getField @"heif_security_limits_max_total_memory" x0
                               , heif_security_limits_max_sample_description_box_entries = BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
                               , heif_security_limits_max_sample_group_description_box_entries = BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
                               , heif_security_limits_max_sequence_frames = BG.getField @"heif_security_limits_max_sequence_frames" x0
                               , heif_security_limits_max_number_of_file_brands = BG.getField @"heif_security_limits_max_number_of_file_brands" x0
                               , heif_security_limits_max_bad_pixels = BG.getField @"heif_security_limits_max_bad_pixels" x0
                               , heif_security_limits_max_iso23001_17_pixel_size_bytes = BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
                               , heif_security_limits_parent = BG.getField @"heif_security_limits_parent" x0
                               }
      , BG.getField @"heif_security_limits_max_size_entity_group" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_security_limits_max_size_entity_group" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_max_size_entity_group")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_max_size_entity_group" where

  type CFieldType Heif_security_limits "heif_security_limits_max_size_entity_group" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 56

{-| __C declaration:__ @max_children_per_box@

    __defined at:__ @libheif\/heif_security.h 60:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_security_limits_max_children_per_box" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_max_children_per_box = y1
                               , heif_security_limits_version = BG.getField @"heif_security_limits_version" x0
                               , heif_security_limits_max_image_size_pixels = BG.getField @"heif_security_limits_max_image_size_pixels" x0
                               , heif_security_limits_max_number_of_tiles = BG.getField @"heif_security_limits_max_number_of_tiles" x0
                               , heif_security_limits_max_bayer_pattern_pixels = BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
                               , heif_security_limits_max_items = BG.getField @"heif_security_limits_max_items" x0
                               , heif_security_limits_max_color_profile_size = BG.getField @"heif_security_limits_max_color_profile_size" x0
                               , heif_security_limits_max_memory_block_size = BG.getField @"heif_security_limits_max_memory_block_size" x0
                               , heif_security_limits_max_components = BG.getField @"heif_security_limits_max_components" x0
                               , heif_security_limits_max_iloc_extents_per_item = BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
                               , heif_security_limits_max_size_entity_group = BG.getField @"heif_security_limits_max_size_entity_group" x0
                               , heif_security_limits_max_total_memory = BG.getField @"heif_security_limits_max_total_memory" x0
                               , heif_security_limits_max_sample_description_box_entries = BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
                               , heif_security_limits_max_sample_group_description_box_entries = BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
                               , heif_security_limits_max_sequence_frames = BG.getField @"heif_security_limits_max_sequence_frames" x0
                               , heif_security_limits_max_number_of_file_brands = BG.getField @"heif_security_limits_max_number_of_file_brands" x0
                               , heif_security_limits_max_bad_pixels = BG.getField @"heif_security_limits_max_bad_pixels" x0
                               , heif_security_limits_max_iso23001_17_pixel_size_bytes = BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
                               , heif_security_limits_parent = BG.getField @"heif_security_limits_parent" x0
                               }
      , BG.getField @"heif_security_limits_max_children_per_box" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_security_limits_max_children_per_box" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_max_children_per_box")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_max_children_per_box" where

  type CFieldType Heif_security_limits "heif_security_limits_max_children_per_box" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 60

{-| __C declaration:__ @max_total_memory@

    __defined at:__ @libheif\/heif_security.h 64:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word64
         ) => BG.CompatHasField.HasField "heif_security_limits_max_total_memory" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_max_total_memory = y1
                               , heif_security_limits_version = BG.getField @"heif_security_limits_version" x0
                               , heif_security_limits_max_image_size_pixels = BG.getField @"heif_security_limits_max_image_size_pixels" x0
                               , heif_security_limits_max_number_of_tiles = BG.getField @"heif_security_limits_max_number_of_tiles" x0
                               , heif_security_limits_max_bayer_pattern_pixels = BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
                               , heif_security_limits_max_items = BG.getField @"heif_security_limits_max_items" x0
                               , heif_security_limits_max_color_profile_size = BG.getField @"heif_security_limits_max_color_profile_size" x0
                               , heif_security_limits_max_memory_block_size = BG.getField @"heif_security_limits_max_memory_block_size" x0
                               , heif_security_limits_max_components = BG.getField @"heif_security_limits_max_components" x0
                               , heif_security_limits_max_iloc_extents_per_item = BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
                               , heif_security_limits_max_size_entity_group = BG.getField @"heif_security_limits_max_size_entity_group" x0
                               , heif_security_limits_max_children_per_box = BG.getField @"heif_security_limits_max_children_per_box" x0
                               , heif_security_limits_max_sample_description_box_entries = BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
                               , heif_security_limits_max_sample_group_description_box_entries = BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
                               , heif_security_limits_max_sequence_frames = BG.getField @"heif_security_limits_max_sequence_frames" x0
                               , heif_security_limits_max_number_of_file_brands = BG.getField @"heif_security_limits_max_number_of_file_brands" x0
                               , heif_security_limits_max_bad_pixels = BG.getField @"heif_security_limits_max_bad_pixels" x0
                               , heif_security_limits_max_iso23001_17_pixel_size_bytes = BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
                               , heif_security_limits_parent = BG.getField @"heif_security_limits_parent" x0
                               }
      , BG.getField @"heif_security_limits_max_total_memory" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word64
         ) => BG.HasField "heif_security_limits_max_total_memory" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_max_total_memory")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_max_total_memory" where

  type CFieldType Heif_security_limits "heif_security_limits_max_total_memory" =
    HsBindgen.Runtime.LibC.Word64

  offset# = \_ -> \_ -> 64

{-| __C declaration:__ @max_sample_description_box_entries@

    __defined at:__ @libheif\/heif_security.h 65:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_security_limits_max_sample_description_box_entries" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_max_sample_description_box_entries = y1
                               , heif_security_limits_version = BG.getField @"heif_security_limits_version" x0
                               , heif_security_limits_max_image_size_pixels = BG.getField @"heif_security_limits_max_image_size_pixels" x0
                               , heif_security_limits_max_number_of_tiles = BG.getField @"heif_security_limits_max_number_of_tiles" x0
                               , heif_security_limits_max_bayer_pattern_pixels = BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
                               , heif_security_limits_max_items = BG.getField @"heif_security_limits_max_items" x0
                               , heif_security_limits_max_color_profile_size = BG.getField @"heif_security_limits_max_color_profile_size" x0
                               , heif_security_limits_max_memory_block_size = BG.getField @"heif_security_limits_max_memory_block_size" x0
                               , heif_security_limits_max_components = BG.getField @"heif_security_limits_max_components" x0
                               , heif_security_limits_max_iloc_extents_per_item = BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
                               , heif_security_limits_max_size_entity_group = BG.getField @"heif_security_limits_max_size_entity_group" x0
                               , heif_security_limits_max_children_per_box = BG.getField @"heif_security_limits_max_children_per_box" x0
                               , heif_security_limits_max_total_memory = BG.getField @"heif_security_limits_max_total_memory" x0
                               , heif_security_limits_max_sample_group_description_box_entries = BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
                               , heif_security_limits_max_sequence_frames = BG.getField @"heif_security_limits_max_sequence_frames" x0
                               , heif_security_limits_max_number_of_file_brands = BG.getField @"heif_security_limits_max_number_of_file_brands" x0
                               , heif_security_limits_max_bad_pixels = BG.getField @"heif_security_limits_max_bad_pixels" x0
                               , heif_security_limits_max_iso23001_17_pixel_size_bytes = BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
                               , heif_security_limits_parent = BG.getField @"heif_security_limits_parent" x0
                               }
      , BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_security_limits_max_sample_description_box_entries" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_max_sample_description_box_entries")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_max_sample_description_box_entries" where

  type CFieldType Heif_security_limits "heif_security_limits_max_sample_description_box_entries" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 72

{-| __C declaration:__ @max_sample_group_description_box_entries@

    __defined at:__ @libheif\/heif_security.h 66:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_security_limits_max_sample_group_description_box_entries" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_max_sample_group_description_box_entries = y1
                               , heif_security_limits_version = BG.getField @"heif_security_limits_version" x0
                               , heif_security_limits_max_image_size_pixels = BG.getField @"heif_security_limits_max_image_size_pixels" x0
                               , heif_security_limits_max_number_of_tiles = BG.getField @"heif_security_limits_max_number_of_tiles" x0
                               , heif_security_limits_max_bayer_pattern_pixels = BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
                               , heif_security_limits_max_items = BG.getField @"heif_security_limits_max_items" x0
                               , heif_security_limits_max_color_profile_size = BG.getField @"heif_security_limits_max_color_profile_size" x0
                               , heif_security_limits_max_memory_block_size = BG.getField @"heif_security_limits_max_memory_block_size" x0
                               , heif_security_limits_max_components = BG.getField @"heif_security_limits_max_components" x0
                               , heif_security_limits_max_iloc_extents_per_item = BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
                               , heif_security_limits_max_size_entity_group = BG.getField @"heif_security_limits_max_size_entity_group" x0
                               , heif_security_limits_max_children_per_box = BG.getField @"heif_security_limits_max_children_per_box" x0
                               , heif_security_limits_max_total_memory = BG.getField @"heif_security_limits_max_total_memory" x0
                               , heif_security_limits_max_sample_description_box_entries = BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
                               , heif_security_limits_max_sequence_frames = BG.getField @"heif_security_limits_max_sequence_frames" x0
                               , heif_security_limits_max_number_of_file_brands = BG.getField @"heif_security_limits_max_number_of_file_brands" x0
                               , heif_security_limits_max_bad_pixels = BG.getField @"heif_security_limits_max_bad_pixels" x0
                               , heif_security_limits_max_iso23001_17_pixel_size_bytes = BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
                               , heif_security_limits_parent = BG.getField @"heif_security_limits_parent" x0
                               }
      , BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_security_limits_max_sample_group_description_box_entries" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_max_sample_group_description_box_entries")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_max_sample_group_description_box_entries" where

  type CFieldType Heif_security_limits "heif_security_limits_max_sample_group_description_box_entries" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 76

{-| __C declaration:__ @max_sequence_frames@

    __defined at:__ @libheif\/heif_security.h 70:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_security_limits_max_sequence_frames" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_max_sequence_frames = y1
                               , heif_security_limits_version = BG.getField @"heif_security_limits_version" x0
                               , heif_security_limits_max_image_size_pixels = BG.getField @"heif_security_limits_max_image_size_pixels" x0
                               , heif_security_limits_max_number_of_tiles = BG.getField @"heif_security_limits_max_number_of_tiles" x0
                               , heif_security_limits_max_bayer_pattern_pixels = BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
                               , heif_security_limits_max_items = BG.getField @"heif_security_limits_max_items" x0
                               , heif_security_limits_max_color_profile_size = BG.getField @"heif_security_limits_max_color_profile_size" x0
                               , heif_security_limits_max_memory_block_size = BG.getField @"heif_security_limits_max_memory_block_size" x0
                               , heif_security_limits_max_components = BG.getField @"heif_security_limits_max_components" x0
                               , heif_security_limits_max_iloc_extents_per_item = BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
                               , heif_security_limits_max_size_entity_group = BG.getField @"heif_security_limits_max_size_entity_group" x0
                               , heif_security_limits_max_children_per_box = BG.getField @"heif_security_limits_max_children_per_box" x0
                               , heif_security_limits_max_total_memory = BG.getField @"heif_security_limits_max_total_memory" x0
                               , heif_security_limits_max_sample_description_box_entries = BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
                               , heif_security_limits_max_sample_group_description_box_entries = BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
                               , heif_security_limits_max_number_of_file_brands = BG.getField @"heif_security_limits_max_number_of_file_brands" x0
                               , heif_security_limits_max_bad_pixels = BG.getField @"heif_security_limits_max_bad_pixels" x0
                               , heif_security_limits_max_iso23001_17_pixel_size_bytes = BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
                               , heif_security_limits_parent = BG.getField @"heif_security_limits_parent" x0
                               }
      , BG.getField @"heif_security_limits_max_sequence_frames" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_security_limits_max_sequence_frames" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_max_sequence_frames")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_max_sequence_frames" where

  type CFieldType Heif_security_limits "heif_security_limits_max_sequence_frames" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 80

{-| __C declaration:__ @max_number_of_file_brands@

    __defined at:__ @libheif\/heif_security.h 71:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_security_limits_max_number_of_file_brands" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_max_number_of_file_brands = y1
                               , heif_security_limits_version = BG.getField @"heif_security_limits_version" x0
                               , heif_security_limits_max_image_size_pixels = BG.getField @"heif_security_limits_max_image_size_pixels" x0
                               , heif_security_limits_max_number_of_tiles = BG.getField @"heif_security_limits_max_number_of_tiles" x0
                               , heif_security_limits_max_bayer_pattern_pixels = BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
                               , heif_security_limits_max_items = BG.getField @"heif_security_limits_max_items" x0
                               , heif_security_limits_max_color_profile_size = BG.getField @"heif_security_limits_max_color_profile_size" x0
                               , heif_security_limits_max_memory_block_size = BG.getField @"heif_security_limits_max_memory_block_size" x0
                               , heif_security_limits_max_components = BG.getField @"heif_security_limits_max_components" x0
                               , heif_security_limits_max_iloc_extents_per_item = BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
                               , heif_security_limits_max_size_entity_group = BG.getField @"heif_security_limits_max_size_entity_group" x0
                               , heif_security_limits_max_children_per_box = BG.getField @"heif_security_limits_max_children_per_box" x0
                               , heif_security_limits_max_total_memory = BG.getField @"heif_security_limits_max_total_memory" x0
                               , heif_security_limits_max_sample_description_box_entries = BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
                               , heif_security_limits_max_sample_group_description_box_entries = BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
                               , heif_security_limits_max_sequence_frames = BG.getField @"heif_security_limits_max_sequence_frames" x0
                               , heif_security_limits_max_bad_pixels = BG.getField @"heif_security_limits_max_bad_pixels" x0
                               , heif_security_limits_max_iso23001_17_pixel_size_bytes = BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
                               , heif_security_limits_parent = BG.getField @"heif_security_limits_parent" x0
                               }
      , BG.getField @"heif_security_limits_max_number_of_file_brands" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_security_limits_max_number_of_file_brands" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_max_number_of_file_brands")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_max_number_of_file_brands" where

  type CFieldType Heif_security_limits "heif_security_limits_max_number_of_file_brands" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 84

{-| __C declaration:__ @max_bad_pixels@

    __defined at:__ @libheif\/heif_security.h 75:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_security_limits_max_bad_pixels" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_max_bad_pixels = y1
                               , heif_security_limits_version = BG.getField @"heif_security_limits_version" x0
                               , heif_security_limits_max_image_size_pixels = BG.getField @"heif_security_limits_max_image_size_pixels" x0
                               , heif_security_limits_max_number_of_tiles = BG.getField @"heif_security_limits_max_number_of_tiles" x0
                               , heif_security_limits_max_bayer_pattern_pixels = BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
                               , heif_security_limits_max_items = BG.getField @"heif_security_limits_max_items" x0
                               , heif_security_limits_max_color_profile_size = BG.getField @"heif_security_limits_max_color_profile_size" x0
                               , heif_security_limits_max_memory_block_size = BG.getField @"heif_security_limits_max_memory_block_size" x0
                               , heif_security_limits_max_components = BG.getField @"heif_security_limits_max_components" x0
                               , heif_security_limits_max_iloc_extents_per_item = BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
                               , heif_security_limits_max_size_entity_group = BG.getField @"heif_security_limits_max_size_entity_group" x0
                               , heif_security_limits_max_children_per_box = BG.getField @"heif_security_limits_max_children_per_box" x0
                               , heif_security_limits_max_total_memory = BG.getField @"heif_security_limits_max_total_memory" x0
                               , heif_security_limits_max_sample_description_box_entries = BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
                               , heif_security_limits_max_sample_group_description_box_entries = BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
                               , heif_security_limits_max_sequence_frames = BG.getField @"heif_security_limits_max_sequence_frames" x0
                               , heif_security_limits_max_number_of_file_brands = BG.getField @"heif_security_limits_max_number_of_file_brands" x0
                               , heif_security_limits_max_iso23001_17_pixel_size_bytes = BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
                               , heif_security_limits_parent = BG.getField @"heif_security_limits_parent" x0
                               }
      , BG.getField @"heif_security_limits_max_bad_pixels" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_security_limits_max_bad_pixels" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_max_bad_pixels")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_max_bad_pixels" where

  type CFieldType Heif_security_limits "heif_security_limits_max_bad_pixels" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 88

{-| __C declaration:__ @max_iso23001_17_pixel_size_bytes@

    __defined at:__ @libheif\/heif_security.h 80:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_security_limits_max_iso23001_17_pixel_size_bytes" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_max_iso23001_17_pixel_size_bytes = y1
                               , heif_security_limits_version = BG.getField @"heif_security_limits_version" x0
                               , heif_security_limits_max_image_size_pixels = BG.getField @"heif_security_limits_max_image_size_pixels" x0
                               , heif_security_limits_max_number_of_tiles = BG.getField @"heif_security_limits_max_number_of_tiles" x0
                               , heif_security_limits_max_bayer_pattern_pixels = BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
                               , heif_security_limits_max_items = BG.getField @"heif_security_limits_max_items" x0
                               , heif_security_limits_max_color_profile_size = BG.getField @"heif_security_limits_max_color_profile_size" x0
                               , heif_security_limits_max_memory_block_size = BG.getField @"heif_security_limits_max_memory_block_size" x0
                               , heif_security_limits_max_components = BG.getField @"heif_security_limits_max_components" x0
                               , heif_security_limits_max_iloc_extents_per_item = BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
                               , heif_security_limits_max_size_entity_group = BG.getField @"heif_security_limits_max_size_entity_group" x0
                               , heif_security_limits_max_children_per_box = BG.getField @"heif_security_limits_max_children_per_box" x0
                               , heif_security_limits_max_total_memory = BG.getField @"heif_security_limits_max_total_memory" x0
                               , heif_security_limits_max_sample_description_box_entries = BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
                               , heif_security_limits_max_sample_group_description_box_entries = BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
                               , heif_security_limits_max_sequence_frames = BG.getField @"heif_security_limits_max_sequence_frames" x0
                               , heif_security_limits_max_number_of_file_brands = BG.getField @"heif_security_limits_max_number_of_file_brands" x0
                               , heif_security_limits_max_bad_pixels = BG.getField @"heif_security_limits_max_bad_pixels" x0
                               , heif_security_limits_parent = BG.getField @"heif_security_limits_parent" x0
                               }
      , BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_security_limits_max_iso23001_17_pixel_size_bytes" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_max_iso23001_17_pixel_size_bytes")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_max_iso23001_17_pixel_size_bytes" where

  type CFieldType Heif_security_limits "heif_security_limits_max_iso23001_17_pixel_size_bytes" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 92

{-| __C declaration:__ @parent@

    __defined at:__ @libheif\/heif_security.h 87:38@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ PtrConst.PtrConst Heif_security_limits
         ) => BG.CompatHasField.HasField "heif_security_limits_parent" Heif_security_limits ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_security_limits { heif_security_limits_parent = y1
                               , heif_security_limits_version = BG.getField @"heif_security_limits_version" x0
                               , heif_security_limits_max_image_size_pixels = BG.getField @"heif_security_limits_max_image_size_pixels" x0
                               , heif_security_limits_max_number_of_tiles = BG.getField @"heif_security_limits_max_number_of_tiles" x0
                               , heif_security_limits_max_bayer_pattern_pixels = BG.getField @"heif_security_limits_max_bayer_pattern_pixels" x0
                               , heif_security_limits_max_items = BG.getField @"heif_security_limits_max_items" x0
                               , heif_security_limits_max_color_profile_size = BG.getField @"heif_security_limits_max_color_profile_size" x0
                               , heif_security_limits_max_memory_block_size = BG.getField @"heif_security_limits_max_memory_block_size" x0
                               , heif_security_limits_max_components = BG.getField @"heif_security_limits_max_components" x0
                               , heif_security_limits_max_iloc_extents_per_item = BG.getField @"heif_security_limits_max_iloc_extents_per_item" x0
                               , heif_security_limits_max_size_entity_group = BG.getField @"heif_security_limits_max_size_entity_group" x0
                               , heif_security_limits_max_children_per_box = BG.getField @"heif_security_limits_max_children_per_box" x0
                               , heif_security_limits_max_total_memory = BG.getField @"heif_security_limits_max_total_memory" x0
                               , heif_security_limits_max_sample_description_box_entries = BG.getField @"heif_security_limits_max_sample_description_box_entries" x0
                               , heif_security_limits_max_sample_group_description_box_entries = BG.getField @"heif_security_limits_max_sample_group_description_box_entries" x0
                               , heif_security_limits_max_sequence_frames = BG.getField @"heif_security_limits_max_sequence_frames" x0
                               , heif_security_limits_max_number_of_file_brands = BG.getField @"heif_security_limits_max_number_of_file_brands" x0
                               , heif_security_limits_max_bad_pixels = BG.getField @"heif_security_limits_max_bad_pixels" x0
                               , heif_security_limits_max_iso23001_17_pixel_size_bytes = BG.getField @"heif_security_limits_max_iso23001_17_pixel_size_bytes" x0
                               }
      , BG.getField @"heif_security_limits_parent" x0
      )

instance ( ty ~ PtrConst.PtrConst Heif_security_limits
         ) => BG.HasField "heif_security_limits_parent" (BG.Ptr Heif_security_limits) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_security_limits_parent")

instance HasCField.HasCField Heif_security_limits "heif_security_limits_parent" where

  type CFieldType Heif_security_limits "heif_security_limits_parent" =
    PtrConst.PtrConst Heif_security_limits

  offset# = \_ -> \_ -> 96

{-| __C declaration:__ @enum heif_compression_format@

    __defined at:__ @libheif\/heif_context.h 38:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_compression_format = Heif_compression_format
  { unwrapHeif_compression_format :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_compression_format where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_compression_format where

  readRaw =
    \ptr0 ->
          pure Heif_compression_format
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_compression_format where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_compression_format unwrapHeif_compression_format2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_compression_format2

deriving via Marshal.EquivStorable Heif_compression_format instance BG.Storable Heif_compression_format

deriving via BG.CUInt instance BG.Prim Heif_compression_format

instance CEnum.CEnum Heif_compression_format where

  type CEnumZ Heif_compression_format = BG.CUInt

  toCEnum = Heif_compression_format

  fromCEnum =
    BG.getField @"unwrapHeif_compression_format"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_compression_undefined")
                                   , (1, BG.singleton "Heif_compression_HEVC")
                                   , (2, BG.singleton "Heif_compression_AVC")
                                   , (3, BG.singleton "Heif_compression_JPEG")
                                   , (4, BG.singleton "Heif_compression_AV1")
                                   , (5, BG.singleton "Heif_compression_VVC")
                                   , (6, BG.singleton "Heif_compression_EVC")
                                   , (7, BG.singleton "Heif_compression_JPEG2000")
                                   , (8, BG.singleton "Heif_compression_uncompressed")
                                   , (9, BG.singleton "Heif_compression_mask")
                                   , (10, BG.singleton "Heif_compression_HTJ2K")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_compression_format"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_compression_format"

  isDeclared = CEnum.seqIsDeclared

  mkDeclared = CEnum.seqMkDeclared

instance CEnum.SequentialCEnum Heif_compression_format where

  minDeclaredValue = Heif_compression_undefined

  maxDeclaredValue = Heif_compression_HTJ2K

instance Show Heif_compression_format where

  showsPrec = CEnum.shows

instance Read Heif_compression_format where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_compression_format" Heif_compression_format ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_compression_format {unwrapHeif_compression_format = y1}
      , BG.getField @"unwrapHeif_compression_format" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_compression_format" (BG.Ptr Heif_compression_format) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_compression_format")

instance HasCField.HasCField Heif_compression_format "unwrapHeif_compression_format" where

  type CFieldType Heif_compression_format "unwrapHeif_compression_format" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_compression_undefined@

    __defined at:__ @libheif\/heif_context.h 46:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_compression_undefined :: Heif_compression_format
pattern Heif_compression_undefined = Heif_compression_format 0

{-| __C declaration:__ @heif_compression_HEVC@

    __defined at:__ @libheif\/heif_context.h 52:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_compression_HEVC :: Heif_compression_format
pattern Heif_compression_HEVC = Heif_compression_format 1

{-| __C declaration:__ @heif_compression_AVC@

    __defined at:__ @libheif\/heif_context.h 60:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_compression_AVC :: Heif_compression_format
pattern Heif_compression_AVC = Heif_compression_format 2

{-| __C declaration:__ @heif_compression_JPEG@

    __defined at:__ @libheif\/heif_context.h 67:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_compression_JPEG :: Heif_compression_format
pattern Heif_compression_JPEG = Heif_compression_format 3

{-| __C declaration:__ @heif_compression_AV1@

    __defined at:__ @libheif\/heif_context.h 75:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_compression_AV1 :: Heif_compression_format
pattern Heif_compression_AV1 = Heif_compression_format 4

{-| __C declaration:__ @heif_compression_VVC@

    __defined at:__ @libheif\/heif_context.h 83:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_compression_VVC :: Heif_compression_format
pattern Heif_compression_VVC = Heif_compression_format 5

{-| __C declaration:__ @heif_compression_EVC@

    __defined at:__ @libheif\/heif_context.h 91:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_compression_EVC :: Heif_compression_format
pattern Heif_compression_EVC = Heif_compression_format 6

{-| __C declaration:__ @heif_compression_JPEG2000@

    __defined at:__ @libheif\/heif_context.h 98:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_compression_JPEG2000 :: Heif_compression_format
pattern Heif_compression_JPEG2000 = Heif_compression_format 7

{-| __C declaration:__ @heif_compression_uncompressed@

    __defined at:__ @libheif\/heif_context.h 104:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_compression_uncompressed :: Heif_compression_format
pattern Heif_compression_uncompressed = Heif_compression_format 8

{-| __C declaration:__ @heif_compression_mask@

    __defined at:__ @libheif\/heif_context.h 110:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_compression_mask :: Heif_compression_format
pattern Heif_compression_mask = Heif_compression_format 9

{-| __C declaration:__ @heif_compression_HTJ2K@

    __defined at:__ @libheif\/heif_context.h 117:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_compression_HTJ2K :: Heif_compression_format
pattern Heif_compression_HTJ2K = Heif_compression_format 10

{-| __C declaration:__ @struct heif_reading_options@

    __defined at:__ @libheif\/heif_context.h 137:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_reading_options

{-| __C declaration:__ @enum heif_reader_grow_status@

    __defined at:__ @libheif\/heif_context.h 139:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_reader_grow_status = Heif_reader_grow_status
  { unwrapHeif_reader_grow_status :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_reader_grow_status where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_reader_grow_status where

  readRaw =
    \ptr0 ->
          pure Heif_reader_grow_status
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_reader_grow_status where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_reader_grow_status unwrapHeif_reader_grow_status2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_reader_grow_status2

deriving via Marshal.EquivStorable Heif_reader_grow_status instance BG.Storable Heif_reader_grow_status

deriving via BG.CUInt instance BG.Prim Heif_reader_grow_status

instance CEnum.CEnum Heif_reader_grow_status where

  type CEnumZ Heif_reader_grow_status = BG.CUInt

  toCEnum = Heif_reader_grow_status

  fromCEnum =
    BG.getField @"unwrapHeif_reader_grow_status"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_reader_grow_status_size_reached")
                                   , (1, BG.singleton "Heif_reader_grow_status_timeout")
                                   , (2, BG.singleton "Heif_reader_grow_status_size_beyond_eof")
                                   , (3, BG.singleton "Heif_reader_grow_status_error")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_reader_grow_status"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_reader_grow_status"

  isDeclared = CEnum.seqIsDeclared

  mkDeclared = CEnum.seqMkDeclared

instance CEnum.SequentialCEnum Heif_reader_grow_status where

  minDeclaredValue =
    Heif_reader_grow_status_size_reached

  maxDeclaredValue = Heif_reader_grow_status_error

instance Show Heif_reader_grow_status where

  showsPrec = CEnum.shows

instance Read Heif_reader_grow_status where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_reader_grow_status" Heif_reader_grow_status ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_reader_grow_status {unwrapHeif_reader_grow_status = y1}
      , BG.getField @"unwrapHeif_reader_grow_status" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_reader_grow_status" (BG.Ptr Heif_reader_grow_status) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_reader_grow_status")

instance HasCField.HasCField Heif_reader_grow_status "unwrapHeif_reader_grow_status" where

  type CFieldType Heif_reader_grow_status "unwrapHeif_reader_grow_status" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_reader_grow_status_size_reached@

    __defined at:__ @libheif\/heif_context.h 141:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_reader_grow_status_size_reached :: Heif_reader_grow_status
pattern Heif_reader_grow_status_size_reached = Heif_reader_grow_status 0

{-| __C declaration:__ @heif_reader_grow_status_timeout@

    __defined at:__ @libheif\/heif_context.h 142:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_reader_grow_status_timeout :: Heif_reader_grow_status
pattern Heif_reader_grow_status_timeout = Heif_reader_grow_status 1

{-| __C declaration:__ @heif_reader_grow_status_size_beyond_eof@

    __defined at:__ @libheif\/heif_context.h 143:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_reader_grow_status_size_beyond_eof :: Heif_reader_grow_status
pattern Heif_reader_grow_status_size_beyond_eof = Heif_reader_grow_status 2

{-| __C declaration:__ @heif_reader_grow_status_error@

    __defined at:__ @libheif\/heif_context.h 144:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_reader_grow_status_error :: Heif_reader_grow_status
pattern Heif_reader_grow_status_error = Heif_reader_grow_status 3

{-| __C declaration:__ @struct heif_reader_range_request_result@

    __defined at:__ @libheif\/heif_context.h 148:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_reader_range_request_result = Heif_reader_range_request_result
  { heif_reader_range_request_result_status :: Heif_reader_grow_status
    {- ^ __C declaration:__ @status@

         __defined at:__ @libheif\/heif_context.h 150:32@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_reader_range_request_result_range_end :: HsBindgen.Runtime.LibC.Word64
    {- ^ __C declaration:__ @range_end@

         __defined at:__ @libheif\/heif_context.h 156:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_reader_range_request_result_reader_error_code :: BG.CInt
    {- ^ __C declaration:__ @reader_error_code@

         __defined at:__ @libheif\/heif_context.h 159:7@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_reader_range_request_result_reader_error_msg :: PtrConst.PtrConst BG.CChar
    {- ^ __C declaration:__ @reader_error_msg@

         __defined at:__ @libheif\/heif_context.h 160:15@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_reader_range_request_result where

  staticSizeOf = \_ -> (32 :: Int)

  staticAlignment = \_ -> (8 :: Int)

instance Marshal.ReadRaw Heif_reader_range_request_result where

  readRaw =
    \ptr0 ->
          pure Heif_reader_range_request_result
      <*> HasCField.readRaw (BG.Proxy @"heif_reader_range_request_result_status") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_reader_range_request_result_range_end") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_reader_range_request_result_reader_error_code") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_reader_range_request_result_reader_error_msg") ptr0

instance Marshal.WriteRaw Heif_reader_range_request_result where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_reader_range_request_result
            heif_reader_range_request_result_status2
            heif_reader_range_request_result_range_end3
            heif_reader_range_request_result_reader_error_code4
            heif_reader_range_request_result_reader_error_msg5 ->
                 HasCField.writeRaw (BG.Proxy @"heif_reader_range_request_result_status") ptr0 heif_reader_range_request_result_status2
              >> HasCField.writeRaw (BG.Proxy @"heif_reader_range_request_result_range_end") ptr0 heif_reader_range_request_result_range_end3
              >> HasCField.writeRaw (BG.Proxy @"heif_reader_range_request_result_reader_error_code") ptr0 heif_reader_range_request_result_reader_error_code4
              >> HasCField.writeRaw (BG.Proxy @"heif_reader_range_request_result_reader_error_msg") ptr0 heif_reader_range_request_result_reader_error_msg5

deriving via Marshal.EquivStorable Heif_reader_range_request_result instance BG.Storable Heif_reader_range_request_result

deriving via Struct.IsStructViaReadRaw Heif_reader_range_request_result instance Struct.IsStruct Heif_reader_range_request_result

{-| __C declaration:__ @status@

    __defined at:__ @libheif\/heif_context.h 150:32@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ Heif_reader_grow_status
         ) => BG.CompatHasField.HasField "heif_reader_range_request_result_status" Heif_reader_range_request_result ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_reader_range_request_result { heif_reader_range_request_result_status = y1
                                           , heif_reader_range_request_result_range_end = BG.getField @"heif_reader_range_request_result_range_end" x0
                                           , heif_reader_range_request_result_reader_error_code = BG.getField @"heif_reader_range_request_result_reader_error_code" x0
                                           , heif_reader_range_request_result_reader_error_msg = BG.getField @"heif_reader_range_request_result_reader_error_msg" x0
                                           }
      , BG.getField @"heif_reader_range_request_result_status" x0
      )

instance ( ty ~ Heif_reader_grow_status
         ) => BG.HasField "heif_reader_range_request_result_status" (BG.Ptr Heif_reader_range_request_result) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_reader_range_request_result_status")

instance HasCField.HasCField Heif_reader_range_request_result "heif_reader_range_request_result_status" where

  type CFieldType Heif_reader_range_request_result "heif_reader_range_request_result_status" =
    Heif_reader_grow_status

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @range_end@

    __defined at:__ @libheif\/heif_context.h 156:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word64
         ) => BG.CompatHasField.HasField "heif_reader_range_request_result_range_end" Heif_reader_range_request_result ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_reader_range_request_result { heif_reader_range_request_result_range_end = y1
                                           , heif_reader_range_request_result_status = BG.getField @"heif_reader_range_request_result_status" x0
                                           , heif_reader_range_request_result_reader_error_code = BG.getField @"heif_reader_range_request_result_reader_error_code" x0
                                           , heif_reader_range_request_result_reader_error_msg = BG.getField @"heif_reader_range_request_result_reader_error_msg" x0
                                           }
      , BG.getField @"heif_reader_range_request_result_range_end" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word64
         ) => BG.HasField "heif_reader_range_request_result_range_end" (BG.Ptr Heif_reader_range_request_result) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_reader_range_request_result_range_end")

instance HasCField.HasCField Heif_reader_range_request_result "heif_reader_range_request_result_range_end" where

  type CFieldType Heif_reader_range_request_result "heif_reader_range_request_result_range_end" =
    HsBindgen.Runtime.LibC.Word64

  offset# = \_ -> \_ -> 8

{-| __C declaration:__ @reader_error_code@

    __defined at:__ @libheif\/heif_context.h 159:7@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CInt
         ) => BG.CompatHasField.HasField "heif_reader_range_request_result_reader_error_code" Heif_reader_range_request_result ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_reader_range_request_result { heif_reader_range_request_result_reader_error_code = y1
                                           , heif_reader_range_request_result_status = BG.getField @"heif_reader_range_request_result_status" x0
                                           , heif_reader_range_request_result_range_end = BG.getField @"heif_reader_range_request_result_range_end" x0
                                           , heif_reader_range_request_result_reader_error_msg = BG.getField @"heif_reader_range_request_result_reader_error_msg" x0
                                           }
      , BG.getField @"heif_reader_range_request_result_reader_error_code" x0
      )

instance ( ty ~ BG.CInt
         ) => BG.HasField "heif_reader_range_request_result_reader_error_code" (BG.Ptr Heif_reader_range_request_result) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_reader_range_request_result_reader_error_code")

instance HasCField.HasCField Heif_reader_range_request_result "heif_reader_range_request_result_reader_error_code" where

  type CFieldType Heif_reader_range_request_result "heif_reader_range_request_result_reader_error_code" =
    BG.CInt

  offset# = \_ -> \_ -> 16

{-| __C declaration:__ @reader_error_msg@

    __defined at:__ @libheif\/heif_context.h 160:15@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ PtrConst.PtrConst BG.CChar
         ) => BG.CompatHasField.HasField "heif_reader_range_request_result_reader_error_msg" Heif_reader_range_request_result ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_reader_range_request_result { heif_reader_range_request_result_reader_error_msg = y1
                                           , heif_reader_range_request_result_status = BG.getField @"heif_reader_range_request_result_status" x0
                                           , heif_reader_range_request_result_range_end = BG.getField @"heif_reader_range_request_result_range_end" x0
                                           , heif_reader_range_request_result_reader_error_code = BG.getField @"heif_reader_range_request_result_reader_error_code" x0
                                           }
      , BG.getField @"heif_reader_range_request_result_reader_error_msg" x0
      )

instance ( ty ~ PtrConst.PtrConst BG.CChar
         ) => BG.HasField "heif_reader_range_request_result_reader_error_msg" (BG.Ptr Heif_reader_range_request_result) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_reader_range_request_result_reader_error_msg")

instance HasCField.HasCField Heif_reader_range_request_result "heif_reader_range_request_result_reader_error_msg" where

  type CFieldType Heif_reader_range_request_result "heif_reader_range_request_result_reader_error_msg" =
    PtrConst.PtrConst BG.CChar

  offset# = \_ -> \_ -> 24

{-| __C declaration:__ @struct heif_reader@

    __defined at:__ @libheif\/heif_context.h 164:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_reader = Heif_reader
  { heif_reader_reader_api_version :: BG.CInt
    {- ^ __C declaration:__ @reader_api_version@

         __defined at:__ @libheif\/heif_context.h 167:7@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_reader_get_position :: BG.FunPtr (BG.Ptr BG.Void -> IO HsBindgen.Runtime.LibC.Int64)
    {- ^ __C declaration:__ @get_position@

         __defined at:__ @libheif\/heif_context.h 170:14@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_reader_read :: BG.FunPtr (BG.Ptr BG.Void -> HsBindgen.Runtime.LibC.CSize -> BG.Ptr BG.Void -> IO BG.CInt)
    {- ^ __C declaration:__ @read@

         __defined at:__ @libheif\/heif_context.h 174:10@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_reader_seek :: BG.FunPtr (HsBindgen.Runtime.LibC.Int64 -> BG.Ptr BG.Void -> IO BG.CInt)
    {- ^ __C declaration:__ @seek@

         __defined at:__ @libheif\/heif_context.h 178:10@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_reader_wait_for_file_size :: BG.FunPtr (HsBindgen.Runtime.LibC.Int64 -> BG.Ptr BG.Void -> IO Heif_reader_grow_status)
    {- ^ __C declaration:__ @wait_for_file_size@

         __defined at:__ @libheif\/heif_context.h 189:35@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_reader_request_range :: BG.FunPtr (HsBindgen.Runtime.LibC.Word64 -> HsBindgen.Runtime.LibC.Word64 -> BG.Ptr BG.Void -> IO Heif_reader_range_request_result)
    {- ^ __C declaration:__ @request_range@

         __defined at:__ @libheif\/heif_context.h 212:39@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_reader_preload_range_hint :: BG.FunPtr (HsBindgen.Runtime.LibC.Word64 -> HsBindgen.Runtime.LibC.Word64 -> BG.Ptr BG.Void -> IO ())
    {- ^ __C declaration:__ @preload_range_hint@

         __defined at:__ @libheif\/heif_context.h 219:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_reader_release_file_range :: BG.FunPtr (HsBindgen.Runtime.LibC.Word64 -> HsBindgen.Runtime.LibC.Word64 -> BG.Ptr BG.Void -> IO ())
    {- ^ __C declaration:__ @release_file_range@

         __defined at:__ @libheif\/heif_context.h 225:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_reader_release_error_msg :: BG.FunPtr (PtrConst.PtrConst BG.CChar -> IO ())
    {- ^ __C declaration:__ @release_error_msg@

         __defined at:__ @libheif\/heif_context.h 230:11@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_reader where

  staticSizeOf = \_ -> (72 :: Int)

  staticAlignment = \_ -> (8 :: Int)

instance Marshal.ReadRaw Heif_reader where

  readRaw =
    \ptr0 ->
          pure Heif_reader
      <*> HasCField.readRaw (BG.Proxy @"heif_reader_reader_api_version") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_reader_get_position") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_reader_read") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_reader_seek") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_reader_wait_for_file_size") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_reader_request_range") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_reader_preload_range_hint") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_reader_release_file_range") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_reader_release_error_msg") ptr0

instance Marshal.WriteRaw Heif_reader where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_reader
            heif_reader_reader_api_version2
            heif_reader_get_position3
            heif_reader_read4
            heif_reader_seek5
            heif_reader_wait_for_file_size6
            heif_reader_request_range7
            heif_reader_preload_range_hint8
            heif_reader_release_file_range9
            heif_reader_release_error_msg10 ->
                 HasCField.writeRaw (BG.Proxy @"heif_reader_reader_api_version") ptr0 heif_reader_reader_api_version2
              >> HasCField.writeRaw (BG.Proxy @"heif_reader_get_position") ptr0 heif_reader_get_position3
              >> HasCField.writeRaw (BG.Proxy @"heif_reader_read") ptr0 heif_reader_read4
              >> HasCField.writeRaw (BG.Proxy @"heif_reader_seek") ptr0 heif_reader_seek5
              >> HasCField.writeRaw (BG.Proxy @"heif_reader_wait_for_file_size") ptr0 heif_reader_wait_for_file_size6
              >> HasCField.writeRaw (BG.Proxy @"heif_reader_request_range") ptr0 heif_reader_request_range7
              >> HasCField.writeRaw (BG.Proxy @"heif_reader_preload_range_hint") ptr0 heif_reader_preload_range_hint8
              >> HasCField.writeRaw (BG.Proxy @"heif_reader_release_file_range") ptr0 heif_reader_release_file_range9
              >> HasCField.writeRaw (BG.Proxy @"heif_reader_release_error_msg") ptr0 heif_reader_release_error_msg10

deriving via Marshal.EquivStorable Heif_reader instance BG.Storable Heif_reader

deriving via Struct.IsStructViaReadRaw Heif_reader instance Struct.IsStruct Heif_reader

{-| __C declaration:__ @reader_api_version@

    __defined at:__ @libheif\/heif_context.h 167:7@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CInt
         ) => BG.CompatHasField.HasField "heif_reader_reader_api_version" Heif_reader ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_reader { heif_reader_reader_api_version = y1
                      , heif_reader_get_position = BG.getField @"heif_reader_get_position" x0
                      , heif_reader_read = BG.getField @"heif_reader_read" x0
                      , heif_reader_seek = BG.getField @"heif_reader_seek" x0
                      , heif_reader_wait_for_file_size = BG.getField @"heif_reader_wait_for_file_size" x0
                      , heif_reader_request_range = BG.getField @"heif_reader_request_range" x0
                      , heif_reader_preload_range_hint = BG.getField @"heif_reader_preload_range_hint" x0
                      , heif_reader_release_file_range = BG.getField @"heif_reader_release_file_range" x0
                      , heif_reader_release_error_msg = BG.getField @"heif_reader_release_error_msg" x0
                      }
      , BG.getField @"heif_reader_reader_api_version" x0
      )

instance ( ty ~ BG.CInt
         ) => BG.HasField "heif_reader_reader_api_version" (BG.Ptr Heif_reader) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_reader_reader_api_version")

instance HasCField.HasCField Heif_reader "heif_reader_reader_api_version" where

  type CFieldType Heif_reader "heif_reader_reader_api_version" =
    BG.CInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @get_position@

    __defined at:__ @libheif\/heif_context.h 170:14@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.FunPtr (BG.Ptr BG.Void -> IO HsBindgen.Runtime.LibC.Int64)
         ) => BG.CompatHasField.HasField "heif_reader_get_position" Heif_reader ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_reader { heif_reader_get_position = y1
                      , heif_reader_reader_api_version = BG.getField @"heif_reader_reader_api_version" x0
                      , heif_reader_read = BG.getField @"heif_reader_read" x0
                      , heif_reader_seek = BG.getField @"heif_reader_seek" x0
                      , heif_reader_wait_for_file_size = BG.getField @"heif_reader_wait_for_file_size" x0
                      , heif_reader_request_range = BG.getField @"heif_reader_request_range" x0
                      , heif_reader_preload_range_hint = BG.getField @"heif_reader_preload_range_hint" x0
                      , heif_reader_release_file_range = BG.getField @"heif_reader_release_file_range" x0
                      , heif_reader_release_error_msg = BG.getField @"heif_reader_release_error_msg" x0
                      }
      , BG.getField @"heif_reader_get_position" x0
      )

instance ( ty ~ BG.FunPtr (BG.Ptr BG.Void -> IO HsBindgen.Runtime.LibC.Int64)
         ) => BG.HasField "heif_reader_get_position" (BG.Ptr Heif_reader) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_reader_get_position")

instance HasCField.HasCField Heif_reader "heif_reader_get_position" where

  type CFieldType Heif_reader "heif_reader_get_position" =
    BG.FunPtr (BG.Ptr BG.Void -> IO HsBindgen.Runtime.LibC.Int64)

  offset# = \_ -> \_ -> 8

{-| __C declaration:__ @read@

    __defined at:__ @libheif\/heif_context.h 174:10@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.FunPtr (BG.Ptr BG.Void -> HsBindgen.Runtime.LibC.CSize -> BG.Ptr BG.Void -> IO BG.CInt)
         ) => BG.CompatHasField.HasField "heif_reader_read" Heif_reader ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_reader { heif_reader_read = y1
                      , heif_reader_reader_api_version = BG.getField @"heif_reader_reader_api_version" x0
                      , heif_reader_get_position = BG.getField @"heif_reader_get_position" x0
                      , heif_reader_seek = BG.getField @"heif_reader_seek" x0
                      , heif_reader_wait_for_file_size = BG.getField @"heif_reader_wait_for_file_size" x0
                      , heif_reader_request_range = BG.getField @"heif_reader_request_range" x0
                      , heif_reader_preload_range_hint = BG.getField @"heif_reader_preload_range_hint" x0
                      , heif_reader_release_file_range = BG.getField @"heif_reader_release_file_range" x0
                      , heif_reader_release_error_msg = BG.getField @"heif_reader_release_error_msg" x0
                      }
      , BG.getField @"heif_reader_read" x0
      )

instance ( ty ~ BG.FunPtr (BG.Ptr BG.Void -> HsBindgen.Runtime.LibC.CSize -> BG.Ptr BG.Void -> IO BG.CInt)
         ) => BG.HasField "heif_reader_read" (BG.Ptr Heif_reader) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_reader_read")

instance HasCField.HasCField Heif_reader "heif_reader_read" where

  type CFieldType Heif_reader "heif_reader_read" =
    BG.FunPtr (BG.Ptr BG.Void -> HsBindgen.Runtime.LibC.CSize -> BG.Ptr BG.Void -> IO BG.CInt)

  offset# = \_ -> \_ -> 16

{-| __C declaration:__ @seek@

    __defined at:__ @libheif\/heif_context.h 178:10@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.FunPtr (HsBindgen.Runtime.LibC.Int64 -> BG.Ptr BG.Void -> IO BG.CInt)
         ) => BG.CompatHasField.HasField "heif_reader_seek" Heif_reader ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_reader { heif_reader_seek = y1
                      , heif_reader_reader_api_version = BG.getField @"heif_reader_reader_api_version" x0
                      , heif_reader_get_position = BG.getField @"heif_reader_get_position" x0
                      , heif_reader_read = BG.getField @"heif_reader_read" x0
                      , heif_reader_wait_for_file_size = BG.getField @"heif_reader_wait_for_file_size" x0
                      , heif_reader_request_range = BG.getField @"heif_reader_request_range" x0
                      , heif_reader_preload_range_hint = BG.getField @"heif_reader_preload_range_hint" x0
                      , heif_reader_release_file_range = BG.getField @"heif_reader_release_file_range" x0
                      , heif_reader_release_error_msg = BG.getField @"heif_reader_release_error_msg" x0
                      }
      , BG.getField @"heif_reader_seek" x0
      )

instance ( ty ~ BG.FunPtr (HsBindgen.Runtime.LibC.Int64 -> BG.Ptr BG.Void -> IO BG.CInt)
         ) => BG.HasField "heif_reader_seek" (BG.Ptr Heif_reader) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_reader_seek")

instance HasCField.HasCField Heif_reader "heif_reader_seek" where

  type CFieldType Heif_reader "heif_reader_seek" =
    BG.FunPtr (HsBindgen.Runtime.LibC.Int64 -> BG.Ptr BG.Void -> IO BG.CInt)

  offset# = \_ -> \_ -> 24

{-| __C declaration:__ @wait_for_file_size@

    __defined at:__ @libheif\/heif_context.h 189:35@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.FunPtr (HsBindgen.Runtime.LibC.Int64 -> BG.Ptr BG.Void -> IO Heif_reader_grow_status)
         ) => BG.CompatHasField.HasField "heif_reader_wait_for_file_size" Heif_reader ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_reader { heif_reader_wait_for_file_size = y1
                      , heif_reader_reader_api_version = BG.getField @"heif_reader_reader_api_version" x0
                      , heif_reader_get_position = BG.getField @"heif_reader_get_position" x0
                      , heif_reader_read = BG.getField @"heif_reader_read" x0
                      , heif_reader_seek = BG.getField @"heif_reader_seek" x0
                      , heif_reader_request_range = BG.getField @"heif_reader_request_range" x0
                      , heif_reader_preload_range_hint = BG.getField @"heif_reader_preload_range_hint" x0
                      , heif_reader_release_file_range = BG.getField @"heif_reader_release_file_range" x0
                      , heif_reader_release_error_msg = BG.getField @"heif_reader_release_error_msg" x0
                      }
      , BG.getField @"heif_reader_wait_for_file_size" x0
      )

instance ( ty ~ BG.FunPtr (HsBindgen.Runtime.LibC.Int64 -> BG.Ptr BG.Void -> IO Heif_reader_grow_status)
         ) => BG.HasField "heif_reader_wait_for_file_size" (BG.Ptr Heif_reader) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_reader_wait_for_file_size")

instance HasCField.HasCField Heif_reader "heif_reader_wait_for_file_size" where

  type CFieldType Heif_reader "heif_reader_wait_for_file_size" =
    BG.FunPtr (HsBindgen.Runtime.LibC.Int64 -> BG.Ptr BG.Void -> IO Heif_reader_grow_status)

  offset# = \_ -> \_ -> 32

{-| __C declaration:__ @request_range@

    __defined at:__ @libheif\/heif_context.h 212:39@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.FunPtr (HsBindgen.Runtime.LibC.Word64 -> HsBindgen.Runtime.LibC.Word64 -> BG.Ptr BG.Void -> IO Heif_reader_range_request_result)
         ) => BG.CompatHasField.HasField "heif_reader_request_range" Heif_reader ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_reader { heif_reader_request_range = y1
                      , heif_reader_reader_api_version = BG.getField @"heif_reader_reader_api_version" x0
                      , heif_reader_get_position = BG.getField @"heif_reader_get_position" x0
                      , heif_reader_read = BG.getField @"heif_reader_read" x0
                      , heif_reader_seek = BG.getField @"heif_reader_seek" x0
                      , heif_reader_wait_for_file_size = BG.getField @"heif_reader_wait_for_file_size" x0
                      , heif_reader_preload_range_hint = BG.getField @"heif_reader_preload_range_hint" x0
                      , heif_reader_release_file_range = BG.getField @"heif_reader_release_file_range" x0
                      , heif_reader_release_error_msg = BG.getField @"heif_reader_release_error_msg" x0
                      }
      , BG.getField @"heif_reader_request_range" x0
      )

instance ( ty ~ BG.FunPtr (HsBindgen.Runtime.LibC.Word64 -> HsBindgen.Runtime.LibC.Word64 -> BG.Ptr BG.Void -> IO Heif_reader_range_request_result)
         ) => BG.HasField "heif_reader_request_range" (BG.Ptr Heif_reader) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_reader_request_range")

instance HasCField.HasCField Heif_reader "heif_reader_request_range" where

  type CFieldType Heif_reader "heif_reader_request_range" =
    BG.FunPtr (HsBindgen.Runtime.LibC.Word64 -> HsBindgen.Runtime.LibC.Word64 -> BG.Ptr BG.Void -> IO Heif_reader_range_request_result)

  offset# = \_ -> \_ -> 40

{-| __C declaration:__ @preload_range_hint@

    __defined at:__ @libheif\/heif_context.h 219:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.FunPtr (HsBindgen.Runtime.LibC.Word64 -> HsBindgen.Runtime.LibC.Word64 -> BG.Ptr BG.Void -> IO ())
         ) => BG.CompatHasField.HasField "heif_reader_preload_range_hint" Heif_reader ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_reader { heif_reader_preload_range_hint = y1
                      , heif_reader_reader_api_version = BG.getField @"heif_reader_reader_api_version" x0
                      , heif_reader_get_position = BG.getField @"heif_reader_get_position" x0
                      , heif_reader_read = BG.getField @"heif_reader_read" x0
                      , heif_reader_seek = BG.getField @"heif_reader_seek" x0
                      , heif_reader_wait_for_file_size = BG.getField @"heif_reader_wait_for_file_size" x0
                      , heif_reader_request_range = BG.getField @"heif_reader_request_range" x0
                      , heif_reader_release_file_range = BG.getField @"heif_reader_release_file_range" x0
                      , heif_reader_release_error_msg = BG.getField @"heif_reader_release_error_msg" x0
                      }
      , BG.getField @"heif_reader_preload_range_hint" x0
      )

instance ( ty ~ BG.FunPtr (HsBindgen.Runtime.LibC.Word64 -> HsBindgen.Runtime.LibC.Word64 -> BG.Ptr BG.Void -> IO ())
         ) => BG.HasField "heif_reader_preload_range_hint" (BG.Ptr Heif_reader) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_reader_preload_range_hint")

instance HasCField.HasCField Heif_reader "heif_reader_preload_range_hint" where

  type CFieldType Heif_reader "heif_reader_preload_range_hint" =
    BG.FunPtr (HsBindgen.Runtime.LibC.Word64 -> HsBindgen.Runtime.LibC.Word64 -> BG.Ptr BG.Void -> IO ())

  offset# = \_ -> \_ -> 48

{-| __C declaration:__ @release_file_range@

    __defined at:__ @libheif\/heif_context.h 225:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.FunPtr (HsBindgen.Runtime.LibC.Word64 -> HsBindgen.Runtime.LibC.Word64 -> BG.Ptr BG.Void -> IO ())
         ) => BG.CompatHasField.HasField "heif_reader_release_file_range" Heif_reader ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_reader { heif_reader_release_file_range = y1
                      , heif_reader_reader_api_version = BG.getField @"heif_reader_reader_api_version" x0
                      , heif_reader_get_position = BG.getField @"heif_reader_get_position" x0
                      , heif_reader_read = BG.getField @"heif_reader_read" x0
                      , heif_reader_seek = BG.getField @"heif_reader_seek" x0
                      , heif_reader_wait_for_file_size = BG.getField @"heif_reader_wait_for_file_size" x0
                      , heif_reader_request_range = BG.getField @"heif_reader_request_range" x0
                      , heif_reader_preload_range_hint = BG.getField @"heif_reader_preload_range_hint" x0
                      , heif_reader_release_error_msg = BG.getField @"heif_reader_release_error_msg" x0
                      }
      , BG.getField @"heif_reader_release_file_range" x0
      )

instance ( ty ~ BG.FunPtr (HsBindgen.Runtime.LibC.Word64 -> HsBindgen.Runtime.LibC.Word64 -> BG.Ptr BG.Void -> IO ())
         ) => BG.HasField "heif_reader_release_file_range" (BG.Ptr Heif_reader) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_reader_release_file_range")

instance HasCField.HasCField Heif_reader "heif_reader_release_file_range" where

  type CFieldType Heif_reader "heif_reader_release_file_range" =
    BG.FunPtr (HsBindgen.Runtime.LibC.Word64 -> HsBindgen.Runtime.LibC.Word64 -> BG.Ptr BG.Void -> IO ())

  offset# = \_ -> \_ -> 56

{-| __C declaration:__ @release_error_msg@

    __defined at:__ @libheif\/heif_context.h 230:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.FunPtr (PtrConst.PtrConst BG.CChar -> IO ())
         ) => BG.CompatHasField.HasField "heif_reader_release_error_msg" Heif_reader ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_reader { heif_reader_release_error_msg = y1
                      , heif_reader_reader_api_version = BG.getField @"heif_reader_reader_api_version" x0
                      , heif_reader_get_position = BG.getField @"heif_reader_get_position" x0
                      , heif_reader_read = BG.getField @"heif_reader_read" x0
                      , heif_reader_seek = BG.getField @"heif_reader_seek" x0
                      , heif_reader_wait_for_file_size = BG.getField @"heif_reader_wait_for_file_size" x0
                      , heif_reader_request_range = BG.getField @"heif_reader_request_range" x0
                      , heif_reader_preload_range_hint = BG.getField @"heif_reader_preload_range_hint" x0
                      , heif_reader_release_file_range = BG.getField @"heif_reader_release_file_range" x0
                      }
      , BG.getField @"heif_reader_release_error_msg" x0
      )

instance ( ty ~ BG.FunPtr (PtrConst.PtrConst BG.CChar -> IO ())
         ) => BG.HasField "heif_reader_release_error_msg" (BG.Ptr Heif_reader) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_reader_release_error_msg")

instance HasCField.HasCField Heif_reader "heif_reader_release_error_msg" where

  type CFieldType Heif_reader "heif_reader_release_error_msg" =
    BG.FunPtr (PtrConst.PtrConst BG.CChar -> IO ())

  offset# = \_ -> \_ -> 64

{-| __C declaration:__ @struct heif_writer@

    __defined at:__ @libheif\/heif_context.h 319:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_writer = Heif_writer
  { heif_writer_writer_api_version :: BG.CInt
    {- ^ __C declaration:__ @writer_api_version@

         __defined at:__ @libheif\/heif_context.h 322:7@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_writer_write :: BG.FunPtr (BG.Ptr Heif_context -> PtrConst.PtrConst BG.Void -> HsBindgen.Runtime.LibC.CSize -> BG.Ptr BG.Void -> IO Heif_error)
    {- ^ __C declaration:__ @write@

         __defined at:__ @libheif\/heif_context.h 327:17@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_writer where

  staticSizeOf = \_ -> (16 :: Int)

  staticAlignment = \_ -> (8 :: Int)

instance Marshal.ReadRaw Heif_writer where

  readRaw =
    \ptr0 ->
          pure Heif_writer
      <*> HasCField.readRaw (BG.Proxy @"heif_writer_writer_api_version") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_writer_write") ptr0

instance Marshal.WriteRaw Heif_writer where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_writer heif_writer_writer_api_version2 heif_writer_write3 ->
               HasCField.writeRaw (BG.Proxy @"heif_writer_writer_api_version") ptr0 heif_writer_writer_api_version2
            >> HasCField.writeRaw (BG.Proxy @"heif_writer_write") ptr0 heif_writer_write3

deriving via Marshal.EquivStorable Heif_writer instance BG.Storable Heif_writer

deriving via Struct.IsStructViaReadRaw Heif_writer instance Struct.IsStruct Heif_writer

{-| __C declaration:__ @writer_api_version@

    __defined at:__ @libheif\/heif_context.h 322:7@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CInt
         ) => BG.CompatHasField.HasField "heif_writer_writer_api_version" Heif_writer ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_writer { heif_writer_writer_api_version = y1
                      , heif_writer_write = BG.getField @"heif_writer_write" x0
                      }
      , BG.getField @"heif_writer_writer_api_version" x0
      )

instance ( ty ~ BG.CInt
         ) => BG.HasField "heif_writer_writer_api_version" (BG.Ptr Heif_writer) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_writer_writer_api_version")

instance HasCField.HasCField Heif_writer "heif_writer_writer_api_version" where

  type CFieldType Heif_writer "heif_writer_writer_api_version" =
    BG.CInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @write@

    __defined at:__ @libheif\/heif_context.h 327:17@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.FunPtr (BG.Ptr Heif_context -> PtrConst.PtrConst BG.Void -> HsBindgen.Runtime.LibC.CSize -> BG.Ptr BG.Void -> IO Heif_error)
         ) => BG.CompatHasField.HasField "heif_writer_write" Heif_writer ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_writer { heif_writer_write = y1
                      , heif_writer_writer_api_version = BG.getField @"heif_writer_writer_api_version" x0
                      }
      , BG.getField @"heif_writer_write" x0
      )

instance ( ty ~ BG.FunPtr (BG.Ptr Heif_context -> PtrConst.PtrConst BG.Void -> HsBindgen.Runtime.LibC.CSize -> BG.Ptr BG.Void -> IO Heif_error)
         ) => BG.HasField "heif_writer_write" (BG.Ptr Heif_writer) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_writer_write")

instance HasCField.HasCField Heif_writer "heif_writer_write" where

  type CFieldType Heif_writer "heif_writer_write" =
    BG.FunPtr (BG.Ptr Heif_context -> PtrConst.PtrConst BG.Void -> HsBindgen.Runtime.LibC.CSize -> BG.Ptr BG.Void -> IO Heif_error)

  offset# = \_ -> \_ -> 8

{-| __C declaration:__ @struct heif_unci_image_parameters@

    __defined at:__ @libheif\/heif_encoding.h 40:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_unci_image_parameters

{-| __C declaration:__ @struct heif_encoder_descriptor@

    __defined at:__ @libheif\/heif_encoding.h 51:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_encoder_descriptor

{-| __C declaration:__ @struct heif_encoder_parameter@

    __defined at:__ @libheif\/heif_encoding.h 56:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_encoder_parameter

{-| __C declaration:__ @enum heif_encoder_parameter_type@

    __defined at:__ @libheif\/heif_encoding.h 154:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_encoder_parameter_type = Heif_encoder_parameter_type
  { unwrapHeif_encoder_parameter_type :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_encoder_parameter_type where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_encoder_parameter_type where

  readRaw =
    \ptr0 ->
          pure Heif_encoder_parameter_type
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_encoder_parameter_type where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_encoder_parameter_type unwrapHeif_encoder_parameter_type2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_encoder_parameter_type2

deriving via Marshal.EquivStorable Heif_encoder_parameter_type instance BG.Storable Heif_encoder_parameter_type

deriving via BG.CUInt instance BG.Prim Heif_encoder_parameter_type

instance CEnum.CEnum Heif_encoder_parameter_type where

  type CEnumZ Heif_encoder_parameter_type = BG.CUInt

  toCEnum = Heif_encoder_parameter_type

  fromCEnum =
    BG.getField @"unwrapHeif_encoder_parameter_type"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (1, BG.singleton "Heif_encoder_parameter_type_integer")
                                   , (2, BG.singleton "Heif_encoder_parameter_type_boolean")
                                   , (3, BG.singleton "Heif_encoder_parameter_type_string")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_encoder_parameter_type"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_encoder_parameter_type"

  isDeclared = CEnum.seqIsDeclared

  mkDeclared = CEnum.seqMkDeclared

instance CEnum.SequentialCEnum Heif_encoder_parameter_type where

  minDeclaredValue =
    Heif_encoder_parameter_type_integer

  maxDeclaredValue = Heif_encoder_parameter_type_string

instance Show Heif_encoder_parameter_type where

  showsPrec = CEnum.shows

instance Read Heif_encoder_parameter_type where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_encoder_parameter_type" Heif_encoder_parameter_type ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_encoder_parameter_type {unwrapHeif_encoder_parameter_type = y1}
      , BG.getField @"unwrapHeif_encoder_parameter_type" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_encoder_parameter_type" (BG.Ptr Heif_encoder_parameter_type) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_encoder_parameter_type")

instance HasCField.HasCField Heif_encoder_parameter_type "unwrapHeif_encoder_parameter_type" where

  type CFieldType Heif_encoder_parameter_type "unwrapHeif_encoder_parameter_type" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_encoder_parameter_type_integer@

    __defined at:__ @libheif\/heif_encoding.h 156:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_encoder_parameter_type_integer :: Heif_encoder_parameter_type
pattern Heif_encoder_parameter_type_integer = Heif_encoder_parameter_type 1

{-| __C declaration:__ @heif_encoder_parameter_type_boolean@

    __defined at:__ @libheif\/heif_encoding.h 157:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_encoder_parameter_type_boolean :: Heif_encoder_parameter_type
pattern Heif_encoder_parameter_type_boolean = Heif_encoder_parameter_type 2

{-| __C declaration:__ @heif_encoder_parameter_type_string@

    __defined at:__ @libheif\/heif_encoding.h 158:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_encoder_parameter_type_string :: Heif_encoder_parameter_type
pattern Heif_encoder_parameter_type_string = Heif_encoder_parameter_type 3

{-| __C declaration:__ @enum heif_orientation@

    __defined at:__ @libheif\/heif_encoding.h 264:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_orientation = Heif_orientation
  { unwrapHeif_orientation :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_orientation where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_orientation where

  readRaw =
    \ptr0 ->
          pure Heif_orientation
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_orientation where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_orientation unwrapHeif_orientation2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_orientation2

deriving via Marshal.EquivStorable Heif_orientation instance BG.Storable Heif_orientation

deriving via BG.CUInt instance BG.Prim Heif_orientation

instance CEnum.CEnum Heif_orientation where

  type CEnumZ Heif_orientation = BG.CUInt

  toCEnum = Heif_orientation

  fromCEnum = BG.getField @"unwrapHeif_orientation"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (1, BG.singleton "Heif_orientation_normal")
                                   , (2, BG.singleton "Heif_orientation_flip_horizontally")
                                   , (3, BG.singleton "Heif_orientation_rotate_180")
                                   , (4, BG.singleton "Heif_orientation_flip_vertically")
                                   , (5, BG.singleton "Heif_orientation_rotate_90_cw_then_flip_horizontally")
                                   , (6, BG.singleton "Heif_orientation_rotate_90_cw")
                                   , (7, BG.singleton "Heif_orientation_rotate_90_cw_then_flip_vertically")
                                   , (8, BG.singleton "Heif_orientation_rotate_270_cw")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_orientation"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_orientation"

  isDeclared = CEnum.seqIsDeclared

  mkDeclared = CEnum.seqMkDeclared

instance CEnum.SequentialCEnum Heif_orientation where

  minDeclaredValue = Heif_orientation_normal

  maxDeclaredValue = Heif_orientation_rotate_270_cw

instance Show Heif_orientation where

  showsPrec = CEnum.shows

instance Read Heif_orientation where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_orientation" Heif_orientation ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_orientation {unwrapHeif_orientation = y1}
      , BG.getField @"unwrapHeif_orientation" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_orientation" (BG.Ptr Heif_orientation) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_orientation")

instance HasCField.HasCField Heif_orientation "unwrapHeif_orientation" where

  type CFieldType Heif_orientation "unwrapHeif_orientation" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_orientation_normal@

    __defined at:__ @libheif\/heif_encoding.h 266:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_orientation_normal :: Heif_orientation
pattern Heif_orientation_normal = Heif_orientation 1

{-| __C declaration:__ @heif_orientation_flip_horizontally@

    __defined at:__ @libheif\/heif_encoding.h 267:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_orientation_flip_horizontally :: Heif_orientation
pattern Heif_orientation_flip_horizontally = Heif_orientation 2

{-| __C declaration:__ @heif_orientation_rotate_180@

    __defined at:__ @libheif\/heif_encoding.h 268:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_orientation_rotate_180 :: Heif_orientation
pattern Heif_orientation_rotate_180 = Heif_orientation 3

{-| __C declaration:__ @heif_orientation_flip_vertically@

    __defined at:__ @libheif\/heif_encoding.h 269:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_orientation_flip_vertically :: Heif_orientation
pattern Heif_orientation_flip_vertically = Heif_orientation 4

{-| __C declaration:__ @heif_orientation_rotate_90_cw_then_flip_horizontally@

    __defined at:__ @libheif\/heif_encoding.h 270:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_orientation_rotate_90_cw_then_flip_horizontally :: Heif_orientation
pattern Heif_orientation_rotate_90_cw_then_flip_horizontally = Heif_orientation 5

{-| __C declaration:__ @heif_orientation_rotate_90_cw@

    __defined at:__ @libheif\/heif_encoding.h 271:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_orientation_rotate_90_cw :: Heif_orientation
pattern Heif_orientation_rotate_90_cw = Heif_orientation 6

{-| __C declaration:__ @heif_orientation_rotate_90_cw_then_flip_vertically@

    __defined at:__ @libheif\/heif_encoding.h 272:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_orientation_rotate_90_cw_then_flip_vertically :: Heif_orientation
pattern Heif_orientation_rotate_90_cw_then_flip_vertically = Heif_orientation 7

{-| __C declaration:__ @heif_orientation_rotate_270_cw@

    __defined at:__ @libheif\/heif_encoding.h 273:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_orientation_rotate_270_cw :: Heif_orientation
pattern Heif_orientation_rotate_270_cw = Heif_orientation 8

{-| __C declaration:__ @struct heif_encoding_options@

    __defined at:__ @libheif\/heif_encoding.h 281:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_encoding_options = Heif_encoding_options
  { heif_encoding_options_version :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @version@

         __defined at:__ @libheif\/heif_encoding.h 283:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_encoding_options_save_alpha_channel :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @save_alpha_channel@

         __defined at:__ @libheif\/heif_encoding.h 287:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_encoding_options_macOS_compatibility_workaround :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @macOS_compatibility_workaround@

         __defined at:__ @libheif\/heif_encoding.h 292:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @save_two_colr_boxes_when_ICC_and_nclx_available@

         __defined at:__ @libheif\/heif_encoding.h 296:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_encoding_options_output_nclx_profile :: BG.Ptr Heif_color_profile_nclx
    {- ^ __C declaration:__ @output_nclx_profile@

         __defined at:__ @libheif\/heif_encoding.h 302:28@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @macOS_compatibility_workaround_no_nclx_profile@

         __defined at:__ @libheif\/heif_encoding.h 304:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_encoding_options_image_orientation :: Heif_orientation
    {- ^ __C declaration:__ @image_orientation@

         __defined at:__ @libheif\/heif_encoding.h 309:20@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_encoding_options_color_conversion_options :: Heif_color_conversion_options
    {- ^ __C declaration:__ @color_conversion_options@

         __defined at:__ @libheif\/heif_encoding.h 313:33@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_encoding_options_prefer_uncC_short_form :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @prefer_uncC_short_form@

         __defined at:__ @libheif\/heif_encoding.h 318:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_encoding_options_unci_parameters :: PtrConst.PtrConst Heif_unci_image_parameters
    {- ^ __C declaration:__ @unci_parameters@

         __defined at:__ @libheif\/heif_encoding.h 326:37@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_encoding_options where

  staticSizeOf = \_ -> (56 :: Int)

  staticAlignment = \_ -> (8 :: Int)

instance Marshal.ReadRaw Heif_encoding_options where

  readRaw =
    \ptr0 ->
          pure Heif_encoding_options
      <*> HasCField.readRaw (BG.Proxy @"heif_encoding_options_version") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_encoding_options_save_alpha_channel") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_encoding_options_macOS_compatibility_workaround") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_encoding_options_output_nclx_profile") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_encoding_options_image_orientation") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_encoding_options_color_conversion_options") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_encoding_options_prefer_uncC_short_form") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_encoding_options_unci_parameters") ptr0

instance Marshal.WriteRaw Heif_encoding_options where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_encoding_options
            heif_encoding_options_version2
            heif_encoding_options_save_alpha_channel3
            heif_encoding_options_macOS_compatibility_workaround4
            heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available5
            heif_encoding_options_output_nclx_profile6
            heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile7
            heif_encoding_options_image_orientation8
            heif_encoding_options_color_conversion_options9
            heif_encoding_options_prefer_uncC_short_form10
            heif_encoding_options_unci_parameters11 ->
                 HasCField.writeRaw (BG.Proxy @"heif_encoding_options_version") ptr0 heif_encoding_options_version2
              >> HasCField.writeRaw (BG.Proxy @"heif_encoding_options_save_alpha_channel") ptr0 heif_encoding_options_save_alpha_channel3
              >> HasCField.writeRaw (BG.Proxy @"heif_encoding_options_macOS_compatibility_workaround") ptr0 heif_encoding_options_macOS_compatibility_workaround4
              >> HasCField.writeRaw (BG.Proxy @"heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available") ptr0 heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available5
              >> HasCField.writeRaw (BG.Proxy @"heif_encoding_options_output_nclx_profile") ptr0 heif_encoding_options_output_nclx_profile6
              >> HasCField.writeRaw (BG.Proxy @"heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile") ptr0 heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile7
              >> HasCField.writeRaw (BG.Proxy @"heif_encoding_options_image_orientation") ptr0 heif_encoding_options_image_orientation8
              >> HasCField.writeRaw (BG.Proxy @"heif_encoding_options_color_conversion_options") ptr0 heif_encoding_options_color_conversion_options9
              >> HasCField.writeRaw (BG.Proxy @"heif_encoding_options_prefer_uncC_short_form") ptr0 heif_encoding_options_prefer_uncC_short_form10
              >> HasCField.writeRaw (BG.Proxy @"heif_encoding_options_unci_parameters") ptr0 heif_encoding_options_unci_parameters11

deriving via Marshal.EquivStorable Heif_encoding_options instance BG.Storable Heif_encoding_options

deriving via Struct.IsStructViaReadRaw Heif_encoding_options instance Struct.IsStruct Heif_encoding_options

{-| __C declaration:__ @version@

    __defined at:__ @libheif\/heif_encoding.h 283:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_encoding_options_version" Heif_encoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_encoding_options { heif_encoding_options_version = y1
                                , heif_encoding_options_save_alpha_channel = BG.getField @"heif_encoding_options_save_alpha_channel" x0
                                , heif_encoding_options_macOS_compatibility_workaround = BG.getField @"heif_encoding_options_macOS_compatibility_workaround" x0
                                , heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available = BG.getField @"heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available" x0
                                , heif_encoding_options_output_nclx_profile = BG.getField @"heif_encoding_options_output_nclx_profile" x0
                                , heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile = BG.getField @"heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile" x0
                                , heif_encoding_options_image_orientation = BG.getField @"heif_encoding_options_image_orientation" x0
                                , heif_encoding_options_color_conversion_options = BG.getField @"heif_encoding_options_color_conversion_options" x0
                                , heif_encoding_options_prefer_uncC_short_form = BG.getField @"heif_encoding_options_prefer_uncC_short_form" x0
                                , heif_encoding_options_unci_parameters = BG.getField @"heif_encoding_options_unci_parameters" x0
                                }
      , BG.getField @"heif_encoding_options_version" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_encoding_options_version" (BG.Ptr Heif_encoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_encoding_options_version")

instance HasCField.HasCField Heif_encoding_options "heif_encoding_options_version" where

  type CFieldType Heif_encoding_options "heif_encoding_options_version" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @save_alpha_channel@

    __defined at:__ @libheif\/heif_encoding.h 287:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_encoding_options_save_alpha_channel" Heif_encoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_encoding_options { heif_encoding_options_save_alpha_channel = y1
                                , heif_encoding_options_version = BG.getField @"heif_encoding_options_version" x0
                                , heif_encoding_options_macOS_compatibility_workaround = BG.getField @"heif_encoding_options_macOS_compatibility_workaround" x0
                                , heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available = BG.getField @"heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available" x0
                                , heif_encoding_options_output_nclx_profile = BG.getField @"heif_encoding_options_output_nclx_profile" x0
                                , heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile = BG.getField @"heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile" x0
                                , heif_encoding_options_image_orientation = BG.getField @"heif_encoding_options_image_orientation" x0
                                , heif_encoding_options_color_conversion_options = BG.getField @"heif_encoding_options_color_conversion_options" x0
                                , heif_encoding_options_prefer_uncC_short_form = BG.getField @"heif_encoding_options_prefer_uncC_short_form" x0
                                , heif_encoding_options_unci_parameters = BG.getField @"heif_encoding_options_unci_parameters" x0
                                }
      , BG.getField @"heif_encoding_options_save_alpha_channel" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_encoding_options_save_alpha_channel" (BG.Ptr Heif_encoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_encoding_options_save_alpha_channel")

instance HasCField.HasCField Heif_encoding_options "heif_encoding_options_save_alpha_channel" where

  type CFieldType Heif_encoding_options "heif_encoding_options_save_alpha_channel" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 1

{-| __C declaration:__ @macOS_compatibility_workaround@

    __defined at:__ @libheif\/heif_encoding.h 292:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_encoding_options_macOS_compatibility_workaround" Heif_encoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_encoding_options { heif_encoding_options_macOS_compatibility_workaround = y1
                                , heif_encoding_options_version = BG.getField @"heif_encoding_options_version" x0
                                , heif_encoding_options_save_alpha_channel = BG.getField @"heif_encoding_options_save_alpha_channel" x0
                                , heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available = BG.getField @"heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available" x0
                                , heif_encoding_options_output_nclx_profile = BG.getField @"heif_encoding_options_output_nclx_profile" x0
                                , heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile = BG.getField @"heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile" x0
                                , heif_encoding_options_image_orientation = BG.getField @"heif_encoding_options_image_orientation" x0
                                , heif_encoding_options_color_conversion_options = BG.getField @"heif_encoding_options_color_conversion_options" x0
                                , heif_encoding_options_prefer_uncC_short_form = BG.getField @"heif_encoding_options_prefer_uncC_short_form" x0
                                , heif_encoding_options_unci_parameters = BG.getField @"heif_encoding_options_unci_parameters" x0
                                }
      , BG.getField @"heif_encoding_options_macOS_compatibility_workaround" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_encoding_options_macOS_compatibility_workaround" (BG.Ptr Heif_encoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_encoding_options_macOS_compatibility_workaround")

instance HasCField.HasCField Heif_encoding_options "heif_encoding_options_macOS_compatibility_workaround" where

  type CFieldType Heif_encoding_options "heif_encoding_options_macOS_compatibility_workaround" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 2

{-| __C declaration:__ @save_two_colr_boxes_when_ICC_and_nclx_available@

    __defined at:__ @libheif\/heif_encoding.h 296:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available" Heif_encoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_encoding_options { heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available = y1
                                , heif_encoding_options_version = BG.getField @"heif_encoding_options_version" x0
                                , heif_encoding_options_save_alpha_channel = BG.getField @"heif_encoding_options_save_alpha_channel" x0
                                , heif_encoding_options_macOS_compatibility_workaround = BG.getField @"heif_encoding_options_macOS_compatibility_workaround" x0
                                , heif_encoding_options_output_nclx_profile = BG.getField @"heif_encoding_options_output_nclx_profile" x0
                                , heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile = BG.getField @"heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile" x0
                                , heif_encoding_options_image_orientation = BG.getField @"heif_encoding_options_image_orientation" x0
                                , heif_encoding_options_color_conversion_options = BG.getField @"heif_encoding_options_color_conversion_options" x0
                                , heif_encoding_options_prefer_uncC_short_form = BG.getField @"heif_encoding_options_prefer_uncC_short_form" x0
                                , heif_encoding_options_unci_parameters = BG.getField @"heif_encoding_options_unci_parameters" x0
                                }
      , BG.getField @"heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available" (BG.Ptr Heif_encoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available")

instance HasCField.HasCField Heif_encoding_options "heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available" where

  type CFieldType Heif_encoding_options "heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 3

{-| __C declaration:__ @output_nclx_profile@

    __defined at:__ @libheif\/heif_encoding.h 302:28@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.Ptr Heif_color_profile_nclx
         ) => BG.CompatHasField.HasField "heif_encoding_options_output_nclx_profile" Heif_encoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_encoding_options { heif_encoding_options_output_nclx_profile = y1
                                , heif_encoding_options_version = BG.getField @"heif_encoding_options_version" x0
                                , heif_encoding_options_save_alpha_channel = BG.getField @"heif_encoding_options_save_alpha_channel" x0
                                , heif_encoding_options_macOS_compatibility_workaround = BG.getField @"heif_encoding_options_macOS_compatibility_workaround" x0
                                , heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available = BG.getField @"heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available" x0
                                , heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile = BG.getField @"heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile" x0
                                , heif_encoding_options_image_orientation = BG.getField @"heif_encoding_options_image_orientation" x0
                                , heif_encoding_options_color_conversion_options = BG.getField @"heif_encoding_options_color_conversion_options" x0
                                , heif_encoding_options_prefer_uncC_short_form = BG.getField @"heif_encoding_options_prefer_uncC_short_form" x0
                                , heif_encoding_options_unci_parameters = BG.getField @"heif_encoding_options_unci_parameters" x0
                                }
      , BG.getField @"heif_encoding_options_output_nclx_profile" x0
      )

instance ( ty ~ BG.Ptr Heif_color_profile_nclx
         ) => BG.HasField "heif_encoding_options_output_nclx_profile" (BG.Ptr Heif_encoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_encoding_options_output_nclx_profile")

instance HasCField.HasCField Heif_encoding_options "heif_encoding_options_output_nclx_profile" where

  type CFieldType Heif_encoding_options "heif_encoding_options_output_nclx_profile" =
    BG.Ptr Heif_color_profile_nclx

  offset# = \_ -> \_ -> 8

{-| __C declaration:__ @macOS_compatibility_workaround_no_nclx_profile@

    __defined at:__ @libheif\/heif_encoding.h 304:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile" Heif_encoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_encoding_options { heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile = y1
                                , heif_encoding_options_version = BG.getField @"heif_encoding_options_version" x0
                                , heif_encoding_options_save_alpha_channel = BG.getField @"heif_encoding_options_save_alpha_channel" x0
                                , heif_encoding_options_macOS_compatibility_workaround = BG.getField @"heif_encoding_options_macOS_compatibility_workaround" x0
                                , heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available = BG.getField @"heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available" x0
                                , heif_encoding_options_output_nclx_profile = BG.getField @"heif_encoding_options_output_nclx_profile" x0
                                , heif_encoding_options_image_orientation = BG.getField @"heif_encoding_options_image_orientation" x0
                                , heif_encoding_options_color_conversion_options = BG.getField @"heif_encoding_options_color_conversion_options" x0
                                , heif_encoding_options_prefer_uncC_short_form = BG.getField @"heif_encoding_options_prefer_uncC_short_form" x0
                                , heif_encoding_options_unci_parameters = BG.getField @"heif_encoding_options_unci_parameters" x0
                                }
      , BG.getField @"heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile" (BG.Ptr Heif_encoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile")

instance HasCField.HasCField Heif_encoding_options "heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile" where

  type CFieldType Heif_encoding_options "heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 16

{-| __C declaration:__ @image_orientation@

    __defined at:__ @libheif\/heif_encoding.h 309:20@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ Heif_orientation
         ) => BG.CompatHasField.HasField "heif_encoding_options_image_orientation" Heif_encoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_encoding_options { heif_encoding_options_image_orientation = y1
                                , heif_encoding_options_version = BG.getField @"heif_encoding_options_version" x0
                                , heif_encoding_options_save_alpha_channel = BG.getField @"heif_encoding_options_save_alpha_channel" x0
                                , heif_encoding_options_macOS_compatibility_workaround = BG.getField @"heif_encoding_options_macOS_compatibility_workaround" x0
                                , heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available = BG.getField @"heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available" x0
                                , heif_encoding_options_output_nclx_profile = BG.getField @"heif_encoding_options_output_nclx_profile" x0
                                , heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile = BG.getField @"heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile" x0
                                , heif_encoding_options_color_conversion_options = BG.getField @"heif_encoding_options_color_conversion_options" x0
                                , heif_encoding_options_prefer_uncC_short_form = BG.getField @"heif_encoding_options_prefer_uncC_short_form" x0
                                , heif_encoding_options_unci_parameters = BG.getField @"heif_encoding_options_unci_parameters" x0
                                }
      , BG.getField @"heif_encoding_options_image_orientation" x0
      )

instance ( ty ~ Heif_orientation
         ) => BG.HasField "heif_encoding_options_image_orientation" (BG.Ptr Heif_encoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_encoding_options_image_orientation")

instance HasCField.HasCField Heif_encoding_options "heif_encoding_options_image_orientation" where

  type CFieldType Heif_encoding_options "heif_encoding_options_image_orientation" =
    Heif_orientation

  offset# = \_ -> \_ -> 20

{-| __C declaration:__ @color_conversion_options@

    __defined at:__ @libheif\/heif_encoding.h 313:33@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ Heif_color_conversion_options
         ) => BG.CompatHasField.HasField "heif_encoding_options_color_conversion_options" Heif_encoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_encoding_options { heif_encoding_options_color_conversion_options = y1
                                , heif_encoding_options_version = BG.getField @"heif_encoding_options_version" x0
                                , heif_encoding_options_save_alpha_channel = BG.getField @"heif_encoding_options_save_alpha_channel" x0
                                , heif_encoding_options_macOS_compatibility_workaround = BG.getField @"heif_encoding_options_macOS_compatibility_workaround" x0
                                , heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available = BG.getField @"heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available" x0
                                , heif_encoding_options_output_nclx_profile = BG.getField @"heif_encoding_options_output_nclx_profile" x0
                                , heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile = BG.getField @"heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile" x0
                                , heif_encoding_options_image_orientation = BG.getField @"heif_encoding_options_image_orientation" x0
                                , heif_encoding_options_prefer_uncC_short_form = BG.getField @"heif_encoding_options_prefer_uncC_short_form" x0
                                , heif_encoding_options_unci_parameters = BG.getField @"heif_encoding_options_unci_parameters" x0
                                }
      , BG.getField @"heif_encoding_options_color_conversion_options" x0
      )

instance ( ty ~ Heif_color_conversion_options
         ) => BG.HasField "heif_encoding_options_color_conversion_options" (BG.Ptr Heif_encoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_encoding_options_color_conversion_options")

instance HasCField.HasCField Heif_encoding_options "heif_encoding_options_color_conversion_options" where

  type CFieldType Heif_encoding_options "heif_encoding_options_color_conversion_options" =
    Heif_color_conversion_options

  offset# = \_ -> \_ -> 24

{-| __C declaration:__ @prefer_uncC_short_form@

    __defined at:__ @libheif\/heif_encoding.h 318:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_encoding_options_prefer_uncC_short_form" Heif_encoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_encoding_options { heif_encoding_options_prefer_uncC_short_form = y1
                                , heif_encoding_options_version = BG.getField @"heif_encoding_options_version" x0
                                , heif_encoding_options_save_alpha_channel = BG.getField @"heif_encoding_options_save_alpha_channel" x0
                                , heif_encoding_options_macOS_compatibility_workaround = BG.getField @"heif_encoding_options_macOS_compatibility_workaround" x0
                                , heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available = BG.getField @"heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available" x0
                                , heif_encoding_options_output_nclx_profile = BG.getField @"heif_encoding_options_output_nclx_profile" x0
                                , heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile = BG.getField @"heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile" x0
                                , heif_encoding_options_image_orientation = BG.getField @"heif_encoding_options_image_orientation" x0
                                , heif_encoding_options_color_conversion_options = BG.getField @"heif_encoding_options_color_conversion_options" x0
                                , heif_encoding_options_unci_parameters = BG.getField @"heif_encoding_options_unci_parameters" x0
                                }
      , BG.getField @"heif_encoding_options_prefer_uncC_short_form" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_encoding_options_prefer_uncC_short_form" (BG.Ptr Heif_encoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_encoding_options_prefer_uncC_short_form")

instance HasCField.HasCField Heif_encoding_options "heif_encoding_options_prefer_uncC_short_form" where

  type CFieldType Heif_encoding_options "heif_encoding_options_prefer_uncC_short_form" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 40

{-| __C declaration:__ @unci_parameters@

    __defined at:__ @libheif\/heif_encoding.h 326:37@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ PtrConst.PtrConst Heif_unci_image_parameters
         ) => BG.CompatHasField.HasField "heif_encoding_options_unci_parameters" Heif_encoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_encoding_options { heif_encoding_options_unci_parameters = y1
                                , heif_encoding_options_version = BG.getField @"heif_encoding_options_version" x0
                                , heif_encoding_options_save_alpha_channel = BG.getField @"heif_encoding_options_save_alpha_channel" x0
                                , heif_encoding_options_macOS_compatibility_workaround = BG.getField @"heif_encoding_options_macOS_compatibility_workaround" x0
                                , heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available = BG.getField @"heif_encoding_options_save_two_colr_boxes_when_ICC_and_nclx_available" x0
                                , heif_encoding_options_output_nclx_profile = BG.getField @"heif_encoding_options_output_nclx_profile" x0
                                , heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile = BG.getField @"heif_encoding_options_macOS_compatibility_workaround_no_nclx_profile" x0
                                , heif_encoding_options_image_orientation = BG.getField @"heif_encoding_options_image_orientation" x0
                                , heif_encoding_options_color_conversion_options = BG.getField @"heif_encoding_options_color_conversion_options" x0
                                , heif_encoding_options_prefer_uncC_short_form = BG.getField @"heif_encoding_options_prefer_uncC_short_form" x0
                                }
      , BG.getField @"heif_encoding_options_unci_parameters" x0
      )

instance ( ty ~ PtrConst.PtrConst Heif_unci_image_parameters
         ) => BG.HasField "heif_encoding_options_unci_parameters" (BG.Ptr Heif_encoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_encoding_options_unci_parameters")

instance HasCField.HasCField Heif_encoding_options "heif_encoding_options_unci_parameters" where

  type CFieldType Heif_encoding_options "heif_encoding_options_unci_parameters" =
    PtrConst.PtrConst Heif_unci_image_parameters

  offset# = \_ -> \_ -> 48

{-| __C declaration:__ @enum heif_progress_step@

    __defined at:__ @libheif\/heif_decoding.h 56:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_progress_step = Heif_progress_step
  { unwrapHeif_progress_step :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_progress_step where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_progress_step where

  readRaw =
    \ptr0 ->
          pure Heif_progress_step
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_progress_step where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_progress_step unwrapHeif_progress_step2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_progress_step2

deriving via Marshal.EquivStorable Heif_progress_step instance BG.Storable Heif_progress_step

deriving via BG.CUInt instance BG.Prim Heif_progress_step

instance CEnum.CEnum Heif_progress_step where

  type CEnumZ Heif_progress_step = BG.CUInt

  toCEnum = Heif_progress_step

  fromCEnum = BG.getField @"unwrapHeif_progress_step"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_progress_step_total")
                                   , (1, BG.singleton "Heif_progress_step_load_tile")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_progress_step"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_progress_step"

  isDeclared = CEnum.seqIsDeclared

  mkDeclared = CEnum.seqMkDeclared

instance CEnum.SequentialCEnum Heif_progress_step where

  minDeclaredValue = Heif_progress_step_total

  maxDeclaredValue = Heif_progress_step_load_tile

instance Show Heif_progress_step where

  showsPrec = CEnum.shows

instance Read Heif_progress_step where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_progress_step" Heif_progress_step ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_progress_step {unwrapHeif_progress_step = y1}
      , BG.getField @"unwrapHeif_progress_step" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_progress_step" (BG.Ptr Heif_progress_step) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_progress_step")

instance HasCField.HasCField Heif_progress_step "unwrapHeif_progress_step" where

  type CFieldType Heif_progress_step "unwrapHeif_progress_step" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_progress_step_total@

    __defined at:__ @libheif\/heif_decoding.h 58:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_progress_step_total :: Heif_progress_step
pattern Heif_progress_step_total = Heif_progress_step 0

{-| __C declaration:__ @heif_progress_step_load_tile@

    __defined at:__ @libheif\/heif_decoding.h 59:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_progress_step_load_tile :: Heif_progress_step
pattern Heif_progress_step_load_tile = Heif_progress_step 1

{-| __C declaration:__ @struct heif_decoding_options@

    __defined at:__ @libheif\/heif_decoding.h 63:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_decoding_options = Heif_decoding_options
  { heif_decoding_options_version :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @version@

         __defined at:__ @libheif\/heif_decoding.h 65:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoding_options_ignore_transformations :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @ignore_transformations@

         __defined at:__ @libheif\/heif_decoding.h 71:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoding_options_start_progress :: BG.FunPtr (Heif_progress_step -> BG.CInt -> BG.Ptr BG.Void -> IO ())
    {- ^ __C declaration:__ @start_progress@

         __defined at:__ @libheif\/heif_decoding.h 74:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoding_options_on_progress :: BG.FunPtr (Heif_progress_step -> BG.CInt -> BG.Ptr BG.Void -> IO ())
    {- ^ __C declaration:__ @on_progress@

         __defined at:__ @libheif\/heif_decoding.h 76:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoding_options_end_progress :: BG.FunPtr (Heif_progress_step -> BG.Ptr BG.Void -> IO ())
    {- ^ __C declaration:__ @end_progress@

         __defined at:__ @libheif\/heif_decoding.h 78:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoding_options_progress_user_data :: BG.Ptr BG.Void
    {- ^ __C declaration:__ @progress_user_data@

         __defined at:__ @libheif\/heif_decoding.h 80:9@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoding_options_convert_hdr_to_8bit :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @convert_hdr_to_8bit@

         __defined at:__ @libheif\/heif_decoding.h 84:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoding_options_strict_decoding :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @strict_decoding@

         __defined at:__ @libheif\/heif_decoding.h 90:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoding_options_decoder_id :: PtrConst.PtrConst BG.CChar
    {- ^ __C declaration:__ @decoder_id@

         __defined at:__ @libheif\/heif_decoding.h 97:15@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoding_options_color_conversion_options :: Heif_color_conversion_options
    {- ^ __C declaration:__ @color_conversion_options@

         __defined at:__ @libheif\/heif_decoding.h 101:33@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoding_options_cancel_decoding :: BG.FunPtr (BG.Ptr BG.Void -> IO BG.CInt)
    {- ^ __C declaration:__ @cancel_decoding@

         __defined at:__ @libheif\/heif_decoding.h 105:10@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoding_options_color_conversion_options_ext :: BG.Ptr Heif_color_conversion_options_ext
    {- ^ __C declaration:__ @color_conversion_options_ext@

         __defined at:__ @libheif\/heif_decoding.h 110:38@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoding_options_ignore_sequence_editlist :: BG.CInt
    {- ^ __C declaration:__ @ignore_sequence_editlist@

         __defined at:__ @libheif\/heif_decoding.h 115:7@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoding_options_output_image_nclx_profile :: BG.Ptr Heif_color_profile_nclx
    {- ^ __C declaration:__ @output_image_nclx_profile@

         __defined at:__ @libheif\/heif_decoding.h 126:28@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoding_options_num_library_threads :: BG.CInt
    {- ^ __C declaration:__ @num_library_threads@

         __defined at:__ @libheif\/heif_decoding.h 128:7@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoding_options_num_codec_threads :: BG.CInt
    {- ^ __C declaration:__ @num_codec_threads@

         __defined at:__ @libheif\/heif_decoding.h 129:7@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoding_options_autocorrect_broken_input :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @autocorrect_broken_input@

         __defined at:__ @libheif\/heif_decoding.h 136:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_decoding_options_output_image_nclx_profile_passthrough :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @output_image_nclx_profile_passthrough@

         __defined at:__ @libheif\/heif_decoding.h 157:11@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_decoding_options where

  staticSizeOf = \_ -> (120 :: Int)

  staticAlignment = \_ -> (8 :: Int)

instance Marshal.ReadRaw Heif_decoding_options where

  readRaw =
    \ptr0 ->
          pure Heif_decoding_options
      <*> HasCField.readRaw (BG.Proxy @"heif_decoding_options_version") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoding_options_ignore_transformations") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoding_options_start_progress") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoding_options_on_progress") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoding_options_end_progress") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoding_options_progress_user_data") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoding_options_convert_hdr_to_8bit") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoding_options_strict_decoding") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoding_options_decoder_id") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoding_options_color_conversion_options") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoding_options_cancel_decoding") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoding_options_color_conversion_options_ext") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoding_options_ignore_sequence_editlist") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoding_options_output_image_nclx_profile") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoding_options_num_library_threads") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoding_options_num_codec_threads") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoding_options_autocorrect_broken_input") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_decoding_options_output_image_nclx_profile_passthrough") ptr0

instance Marshal.WriteRaw Heif_decoding_options where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_decoding_options
            heif_decoding_options_version2
            heif_decoding_options_ignore_transformations3
            heif_decoding_options_start_progress4
            heif_decoding_options_on_progress5
            heif_decoding_options_end_progress6
            heif_decoding_options_progress_user_data7
            heif_decoding_options_convert_hdr_to_8bit8
            heif_decoding_options_strict_decoding9
            heif_decoding_options_decoder_id10
            heif_decoding_options_color_conversion_options11
            heif_decoding_options_cancel_decoding12
            heif_decoding_options_color_conversion_options_ext13
            heif_decoding_options_ignore_sequence_editlist14
            heif_decoding_options_output_image_nclx_profile15
            heif_decoding_options_num_library_threads16
            heif_decoding_options_num_codec_threads17
            heif_decoding_options_autocorrect_broken_input18
            heif_decoding_options_output_image_nclx_profile_passthrough19 ->
                 HasCField.writeRaw (BG.Proxy @"heif_decoding_options_version") ptr0 heif_decoding_options_version2
              >> HasCField.writeRaw (BG.Proxy @"heif_decoding_options_ignore_transformations") ptr0 heif_decoding_options_ignore_transformations3
              >> HasCField.writeRaw (BG.Proxy @"heif_decoding_options_start_progress") ptr0 heif_decoding_options_start_progress4
              >> HasCField.writeRaw (BG.Proxy @"heif_decoding_options_on_progress") ptr0 heif_decoding_options_on_progress5
              >> HasCField.writeRaw (BG.Proxy @"heif_decoding_options_end_progress") ptr0 heif_decoding_options_end_progress6
              >> HasCField.writeRaw (BG.Proxy @"heif_decoding_options_progress_user_data") ptr0 heif_decoding_options_progress_user_data7
              >> HasCField.writeRaw (BG.Proxy @"heif_decoding_options_convert_hdr_to_8bit") ptr0 heif_decoding_options_convert_hdr_to_8bit8
              >> HasCField.writeRaw (BG.Proxy @"heif_decoding_options_strict_decoding") ptr0 heif_decoding_options_strict_decoding9
              >> HasCField.writeRaw (BG.Proxy @"heif_decoding_options_decoder_id") ptr0 heif_decoding_options_decoder_id10
              >> HasCField.writeRaw (BG.Proxy @"heif_decoding_options_color_conversion_options") ptr0 heif_decoding_options_color_conversion_options11
              >> HasCField.writeRaw (BG.Proxy @"heif_decoding_options_cancel_decoding") ptr0 heif_decoding_options_cancel_decoding12
              >> HasCField.writeRaw (BG.Proxy @"heif_decoding_options_color_conversion_options_ext") ptr0 heif_decoding_options_color_conversion_options_ext13
              >> HasCField.writeRaw (BG.Proxy @"heif_decoding_options_ignore_sequence_editlist") ptr0 heif_decoding_options_ignore_sequence_editlist14
              >> HasCField.writeRaw (BG.Proxy @"heif_decoding_options_output_image_nclx_profile") ptr0 heif_decoding_options_output_image_nclx_profile15
              >> HasCField.writeRaw (BG.Proxy @"heif_decoding_options_num_library_threads") ptr0 heif_decoding_options_num_library_threads16
              >> HasCField.writeRaw (BG.Proxy @"heif_decoding_options_num_codec_threads") ptr0 heif_decoding_options_num_codec_threads17
              >> HasCField.writeRaw (BG.Proxy @"heif_decoding_options_autocorrect_broken_input") ptr0 heif_decoding_options_autocorrect_broken_input18
              >> HasCField.writeRaw (BG.Proxy @"heif_decoding_options_output_image_nclx_profile_passthrough") ptr0 heif_decoding_options_output_image_nclx_profile_passthrough19

deriving via Marshal.EquivStorable Heif_decoding_options instance BG.Storable Heif_decoding_options

deriving via Struct.IsStructViaReadRaw Heif_decoding_options instance Struct.IsStruct Heif_decoding_options

{-| __C declaration:__ @version@

    __defined at:__ @libheif\/heif_decoding.h 65:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_decoding_options_version" Heif_decoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoding_options { heif_decoding_options_version = y1
                                , heif_decoding_options_ignore_transformations = BG.getField @"heif_decoding_options_ignore_transformations" x0
                                , heif_decoding_options_start_progress = BG.getField @"heif_decoding_options_start_progress" x0
                                , heif_decoding_options_on_progress = BG.getField @"heif_decoding_options_on_progress" x0
                                , heif_decoding_options_end_progress = BG.getField @"heif_decoding_options_end_progress" x0
                                , heif_decoding_options_progress_user_data = BG.getField @"heif_decoding_options_progress_user_data" x0
                                , heif_decoding_options_convert_hdr_to_8bit = BG.getField @"heif_decoding_options_convert_hdr_to_8bit" x0
                                , heif_decoding_options_strict_decoding = BG.getField @"heif_decoding_options_strict_decoding" x0
                                , heif_decoding_options_decoder_id = BG.getField @"heif_decoding_options_decoder_id" x0
                                , heif_decoding_options_color_conversion_options = BG.getField @"heif_decoding_options_color_conversion_options" x0
                                , heif_decoding_options_cancel_decoding = BG.getField @"heif_decoding_options_cancel_decoding" x0
                                , heif_decoding_options_color_conversion_options_ext = BG.getField @"heif_decoding_options_color_conversion_options_ext" x0
                                , heif_decoding_options_ignore_sequence_editlist = BG.getField @"heif_decoding_options_ignore_sequence_editlist" x0
                                , heif_decoding_options_output_image_nclx_profile = BG.getField @"heif_decoding_options_output_image_nclx_profile" x0
                                , heif_decoding_options_num_library_threads = BG.getField @"heif_decoding_options_num_library_threads" x0
                                , heif_decoding_options_num_codec_threads = BG.getField @"heif_decoding_options_num_codec_threads" x0
                                , heif_decoding_options_autocorrect_broken_input = BG.getField @"heif_decoding_options_autocorrect_broken_input" x0
                                , heif_decoding_options_output_image_nclx_profile_passthrough = BG.getField @"heif_decoding_options_output_image_nclx_profile_passthrough" x0
                                }
      , BG.getField @"heif_decoding_options_version" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_decoding_options_version" (BG.Ptr Heif_decoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoding_options_version")

instance HasCField.HasCField Heif_decoding_options "heif_decoding_options_version" where

  type CFieldType Heif_decoding_options "heif_decoding_options_version" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @ignore_transformations@

    __defined at:__ @libheif\/heif_decoding.h 71:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_decoding_options_ignore_transformations" Heif_decoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoding_options { heif_decoding_options_ignore_transformations = y1
                                , heif_decoding_options_version = BG.getField @"heif_decoding_options_version" x0
                                , heif_decoding_options_start_progress = BG.getField @"heif_decoding_options_start_progress" x0
                                , heif_decoding_options_on_progress = BG.getField @"heif_decoding_options_on_progress" x0
                                , heif_decoding_options_end_progress = BG.getField @"heif_decoding_options_end_progress" x0
                                , heif_decoding_options_progress_user_data = BG.getField @"heif_decoding_options_progress_user_data" x0
                                , heif_decoding_options_convert_hdr_to_8bit = BG.getField @"heif_decoding_options_convert_hdr_to_8bit" x0
                                , heif_decoding_options_strict_decoding = BG.getField @"heif_decoding_options_strict_decoding" x0
                                , heif_decoding_options_decoder_id = BG.getField @"heif_decoding_options_decoder_id" x0
                                , heif_decoding_options_color_conversion_options = BG.getField @"heif_decoding_options_color_conversion_options" x0
                                , heif_decoding_options_cancel_decoding = BG.getField @"heif_decoding_options_cancel_decoding" x0
                                , heif_decoding_options_color_conversion_options_ext = BG.getField @"heif_decoding_options_color_conversion_options_ext" x0
                                , heif_decoding_options_ignore_sequence_editlist = BG.getField @"heif_decoding_options_ignore_sequence_editlist" x0
                                , heif_decoding_options_output_image_nclx_profile = BG.getField @"heif_decoding_options_output_image_nclx_profile" x0
                                , heif_decoding_options_num_library_threads = BG.getField @"heif_decoding_options_num_library_threads" x0
                                , heif_decoding_options_num_codec_threads = BG.getField @"heif_decoding_options_num_codec_threads" x0
                                , heif_decoding_options_autocorrect_broken_input = BG.getField @"heif_decoding_options_autocorrect_broken_input" x0
                                , heif_decoding_options_output_image_nclx_profile_passthrough = BG.getField @"heif_decoding_options_output_image_nclx_profile_passthrough" x0
                                }
      , BG.getField @"heif_decoding_options_ignore_transformations" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_decoding_options_ignore_transformations" (BG.Ptr Heif_decoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoding_options_ignore_transformations")

instance HasCField.HasCField Heif_decoding_options "heif_decoding_options_ignore_transformations" where

  type CFieldType Heif_decoding_options "heif_decoding_options_ignore_transformations" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 1

{-| __C declaration:__ @start_progress@

    __defined at:__ @libheif\/heif_decoding.h 74:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.FunPtr (Heif_progress_step -> BG.CInt -> BG.Ptr BG.Void -> IO ())
         ) => BG.CompatHasField.HasField "heif_decoding_options_start_progress" Heif_decoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoding_options { heif_decoding_options_start_progress = y1
                                , heif_decoding_options_version = BG.getField @"heif_decoding_options_version" x0
                                , heif_decoding_options_ignore_transformations = BG.getField @"heif_decoding_options_ignore_transformations" x0
                                , heif_decoding_options_on_progress = BG.getField @"heif_decoding_options_on_progress" x0
                                , heif_decoding_options_end_progress = BG.getField @"heif_decoding_options_end_progress" x0
                                , heif_decoding_options_progress_user_data = BG.getField @"heif_decoding_options_progress_user_data" x0
                                , heif_decoding_options_convert_hdr_to_8bit = BG.getField @"heif_decoding_options_convert_hdr_to_8bit" x0
                                , heif_decoding_options_strict_decoding = BG.getField @"heif_decoding_options_strict_decoding" x0
                                , heif_decoding_options_decoder_id = BG.getField @"heif_decoding_options_decoder_id" x0
                                , heif_decoding_options_color_conversion_options = BG.getField @"heif_decoding_options_color_conversion_options" x0
                                , heif_decoding_options_cancel_decoding = BG.getField @"heif_decoding_options_cancel_decoding" x0
                                , heif_decoding_options_color_conversion_options_ext = BG.getField @"heif_decoding_options_color_conversion_options_ext" x0
                                , heif_decoding_options_ignore_sequence_editlist = BG.getField @"heif_decoding_options_ignore_sequence_editlist" x0
                                , heif_decoding_options_output_image_nclx_profile = BG.getField @"heif_decoding_options_output_image_nclx_profile" x0
                                , heif_decoding_options_num_library_threads = BG.getField @"heif_decoding_options_num_library_threads" x0
                                , heif_decoding_options_num_codec_threads = BG.getField @"heif_decoding_options_num_codec_threads" x0
                                , heif_decoding_options_autocorrect_broken_input = BG.getField @"heif_decoding_options_autocorrect_broken_input" x0
                                , heif_decoding_options_output_image_nclx_profile_passthrough = BG.getField @"heif_decoding_options_output_image_nclx_profile_passthrough" x0
                                }
      , BG.getField @"heif_decoding_options_start_progress" x0
      )

instance ( ty ~ BG.FunPtr (Heif_progress_step -> BG.CInt -> BG.Ptr BG.Void -> IO ())
         ) => BG.HasField "heif_decoding_options_start_progress" (BG.Ptr Heif_decoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoding_options_start_progress")

instance HasCField.HasCField Heif_decoding_options "heif_decoding_options_start_progress" where

  type CFieldType Heif_decoding_options "heif_decoding_options_start_progress" =
    BG.FunPtr (Heif_progress_step -> BG.CInt -> BG.Ptr BG.Void -> IO ())

  offset# = \_ -> \_ -> 8

{-| __C declaration:__ @on_progress@

    __defined at:__ @libheif\/heif_decoding.h 76:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.FunPtr (Heif_progress_step -> BG.CInt -> BG.Ptr BG.Void -> IO ())
         ) => BG.CompatHasField.HasField "heif_decoding_options_on_progress" Heif_decoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoding_options { heif_decoding_options_on_progress = y1
                                , heif_decoding_options_version = BG.getField @"heif_decoding_options_version" x0
                                , heif_decoding_options_ignore_transformations = BG.getField @"heif_decoding_options_ignore_transformations" x0
                                , heif_decoding_options_start_progress = BG.getField @"heif_decoding_options_start_progress" x0
                                , heif_decoding_options_end_progress = BG.getField @"heif_decoding_options_end_progress" x0
                                , heif_decoding_options_progress_user_data = BG.getField @"heif_decoding_options_progress_user_data" x0
                                , heif_decoding_options_convert_hdr_to_8bit = BG.getField @"heif_decoding_options_convert_hdr_to_8bit" x0
                                , heif_decoding_options_strict_decoding = BG.getField @"heif_decoding_options_strict_decoding" x0
                                , heif_decoding_options_decoder_id = BG.getField @"heif_decoding_options_decoder_id" x0
                                , heif_decoding_options_color_conversion_options = BG.getField @"heif_decoding_options_color_conversion_options" x0
                                , heif_decoding_options_cancel_decoding = BG.getField @"heif_decoding_options_cancel_decoding" x0
                                , heif_decoding_options_color_conversion_options_ext = BG.getField @"heif_decoding_options_color_conversion_options_ext" x0
                                , heif_decoding_options_ignore_sequence_editlist = BG.getField @"heif_decoding_options_ignore_sequence_editlist" x0
                                , heif_decoding_options_output_image_nclx_profile = BG.getField @"heif_decoding_options_output_image_nclx_profile" x0
                                , heif_decoding_options_num_library_threads = BG.getField @"heif_decoding_options_num_library_threads" x0
                                , heif_decoding_options_num_codec_threads = BG.getField @"heif_decoding_options_num_codec_threads" x0
                                , heif_decoding_options_autocorrect_broken_input = BG.getField @"heif_decoding_options_autocorrect_broken_input" x0
                                , heif_decoding_options_output_image_nclx_profile_passthrough = BG.getField @"heif_decoding_options_output_image_nclx_profile_passthrough" x0
                                }
      , BG.getField @"heif_decoding_options_on_progress" x0
      )

instance ( ty ~ BG.FunPtr (Heif_progress_step -> BG.CInt -> BG.Ptr BG.Void -> IO ())
         ) => BG.HasField "heif_decoding_options_on_progress" (BG.Ptr Heif_decoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoding_options_on_progress")

instance HasCField.HasCField Heif_decoding_options "heif_decoding_options_on_progress" where

  type CFieldType Heif_decoding_options "heif_decoding_options_on_progress" =
    BG.FunPtr (Heif_progress_step -> BG.CInt -> BG.Ptr BG.Void -> IO ())

  offset# = \_ -> \_ -> 16

{-| __C declaration:__ @end_progress@

    __defined at:__ @libheif\/heif_decoding.h 78:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.FunPtr (Heif_progress_step -> BG.Ptr BG.Void -> IO ())
         ) => BG.CompatHasField.HasField "heif_decoding_options_end_progress" Heif_decoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoding_options { heif_decoding_options_end_progress = y1
                                , heif_decoding_options_version = BG.getField @"heif_decoding_options_version" x0
                                , heif_decoding_options_ignore_transformations = BG.getField @"heif_decoding_options_ignore_transformations" x0
                                , heif_decoding_options_start_progress = BG.getField @"heif_decoding_options_start_progress" x0
                                , heif_decoding_options_on_progress = BG.getField @"heif_decoding_options_on_progress" x0
                                , heif_decoding_options_progress_user_data = BG.getField @"heif_decoding_options_progress_user_data" x0
                                , heif_decoding_options_convert_hdr_to_8bit = BG.getField @"heif_decoding_options_convert_hdr_to_8bit" x0
                                , heif_decoding_options_strict_decoding = BG.getField @"heif_decoding_options_strict_decoding" x0
                                , heif_decoding_options_decoder_id = BG.getField @"heif_decoding_options_decoder_id" x0
                                , heif_decoding_options_color_conversion_options = BG.getField @"heif_decoding_options_color_conversion_options" x0
                                , heif_decoding_options_cancel_decoding = BG.getField @"heif_decoding_options_cancel_decoding" x0
                                , heif_decoding_options_color_conversion_options_ext = BG.getField @"heif_decoding_options_color_conversion_options_ext" x0
                                , heif_decoding_options_ignore_sequence_editlist = BG.getField @"heif_decoding_options_ignore_sequence_editlist" x0
                                , heif_decoding_options_output_image_nclx_profile = BG.getField @"heif_decoding_options_output_image_nclx_profile" x0
                                , heif_decoding_options_num_library_threads = BG.getField @"heif_decoding_options_num_library_threads" x0
                                , heif_decoding_options_num_codec_threads = BG.getField @"heif_decoding_options_num_codec_threads" x0
                                , heif_decoding_options_autocorrect_broken_input = BG.getField @"heif_decoding_options_autocorrect_broken_input" x0
                                , heif_decoding_options_output_image_nclx_profile_passthrough = BG.getField @"heif_decoding_options_output_image_nclx_profile_passthrough" x0
                                }
      , BG.getField @"heif_decoding_options_end_progress" x0
      )

instance ( ty ~ BG.FunPtr (Heif_progress_step -> BG.Ptr BG.Void -> IO ())
         ) => BG.HasField "heif_decoding_options_end_progress" (BG.Ptr Heif_decoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoding_options_end_progress")

instance HasCField.HasCField Heif_decoding_options "heif_decoding_options_end_progress" where

  type CFieldType Heif_decoding_options "heif_decoding_options_end_progress" =
    BG.FunPtr (Heif_progress_step -> BG.Ptr BG.Void -> IO ())

  offset# = \_ -> \_ -> 24

{-| __C declaration:__ @progress_user_data@

    __defined at:__ @libheif\/heif_decoding.h 80:9@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.Ptr BG.Void
         ) => BG.CompatHasField.HasField "heif_decoding_options_progress_user_data" Heif_decoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoding_options { heif_decoding_options_progress_user_data = y1
                                , heif_decoding_options_version = BG.getField @"heif_decoding_options_version" x0
                                , heif_decoding_options_ignore_transformations = BG.getField @"heif_decoding_options_ignore_transformations" x0
                                , heif_decoding_options_start_progress = BG.getField @"heif_decoding_options_start_progress" x0
                                , heif_decoding_options_on_progress = BG.getField @"heif_decoding_options_on_progress" x0
                                , heif_decoding_options_end_progress = BG.getField @"heif_decoding_options_end_progress" x0
                                , heif_decoding_options_convert_hdr_to_8bit = BG.getField @"heif_decoding_options_convert_hdr_to_8bit" x0
                                , heif_decoding_options_strict_decoding = BG.getField @"heif_decoding_options_strict_decoding" x0
                                , heif_decoding_options_decoder_id = BG.getField @"heif_decoding_options_decoder_id" x0
                                , heif_decoding_options_color_conversion_options = BG.getField @"heif_decoding_options_color_conversion_options" x0
                                , heif_decoding_options_cancel_decoding = BG.getField @"heif_decoding_options_cancel_decoding" x0
                                , heif_decoding_options_color_conversion_options_ext = BG.getField @"heif_decoding_options_color_conversion_options_ext" x0
                                , heif_decoding_options_ignore_sequence_editlist = BG.getField @"heif_decoding_options_ignore_sequence_editlist" x0
                                , heif_decoding_options_output_image_nclx_profile = BG.getField @"heif_decoding_options_output_image_nclx_profile" x0
                                , heif_decoding_options_num_library_threads = BG.getField @"heif_decoding_options_num_library_threads" x0
                                , heif_decoding_options_num_codec_threads = BG.getField @"heif_decoding_options_num_codec_threads" x0
                                , heif_decoding_options_autocorrect_broken_input = BG.getField @"heif_decoding_options_autocorrect_broken_input" x0
                                , heif_decoding_options_output_image_nclx_profile_passthrough = BG.getField @"heif_decoding_options_output_image_nclx_profile_passthrough" x0
                                }
      , BG.getField @"heif_decoding_options_progress_user_data" x0
      )

instance ( ty ~ BG.Ptr BG.Void
         ) => BG.HasField "heif_decoding_options_progress_user_data" (BG.Ptr Heif_decoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoding_options_progress_user_data")

instance HasCField.HasCField Heif_decoding_options "heif_decoding_options_progress_user_data" where

  type CFieldType Heif_decoding_options "heif_decoding_options_progress_user_data" =
    BG.Ptr BG.Void

  offset# = \_ -> \_ -> 32

{-| __C declaration:__ @convert_hdr_to_8bit@

    __defined at:__ @libheif\/heif_decoding.h 84:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_decoding_options_convert_hdr_to_8bit" Heif_decoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoding_options { heif_decoding_options_convert_hdr_to_8bit = y1
                                , heif_decoding_options_version = BG.getField @"heif_decoding_options_version" x0
                                , heif_decoding_options_ignore_transformations = BG.getField @"heif_decoding_options_ignore_transformations" x0
                                , heif_decoding_options_start_progress = BG.getField @"heif_decoding_options_start_progress" x0
                                , heif_decoding_options_on_progress = BG.getField @"heif_decoding_options_on_progress" x0
                                , heif_decoding_options_end_progress = BG.getField @"heif_decoding_options_end_progress" x0
                                , heif_decoding_options_progress_user_data = BG.getField @"heif_decoding_options_progress_user_data" x0
                                , heif_decoding_options_strict_decoding = BG.getField @"heif_decoding_options_strict_decoding" x0
                                , heif_decoding_options_decoder_id = BG.getField @"heif_decoding_options_decoder_id" x0
                                , heif_decoding_options_color_conversion_options = BG.getField @"heif_decoding_options_color_conversion_options" x0
                                , heif_decoding_options_cancel_decoding = BG.getField @"heif_decoding_options_cancel_decoding" x0
                                , heif_decoding_options_color_conversion_options_ext = BG.getField @"heif_decoding_options_color_conversion_options_ext" x0
                                , heif_decoding_options_ignore_sequence_editlist = BG.getField @"heif_decoding_options_ignore_sequence_editlist" x0
                                , heif_decoding_options_output_image_nclx_profile = BG.getField @"heif_decoding_options_output_image_nclx_profile" x0
                                , heif_decoding_options_num_library_threads = BG.getField @"heif_decoding_options_num_library_threads" x0
                                , heif_decoding_options_num_codec_threads = BG.getField @"heif_decoding_options_num_codec_threads" x0
                                , heif_decoding_options_autocorrect_broken_input = BG.getField @"heif_decoding_options_autocorrect_broken_input" x0
                                , heif_decoding_options_output_image_nclx_profile_passthrough = BG.getField @"heif_decoding_options_output_image_nclx_profile_passthrough" x0
                                }
      , BG.getField @"heif_decoding_options_convert_hdr_to_8bit" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_decoding_options_convert_hdr_to_8bit" (BG.Ptr Heif_decoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoding_options_convert_hdr_to_8bit")

instance HasCField.HasCField Heif_decoding_options "heif_decoding_options_convert_hdr_to_8bit" where

  type CFieldType Heif_decoding_options "heif_decoding_options_convert_hdr_to_8bit" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 40

{-| __C declaration:__ @strict_decoding@

    __defined at:__ @libheif\/heif_decoding.h 90:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_decoding_options_strict_decoding" Heif_decoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoding_options { heif_decoding_options_strict_decoding = y1
                                , heif_decoding_options_version = BG.getField @"heif_decoding_options_version" x0
                                , heif_decoding_options_ignore_transformations = BG.getField @"heif_decoding_options_ignore_transformations" x0
                                , heif_decoding_options_start_progress = BG.getField @"heif_decoding_options_start_progress" x0
                                , heif_decoding_options_on_progress = BG.getField @"heif_decoding_options_on_progress" x0
                                , heif_decoding_options_end_progress = BG.getField @"heif_decoding_options_end_progress" x0
                                , heif_decoding_options_progress_user_data = BG.getField @"heif_decoding_options_progress_user_data" x0
                                , heif_decoding_options_convert_hdr_to_8bit = BG.getField @"heif_decoding_options_convert_hdr_to_8bit" x0
                                , heif_decoding_options_decoder_id = BG.getField @"heif_decoding_options_decoder_id" x0
                                , heif_decoding_options_color_conversion_options = BG.getField @"heif_decoding_options_color_conversion_options" x0
                                , heif_decoding_options_cancel_decoding = BG.getField @"heif_decoding_options_cancel_decoding" x0
                                , heif_decoding_options_color_conversion_options_ext = BG.getField @"heif_decoding_options_color_conversion_options_ext" x0
                                , heif_decoding_options_ignore_sequence_editlist = BG.getField @"heif_decoding_options_ignore_sequence_editlist" x0
                                , heif_decoding_options_output_image_nclx_profile = BG.getField @"heif_decoding_options_output_image_nclx_profile" x0
                                , heif_decoding_options_num_library_threads = BG.getField @"heif_decoding_options_num_library_threads" x0
                                , heif_decoding_options_num_codec_threads = BG.getField @"heif_decoding_options_num_codec_threads" x0
                                , heif_decoding_options_autocorrect_broken_input = BG.getField @"heif_decoding_options_autocorrect_broken_input" x0
                                , heif_decoding_options_output_image_nclx_profile_passthrough = BG.getField @"heif_decoding_options_output_image_nclx_profile_passthrough" x0
                                }
      , BG.getField @"heif_decoding_options_strict_decoding" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_decoding_options_strict_decoding" (BG.Ptr Heif_decoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoding_options_strict_decoding")

instance HasCField.HasCField Heif_decoding_options "heif_decoding_options_strict_decoding" where

  type CFieldType Heif_decoding_options "heif_decoding_options_strict_decoding" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 41

{-| __C declaration:__ @decoder_id@

    __defined at:__ @libheif\/heif_decoding.h 97:15@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ PtrConst.PtrConst BG.CChar
         ) => BG.CompatHasField.HasField "heif_decoding_options_decoder_id" Heif_decoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoding_options { heif_decoding_options_decoder_id = y1
                                , heif_decoding_options_version = BG.getField @"heif_decoding_options_version" x0
                                , heif_decoding_options_ignore_transformations = BG.getField @"heif_decoding_options_ignore_transformations" x0
                                , heif_decoding_options_start_progress = BG.getField @"heif_decoding_options_start_progress" x0
                                , heif_decoding_options_on_progress = BG.getField @"heif_decoding_options_on_progress" x0
                                , heif_decoding_options_end_progress = BG.getField @"heif_decoding_options_end_progress" x0
                                , heif_decoding_options_progress_user_data = BG.getField @"heif_decoding_options_progress_user_data" x0
                                , heif_decoding_options_convert_hdr_to_8bit = BG.getField @"heif_decoding_options_convert_hdr_to_8bit" x0
                                , heif_decoding_options_strict_decoding = BG.getField @"heif_decoding_options_strict_decoding" x0
                                , heif_decoding_options_color_conversion_options = BG.getField @"heif_decoding_options_color_conversion_options" x0
                                , heif_decoding_options_cancel_decoding = BG.getField @"heif_decoding_options_cancel_decoding" x0
                                , heif_decoding_options_color_conversion_options_ext = BG.getField @"heif_decoding_options_color_conversion_options_ext" x0
                                , heif_decoding_options_ignore_sequence_editlist = BG.getField @"heif_decoding_options_ignore_sequence_editlist" x0
                                , heif_decoding_options_output_image_nclx_profile = BG.getField @"heif_decoding_options_output_image_nclx_profile" x0
                                , heif_decoding_options_num_library_threads = BG.getField @"heif_decoding_options_num_library_threads" x0
                                , heif_decoding_options_num_codec_threads = BG.getField @"heif_decoding_options_num_codec_threads" x0
                                , heif_decoding_options_autocorrect_broken_input = BG.getField @"heif_decoding_options_autocorrect_broken_input" x0
                                , heif_decoding_options_output_image_nclx_profile_passthrough = BG.getField @"heif_decoding_options_output_image_nclx_profile_passthrough" x0
                                }
      , BG.getField @"heif_decoding_options_decoder_id" x0
      )

instance ( ty ~ PtrConst.PtrConst BG.CChar
         ) => BG.HasField "heif_decoding_options_decoder_id" (BG.Ptr Heif_decoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoding_options_decoder_id")

instance HasCField.HasCField Heif_decoding_options "heif_decoding_options_decoder_id" where

  type CFieldType Heif_decoding_options "heif_decoding_options_decoder_id" =
    PtrConst.PtrConst BG.CChar

  offset# = \_ -> \_ -> 48

{-| __C declaration:__ @color_conversion_options@

    __defined at:__ @libheif\/heif_decoding.h 101:33@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ Heif_color_conversion_options
         ) => BG.CompatHasField.HasField "heif_decoding_options_color_conversion_options" Heif_decoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoding_options { heif_decoding_options_color_conversion_options = y1
                                , heif_decoding_options_version = BG.getField @"heif_decoding_options_version" x0
                                , heif_decoding_options_ignore_transformations = BG.getField @"heif_decoding_options_ignore_transformations" x0
                                , heif_decoding_options_start_progress = BG.getField @"heif_decoding_options_start_progress" x0
                                , heif_decoding_options_on_progress = BG.getField @"heif_decoding_options_on_progress" x0
                                , heif_decoding_options_end_progress = BG.getField @"heif_decoding_options_end_progress" x0
                                , heif_decoding_options_progress_user_data = BG.getField @"heif_decoding_options_progress_user_data" x0
                                , heif_decoding_options_convert_hdr_to_8bit = BG.getField @"heif_decoding_options_convert_hdr_to_8bit" x0
                                , heif_decoding_options_strict_decoding = BG.getField @"heif_decoding_options_strict_decoding" x0
                                , heif_decoding_options_decoder_id = BG.getField @"heif_decoding_options_decoder_id" x0
                                , heif_decoding_options_cancel_decoding = BG.getField @"heif_decoding_options_cancel_decoding" x0
                                , heif_decoding_options_color_conversion_options_ext = BG.getField @"heif_decoding_options_color_conversion_options_ext" x0
                                , heif_decoding_options_ignore_sequence_editlist = BG.getField @"heif_decoding_options_ignore_sequence_editlist" x0
                                , heif_decoding_options_output_image_nclx_profile = BG.getField @"heif_decoding_options_output_image_nclx_profile" x0
                                , heif_decoding_options_num_library_threads = BG.getField @"heif_decoding_options_num_library_threads" x0
                                , heif_decoding_options_num_codec_threads = BG.getField @"heif_decoding_options_num_codec_threads" x0
                                , heif_decoding_options_autocorrect_broken_input = BG.getField @"heif_decoding_options_autocorrect_broken_input" x0
                                , heif_decoding_options_output_image_nclx_profile_passthrough = BG.getField @"heif_decoding_options_output_image_nclx_profile_passthrough" x0
                                }
      , BG.getField @"heif_decoding_options_color_conversion_options" x0
      )

instance ( ty ~ Heif_color_conversion_options
         ) => BG.HasField "heif_decoding_options_color_conversion_options" (BG.Ptr Heif_decoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoding_options_color_conversion_options")

instance HasCField.HasCField Heif_decoding_options "heif_decoding_options_color_conversion_options" where

  type CFieldType Heif_decoding_options "heif_decoding_options_color_conversion_options" =
    Heif_color_conversion_options

  offset# = \_ -> \_ -> 56

{-| __C declaration:__ @cancel_decoding@

    __defined at:__ @libheif\/heif_decoding.h 105:10@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.FunPtr (BG.Ptr BG.Void -> IO BG.CInt)
         ) => BG.CompatHasField.HasField "heif_decoding_options_cancel_decoding" Heif_decoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoding_options { heif_decoding_options_cancel_decoding = y1
                                , heif_decoding_options_version = BG.getField @"heif_decoding_options_version" x0
                                , heif_decoding_options_ignore_transformations = BG.getField @"heif_decoding_options_ignore_transformations" x0
                                , heif_decoding_options_start_progress = BG.getField @"heif_decoding_options_start_progress" x0
                                , heif_decoding_options_on_progress = BG.getField @"heif_decoding_options_on_progress" x0
                                , heif_decoding_options_end_progress = BG.getField @"heif_decoding_options_end_progress" x0
                                , heif_decoding_options_progress_user_data = BG.getField @"heif_decoding_options_progress_user_data" x0
                                , heif_decoding_options_convert_hdr_to_8bit = BG.getField @"heif_decoding_options_convert_hdr_to_8bit" x0
                                , heif_decoding_options_strict_decoding = BG.getField @"heif_decoding_options_strict_decoding" x0
                                , heif_decoding_options_decoder_id = BG.getField @"heif_decoding_options_decoder_id" x0
                                , heif_decoding_options_color_conversion_options = BG.getField @"heif_decoding_options_color_conversion_options" x0
                                , heif_decoding_options_color_conversion_options_ext = BG.getField @"heif_decoding_options_color_conversion_options_ext" x0
                                , heif_decoding_options_ignore_sequence_editlist = BG.getField @"heif_decoding_options_ignore_sequence_editlist" x0
                                , heif_decoding_options_output_image_nclx_profile = BG.getField @"heif_decoding_options_output_image_nclx_profile" x0
                                , heif_decoding_options_num_library_threads = BG.getField @"heif_decoding_options_num_library_threads" x0
                                , heif_decoding_options_num_codec_threads = BG.getField @"heif_decoding_options_num_codec_threads" x0
                                , heif_decoding_options_autocorrect_broken_input = BG.getField @"heif_decoding_options_autocorrect_broken_input" x0
                                , heif_decoding_options_output_image_nclx_profile_passthrough = BG.getField @"heif_decoding_options_output_image_nclx_profile_passthrough" x0
                                }
      , BG.getField @"heif_decoding_options_cancel_decoding" x0
      )

instance ( ty ~ BG.FunPtr (BG.Ptr BG.Void -> IO BG.CInt)
         ) => BG.HasField "heif_decoding_options_cancel_decoding" (BG.Ptr Heif_decoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoding_options_cancel_decoding")

instance HasCField.HasCField Heif_decoding_options "heif_decoding_options_cancel_decoding" where

  type CFieldType Heif_decoding_options "heif_decoding_options_cancel_decoding" =
    BG.FunPtr (BG.Ptr BG.Void -> IO BG.CInt)

  offset# = \_ -> \_ -> 72

{-| __C declaration:__ @color_conversion_options_ext@

    __defined at:__ @libheif\/heif_decoding.h 110:38@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.Ptr Heif_color_conversion_options_ext
         ) => BG.CompatHasField.HasField "heif_decoding_options_color_conversion_options_ext" Heif_decoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoding_options { heif_decoding_options_color_conversion_options_ext = y1
                                , heif_decoding_options_version = BG.getField @"heif_decoding_options_version" x0
                                , heif_decoding_options_ignore_transformations = BG.getField @"heif_decoding_options_ignore_transformations" x0
                                , heif_decoding_options_start_progress = BG.getField @"heif_decoding_options_start_progress" x0
                                , heif_decoding_options_on_progress = BG.getField @"heif_decoding_options_on_progress" x0
                                , heif_decoding_options_end_progress = BG.getField @"heif_decoding_options_end_progress" x0
                                , heif_decoding_options_progress_user_data = BG.getField @"heif_decoding_options_progress_user_data" x0
                                , heif_decoding_options_convert_hdr_to_8bit = BG.getField @"heif_decoding_options_convert_hdr_to_8bit" x0
                                , heif_decoding_options_strict_decoding = BG.getField @"heif_decoding_options_strict_decoding" x0
                                , heif_decoding_options_decoder_id = BG.getField @"heif_decoding_options_decoder_id" x0
                                , heif_decoding_options_color_conversion_options = BG.getField @"heif_decoding_options_color_conversion_options" x0
                                , heif_decoding_options_cancel_decoding = BG.getField @"heif_decoding_options_cancel_decoding" x0
                                , heif_decoding_options_ignore_sequence_editlist = BG.getField @"heif_decoding_options_ignore_sequence_editlist" x0
                                , heif_decoding_options_output_image_nclx_profile = BG.getField @"heif_decoding_options_output_image_nclx_profile" x0
                                , heif_decoding_options_num_library_threads = BG.getField @"heif_decoding_options_num_library_threads" x0
                                , heif_decoding_options_num_codec_threads = BG.getField @"heif_decoding_options_num_codec_threads" x0
                                , heif_decoding_options_autocorrect_broken_input = BG.getField @"heif_decoding_options_autocorrect_broken_input" x0
                                , heif_decoding_options_output_image_nclx_profile_passthrough = BG.getField @"heif_decoding_options_output_image_nclx_profile_passthrough" x0
                                }
      , BG.getField @"heif_decoding_options_color_conversion_options_ext" x0
      )

instance ( ty ~ BG.Ptr Heif_color_conversion_options_ext
         ) => BG.HasField "heif_decoding_options_color_conversion_options_ext" (BG.Ptr Heif_decoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoding_options_color_conversion_options_ext")

instance HasCField.HasCField Heif_decoding_options "heif_decoding_options_color_conversion_options_ext" where

  type CFieldType Heif_decoding_options "heif_decoding_options_color_conversion_options_ext" =
    BG.Ptr Heif_color_conversion_options_ext

  offset# = \_ -> \_ -> 80

{-| __C declaration:__ @ignore_sequence_editlist@

    __defined at:__ @libheif\/heif_decoding.h 115:7@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CInt
         ) => BG.CompatHasField.HasField "heif_decoding_options_ignore_sequence_editlist" Heif_decoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoding_options { heif_decoding_options_ignore_sequence_editlist = y1
                                , heif_decoding_options_version = BG.getField @"heif_decoding_options_version" x0
                                , heif_decoding_options_ignore_transformations = BG.getField @"heif_decoding_options_ignore_transformations" x0
                                , heif_decoding_options_start_progress = BG.getField @"heif_decoding_options_start_progress" x0
                                , heif_decoding_options_on_progress = BG.getField @"heif_decoding_options_on_progress" x0
                                , heif_decoding_options_end_progress = BG.getField @"heif_decoding_options_end_progress" x0
                                , heif_decoding_options_progress_user_data = BG.getField @"heif_decoding_options_progress_user_data" x0
                                , heif_decoding_options_convert_hdr_to_8bit = BG.getField @"heif_decoding_options_convert_hdr_to_8bit" x0
                                , heif_decoding_options_strict_decoding = BG.getField @"heif_decoding_options_strict_decoding" x0
                                , heif_decoding_options_decoder_id = BG.getField @"heif_decoding_options_decoder_id" x0
                                , heif_decoding_options_color_conversion_options = BG.getField @"heif_decoding_options_color_conversion_options" x0
                                , heif_decoding_options_cancel_decoding = BG.getField @"heif_decoding_options_cancel_decoding" x0
                                , heif_decoding_options_color_conversion_options_ext = BG.getField @"heif_decoding_options_color_conversion_options_ext" x0
                                , heif_decoding_options_output_image_nclx_profile = BG.getField @"heif_decoding_options_output_image_nclx_profile" x0
                                , heif_decoding_options_num_library_threads = BG.getField @"heif_decoding_options_num_library_threads" x0
                                , heif_decoding_options_num_codec_threads = BG.getField @"heif_decoding_options_num_codec_threads" x0
                                , heif_decoding_options_autocorrect_broken_input = BG.getField @"heif_decoding_options_autocorrect_broken_input" x0
                                , heif_decoding_options_output_image_nclx_profile_passthrough = BG.getField @"heif_decoding_options_output_image_nclx_profile_passthrough" x0
                                }
      , BG.getField @"heif_decoding_options_ignore_sequence_editlist" x0
      )

instance ( ty ~ BG.CInt
         ) => BG.HasField "heif_decoding_options_ignore_sequence_editlist" (BG.Ptr Heif_decoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoding_options_ignore_sequence_editlist")

instance HasCField.HasCField Heif_decoding_options "heif_decoding_options_ignore_sequence_editlist" where

  type CFieldType Heif_decoding_options "heif_decoding_options_ignore_sequence_editlist" =
    BG.CInt

  offset# = \_ -> \_ -> 88

{-| __C declaration:__ @output_image_nclx_profile@

    __defined at:__ @libheif\/heif_decoding.h 126:28@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.Ptr Heif_color_profile_nclx
         ) => BG.CompatHasField.HasField "heif_decoding_options_output_image_nclx_profile" Heif_decoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoding_options { heif_decoding_options_output_image_nclx_profile = y1
                                , heif_decoding_options_version = BG.getField @"heif_decoding_options_version" x0
                                , heif_decoding_options_ignore_transformations = BG.getField @"heif_decoding_options_ignore_transformations" x0
                                , heif_decoding_options_start_progress = BG.getField @"heif_decoding_options_start_progress" x0
                                , heif_decoding_options_on_progress = BG.getField @"heif_decoding_options_on_progress" x0
                                , heif_decoding_options_end_progress = BG.getField @"heif_decoding_options_end_progress" x0
                                , heif_decoding_options_progress_user_data = BG.getField @"heif_decoding_options_progress_user_data" x0
                                , heif_decoding_options_convert_hdr_to_8bit = BG.getField @"heif_decoding_options_convert_hdr_to_8bit" x0
                                , heif_decoding_options_strict_decoding = BG.getField @"heif_decoding_options_strict_decoding" x0
                                , heif_decoding_options_decoder_id = BG.getField @"heif_decoding_options_decoder_id" x0
                                , heif_decoding_options_color_conversion_options = BG.getField @"heif_decoding_options_color_conversion_options" x0
                                , heif_decoding_options_cancel_decoding = BG.getField @"heif_decoding_options_cancel_decoding" x0
                                , heif_decoding_options_color_conversion_options_ext = BG.getField @"heif_decoding_options_color_conversion_options_ext" x0
                                , heif_decoding_options_ignore_sequence_editlist = BG.getField @"heif_decoding_options_ignore_sequence_editlist" x0
                                , heif_decoding_options_num_library_threads = BG.getField @"heif_decoding_options_num_library_threads" x0
                                , heif_decoding_options_num_codec_threads = BG.getField @"heif_decoding_options_num_codec_threads" x0
                                , heif_decoding_options_autocorrect_broken_input = BG.getField @"heif_decoding_options_autocorrect_broken_input" x0
                                , heif_decoding_options_output_image_nclx_profile_passthrough = BG.getField @"heif_decoding_options_output_image_nclx_profile_passthrough" x0
                                }
      , BG.getField @"heif_decoding_options_output_image_nclx_profile" x0
      )

instance ( ty ~ BG.Ptr Heif_color_profile_nclx
         ) => BG.HasField "heif_decoding_options_output_image_nclx_profile" (BG.Ptr Heif_decoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoding_options_output_image_nclx_profile")

instance HasCField.HasCField Heif_decoding_options "heif_decoding_options_output_image_nclx_profile" where

  type CFieldType Heif_decoding_options "heif_decoding_options_output_image_nclx_profile" =
    BG.Ptr Heif_color_profile_nclx

  offset# = \_ -> \_ -> 96

{-| __C declaration:__ @num_library_threads@

    __defined at:__ @libheif\/heif_decoding.h 128:7@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CInt
         ) => BG.CompatHasField.HasField "heif_decoding_options_num_library_threads" Heif_decoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoding_options { heif_decoding_options_num_library_threads = y1
                                , heif_decoding_options_version = BG.getField @"heif_decoding_options_version" x0
                                , heif_decoding_options_ignore_transformations = BG.getField @"heif_decoding_options_ignore_transformations" x0
                                , heif_decoding_options_start_progress = BG.getField @"heif_decoding_options_start_progress" x0
                                , heif_decoding_options_on_progress = BG.getField @"heif_decoding_options_on_progress" x0
                                , heif_decoding_options_end_progress = BG.getField @"heif_decoding_options_end_progress" x0
                                , heif_decoding_options_progress_user_data = BG.getField @"heif_decoding_options_progress_user_data" x0
                                , heif_decoding_options_convert_hdr_to_8bit = BG.getField @"heif_decoding_options_convert_hdr_to_8bit" x0
                                , heif_decoding_options_strict_decoding = BG.getField @"heif_decoding_options_strict_decoding" x0
                                , heif_decoding_options_decoder_id = BG.getField @"heif_decoding_options_decoder_id" x0
                                , heif_decoding_options_color_conversion_options = BG.getField @"heif_decoding_options_color_conversion_options" x0
                                , heif_decoding_options_cancel_decoding = BG.getField @"heif_decoding_options_cancel_decoding" x0
                                , heif_decoding_options_color_conversion_options_ext = BG.getField @"heif_decoding_options_color_conversion_options_ext" x0
                                , heif_decoding_options_ignore_sequence_editlist = BG.getField @"heif_decoding_options_ignore_sequence_editlist" x0
                                , heif_decoding_options_output_image_nclx_profile = BG.getField @"heif_decoding_options_output_image_nclx_profile" x0
                                , heif_decoding_options_num_codec_threads = BG.getField @"heif_decoding_options_num_codec_threads" x0
                                , heif_decoding_options_autocorrect_broken_input = BG.getField @"heif_decoding_options_autocorrect_broken_input" x0
                                , heif_decoding_options_output_image_nclx_profile_passthrough = BG.getField @"heif_decoding_options_output_image_nclx_profile_passthrough" x0
                                }
      , BG.getField @"heif_decoding_options_num_library_threads" x0
      )

instance ( ty ~ BG.CInt
         ) => BG.HasField "heif_decoding_options_num_library_threads" (BG.Ptr Heif_decoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoding_options_num_library_threads")

instance HasCField.HasCField Heif_decoding_options "heif_decoding_options_num_library_threads" where

  type CFieldType Heif_decoding_options "heif_decoding_options_num_library_threads" =
    BG.CInt

  offset# = \_ -> \_ -> 104

{-| __C declaration:__ @num_codec_threads@

    __defined at:__ @libheif\/heif_decoding.h 129:7@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CInt
         ) => BG.CompatHasField.HasField "heif_decoding_options_num_codec_threads" Heif_decoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoding_options { heif_decoding_options_num_codec_threads = y1
                                , heif_decoding_options_version = BG.getField @"heif_decoding_options_version" x0
                                , heif_decoding_options_ignore_transformations = BG.getField @"heif_decoding_options_ignore_transformations" x0
                                , heif_decoding_options_start_progress = BG.getField @"heif_decoding_options_start_progress" x0
                                , heif_decoding_options_on_progress = BG.getField @"heif_decoding_options_on_progress" x0
                                , heif_decoding_options_end_progress = BG.getField @"heif_decoding_options_end_progress" x0
                                , heif_decoding_options_progress_user_data = BG.getField @"heif_decoding_options_progress_user_data" x0
                                , heif_decoding_options_convert_hdr_to_8bit = BG.getField @"heif_decoding_options_convert_hdr_to_8bit" x0
                                , heif_decoding_options_strict_decoding = BG.getField @"heif_decoding_options_strict_decoding" x0
                                , heif_decoding_options_decoder_id = BG.getField @"heif_decoding_options_decoder_id" x0
                                , heif_decoding_options_color_conversion_options = BG.getField @"heif_decoding_options_color_conversion_options" x0
                                , heif_decoding_options_cancel_decoding = BG.getField @"heif_decoding_options_cancel_decoding" x0
                                , heif_decoding_options_color_conversion_options_ext = BG.getField @"heif_decoding_options_color_conversion_options_ext" x0
                                , heif_decoding_options_ignore_sequence_editlist = BG.getField @"heif_decoding_options_ignore_sequence_editlist" x0
                                , heif_decoding_options_output_image_nclx_profile = BG.getField @"heif_decoding_options_output_image_nclx_profile" x0
                                , heif_decoding_options_num_library_threads = BG.getField @"heif_decoding_options_num_library_threads" x0
                                , heif_decoding_options_autocorrect_broken_input = BG.getField @"heif_decoding_options_autocorrect_broken_input" x0
                                , heif_decoding_options_output_image_nclx_profile_passthrough = BG.getField @"heif_decoding_options_output_image_nclx_profile_passthrough" x0
                                }
      , BG.getField @"heif_decoding_options_num_codec_threads" x0
      )

instance ( ty ~ BG.CInt
         ) => BG.HasField "heif_decoding_options_num_codec_threads" (BG.Ptr Heif_decoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoding_options_num_codec_threads")

instance HasCField.HasCField Heif_decoding_options "heif_decoding_options_num_codec_threads" where

  type CFieldType Heif_decoding_options "heif_decoding_options_num_codec_threads" =
    BG.CInt

  offset# = \_ -> \_ -> 108

{-| __C declaration:__ @autocorrect_broken_input@

    __defined at:__ @libheif\/heif_decoding.h 136:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_decoding_options_autocorrect_broken_input" Heif_decoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoding_options { heif_decoding_options_autocorrect_broken_input = y1
                                , heif_decoding_options_version = BG.getField @"heif_decoding_options_version" x0
                                , heif_decoding_options_ignore_transformations = BG.getField @"heif_decoding_options_ignore_transformations" x0
                                , heif_decoding_options_start_progress = BG.getField @"heif_decoding_options_start_progress" x0
                                , heif_decoding_options_on_progress = BG.getField @"heif_decoding_options_on_progress" x0
                                , heif_decoding_options_end_progress = BG.getField @"heif_decoding_options_end_progress" x0
                                , heif_decoding_options_progress_user_data = BG.getField @"heif_decoding_options_progress_user_data" x0
                                , heif_decoding_options_convert_hdr_to_8bit = BG.getField @"heif_decoding_options_convert_hdr_to_8bit" x0
                                , heif_decoding_options_strict_decoding = BG.getField @"heif_decoding_options_strict_decoding" x0
                                , heif_decoding_options_decoder_id = BG.getField @"heif_decoding_options_decoder_id" x0
                                , heif_decoding_options_color_conversion_options = BG.getField @"heif_decoding_options_color_conversion_options" x0
                                , heif_decoding_options_cancel_decoding = BG.getField @"heif_decoding_options_cancel_decoding" x0
                                , heif_decoding_options_color_conversion_options_ext = BG.getField @"heif_decoding_options_color_conversion_options_ext" x0
                                , heif_decoding_options_ignore_sequence_editlist = BG.getField @"heif_decoding_options_ignore_sequence_editlist" x0
                                , heif_decoding_options_output_image_nclx_profile = BG.getField @"heif_decoding_options_output_image_nclx_profile" x0
                                , heif_decoding_options_num_library_threads = BG.getField @"heif_decoding_options_num_library_threads" x0
                                , heif_decoding_options_num_codec_threads = BG.getField @"heif_decoding_options_num_codec_threads" x0
                                , heif_decoding_options_output_image_nclx_profile_passthrough = BG.getField @"heif_decoding_options_output_image_nclx_profile_passthrough" x0
                                }
      , BG.getField @"heif_decoding_options_autocorrect_broken_input" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_decoding_options_autocorrect_broken_input" (BG.Ptr Heif_decoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoding_options_autocorrect_broken_input")

instance HasCField.HasCField Heif_decoding_options "heif_decoding_options_autocorrect_broken_input" where

  type CFieldType Heif_decoding_options "heif_decoding_options_autocorrect_broken_input" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 112

{-| __C declaration:__ @output_image_nclx_profile_passthrough@

    __defined at:__ @libheif\/heif_decoding.h 157:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_decoding_options_output_image_nclx_profile_passthrough" Heif_decoding_options ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_decoding_options { heif_decoding_options_output_image_nclx_profile_passthrough = y1
                                , heif_decoding_options_version = BG.getField @"heif_decoding_options_version" x0
                                , heif_decoding_options_ignore_transformations = BG.getField @"heif_decoding_options_ignore_transformations" x0
                                , heif_decoding_options_start_progress = BG.getField @"heif_decoding_options_start_progress" x0
                                , heif_decoding_options_on_progress = BG.getField @"heif_decoding_options_on_progress" x0
                                , heif_decoding_options_end_progress = BG.getField @"heif_decoding_options_end_progress" x0
                                , heif_decoding_options_progress_user_data = BG.getField @"heif_decoding_options_progress_user_data" x0
                                , heif_decoding_options_convert_hdr_to_8bit = BG.getField @"heif_decoding_options_convert_hdr_to_8bit" x0
                                , heif_decoding_options_strict_decoding = BG.getField @"heif_decoding_options_strict_decoding" x0
                                , heif_decoding_options_decoder_id = BG.getField @"heif_decoding_options_decoder_id" x0
                                , heif_decoding_options_color_conversion_options = BG.getField @"heif_decoding_options_color_conversion_options" x0
                                , heif_decoding_options_cancel_decoding = BG.getField @"heif_decoding_options_cancel_decoding" x0
                                , heif_decoding_options_color_conversion_options_ext = BG.getField @"heif_decoding_options_color_conversion_options_ext" x0
                                , heif_decoding_options_ignore_sequence_editlist = BG.getField @"heif_decoding_options_ignore_sequence_editlist" x0
                                , heif_decoding_options_output_image_nclx_profile = BG.getField @"heif_decoding_options_output_image_nclx_profile" x0
                                , heif_decoding_options_num_library_threads = BG.getField @"heif_decoding_options_num_library_threads" x0
                                , heif_decoding_options_num_codec_threads = BG.getField @"heif_decoding_options_num_codec_threads" x0
                                , heif_decoding_options_autocorrect_broken_input = BG.getField @"heif_decoding_options_autocorrect_broken_input" x0
                                }
      , BG.getField @"heif_decoding_options_output_image_nclx_profile_passthrough" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_decoding_options_output_image_nclx_profile_passthrough" (BG.Ptr Heif_decoding_options) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_decoding_options_output_image_nclx_profile_passthrough")

instance HasCField.HasCField Heif_decoding_options "heif_decoding_options_output_image_nclx_profile_passthrough" where

  type CFieldType Heif_decoding_options "heif_decoding_options_output_image_nclx_profile_passthrough" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 113

{-| __C declaration:__ @struct heif_decoder_descriptor@

    __defined at:__ @libheif\/heif_decoding.h 175:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_decoder_descriptor

{-| __C declaration:__ @struct heif_image_tiling@

    __defined at:__ @libheif\/heif_tiling.h 37:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_image_tiling = Heif_image_tiling
  { heif_image_tiling_version :: BG.CInt
    {- ^ __C declaration:__ @version@

         __defined at:__ @libheif\/heif_tiling.h 39:7@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_image_tiling_num_columns :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @num_columns@

         __defined at:__ @libheif\/heif_tiling.h 43:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_image_tiling_num_rows :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @num_rows@

         __defined at:__ @libheif\/heif_tiling.h 44:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_image_tiling_tile_width :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @tile_width@

         __defined at:__ @libheif\/heif_tiling.h 45:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_image_tiling_tile_height :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @tile_height@

         __defined at:__ @libheif\/heif_tiling.h 46:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_image_tiling_image_width :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @image_width@

         __defined at:__ @libheif\/heif_tiling.h 48:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_image_tiling_image_height :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @image_height@

         __defined at:__ @libheif\/heif_tiling.h 49:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_image_tiling_top_offset :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @top_offset@

         __defined at:__ @libheif\/heif_tiling.h 54:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_image_tiling_left_offset :: HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @left_offset@

         __defined at:__ @libheif\/heif_tiling.h 55:12@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_image_tiling_number_of_extra_dimensions :: HsBindgen.Runtime.LibC.Word8
    {- ^ __C declaration:__ @number_of_extra_dimensions@

         __defined at:__ @libheif\/heif_tiling.h 57:11@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_image_tiling_extra_dimension_size :: CA.ConstantArray 8 HsBindgen.Runtime.LibC.Word32
    {- ^ __C declaration:__ @extra_dimension_size@

         __defined at:__ @libheif\/heif_tiling.h 58:12@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_image_tiling where

  staticSizeOf = \_ -> (72 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_image_tiling where

  readRaw =
    \ptr0 ->
          pure Heif_image_tiling
      <*> HasCField.readRaw (BG.Proxy @"heif_image_tiling_version") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_image_tiling_num_columns") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_image_tiling_num_rows") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_image_tiling_tile_width") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_image_tiling_tile_height") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_image_tiling_image_width") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_image_tiling_image_height") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_image_tiling_top_offset") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_image_tiling_left_offset") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_image_tiling_number_of_extra_dimensions") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_image_tiling_extra_dimension_size") ptr0

instance Marshal.WriteRaw Heif_image_tiling where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_image_tiling
            heif_image_tiling_version2
            heif_image_tiling_num_columns3
            heif_image_tiling_num_rows4
            heif_image_tiling_tile_width5
            heif_image_tiling_tile_height6
            heif_image_tiling_image_width7
            heif_image_tiling_image_height8
            heif_image_tiling_top_offset9
            heif_image_tiling_left_offset10
            heif_image_tiling_number_of_extra_dimensions11
            heif_image_tiling_extra_dimension_size12 ->
                 HasCField.writeRaw (BG.Proxy @"heif_image_tiling_version") ptr0 heif_image_tiling_version2
              >> HasCField.writeRaw (BG.Proxy @"heif_image_tiling_num_columns") ptr0 heif_image_tiling_num_columns3
              >> HasCField.writeRaw (BG.Proxy @"heif_image_tiling_num_rows") ptr0 heif_image_tiling_num_rows4
              >> HasCField.writeRaw (BG.Proxy @"heif_image_tiling_tile_width") ptr0 heif_image_tiling_tile_width5
              >> HasCField.writeRaw (BG.Proxy @"heif_image_tiling_tile_height") ptr0 heif_image_tiling_tile_height6
              >> HasCField.writeRaw (BG.Proxy @"heif_image_tiling_image_width") ptr0 heif_image_tiling_image_width7
              >> HasCField.writeRaw (BG.Proxy @"heif_image_tiling_image_height") ptr0 heif_image_tiling_image_height8
              >> HasCField.writeRaw (BG.Proxy @"heif_image_tiling_top_offset") ptr0 heif_image_tiling_top_offset9
              >> HasCField.writeRaw (BG.Proxy @"heif_image_tiling_left_offset") ptr0 heif_image_tiling_left_offset10
              >> HasCField.writeRaw (BG.Proxy @"heif_image_tiling_number_of_extra_dimensions") ptr0 heif_image_tiling_number_of_extra_dimensions11
              >> HasCField.writeRaw (BG.Proxy @"heif_image_tiling_extra_dimension_size") ptr0 heif_image_tiling_extra_dimension_size12

deriving via Marshal.EquivStorable Heif_image_tiling instance BG.Storable Heif_image_tiling

deriving via Struct.IsStructViaReadRaw Heif_image_tiling instance Struct.IsStruct Heif_image_tiling

{-| __C declaration:__ @version@

    __defined at:__ @libheif\/heif_tiling.h 39:7@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CInt
         ) => BG.CompatHasField.HasField "heif_image_tiling_version" Heif_image_tiling ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_image_tiling { heif_image_tiling_version = y1
                            , heif_image_tiling_num_columns = BG.getField @"heif_image_tiling_num_columns" x0
                            , heif_image_tiling_num_rows = BG.getField @"heif_image_tiling_num_rows" x0
                            , heif_image_tiling_tile_width = BG.getField @"heif_image_tiling_tile_width" x0
                            , heif_image_tiling_tile_height = BG.getField @"heif_image_tiling_tile_height" x0
                            , heif_image_tiling_image_width = BG.getField @"heif_image_tiling_image_width" x0
                            , heif_image_tiling_image_height = BG.getField @"heif_image_tiling_image_height" x0
                            , heif_image_tiling_top_offset = BG.getField @"heif_image_tiling_top_offset" x0
                            , heif_image_tiling_left_offset = BG.getField @"heif_image_tiling_left_offset" x0
                            , heif_image_tiling_number_of_extra_dimensions = BG.getField @"heif_image_tiling_number_of_extra_dimensions" x0
                            , heif_image_tiling_extra_dimension_size = BG.getField @"heif_image_tiling_extra_dimension_size" x0
                            }
      , BG.getField @"heif_image_tiling_version" x0
      )

instance ( ty ~ BG.CInt
         ) => BG.HasField "heif_image_tiling_version" (BG.Ptr Heif_image_tiling) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_image_tiling_version")

instance HasCField.HasCField Heif_image_tiling "heif_image_tiling_version" where

  type CFieldType Heif_image_tiling "heif_image_tiling_version" =
    BG.CInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @num_columns@

    __defined at:__ @libheif\/heif_tiling.h 43:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_image_tiling_num_columns" Heif_image_tiling ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_image_tiling { heif_image_tiling_num_columns = y1
                            , heif_image_tiling_version = BG.getField @"heif_image_tiling_version" x0
                            , heif_image_tiling_num_rows = BG.getField @"heif_image_tiling_num_rows" x0
                            , heif_image_tiling_tile_width = BG.getField @"heif_image_tiling_tile_width" x0
                            , heif_image_tiling_tile_height = BG.getField @"heif_image_tiling_tile_height" x0
                            , heif_image_tiling_image_width = BG.getField @"heif_image_tiling_image_width" x0
                            , heif_image_tiling_image_height = BG.getField @"heif_image_tiling_image_height" x0
                            , heif_image_tiling_top_offset = BG.getField @"heif_image_tiling_top_offset" x0
                            , heif_image_tiling_left_offset = BG.getField @"heif_image_tiling_left_offset" x0
                            , heif_image_tiling_number_of_extra_dimensions = BG.getField @"heif_image_tiling_number_of_extra_dimensions" x0
                            , heif_image_tiling_extra_dimension_size = BG.getField @"heif_image_tiling_extra_dimension_size" x0
                            }
      , BG.getField @"heif_image_tiling_num_columns" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_image_tiling_num_columns" (BG.Ptr Heif_image_tiling) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_image_tiling_num_columns")

instance HasCField.HasCField Heif_image_tiling "heif_image_tiling_num_columns" where

  type CFieldType Heif_image_tiling "heif_image_tiling_num_columns" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 4

{-| __C declaration:__ @num_rows@

    __defined at:__ @libheif\/heif_tiling.h 44:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_image_tiling_num_rows" Heif_image_tiling ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_image_tiling { heif_image_tiling_num_rows = y1
                            , heif_image_tiling_version = BG.getField @"heif_image_tiling_version" x0
                            , heif_image_tiling_num_columns = BG.getField @"heif_image_tiling_num_columns" x0
                            , heif_image_tiling_tile_width = BG.getField @"heif_image_tiling_tile_width" x0
                            , heif_image_tiling_tile_height = BG.getField @"heif_image_tiling_tile_height" x0
                            , heif_image_tiling_image_width = BG.getField @"heif_image_tiling_image_width" x0
                            , heif_image_tiling_image_height = BG.getField @"heif_image_tiling_image_height" x0
                            , heif_image_tiling_top_offset = BG.getField @"heif_image_tiling_top_offset" x0
                            , heif_image_tiling_left_offset = BG.getField @"heif_image_tiling_left_offset" x0
                            , heif_image_tiling_number_of_extra_dimensions = BG.getField @"heif_image_tiling_number_of_extra_dimensions" x0
                            , heif_image_tiling_extra_dimension_size = BG.getField @"heif_image_tiling_extra_dimension_size" x0
                            }
      , BG.getField @"heif_image_tiling_num_rows" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_image_tiling_num_rows" (BG.Ptr Heif_image_tiling) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_image_tiling_num_rows")

instance HasCField.HasCField Heif_image_tiling "heif_image_tiling_num_rows" where

  type CFieldType Heif_image_tiling "heif_image_tiling_num_rows" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 8

{-| __C declaration:__ @tile_width@

    __defined at:__ @libheif\/heif_tiling.h 45:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_image_tiling_tile_width" Heif_image_tiling ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_image_tiling { heif_image_tiling_tile_width = y1
                            , heif_image_tiling_version = BG.getField @"heif_image_tiling_version" x0
                            , heif_image_tiling_num_columns = BG.getField @"heif_image_tiling_num_columns" x0
                            , heif_image_tiling_num_rows = BG.getField @"heif_image_tiling_num_rows" x0
                            , heif_image_tiling_tile_height = BG.getField @"heif_image_tiling_tile_height" x0
                            , heif_image_tiling_image_width = BG.getField @"heif_image_tiling_image_width" x0
                            , heif_image_tiling_image_height = BG.getField @"heif_image_tiling_image_height" x0
                            , heif_image_tiling_top_offset = BG.getField @"heif_image_tiling_top_offset" x0
                            , heif_image_tiling_left_offset = BG.getField @"heif_image_tiling_left_offset" x0
                            , heif_image_tiling_number_of_extra_dimensions = BG.getField @"heif_image_tiling_number_of_extra_dimensions" x0
                            , heif_image_tiling_extra_dimension_size = BG.getField @"heif_image_tiling_extra_dimension_size" x0
                            }
      , BG.getField @"heif_image_tiling_tile_width" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_image_tiling_tile_width" (BG.Ptr Heif_image_tiling) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_image_tiling_tile_width")

instance HasCField.HasCField Heif_image_tiling "heif_image_tiling_tile_width" where

  type CFieldType Heif_image_tiling "heif_image_tiling_tile_width" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 12

{-| __C declaration:__ @tile_height@

    __defined at:__ @libheif\/heif_tiling.h 46:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_image_tiling_tile_height" Heif_image_tiling ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_image_tiling { heif_image_tiling_tile_height = y1
                            , heif_image_tiling_version = BG.getField @"heif_image_tiling_version" x0
                            , heif_image_tiling_num_columns = BG.getField @"heif_image_tiling_num_columns" x0
                            , heif_image_tiling_num_rows = BG.getField @"heif_image_tiling_num_rows" x0
                            , heif_image_tiling_tile_width = BG.getField @"heif_image_tiling_tile_width" x0
                            , heif_image_tiling_image_width = BG.getField @"heif_image_tiling_image_width" x0
                            , heif_image_tiling_image_height = BG.getField @"heif_image_tiling_image_height" x0
                            , heif_image_tiling_top_offset = BG.getField @"heif_image_tiling_top_offset" x0
                            , heif_image_tiling_left_offset = BG.getField @"heif_image_tiling_left_offset" x0
                            , heif_image_tiling_number_of_extra_dimensions = BG.getField @"heif_image_tiling_number_of_extra_dimensions" x0
                            , heif_image_tiling_extra_dimension_size = BG.getField @"heif_image_tiling_extra_dimension_size" x0
                            }
      , BG.getField @"heif_image_tiling_tile_height" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_image_tiling_tile_height" (BG.Ptr Heif_image_tiling) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_image_tiling_tile_height")

instance HasCField.HasCField Heif_image_tiling "heif_image_tiling_tile_height" where

  type CFieldType Heif_image_tiling "heif_image_tiling_tile_height" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 16

{-| __C declaration:__ @image_width@

    __defined at:__ @libheif\/heif_tiling.h 48:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_image_tiling_image_width" Heif_image_tiling ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_image_tiling { heif_image_tiling_image_width = y1
                            , heif_image_tiling_version = BG.getField @"heif_image_tiling_version" x0
                            , heif_image_tiling_num_columns = BG.getField @"heif_image_tiling_num_columns" x0
                            , heif_image_tiling_num_rows = BG.getField @"heif_image_tiling_num_rows" x0
                            , heif_image_tiling_tile_width = BG.getField @"heif_image_tiling_tile_width" x0
                            , heif_image_tiling_tile_height = BG.getField @"heif_image_tiling_tile_height" x0
                            , heif_image_tiling_image_height = BG.getField @"heif_image_tiling_image_height" x0
                            , heif_image_tiling_top_offset = BG.getField @"heif_image_tiling_top_offset" x0
                            , heif_image_tiling_left_offset = BG.getField @"heif_image_tiling_left_offset" x0
                            , heif_image_tiling_number_of_extra_dimensions = BG.getField @"heif_image_tiling_number_of_extra_dimensions" x0
                            , heif_image_tiling_extra_dimension_size = BG.getField @"heif_image_tiling_extra_dimension_size" x0
                            }
      , BG.getField @"heif_image_tiling_image_width" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_image_tiling_image_width" (BG.Ptr Heif_image_tiling) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_image_tiling_image_width")

instance HasCField.HasCField Heif_image_tiling "heif_image_tiling_image_width" where

  type CFieldType Heif_image_tiling "heif_image_tiling_image_width" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 20

{-| __C declaration:__ @image_height@

    __defined at:__ @libheif\/heif_tiling.h 49:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_image_tiling_image_height" Heif_image_tiling ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_image_tiling { heif_image_tiling_image_height = y1
                            , heif_image_tiling_version = BG.getField @"heif_image_tiling_version" x0
                            , heif_image_tiling_num_columns = BG.getField @"heif_image_tiling_num_columns" x0
                            , heif_image_tiling_num_rows = BG.getField @"heif_image_tiling_num_rows" x0
                            , heif_image_tiling_tile_width = BG.getField @"heif_image_tiling_tile_width" x0
                            , heif_image_tiling_tile_height = BG.getField @"heif_image_tiling_tile_height" x0
                            , heif_image_tiling_image_width = BG.getField @"heif_image_tiling_image_width" x0
                            , heif_image_tiling_top_offset = BG.getField @"heif_image_tiling_top_offset" x0
                            , heif_image_tiling_left_offset = BG.getField @"heif_image_tiling_left_offset" x0
                            , heif_image_tiling_number_of_extra_dimensions = BG.getField @"heif_image_tiling_number_of_extra_dimensions" x0
                            , heif_image_tiling_extra_dimension_size = BG.getField @"heif_image_tiling_extra_dimension_size" x0
                            }
      , BG.getField @"heif_image_tiling_image_height" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_image_tiling_image_height" (BG.Ptr Heif_image_tiling) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_image_tiling_image_height")

instance HasCField.HasCField Heif_image_tiling "heif_image_tiling_image_height" where

  type CFieldType Heif_image_tiling "heif_image_tiling_image_height" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 24

{-| __C declaration:__ @top_offset@

    __defined at:__ @libheif\/heif_tiling.h 54:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_image_tiling_top_offset" Heif_image_tiling ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_image_tiling { heif_image_tiling_top_offset = y1
                            , heif_image_tiling_version = BG.getField @"heif_image_tiling_version" x0
                            , heif_image_tiling_num_columns = BG.getField @"heif_image_tiling_num_columns" x0
                            , heif_image_tiling_num_rows = BG.getField @"heif_image_tiling_num_rows" x0
                            , heif_image_tiling_tile_width = BG.getField @"heif_image_tiling_tile_width" x0
                            , heif_image_tiling_tile_height = BG.getField @"heif_image_tiling_tile_height" x0
                            , heif_image_tiling_image_width = BG.getField @"heif_image_tiling_image_width" x0
                            , heif_image_tiling_image_height = BG.getField @"heif_image_tiling_image_height" x0
                            , heif_image_tiling_left_offset = BG.getField @"heif_image_tiling_left_offset" x0
                            , heif_image_tiling_number_of_extra_dimensions = BG.getField @"heif_image_tiling_number_of_extra_dimensions" x0
                            , heif_image_tiling_extra_dimension_size = BG.getField @"heif_image_tiling_extra_dimension_size" x0
                            }
      , BG.getField @"heif_image_tiling_top_offset" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_image_tiling_top_offset" (BG.Ptr Heif_image_tiling) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_image_tiling_top_offset")

instance HasCField.HasCField Heif_image_tiling "heif_image_tiling_top_offset" where

  type CFieldType Heif_image_tiling "heif_image_tiling_top_offset" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 28

{-| __C declaration:__ @left_offset@

    __defined at:__ @libheif\/heif_tiling.h 55:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_image_tiling_left_offset" Heif_image_tiling ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_image_tiling { heif_image_tiling_left_offset = y1
                            , heif_image_tiling_version = BG.getField @"heif_image_tiling_version" x0
                            , heif_image_tiling_num_columns = BG.getField @"heif_image_tiling_num_columns" x0
                            , heif_image_tiling_num_rows = BG.getField @"heif_image_tiling_num_rows" x0
                            , heif_image_tiling_tile_width = BG.getField @"heif_image_tiling_tile_width" x0
                            , heif_image_tiling_tile_height = BG.getField @"heif_image_tiling_tile_height" x0
                            , heif_image_tiling_image_width = BG.getField @"heif_image_tiling_image_width" x0
                            , heif_image_tiling_image_height = BG.getField @"heif_image_tiling_image_height" x0
                            , heif_image_tiling_top_offset = BG.getField @"heif_image_tiling_top_offset" x0
                            , heif_image_tiling_number_of_extra_dimensions = BG.getField @"heif_image_tiling_number_of_extra_dimensions" x0
                            , heif_image_tiling_extra_dimension_size = BG.getField @"heif_image_tiling_extra_dimension_size" x0
                            }
      , BG.getField @"heif_image_tiling_left_offset" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_image_tiling_left_offset" (BG.Ptr Heif_image_tiling) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_image_tiling_left_offset")

instance HasCField.HasCField Heif_image_tiling "heif_image_tiling_left_offset" where

  type CFieldType Heif_image_tiling "heif_image_tiling_left_offset" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 32

{-| __C declaration:__ @number_of_extra_dimensions@

    __defined at:__ @libheif\/heif_tiling.h 57:11@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "heif_image_tiling_number_of_extra_dimensions" Heif_image_tiling ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_image_tiling { heif_image_tiling_number_of_extra_dimensions = y1
                            , heif_image_tiling_version = BG.getField @"heif_image_tiling_version" x0
                            , heif_image_tiling_num_columns = BG.getField @"heif_image_tiling_num_columns" x0
                            , heif_image_tiling_num_rows = BG.getField @"heif_image_tiling_num_rows" x0
                            , heif_image_tiling_tile_width = BG.getField @"heif_image_tiling_tile_width" x0
                            , heif_image_tiling_tile_height = BG.getField @"heif_image_tiling_tile_height" x0
                            , heif_image_tiling_image_width = BG.getField @"heif_image_tiling_image_width" x0
                            , heif_image_tiling_image_height = BG.getField @"heif_image_tiling_image_height" x0
                            , heif_image_tiling_top_offset = BG.getField @"heif_image_tiling_top_offset" x0
                            , heif_image_tiling_left_offset = BG.getField @"heif_image_tiling_left_offset" x0
                            , heif_image_tiling_extra_dimension_size = BG.getField @"heif_image_tiling_extra_dimension_size" x0
                            }
      , BG.getField @"heif_image_tiling_number_of_extra_dimensions" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "heif_image_tiling_number_of_extra_dimensions" (BG.Ptr Heif_image_tiling) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_image_tiling_number_of_extra_dimensions")

instance HasCField.HasCField Heif_image_tiling "heif_image_tiling_number_of_extra_dimensions" where

  type CFieldType Heif_image_tiling "heif_image_tiling_number_of_extra_dimensions" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 36

{-| __C declaration:__ @extra_dimension_size@

    __defined at:__ @libheif\/heif_tiling.h 58:12@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ CA.ConstantArray 8 HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "heif_image_tiling_extra_dimension_size" Heif_image_tiling ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_image_tiling { heif_image_tiling_extra_dimension_size = y1
                            , heif_image_tiling_version = BG.getField @"heif_image_tiling_version" x0
                            , heif_image_tiling_num_columns = BG.getField @"heif_image_tiling_num_columns" x0
                            , heif_image_tiling_num_rows = BG.getField @"heif_image_tiling_num_rows" x0
                            , heif_image_tiling_tile_width = BG.getField @"heif_image_tiling_tile_width" x0
                            , heif_image_tiling_tile_height = BG.getField @"heif_image_tiling_tile_height" x0
                            , heif_image_tiling_image_width = BG.getField @"heif_image_tiling_image_width" x0
                            , heif_image_tiling_image_height = BG.getField @"heif_image_tiling_image_height" x0
                            , heif_image_tiling_top_offset = BG.getField @"heif_image_tiling_top_offset" x0
                            , heif_image_tiling_left_offset = BG.getField @"heif_image_tiling_left_offset" x0
                            , heif_image_tiling_number_of_extra_dimensions = BG.getField @"heif_image_tiling_number_of_extra_dimensions" x0
                            }
      , BG.getField @"heif_image_tiling_extra_dimension_size" x0
      )

instance ( ty ~ CA.ConstantArray 8 HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "heif_image_tiling_extra_dimension_size" (BG.Ptr Heif_image_tiling) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_image_tiling_extra_dimension_size")

instance HasCField.HasCField Heif_image_tiling "heif_image_tiling_extra_dimension_size" where

  type CFieldType Heif_image_tiling "heif_image_tiling_extra_dimension_size" =
    CA.ConstantArray 8 HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 40

{-| __C declaration:__ @enum heif_component_datatype@

    __defined at:__ @libheif\/heif_components.h 48:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_component_datatype = Heif_component_datatype
  { unwrapHeif_component_datatype :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_component_datatype where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_component_datatype where

  readRaw =
    \ptr0 ->
          pure Heif_component_datatype
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_component_datatype where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_component_datatype unwrapHeif_component_datatype2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_component_datatype2

deriving via Marshal.EquivStorable Heif_component_datatype instance BG.Storable Heif_component_datatype

deriving via BG.CUInt instance BG.Prim Heif_component_datatype

instance CEnum.CEnum Heif_component_datatype where

  type CEnumZ Heif_component_datatype = BG.CUInt

  toCEnum = Heif_component_datatype

  fromCEnum =
    BG.getField @"unwrapHeif_component_datatype"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_component_datatype_unsigned_integer")
                                   , (1, BG.singleton "Heif_component_datatype_floating_point")
                                   , (2, BG.singleton "Heif_component_datatype_complex_number")
                                   , (3, BG.singleton "Heif_component_datatype_signed_integer")
                                   , (255, BG.singleton "Heif_component_datatype_undefined")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_component_datatype"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_component_datatype"

instance Show Heif_component_datatype where

  showsPrec = CEnum.shows

instance Read Heif_component_datatype where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_component_datatype" Heif_component_datatype ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_component_datatype {unwrapHeif_component_datatype = y1}
      , BG.getField @"unwrapHeif_component_datatype" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_component_datatype" (BG.Ptr Heif_component_datatype) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_component_datatype")

instance HasCField.HasCField Heif_component_datatype "unwrapHeif_component_datatype" where

  type CFieldType Heif_component_datatype "unwrapHeif_component_datatype" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_component_datatype_unsigned_integer@

    __defined at:__ @libheif\/heif_components.h 50:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_component_datatype_unsigned_integer :: Heif_component_datatype
pattern Heif_component_datatype_unsigned_integer = Heif_component_datatype 0

{-| __C declaration:__ @heif_component_datatype_floating_point@

    __defined at:__ @libheif\/heif_components.h 51:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_component_datatype_floating_point :: Heif_component_datatype
pattern Heif_component_datatype_floating_point = Heif_component_datatype 1

{-| __C declaration:__ @heif_component_datatype_complex_number@

    __defined at:__ @libheif\/heif_components.h 52:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_component_datatype_complex_number :: Heif_component_datatype
pattern Heif_component_datatype_complex_number = Heif_component_datatype 2

{-| __C declaration:__ @heif_component_datatype_signed_integer@

    __defined at:__ @libheif\/heif_components.h 53:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_component_datatype_signed_integer :: Heif_component_datatype
pattern Heif_component_datatype_signed_integer = Heif_component_datatype 3

{-| __C declaration:__ @heif_component_datatype_undefined@

    __defined at:__ @libheif\/heif_components.h 54:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_component_datatype_undefined :: Heif_component_datatype
pattern Heif_component_datatype_undefined = Heif_component_datatype 255

{-| __C declaration:__ @struct heif_complex32@

    __defined at:__ @libheif\/heif_components.h 57:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_complex32 = Heif_complex32
  { heif_complex32_real :: BG.CFloat
    {- ^ __C declaration:__ @real@

         __defined at:__ @libheif\/heif_components.h 59:9@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_complex32_imaginary :: BG.CFloat
    {- ^ __C declaration:__ @imaginary@

         __defined at:__ @libheif\/heif_components.h 59:15@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_complex32 where

  staticSizeOf = \_ -> (8 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_complex32 where

  readRaw =
    \ptr0 ->
          pure Heif_complex32
      <*> HasCField.readRaw (BG.Proxy @"heif_complex32_real") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_complex32_imaginary") ptr0

instance Marshal.WriteRaw Heif_complex32 where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_complex32 heif_complex32_real2 heif_complex32_imaginary3 ->
               HasCField.writeRaw (BG.Proxy @"heif_complex32_real") ptr0 heif_complex32_real2
            >> HasCField.writeRaw (BG.Proxy @"heif_complex32_imaginary") ptr0 heif_complex32_imaginary3

deriving via Marshal.EquivStorable Heif_complex32 instance BG.Storable Heif_complex32

deriving via Struct.IsStructViaReadRaw Heif_complex32 instance Struct.IsStruct Heif_complex32

{-| __C declaration:__ @real@

    __defined at:__ @libheif\/heif_components.h 59:9@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CFloat
         ) => BG.CompatHasField.HasField "heif_complex32_real" Heif_complex32 ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_complex32 { heif_complex32_real = y1
                         , heif_complex32_imaginary = BG.getField @"heif_complex32_imaginary" x0
                         }
      , BG.getField @"heif_complex32_real" x0
      )

instance ( ty ~ BG.CFloat
         ) => BG.HasField "heif_complex32_real" (BG.Ptr Heif_complex32) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_complex32_real")

instance HasCField.HasCField Heif_complex32 "heif_complex32_real" where

  type CFieldType Heif_complex32 "heif_complex32_real" =
    BG.CFloat

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @imaginary@

    __defined at:__ @libheif\/heif_components.h 59:15@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CFloat
         ) => BG.CompatHasField.HasField "heif_complex32_imaginary" Heif_complex32 ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_complex32 { heif_complex32_imaginary = y1
                         , heif_complex32_real = BG.getField @"heif_complex32_real" x0
                         }
      , BG.getField @"heif_complex32_imaginary" x0
      )

instance ( ty ~ BG.CFloat
         ) => BG.HasField "heif_complex32_imaginary" (BG.Ptr Heif_complex32) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_complex32_imaginary")

instance HasCField.HasCField Heif_complex32 "heif_complex32_imaginary" where

  type CFieldType Heif_complex32 "heif_complex32_imaginary" =
    BG.CFloat

  offset# = \_ -> \_ -> 4

{-| __C declaration:__ @struct heif_complex64@

    __defined at:__ @libheif\/heif_components.h 62:16@

    __exported by:__ @libheif\/heif.h@
-}
data Heif_complex64 = Heif_complex64
  { heif_complex64_real :: BG.CDouble
    {- ^ __C declaration:__ @real@

         __defined at:__ @libheif\/heif_components.h 64:10@

         __exported by:__ @libheif\/heif.h@
    -}
  , heif_complex64_imaginary :: BG.CDouble
    {- ^ __C declaration:__ @imaginary@

         __defined at:__ @libheif\/heif_components.h 64:16@

         __exported by:__ @libheif\/heif.h@
    -}
  }
  deriving stock (Eq, BG.Generic, Show)

instance Marshal.StaticSize Heif_complex64 where

  staticSizeOf = \_ -> (16 :: Int)

  staticAlignment = \_ -> (8 :: Int)

instance Marshal.ReadRaw Heif_complex64 where

  readRaw =
    \ptr0 ->
          pure Heif_complex64
      <*> HasCField.readRaw (BG.Proxy @"heif_complex64_real") ptr0
      <*> HasCField.readRaw (BG.Proxy @"heif_complex64_imaginary") ptr0

instance Marshal.WriteRaw Heif_complex64 where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_complex64 heif_complex64_real2 heif_complex64_imaginary3 ->
               HasCField.writeRaw (BG.Proxy @"heif_complex64_real") ptr0 heif_complex64_real2
            >> HasCField.writeRaw (BG.Proxy @"heif_complex64_imaginary") ptr0 heif_complex64_imaginary3

deriving via Marshal.EquivStorable Heif_complex64 instance BG.Storable Heif_complex64

deriving via Struct.IsStructViaReadRaw Heif_complex64 instance Struct.IsStruct Heif_complex64

{-| __C declaration:__ @real@

    __defined at:__ @libheif\/heif_components.h 64:10@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CDouble
         ) => BG.CompatHasField.HasField "heif_complex64_real" Heif_complex64 ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_complex64 { heif_complex64_real = y1
                         , heif_complex64_imaginary = BG.getField @"heif_complex64_imaginary" x0
                         }
      , BG.getField @"heif_complex64_real" x0
      )

instance ( ty ~ BG.CDouble
         ) => BG.HasField "heif_complex64_real" (BG.Ptr Heif_complex64) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_complex64_real")

instance HasCField.HasCField Heif_complex64 "heif_complex64_real" where

  type CFieldType Heif_complex64 "heif_complex64_real" =
    BG.CDouble

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @imaginary@

    __defined at:__ @libheif\/heif_components.h 64:16@

    __exported by:__ @libheif\/heif.h@
-}
instance ( ty ~ BG.CDouble
         ) => BG.CompatHasField.HasField "heif_complex64_imaginary" Heif_complex64 ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_complex64 { heif_complex64_imaginary = y1
                         , heif_complex64_real = BG.getField @"heif_complex64_real" x0
                         }
      , BG.getField @"heif_complex64_imaginary" x0
      )

instance ( ty ~ BG.CDouble
         ) => BG.HasField "heif_complex64_imaginary" (BG.Ptr Heif_complex64) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"heif_complex64_imaginary")

instance HasCField.HasCField Heif_complex64 "heif_complex64_imaginary" where

  type CFieldType Heif_complex64 "heif_complex64_imaginary" =
    BG.CDouble

  offset# = \_ -> \_ -> 8

{-| __C declaration:__ @enum heif_cmpd_component_type@

    __defined at:__ @libheif\/heif_components.h 70:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_cmpd_component_type = Heif_cmpd_component_type
  { unwrapHeif_cmpd_component_type :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_cmpd_component_type where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_cmpd_component_type where

  readRaw =
    \ptr0 ->
          pure Heif_cmpd_component_type
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_cmpd_component_type where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_cmpd_component_type unwrapHeif_cmpd_component_type2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_cmpd_component_type2

deriving via Marshal.EquivStorable Heif_cmpd_component_type instance BG.Storable Heif_cmpd_component_type

deriving via BG.CUInt instance BG.Prim Heif_cmpd_component_type

instance CEnum.CEnum Heif_cmpd_component_type where

  type CEnumZ Heif_cmpd_component_type = BG.CUInt

  toCEnum = Heif_cmpd_component_type

  fromCEnum =
    BG.getField @"unwrapHeif_cmpd_component_type"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_cmpd_component_type_monochrome")
                                   , (1, BG.singleton "Heif_cmpd_component_type_Y")
                                   , (2, BG.singleton "Heif_cmpd_component_type_Cb")
                                   , (3, BG.singleton "Heif_cmpd_component_type_Cr")
                                   , (4, BG.singleton "Heif_cmpd_component_type_red")
                                   , (5, BG.singleton "Heif_cmpd_component_type_green")
                                   , (6, BG.singleton "Heif_cmpd_component_type_blue")
                                   , (7, BG.singleton "Heif_cmpd_component_type_alpha")
                                   , (8, BG.singleton "Heif_cmpd_component_type_depth")
                                   , (9, BG.singleton "Heif_cmpd_component_type_disparity")
                                   , (10, BG.singleton "Heif_cmpd_component_type_palette")
                                   , (11, BG.singleton "Heif_cmpd_component_type_filter_array")
                                   , (12, BG.singleton "Heif_cmpd_component_type_padded")
                                   , (13, BG.singleton "Heif_cmpd_component_type_cyan")
                                   , (14, BG.singleton "Heif_cmpd_component_type_magenta")
                                   , (15, BG.singleton "Heif_cmpd_component_type_yellow")
                                   , (16, BG.singleton "Heif_cmpd_component_type_key_black")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_cmpd_component_type"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_cmpd_component_type"

  isDeclared = CEnum.seqIsDeclared

  mkDeclared = CEnum.seqMkDeclared

instance CEnum.SequentialCEnum Heif_cmpd_component_type where

  minDeclaredValue =
    Heif_cmpd_component_type_monochrome

  maxDeclaredValue = Heif_cmpd_component_type_key_black

instance Show Heif_cmpd_component_type where

  showsPrec = CEnum.shows

instance Read Heif_cmpd_component_type where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_cmpd_component_type" Heif_cmpd_component_type ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_cmpd_component_type {unwrapHeif_cmpd_component_type = y1}
      , BG.getField @"unwrapHeif_cmpd_component_type" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_cmpd_component_type" (BG.Ptr Heif_cmpd_component_type) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_cmpd_component_type")

instance HasCField.HasCField Heif_cmpd_component_type "unwrapHeif_cmpd_component_type" where

  type CFieldType Heif_cmpd_component_type "unwrapHeif_cmpd_component_type" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_cmpd_component_type_monochrome@

    __defined at:__ @libheif\/heif_components.h 72:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_cmpd_component_type_monochrome :: Heif_cmpd_component_type
pattern Heif_cmpd_component_type_monochrome = Heif_cmpd_component_type 0

{-| __C declaration:__ @heif_cmpd_component_type_Y@

    __defined at:__ @libheif\/heif_components.h 73:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_cmpd_component_type_Y :: Heif_cmpd_component_type
pattern Heif_cmpd_component_type_Y = Heif_cmpd_component_type 1

{-| __C declaration:__ @heif_cmpd_component_type_Cb@

    __defined at:__ @libheif\/heif_components.h 74:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_cmpd_component_type_Cb :: Heif_cmpd_component_type
pattern Heif_cmpd_component_type_Cb = Heif_cmpd_component_type 2

{-| __C declaration:__ @heif_cmpd_component_type_Cr@

    __defined at:__ @libheif\/heif_components.h 75:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_cmpd_component_type_Cr :: Heif_cmpd_component_type
pattern Heif_cmpd_component_type_Cr = Heif_cmpd_component_type 3

{-| __C declaration:__ @heif_cmpd_component_type_red@

    __defined at:__ @libheif\/heif_components.h 76:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_cmpd_component_type_red :: Heif_cmpd_component_type
pattern Heif_cmpd_component_type_red = Heif_cmpd_component_type 4

{-| __C declaration:__ @heif_cmpd_component_type_green@

    __defined at:__ @libheif\/heif_components.h 77:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_cmpd_component_type_green :: Heif_cmpd_component_type
pattern Heif_cmpd_component_type_green = Heif_cmpd_component_type 5

{-| __C declaration:__ @heif_cmpd_component_type_blue@

    __defined at:__ @libheif\/heif_components.h 78:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_cmpd_component_type_blue :: Heif_cmpd_component_type
pattern Heif_cmpd_component_type_blue = Heif_cmpd_component_type 6

{-| __C declaration:__ @heif_cmpd_component_type_alpha@

    __defined at:__ @libheif\/heif_components.h 79:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_cmpd_component_type_alpha :: Heif_cmpd_component_type
pattern Heif_cmpd_component_type_alpha = Heif_cmpd_component_type 7

{-| __C declaration:__ @heif_cmpd_component_type_depth@

    __defined at:__ @libheif\/heif_components.h 80:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_cmpd_component_type_depth :: Heif_cmpd_component_type
pattern Heif_cmpd_component_type_depth = Heif_cmpd_component_type 8

{-| __C declaration:__ @heif_cmpd_component_type_disparity@

    __defined at:__ @libheif\/heif_components.h 81:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_cmpd_component_type_disparity :: Heif_cmpd_component_type
pattern Heif_cmpd_component_type_disparity = Heif_cmpd_component_type 9

{-| __C declaration:__ @heif_cmpd_component_type_palette@

    __defined at:__ @libheif\/heif_components.h 82:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_cmpd_component_type_palette :: Heif_cmpd_component_type
pattern Heif_cmpd_component_type_palette = Heif_cmpd_component_type 10

{-| __C declaration:__ @heif_cmpd_component_type_filter_array@

    __defined at:__ @libheif\/heif_components.h 83:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_cmpd_component_type_filter_array :: Heif_cmpd_component_type
pattern Heif_cmpd_component_type_filter_array = Heif_cmpd_component_type 11

{-| __C declaration:__ @heif_cmpd_component_type_padded@

    __defined at:__ @libheif\/heif_components.h 84:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_cmpd_component_type_padded :: Heif_cmpd_component_type
pattern Heif_cmpd_component_type_padded = Heif_cmpd_component_type 12

{-| __C declaration:__ @heif_cmpd_component_type_cyan@

    __defined at:__ @libheif\/heif_components.h 85:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_cmpd_component_type_cyan :: Heif_cmpd_component_type
pattern Heif_cmpd_component_type_cyan = Heif_cmpd_component_type 13

{-| __C declaration:__ @heif_cmpd_component_type_magenta@

    __defined at:__ @libheif\/heif_components.h 86:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_cmpd_component_type_magenta :: Heif_cmpd_component_type
pattern Heif_cmpd_component_type_magenta = Heif_cmpd_component_type 14

{-| __C declaration:__ @heif_cmpd_component_type_yellow@

    __defined at:__ @libheif\/heif_components.h 87:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_cmpd_component_type_yellow :: Heif_cmpd_component_type
pattern Heif_cmpd_component_type_yellow = Heif_cmpd_component_type 15

{-| __C declaration:__ @heif_cmpd_component_type_key_black@

    __defined at:__ @libheif\/heif_components.h 88:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_cmpd_component_type_key_black :: Heif_cmpd_component_type
pattern Heif_cmpd_component_type_key_black = Heif_cmpd_component_type 16

{-| __C declaration:__ @enum heif_omaf_image_projection@

    __defined at:__ @libheif\/heif_omaf.h 49:14@

    __exported by:__ @libheif\/heif.h@
-}
newtype Heif_omaf_image_projection = Heif_omaf_image_projection
  { unwrapHeif_omaf_image_projection :: BG.CUInt
  }
  deriving stock (Eq, BG.Generic, Ord)
  deriving newtype (BG.HasFFIType)

instance Marshal.StaticSize Heif_omaf_image_projection where

  staticSizeOf = \_ -> (4 :: Int)

  staticAlignment = \_ -> (4 :: Int)

instance Marshal.ReadRaw Heif_omaf_image_projection where

  readRaw =
    \ptr0 ->
          pure Heif_omaf_image_projection
      <*> Marshal.readRawByteOff ptr0 (0 :: Int)

instance Marshal.WriteRaw Heif_omaf_image_projection where

  writeRaw =
    \ptr0 ->
      \s1 ->
        case s1 of
          Heif_omaf_image_projection unwrapHeif_omaf_image_projection2 ->
            Marshal.writeRawByteOff ptr0 (0 :: Int) unwrapHeif_omaf_image_projection2

deriving via Marshal.EquivStorable Heif_omaf_image_projection instance BG.Storable Heif_omaf_image_projection

deriving via BG.CUInt instance BG.Prim Heif_omaf_image_projection

instance CEnum.CEnum Heif_omaf_image_projection where

  type CEnumZ Heif_omaf_image_projection = BG.CUInt

  toCEnum = Heif_omaf_image_projection

  fromCEnum =
    BG.getField @"unwrapHeif_omaf_image_projection"

  declaredValues =
    \_ ->
      CEnum.declaredValuesFromList [ (0, BG.singleton "Heif_omaf_image_projection_equirectangular")
                                   , (1, BG.singleton "Heif_omaf_image_projection_cube_map")
                                   , (255, BG.singleton "Heif_omaf_image_projection_flat")
                                   ]

  showsUndeclared =
    CEnum.showsWrappedUndeclared "Heif_omaf_image_projection"

  readPrecUndeclared =
    CEnum.readPrecWrappedUndeclared "Heif_omaf_image_projection"

instance Show Heif_omaf_image_projection where

  showsPrec = CEnum.shows

instance Read Heif_omaf_image_projection where

  readPrec = CEnum.readPrec

  readList = BG.readListDefault

  readListPrec = BG.readListPrecDefault

instance ( ty ~ BG.CUInt
         ) => BG.CompatHasField.HasField "unwrapHeif_omaf_image_projection" Heif_omaf_image_projection ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Heif_omaf_image_projection {unwrapHeif_omaf_image_projection = y1}
      , BG.getField @"unwrapHeif_omaf_image_projection" x0
      )

instance ( ty ~ BG.CUInt
         ) => BG.HasField "unwrapHeif_omaf_image_projection" (BG.Ptr Heif_omaf_image_projection) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapHeif_omaf_image_projection")

instance HasCField.HasCField Heif_omaf_image_projection "unwrapHeif_omaf_image_projection" where

  type CFieldType Heif_omaf_image_projection "unwrapHeif_omaf_image_projection" =
    BG.CUInt

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @heif_omaf_image_projection_equirectangular@

    __defined at:__ @libheif\/heif_omaf.h 54:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_omaf_image_projection_equirectangular :: Heif_omaf_image_projection
pattern Heif_omaf_image_projection_equirectangular = Heif_omaf_image_projection 0

{-| __C declaration:__ @heif_omaf_image_projection_cube_map@

    __defined at:__ @libheif\/heif_omaf.h 59:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_omaf_image_projection_cube_map :: Heif_omaf_image_projection
pattern Heif_omaf_image_projection_cube_map = Heif_omaf_image_projection 1

{-| __C declaration:__ @heif_omaf_image_projection_flat@

    __defined at:__ @libheif\/heif_omaf.h 75:3@

    __exported by:__ @libheif\/heif.h@
-}
pattern Heif_omaf_image_projection_flat :: Heif_omaf_image_projection
pattern Heif_omaf_image_projection_flat = Heif_omaf_image_projection 255

-- __unique:__ @instance ToFunPtr (HsBindgen.Runtime.LibC.Int64 -> BG.Ptr BG.Void -> IO Heif_reader_grow_status)@
foreign import ccall safe "wrapper" hs_bindgen_3afa1efa37aa74cc_base ::
     (BG.Int64 -> BG.Ptr BG.Void -> IO BG.Word32)
  -> IO (BG.FunPtr (BG.Int64 -> BG.Ptr BG.Void -> IO BG.Word32))

-- __unique:__ @instance ToFunPtr (HsBindgen.Runtime.LibC.Int64 -> BG.Ptr BG.Void -> IO Heif_reader_grow_status)@
hs_bindgen_3afa1efa37aa74cc ::
     (HsBindgen.Runtime.LibC.Int64 -> BG.Ptr BG.Void -> IO Heif_reader_grow_status)
  -> IO (BG.FunPtr (HsBindgen.Runtime.LibC.Int64 -> BG.Ptr BG.Void -> IO Heif_reader_grow_status))
hs_bindgen_3afa1efa37aa74cc =
  \fun0 ->
    fmap BG.castFunPtrFromFFIType (hs_bindgen_3afa1efa37aa74cc_base (BG.toFFIType fun0))

-- __unique:__ @instance FromFunPtr (HsBindgen.Runtime.LibC.Int64 -> BG.Ptr BG.Void -> IO Heif_reader_grow_status)@
foreign import ccall safe "dynamic" hs_bindgen_1b1da37f50011c80_base ::
     BG.FunPtr (BG.Int64 -> BG.Ptr BG.Void -> IO BG.Word32)
  -> BG.Int64 -> BG.Ptr BG.Void -> IO BG.Word32

-- __unique:__ @instance FromFunPtr (HsBindgen.Runtime.LibC.Int64 -> BG.Ptr BG.Void -> IO Heif_reader_grow_status)@
hs_bindgen_1b1da37f50011c80 ::
     BG.FunPtr (HsBindgen.Runtime.LibC.Int64 -> BG.Ptr BG.Void -> IO Heif_reader_grow_status)
  -> HsBindgen.Runtime.LibC.Int64 -> BG.Ptr BG.Void -> IO Heif_reader_grow_status
hs_bindgen_1b1da37f50011c80 =
  \funPtr0 ->
    BG.fromFFIType (hs_bindgen_1b1da37f50011c80_base (BG.castFunPtrToFFIType funPtr0))

instance BG.ToFunPtr (HsBindgen.Runtime.LibC.Int64 -> BG.Ptr BG.Void -> IO Heif_reader_grow_status) where

  toFunPtr = hs_bindgen_3afa1efa37aa74cc

instance BG.FromFunPtr (HsBindgen.Runtime.LibC.Int64 -> BG.Ptr BG.Void -> IO Heif_reader_grow_status) where

  fromFunPtr = hs_bindgen_1b1da37f50011c80