structure Error : sig
     datatype t
   (* global errors *)
       = INVALID_NAME
       | INVALID_OPERATION
   (* device errors *)
       | INVALID_DEVICE
       | INVALID_CONTEXT
   (* general errors *)
       | INVALID_ENUM
       | INVALID_VALUE
       | OUT_OF_MEMORY

     val getError : unit -> t
     val getDevError : device -> t

     val toString : t -> string

   end

structure Format : sig
    eqtype t

    val MONO8 : t
    val MONO16 : t
    val STEREO8 : t
    val STEREO16 : t

    val isMono : t -> bool
    val channels : t -> int
    val bytesPerChannel : t -> int
    val bytesPerSample : t -> int
  end

structure Buffer : sig
    type t = buffer

    val gen : unit -> t
    val genList : int -> t list
    val delete : t list -> unit

  (* Get Buffer parameters *)
    val frequency : t -> int
    val bitsPerSample : t -> int
    val channels : t -> int
    val size : t -> int

    val loadFromVector : (t * Word8Vector.vector * Format.t * int) -> unit
    val loadFromArray : (t * Word8Array.array * Format.t * int) -> unit
  end

structure Source : sig
    type t = source

  (* the type *)
    datatype mode = UNDETERMINED | STATIC | STREAMING

    eqtype state
    val INITIAL : state
    val PLAYING : state
    val PAUSED : state
    val STOPPED : state

    val gen : unit -> t
    val genList : int -> t list
    val delete : t list -> unit

  (* playback controls *)
    val play : t -> unit
    val playList : t list -> unit
    val stop : t -> unit
    val stopList : t list -> unit
    val pause : t -> unit
    val pauseList : t list -> unit
    val rewind : t -> unit
    val rewindList : t list -> unit

  (* get the current mode of the source *)
    val mode : t -> mode

  (* get current state *)
    val state : t -> state

  (* source position *)
    val position : t -> vec3f
    val setPosition : (t * vec3f) -> unit

  (* is position relative to listener? *)
    val relative : t -> bool
    val setRelative : t * bool -> unit

  (* source velocity *)
    val velocity : t -> vec3f
    val setVelocity : (t * vec3f) -> unit

  (* source direction and cone *)
    val direction : t -> vec3f
    val setDirection : (t * vec3f) -> unit
    val coneInnerAngle : t -> float
    val setConeInnerAngle : t * float -> unit
    val coneOuterAngle : t -> float
    val setConeOuterAngle : t * float -> unit
    val coneOuterGain : t -> float
    val setConeOuterGain : t * float -> unit

  (* frequency shift *)
    val pitch : t -> float
    val setPitch : t * float -> unit

  (* looping playback *)
    val looping : t -> bool
    val setLooping : t * bool -> unit

  (* gain bounds *)
    val minGain : t -> float
    val setMinGain : t -> float
    val maxGain : t -> float
    val setMaxGain : t -> float

  (* distance-model attributes *)
    val referenceDistance : t -> float
    val setReferenceDistance : t * float -> unit
    val rolloffFactor : t -> float
    val setRolloffFactor : t * float -> unit
    val maxDistance : t -> float
    val setMaxDistance : t * float -> unit

  (* offset into the curent audio data *)
    val offset : t -> Time.time
    val setOffset : t * Time.time -> unit
    val sampleOffset : t -> int
    val setSampleOffset : t * int -> unit
    val byteOffset : t -> int
    val setByteOffset : t * int -> unit

  (* get the current buffer attached to the t, or NONE if there is no buffer *)
    val buffer : t -> buffer option
  (* set the given buffer to be the head of the t's queue *)
    val setBuffer : t * buffer -> unit
  (* clear all of the buffers from the t's queue *)
    val clrBuffer : t -> unit

  (* return the number of buffers in the t's queue *)
    val buffersQueued : t -> int
  (* return the number of buffers that have been completely played *)
    val buffersProcessed : t -> int
  (* add buffers to the end of the t's queue *)
    val queueBuffers : t * buffer list -> unit
  (* remove processed buffers from the front of the queue *)
    val unqueueBuffers : t * int -> buffer list

  end

structure Listener : sig
    val gain : float -> unit
    val getGain : unit -> float

    val position : vec3f -> unit
    val getPosition : unit -> vec3f

    val velocity : vec3f -> unit
    val getVelocity : unit -> vec3f

    val orientation : {dir : vec3f, up : vec3f} -> unit
    val getOrientation : unit -> {dir : vec3f, up : vec3f}
  end

structure Context : sig
    datatype context_attr
      = FREQUENCY of int        (* Frequency for mixing output buffer (Hz) *)
      | REFRESH of int          (* Refresh intervals (Hz) *)
      | SYNC of bool            (* Indicating a synchronous context *)
      | MONO_SOURCES of int     (* Number of requested mono sources *)
      | STEREO_SOURCES of int   (* Number of requested stereo sources *)

    val create : device * context_attr list -> context option
    val makeCurrent : context -> bool
    val process : context -> unit
    val suspend : context -> unit
    val destroy : context -> unit
    val getCurrent : unit -> context option
    val getDevice : context -> device option
  end

structure Device : sig
    val openDev : string option -> device option
    val close : device -> bool

    val defaultSpecifier : unit -> string
    val specifier : device -> string
    val specifiers : unit -> string list
    val attributes : device -> Context.context_attr list
  end

structure IO : sig
    type buffer_info = {
        frequency : int,
        format : Format.format,
        size : int
      }
    val loadFile : string -> buffer * buffer_info
    val loadFileIntoBuffer : string * buffer -> buffer_info
  end