Source file wayland_proto.ml

(* This file was generated automatically by wayland-scanner-ocaml *)

module Wl_display = struct
  type t = [`Wl_display]
  type _ Metadata.ty += T : [`Wl_display] Metadata.ty
  type versions = [`V1]
  let interface = "wl_display"
  let version = 1l
  
  (** Global error values.
      
      These errors are global and can be emitted in response to any
      server request. *)
  module Error = struct
    type t =
      | Invalid_object : t
      | Invalid_method : t
      | No_memory : t
      | Implementation : t
    
    let to_int32 = function
      | Invalid_object -> 0l
      | Invalid_method -> 1l
      | No_memory -> 2l
      | Implementation -> 3l
    
    let of_int32 = function
      | 0l -> Invalid_object
      | 1l -> Invalid_method
      | 2l -> No_memory
      | 3l -> Implementation
      | x -> Fmt.failwith "Invalid error enum value %ld" x
  end
  
  let requests = function
    | 0 -> "sync", ["callback", `New_ID (Some "wl_callback")]
    | 1 -> "get_registry", ["registry", `New_ID (Some "wl_registry")]
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | 0 -> "error", ["object_id", `Object (None); "code", `Uint; "message", `String]
    | 1 -> "delete_id", ["id", `Uint]
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_display)

module Wl_registry = struct
  type t = [`Wl_registry]
  type _ Metadata.ty += T : [`Wl_registry] Metadata.ty
  type versions = [`V1]
  let interface = "wl_registry"
  let version = 1l
  
  let requests = function
    | 0 -> "bind", ["name", `Uint; "id", `New_ID (None)]
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | 0 -> "global", ["name", `Uint; "interface", `String; "version", `Uint]
    | 1 -> "global_remove", ["name", `Uint]
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_registry)

module Wl_callback = struct
  type t = [`Wl_callback]
  type _ Metadata.ty += T : [`Wl_callback] Metadata.ty
  type versions = [`V1]
  let interface = "wl_callback"
  let version = 1l
  
  let requests = function
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | 0 -> "done", ["callback_data", `Uint]
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_callback)

module Wl_compositor = struct
  type t = [`Wl_compositor]
  type _ Metadata.ty += T : [`Wl_compositor] Metadata.ty
  type versions = [`V1 | `V2 | `V3 | `V4 | `V5 | `V6]
  let interface = "wl_compositor"
  let version = 6l
  
  let requests = function
    | 0 -> "create_surface", ["id", `New_ID (Some "wl_surface")]
    | 1 -> "create_region", ["id", `New_ID (Some "wl_region")]
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_compositor)

module Wl_shm_pool = struct
  type t = [`Wl_shm_pool]
  type _ Metadata.ty += T : [`Wl_shm_pool] Metadata.ty
  type versions = [`V1 | `V2]
  let interface = "wl_shm_pool"
  let version = 2l
  
  let requests = function
    | 0 -> "create_buffer", ["id", `New_ID (Some "wl_buffer"); "offset", `Int; "width", `Int; "height", `Int;
                             "stride", `Int; "format", `Uint]
    | 1 -> "destroy", []
    | 2 -> "resize", ["size", `Int]
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_shm_pool)

module Wl_shm = struct
  type t = [`Wl_shm]
  type _ Metadata.ty += T : [`Wl_shm] Metadata.ty
  type versions = [`V1 | `V2]
  let interface = "wl_shm"
  let version = 2l
  
  (** Wl_shm error values.
      
      These errors can be emitted in response to wl_shm requests. *)
  module Error = struct
    type t =
      | Invalid_format : t
      | Invalid_stride : t
      | Invalid_fd : t
    
    let to_int32 = function
      | Invalid_format -> 0l
      | Invalid_stride -> 1l
      | Invalid_fd -> 2l
    
    let of_int32 = function
      | 0l -> Invalid_format
      | 1l -> Invalid_stride
      | 2l -> Invalid_fd
      | x -> Fmt.failwith "Invalid error enum value %ld" x
  end
  
  
  (** Pixel formats.
      
      This describes the memory layout of an individual pixel.
      
      All renderers should support argb8888 and xrgb8888 but any other
      formats are optional and may not be supported by the particular
      renderer in use.
      
      The drm format codes match the macros defined in drm_fourcc.h, except
      argb8888 and xrgb8888. The formats actually supported by the compositor
      will be reported by the format event.
      
      For all wl_shm formats and unless specified in another protocol
      extension, pre-multiplied alpha is used for pixel values. *)
  module Format = struct
    type t =
      | Argb8888 : t
      | Xrgb8888 : t
      | C8 : t
      | Rgb332 : t
      | Bgr233 : t
      | Xrgb4444 : t
      | Xbgr4444 : t
      | Rgbx4444 : t
      | Bgrx4444 : t
      | Argb4444 : t
      | Abgr4444 : t
      | Rgba4444 : t
      | Bgra4444 : t
      | Xrgb1555 : t
      | Xbgr1555 : t
      | Rgbx5551 : t
      | Bgrx5551 : t
      | Argb1555 : t
      | Abgr1555 : t
      | Rgba5551 : t
      | Bgra5551 : t
      | Rgb565 : t
      | Bgr565 : t
      | Rgb888 : t
      | Bgr888 : t
      | Xbgr8888 : t
      | Rgbx8888 : t
      | Bgrx8888 : t
      | Abgr8888 : t
      | Rgba8888 : t
      | Bgra8888 : t
      | Xrgb2101010 : t
      | Xbgr2101010 : t
      | Rgbx1010102 : t
      | Bgrx1010102 : t
      | Argb2101010 : t
      | Abgr2101010 : t
      | Rgba1010102 : t
      | Bgra1010102 : t
      | Yuyv : t
      | Yvyu : t
      | Uyvy : t
      | Vyuy : t
      | Ayuv : t
      | Nv12 : t
      | Nv21 : t
      | Nv16 : t
      | Nv61 : t
      | Yuv410 : t
      | Yvu410 : t
      | Yuv411 : t
      | Yvu411 : t
      | Yuv420 : t
      | Yvu420 : t
      | Yuv422 : t
      | Yvu422 : t
      | Yuv444 : t
      | Yvu444 : t
      | R8 : t
      | R16 : t
      | Rg88 : t
      | Gr88 : t
      | Rg1616 : t
      | Gr1616 : t
      | Xrgb16161616f : t
      | Xbgr16161616f : t
      | Argb16161616f : t
      | Abgr16161616f : t
      | Xyuv8888 : t
      | Vuy888 : t
      | Vuy101010 : t
      | Y210 : t
      | Y212 : t
      | Y216 : t
      | Y410 : t
      | Y412 : t
      | Y416 : t
      | Xvyu2101010 : t
      | Xvyu12_16161616 : t
      | Xvyu16161616 : t
      | Y0l0 : t
      | X0l0 : t
      | Y0l2 : t
      | X0l2 : t
      | Yuv420_8bit : t
      | Yuv420_10bit : t
      | Xrgb8888_a8 : t
      | Xbgr8888_a8 : t
      | Rgbx8888_a8 : t
      | Bgrx8888_a8 : t
      | Rgb888_a8 : t
      | Bgr888_a8 : t
      | Rgb565_a8 : t
      | Bgr565_a8 : t
      | Nv24 : t
      | Nv42 : t
      | P210 : t
      | P010 : t
      | P012 : t
      | P016 : t
      | Axbxgxrx106106106106 : t
      | Nv15 : t
      | Q410 : t
      | Q401 : t
      | Xrgb16161616 : t
      | Xbgr16161616 : t
      | Argb16161616 : t
      | Abgr16161616 : t
      | C1 : t
      | C2 : t
      | C4 : t
      | D1 : t
      | D2 : t
      | D4 : t
      | D8 : t
      | R1 : t
      | R2 : t
      | R4 : t
      | R10 : t
      | R12 : t
      | Avuy8888 : t
      | Xvuy8888 : t
      | P030 : t
    
    let to_int32 = function
      | Argb8888 -> 0l
      | Xrgb8888 -> 1l
      | C8 -> 538982467l
      | Rgb332 -> 943867730l
      | Bgr233 -> 944916290l
      | Xrgb4444 -> 842093144l
      | Xbgr4444 -> 842089048l
      | Rgbx4444 -> 842094674l
      | Bgrx4444 -> 842094658l
      | Argb4444 -> 842093121l
      | Abgr4444 -> 842089025l
      | Rgba4444 -> 842088786l
      | Bgra4444 -> 842088770l
      | Xrgb1555 -> 892424792l
      | Xbgr1555 -> 892420696l
      | Rgbx5551 -> 892426322l
      | Bgrx5551 -> 892426306l
      | Argb1555 -> 892424769l
      | Abgr1555 -> 892420673l
      | Rgba5551 -> 892420434l
      | Bgra5551 -> 892420418l
      | Rgb565 -> 909199186l
      | Bgr565 -> 909199170l
      | Rgb888 -> 875710290l
      | Bgr888 -> 875710274l
      | Xbgr8888 -> 875709016l
      | Rgbx8888 -> 875714642l
      | Bgrx8888 -> 875714626l
      | Abgr8888 -> 875708993l
      | Rgba8888 -> 875708754l
      | Bgra8888 -> 875708738l
      | Xrgb2101010 -> 808669784l
      | Xbgr2101010 -> 808665688l
      | Rgbx1010102 -> 808671314l
      | Bgrx1010102 -> 808671298l
      | Argb2101010 -> 808669761l
      | Abgr2101010 -> 808665665l
      | Rgba1010102 -> 808665426l
      | Bgra1010102 -> 808665410l
      | Yuyv -> 1448695129l
      | Yvyu -> 1431918169l
      | Uyvy -> 1498831189l
      | Vyuy -> 1498765654l
      | Ayuv -> 1448433985l
      | Nv12 -> 842094158l
      | Nv21 -> 825382478l
      | Nv16 -> 909203022l
      | Nv61 -> 825644622l
      | Yuv410 -> 961959257l
      | Yvu410 -> 961893977l
      | Yuv411 -> 825316697l
      | Yvu411 -> 825316953l
      | Yuv420 -> 842093913l
      | Yvu420 -> 842094169l
      | Yuv422 -> 909202777l
      | Yvu422 -> 909203033l
      | Yuv444 -> 875713881l
      | Yvu444 -> 875714137l
      | R8 -> 538982482l
      | R16 -> 540422482l
      | Rg88 -> 943212370l
      | Gr88 -> 943215175l
      | Rg1616 -> 842221394l
      | Gr1616 -> 842224199l
      | Xrgb16161616f -> 1211388504l
      | Xbgr16161616f -> 1211384408l
      | Argb16161616f -> 1211388481l
      | Abgr16161616f -> 1211384385l
      | Xyuv8888 -> 1448434008l
      | Vuy888 -> 875713878l
      | Vuy101010 -> 808670550l
      | Y210 -> 808530521l
      | Y212 -> 842084953l
      | Y216 -> 909193817l
      | Y410 -> 808531033l
      | Y412 -> 842085465l
      | Y416 -> 909194329l
      | Xvyu2101010 -> 808670808l
      | Xvyu12_16161616 -> 909334104l
      | Xvyu16161616 -> 942954072l
      | Y0l0 -> 810299481l
      | X0l0 -> 810299480l
      | Y0l2 -> 843853913l
      | X0l2 -> 843853912l
      | Yuv420_8bit -> 942691673l
      | Yuv420_10bit -> 808539481l
      | Xrgb8888_a8 -> 943805016l
      | Xbgr8888_a8 -> 943800920l
      | Rgbx8888_a8 -> 943806546l
      | Bgrx8888_a8 -> 943806530l
      | Rgb888_a8 -> 943798354l
      | Bgr888_a8 -> 943798338l
      | Rgb565_a8 -> 943797586l
      | Bgr565_a8 -> 943797570l
      | Nv24 -> 875714126l
      | Nv42 -> 842290766l
      | P210 -> 808530512l
      | P010 -> 808530000l
      | P012 -> 842084432l
      | P016 -> 909193296l
      | Axbxgxrx106106106106 -> 808534593l
      | Nv15 -> 892425806l
      | Q410 -> 808531025l
      | Q401 -> 825242705l
      | Xrgb16161616 -> 942953048l
      | Xbgr16161616 -> 942948952l
      | Argb16161616 -> 942953025l
      | Abgr16161616 -> 942948929l
      | C1 -> 538980675l
      | C2 -> 538980931l
      | C4 -> 538981443l
      | D1 -> 538980676l
      | D2 -> 538980932l
      | D4 -> 538981444l
      | D8 -> 538982468l
      | R1 -> 538980690l
      | R2 -> 538980946l
      | R4 -> 538981458l
      | R10 -> 540029266l
      | R12 -> 540160338l
      | Avuy8888 -> 1498764865l
      | Xvuy8888 -> 1498764888l
      | P030 -> 808661072l
    
    let of_int32 = function
      | 0l -> Argb8888
      | 1l -> Xrgb8888
      | 538982467l -> C8
      | 943867730l -> Rgb332
      | 944916290l -> Bgr233
      | 842093144l -> Xrgb4444
      | 842089048l -> Xbgr4444
      | 842094674l -> Rgbx4444
      | 842094658l -> Bgrx4444
      | 842093121l -> Argb4444
      | 842089025l -> Abgr4444
      | 842088786l -> Rgba4444
      | 842088770l -> Bgra4444
      | 892424792l -> Xrgb1555
      | 892420696l -> Xbgr1555
      | 892426322l -> Rgbx5551
      | 892426306l -> Bgrx5551
      | 892424769l -> Argb1555
      | 892420673l -> Abgr1555
      | 892420434l -> Rgba5551
      | 892420418l -> Bgra5551
      | 909199186l -> Rgb565
      | 909199170l -> Bgr565
      | 875710290l -> Rgb888
      | 875710274l -> Bgr888
      | 875709016l -> Xbgr8888
      | 875714642l -> Rgbx8888
      | 875714626l -> Bgrx8888
      | 875708993l -> Abgr8888
      | 875708754l -> Rgba8888
      | 875708738l -> Bgra8888
      | 808669784l -> Xrgb2101010
      | 808665688l -> Xbgr2101010
      | 808671314l -> Rgbx1010102
      | 808671298l -> Bgrx1010102
      | 808669761l -> Argb2101010
      | 808665665l -> Abgr2101010
      | 808665426l -> Rgba1010102
      | 808665410l -> Bgra1010102
      | 1448695129l -> Yuyv
      | 1431918169l -> Yvyu
      | 1498831189l -> Uyvy
      | 1498765654l -> Vyuy
      | 1448433985l -> Ayuv
      | 842094158l -> Nv12
      | 825382478l -> Nv21
      | 909203022l -> Nv16
      | 825644622l -> Nv61
      | 961959257l -> Yuv410
      | 961893977l -> Yvu410
      | 825316697l -> Yuv411
      | 825316953l -> Yvu411
      | 842093913l -> Yuv420
      | 842094169l -> Yvu420
      | 909202777l -> Yuv422
      | 909203033l -> Yvu422
      | 875713881l -> Yuv444
      | 875714137l -> Yvu444
      | 538982482l -> R8
      | 540422482l -> R16
      | 943212370l -> Rg88
      | 943215175l -> Gr88
      | 842221394l -> Rg1616
      | 842224199l -> Gr1616
      | 1211388504l -> Xrgb16161616f
      | 1211384408l -> Xbgr16161616f
      | 1211388481l -> Argb16161616f
      | 1211384385l -> Abgr16161616f
      | 1448434008l -> Xyuv8888
      | 875713878l -> Vuy888
      | 808670550l -> Vuy101010
      | 808530521l -> Y210
      | 842084953l -> Y212
      | 909193817l -> Y216
      | 808531033l -> Y410
      | 842085465l -> Y412
      | 909194329l -> Y416
      | 808670808l -> Xvyu2101010
      | 909334104l -> Xvyu12_16161616
      | 942954072l -> Xvyu16161616
      | 810299481l -> Y0l0
      | 810299480l -> X0l0
      | 843853913l -> Y0l2
      | 843853912l -> X0l2
      | 942691673l -> Yuv420_8bit
      | 808539481l -> Yuv420_10bit
      | 943805016l -> Xrgb8888_a8
      | 943800920l -> Xbgr8888_a8
      | 943806546l -> Rgbx8888_a8
      | 943806530l -> Bgrx8888_a8
      | 943798354l -> Rgb888_a8
      | 943798338l -> Bgr888_a8
      | 943797586l -> Rgb565_a8
      | 943797570l -> Bgr565_a8
      | 875714126l -> Nv24
      | 842290766l -> Nv42
      | 808530512l -> P210
      | 808530000l -> P010
      | 842084432l -> P012
      | 909193296l -> P016
      | 808534593l -> Axbxgxrx106106106106
      | 892425806l -> Nv15
      | 808531025l -> Q410
      | 825242705l -> Q401
      | 942953048l -> Xrgb16161616
      | 942948952l -> Xbgr16161616
      | 942953025l -> Argb16161616
      | 942948929l -> Abgr16161616
      | 538980675l -> C1
      | 538980931l -> C2
      | 538981443l -> C4
      | 538980676l -> D1
      | 538980932l -> D2
      | 538981444l -> D4
      | 538982468l -> D8
      | 538980690l -> R1
      | 538980946l -> R2
      | 538981458l -> R4
      | 540029266l -> R10
      | 540160338l -> R12
      | 1498764865l -> Avuy8888
      | 1498764888l -> Xvuy8888
      | 808661072l -> P030
      | x -> Fmt.failwith "Invalid format enum value %ld" x
  end
  
  let requests = function
    | 0 -> "create_pool", ["id", `New_ID (Some "wl_shm_pool"); "fd", `FD; "size", `Int]
    | 1 -> "release", []
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | 0 -> "format", ["format", `Uint]
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_shm)

module Wl_buffer = struct
  type t = [`Wl_buffer]
  type _ Metadata.ty += T : [`Wl_buffer] Metadata.ty
  type versions = [`V1]
  let interface = "wl_buffer"
  let version = 1l
  
  let requests = function
    | 0 -> "destroy", []
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | 0 -> "release", []
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_buffer)

module Wl_data_offer = struct
  type t = [`Wl_data_offer]
  type _ Metadata.ty += T : [`Wl_data_offer] Metadata.ty
  type versions = [`V1 | `V2 | `V3]
  let interface = "wl_data_offer"
  let version = 3l
  
  module Error = struct
    type t =
      | Invalid_finish : t
      | Invalid_action_mask : t
      | Invalid_action : t
      | Invalid_offer : t
    
    let to_int32 = function
      | Invalid_finish -> 0l
      | Invalid_action_mask -> 1l
      | Invalid_action -> 2l
      | Invalid_offer -> 3l
    
    let of_int32 = function
      | 0l -> Invalid_finish
      | 1l -> Invalid_action_mask
      | 2l -> Invalid_action
      | 3l -> Invalid_offer
      | x -> Fmt.failwith "Invalid error enum value %ld" x
  end
  
  let requests = function
    | 0 -> "accept", ["serial", `Uint; "mime_type", `String]
    | 1 -> "receive", ["mime_type", `String; "fd", `FD]
    | 2 -> "destroy", []
    | 3 -> "finish", []
    | 4 -> "set_actions", ["dnd_actions", `Uint; "preferred_action", `Uint]
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | 0 -> "offer", ["mime_type", `String]
    | 1 -> "source_actions", ["source_actions", `Uint]
    | 2 -> "action", ["dnd_action", `Uint]
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_data_offer)

module Wl_data_source = struct
  type t = [`Wl_data_source]
  type _ Metadata.ty += T : [`Wl_data_source] Metadata.ty
  type versions = [`V1 | `V2 | `V3]
  let interface = "wl_data_source"
  let version = 3l
  
  module Error = struct
    type t =
      | Invalid_action_mask : t
      | Invalid_source : t
    
    let to_int32 = function
      | Invalid_action_mask -> 0l
      | Invalid_source -> 1l
    
    let of_int32 = function
      | 0l -> Invalid_action_mask
      | 1l -> Invalid_source
      | x -> Fmt.failwith "Invalid error enum value %ld" x
  end
  
  let requests = function
    | 0 -> "offer", ["mime_type", `String]
    | 1 -> "destroy", []
    | 2 -> "set_actions", ["dnd_actions", `Uint]
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | 0 -> "target", ["mime_type", `String]
    | 1 -> "send", ["mime_type", `String; "fd", `FD]
    | 2 -> "cancelled", []
    | 3 -> "dnd_drop_performed", []
    | 4 -> "dnd_finished", []
    | 5 -> "action", ["dnd_action", `Uint]
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_data_source)

module Wl_data_device = struct
  type t = [`Wl_data_device]
  type _ Metadata.ty += T : [`Wl_data_device] Metadata.ty
  type versions = [`V1 | `V2 | `V3]
  let interface = "wl_data_device"
  let version = 3l
  
  module Error = struct
    type t =
      | Role : t
      | Used_source : t
    
    let to_int32 = function
      | Role -> 0l
      | Used_source -> 1l
    
    let of_int32 = function
      | 0l -> Role
      | 1l -> Used_source
      | x -> Fmt.failwith "Invalid error enum value %ld" x
  end
  
  let requests = function
    | 0 -> "start_drag", ["source", `Object (Some "wl_data_source"); "origin", `Object (Some "wl_surface");
                          "icon", `Object (Some "wl_surface"); "serial", `Uint]
    | 1 -> "set_selection", ["source", `Object (Some "wl_data_source"); "serial", `Uint]
    | 2 -> "release", []
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | 0 -> "data_offer", ["id", `New_ID (Some "wl_data_offer")]
    | 1 -> "enter", ["serial", `Uint; "surface", `Object (Some "wl_surface"); "x", `Fixed; "y", `Fixed;
                     "id", `Object (Some "wl_data_offer")]
    | 2 -> "leave", []
    | 3 -> "motion", ["time", `Uint; "x", `Fixed; "y", `Fixed]
    | 4 -> "drop", []
    | 5 -> "selection", ["id", `Object (Some "wl_data_offer")]
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_data_device)

module Wl_data_device_manager = struct
  type t = [`Wl_data_device_manager]
  type _ Metadata.ty += T : [`Wl_data_device_manager] Metadata.ty
  type versions = [`V1 | `V2 | `V3]
  let interface = "wl_data_device_manager"
  let version = 3l
  
  (** Drag and drop actions.
      
      This is a bitmask of the available/preferred actions in a
      drag-and-drop operation.
      
      In the compositor, the selected action is a result of matching the
      actions offered by the source and destination sides.  "action" events
      with a "none" action will be sent to both source and destination if
      there is no match. All further checks will effectively happen on
      (source actions ∩ destination actions).
      
      In addition, compositors may also pick different actions in
      reaction to key modifiers being pressed. One common design that
      is used in major toolkits (and the behavior recommended for
      compositors) is:
      
      - If no modifiers are pressed, the first match (in bit order)
      will be used.
      - Pressing Shift selects "move", if enabled in the mask.
      - Pressing Control selects "copy", if enabled in the mask.
      
      Behavior beyond that is considered implementation-dependent.
      Compositors may for example bind other modifiers (like Alt/Meta)
      or drags initiated with other buttons than BTN_LEFT to specific
      actions (e.g. "ask"). *)
  module Dnd_action = struct
    type t = int32
    
    let none = 0l
    
    let copy = 1l
    
    let move = 2l
    
    let ask = 4l
    
    let to_int32 = Fun.id
    let of_int32 = Fun.id
  end
  
  let requests = function
    | 0 -> "create_data_source", ["id", `New_ID (Some "wl_data_source")]
    | 1 -> "get_data_device", ["id", `New_ID (Some "wl_data_device"); "seat", `Object (Some "wl_seat")]
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_data_device_manager)

module Wl_shell = struct
  type t = [`Wl_shell]
  type _ Metadata.ty += T : [`Wl_shell] Metadata.ty
  type versions = [`V1]
  let interface = "wl_shell"
  let version = 1l
  
  module Error = struct
    type t =
      | Role : t
    
    let to_int32 = function
      | Role -> 0l
    
    let of_int32 = function
      | 0l -> Role
      | x -> Fmt.failwith "Invalid error enum value %ld" x
  end
  
  let requests = function
    | 0 -> "get_shell_surface", ["id", `New_ID (Some "wl_shell_surface"); "surface", `Object (Some "wl_surface")]
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_shell)

module Wl_shell_surface = struct
  type t = [`Wl_shell_surface]
  type _ Metadata.ty += T : [`Wl_shell_surface] Metadata.ty
  type versions = [`V1]
  let interface = "wl_shell_surface"
  let version = 1l
  
  (** Edge values for resizing.
      
      These values are used to indicate which edge of a surface
      is being dragged in a resize operation. The server may
      use this information to adapt its behavior, e.g. choose
      an appropriate cursor image. *)
  module Resize = struct
    type t = int32
    
    let none = 0l
    
    let top = 1l
    
    let bottom = 2l
    
    let left = 4l
    
    let top_left = 5l
    
    let bottom_left = 6l
    
    let right = 8l
    
    let top_right = 9l
    
    let bottom_right = 10l
    
    let to_int32 = Fun.id
    let of_int32 = Fun.id
  end
  
  
  (** Details of transient behaviour.
      
      These flags specify details of the expected behaviour
      of transient surfaces. Used in the set_transient request. *)
  module Transient = struct
    type t = int32
    
    let inactive = 1l
    
    let to_int32 = Fun.id
    let of_int32 = Fun.id
  end
  
  
  (** Different method to set the surface fullscreen.
      
      Hints to indicate to the compositor how to deal with a conflict
      between the dimensions of the surface and the dimensions of the
      output. The compositor is free to ignore this parameter. *)
  module Fullscreen_method = struct
    type t =
      | Default : t
      | Scale : t
      | Driver : t
      | Fill : t
    
    let to_int32 = function
      | Default -> 0l
      | Scale -> 1l
      | Driver -> 2l
      | Fill -> 3l
    
    let of_int32 = function
      | 0l -> Default
      | 1l -> Scale
      | 2l -> Driver
      | 3l -> Fill
      | x -> Fmt.failwith "Invalid fullscreen_method enum value %ld" x
  end
  
  let requests = function
    | 0 -> "pong", ["serial", `Uint]
    | 1 -> "move", ["seat", `Object (Some "wl_seat"); "serial", `Uint]
    | 2 -> "resize", ["seat", `Object (Some "wl_seat"); "serial", `Uint; "edges", `Uint]
    | 3 -> "set_toplevel", []
    | 4 -> "set_transient", ["parent", `Object (Some "wl_surface"); "x", `Int; "y", `Int; "flags", `Uint]
    | 5 -> "set_fullscreen", ["method", `Uint; "framerate", `Uint; "output", `Object (Some "wl_output")]
    | 6 -> "set_popup", ["seat", `Object (Some "wl_seat"); "serial", `Uint; "parent", `Object (Some "wl_surface");
                         "x", `Int; "y", `Int; "flags", `Uint]
    | 7 -> "set_maximized", ["output", `Object (Some "wl_output")]
    | 8 -> "set_title", ["title", `String]
    | 9 -> "set_class", ["class_", `String]
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | 0 -> "ping", ["serial", `Uint]
    | 1 -> "configure", ["edges", `Uint; "width", `Int; "height", `Int]
    | 2 -> "popup_done", []
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_shell_surface)

module Wl_surface = struct
  type t = [`Wl_surface]
  type _ Metadata.ty += T : [`Wl_surface] Metadata.ty
  type versions = [`V1 | `V2 | `V3 | `V4 | `V5 | `V6]
  let interface = "wl_surface"
  let version = 6l
  
  (** Wl_surface error values.
      
      These errors can be emitted in response to wl_surface requests. *)
  module Error = struct
    type t =
      | Invalid_scale : t
      | Invalid_transform : t
      | Invalid_size : t
      | Invalid_offset : t
      | Defunct_role_object : t
    
    let to_int32 = function
      | Invalid_scale -> 0l
      | Invalid_transform -> 1l
      | Invalid_size -> 2l
      | Invalid_offset -> 3l
      | Defunct_role_object -> 4l
    
    let of_int32 = function
      | 0l -> Invalid_scale
      | 1l -> Invalid_transform
      | 2l -> Invalid_size
      | 3l -> Invalid_offset
      | 4l -> Defunct_role_object
      | x -> Fmt.failwith "Invalid error enum value %ld" x
  end
  
  let requests = function
    | 0 -> "destroy", []
    | 1 -> "attach", ["buffer", `Object (Some "wl_buffer"); "x", `Int; "y", `Int]
    | 2 -> "damage", ["x", `Int; "y", `Int; "width", `Int; "height", `Int]
    | 3 -> "frame", ["callback", `New_ID (Some "wl_callback")]
    | 4 -> "set_opaque_region", ["region", `Object (Some "wl_region")]
    | 5 -> "set_input_region", ["region", `Object (Some "wl_region")]
    | 6 -> "commit", []
    | 7 -> "set_buffer_transform", ["transform", `Int]
    | 8 -> "set_buffer_scale", ["scale", `Int]
    | 9 -> "damage_buffer", ["x", `Int; "y", `Int; "width", `Int; "height", `Int]
    | 10 -> "offset", ["x", `Int; "y", `Int]
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | 0 -> "enter", ["output", `Object (Some "wl_output")]
    | 1 -> "leave", ["output", `Object (Some "wl_output")]
    | 2 -> "preferred_buffer_scale", ["factor", `Int]
    | 3 -> "preferred_buffer_transform", ["transform", `Uint]
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_surface)

module Wl_seat = struct
  type t = [`Wl_seat]
  type _ Metadata.ty += T : [`Wl_seat] Metadata.ty
  type versions = [`V1 | `V2 | `V3 | `V4 | `V5 | `V6 | `V7 | `V8 | `V9]
  let interface = "wl_seat"
  let version = 9l
  
  (** Seat capability bitmask.
      
      This is a bitmask of capabilities this seat has; if a member is
      set, then it is present on the seat. *)
  module Capability = struct
    type t = int32
    
    let pointer = 1l
    
    let keyboard = 2l
    
    let touch = 4l
    
    let to_int32 = Fun.id
    let of_int32 = Fun.id
  end
  
  
  (** Wl_seat error values.
      
      These errors can be emitted in response to wl_seat requests. *)
  module Error = struct
    type t =
      | Missing_capability : t
    
    let to_int32 = function
      | Missing_capability -> 0l
    
    let of_int32 = function
      | 0l -> Missing_capability
      | x -> Fmt.failwith "Invalid error enum value %ld" x
  end
  
  let requests = function
    | 0 -> "get_pointer", ["id", `New_ID (Some "wl_pointer")]
    | 1 -> "get_keyboard", ["id", `New_ID (Some "wl_keyboard")]
    | 2 -> "get_touch", ["id", `New_ID (Some "wl_touch")]
    | 3 -> "release", []
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | 0 -> "capabilities", ["capabilities", `Uint]
    | 1 -> "name", ["name", `String]
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_seat)

module Wl_pointer = struct
  type t = [`Wl_pointer]
  type _ Metadata.ty += T : [`Wl_pointer] Metadata.ty
  type versions = [`V1 | `V2 | `V3 | `V4 | `V5 | `V6 | `V7 | `V8 | `V9]
  let interface = "wl_pointer"
  let version = 9l
  
  module Error = struct
    type t =
      | Role : t
    
    let to_int32 = function
      | Role -> 0l
    
    let of_int32 = function
      | 0l -> Role
      | x -> Fmt.failwith "Invalid error enum value %ld" x
  end
  
  
  (** Physical button state.
      
      Describes the physical state of a button that produced the button
      event. *)
  module Button_state = struct
    type t =
      | Released : t
      | Pressed : t
    
    let to_int32 = function
      | Released -> 0l
      | Pressed -> 1l
    
    let of_int32 = function
      | 0l -> Released
      | 1l -> Pressed
      | x -> Fmt.failwith "Invalid button_state enum value %ld" x
  end
  
  
  (** Axis types.
      
      Describes the axis types of scroll events. *)
  module Axis = struct
    type t =
      | Vertical_scroll : t
      | Horizontal_scroll : t
    
    let to_int32 = function
      | Vertical_scroll -> 0l
      | Horizontal_scroll -> 1l
    
    let of_int32 = function
      | 0l -> Vertical_scroll
      | 1l -> Horizontal_scroll
      | x -> Fmt.failwith "Invalid axis enum value %ld" x
  end
  
  
  (** Axis source types.
      
      Describes the source types for axis events. This indicates to the
      client how an axis event was physically generated; a client may
      adjust the user interface accordingly. For example, scroll events
      from a "finger" source may be in a smooth coordinate space with
      kinetic scrolling whereas a "wheel" source may be in discrete steps
      of a number of lines.
      
      The "continuous" axis source is a device generating events in a
      continuous coordinate space, but using something other than a
      finger. One example for this source is button-based scrolling where
      the vertical motion of a device is converted to scroll events while
      a button is held down.
      
      The "wheel tilt" axis source indicates that the actual device is a
      wheel but the scroll event is not caused by a rotation but a
      (usually sideways) tilt of the wheel. *)
  module Axis_source = struct
    type t =
      | Wheel : t
      | Finger : t
      | Continuous : t
      | Wheel_tilt : t
    
    let to_int32 = function
      | Wheel -> 0l
      | Finger -> 1l
      | Continuous -> 2l
      | Wheel_tilt -> 3l
    
    let of_int32 = function
      | 0l -> Wheel
      | 1l -> Finger
      | 2l -> Continuous
      | 3l -> Wheel_tilt
      | x -> Fmt.failwith "Invalid axis_source enum value %ld" x
  end
  
  
  (** Axis relative direction.
      
      This specifies the direction of the physical motion that caused a
      wl_pointer.axis event, relative to the wl_pointer.axis direction. *)
  module Axis_relative_direction = struct
    type t =
      | Identical : t
      | Inverted : t
    
    let to_int32 = function
      | Identical -> 0l
      | Inverted -> 1l
    
    let of_int32 = function
      | 0l -> Identical
      | 1l -> Inverted
      | x -> Fmt.failwith "Invalid axis_relative_direction enum value %ld" x
  end
  
  let requests = function
    | 0 -> "set_cursor", ["serial", `Uint; "surface", `Object (Some "wl_surface"); "hotspot_x", `Int; "hotspot_y", `Int]
    | 1 -> "release", []
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | 0 -> "enter", ["serial", `Uint; "surface", `Object (Some "wl_surface"); "surface_x", `Fixed; "surface_y", `Fixed]
    | 1 -> "leave", ["serial", `Uint; "surface", `Object (Some "wl_surface")]
    | 2 -> "motion", ["time", `Uint; "surface_x", `Fixed; "surface_y", `Fixed]
    | 3 -> "button", ["serial", `Uint; "time", `Uint; "button", `Uint; "state", `Uint]
    | 4 -> "axis", ["time", `Uint; "axis", `Uint; "value", `Fixed]
    | 5 -> "frame", []
    | 6 -> "axis_source", ["axis_source", `Uint]
    | 7 -> "axis_stop", ["time", `Uint; "axis", `Uint]
    | 8 -> "axis_discrete", ["axis", `Uint; "discrete", `Int]
    | 9 -> "axis_value120", ["axis", `Uint; "value120", `Int]
    | 10 -> "axis_relative_direction", ["axis", `Uint; "direction", `Uint]
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_pointer)

module Wl_keyboard = struct
  type t = [`Wl_keyboard]
  type _ Metadata.ty += T : [`Wl_keyboard] Metadata.ty
  type versions = [`V1 | `V2 | `V3 | `V4 | `V5 | `V6 | `V7 | `V8 | `V9]
  let interface = "wl_keyboard"
  let version = 9l
  
  (** Keyboard mapping format.
      
      This specifies the format of the keymap provided to the
      client with the wl_keyboard.keymap event. *)
  module Keymap_format = struct
    type t =
      | No_keymap : t
      | Xkb_v1 : t
    
    let to_int32 = function
      | No_keymap -> 0l
      | Xkb_v1 -> 1l
    
    let of_int32 = function
      | 0l -> No_keymap
      | 1l -> Xkb_v1
      | x -> Fmt.failwith "Invalid keymap_format enum value %ld" x
  end
  
  
  (** Physical key state.
      
      Describes the physical state of a key that produced the key event. *)
  module Key_state = struct
    type t =
      | Released : t
      | Pressed : t
    
    let to_int32 = function
      | Released -> 0l
      | Pressed -> 1l
    
    let of_int32 = function
      | 0l -> Released
      | 1l -> Pressed
      | x -> Fmt.failwith "Invalid key_state enum value %ld" x
  end
  
  let requests = function
    | 0 -> "release", []
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | 0 -> "keymap", ["format", `Uint; "fd", `FD; "size", `Uint]
    | 1 -> "enter", ["serial", `Uint; "surface", `Object (Some "wl_surface"); "keys", `Array]
    | 2 -> "leave", ["serial", `Uint; "surface", `Object (Some "wl_surface")]
    | 3 -> "key", ["serial", `Uint; "time", `Uint; "key", `Uint; "state", `Uint]
    | 4 -> "modifiers", ["serial", `Uint; "mods_depressed", `Uint; "mods_latched", `Uint; "mods_locked", `Uint;
                         "group", `Uint]
    | 5 -> "repeat_info", ["rate", `Int; "delay", `Int]
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_keyboard)

module Wl_touch = struct
  type t = [`Wl_touch]
  type _ Metadata.ty += T : [`Wl_touch] Metadata.ty
  type versions = [`V1 | `V2 | `V3 | `V4 | `V5 | `V6 | `V7 | `V8 | `V9]
  let interface = "wl_touch"
  let version = 9l
  
  let requests = function
    | 0 -> "release", []
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | 0 -> "down", ["serial", `Uint; "time", `Uint; "surface", `Object (Some "wl_surface"); "id", `Int; "x", `Fixed;
                    "y", `Fixed]
    | 1 -> "up", ["serial", `Uint; "time", `Uint; "id", `Int]
    | 2 -> "motion", ["time", `Uint; "id", `Int; "x", `Fixed; "y", `Fixed]
    | 3 -> "frame", []
    | 4 -> "cancel", []
    | 5 -> "shape", ["id", `Int; "major", `Fixed; "minor", `Fixed]
    | 6 -> "orientation", ["id", `Int; "orientation", `Fixed]
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_touch)

module Wl_output = struct
  type t = [`Wl_output]
  type _ Metadata.ty += T : [`Wl_output] Metadata.ty
  type versions = [`V1 | `V2 | `V3 | `V4]
  let interface = "wl_output"
  let version = 4l
  
  (** Subpixel geometry information.
      
      This enumeration describes how the physical
      pixels on an output are laid out. *)
  module Subpixel = struct
    type t =
      | Unknown : t
      | None : t
      | Horizontal_rgb : t
      | Horizontal_bgr : t
      | Vertical_rgb : t
      | Vertical_bgr : t
    
    let to_int32 = function
      | Unknown -> 0l
      | None -> 1l
      | Horizontal_rgb -> 2l
      | Horizontal_bgr -> 3l
      | Vertical_rgb -> 4l
      | Vertical_bgr -> 5l
    
    let of_int32 = function
      | 0l -> Unknown
      | 1l -> None
      | 2l -> Horizontal_rgb
      | 3l -> Horizontal_bgr
      | 4l -> Vertical_rgb
      | 5l -> Vertical_bgr
      | x -> Fmt.failwith "Invalid subpixel enum value %ld" x
  end
  
  
  (** Transform from framebuffer to output.
      
      This describes the transform that a compositor will apply to a
      surface to compensate for the rotation or mirroring of an
      output device.
      
      The flipped values correspond to an initial flip around a
      vertical axis followed by rotation.
      
      The purpose is mainly to allow clients to render accordingly and
      tell the compositor, so that for fullscreen surfaces, the
      compositor will still be able to scan out directly from client
      surfaces. *)
  module Transform = struct
    type t =
      | Normal : t
      | V90 : t
      | V180 : t
      | V270 : t
      | Flipped : t
      | Flipped_90 : t
      | Flipped_180 : t
      | Flipped_270 : t
    
    let to_int32 = function
      | Normal -> 0l
      | V90 -> 1l
      | V180 -> 2l
      | V270 -> 3l
      | Flipped -> 4l
      | Flipped_90 -> 5l
      | Flipped_180 -> 6l
      | Flipped_270 -> 7l
    
    let of_int32 = function
      | 0l -> Normal
      | 1l -> V90
      | 2l -> V180
      | 3l -> V270
      | 4l -> Flipped
      | 5l -> Flipped_90
      | 6l -> Flipped_180
      | 7l -> Flipped_270
      | x -> Fmt.failwith "Invalid transform enum value %ld" x
  end
  
  
  (** Mode information.
      
      These flags describe properties of an output mode.
      They are used in the flags bitfield of the mode event. *)
  module Mode = struct
    type t = int32
    
    let current = 1l
    
    let preferred = 2l
    
    let to_int32 = Fun.id
    let of_int32 = Fun.id
  end
  
  let requests = function
    | 0 -> "release", []
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | 0 -> "geometry", ["x", `Int; "y", `Int; "physical_width", `Int; "physical_height", `Int; "subpixel", `Int;
                        "make", `String; "model", `String; "transform", `Int]
    | 1 -> "mode", ["flags", `Uint; "width", `Int; "height", `Int; "refresh", `Int]
    | 2 -> "done", []
    | 3 -> "scale", ["factor", `Int]
    | 4 -> "name", ["name", `String]
    | 5 -> "description", ["description", `String]
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_output)

module Wl_region = struct
  type t = [`Wl_region]
  type _ Metadata.ty += T : [`Wl_region] Metadata.ty
  type versions = [`V1]
  let interface = "wl_region"
  let version = 1l
  
  let requests = function
    | 0 -> "destroy", []
    | 1 -> "add", ["x", `Int; "y", `Int; "width", `Int; "height", `Int]
    | 2 -> "subtract", ["x", `Int; "y", `Int; "width", `Int; "height", `Int]
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_region)

module Wl_subcompositor = struct
  type t = [`Wl_subcompositor]
  type _ Metadata.ty += T : [`Wl_subcompositor] Metadata.ty
  type versions = [`V1]
  let interface = "wl_subcompositor"
  let version = 1l
  
  module Error = struct
    type t =
      | Bad_surface : t
      | Bad_parent : t
    
    let to_int32 = function
      | Bad_surface -> 0l
      | Bad_parent -> 1l
    
    let of_int32 = function
      | 0l -> Bad_surface
      | 1l -> Bad_parent
      | x -> Fmt.failwith "Invalid error enum value %ld" x
  end
  
  let requests = function
    | 0 -> "destroy", []
    | 1 -> "get_subsurface", ["id", `New_ID (Some "wl_subsurface"); "surface", `Object (Some "wl_surface");
                              "parent", `Object (Some "wl_surface")]
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_subcompositor)

module Wl_subsurface = struct
  type t = [`Wl_subsurface]
  type _ Metadata.ty += T : [`Wl_subsurface] Metadata.ty
  type versions = [`V1]
  let interface = "wl_subsurface"
  let version = 1l
  
  module Error = struct
    type t =
      | Bad_surface : t
    
    let to_int32 = function
      | Bad_surface -> 0l
    
    let of_int32 = function
      | 0l -> Bad_surface
      | x -> Fmt.failwith "Invalid error enum value %ld" x
  end
  
  let requests = function
    | 0 -> "destroy", []
    | 1 -> "set_position", ["x", `Int; "y", `Int]
    | 2 -> "place_above", ["sibling", `Object (Some "wl_surface")]
    | 3 -> "place_below", ["sibling", `Object (Some "wl_surface")]
    | 4 -> "set_sync", []
    | 5 -> "set_desync", []
    | i -> Proxy.unknown_request i, []
  
  let events = function
    | i -> Proxy.unknown_event i, []
  
end
let () = Iface_reg.register (module Wl_subsurface)