!"      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                 ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                              Safe@ dbusWhen a D-Bus server must listen for connections, or a client must connect to a server, the listening socket's configuration is specified with an address. An address contains the method>, which determines the protocol and transport mechanism, and  parametersJ, which provide additional method-specific information about the address.dbus7Try to convert a method string and parameter map to an .Returns ) if the method or parameters are invalid.dbus9Convert an address to a string in the format expected by  . dbusCConvert a list of addresses to a string in the format expected by  . dbus3Try to parse a string containing one valid address.#An address string is in the format method:key1=val1,key2=val2. There are some limitations on the characters allowed within methods and parameters; see the D-Bus specification for full details. dbus=Try to parse a string containing one or more valid addresses.+Addresses are separated by semicolons. See   for the format of addresses. dbus1Returns the address in the environment variable DBUS_SYSTEM_BUS_ADDRESS, or )unix:path=/var/run/dbus/system_bus_socket if DBUS_SYSTEM_BUS_ADDRESS is not set.Returns  if DBUS_SYSTEM_BUS_ADDRESS contains an invalid address.dbus1Returns the address in the environment variable DBUS_SESSION_BUS_ADDRESS, which must be set.Returns  if DBUS_SYSTEM_BUS_ADDRESS* is unset or contains an invalid address.dbus1Returns the address in the environment variable DBUS_STARTER_ADDRESS, which must be set.Returns  if DBUS_STARTER_ADDRESS* is unset or contains an invalid address.  None 7=?MXdbusA value used to uniquely identify a particular message within a session. Serials are 32-bit unsigned integers, and eventually wrap.dbus{A D-Bus Dictionary is a container type similar to Haskell maps, storing zero or more associations between keys and values.Most users can use the F instance for maps to extract the values of a dictionary. This type is for advanced use cases, where the user wants to convert dictionary items to Haskell types that are not instances of B.dbuspA D-Bus Array is a container type similar to Haskell lists, storing zero or more values of a single D-Bus type.Most users can use the F instance for lists or vectors to extract the values of an array. This type is for advanced use cases, where the user wants to convert array values to Haskell types that are not instances of B.dbustA D-Bus Structure is a container type similar to Haskell tuples, storing values of any type that is convertable to F,. A Structure may contain up to 255 values.Most users can use the F instance for tuples to extract the values of a structure. This type is for very large structures, which may be awkward to work with as tuples.dbus`Bus names are used to identify particular clients on the message bus. A bus name may be either unique or  well-knownm, where unique names start with a colon. Bus names consist of alphanumeric characters separated by periods.See  Rhttp://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus for details. dbusError names are used to identify which type of error was returned from a method call. Error names consist of alphanumeric characters separated by periods.See  Thttp://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-error for details."dbusMember names are used to identify a single method or signal within an interface. Method names consist of alphanumeric characters.See  Uhttp://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-member for details.$dbusInterfaces are used to group a set of methods and signals within an exported object. Interface names consist of alphanumeric characters separated by periods.See  Xhttp://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-interface for details.&dbusjObject paths are special strings, used to identify a particular object exported from a D-Bus application.cObject paths must begin with a slash, and consist of alphanumeric characters separated by slashes.See  _http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-marshaling-object-path for details.=dbusRVariants may contain any other built-in D-Bus value. Besides representing native VARIANTK values, they allow type-safe storage and inspection of D-Bus collections.?dbus1Atomic types can be used as keys to dictionaries.'Users may not provide new instances of ?H because this could allow dictionaries to be created with invalid keys.BdbusOValue types can be used as items in containers, such as lists or dictionaries.'Users may not provide new instances of BU because this could allow containers to be created with items of heterogenous types.KdbusLA signature is a list of D-Bus types, obeying some basic rules of validity.2The rules of signature validity are complex: see  Shttp://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-signatures for details.`dbus5Get the list of types in a signature. The inverse of c.adbus=Convert a signature into a signature string. The inverse of e.cdbus/Convert a list of types into a valid signature.4Throws if the given types are not a valid signature.ddbus/Convert a list of types into a valid signature.AThrows an exception if the given types are not a valid signature.edbus0Parse a signature string into a valid signature.4Throws if the given string is not a valid signature.qdbusEvery variant is strongly-typed; that is, the type of its contained value is known at all times. This function retrieves that type, so that the correct cast can be used to retrieve the value.dbus%Get the first serial in the sequence.dbus>Get the next serial in the sequence. This may wrap around to . !"#$%&'(543210/.-,+*)6<;:978=>?A@BECDFGHIJKLM^]\[ZYXWVUTSRQPON_`abcdefghijklmnopqrstuvwxyz{|}~M^]\[ZYXWVUTSRQPON_KL`abcdefghIJijklFGHBECD?A@=>6<;:978(543210/.-,+*)mnopqrstuv&'wxyz{|$%}~"# !None-dbustNot an actual message type, but a wrapper around messages received from the bus. Each value contains the message's .If casing against these constructors, always include a default case to handle messages of an unknown type. New message types may be added to the D-Bus specification, and applications should handle them gracefully by either ignoring or logging them.3dbusMSignals are broadcast by applications to notify other clients of some event.5dbus0The path of the object that emitted this signal.6dbus*The interface that this signal belongs to.7dbusThe name of this signal.8dbus5The name of the application that emitted this signal.Most users will just leave this empty, because the bus overwrites the sender for security reasons. Setting the sender manually is used for peer-peer connections. Defaults to Nothing.9dbus6The name of the application to emit the signal to. If NothingX, the signal is sent to any application that has registered an appropriate match rule. Defaults to Nothing.:dbusLAdditional information about the signal, such as the new value or the time. Defaults to [].;dbuslA method error is a reply to a method call, indicating that the call received an error and did not succeed.=dbussThe name of the error type. Names are used so clients can handle certain classes of error differently from others.>dbusoThe serial of the original method call. This lets the original caller match up this reply to the pending call.?dbus:The name of the application that is returning from a call.Most users will just leave this empty, because the bus overwrites the sender for security reasons. Setting the sender manually is used for peer-peer connections. Defaults to Nothing.@dbus4The name of the application that initiated the call.Most users should set this. If a message with no destination is sent to the bus, the bus will behave as if the destination was set to org.freedesktop.DBusZ. For peer-peer connections, the destination can be empty because there is only one peer. Defaults to Nothing.AdbusAdditional information about the error. By convention, if the error body contains any items, the first item should be a string describing the error.BdbusQA method return is a reply to a method call, indicating that the call succeeded.DdbusoThe serial of the original method call. This lets the original caller match up this reply to the pending call.Edbus:The name of the application that is returning from a call.Most users will just leave this empty, because the bus overwrites the sender for security reasons. Setting the sender manually is used for peer-peer connections. Defaults to Nothing.Fdbus4The name of the application that initiated the call.Most users should set this. If a message with no destination is sent to the bus, the bus will behave as if the destination was set to org.freedesktop.DBusZ. For peer-peer connections, the destination can be empty because there is only one peer. Defaults to Nothing.Gdbus*Values returned from the method call. See G. Defaults to [].HdbusA method call is a request to run some procedure exported by the remote process. Procedures are identified by an (object_path, interface_name, method_name) tuple.JdbusThe object path of the method call. Conceptually, object paths act like a procedural language's pointers. Each object referenced by a path is a collection of procedures.KdbusThe interface of the method call. Each object may implement any number of interfaces. Each method is part of at least one interface.In certain cases, this may be Nothing+, but most users should set it to a value.Ldbus{The method name of the method call. Method names are unique within an interface, but might not be unique within an object.Mdbus0The name of the application that sent this call.Most users will just leave this empty, because the bus overwrites the sender for security reasons. Setting the sender manually is used for peer-peer connections. Defaults to Nothing.Ndbus0The name of the application to send the call to.Most users should set this. If a message with no destination is sent to the bus, the bus will behave as if the destination was set to org.freedesktop.DBusZ. For peer-peer connections, the destination can be empty because there is only one peer. Defaults to Nothing.OdbuslSet whether a reply is expected. This can save network and cpu resources by inhibiting unnecessary replies. Defaults to True.Pdbus0Set whether the bus should auto-start the remote Defaults to True.Qdbus&The arguments to the method call. See G. Defaults to [].gdbusoGet a human-readable description of the error, by returning the first item in the error body if it's a string.;-./0123457689:;<=>?@ABCDEFGHIJKLMNPOQRSTUVWXYZ[\]^_`abcdefg;abcde\]^_`HIJKLMNPOQBCDEFG;<=>?@Ag3457689:-./012RSTUVWXYZ[fNone z{|~} |~}{zNonedbusA D-Bus UUID is 128 bits of data, usually randomly generated. They are used for identifying unique server instances to clients.:Older versions of the D-Bus spec also called these values GUIDs.DD-Bus UUIDs are not the same as the RFC-standardized UUIDs or GUIDs.dbus[Deprecated. Get the D-Bus type corresponding to the given Haskell value. The value may be  undefined.dbus;Get the D-Bus type corresponding to the given Haskell type a.dbusConstruct a new H- for the given object, interface, and method.Use fields such as N and Q to populate a H. R{-# LANGUAGE OverloadedStrings #-} methodCall "/" "org.example.Math" "Add" { N' = Just "org.example.Calculator" , Q = [G (1 :: Int32), G (2 :: Int32)] } dbusConstruct a new B3, in reply to a method call with the given serial.Use fields such as G to populate a B.dbusConstruct a new ;3, in reply to a method call with the given serial.Use fields such as A to populate a ;.dbusConstruct a new 32 for the given object, interface, and signal name.Use fields such as : to populate a 3.dbus<No matter what sort of message was received, get its serial.dbusJNo matter what sort of message was received, get its sender (if provided).dbusHNo matter what sort of message was received, get its body (if provided).dbus Convert a a into a o. Although unusual, it is possible for marshaling to fail; if this occurs, an error will be returned instead.dbusParse a  into a -. The result can be inspected to see what type of message was parsed. Unknown message types can still be parsed successfully, as long as they otherwise conform to the D-Bus standard.dbus)Format a D-Bus UUID as hex-encoded ASCII.dbusGenerate a random D-Bus UUID. This value is suitable for use in a randomly-allocated address, or as a listener's socket address "guid" parameter.  "$&=?BFHGKMNOPQRSTUVWXYZ[\]^`acdeqyz{}~-./013:98675;A@?>=BGFEDHQOPNMLKJagz{|~}aHJKLMNPOQBDEFG;=>?@Ag357689:-./01=FHGq?BKMNOPQRSTUVWXYZ[\]^cd`ae&{yz$}~"  |~}{zNone%%None "#1HMSVXtNoneNone' None2HVdbus-Supports connecting over Unix or TCP sockets.\Unix sockets are similar to pipes, but exist as special files in the filesystem. On Linux, abstract socketsO have a path-like address, but do not actually have entries in the filesystem.(TCP sockets may use either IPv4 or IPv6.dbusA @ which can listen for and accept connections from remote peers.dbus5Used for transports that listen on a port or address.dbusOBegin listening for connections on the given address, using the given options. Throws a ^ if it's not possible to listen at that address (for example, if the port is already in use).dbusAccept a new connection. Throws a H if some error happens before the transport is ready to exchange bytes.dbusClose an open listener.dbus0Get the address to use to connect to a listener.dbus2Get the UUID allocated to this transport listener.See .dbusA . which can open a connection to a remote peer.dbus@Open a connection to the given address, using the given options. Throws a - if the connection could not be established.dbusA ' can exchange bytes with a remote peer.dbusTAdditional options that this transport type may use when establishing a connection.dbus,Default values for this transport's options.dbusSend a  over the transport. Throws a  if an error occurs.dbus Receive a  of the given size from the transport. The transport should block until sufficient bytes are available, and only return fewer than the requested amount if there will not be any more data. Throws a  if an error occurs.dbusJClose an open transport, and release any associated resources or handles.dbus3Thrown from transport methods when an error occurs.dbusAThe maximum size of the connection queue for a listening socket.dbus@Returns the processID, userID, and groupID of the socket's peer.See . None2EHVXKYdbus Used with   and  8 to provide custom authenticators or transport options.dbusUsed to perform authentication with the remote peer. After a transport has been opened, it will be passed to the authenticator. If the authenticator returns true, then the socket was authenticated.dbusyOptions for the underlying transport, to be used by custom transports for controlling how to connect to the remote peer.See DBus.Transport* for details on defining custom transportsdbusgAn Authenticator defines how the local peer (client) authenticates itself to the remote peer (server).dbus1Defines the client-side half of an authenticator.dbus`Defines the server-side half of an authenticator. The UUID is allocated by the socket listener.dbusRAn open socket to another process. Messages can be sent to the remote peer using , or received using .dbusIStores information about an error encountered while creating or using a .dbusDefault ?, which uses the default Unix/TCP transport and authenticator. dbus>Open a socket to a remote peer listening at the given address. open =    Throws  on failure. dbus>Open a socket to a remote peer listening at the given address.Most users should use  U. This function is for users who need to define custom authenticators or transports.Throws  on failure. dbus%Begin listening at the given address.Use  - to create sockets from incoming connections.Use Y to stop listening, and to free underlying transport resources such as file descriptors.Throws  on failure. dbus%Begin listening at the given address.Use  - to create sockets from incoming connections.Use Y to stop listening, and to free underlying transport resources such as file descriptors.SThis function is for users who need to define custom authenticators or transports.Throws  on failure. dbus/Accept a new connection from a socket listener.Throws  on failure.dbusClose an open C. Once closed, the socket is no longer valid and must not be used.dbusClose an open E. Once closed, the listener is no longer valid and must not be used.dbus0Get the address to use to connect to a listener.dbus(Send a single message, with a generated . The second parameter exists to prevent race conditions when registering a reply handler; it receives the serial the message will* be sent with, before it's actually sent.Sockets are thread-safe. Only one message may be sent at a time; if multiple threads attempt to send messages concurrently, one will block until after the other has finished.Throws  on failure.dbusKReceive the next message from the socket , blocking until one is available.Sockets are thread-safe. Only one message may be received at a time; if multiple threads attempt to receive messages concurrently, one will block until after the other has finished.Throws  on failure.dbusAn empty authenticator. Use  or 1 to control how the authentication is performed. SmyAuthenticator :: Authenticator MyTransport myAuthenticator = authenticator {  = clientMyAuth , p = serverMyAuth } clientMyAuth :: MyTransport -> IO Bool serverMyAuth :: MyTransport -> String -> IO Bool dbusImplements the D-Bus EXTERNAL> mechanism, which uses credential passing over a Unix socket.dbusDrop n items from the end of a listdbus^Read values from a monad until a guard value is read; return all values, including the guard.           None&'2=>?@AEPSX03dbusDOptions for the underlying socket, for advanced use cases. See the  DBus.Socket module.4dbusA function to run the client thread. The provided IO computation should be called repeatedly; each time it is called, it will process one incoming message.&The provided computation will throw a >K if it fails to process an incoming message, or if the connection is lost.The default implementation is .dbusA function to build the interfaces that should be present at every point where there is an object present. The default value builds the property and introspection interfaces.6dbusuAn active client session to a message bus. Clients may send or receive method calls, and listen for or emit signals.GdbusUsed to automatically generate method signatures for introspection documents. To support automatic signatures, a method's parameters and return value must all be instances of B.>This class maps Haskell idioms to D-Bus; it is therefore unable to generate some signatures. In particular, it does not support methods which accept/return a single structure, or single-element structures. It also cannot generate signatures for methods with parameters or return values which are only instances of F. For these cases, please use  .nTo match common Haskell use, if the return value is a tuple, it will be converted to a list of return values.HdbusRA match rule describes which signals a particular callback is interested in. Use { to construct match rules.DExample: a match rule which matches signals sent by the root object. +matchFromRoot :: MatchRule matchFromRoot = { { K = Just "/" } Idbus;If set, only receives signals sent from the given bus name.'The standard D-Bus implementation from  http://dbus.freedesktop.org/R almost always sets signal senders to the unique name of the sending client. If I is a requested name like "com.example.Foo" , it will not match any signals.TThe exception is for signals sent by the bus itself, which always have a sender of "org.freedesktop.DBus".Jdbus9If set, only receives signals sent to the given bus name.Kdbus7If set, only receives signals sent with the given path.LdbusAIf set, only receives signals sent with the given interface name.Mdbus>If set, only receives signals sent with the given member name.NdbusOIf set, only receives signals sent with the given path or any of its children.Pdbus+This client has released the provided name.Qdbus;The provided name is not assigned to any client on the bus.Rdbus1The provided name is not assigned to this client.SdbusuNot exported; exists to generate a compiler warning if users case on the reply and forget to include a default case.Udbus;This client is now the primary owner of the requested name.VdbusmThe name was already reserved by another client, and replacement was either not attempted or not successful.Wdbus1The name was already reserved by another client, G was set, and replacement was either not attempted or not successful.Xdbus?This client is already the primary owner of the requested name.YdbusuNot exported; exists to generate a compiler warning if users case on the reply and forget to include a default case._dbus:Connect to the bus specified in the environment variable DBUS_SYSTEM_BUS_ADDRESS , or to )unix:path=/var/run/dbus/system_bus_socket if DBUS_SYSTEM_BUS_ADDRESS is not set. Throws a > if DBUS_SYSTEM_BUS_ADDRESSB contains an invalid address, or if connecting to the bus failed.`dbus:Connect to the bus specified in the environment variable DBUS_SESSION_BUS_ADDRESS, which must be set. Throws a > if DBUS_SESSION_BUS_ADDRESSL is unset, contains an invalid address, or if connecting to the bus failed.adbus:Connect to the bus specified in the environment variable DBUS_STARTER_ADDRESS, which must be set. Throws a > if DBUS_STARTER_ADDRESSL is unset, contains an invalid address, or if connecting to the bus failed.bdbus,Connect to the bus at the specified address. Throws a > on failure.cdbusgConnect to the bus at the specified address, with the given connection options. Most users should use b instead. Throws a > on failure.fdbusVDefault client options. Uses the built-in Socket-based transport, which supports the tcp: and unix: methods.gdbusStop a Client'2s callback thread and close its underlying socket.hdbusXAllow this client's reservation to be replaced, if another client requests it with the i flag.|If this client's reservation is replaced, this client will be added to the wait queue unless the request also included the j flag.idbus{If the name being requested is already reserved, attempt to replace it. This only works if the current owner provided the h flag.jdbusZIf the name is already in use, do not add this client to the queue, just return an error.kdbusAsks the message bus to assign the given name to this client. The bus maintains a queue of possible owners, where the head of the queue is the current ("primary") owner.,There are several uses for name reservation:Clients which export methods reserve a name so users and applications can send them messages. For example, the GNOME Keyring reserves the name "org.gnome.keyring"; on the user's session bus, and NetworkManager reserves  "org.freedesktop.NetworkManager" on the system bus.;When there are multiple implementations of a particular service, the service standard will ususally include a generic bus name for the service. This allows other clients to avoid depending on any particular implementation's name. For example, both the GNOME Keyring and KDE KWallet services request the "org.freedesktop.secrets"# name on the user's session bus.A process with "single instance" behavior can use name assignment to check whether the instance is already running, and invoke some method on it (e.g. opening a new window). Throws a > if the call failed.ldbus:Release a name that this client previously requested. See k) for an explanation of name reservation. Throws a > if the call failed.mdbus9Send a method call to the bus, and wait for the response. Throws a >J if the method call couldn't be sent, or if the reply couldn't be parsed.ndbus9Send a method call to the bus, and wait for the response. Unsets the noReplyExpected message flag before sending. Throws a >[ if the method call couldn't sent, if the reply couldn't be parsed, or if the reply was a ;.odbus>Send a method call to the bus, and do not wait for a response. Sets the noReplyExpected message flag before sending. Throws a >% if the method call couldn't be sent.pdbusHRetrieve a property using the method call parameters that were provided. Throws a >* if the property request couldn't be sent.vdbusmRequest that the bus forward signals matching the given rule to this client, and process them in a callback.rA received signal might be processed by more than one callback at a time. Callbacks each run in their own thread. The returned 1 can be passed to w to stop handling this signal. Throws a >0 if the match rule couldn't be added to the bus.wdbusCRequest that the bus stop forwarding signals for the given handler. Throws a >4 if the match rule couldn't be removed from the bus.xdbusEquivalent to v , but does not return the added 1.ydbusEmit the signal on the bus. Throws a >( if the signal message couldn't be sent.zdbusAConvert a match rule into the textual format accepted by the bus.{dbusMatch any signal.|dbusTNormally, any exceptions raised while executing a method will be given the generic #"org.freedesktop.DBus.Error.Failed" name. | allows the programmer to specify an error name, and provide additional information to the remote application. You may use this instead of  to abort a method call.}dbus^Prepare a Haskell function for export, automatically detecting the function's type signature.See G1 for details on the limitations of this function.See method1 for exporting functions with user-defined types.dbusbDefine a method handler, which will accept method calls with the given interface and member name.}Note that the input and output parameter signatures are used for introspection, but are not checked when executing a method.See }O for an easier way to export functions with simple parameter and return types.dbusExport the given  at the given &Use } to construct a +8 from a function that accepts and returns simple types.Use method to construct a += from a function that handles parameter conversion manually. ping :: MethodCall -> IO " ping _ = ReplyReturn [] sayHello :: String -> IO String sayHello name = return ("Hello " ++ name ++ "!") export client "/hello_world" defaultInterface { interfaceName = "com.example.HelloWorld" , interfaceMethods = [ method> "com.example.HelloWorld" "Ping" ping , }Z "com.example.HelloWorld" "Hello" sayHello ] } dbus Revokes the export of the given &H. This will remove all interfaces and methods associated with the path.|dbus Error messagedbus"Additional items of the error bodydbusInput parameter signaturedbusOutput parameter signaturer ! "#$%&'()*+,-./0124356789:;<=>@?ABGHNMLKJIOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~r6789:;<=5\[]^! Bb_`agmnopqrstud+,-./0G}~%&'()*"#$|1vwyxHz{IJKLMNeklZhijTUVWXYOPQRS>A?@234fc  None&&44 NoneN:: !"#$$%%&&'(())**++,,--./0123456789:;<=>?@ABCCDEFGHIJKLMNNOOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!      !"#$%&'()*+,-./01234556789:;<<=>?@ABBCDEFGGHIJKLMNOPQRSTUVWXYZZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~oH55st                                                                                                ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y  Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } } ~                                                       M  N            X  Y                            !dbus-1.2.7-6TRUoINKtjp9UUluIljeZkDBus.Internal.AddressDBus.Internal.TypesDBus.Internal.MessageDBus.Internal.WireDBusDBus.Introspection.TypesDBus.Introspection.RenderDBus.Introspection.ParseDBus.Transport DBus.Socket DBus.ClientDBus.GenerationDBus.THDBus.IntrospectionmethodAddress addressMethodaddressParametersaddress validMethod validParamsoptionallyEncoded formatAddressformatAddresses parseAddressparseAddresses parsecAddressgetSystemAddressgetSessionAddressgetStarterAddressgetenvhexToIntmaybeParseString $fShowAddress $fEqAddressSerial DictionaryArray ArrayBytes StructureBusName ErrorName MemberName InterfaceName ObjectPathAtomAtomBool AtomWord8 AtomWord16 AtomWord32 AtomWord64 AtomInt16 AtomInt32 AtomInt64 AtomDouble AtomUnixFdAtomText AtomSignatureAtomObjectPathValue ValueAtom ValueVariant ValueBytes ValueVectorValueMapValueStructureVariantIsAtomtoAtomfromAtomIsValuetypeOf'toValue fromValue IsVariant toVariant fromVariant SigParseError SignatureType TypeBoolean TypeWord8 TypeWord16 TypeWord32 TypeWord64 TypeInt16 TypeInt32 TypeInt64 TypeDouble TypeUnixFd TypeString TypeSignatureTypeObjectPath TypeVariant TypeArrayTypeDictionary TypeStructureshowTypesignatureTypesformatSignaturetypeCode signature signature_parseSignatureparseSignatureBytes parseSigFast parseAtompeekWord8AsInt parseSigFullextractFromVarianttypeOfshowAtom showValue showThings vectorToBytes variantType valueTypeatomTypebimapbimapMvarToVal pathElements fromElementsformatObjectPathparseObjectPath objectPath_parserObjectPathformatInterfaceNameparseInterfaceNameinterfaceName_parserInterfaceNameformatMemberNameparseMemberName memberName_parserMemberNameformatErrorNameparseErrorName errorName_ formatBusName parseBusNamebusName_ parserBusNamestructureItems arrayItemsdictionaryItems serialValue firstSerial nextSerial skipSepBy1 forceParse $fShowType $fNFDataType$fIsStringSignature$fShowSignature$fExceptionSigParseError$fIsStringObjectPath $fShowVariant $fEqValue$fIsVariant(,,,,,,,,,,,,,,)$fIsVariant(,,,,,,,,,,,,,)$fIsVariant(,,,,,,,,,,,,)$fIsVariant(,,,,,,,,,,,)$fIsVariant(,,,,,,,,,,)$fIsVariant(,,,,,,,,,)$fIsVariant(,,,,,,,,)$fIsVariant(,,,,,,,)$fIsVariant(,,,,,,)$fIsVariant(,,,,,)$fIsVariant(,,,,)$fIsVariant(,,,)$fIsVariant(,,)$fIsVariant(,) $fIsVariant()$fIsValue(,,,,,,,,,,,,,,)$fIsValue(,,,,,,,,,,,,,)$fIsValue(,,,,,,,,,,,,)$fIsValue(,,,,,,,,,,,)$fIsValue(,,,,,,,,,,)$fIsValue(,,,,,,,,,)$fIsValue(,,,,,,,,)$fIsValue(,,,,,,,)$fIsValue(,,,,,,)$fIsValue(,,,,,)$fIsValue(,,,,)$fIsValue(,,,) $fIsValue(,,) $fIsValue(,) $fIsValue()$fIsVariantByteString$fIsValueByteString$fIsVariantByteString0$fIsValueByteString0 $fIsVariant[] $fIsValue[]$fIsVariantVector$fIsValueVector$fIsVariant[]0$fIsVariantText$fIsVariantVariant$fIsValueVariant$fIsVariantObjectPath$fIsVariantSignature$fIsVariantText0 $fIsVariantFd$fIsVariantDouble$fIsVariantInt64$fIsVariantInt32$fIsVariantInt16$fIsVariantWord64$fIsVariantWord32$fIsVariantWord16$fIsVariantWord8$fIsVariantBool$fIsVariantMap $fIsValueMap $fIsValue[]0 $fIsAtom[] $fIsValueText $fIsAtomText$fIsValueObjectPath$fIsAtomObjectPath$fIsValueSignature$fIsAtomSignature$fIsValueText0 $fIsAtomText0 $fIsValueFd $fIsAtomFd$fIsValueDouble$fIsAtomDouble$fIsValueInt64 $fIsAtomInt64$fIsValueInt32 $fIsAtomInt32$fIsValueInt16 $fIsAtomInt16$fIsValueWord64$fIsAtomWord64$fIsValueWord32$fIsAtomWord32$fIsValueWord16$fIsAtomWord16$fIsValueWord8 $fIsAtomWord8 $fIsValueBool $fIsAtomBool$fIsVariantInterfaceName$fIsStringInterfaceName$fIsVariantMemberName$fIsStringMemberName$fIsVariantErrorName$fIsStringErrorName$fIsVariantBusName$fIsStringBusName$fIsVariantStructure$fShowStructure$fIsVariantArray $fEqArray $fShowArray$fIsVariantDictionary$fShowDictionary$fIsVariantSerial$fEqType $fOrdType $fGenericType $fEqSignature$fOrdSignature$fNFDataSignature$fShowSigParseError$fEqObjectPath$fOrdObjectPath$fShowObjectPath$fNFDataObjectPath $fShowAtom$fEqAtom $fOrdAtom $fShowValue $fEqVariant$fEqInterfaceName$fOrdInterfaceName$fShowInterfaceName$fNFDataInterfaceName$fEqMemberName$fOrdMemberName$fShowMemberName$fNFDataMemberName $fEqErrorName$fOrdErrorName$fShowErrorName$fNFDataErrorName $fEqBusName $fOrdBusName $fShowBusName$fNFDataBusName $fEqStructure$fEqDictionary $fEqSerial $fOrdSerial $fShowSerial$fLiftMemberName$fLiftInterfaceName$fLiftObjectPath $fLiftBusNameReceivedMessageReceivedMethodCallReceivedMethodReturnReceivedMethodErrorReceivedSignalReceivedUnknownSignal signalPathsignalInterface signalMember signalSendersignalDestination signalBody MethodErrormethodErrorNamemethodErrorSerialmethodErrorSendermethodErrorDestinationmethodErrorBody MethodReturnmethodReturnSerialmethodReturnSendermethodReturnDestinationmethodReturnBody MethodCallmethodCallPathmethodCallInterfacemethodCallMembermethodCallSendermethodCallDestinationmethodCallReplyExpectedmethodCallAutoStartmethodCallBody HeaderField HeaderPathHeaderInterface HeaderMemberHeaderErrorNameHeaderReplySerialHeaderDestination HeaderSenderHeaderSignature HeaderUnixFdsUnknownMessageunknownMessageTypeunknownMessageSenderunknownMessageBodyMessagemessageTypeCodemessageHeaderFields messageBody messageFlagssetMethodCallFlagsmethodErrorMessage$fMessageMethodCall$fMessageMethodReturn$fMessageMethodError$fMessageSignal$fShowUnknownMessage$fEqUnknownMessage$fShowHeaderField$fEqHeaderField$fEqMethodCall$fShowMethodCall$fShowMethodReturn$fEqMethodReturn$fShowMethodError$fEqMethodError $fShowSignal $fEqSignal$fShowReceivedMessage$fEqReceivedMessageUnmarshalError MarshalError Endianness LittleEndian BigEndianmarshalErrorMessageunmarshalErrorMessagemarshalMessageunmarshalMessageMunmarshalMessage $fMonadWire$fApplicativeWire $fFunctorWire $fMonadErrorM$fApplicativeErrorM$fFunctorErrorM $fMonadErrorT$fApplicativeErrorT$fFunctorErrorT$fShowEndianness$fEqEndianness$fShowMarshalError$fEqMarshalError$fShowUnmarshalError$fEqUnmarshalErrorUUID methodCall methodReturn methodErrorsignalreceivedMessageSerialreceivedMessageSenderreceivedMessageBodymarshal unmarshal formatUUID randomUUID$fEqUUID $fOrdUUID $fShowUUIDProperty propertyName propertyType propertyRead propertyWrite SignalArg signalArgName signalArgType signalName signalArgs DirectionInOut MethodArg methodArgName methodArgTypemethodArgDirectionMethod methodName methodArgs Interface interfaceNameinterfaceMethodsinterfaceSignalsinterfacePropertiesObject objectPathobjectInterfacesobjectChildren$fShowDirection $fEqDirection$fShowMethodArg $fEqMethodArg $fShowMethod $fEqMethod$fShowSignalArg $fEqSignalArg$fShowProperty $fEqProperty$fShowInterface $fEqInterface $fShowObject $fEqObject formatXML$fPrimMonadRender$fMonadThrowRender $fMonadRender$fApplicativeRender$fFunctorRenderparseXMLSocketTransportTransportListenTransportListenertransportListentransportAccepttransportListenerClosetransportListenerAddresstransportListenerUUID TransportOpen transportOpen TransportTransportOptionstransportDefaultOptions transportPut transportGettransportCloseTransportErrortransportErrorMessagetransportErrorAddresstransportErrorsocketTransportCredentials$fExceptionTransportError $fTransportListenSocketTransport$fTransportOpenSocketTransport$fTransportSocketTransport$fEqTransportError$fShowTransportErrorSocketListener SocketOptionssocketAuthenticatorsocketTransportOptions AuthenticatorauthenticatorClientauthenticatorServerSocket SocketErrorsocketErrorMessagesocketErrorFatalsocketErrorAddress socketErrordefaultSocketOptionsopenopenWithlisten listenWithacceptclose closeListenersocketListenerAddresssendreceive authenticator$fExceptionSocketError$fTransportSomeTransport$fEqSocketError$fShowSocketErrorPathInfo_pathInterfaces _pathChildrenReply ReplyReturn ReplyErrorpropertyGetterpropertySetter inSignature outSignature methodHandler SignalHandler ClientOptionsclientSocketOptionsclientThreadRunnerDBusRClient clientSocketclientPendingCallsclientSignalHandlers clientObjectsclientThreadIDclientInterfaces ClientErrorclientErrorMessageclientErrorFatal clientErrordefaultInterface$fExceptionClientError $fEqPathInfo$fEqClientError$fShowClientError AutoMethod MatchRule matchSendermatchDestination matchPathmatchInterface matchMembermatchPathNamespaceReleaseNameReply NameReleasedNameNonExistent NameNotOwnerUnknownReleaseNameReplyRequestNameReplyNamePrimaryOwner NameInQueue NameExistsNameAlreadyOwnerUnknownRequestNameReplyRequestNameFlag pathChildrenpathInterfacespathLensfindPath connectSystemconnectSessionconnectStarterconnect connectWithbuildPropertiesInterfacebuildIntrospectableInterfacedefaultClientOptions disconnectnameAllowReplacementnameReplaceExistingnameDoNotQueue requestName releaseNamecallcall_ callNoReply getPropertygetPropertyValue setPropertysetPropertyValuegetAllPropertiesgetAllPropertiesMapaddMatch removeMatchemitformatMatchRulematchAny throwError autoMethodautoMethodWithMsg autoPropertyreadOnlyProperty makeMethodexportunexportbuildIntrospectionObjectbuildIntrospectionInterfacebuildIntrospectionPropertybuildIntrospectionMethod errorFailederrorUnknownMethoderrorInvalidParametersdbusNamedbusPath$fShowMatchRule$fExceptionMethodExc$fAutoMethod->$fAutoMethodReaderT$fAutoMethodIO$fAutoMethodReaderT0$fAutoMethodIO0$fEqRequestNameFlag$fShowRequestNameFlag$fEqRequestNameReply$fShowRequestNameReply$fEqReleaseNameReply$fShowReleaseNameReply$fShowMethodExc $fEqMethodExcGenerationParams genBusName genObjectPathgenInterfaceNamegenTakeSignalErrorHandler getTHTypeClientBusPathR dbusInvoke???/?defaultGetDictTypedefaultGetTHTypebuildGetTHType newNameDefdefaultGenerationParams addTypeArg addTypeArgIf unitIOTypeaddArgIfmkFunDgenerateClient maybeNamemakeToVariantAppmakeFromVariantAppmakeJustPattern mapOrHead runGetFirstbuildGeneratedSignaturegetSetMethodCallParamsclientArgumentUnpackingMessageclientArgumentUnpackingErrorgenerateClientMethodgenerateClientPropertygenerateSignalsFromInterfacegenerateSignalsgenerateSignalgenerateFromFilePathsignalForPropertiesChangedemitPropertiesChangedmakeHandlerForPropertiesChangedregisterForPropertiesChangedsignalForNameOwnerChangedemitNameOwnerChangedmakeHandlerForNameOwnerChangedregisterForNameOwnerChangedsignalForNameLost emitNameLostmakeHandlerForNameLostregisterForNameLostsignalForNameAcquiredemitNameAcquiredmakeHandlerForNameAcquiredregisterForNameAcquiredhelloMethodCallhellorequestNameMethodCallreleaseNameMethodCallstartServiceByNameMethodCallstartServiceByName%updateActivationEnvironmentMethodCallupdateActivationEnvironmentnameHasOwnerMethodCall nameHasOwnerlistNamesMethodCall listNameslistActivatableNamesMethodCalllistActivatableNamesaddMatchMethodCallremoveMatchMethodCallgetNameOwnerMethodCall getNameOwnerlistQueuedOwnersMethodCalllistQueuedOwnersgetConnectionUnixUserMethodCallgetConnectionUnixUser$getConnectionUnixProcessIDMethodCallgetConnectionUnixProcessID getAdtAuditSessionDataMethodCallgetAdtAuditSessionData-getConnectionSELinuxSecurityContextMethodCall#getConnectionSELinuxSecurityContextreloadConfigMethodCall reloadConfiggetIdMethodCallgetId"getConnectionCredentialsMethodCallgetConnectionCredentialsmethodCallForFeatures getFeaturesmethodCallForInterfaces getInterfacesbase GHC.MaybeNothingbytestring-0.10.8.2Data.ByteString.Internal ByteStringsocketTransportOptionBacklog&network-3.1.0.0-DH2jfvb4nAO8RR4tKibx4BNetwork.Socket.UnixgetPeerCredential authExternaldropEnd readUntil Control.MonadforeverclientBuildInterfaces DoNotQueueGHC.IOthrowIO