h*      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                 1.3.4 Safe-Inferred 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  parameters, 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  . dbusConvert 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.dbus7Returns the first address in the environment variable DBUS_SESSION_BUS_ADDRESS, which must be set.Returns  if DBUS_SYSTEM_BUS_ADDRESS! contains an invalid address or DBUS_SESSION_BUS_ADDRESS is unset XDG_RUNTIME_DIR doesn't have /bus.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.   Safe-Inferred <'dbusA value used to uniquely identify a particular message within a session. Serials are 32-bit unsigned integers, and eventually wrap.dbusA 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 E 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 A.dbusA 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 E 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 A.dbusA D-Bus Structure is a container type similar to Haskell tuples, storing values of any type that is convertable to E,. A Structure may contain up to 255 values.Most users can use the E 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.dbusBus names are used to identify particular clients on the message bus. A bus name may be either unique or  well-known, where unique names start with a colon. Bus names consist of alphanumeric characters separated by periods.See  http://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  http://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  http://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  http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-interface for details.%dbusObject paths are special strings, used to identify a particular object exported from a D-Bus application.Object 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.<dbusVariants may contain any other built-in D-Bus value. Besides representing native VARIANT 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 > because this could allow dictionaries to be created with invalid keys.AdbusValue types can be used as items in containers, such as lists or dictionaries.'Users may not provide new instances of A because this could allow containers to be created with items of heterogenous types.JdbusA signature is a list of D-Bus types, obeying some basic rules of validity.2The rules of signature validity are complex: see  http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-signatures for details._dbus5Get the list of types in a signature. The inverse of b.`dbus=Convert a signature into a signature string. The inverse of d.bdbus/Convert a list of types into a valid signature.4Throws if the given types are not a valid signature.cdbus/Convert a list of types into a valid signature.Throws an exception if the given types are not a valid signature.ddbus0Parse a signature string into a valid signature.4Throws if the given string is not a valid signature.pdbusEvery 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 . !"#$%&'43210/.-,+*)(5;:9867<=>@?ADBCEFGHIJKL]\[ZYXWVUTSRQPONM^_`abcdefghijklmnopqrstuvwxyz{|}~L]\[ZYXWVUTSRQPONM^JK_`abcdefgHIhijkEFGADBC>@?<=5;:9867'43210/.-,+*)(lmnopqrstu%&vwxyz{#$|}~!"  Safe-Inferred<dbusNot 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.dbusSignals are broadcast by applications to notify other clients of some event.dbus0The path of the object that emitted this signal.dbus*The interface that this signal belongs to.dbusThe name of this signal.dbus5The 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.dbus6The name of the application to emit the signal to. If Nothing, the signal is sent to any application that has registered an appropriate match rule. Defaults to Nothing.dbusAdditional information about the signal, such as the new value or the time. Defaults to [].dbusA method error is a reply to a method call, indicating that the call received an error and did not succeed.dbusThe name of the error type. Names are used so clients can handle certain classes of error differently from others.dbusThe 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.DBus. For peer-peer connections, the destination can be empty because there is only one peer. Defaults to Nothing.dbusAdditional information about the error. By convention, if the error body contains any items, the first item should be a string describing the error.dbusA method return is a reply to a method call, indicating that the call succeeded.dbusThe 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.DBus. For peer-peer connections, the destination can be empty because there is only one peer. Defaults to Nothing.dbus*Values returned from the method call. See F. Defaults to [].dbusA 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.dbusThe 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.dbusThe 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.dbusThe method name of the method call. Method names are unique within an interface, but might not be unique within an object.dbus0The 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.dbus0The 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.DBus. For peer-peer connections, the destination can be empty because there is only one peer. Defaults to Nothing.dbusSet whether a reply is expected. This can save network and cpu resources by inhibiting unnecessary replies. Defaults to True.dbus0Set whether the bus should auto-start the remote Defaults to True.dbus&The arguments to the method call. See F. Defaults to [].dbusGet a human-readable description of the error, by returning the first item in the error body if it's a string.;; Safe-Inferred>   Safe-InferredIdbusA 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.D-Bus UUIDs are not the same as the RFC-standardized UUIDs or GUIDs.dbusDeprecated. 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 - for the given object, interface, and method.Use fields such as  and  to populate a . {-# LANGUAGE OverloadedStrings #-} methodCall "/" "org.example.Math" "Add" { ' = Just "org.example.Calculator" ,  = [F (1 :: Int32), F (2 :: Int32)] } dbusConstruct a new 3, in reply to a method call with the given serial.Use fields such as  to populate a .dbusConstruct a new 3, in reply to a method call with the given serial.Use fields such as  to populate a .dbusConstruct a new 2 for the given object, interface, and signal name.Use fields such as  to populate a .dbusAJLMNOPQRSTUVWXYZ[\]bc_`d%zxy#~|}! AJLMNOPQRSTUVWXYZ[\]bc_`d%zxy#~|}!  Safe-InferredKc%% Safe-Inferred "%&6L- Safe-Inferred"LX Safe-InferredL'  Safe-Inferred7Widbus-Supports connecting over Unix or TCP sockets.Unix sockets are similar to pipes, but exist as special files in the filesystem. On Linux, abstract sockets 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.dbusBegin 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  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.dbusOpen 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.dbusAdditional 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.dbusSend a . and Unix file descriptors 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.dbus Receive a  of the given size from the transport, plus any Unix file descriptors that arrive with the byte data. 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.dbusClose an open transport, and release any associated resources or handles.dbus3Thrown from transport methods when an error occurs.dbusReturns the processID, userID, and groupID of the socket's peer.See .dbus(Copied from Network.Socket.ByteString.IOdbusSpecial decode function to handle > 1 Fd. Should be able to replace with a function from the network package in future (https:/ github.comhaskellnetwork issues/566)  Safe-Inferred7gdbus 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.dbusOptions 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 transportsdbusAn Authenticator defines how the local peer (client) authenticates itself to the remote peer (server).dbus1Defines the client-side half of an authenticator.dbusDefines the server-side half of an authenticator. The UUID is allocated by the socket listener.dbusAn open socket to another process. Messages can be sent to the remote peer using , or received using .dbusStores information about an error encountered while creating or using a .dbusDefault , which uses the default Unix/TCP transport and authenticator (without support for Unix file descriptor passing).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 . 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  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  to stop listening, and to free underlying transport resources such as file descriptors.This 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 . Once closed, the socket is no longer valid and must not be used.dbusClose an open . 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.dbusReceive 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. myAuthenticator :: Authenticator MyTransport myAuthenticator = authenticator {  = clientMyAuth ,  = serverMyAuth } clientMyAuth :: MyTransport -> IO Bool serverMyAuth :: MyTransport -> String -> IO Bool dbus+An authenticator that implements the D-Bus EXTERNAL mechanism, which uses credential passing over a Unix socket, with support for Unix file descriptor passing.dbusImplements the D-Bus EXTERNAL mechanism, which uses credential passing over a Unix socket, optionally supporting Unix file descriptor passing.dbusDrop n items from the end of a listdbusRead values from a monad until a guard value is read; return all values, including the guard.  Safe-Inferred")*71dbusOptions for the underlying socket, for advanced use cases. See the  DBus.Socket module.dbusA 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  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.dbusAn active client session to a message bus. Clients may send or receive method calls, and listen for or emit signals.dbusUsed to automatically generate method signatures for introspection documents. To support automatic signatures, a method's parameters and return value must all be instances of A.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 E. For these cases, please use  .To match common Haskell use, if the return value is a tuple, it will be converted to a list of return values.dbusA match rule describes which signals a particular callback is interested in. Use  to construct match rules.Example: a match rule which matches signals sent by the root object. +matchFromRoot :: MatchRule matchFromRoot =  {  = Just "/" } dbus;If set, only receives signals sent from the given bus name.'The standard D-Bus implementation from  http://dbus.freedesktop.org/ almost always sets signal senders to the unique name of the sending client. If  is a requested name like "com.example.Foo" , it will not match any signals.The exception is for signals sent by the bus itself, which always have a sender of "org.freedesktop.DBus".dbus9If set, only receives signals sent to the given bus name.dbus7If set, only receives signals sent with the given path.dbusIf set, only receives signals sent with the given interface name.dbus>If set, only receives signals sent with the given member name.dbusIf set, only receives signals sent with the given path or any of its children.dbus+This client has released the provided name.dbus;The provided name is not assigned to any client on the bus.dbus1The provided name is not assigned to this client.dbusNot exported; exists to generate a compiler warning if users case on the reply and forget to include a default case.dbus;This client is now the primary owner of the requested name.dbusThe name was already reserved by another client, and replacement was either not attempted or not successful.dbus1The name was already reserved by another client,  was set, and replacement was either not attempted or not successful.dbus?This client is already the primary owner of the requested name.dbusNot 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_ADDRESS 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_ADDRESS is unset, contains an invalid address, or if connecting to the bus failed.dbus:Connect to the bus specified in the environment variable DBUS_STARTER_ADDRESS, which must be set. Throws a  if DBUS_STARTER_ADDRESS is unset, contains an invalid address, or if connecting to the bus failed.dbus,Connect to the bus at the specified address. Throws a  on failure.dbusConnect to the bus at the specified address, with the given connection options. Most users should use  instead. Throws a  on failure.dbusConnect to the bus at the specified address, with the given connection options, and return the unique client bus name. Most users should use  or  instead. Throws a  on failure.dbusDefault client options. Uses the built-in Socket-based transport, which supports the tcp: and unix: methods.dbusStop a Client'2s callback thread and close its underlying socket.dbusAllow this client's reservation to be replaced, if another client requests it with the  flag.If this client's reservation is replaced, this client will be added to the wait queue unless the request also included the  flag.dbusIf the name being requested is already reserved, attempt to replace it. This only works if the current owner provided the  flag.dbusIf the name is already in use, do not add this client to the queue, just return an error.dbusAsks 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.dbus:Release a name that this client previously requested. See ) for an explanation of name reservation. Throws a  if the call failed.dbus9Send a method call to the bus, and wait for the response. Throws a  if the method call couldn't be sent, or if the reply couldn't be parsed.dbus9Send 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 .dbus>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.dbusRetrieve a property using the method call parameters that were provided. Throws a * if the property request couldn't be sent.dbusRequest that the bus forward signals matching the given rule to this client, and process them in a callback.A received signal might be processed by more than one callback at a time. Callbacks each run in their own thread. The returned  can be passed to  to stop handling this signal. Throws a 0 if the match rule couldn't be added to the bus.dbusRequest that the bus stop forwarding signals for the given handler. Throws a 4 if the match rule couldn't be removed from the bus.dbusEquivalent to  , but does not return the added .dbusEmit the signal on the bus. Throws a ( if the signal message couldn't be sent.dbusConvert a match rule into the textual format accepted by the bus.dbusMatch any signal.dbusNormally, 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.dbusPrepare a Haskell function for export, automatically detecting the function's type signature.See 1 for details on the limitations of this function.See method1 for exporting functions with user-defined types.dbusDefine 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  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 ,  "com.example.HelloWorld" "Hello" sayHello ] } dbus Revokes the export of the given %. This will remove all interfaces and methods associated with the path.dbus Error messagedbus"Additional items of the error bodydbusInput parameter signaturedbusOutput parameter signature  Safe-Inferred"dbus8Compatibility helper to create (total) tuple expressions''44  Safe-Inferred":: !"#$$%%&&'(())**++,,--./0123456789:;<=>?@ABCCDEFGHIJKLMNNOOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!o                                                                                                                                                                                                                                                                                                         !dbus-1.3.4-5w6Hi2i8Pli6HC8wqWgvM3DBus.Internal.AddressDBus.Internal.TypesDBus.Internal.MessageDBus.Internal.WireDBusDBus.Introspection.TypesDBus.Introspection.RenderDBus.Introspection.ParseDBus.Transport DBus.Socket DBus.ClientDBus.GenerationDBus.THdbusDBus.IntrospectionmethodAddress addressMethodaddressParametersaddress validMethod validParamsoptionallyEncoded formatAddressformatAddresses parseAddressparseAddresses parsecAddressgetSystemAddressgetSessionAddressgetStarterAddresshexToIntmaybeParseString $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$fIsVariantList $fIsValueList$fIsVariantVector$fIsValueVector$fIsVariantList0$fIsVariantText$fIsVariantVariant$fIsValueVariant$fIsVariantObjectPath$fIsVariantSignature$fIsVariantText0 $fIsVariantFd$fIsVariantDouble$fIsVariantInt64$fIsVariantInt32$fIsVariantInt16$fIsVariantWord64$fIsVariantWord32$fIsVariantWord16$fIsVariantWord8$fIsVariantBool$fIsVariantMap $fIsValueMap$fIsValueList0 $fIsAtomList $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 $fEqSerial $fOrdSerial $fShowSerial$fEqDictionary $fEqStructure $fEqBusName $fOrdBusName $fShowBusName$fNFDataBusName $fEqErrorName$fOrdErrorName$fShowErrorName$fNFDataErrorName$fEqMemberName$fOrdMemberName$fShowMemberName$fNFDataMemberName$fEqInterfaceName$fOrdInterfaceName$fShowInterfaceName$fNFDataInterfaceName $fShowValue $fEqVariant $fShowAtom$fEqAtom $fOrdAtom$fEqObjectPath$fOrdObjectPath$fShowObjectPath$fNFDataObjectPath$fShowSigParseError $fEqSignature$fOrdSignature$fNFDataSignature$fEqType $fOrdType $fGenericType$fLiftBoxedRepMemberName$fLiftBoxedRepInterfaceName$fLiftBoxedRepObjectPath$fLiftBoxedRepBusNameReceivedMessageReceivedMethodCallReceivedMethodReturnReceivedMethodErrorReceivedSignalReceivedUnknownSignal signalPathsignalInterface signalMember signalSendersignalDestination signalBody MethodErrormethodErrorNamemethodErrorSerialmethodErrorSendermethodErrorDestinationmethodErrorBody MethodReturnmethodReturnSerialmethodReturnSendermethodReturnDestinationmethodReturnBody MethodCallmethodCallPathmethodCallInterfacemethodCallMembermethodCallSendermethodCallDestinationmethodCallReplyExpectedmethodCallAutoStartmethodCallBody HeaderField HeaderPathHeaderInterface HeaderMemberHeaderErrorNameHeaderReplySerialHeaderDestination HeaderSenderHeaderSignature HeaderUnixFdsUnknownMessageunknownMessageTypeunknownMessageSenderunknownMessageBodyMessagemessageTypeCodemessageHeaderFields messageBody messageFlagssetMethodCallFlagsmethodErrorMessage$fMessageMethodCall$fMessageMethodReturn$fMessageMethodError$fMessageSignal$fShowReceivedMessage$fEqReceivedMessage $fShowSignal $fEqSignal$fShowMethodError$fEqMethodError$fShowMethodReturn$fEqMethodReturn$fEqMethodCall$fShowMethodCall$fShowHeaderField$fEqHeaderField$fShowUnknownMessage$fEqUnknownMessageUnmarshalError MarshalError Endianness LittleEndian BigEndianmarshalErrorMessageunmarshalErrorMessagemarshalMessageunmarshalMessageMunmarshalMessage $fMonadWire$fApplicativeWire $fFunctorWire $fMonadErrorM$fApplicativeErrorM$fFunctorErrorM $fMonadErrorT$fApplicativeErrorT$fFunctorErrorT$fShowUnmarshalError$fEqUnmarshalError$fShowMarshalError$fEqMarshalError$fShowEndianness$fEqEndiannessUUIDtypeOf' methodCall methodReturn methodErrorsignalreceivedMessageSerialreceivedMessageSenderreceivedMessageBodymarshalmarshalWithFds unmarshalunmarshalWithFds formatUUID randomUUID$fEqUUID $fOrdUUID $fShowUUIDProperty propertyName propertyType propertyRead propertyWrite SignalArg signalArgName signalArgType signalName signalArgs DirectionInOut MethodArg methodArgName methodArgTypemethodArgDirectionMethod methodName methodArgs Interface interfaceNameinterfaceMethodsinterfaceSignalsinterfacePropertiesObject objectPathobjectInterfacesobjectChildren $fShowObject $fEqObject$fShowInterface $fEqInterface$fShowProperty $fEqProperty$fShowSignalArg $fEqSignalArg $fShowMethod $fEqMethod$fShowMethodArg $fEqMethodArg$fShowDirection $fEqDirection formatXML$fPrimMonadRender$fMonadThrowRender $fMonadRender$fApplicativeRender$fFunctorRenderparseXMLSocketTransportTransportListenTransportListenertransportListentransportAccepttransportListenerClosetransportListenerAddresstransportListenerUUID TransportOpen transportOpen TransportTransportOptionstransportDefaultOptions transportPuttransportPutWithFds transportGettransportGetWithFdstransportCloseTransportErrortransportErrorMessagetransportErrorAddresstransportErrorsocketTransportCredentials$fExceptionTransportError $fTransportListenSocketTransport$fTransportOpenSocketTransport$fTransportSocketTransport$fEqTransportError$fShowTransportErrorSocketListener SocketOptionssocketAuthenticatorsocketTransportOptions AuthenticatorauthenticatorClientauthenticatorServerSocket SocketErrorsocketErrorMessagesocketErrorFatalsocketErrorAddress socketErrordefaultSocketOptionsopenopenWithlisten listenWithacceptclose closeListenersocketListenerAddresssendreceive authenticatorauthenticatorWithUnixFds$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 connectWithconnectWithNamebuildPropertiesInterfacebuildIntrospectableInterfacedefaultClientOptions disconnectnameAllowReplacementnameReplaceExistingnameDoNotQueue requestName releaseNamecallcall_ callNoReply getPropertygetPropertyValue setPropertysetPropertyValuegetAllPropertiesgetAllPropertiesMapaddMatch removeMatchemitformatMatchRulematchAny throwError autoMethodautoMethodWithMsg autoPropertyreadOnlyProperty makeMethodexportunexportbuildIntrospectionObjectbuildIntrospectionInterfacebuildIntrospectionPropertybuildIntrospectionMethod errorFailederrorUnknownMethoderrorInvalidParametersdbusNamedbusPath$fShowMatchRule$fExceptionMethodExc$fAutoMethodFUN$fAutoMethodReaderT$fAutoMethodIO$fAutoMethodReaderT0$fAutoMethodIO0$fShowMethodExc $fEqMethodExc$fEqReleaseNameReply$fShowReleaseNameReply$fEqRequestNameReply$fShowRequestNameReply$fEqRequestNameFlag$fShowRequestNameFlagGenerationParams genBusName genObjectPathgenInterfaceNamegenTakeSignalErrorHandler getTHTypeClientBusPathRmkTupE 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.11.5.2Data.ByteString.Internal.Type ByteStringSystem.Posix.TypesFd&network-3.2.0.0-47H6oOVIBv68rlUFaUACvnNetwork.Socket.UnixgetPeerCredential waitWhen0 decodeFdCmsgsocketTransportOptionBacklog authExternaldropEnd readUntil Control.MonadforeverclientBuildInterfaces DoNotQueueGHC.IOthrowIO