diff --git a/Ldap-Asn1-Type.html b/Ldap-Asn1-Type.html index a122659..efef296 100644 --- a/Ldap-Asn1-Type.html +++ b/Ldap-Asn1-Type.html @@ -1,7 +1,7 @@ Ldap.Asn1.Type

ldap-client-0.1.0: Pure Haskell LDAP Client Library

Safe HaskellSafe
LanguageHaskell2010

Ldap.Asn1.Type

Synopsis

Documentation

data LdapMessage op Source

Message envelope. (Section 4.1.1.)

Constructors

LdapMessage 

Fields

ldapMessageId :: !Id
 
ldapMessageOp :: !op
 
ldapMessageControls :: !(Maybe Controls)
 

Instances

Eq op => Eq (LdapMessage op) Source 
Show op => Show (LdapMessage op) Source 
ToAsn1 op => ToAsn1 (LdapMessage op) Source
LDAPMessage ::= SEQUENCE {
+
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Safe HaskellSafe
LanguageHaskell2010
Ldap.Asn1.Type
Synopsis
Documentation
data LdapMessage op Source
Message envelope. (Section 4.1.1.)
Constructors
LdapMessage 
Fields
ldapMessageId :: !Id
 
ldapMessageOp :: !op
 
ldapMessageControls :: !(Maybe Controls)
 
Instances
Eq op => Eq (LdapMessage op) Source 
Show op => Show (LdapMessage op) Source 
ToAsn1 op => ToAsn1 (LdapMessage op) Source
LDAPMessage ::= SEQUENCE {
      messageID       MessageID,
      protocolOp      CHOICE {
           bindRequest           BindRequest,
@@ -100,10 +100,12 @@ window.onload = function () {pageLoad();setSynopsis("mini_Ldap-Asn1-Type.html");
 
IntermediateResponse ::= [APPLICATION 25] SEQUENCE {
      responseName     [0] LDAPOID OPTIONAL,
      responseValue    [1] OCTET STRING OPTIONAL }
-
newtype AuthenticationChoice Source
Constructors
Simple ByteString 
Instances
newtype AuthenticationChoice Source
Not really a choice until SASL is supported.
Constructors
Simple ByteString 
Instances
Eq AuthenticationChoice Source 
Show AuthenticationChoice Source 
ToAsn1 AuthenticationChoice Source
AuthenticationChoice ::= CHOICE {
      simple                  [0] OCTET STRING,
      ...  }
-
data Scope Source
Constructors
BaseObject 
SingleLevel 
WholeSubtree 
Instances
data DerefAliases Source
Constructors
NeverDerefAliases 
DerefInSearching 
DerefFindingBaseObject 
DerefAlways 
Instances
data Filter Source
Constructors
And (NonEmpty Filter) 
Or (NonEmpty Filter) 
Not Filter 
EqualityMatch AttributeValueAssertion 
Substrings SubstringFilter 
GreaterOrEqual AttributeValueAssertion 
LessOrEqual AttributeValueAssertion 
Present AttributeDescription 
ApproxMatch AttributeValueAssertion 
ExtensibleMatch MatchingRuleAssertion 
Instances
data Scope Source
Scope of the search to be performed.
Constructors
BaseObject
Constrained to the entry named by baseObject.
SingleLevel
Constrained to the immediate subordinates of the entry named by baseObject.
WholeSubtree
Constrained to the entry named by baseObject and to all its subordinates.
Instances
data DerefAliases Source
An indicator as to whether or not alias entries (as defined in
+ [RFC4512]) are to be dereferenced during stages of the Search
+ operation.
Constructors
NeverDerefAliases
Do not dereference aliases in searching or in locating the base object of the Search.
DerefInSearching
While searching subordinates of the base object, dereference any alias within the search scope.
DerefFindingBaseObject
Dereference aliases in locating the base object of the Search.
DerefAlways
Dereference aliases both in searching and in locating the base object of the Search.
Instances
data Filter Source
Conditions that must be fulfilled in order for the Search to match a given entry.
Constructors
And !(NonEmpty Filter)
All filters evaluate to TRUE
Or !(NonEmpty Filter)
Any filter evaluates to TRUE
Not Filter
Filter evaluates to FALSE
EqualityMatch AttributeValueAssertion
EQUALITY rule returns TRUE
Substrings SubstringFilter
SUBSTR rule returns TRUE
GreaterOrEqual AttributeValueAssertion
ORDERING rule returns FALSE
LessOrEqual AttributeValueAssertion
ORDERING or EQUALITY rule returns TRUE
Present AttributeDescription
Attribute is present in the entry
ApproxMatch AttributeValueAssertion
Same as EqualityMatch for most servers
ExtensibleMatch MatchingRuleAssertion 
Instances
Eq Filter Source 
Show Filter Source 
ToAsn1 Filter Source
Filter ::= CHOICE {
      and             [0] SET SIZE (1..MAX) OF filter Filter,
      or              [1] SET SIZE (1..MAX) OF filter Filter,
      not             [2] Filter,
@@ -115,14 +117,14 @@ window.onload = function () {pageLoad();setSynopsis("mini_Ldap-Asn1-Type.html");
      approxMatch     [8] AttributeValueAssertion,
      extensibleMatch [9] MatchingRuleAssertion,
      ...  }
-
data SubstringFilter Source
Constructors
SubstringFilter AttributeDescription (NonEmpty Substring) 
Instances
data SubstringFilter Source
Constructors
SubstringFilter !AttributeDescription !(NonEmpty Substring) 
Instances
Eq SubstringFilter Source 
Show SubstringFilter Source 
ToAsn1 SubstringFilter Source
SubstringFilter ::= SEQUENCE {
      type           AttributeDescription,
      substrings     SEQUENCE SIZE (1..MAX) OF substring CHOICE {
           initial [0] AssertionValue,  -- can occur at most once
           any     [1] AssertionValue,
           final   [2] AssertionValue } -- can occur at most once
      }
-
data Substring Source
Constructors
Initial AssertionValue 
Any AssertionValue 
Final AssertionValue 
Instances
data MatchingRuleAssertion Source
Constructors
MatchingRuleAssertion (Maybe MatchingRuleId) (Maybe AttributeDescription) AssertionValue Bool 
Instances
data Substring Source
Constructors
Initial !AssertionValue 
Any !AssertionValue 
Final !AssertionValue 
Instances
data MatchingRuleAssertion Source
Constructors
MatchingRuleAssertion !(Maybe MatchingRuleId) !(Maybe AttributeDescription) !AssertionValue !Bool 
Instances
Eq MatchingRuleAssertion Source 
Show MatchingRuleAssertion Source 
ToAsn1 MatchingRuleAssertion Source
MatchingRuleAssertion ::= SEQUENCE {
      matchingRule    [1] MatchingRuleId OPTIONAL,
      type            [2] AttributeDescription OPTIONAL,
      matchValue      [3] AssertionValue,
@@ -130,16 +132,16 @@ window.onload = function () {pageLoad();setSynopsis("mini_Ldap-Asn1-Type.html");
 
newtype MatchingRuleId Source
Matching rules are defined in Section 4.1.3 of [RFC4512].  A matching
  rule is identified in the protocol by the printable representation of
  either its numericoid or one of its short name descriptors
- [RFC4512], e.g., caseIgnoreMatch or '2.5.13.2'. (Section 4.1.8.)
Constructors
MatchingRuleId LdapString 
Instances
newtype AttributeSelection Source
Constructors
AttributeSelection [LdapString] 
Instances
Eq AttributeSelection Source 
Show AttributeSelection Source 
ToAsn1 AttributeSelection Source
AttributeSelection ::= SEQUENCE OF selector LDAPString
-
newtype AttributeList Source
Constructors
AttributeList [Attribute] 
Instances
Eq AttributeList Source 
Show AttributeList Source 
ToAsn1 AttributeList Source
AttributeList ::= SEQUENCE OF attribute Attribute
-
newtype PartialAttributeList Source
Constructors
PartialAttributeList [PartialAttribute] 
Instances
Eq PartialAttributeList Source 
Show PartialAttributeList Source 
FromAsn1 PartialAttributeList Source
PartialAttributeList ::= SEQUENCE OF partialAttribute PartialAttribute
-
newtype Controls Source
Constructors
Controls [Control] 
Instances
Eq Controls Source 
Show Controls Source 
ToAsn1 Controls Source
Controls ::= SEQUENCE OF control Control
-
data Control Source
Constructors
Control LdapOid Bool (Maybe ByteString) 
Instances
Eq Control Source 
Show Control Source 
ToAsn1 Control Source
Control ::= SEQUENCE {
+ [RFC4512], e.g., caseIgnoreMatch or '2.5.13.2'. (Section 4.1.8.)
Constructors
MatchingRuleId LdapString 
Instances
newtype AttributeSelection Source
Constructors
AttributeSelection [LdapString] 
Instances
Eq AttributeSelection Source 
Show AttributeSelection Source 
ToAsn1 AttributeSelection Source
AttributeSelection ::= SEQUENCE OF selector LDAPString
+
newtype AttributeList Source
Constructors
AttributeList [Attribute] 
Instances
Eq AttributeList Source 
Show AttributeList Source 
ToAsn1 AttributeList Source
AttributeList ::= SEQUENCE OF attribute Attribute
+
newtype PartialAttributeList Source
Constructors
PartialAttributeList [PartialAttribute] 
Instances
Eq PartialAttributeList Source 
Show PartialAttributeList Source 
FromAsn1 PartialAttributeList Source
PartialAttributeList ::= SEQUENCE OF partialAttribute PartialAttribute
+
newtype Controls Source
Constructors
Controls [Control] 
Instances
Eq Controls Source 
Show Controls Source 
ToAsn1 Controls Source
Controls ::= SEQUENCE OF control Control
+
data Control Source
Constructors
Control !LdapOid !Bool !(Maybe ByteString) 
Instances
Eq Control Source 
Show Control Source 
ToAsn1 Control Source
Control ::= SEQUENCE {
      controlType             LDAPOID,
      criticality             BOOLEAN DEFAULT FALSE,
      controlValue            OCTET STRING OPTIONAL }
-
data LdapResult Source
Constructors
LdapResult ResultCode LdapDn LdapString (Maybe ReferralUris) 
Instances
data LdapResult Source
Constructors
LdapResult !ResultCode !LdapDn !LdapString !(Maybe ReferralUris) 
Instances
Eq LdapResult Source 
Show LdapResult Source 
FromAsn1 LdapResult Source
LDAPResult ::= SEQUENCE {
      resultCode         ENUMERATED {
           success                      (0),
           operationsError              (1),
@@ -191,40 +193,40 @@ window.onload = function () {pageLoad();setSynopsis("mini_Ldap-Asn1-Type.html");
      matchedDN          LDAPDN,
      diagnosticMessage  LDAPString,
      referral           [3] Referral OPTIONAL }
-
data ResultCode Source
Constructors
Success 
OperationError 
ProtocolError 
TimeLimitExceeded 
SizeLimitExceeded 
CompareFalse 
CompareTrue 
AuthMethodNotSupported 
StrongerAuthRequired 
Referral 
AdminLimitExceeded 
UnavailableCriticalExtension 
ConfidentialityRequired 
SaslBindInProgress 
NoSuchAttribute 
UndefinedAttributeType 
InappropriateMatching 
ConstraintViolation 
AttributeOrValueExists 
InvalidAttributeSyntax 
NoSuchObject 
AliasProblem 
InvalidDNSyntax 
AliasDereferencingProblem 
InappropriateAuthentication 
InvalidCredentials 
InsufficientAccessRights 
Busy 
Unavailable 
UnwillingToPerform 
LoopDetect 
NamingViolation 
ObjectClassViolation 
NotAllowedOnNonLeaf 
NotAllowedOnRDN 
EntryAlreadyExists 
ObjectClassModsProhibited 
AffectsMultipleDSAs 
Other 
Instances
newtype AttributeDescription Source
Constructors
AttributeDescription LdapString 
Instances
data ResultCode Source
LDAP operation's result.
Constructors
Success 
OperationError 
ProtocolError 
TimeLimitExceeded 
SizeLimitExceeded 
CompareFalse 
CompareTrue 
AuthMethodNotSupported 
StrongerAuthRequired 
Referral 
AdminLimitExceeded 
UnavailableCriticalExtension 
ConfidentialityRequired 
SaslBindInProgress 
NoSuchAttribute 
UndefinedAttributeType 
InappropriateMatching 
ConstraintViolation 
AttributeOrValueExists 
InvalidAttributeSyntax 
NoSuchObject 
AliasProblem 
InvalidDNSyntax 
AliasDereferencingProblem 
InappropriateAuthentication 
InvalidCredentials 
InsufficientAccessRights 
Busy 
Unavailable 
UnwillingToPerform 
LoopDetect 
NamingViolation 
ObjectClassViolation 
NotAllowedOnNonLeaf 
NotAllowedOnRDN 
EntryAlreadyExists 
ObjectClassModsProhibited 
AffectsMultipleDSAs 
Other 
Instances
newtype AttributeDescription Source
Constructors
AttributeDescription LdapString 
Instances
Eq AttributeDescription Source 
Show AttributeDescription Source 
ToAsn1 AttributeDescription Source
AttributeDescription ::= LDAPString
 
FromAsn1 AttributeDescription Source
AttributeDescription ::= LDAPString
-
newtype AttributeValue Source
Constructors
AttributeValue ByteString 
Instances
newtype AttributeValue Source
Constructors
AttributeValue ByteString 
Instances
Eq AttributeValue Source 
Show AttributeValue Source 
ToAsn1 AttributeValue Source
AttributeValue ::= OCTET STRING
 
FromAsn1 AttributeValue Source
AttributeValue ::= OCTET STRING
-
data AttributeValueAssertion Source
Constructors
AttributeValueAssertion AttributeDescription AssertionValue 
Instances
data AttributeValueAssertion Source
Constructors
AttributeValueAssertion !AttributeDescription !AssertionValue 
Instances
Eq AttributeValueAssertion Source 
Show AttributeValueAssertion Source 
ToAsn1 AttributeValueAssertion Source
AttributeValueAssertion ::= SEQUENCE {
      attributeDesc   AttributeDescription,
      assertionValue  AssertionValue }
-
newtype AssertionValue Source
Constructors
AssertionValue ByteString 
Instances
data Attribute Source
Constructors
Attribute AttributeDescription (NonEmpty AttributeValue) 
Instances
Eq Attribute Source 
Show Attribute Source 
ToAsn1 Attribute Source
Attribute ::= PartialAttribute(WITH COMPONENTS {
+
newtype AssertionValue Source
Constructors
AssertionValue ByteString 
Instances
data Attribute Source
Constructors
Attribute !AttributeDescription !(NonEmpty AttributeValue) 
Instances
Eq Attribute Source 
Show Attribute Source 
ToAsn1 Attribute Source
Attribute ::= PartialAttribute(WITH COMPONENTS {
      ...,
      vals (SIZE(1..MAX))})
-
data PartialAttribute Source
Constructors
PartialAttribute AttributeDescription [AttributeValue] 
Instances
data PartialAttribute Source
Constructors
PartialAttribute !AttributeDescription ![AttributeValue] 
Instances
Eq PartialAttribute Source 
Show PartialAttribute Source 
ToAsn1 PartialAttribute Source
PartialAttribute ::= SEQUENCE {
      type       AttributeDescription,
      vals       SET OF value AttributeValue }
 
FromAsn1 PartialAttribute Source
PartialAttribute ::= SEQUENCE {
      type       AttributeDescription,
      vals       SET OF value AttributeValue }
 
newtype LdapDn Source
An LDAPDN is defined to be the representation of a Distinguished Name
- (DN) after encoding according to the specification in [RFC4514].
Constructors
LdapDn LdapString 
Instances
Eq LdapDn Source 
Show LdapDn Source 
ToAsn1 LdapDn Source
LDAPDN ::= LDAPString -- Constrained to <distinguishedName>
+ (DN) after encoding according to the specification in [RFC4514].
Constructors
LdapDn LdapString 
Instances
Eq LdapDn Source 
Show LdapDn Source 
ToAsn1 LdapDn Source
LDAPDN ::= LDAPString -- Constrained to <distinguishedName>
 
FromAsn1 LdapDn Source
LDAPDN ::= LDAPString
 
newtype RelativeLdapDn Source
A RelativeLDAPDN is defined to be the representation of a Relative
  Distinguished Name (RDN) after encoding according to the
- specification in [RFC4514].
Constructors
RelativeLdapDn LdapString 
Instances
Eq RelativeLdapDn Source 
Show RelativeLdapDn Source 
ToAsn1 RelativeLdapDn Source
RelativeLDAPDN ::= LDAPString -- Constrained to <name-component>
-
newtype ReferralUris Source
Constructors
ReferralUris (NonEmpty Uri) 
Instances
Eq ReferralUris Source 
Show ReferralUris Source 
FromAsn1 ReferralUris Source
Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI
-
newtype Uri Source
Constructors
Uri LdapString 
Instances
Eq Uri Source 
Show Uri Source 
FromAsn1 Uri Source
URI ::= LDAPString
-
data Operation Source
Constructors
Add 
Delete 
Replace 
Instances
newtype LdapString Source
The LDAPString is a notational convenience to indicate that, although
+ specification in [RFC4514].
Constructors
RelativeLdapDn LdapString 
Instances
Eq RelativeLdapDn Source 
Show RelativeLdapDn Source 
ToAsn1 RelativeLdapDn Source
RelativeLDAPDN ::= LDAPString -- Constrained to <name-component>
+
newtype ReferralUris Source
Constructors
ReferralUris (NonEmpty Uri) 
Instances
Eq ReferralUris Source 
Show ReferralUris Source 
FromAsn1 ReferralUris Source
Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI
+
newtype Uri Source
Constructors
Uri LdapString 
Instances
Eq Uri Source 
Show Uri Source 
FromAsn1 Uri Source
URI ::= LDAPString
+
data Operation Source
Constructors
Add 
Delete 
Replace 
Instances
newtype LdapString Source
The LDAPString is a notational convenience to indicate that, although
  strings of LDAPString type encode as ASN.1 OCTET STRING types, the
  [ISO10646] character set (a superset of [Unicode]) is used, encoded
- following the UTF-8 [RFC3629] algorithm. (Section 4.1.2.)
Constructors
LdapString Text 
Instances
Eq LdapString Source 
Show LdapString Source 
ToAsn1 LdapString Source
LDAPString ::= OCTET STRING -- UTF-8 encoded
+ following the UTF-8 [RFC3629] algorithm. (Section 4.1.2.)
Constructors
LdapString Text 
Instances
Eq LdapString Source 
Show LdapString Source 
ToAsn1 LdapString Source
LDAPString ::= OCTET STRING -- UTF-8 encoded
 
FromAsn1 LdapString Source
LDAPString ::= OCTET STRING -- UTF-8 encoded,
 
newtype LdapOid Source
The LDAPOID is a notational convenience to indicate that the
  permitted value of this string is a (UTF-8 encoded) dotted-decimal
  representation of an OBJECT IDENTIFIER.  Although an LDAPOID is
  encoded as an OCTET STRING, values are limited to the definition of
- <numericoid> given in Section 1.4 of [RFC4512].
Constructors
LdapOid Text 
Instances
Eq LdapOid Source 
Show LdapOid Source 
ToAsn1 LdapOid Source
LDAPOID ::= OCTET STRING -- Constrained to <numericoid>
+ <numericoid> given in Section 1.4 of [RFC4512].
Constructors
LdapOid Text 
Instances
Eq LdapOid Source 
Show LdapOid Source 
ToAsn1 LdapOid Source
LDAPOID ::= OCTET STRING -- Constrained to <numericoid>
 
FromAsn1 LdapOid Source
LDAPOID ::= OCTET STRING -- Constrained to <numericoid>
 

\ No newline at end of file
diff --git a/Ldap-Client-Bind.html b/Ldap-Client-Bind.html
index f42491d..9a8fb01 100644
--- a/Ldap-Client-Bind.html
+++ b/Ldap-Client-Bind.html
@@ -1,7 +1,7 @@
 Ldap.Client.Bind
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Safe HaskellNone
LanguageHaskell2010
Ldap.Client.Bind
Description
Bind operation.
This operation comes in four flavours:
Of those, the first one (bind) is probably the most useful for the typical usecase.
Synopsis
Documentation
bind :: Ldap -> Dn -> Password -> IO () Source
Perform the Bind operation synchronously. Raises ResponseError on failures.
bindEither :: Ldap -> Dn -> Password -> IO (Either ResponseError ()) Source
Perform the Bind operation synchronously. Returns Left e where
- e is a ResponseError on failures.
bindAsync :: Ldap -> Dn -> Password -> IO (Async ()) Source
Perform the Bind operation asynchronously. Call wait to wait
- for its completion.
bindAsyncSTM :: Ldap -> Dn -> Password -> STM (Async ()) Source
Perform the Bind operation asynchronously.
Don't wait for its completion (with waitSTM) in the
+
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Safe HaskellNone
LanguageHaskell2010
Ldap.Client.Bind
Description
Bind operation.
This operation comes in four flavours:
Of those, the first one (bind) is probably the most useful for the typical usecase.
Synopsis
Documentation
newtype Password Source
User's password.
Constructors
Password ByteString 
Instances
bind :: Ldap -> Dn -> Password -> IO () Source
Perform the Bind operation synchronously. Raises ResponseError on failures.
bindEither :: Ldap -> Dn -> Password -> IO (Either ResponseError ()) Source
Perform the Bind operation synchronously. Returns Left e where
+ e is a ResponseError on failures.
bindAsync :: Ldap -> Dn -> Password -> IO (Async ()) Source
Perform the Bind operation asynchronously. Call wait to wait
+ for its completion.
bindAsyncSTM :: Ldap -> Dn -> Password -> STM (Async ()) Source
Perform the Bind operation asynchronously.
Don't wait for its completion (with waitSTM) in the
  same transaction you've performed it in.

\ No newline at end of file
diff --git a/Ldap-Client-Extended.html b/Ldap-Client-Extended.html
index e30031b..2fccba2 100644
--- a/Ldap-Client-Extended.html
+++ b/Ldap-Client-Extended.html
@@ -1,7 +1,7 @@
 Ldap.Client.Extended
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Safe HaskellNone
LanguageHaskell2010
Ldap.Client.Extended
Description
Extended operation.
This operation comes in four flavours:
Of those, the first one (extended) is probably the most useful for the typical usecase.
Documentation
extended :: Ldap -> Oid -> Maybe ByteString -> IO () Source
Perform the Extended operation synchronously. Raises ResponseError on failures.
extendedEither :: Ldap -> Oid -> Maybe ByteString -> IO (Either ResponseError ()) Source
Perform the Extended operation synchronously. Returns Left e where
- e is a ResponseError on failures.
extendedAsync :: Ldap -> Oid -> Maybe ByteString -> IO (Async ()) Source
Perform the Extended operation asynchronously. Call wait to wait
- for its completion.
extendedAsyncSTM :: Ldap -> Oid -> Maybe ByteString -> STM (Async ()) Source
Perform the Extended operation asynchronously.
Don't wait for its completion (with waitSTM) in the
- same transaction you've performed it in.
startTls :: Ldap -> IO () Source
startTlsEither :: Ldap -> IO (Either ResponseError ()) Source
startTlsAsync :: Ldap -> IO (Async ()) Source
startTlsAsyncSTM :: Ldap -> STM (Async ()) Source

\ No newline at end of file
+
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Safe HaskellNone
LanguageHaskell2010
Ldap.Client.Extended
Description
Extended operation.
This operation comes in four flavours:
Of those, the first one (extended) is probably the most useful for the typical usecase.
Extended Operation
newtype Oid Source
Globally unique LDAP object identifier.
Constructors
Oid Text 
Instances
extended :: Ldap -> Oid -> Maybe ByteString -> IO () Source
Perform the Extended operation synchronously. Raises ResponseError on failures.
extendedEither :: Ldap -> Oid -> Maybe ByteString -> IO (Either ResponseError ()) Source
Perform the Extended operation synchronously. Returns Left e where
+ e is a ResponseError on failures.
extendedAsync :: Ldap -> Oid -> Maybe ByteString -> IO (Async ()) Source
Perform the Extended operation asynchronously. Call wait to wait
+ for its completion.
extendedAsyncSTM :: Ldap -> Oid -> Maybe ByteString -> STM (Async ()) Source
Perform the Extended operation asynchronously.
Don't wait for its completion (with waitSTM) in the
+ same transaction you've performed it in.
StartTLS Operation
startTls :: Ldap -> IO () Source
An example of Extended Operation, cf. extended.
startTlsEither :: Ldap -> IO (Either ResponseError ()) Source
An example of Extended Operation, cf. extendedEither.
startTlsAsync :: Ldap -> IO (Async ()) Source
An example of Extended Operation, cf. extendedAsync.
startTlsAsyncSTM :: Ldap -> STM (Async ()) Source
An example of Extended Operation, cf. extendedAsyncSTM.

\ No newline at end of file
diff --git a/Ldap-Client-Internal.html b/Ldap-Client-Internal.html
index 830532a..e92d5ff 100644
--- a/Ldap-Client-Internal.html
+++ b/Ldap-Client-Internal.html
@@ -1,10 +1,15 @@
 Ldap.Client.Internal
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Safe HaskellNone
LanguageHaskell2010
Ldap.Client.Internal
Synopsis
Documentation
data Host Source
Constructors
Plain String 
Secure String 
Insecure String 
Instances
data PortNumber :: *
Instances
data Ldap Source
Constructors
Ldap 
Fields
client :: TQueue ClientMessage
 
Instances
data ClientMessage Source
Constructors
New Request (TMVar (NonEmpty ProtocolServerOp)) 
data ResultCode Source
Constructors
Success 
OperationError 
ProtocolError 
TimeLimitExceeded 
SizeLimitExceeded 
CompareFalse 
CompareTrue 
AuthMethodNotSupported 
StrongerAuthRequired 
Referral 
AdminLimitExceeded 
UnavailableCriticalExtension 
ConfidentialityRequired 
SaslBindInProgress 
NoSuchAttribute 
UndefinedAttributeType 
InappropriateMatching 
ConstraintViolation 
AttributeOrValueExists 
InvalidAttributeSyntax 
NoSuchObject 
AliasProblem 
InvalidDNSyntax 
AliasDereferencingProblem 
InappropriateAuthentication 
InvalidCredentials 
InsufficientAccessRights 
Busy 
Unavailable 
UnwillingToPerform 
LoopDetect 
NamingViolation 
ObjectClassViolation 
NotAllowedOnNonLeaf 
NotAllowedOnRDN 
EntryAlreadyExists 
ObjectClassModsProhibited 
AffectsMultipleDSAs 
Other 
Instances
data Async a Source
Instances
newtype Oid Source
Constructors
Oid Text 
Instances
type AttrList f = [(Attr, f AttrValue)] Source
Waiting for Request Completion
wait :: Async a -> IO (Either ResponseError a) Source
waitSTM :: Async a -> STM (Either ResponseError a) Source
unbindAsync :: Ldap -> IO () Source
Note that unbindAsync does not return an Async,
+
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Safe HaskellNone
LanguageHaskell2010
Ldap.Client.Internal
Synopsis
Documentation
data Host Source
LDAP host.
Constructors
Plain String
Plain LDAP. Do not use!
Insecure String
LDAP over TLS without the certificate validity check.
+   Only use for testing!
Secure String
LDAP over TLS. Use!
Instances
data PortNumber :: *
Instances
data Ldap Source
A token. All functions that interact with the Directory require one.
Constructors
Ldap 
Fields
client :: TQueue ClientMessage
 
Instances
data ClientMessage Source
Constructors
New Request (TMVar (NonEmpty ProtocolServerOp)) 
data ResultCode Source
LDAP operation's result.
Constructors
Success 
OperationError 
ProtocolError 
TimeLimitExceeded 
SizeLimitExceeded 
CompareFalse 
CompareTrue 
AuthMethodNotSupported 
StrongerAuthRequired 
Referral 
AdminLimitExceeded 
UnavailableCriticalExtension 
ConfidentialityRequired 
SaslBindInProgress 
NoSuchAttribute 
UndefinedAttributeType 
InappropriateMatching 
ConstraintViolation 
AttributeOrValueExists 
InvalidAttributeSyntax 
NoSuchObject 
AliasProblem 
InvalidDNSyntax 
AliasDereferencingProblem 
InappropriateAuthentication 
InvalidCredentials 
InsufficientAccessRights 
Busy 
Unavailable 
UnwillingToPerform 
LoopDetect 
NamingViolation 
ObjectClassViolation 
NotAllowedOnNonLeaf 
NotAllowedOnRDN 
EntryAlreadyExists 
ObjectClassModsProhibited 
AffectsMultipleDSAs 
Other 
Instances
data Async a Source
Asynchronous LDAP operation. Use wait or waitSTM to wait for its completion.
Instances
type AttrList f = [(Attr, f AttrValue)] Source
List of attributes and their values. f is the structure these
+ values are in, e.g. NonEmpty.
Waiting for Request Completion
wait :: Async a -> IO (Either ResponseError a) Source
Wait for operation completion.
waitSTM :: Async a -> STM (Either ResponseError a) Source
Wait for operation completion inside STM.
Do not use this inside the same STM transaction the operation was
+ requested in! To give LDAP the chance to respond to it that transaction
+ should commit. After that, applying waitSTM to the corresponding Async
+ starts to make sense.
Misc
type Response = NonEmpty InMessage Source
data ResponseError Source
Response indicates a failed operation.
Constructors
ResponseInvalid Request Response
LDAP server did not follow the protocol, so ldap-client couldn't make sense of the response.
ResponseErrorCode Request ResultCode Dn Text
The response contains a result code indicating failure and an error message.
Instances
type Request = ProtocolClientOp Source
raise :: Exception e => Either e a -> IO a Source
sendRequest :: Ldap -> (Response -> Either ResponseError a) -> Request -> STM (Async a) Source
newtype Dn Source
Unique identifier of an LDAP entry.
Constructors
Dn Text 
Instances
newtype Attr Source
Attribute name.
Constructors
Attr Text 
Instances
type AttrValue = ByteString Source
Attribute value.
unAttr :: Attr -> Text Source
Unbind operation
unbindAsync :: Ldap -> IO () Source
Terminate the connection to the Directory.
Note that unbindAsync does not return an Async,
  because LDAP server never responds to UnbindRequests, hence
  a call to wait on a hypothetical Async would have resulted
- in an exception anyway.
unbindAsyncSTM :: Ldap -> STM () Source
Note that unbindAsyncSTM does not return an Async,
+ in an exception anyway.
unbindAsyncSTM :: Ldap -> STM () Source
Terminate the connection to the Directory.
Note that unbindAsyncSTM does not return an Async,
  because LDAP server never responds to UnbindRequests, hence
  a call to wait on a hypothetical Async would have resulted
- in an exception anyway.
Misc
type Response = NonEmpty InMessage Source
data ResponseError Source
Constructors
ResponseInvalid Request Response 
ResponseErrorCode Request ResultCode Dn Text 
Instances
type Request = ProtocolClientOp Source
raise :: Exception e => Either e a -> IO a Source
sendRequest :: Ldap -> (Response -> Either ResponseError a) -> Request -> STM (Async a) Source
newtype Dn Source
Constructors
Dn Text 
Instances
newtype RelativeDn Source
Constructors
RelativeDn Text 
Instances
newtype Password Source
Constructors
Password ByteString 
Instances
newtype Attr Source
Constructors
Attr Text 
Instances
type AttrValue = ByteString Source
unAttr :: Attr -> Text Source

\ No newline at end of file
+ in an exception anyway.

\ No newline at end of file
diff --git a/Ldap-Client-Modify.html b/Ldap-Client-Modify.html
index 7f47c6e..228acc1 100644
--- a/Ldap-Client-Modify.html
+++ b/Ldap-Client-Modify.html
@@ -4,10 +4,10 @@ window.onload = function () {pageLoad();setSynopsis("mini_Ldap-Client-Modify.htm
 
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Safe HaskellNone
LanguageHaskell2010
Ldap.Client.Modify
Description
Modify and
  Modify DN operations.
These operations come in four flavours:
Of those, the first one (modify / modifyDn) is probably the most
- useful for the typical usecase.
Documentation
data Operation Source
Type of modification being performed.
Constructors
Delete Attr [AttrValue]
Delete values from the attribute. Deletes the attribute if the list is empty or all current values are listed.
Add Attr [AttrValue]
Add values to the attribute, creating it if necessary.
Replace Attr [AttrValue]
Replace all existing values of the attribute with the new list. Deletes the attribute if the list is empty.
Instances
modify :: Ldap -> Dn -> [Operation] -> IO () Source
Perform the Modify operation synchronously. Raises ResponseError on failures.
modifyEither :: Ldap -> Dn -> [Operation] -> IO (Either ResponseError ()) Source
Perform the Modify operation synchronously. Returns Left e where
+ useful for the typical usecase.
Documentation
data Operation Source
Type of modification being performed.
Constructors
Delete Attr [AttrValue]
Delete values from the attribute. Deletes the attribute if the list is empty or all current values are listed.
Add Attr [AttrValue]
Add values to the attribute, creating it if necessary.
Replace Attr [AttrValue]
Replace all existing values of the attribute with the new list. Deletes the attribute if the list is empty.
Instances
modify :: Ldap -> Dn -> [Operation] -> IO () Source
Perform the Modify operation synchronously. Raises ResponseError on failures.
modifyEither :: Ldap -> Dn -> [Operation] -> IO (Either ResponseError ()) Source
Perform the Modify operation synchronously. Returns Left e where
  e is a ResponseError on failures.
modifyAsync :: Ldap -> Dn -> [Operation] -> IO (Async ()) Source
Perform the Modify operation asynchronously. Call wait to wait
  for its completion.
modifyAsyncSTM :: Ldap -> Dn -> [Operation] -> STM (Async ()) Source
Perform the Modify operation asynchronously.
Don't wait for its completion (with waitSTM) in the
- same transaction you've performed it in.
modifyDn :: Ldap -> Dn -> RelativeDn -> Bool -> Maybe Dn -> IO () Source
Perform the Modify DN operation synchronously. Raises ResponseError on failures.
modifyDnEither :: Ldap -> Dn -> RelativeDn -> Bool -> Maybe Dn -> IO (Either ResponseError ()) Source
Perform the Modify DN operation synchronously. Returns Left e where
- e is a ResponseError on failures.
modifyDnAsync :: Ldap -> Dn -> RelativeDn -> Bool -> Maybe Dn -> IO (Async ()) Source
Perform the Modify DN operation asynchronously. Call wait to wait
- for its completion.
modifyDnAsyncSTM :: Ldap -> Dn -> RelativeDn -> Bool -> Maybe Dn -> STM (Async ()) Source
Perform the Modify DN operation asynchronously.
Don't wait for its completion (with waitSTM) in the
+ same transaction you've performed it in.
newtype RelativeDn Source
A component of Dn.
Constructors
RelativeDn Text 
Instances
modifyDn :: Ldap -> Dn -> RelativeDn -> Bool -> Maybe Dn -> IO () Source
Perform the Modify DN operation synchronously. Raises ResponseError on failures.
modifyDnEither :: Ldap -> Dn -> RelativeDn -> Bool -> Maybe Dn -> IO (Either ResponseError ()) Source
Perform the Modify DN operation synchronously. Returns Left e where
+ e is a ResponseError on failures.
modifyDnAsync :: Ldap -> Dn -> RelativeDn -> Bool -> Maybe Dn -> IO (Async ()) Source
Perform the Modify DN operation asynchronously. Call wait to wait
+ for its completion.
modifyDnAsyncSTM :: Ldap -> Dn -> RelativeDn -> Bool -> Maybe Dn -> STM (Async ()) Source
Perform the Modify DN operation asynchronously.
Don't wait for its completion (with waitSTM) in the
  same transaction you've performed it in.

\ No newline at end of file
diff --git a/Ldap-Client-Search.html b/Ldap-Client-Search.html
index 62c9739..5452b22 100644
--- a/Ldap-Client-Search.html
+++ b/Ldap-Client-Search.html
@@ -1,7 +1,12 @@
 Ldap.Client.Search
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Safe HaskellNone
LanguageHaskell2010
Ldap.Client.Search
Description
Search operation.
This operation comes in four flavours:
Of those, the first one (search) is probably the most useful for the typical usecase.
Documentation
search :: Ldap -> Dn -> Mod Search -> Filter -> [Attr] -> IO [SearchEntry] Source
Perform the Search operation synchronously. Raises ResponseError on failures.
searchEither :: Ldap -> Dn -> Mod Search -> Filter -> [Attr] -> IO (Either ResponseError [SearchEntry]) Source
Perform the Search operation synchronously. Returns Left e where
+
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Safe HaskellNone
LanguageHaskell2010
Ldap.Client.Search
Description
Search operation.
This operation comes in four flavours:
Of those, the first one (search) is probably the most useful for the typical usecase.
Documentation
search :: Ldap -> Dn -> Mod Search -> Filter -> [Attr] -> IO [SearchEntry] Source
Perform the Search operation synchronously. Raises ResponseError on failures.
searchEither :: Ldap -> Dn -> Mod Search -> Filter -> [Attr] -> IO (Either ResponseError [SearchEntry]) Source
Perform the Search operation synchronously. Returns Left e where
  e is a ResponseError on failures.
searchAsync :: Ldap -> Dn -> Mod Search -> Filter -> [Attr] -> IO (Async [SearchEntry]) Source
Perform the Search operation asynchronously. Call wait to wait
  for its completion.
searchAsyncSTM :: Ldap -> Dn -> Mod Search -> Filter -> [Attr] -> STM (Async [SearchEntry]) Source
Perform the Search operation asynchronously.
Don't wait for its completion (with waitSTM) in the
- same transaction you've performed it in.
data Search Source
Instances
data Mod a Source
Instances
Monoid (Mod a) Source 
Semigroup (Mod a) Source 
data Scope Source
Constructors
BaseObject 
SingleLevel 
WholeSubtree 
Instances
scope :: Scope -> Mod Search Source
size :: Int32 -> Mod Search Source
time :: Int32 -> Mod Search Source
typesOnly :: Bool -> Mod Search Source
derefAliases :: DerefAliases -> Mod Search Source
data Filter Source
Constructors
Not Filter 
And (NonEmpty Filter) 
Or (NonEmpty Filter) 
Present Attr 
Attr := AttrValue 
Attr :>= AttrValue 
Attr :<= AttrValue 
Attr :~= AttrValue 
Attr :=* (Maybe AttrValue, [AttrValue], Maybe AttrValue) 
(Maybe Attr, Maybe Attr, Bool) ::= AttrValue 
data SearchEntry Source
Constructors
SearchEntry Dn (AttrList []) 
Instances

\ No newline at end of file
+ same transaction you've performed it in.
data Search Source
Search options. Use Mod to change some of those.
Instances
data Mod a Source
Search modifier. Combine using Semigroup and/or Monoid instance.
Instances
Monoid (Mod a) Source 
Semigroup (Mod a) Source 
data Scope Source
Scope of the search to be performed.
Constructors
BaseObject
Constrained to the entry named by baseObject.
SingleLevel
Constrained to the immediate subordinates of the entry named by baseObject.
WholeSubtree
Constrained to the entry named by baseObject and to all its subordinates.
Instances
scope :: Scope -> Mod Search Source
Scope of the search (default: WholeSubtree).
size :: Int32 -> Mod Search Source
Maximum number of entries to be returned as a result of the Search.
+ No limit if the value is 0 (default: 0).
time :: Int32 -> Mod Search Source
Maximum time (in seconds) allowed for the Search. No limit if the value
+ is 0 (default: 0).
typesOnly :: Bool -> Mod Search Source
Whether Search results are to contain just attribute descriptions, or
+ both attribute descriptions and values (default: False).
data DerefAliases Source
An indicator as to whether or not alias entries (as defined in
+ [RFC4512]) are to be dereferenced during stages of the Search
+ operation.
Constructors
NeverDerefAliases
Do not dereference aliases in searching or in locating the base object of the Search.
DerefInSearching
While searching subordinates of the base object, dereference any alias within the search scope.
DerefFindingBaseObject
Dereference aliases in locating the base object of the Search.
DerefAlways
Dereference aliases both in searching and in locating the base object of the Search.
Instances
derefAliases :: DerefAliases -> Mod Search Source
Alias dereference policy (default: NeverDerefAliases).
data Filter Source
Conditions that must be fulfilled in order for the Search to match a given entry.
Constructors
Not !Filter
Filter does not match the entry
And !(NonEmpty Filter)
All filters match the entry
Or !(NonEmpty Filter)
Any filter matches the entry
Present !Attr
Attribute is present in the entry
!Attr := !AttrValue
Attribute's value is equal to the assertion
!Attr :>= !AttrValue
Attribute's value is equal to or greater than the assertion
!Attr :<= !AttrValue
Attribute's value is equal to or less than the assertion
!Attr :~= !AttrValue
Attribute's value approximately matches the assertion
!Attr :=* !(Maybe AttrValue, [AttrValue], Maybe AttrValue)
Glob match
(Maybe Attr, Maybe Attr, Bool) ::= AttrValue
Extensible match
data SearchEntry Source
Entry found during the Search.
Constructors
SearchEntry !Dn !(AttrList []) 
Instances

\ No newline at end of file
diff --git a/Ldap-Client.html b/Ldap-Client.html
index 2c52051..3ef285b 100644
--- a/Ldap-Client.html
+++ b/Ldap-Client.html
@@ -1,4 +1,11 @@
 Ldap.Client
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Safe HaskellNone
LanguageHaskell2010
Ldap.Client
Synopsis
Documentation
data Host Source
Constructors
Plain String 
Secure String 
Insecure String 
Instances
data Ldap Source
Instances
data LdapError Source
Constructors
IOError IOError 
ParseError ASN1Error 
ResponseError ResponseError 
DisconnectError Disconnect 
Instances
data ResponseError Source
Constructors
ResponseInvalid Request Response 
ResponseErrorCode Request ResultCode Dn Text 
Instances
data ResultCode Source
Constructors
Success 
OperationError 
ProtocolError 
TimeLimitExceeded 
SizeLimitExceeded 
CompareFalse 
CompareTrue 
AuthMethodNotSupported 
StrongerAuthRequired 
Referral 
AdminLimitExceeded 
UnavailableCriticalExtension 
ConfidentialityRequired 
SaslBindInProgress 
NoSuchAttribute 
UndefinedAttributeType 
InappropriateMatching 
ConstraintViolation 
AttributeOrValueExists 
InvalidAttributeSyntax 
NoSuchObject 
AliasProblem 
InvalidDNSyntax 
AliasDereferencingProblem 
InappropriateAuthentication 
InvalidCredentials 
InsufficientAccessRights 
Busy 
Unavailable 
UnwillingToPerform 
LoopDetect 
NamingViolation 
ObjectClassViolation 
NotAllowedOnNonLeaf 
NotAllowedOnRDN 
EntryAlreadyExists 
ObjectClassModsProhibited 
AffectsMultipleDSAs 
Other 
Instances
data Async a Source
Instances
with :: Host -> PortNumber -> (Ldap -> IO a) -> IO (Either LdapError a) Source
The entrypoint into LDAP.
Bind
bind :: Ldap -> Dn -> Password -> IO () Source
Perform the Bind operation synchronously. Raises ResponseError on failures.
Search
search :: Ldap -> Dn -> Mod Search -> Filter -> [Attr] -> IO [SearchEntry] Source
Perform the Search operation synchronously. Raises ResponseError on failures.
data SearchEntry Source
Constructors
SearchEntry Dn (AttrList []) 
Instances
Search modifiers
data Search Source
Instances
data Mod a Source
Instances
Monoid (Mod a) Source 
Semigroup (Mod a) Source 
scope :: Scope -> Mod Search Source
data Scope Source
Constructors
BaseObject 
SingleLevel 
WholeSubtree 
Instances
size :: Int32 -> Mod Search Source
time :: Int32 -> Mod Search Source
typesOnly :: Bool -> Mod Search Source
derefAliases :: DerefAliases -> Mod Search Source
data Filter Source
Constructors
Not Filter 
And (NonEmpty Filter) 
Or (NonEmpty Filter) 
Present Attr 
Attr := AttrValue 
Attr :>= AttrValue 
Attr :<= AttrValue 
Attr :~= AttrValue 
Attr :=* (Maybe AttrValue, [AttrValue], Maybe AttrValue) 
(Maybe Attr, Maybe Attr, Bool) ::= AttrValue 
Modify
modify :: Ldap -> Dn -> [Operation] -> IO () Source
Perform the Modify operation synchronously. Raises ResponseError on failures.
data Operation Source
Type of modification being performed.
Constructors
Delete Attr [AttrValue]
Delete values from the attribute. Deletes the attribute if the list is empty or all current values are listed.
Add Attr [AttrValue]
Add values to the attribute, creating it if necessary.
Replace Attr [AttrValue]
Replace all existing values of the attribute with the new list. Deletes the attribute if the list is empty.
Instances
Add
add :: Ldap -> Dn -> AttrList NonEmpty -> IO () Source
Perform the Add operation synchronously. Raises ResponseError on failures.
Delete
delete :: Ldap -> Dn -> IO () Source
Perform the Delete operation synchronously. Raises ResponseError on failures.
ModifyDn
modifyDn :: Ldap -> Dn -> RelativeDn -> Bool -> Maybe Dn -> IO () Source
Perform the Modify DN operation synchronously. Raises ResponseError on failures.
Compare
compare :: Ldap -> Dn -> Attr -> AttrValue -> IO Bool Source
Perform the Compare operation synchronously. Raises ResponseError on failures.
Extended
extended :: Ldap -> Oid -> Maybe ByteString -> IO () Source
Perform the Extended operation synchronously. Raises ResponseError on failures.
Waiting for completion
wait :: Async a -> IO (Either ResponseError a) Source
Miscellanous
newtype Dn Source
Constructors
Dn Text 
Instances
newtype RelativeDn Source
Constructors
RelativeDn Text 
Instances
newtype Oid Source
Constructors
Oid Text 
Instances
newtype Password Source
Constructors
Password ByteString 
Instances
type AttrList f = [(Attr, f AttrValue)] Source
newtype Attr Source
Constructors
Attr Text 
Instances
type AttrValue = ByteString Source
Re-exports
data NonEmpty a :: * -> *
Instances
Monad NonEmpty 
Functor NonEmpty 
MonadFix NonEmpty 
Applicative NonEmpty 
Foldable NonEmpty 
Traversable NonEmpty 
Generic1 NonEmpty 
MonadZip NonEmpty 
IsList (NonEmpty a) 
Eq a => Eq (NonEmpty a) 
Data a => Data (NonEmpty a) 
Ord a => Ord (NonEmpty a) 
Read a => Read (NonEmpty a) 
Show a => Show (NonEmpty a) 
Generic (NonEmpty a) 
NFData a => NFData (NonEmpty a) 
Hashable a => Hashable (NonEmpty a) 
ToAsn1 a => ToAsn1 (NonEmpty a) 
Semigroup (NonEmpty a) 
type Rep1 NonEmpty = D1 D1NonEmpty (C1 C1_0NonEmpty ((:*:) (S1 NoSelector Par1) (S1 NoSelector (Rec1 [])))) 
type Rep (NonEmpty a) = D1 D1NonEmpty (C1 C1_0NonEmpty ((:*:) (S1 NoSelector (Rec0 a)) (S1 NoSelector (Rec0 [a])))) 
type Item (NonEmpty a) = a 
data PortNumber :: *
Instances

\ No newline at end of file
+
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Safe HaskellNone
LanguageHaskell2010
Ldap.Client
Description
Pure Haskell LDAP client library.
Synopsis
Documentation
data Host Source
LDAP host.
Constructors
Plain String
Plain LDAP. Do not use!
Insecure String
LDAP over TLS without the certificate validity check.
+   Only use for testing!
Secure String
LDAP over TLS. Use!
Instances
data Ldap Source
A token. All functions that interact with the Directory require one.
Instances
data LdapError Source
Various failures that can happen when working with LDAP.
Constructors
IOError IOError
Network failure.
ParseError ASN1Error
Invalid ASN.1 data received from the server.
ResponseError ResponseError
An LDAP operation failed.
DisconnectError Disconnect
Notice of Disconnection has been received.
Instances
data ResponseError Source
Response indicates a failed operation.
Constructors
ResponseInvalid Request Response
LDAP server did not follow the protocol, so ldap-client couldn't make sense of the response.
ResponseErrorCode Request ResultCode Dn Text
The response contains a result code indicating failure and an error message.
Instances
data ResultCode Source
LDAP operation's result.
Constructors
Success 
OperationError 
ProtocolError 
TimeLimitExceeded 
SizeLimitExceeded 
CompareFalse 
CompareTrue 
AuthMethodNotSupported 
StrongerAuthRequired 
Referral 
AdminLimitExceeded 
UnavailableCriticalExtension 
ConfidentialityRequired 
SaslBindInProgress 
NoSuchAttribute 
UndefinedAttributeType 
InappropriateMatching 
ConstraintViolation 
AttributeOrValueExists 
InvalidAttributeSyntax 
NoSuchObject 
AliasProblem 
InvalidDNSyntax 
AliasDereferencingProblem 
InappropriateAuthentication 
InvalidCredentials 
InsufficientAccessRights 
Busy 
Unavailable 
UnwillingToPerform 
LoopDetect 
NamingViolation 
ObjectClassViolation 
NotAllowedOnNonLeaf 
NotAllowedOnRDN 
EntryAlreadyExists 
ObjectClassModsProhibited 
AffectsMultipleDSAs 
Other 
Instances
data Async a Source
Asynchronous LDAP operation. Use wait or waitSTM to wait for its completion.
Instances
with :: Host -> PortNumber -> (Ldap -> IO a) -> IO (Either LdapError a) Source
The entrypoint into LDAP.
It catches all LDAP-related exceptions.
Bind
newtype Password Source
User's password.
Constructors
Password ByteString 
Instances
bind :: Ldap -> Dn -> Password -> IO () Source
Perform the Bind operation synchronously. Raises ResponseError on failures.
Search
search :: Ldap -> Dn -> Mod Search -> Filter -> [Attr] -> IO [SearchEntry] Source
Perform the Search operation synchronously. Raises ResponseError on failures.
data SearchEntry Source
Entry found during the Search.
Constructors
SearchEntry !Dn !(AttrList []) 
Instances
Search modifiers
data Search Source
Search options. Use Mod to change some of those.
Instances
data Mod a Source
Search modifier. Combine using Semigroup and/or Monoid instance.
Instances
Monoid (Mod a) Source 
Semigroup (Mod a) Source 
data Scope Source
Scope of the search to be performed.
Constructors
BaseObject
Constrained to the entry named by baseObject.
SingleLevel
Constrained to the immediate subordinates of the entry named by baseObject.
WholeSubtree
Constrained to the entry named by baseObject and to all its subordinates.
Instances
scope :: Scope -> Mod Search Source
Scope of the search (default: WholeSubtree).
size :: Int32 -> Mod Search Source
Maximum number of entries to be returned as a result of the Search.
+ No limit if the value is 0 (default: 0).
time :: Int32 -> Mod Search Source
Maximum time (in seconds) allowed for the Search. No limit if the value
+ is 0 (default: 0).
typesOnly :: Bool -> Mod Search Source
Whether Search results are to contain just attribute descriptions, or
+ both attribute descriptions and values (default: False).
data DerefAliases Source
An indicator as to whether or not alias entries (as defined in
+ [RFC4512]) are to be dereferenced during stages of the Search
+ operation.
Constructors
NeverDerefAliases
Do not dereference aliases in searching or in locating the base object of the Search.
DerefInSearching
While searching subordinates of the base object, dereference any alias within the search scope.
DerefFindingBaseObject
Dereference aliases in locating the base object of the Search.
DerefAlways
Dereference aliases both in searching and in locating the base object of the Search.
Instances
derefAliases :: DerefAliases -> Mod Search Source
Alias dereference policy (default: NeverDerefAliases).
data Filter Source
Conditions that must be fulfilled in order for the Search to match a given entry.
Constructors
Not !Filter
Filter does not match the entry
And !(NonEmpty Filter)
All filters match the entry
Or !(NonEmpty Filter)
Any filter matches the entry
Present !Attr
Attribute is present in the entry
!Attr := !AttrValue
Attribute's value is equal to the assertion
!Attr :>= !AttrValue
Attribute's value is equal to or greater than the assertion
!Attr :<= !AttrValue
Attribute's value is equal to or less than the assertion
!Attr :~= !AttrValue
Attribute's value approximately matches the assertion
!Attr :=* !(Maybe AttrValue, [AttrValue], Maybe AttrValue)
Glob match
(Maybe Attr, Maybe Attr, Bool) ::= AttrValue
Extensible match
Modify
modify :: Ldap -> Dn -> [Operation] -> IO () Source
Perform the Modify operation synchronously. Raises ResponseError on failures.
data Operation Source
Type of modification being performed.
Constructors
Delete Attr [AttrValue]
Delete values from the attribute. Deletes the attribute if the list is empty or all current values are listed.
Add Attr [AttrValue]
Add values to the attribute, creating it if necessary.
Replace Attr [AttrValue]
Replace all existing values of the attribute with the new list. Deletes the attribute if the list is empty.
Instances
Add
add :: Ldap -> Dn -> AttrList NonEmpty -> IO () Source
Perform the Add operation synchronously. Raises ResponseError on failures.
Delete
delete :: Ldap -> Dn -> IO () Source
Perform the Delete operation synchronously. Raises ResponseError on failures.
ModifyDn
newtype RelativeDn Source
A component of Dn.
Constructors
RelativeDn Text 
Instances
modifyDn :: Ldap -> Dn -> RelativeDn -> Bool -> Maybe Dn -> IO () Source
Perform the Modify DN operation synchronously. Raises ResponseError on failures.
Compare
compare :: Ldap -> Dn -> Attr -> AttrValue -> IO Bool Source
Perform the Compare operation synchronously. Raises ResponseError on failures.
Extended
newtype Oid Source
Globally unique LDAP object identifier.
Constructors
Oid Text 
Instances
extended :: Ldap -> Oid -> Maybe ByteString -> IO () Source
Perform the Extended operation synchronously. Raises ResponseError on failures.
Waiting for completion
wait :: Async a -> IO (Either ResponseError a) Source
Wait for operation completion.
Miscellanous
newtype Dn Source
Unique identifier of an LDAP entry.
Constructors
Dn Text 
Instances
newtype Attr Source
Attribute name.
Constructors
Attr Text 
Instances
type AttrValue = ByteString Source
Attribute value.
type AttrList f = [(Attr, f AttrValue)] Source
List of attributes and their values. f is the structure these
+ values are in, e.g. NonEmpty.
Re-exports
data NonEmpty a :: * -> *
Instances
Monad NonEmpty 
Functor NonEmpty 
MonadFix NonEmpty 
Applicative NonEmpty 
Foldable NonEmpty 
Traversable NonEmpty 
Generic1 NonEmpty 
MonadZip NonEmpty 
IsList (NonEmpty a) 
Eq a => Eq (NonEmpty a) 
Data a => Data (NonEmpty a) 
Ord a => Ord (NonEmpty a) 
Read a => Read (NonEmpty a) 
Show a => Show (NonEmpty a) 
Generic (NonEmpty a) 
NFData a => NFData (NonEmpty a) 
Hashable a => Hashable (NonEmpty a) 
ToAsn1 a => ToAsn1 (NonEmpty a) 
Semigroup (NonEmpty a) 
type Rep1 NonEmpty = D1 D1NonEmpty (C1 C1_0NonEmpty ((:*:) (S1 NoSelector Par1) (S1 NoSelector (Rec1 [])))) 
type Rep (NonEmpty a) = D1 D1NonEmpty (C1 C1_0NonEmpty ((:*:) (S1 NoSelector (Rec0 a)) (S1 NoSelector (Rec0 [a])))) 
type Item (NonEmpty a) = a 
data PortNumber :: *
Instances

\ No newline at end of file
diff --git a/doc-index-All.html b/doc-index-All.html
index 3a297d7..feb22e6 100644
--- a/doc-index-All.html
+++ b/doc-index-All.html
@@ -1,4 +1,4 @@
 ldap-client-0.1.0: Pure Haskell LDAP Client Library (Index)
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Index
::=Ldap.Client.Search, Ldap.Client
:<=Ldap.Client.Search, Ldap.Client
:=Ldap.Client.Search, Ldap.Client
:=*Ldap.Client.Search, Ldap.Client
:>=Ldap.Client.Search, Ldap.Client
:~=Ldap.Client.Search, Ldap.Client
Add 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Modify, Ldap.Client
addLdap.Client.Add, Ldap.Client
addAsyncLdap.Client.Add
addAsyncSTMLdap.Client.Add
addEitherLdap.Client.Add
AddRequestLdap.Asn1.Type
AddResponseLdap.Asn1.Type
AdminLimitExceededLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
AffectsMultipleDSAsLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
AliasDereferencingProblemLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
AliasProblemLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
And 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Search, Ldap.Client
AnyLdap.Asn1.Type
ApproxMatchLdap.Asn1.Type
AssertionValue 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
AsyncLdap.Client.Internal, Ldap.Client
Attr 
1 (Type/Class)Ldap.Client.Internal, Ldap.Client
2 (Data Constructor)Ldap.Client.Internal, Ldap.Client
Attribute 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
AttributeDescription 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
AttributeList 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
AttributeOrValueExistsLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
AttributeSelection 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
AttributeValue 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
AttributeValueAssertion 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
AttrListLdap.Client.Internal, Ldap.Client
AttrValueLdap.Client.Internal, Ldap.Client
AuthenticationChoiceLdap.Asn1.Type
AuthMethodNotSupportedLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
BaseObjectLdap.Asn1.Type, Ldap.Client.Search, Ldap.Client
bindLdap.Client.Bind, Ldap.Client
bindAsyncLdap.Client.Bind
bindAsyncSTMLdap.Client.Bind
bindEitherLdap.Client.Bind
BindRequestLdap.Asn1.Type
BindResponseLdap.Asn1.Type
BusyLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
clientLdap.Client.Internal
ClientMessageLdap.Client.Internal
compareLdap.Client.Compare, Ldap.Client
compareAsyncLdap.Client.Compare
compareAsyncSTMLdap.Client.Compare
compareEitherLdap.Client.Compare
CompareFalseLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
CompareRequestLdap.Asn1.Type
CompareResponseLdap.Asn1.Type
CompareTrueLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ConfidentialityRequiredLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ConstraintViolationLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
Control 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
Controls 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
Delete 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Modify, Ldap.Client
deleteLdap.Client.Delete, Ldap.Client
deleteAsyncLdap.Client.Delete
deleteAsyncSTMLdap.Client.Delete
deleteEitherLdap.Client.Delete
DeleteRequestLdap.Asn1.Type
DeleteResponseLdap.Asn1.Type
DerefAliasesLdap.Asn1.Type
derefAliasesLdap.Client.Search, Ldap.Client
DerefAlwaysLdap.Asn1.Type
DerefFindingBaseObjectLdap.Asn1.Type
DerefInSearchingLdap.Asn1.Type
DisconnectErrorLdap.Client
Dn 
1 (Type/Class)Ldap.Client.Internal, Ldap.Client
2 (Data Constructor)Ldap.Client.Internal, Ldap.Client
EntryAlreadyExistsLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
EqualityMatchLdap.Asn1.Type
extendedLdap.Client.Extended, Ldap.Client
extendedAsyncLdap.Client.Extended
extendedAsyncSTMLdap.Client.Extended
extendedEitherLdap.Client.Extended
ExtendedRequestLdap.Asn1.Type
ExtendedResponseLdap.Asn1.Type
ExtensibleMatchLdap.Asn1.Type
Filter 
1 (Type/Class)Ldap.Asn1.Type
2 (Type/Class)Ldap.Client.Search, Ldap.Client
FinalLdap.Asn1.Type
FromAsn1Ldap.Asn1.FromAsn1
GreaterOrEqualLdap.Asn1.Type
HostLdap.Client.Internal, Ldap.Client
Id 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
InappropriateAuthenticationLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
InappropriateMatchingLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
InitialLdap.Asn1.Type
InsecureLdap.Client.Internal, Ldap.Client
InsufficientAccessRightsLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
IntermediateResponseLdap.Asn1.Type
InvalidAttributeSyntaxLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
InvalidCredentialsLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
InvalidDNSyntaxLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
IOErrorLdap.Client
Ldap 
1 (Type/Class)Ldap.Client.Internal, Ldap.Client
2 (Data Constructor)Ldap.Client.Internal
LdapDn 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
LdapErrorLdap.Client
LdapMessage 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
ldapMessageControlsLdap.Asn1.Type
ldapMessageIdLdap.Asn1.Type
ldapMessageOpLdap.Asn1.Type
LdapOid 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
LdapResult 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
LdapString 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
LessOrEqualLdap.Asn1.Type
LoopDetectLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
MatchingRuleAssertion 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
MatchingRuleId 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
ModLdap.Client.Search, Ldap.Client
modifyLdap.Client.Modify, Ldap.Client
modifyAsyncLdap.Client.Modify
modifyAsyncSTMLdap.Client.Modify
modifyDnLdap.Client.Modify, Ldap.Client
modifyDnAsyncLdap.Client.Modify
modifyDnAsyncSTMLdap.Client.Modify
modifyDnEitherLdap.Client.Modify
ModifyDnRequestLdap.Asn1.Type
ModifyDnResponseLdap.Asn1.Type
modifyEitherLdap.Client.Modify
ModifyRequestLdap.Asn1.Type
ModifyResponseLdap.Asn1.Type
NamingViolationLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
NeverDerefAliasesLdap.Asn1.Type
NewLdap.Client.Internal
NonEmptyLdap.Client
NoSuchAttributeLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
NoSuchObjectLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
Not 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Search, Ldap.Client
NotAllowedOnNonLeafLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
NotAllowedOnRDNLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ObjectClassModsProhibitedLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ObjectClassViolationLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
Oid 
1 (Type/Class)Ldap.Client.Internal, Ldap.Client
2 (Data Constructor)Ldap.Client.Internal, Ldap.Client
Operation 
1 (Type/Class)Ldap.Asn1.Type
2 (Type/Class)Ldap.Client.Modify, Ldap.Client
OperationErrorLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
Or 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Search, Ldap.Client
OtherLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
parseAsn1Ldap.Asn1.FromAsn1
ParseErrorLdap.Client
PartialAttribute 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
PartialAttributeList 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
Password 
1 (Type/Class)Ldap.Client.Internal, Ldap.Client
2 (Data Constructor)Ldap.Client.Internal, Ldap.Client
PlainLdap.Client.Internal, Ldap.Client
PortNumberLdap.Client.Internal, Ldap.Client
Present 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Search, Ldap.Client
ProtocolClientOpLdap.Asn1.Type
ProtocolErrorLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ProtocolServerOpLdap.Asn1.Type
raiseLdap.Client.Internal
ReferralLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ReferralUris 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
RelativeDn 
1 (Type/Class)Ldap.Client.Internal, Ldap.Client
2 (Data Constructor)Ldap.Client.Internal, Ldap.Client
RelativeLdapDn 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
Replace 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Modify, Ldap.Client
RequestLdap.Client.Internal
ResponseLdap.Client.Internal
ResponseError 
1 (Type/Class)Ldap.Client.Internal, Ldap.Client
2 (Data Constructor)Ldap.Client
ResponseErrorCodeLdap.Client.Internal, Ldap.Client
ResponseInvalidLdap.Client.Internal, Ldap.Client
ResultCodeLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
SaslBindInProgressLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ScopeLdap.Asn1.Type, Ldap.Client.Search, Ldap.Client
scopeLdap.Client.Search, Ldap.Client
SearchLdap.Client.Search, Ldap.Client
searchLdap.Client.Search, Ldap.Client
searchAsyncLdap.Client.Search
searchAsyncSTMLdap.Client.Search
searchEitherLdap.Client.Search
SearchEntry 
1 (Type/Class)Ldap.Client.Search, Ldap.Client
2 (Data Constructor)Ldap.Client.Search, Ldap.Client
SearchRequestLdap.Asn1.Type
SearchResultDoneLdap.Asn1.Type
SearchResultEntryLdap.Asn1.Type
SearchResultReferenceLdap.Asn1.Type
SecureLdap.Client.Internal, Ldap.Client
sendRequestLdap.Client.Internal
SimpleLdap.Asn1.Type
SingleLevelLdap.Asn1.Type, Ldap.Client.Search, Ldap.Client
sizeLdap.Client.Search, Ldap.Client
SizeLimitExceededLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
startTlsLdap.Client.Extended
startTlsAsyncLdap.Client.Extended
startTlsAsyncSTMLdap.Client.Extended
startTlsEitherLdap.Client.Extended
StrongerAuthRequiredLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
SubstringLdap.Asn1.Type
SubstringFilter 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
SubstringsLdap.Asn1.Type
SuccessLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
timeLdap.Client.Search, Ldap.Client
TimeLimitExceededLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ToAsn1Ldap.Asn1.ToAsn1
toAsn1Ldap.Asn1.ToAsn1
typesOnlyLdap.Client.Search, Ldap.Client
unAttrLdap.Client.Internal
UnavailableLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
UnavailableCriticalExtensionLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
unbindAsyncLdap.Client.Internal
unbindAsyncSTMLdap.Client.Internal
UnbindRequestLdap.Asn1.Type
UndefinedAttributeTypeLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
unIdLdap.Asn1.Type
UnwillingToPerformLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
Uri 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
waitLdap.Client.Internal, Ldap.Client
waitSTMLdap.Client.Internal
WholeSubtreeLdap.Asn1.Type, Ldap.Client.Search, Ldap.Client
withLdap.Client

\ No newline at end of file
+
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Index
::=Ldap.Client.Search, Ldap.Client
:<=Ldap.Client.Search, Ldap.Client
:=Ldap.Client.Search, Ldap.Client
:=*Ldap.Client.Search, Ldap.Client
:>=Ldap.Client.Search, Ldap.Client
:~=Ldap.Client.Search, Ldap.Client
Add 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Modify, Ldap.Client
addLdap.Client.Add, Ldap.Client
addAsyncLdap.Client.Add
addAsyncSTMLdap.Client.Add
addEitherLdap.Client.Add
AddRequestLdap.Asn1.Type
AddResponseLdap.Asn1.Type
AdminLimitExceededLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
AffectsMultipleDSAsLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
AliasDereferencingProblemLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
AliasProblemLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
And 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Search, Ldap.Client
AnyLdap.Asn1.Type
ApproxMatchLdap.Asn1.Type
AssertionValue 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
AsyncLdap.Client.Internal, Ldap.Client
Attr 
1 (Type/Class)Ldap.Client.Internal, Ldap.Client
2 (Data Constructor)Ldap.Client.Internal, Ldap.Client
Attribute 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
AttributeDescription 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
AttributeList 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
AttributeOrValueExistsLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
AttributeSelection 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
AttributeValue 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
AttributeValueAssertion 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
AttrListLdap.Client.Internal, Ldap.Client
AttrValueLdap.Client.Internal, Ldap.Client
AuthenticationChoiceLdap.Asn1.Type
AuthMethodNotSupportedLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
BaseObjectLdap.Asn1.Type, Ldap.Client.Search, Ldap.Client
bindLdap.Client.Bind, Ldap.Client
bindAsyncLdap.Client.Bind
bindAsyncSTMLdap.Client.Bind
bindEitherLdap.Client.Bind
BindRequestLdap.Asn1.Type
BindResponseLdap.Asn1.Type
BusyLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
clientLdap.Client.Internal
ClientMessageLdap.Client.Internal
compareLdap.Client.Compare, Ldap.Client
compareAsyncLdap.Client.Compare
compareAsyncSTMLdap.Client.Compare
compareEitherLdap.Client.Compare
CompareFalseLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
CompareRequestLdap.Asn1.Type
CompareResponseLdap.Asn1.Type
CompareTrueLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ConfidentialityRequiredLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ConstraintViolationLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
Control 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
Controls 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
Delete 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Modify, Ldap.Client
deleteLdap.Client.Delete, Ldap.Client
deleteAsyncLdap.Client.Delete
deleteAsyncSTMLdap.Client.Delete
deleteEitherLdap.Client.Delete
DeleteRequestLdap.Asn1.Type
DeleteResponseLdap.Asn1.Type
DerefAliasesLdap.Asn1.Type, Ldap.Client.Search, Ldap.Client
derefAliasesLdap.Client.Search, Ldap.Client
DerefAlwaysLdap.Asn1.Type, Ldap.Client.Search, Ldap.Client
DerefFindingBaseObjectLdap.Asn1.Type, Ldap.Client.Search, Ldap.Client
DerefInSearchingLdap.Asn1.Type, Ldap.Client.Search, Ldap.Client
DisconnectErrorLdap.Client
Dn 
1 (Type/Class)Ldap.Client.Internal, Ldap.Client
2 (Data Constructor)Ldap.Client.Internal, Ldap.Client
EntryAlreadyExistsLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
EqualityMatchLdap.Asn1.Type
extendedLdap.Client.Extended, Ldap.Client
extendedAsyncLdap.Client.Extended
extendedAsyncSTMLdap.Client.Extended
extendedEitherLdap.Client.Extended
ExtendedRequestLdap.Asn1.Type
ExtendedResponseLdap.Asn1.Type
ExtensibleMatchLdap.Asn1.Type
Filter 
1 (Type/Class)Ldap.Asn1.Type
2 (Type/Class)Ldap.Client.Search, Ldap.Client
FinalLdap.Asn1.Type
FromAsn1Ldap.Asn1.FromAsn1
GreaterOrEqualLdap.Asn1.Type
HostLdap.Client.Internal, Ldap.Client
Id 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
InappropriateAuthenticationLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
InappropriateMatchingLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
InitialLdap.Asn1.Type
InsecureLdap.Client.Internal, Ldap.Client
InsufficientAccessRightsLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
IntermediateResponseLdap.Asn1.Type
InvalidAttributeSyntaxLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
InvalidCredentialsLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
InvalidDNSyntaxLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
IOErrorLdap.Client
Ldap 
1 (Type/Class)Ldap.Client.Internal, Ldap.Client
2 (Data Constructor)Ldap.Client.Internal
LdapDn 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
LdapErrorLdap.Client
LdapMessage 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
ldapMessageControlsLdap.Asn1.Type
ldapMessageIdLdap.Asn1.Type
ldapMessageOpLdap.Asn1.Type
LdapOid 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
LdapResult 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
LdapString 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
LessOrEqualLdap.Asn1.Type
LoopDetectLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
MatchingRuleAssertion 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
MatchingRuleId 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
ModLdap.Client.Search, Ldap.Client
modifyLdap.Client.Modify, Ldap.Client
modifyAsyncLdap.Client.Modify
modifyAsyncSTMLdap.Client.Modify
modifyDnLdap.Client.Modify, Ldap.Client
modifyDnAsyncLdap.Client.Modify
modifyDnAsyncSTMLdap.Client.Modify
modifyDnEitherLdap.Client.Modify
ModifyDnRequestLdap.Asn1.Type
ModifyDnResponseLdap.Asn1.Type
modifyEitherLdap.Client.Modify
ModifyRequestLdap.Asn1.Type
ModifyResponseLdap.Asn1.Type
NamingViolationLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
NeverDerefAliasesLdap.Asn1.Type, Ldap.Client.Search, Ldap.Client
NewLdap.Client.Internal
NonEmptyLdap.Client
NoSuchAttributeLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
NoSuchObjectLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
Not 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Search, Ldap.Client
NotAllowedOnNonLeafLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
NotAllowedOnRDNLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ObjectClassModsProhibitedLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ObjectClassViolationLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
Oid 
1 (Type/Class)Ldap.Client.Extended, Ldap.Client
2 (Data Constructor)Ldap.Client.Extended, Ldap.Client
Operation 
1 (Type/Class)Ldap.Asn1.Type
2 (Type/Class)Ldap.Client.Modify, Ldap.Client
OperationErrorLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
Or 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Search, Ldap.Client
OtherLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
parseAsn1Ldap.Asn1.FromAsn1
ParseErrorLdap.Client
PartialAttribute 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
PartialAttributeList 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
Password 
1 (Type/Class)Ldap.Client.Bind, Ldap.Client
2 (Data Constructor)Ldap.Client.Bind, Ldap.Client
PlainLdap.Client.Internal, Ldap.Client
PortNumberLdap.Client.Internal, Ldap.Client
Present 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Search, Ldap.Client
ProtocolClientOpLdap.Asn1.Type
ProtocolErrorLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ProtocolServerOpLdap.Asn1.Type
raiseLdap.Client.Internal
ReferralLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ReferralUris 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
RelativeDn 
1 (Type/Class)Ldap.Client.Modify, Ldap.Client
2 (Data Constructor)Ldap.Client.Modify, Ldap.Client
RelativeLdapDn 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
Replace 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Modify, Ldap.Client
RequestLdap.Client.Internal
ResponseLdap.Client.Internal
ResponseError 
1 (Type/Class)Ldap.Client.Internal, Ldap.Client
2 (Data Constructor)Ldap.Client
ResponseErrorCodeLdap.Client.Internal, Ldap.Client
ResponseInvalidLdap.Client.Internal, Ldap.Client
ResultCodeLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
SaslBindInProgressLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ScopeLdap.Asn1.Type, Ldap.Client.Search, Ldap.Client
scopeLdap.Client.Search, Ldap.Client
SearchLdap.Client.Search, Ldap.Client
searchLdap.Client.Search, Ldap.Client
searchAsyncLdap.Client.Search
searchAsyncSTMLdap.Client.Search
searchEitherLdap.Client.Search
SearchEntry 
1 (Type/Class)Ldap.Client.Search, Ldap.Client
2 (Data Constructor)Ldap.Client.Search, Ldap.Client
SearchRequestLdap.Asn1.Type
SearchResultDoneLdap.Asn1.Type
SearchResultEntryLdap.Asn1.Type
SearchResultReferenceLdap.Asn1.Type
SecureLdap.Client.Internal, Ldap.Client
sendRequestLdap.Client.Internal
SimpleLdap.Asn1.Type
SingleLevelLdap.Asn1.Type, Ldap.Client.Search, Ldap.Client
sizeLdap.Client.Search, Ldap.Client
SizeLimitExceededLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
startTlsLdap.Client.Extended
startTlsAsyncLdap.Client.Extended
startTlsAsyncSTMLdap.Client.Extended
startTlsEitherLdap.Client.Extended
StrongerAuthRequiredLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
SubstringLdap.Asn1.Type
SubstringFilter 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
SubstringsLdap.Asn1.Type
SuccessLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
timeLdap.Client.Search, Ldap.Client
TimeLimitExceededLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ToAsn1Ldap.Asn1.ToAsn1
toAsn1Ldap.Asn1.ToAsn1
typesOnlyLdap.Client.Search, Ldap.Client
unAttrLdap.Client.Internal
UnavailableLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
UnavailableCriticalExtensionLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
unbindAsyncLdap.Client.Internal
unbindAsyncSTMLdap.Client.Internal
UnbindRequestLdap.Asn1.Type
UndefinedAttributeTypeLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
unIdLdap.Asn1.Type
UnwillingToPerformLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
Uri 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
waitLdap.Client.Internal, Ldap.Client
waitSTMLdap.Client.Internal
WholeSubtreeLdap.Asn1.Type, Ldap.Client.Search, Ldap.Client
withLdap.Client

\ No newline at end of file
diff --git a/doc-index-D.html b/doc-index-D.html
index aef5395..c973edf 100644
--- a/doc-index-D.html
+++ b/doc-index-D.html
@@ -1,4 +1,4 @@
 ldap-client-0.1.0: Pure Haskell LDAP Client Library (Index - D)
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Index - D
Delete 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Modify, Ldap.Client
deleteLdap.Client.Delete, Ldap.Client
deleteAsyncLdap.Client.Delete
deleteAsyncSTMLdap.Client.Delete
deleteEitherLdap.Client.Delete
DeleteRequestLdap.Asn1.Type
DeleteResponseLdap.Asn1.Type
DerefAliasesLdap.Asn1.Type
derefAliasesLdap.Client.Search, Ldap.Client
DerefAlwaysLdap.Asn1.Type
DerefFindingBaseObjectLdap.Asn1.Type
DerefInSearchingLdap.Asn1.Type
DisconnectErrorLdap.Client
Dn 
1 (Type/Class)Ldap.Client.Internal, Ldap.Client
2 (Data Constructor)Ldap.Client.Internal, Ldap.Client

\ No newline at end of file
+
ldap-client-0.1.0: Pure Haskell LDAP Client Library

\ No newline at end of file
diff --git a/doc-index-N.html b/doc-index-N.html
index fc2f894..c775063 100644
--- a/doc-index-N.html
+++ b/doc-index-N.html
@@ -1,4 +1,4 @@
 ldap-client-0.1.0: Pure Haskell LDAP Client Library (Index - N)
ldap-client-0.1.0: Pure Haskell LDAP Client Library

\ No newline at end of file
+
ldap-client-0.1.0: Pure Haskell LDAP Client Library

\ No newline at end of file
diff --git a/doc-index-O.html b/doc-index-O.html
index 1ee8e79..734202b 100644
--- a/doc-index-O.html
+++ b/doc-index-O.html
@@ -1,4 +1,4 @@
 ldap-client-0.1.0: Pure Haskell LDAP Client Library (Index - O)
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Index - O
ObjectClassModsProhibitedLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ObjectClassViolationLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
Oid 
1 (Type/Class)Ldap.Client.Internal, Ldap.Client
2 (Data Constructor)Ldap.Client.Internal, Ldap.Client
Operation 
1 (Type/Class)Ldap.Asn1.Type
2 (Type/Class)Ldap.Client.Modify, Ldap.Client
OperationErrorLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
Or 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Search, Ldap.Client
OtherLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client

\ No newline at end of file
+
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Index - O
ObjectClassModsProhibitedLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ObjectClassViolationLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
Oid 
1 (Type/Class)Ldap.Client.Extended, Ldap.Client
2 (Data Constructor)Ldap.Client.Extended, Ldap.Client
Operation 
1 (Type/Class)Ldap.Asn1.Type
2 (Type/Class)Ldap.Client.Modify, Ldap.Client
OperationErrorLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
Or 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Search, Ldap.Client
OtherLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client

\ No newline at end of file
diff --git a/doc-index-P.html b/doc-index-P.html
index b12db76..c7d139f 100644
--- a/doc-index-P.html
+++ b/doc-index-P.html
@@ -1,4 +1,4 @@
 ldap-client-0.1.0: Pure Haskell LDAP Client Library (Index - P)
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Index - P
parseAsn1Ldap.Asn1.FromAsn1
ParseErrorLdap.Client
PartialAttribute 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
PartialAttributeList 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
Password 
1 (Type/Class)Ldap.Client.Internal, Ldap.Client
2 (Data Constructor)Ldap.Client.Internal, Ldap.Client
PlainLdap.Client.Internal, Ldap.Client
PortNumberLdap.Client.Internal, Ldap.Client
Present 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Search, Ldap.Client
ProtocolClientOpLdap.Asn1.Type
ProtocolErrorLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ProtocolServerOpLdap.Asn1.Type

\ No newline at end of file
+
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Index - P
parseAsn1Ldap.Asn1.FromAsn1
ParseErrorLdap.Client
PartialAttribute 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
PartialAttributeList 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
Password 
1 (Type/Class)Ldap.Client.Bind, Ldap.Client
2 (Data Constructor)Ldap.Client.Bind, Ldap.Client
PlainLdap.Client.Internal, Ldap.Client
PortNumberLdap.Client.Internal, Ldap.Client
Present 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Search, Ldap.Client
ProtocolClientOpLdap.Asn1.Type
ProtocolErrorLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ProtocolServerOpLdap.Asn1.Type

\ No newline at end of file
diff --git a/doc-index-R.html b/doc-index-R.html
index 80f5829..23d6779 100644
--- a/doc-index-R.html
+++ b/doc-index-R.html
@@ -1,4 +1,4 @@
 ldap-client-0.1.0: Pure Haskell LDAP Client Library (Index - R)
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Index - R
raiseLdap.Client.Internal
ReferralLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ReferralUris 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
RelativeDn 
1 (Type/Class)Ldap.Client.Internal, Ldap.Client
2 (Data Constructor)Ldap.Client.Internal, Ldap.Client
RelativeLdapDn 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
Replace 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Modify, Ldap.Client
RequestLdap.Client.Internal
ResponseLdap.Client.Internal
ResponseError 
1 (Type/Class)Ldap.Client.Internal, Ldap.Client
2 (Data Constructor)Ldap.Client
ResponseErrorCodeLdap.Client.Internal, Ldap.Client
ResponseInvalidLdap.Client.Internal, Ldap.Client
ResultCodeLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client

\ No newline at end of file
+
ldap-client-0.1.0: Pure Haskell LDAP Client Library
Index - R
raiseLdap.Client.Internal
ReferralLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client
ReferralUris 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
RelativeDn 
1 (Type/Class)Ldap.Client.Modify, Ldap.Client
2 (Data Constructor)Ldap.Client.Modify, Ldap.Client
RelativeLdapDn 
1 (Type/Class)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Asn1.Type
Replace 
1 (Data Constructor)Ldap.Asn1.Type
2 (Data Constructor)Ldap.Client.Modify, Ldap.Client
RequestLdap.Client.Internal
ResponseLdap.Client.Internal
ResponseError 
1 (Type/Class)Ldap.Client.Internal, Ldap.Client
2 (Data Constructor)Ldap.Client
ResponseErrorCodeLdap.Client.Internal, Ldap.Client
ResponseInvalidLdap.Client.Internal, Ldap.Client
ResultCodeLdap.Asn1.Type, Ldap.Client.Internal, Ldap.Client

\ No newline at end of file
diff --git a/ldap-client.haddock b/ldap-client.haddock
index da7f899..9a8f92d 100644
Binary files a/ldap-client.haddock and b/ldap-client.haddock differ
diff --git a/mini_Ldap-Client-Bind.html b/mini_Ldap-Client-Bind.html
index 834210c..196c4a7 100644
--- a/mini_Ldap-Client-Bind.html
+++ b/mini_Ldap-Client-Bind.html
@@ -1,4 +1,4 @@
 Ldap.Client.Bind
Ldap.Client.Bind

\ No newline at end of file
+
Ldap.Client.Bind

\ No newline at end of file
diff --git a/mini_Ldap-Client-Extended.html b/mini_Ldap-Client-Extended.html
index ebf2d85..023931f 100644
--- a/mini_Ldap-Client-Extended.html
+++ b/mini_Ldap-Client-Extended.html
@@ -1,4 +1,4 @@
 Ldap.Client.Extended
Ldap.Client.Extended

\ No newline at end of file
+
Ldap.Client.Extended

\ No newline at end of file
diff --git a/mini_Ldap-Client-Internal.html b/mini_Ldap-Client-Internal.html
index 510ec9f..4619814 100644
--- a/mini_Ldap-Client-Internal.html
+++ b/mini_Ldap-Client-Internal.html
@@ -1,4 +1,4 @@
 Ldap.Client.Internal
Ldap.Client.Internal
data Host
data PortNumber
data Ldap
data ClientMessage
data ResultCode
data Async a
data Oid
type AttrList f
Waiting for Request Completion
wait
waitSTM
unbindAsync
unbindAsyncSTM
Misc
type Response
data ResponseError
type Request
raise
sendRequest
data Dn
data RelativeDn
data Password
data Attr
type AttrValue
unAttr

\ No newline at end of file
+
Ldap.Client.Internal
data Host
data PortNumber
data Ldap
data ClientMessage
data ResultCode
data Async a
type AttrList f
Waiting for Request Completion
wait
waitSTM
Misc
type Response
data ResponseError
type Request
raise
sendRequest
data Dn
data Attr
type AttrValue
unAttr
Unbind operation
unbindAsync
unbindAsyncSTM

\ No newline at end of file
diff --git a/mini_Ldap-Client-Modify.html b/mini_Ldap-Client-Modify.html
index 06ccf0f..3ca044d 100644
--- a/mini_Ldap-Client-Modify.html
+++ b/mini_Ldap-Client-Modify.html
@@ -1,4 +1,4 @@
 Ldap.Client.Modify
Ldap.Client.Modify

\ No newline at end of file
+
Ldap.Client.Modify

\ No newline at end of file
diff --git a/mini_Ldap-Client-Search.html b/mini_Ldap-Client-Search.html
index 9d4bb03..d2af2f7 100644
--- a/mini_Ldap-Client-Search.html
+++ b/mini_Ldap-Client-Search.html
@@ -1,4 +1,4 @@
 Ldap.Client.Search
Ldap.Client.Search

\ No newline at end of file
+
Ldap.Client.Search

\ No newline at end of file
diff --git a/mini_Ldap-Client.html b/mini_Ldap-Client.html
index bcbb978..f6ea8c4 100644
--- a/mini_Ldap-Client.html
+++ b/mini_Ldap-Client.html
@@ -1,4 +1,4 @@
 Ldap.Client
Ldap.Client
data Host
data Ldap
data LdapError
data ResponseError
data ResultCode
data Async a
with
Bind
bind
Search
search
data SearchEntry
Search modifiers
data Search
data Mod a
scope
data Scope
size
time
typesOnly
derefAliases
data Filter
Modify
modify
data Operation
Add
add
Delete
delete
ModifyDn
modifyDn
Compare
compare
Extended
extended
Waiting for completion
wait
Miscellanous
data Dn
data RelativeDn
data Oid
data Password
type AttrList f
data Attr
type AttrValue
Re-exports
data NonEmpty a
data PortNumber

\ No newline at end of file
+
Ldap.Client
data Host
data Ldap
data LdapError
data ResponseError
data ResultCode
data Async a
with
Bind
data Password
bind
Search
search
data SearchEntry
Search modifiers
data Search
data Mod a
data Scope
scope
size
time
typesOnly
data DerefAliases
derefAliases
data Filter
Modify
modify
data Operation
Add
add
Delete
delete
ModifyDn
data RelativeDn
modifyDn
Compare
compare
Extended
data Oid
extended
Waiting for completion
wait
Miscellanous
data Dn
data Attr
type AttrValue
type AttrList f
Re-exports
data NonEmpty a
data PortNumber

\ No newline at end of file
diff --git a/src/Ldap-Asn1-Type.html b/src/Ldap-Asn1-Type.html
index 2d2cb70..899e6e8 100644
--- a/src/Ldap-Asn1-Type.html
+++ b/src/Ldap-Asn1-Type.html
@@ -56,170 +56,177 @@
   | IntermediateResponse !(Maybe LdapOid) !(Maybe ByteString)
     deriving (Show, Eq)
 
-newtype AuthenticationChoice = Simple ByteString
-    deriving (Show, Eq)
-
-data Scope =
-    BaseObject
-  | SingleLevel
-  | WholeSubtree
-    deriving (Show, Eq)
-
-data DerefAliases =
-    NeverDerefAliases
-  | DerefInSearching
-  | DerefFindingBaseObject
-  | DerefAlways
-    deriving (Show, Eq)
-
-data Filter =
-    And (NonEmpty Filter)
-  | Or (NonEmpty Filter)
-  | Not Filter
-  | EqualityMatch AttributeValueAssertion
-  | Substrings SubstringFilter
-  | GreaterOrEqual AttributeValueAssertion
-  | LessOrEqual AttributeValueAssertion
-  | Present AttributeDescription
-  | ApproxMatch AttributeValueAssertion
-  | ExtensibleMatch MatchingRuleAssertion
-    deriving (Show, Eq)
-
-data SubstringFilter = SubstringFilter AttributeDescription (NonEmpty Substring)
-    deriving (Show, Eq)
-
-data Substring =
-    Initial AssertionValue
-  | Any AssertionValue
-  | Final AssertionValue
+-- | Not really a choice until SASL is supported.
+newtype AuthenticationChoice = Simple ByteString
+    deriving (Show, Eq)
+
+-- | Scope of the search to be performed.
+data Scope =
+    BaseObject   -- ^ Constrained to the entry named by baseObject.
+  | SingleLevel  -- ^ Constrained to the immediate subordinates of the entry named by baseObject.
+  | WholeSubtree -- ^ Constrained to the entry named by baseObject and to all its subordinates.
+    deriving (Show, Eq)
+
+-- | An indicator as to whether or not alias entries (as defined in
+-- [RFC4512]) are to be dereferenced during stages of the Search
+-- operation.
+data DerefAliases =
+    NeverDerefAliases      -- ^ Do not dereference aliases in searching or in locating the base object of the Search.
+  | DerefInSearching       -- ^ While searching subordinates of the base object, dereference any alias within the search scope.
+  | DerefFindingBaseObject -- ^ Dereference aliases in locating the base object of the Search.
+  | DerefAlways            -- ^ Dereference aliases both in searching and in locating the base object of the Search.
+    deriving (Show, Eq)
+
+-- | Conditions that must be fulfilled in order for the Search to match a given entry.
+data Filter =
+    And !(NonEmpty Filter)                 -- ^ All filters evaluate to @TRUE@
+  | Or !(NonEmpty Filter)                  -- ^ Any filter evaluates to @TRUE@
+  | Not Filter                             -- ^ Filter evaluates to @FALSE@
+  | EqualityMatch AttributeValueAssertion  -- ^ @EQUALITY@ rule returns @TRUE@
+  | Substrings SubstringFilter             -- ^ @SUBSTR@ rule returns @TRUE@
+  | GreaterOrEqual AttributeValueAssertion -- ^ @ORDERING@ rule returns @FALSE@
+  | LessOrEqual AttributeValueAssertion    -- ^ @ORDERING@ or @EQUALITY@ rule returns @TRUE@
+  | Present AttributeDescription           -- ^ Attribute is present in the entry
+  | ApproxMatch AttributeValueAssertion    -- ^ Same as 'EqualityMatch' for most servers
+  | ExtensibleMatch MatchingRuleAssertion
+    deriving (Show, Eq)
+
+data SubstringFilter = SubstringFilter !AttributeDescription !(NonEmpty Substring)
     deriving (Show, Eq)
 
-data MatchingRuleAssertion = MatchingRuleAssertion (Maybe MatchingRuleId) (Maybe AttributeDescription) AssertionValue Bool
-    deriving (Show, Eq)
-
--- | Matching rules are defined in Section 4.1.3 of [RFC4512].  A matching
--- rule is identified in the protocol by the printable representation of
--- either its <numericoid> or one of its short name descriptors
--- [RFC4512], e.g., 'caseIgnoreMatch' or '2.5.13.2'. (Section 4.1.8.)
-newtype MatchingRuleId = MatchingRuleId LdapString
-    deriving (Show, Eq)
-
-newtype AttributeSelection = AttributeSelection [LdapString]
-    deriving (Show, Eq)
-
-newtype AttributeList = AttributeList [Attribute]
+data Substring =
+    Initial !AssertionValue
+  | Any !AssertionValue
+  | Final !AssertionValue
+    deriving (Show, Eq)
+
+data MatchingRuleAssertion = MatchingRuleAssertion !(Maybe MatchingRuleId) !(Maybe AttributeDescription) !AssertionValue !Bool
+    deriving (Show, Eq)
+
+-- | Matching rules are defined in Section 4.1.3 of [RFC4512].  A matching
+-- rule is identified in the protocol by the printable representation of
+-- either its <numericoid> or one of its short name descriptors
+-- [RFC4512], e.g., 'caseIgnoreMatch' or '2.5.13.2'. (Section 4.1.8.)
+newtype MatchingRuleId = MatchingRuleId LdapString
     deriving (Show, Eq)
 
-newtype PartialAttributeList = PartialAttributeList [PartialAttribute]
+newtype AttributeSelection = AttributeSelection [LdapString]
     deriving (Show, Eq)
 
-newtype Controls = Controls [Control]
+newtype AttributeList = AttributeList [Attribute]
     deriving (Show, Eq)
 
-data Control = Control LdapOid Bool (Maybe ByteString)
+newtype PartialAttributeList = PartialAttributeList [PartialAttribute]
     deriving (Show, Eq)
 
-data LdapResult = LdapResult ResultCode LdapDn LdapString (Maybe ReferralUris)
+newtype Controls = Controls [Control]
     deriving (Show, Eq)
 
-data ResultCode =
-    Success
-  | OperationError
-  | ProtocolError
-  | TimeLimitExceeded
-  | SizeLimitExceeded
-  | CompareFalse
-  | CompareTrue
-  | AuthMethodNotSupported
-  | StrongerAuthRequired
-  | Referral
-  | AdminLimitExceeded
-  | UnavailableCriticalExtension
-  | ConfidentialityRequired
-  | SaslBindInProgress
-  | NoSuchAttribute
-  | UndefinedAttributeType
-  | InappropriateMatching
-  | ConstraintViolation
-  | AttributeOrValueExists
-  | InvalidAttributeSyntax
-  | NoSuchObject
-  | AliasProblem
-  | InvalidDNSyntax
-  | AliasDereferencingProblem
-  | InappropriateAuthentication
-  | InvalidCredentials
-  | InsufficientAccessRights
-  | Busy
-  | Unavailable
-  | UnwillingToPerform
-  | LoopDetect
-  | NamingViolation
-  | ObjectClassViolation
-  | NotAllowedOnNonLeaf
-  | NotAllowedOnRDN
-  | EntryAlreadyExists
-  | ObjectClassModsProhibited
-  | AffectsMultipleDSAs
-  | Other
-    deriving (Show, Eq)
-
-newtype AttributeDescription = AttributeDescription LdapString
-    deriving (Show, Eq)
-
-newtype AttributeValue = AttributeValue ByteString
-    deriving (Show, Eq)
-
-data AttributeValueAssertion = AttributeValueAssertion AttributeDescription AssertionValue
-    deriving (Show, Eq)
-
-newtype AssertionValue = AssertionValue ByteString
-    deriving (Show, Eq)
-
-data Attribute = Attribute AttributeDescription (NonEmpty AttributeValue)
-    deriving (Show, Eq)
-
-data PartialAttribute = PartialAttribute AttributeDescription [AttributeValue]
-    deriving (Show, Eq)
-
+data Control = Control !LdapOid !Bool !(Maybe ByteString)
+    deriving (Show, Eq)
+
+data LdapResult = LdapResult !ResultCode !LdapDn !LdapString !(Maybe ReferralUris)
+    deriving (Show, Eq)
+
+-- | LDAP operation's result.
+data ResultCode =
+    Success
+  | OperationError
+  | ProtocolError
+  | TimeLimitExceeded
+  | SizeLimitExceeded
+  | CompareFalse
+  | CompareTrue
+  | AuthMethodNotSupported
+  | StrongerAuthRequired
+  | Referral
+  | AdminLimitExceeded
+  | UnavailableCriticalExtension
+  | ConfidentialityRequired
+  | SaslBindInProgress
+  | NoSuchAttribute
+  | UndefinedAttributeType
+  | InappropriateMatching
+  | ConstraintViolation
+  | AttributeOrValueExists
+  | InvalidAttributeSyntax
+  | NoSuchObject
+  | AliasProblem
+  | InvalidDNSyntax
+  | AliasDereferencingProblem
+  | InappropriateAuthentication
+  | InvalidCredentials
+  | InsufficientAccessRights
+  | Busy
+  | Unavailable
+  | UnwillingToPerform
+  | LoopDetect
+  | NamingViolation
+  | ObjectClassViolation
+  | NotAllowedOnNonLeaf
+  | NotAllowedOnRDN
+  | EntryAlreadyExists
+  | ObjectClassModsProhibited
+  | AffectsMultipleDSAs
+  | Other
+    deriving (Show, Eq)
+
+newtype AttributeDescription = AttributeDescription LdapString
+    deriving (Show, Eq)
+
+newtype AttributeValue = AttributeValue ByteString
+    deriving (Show, Eq)
+
+data AttributeValueAssertion = AttributeValueAssertion !AttributeDescription !AssertionValue
+    deriving (Show, Eq)
+
+newtype AssertionValue = AssertionValue ByteString
+    deriving (Show, Eq)
 
-
--- | An LDAPDN is defined to be the representation of a Distinguished Name
--- (DN) after encoding according to the specification in [RFC4514].
-newtype LdapDn = LdapDn LdapString
+data Attribute = Attribute !AttributeDescription !(NonEmpty AttributeValue)
+    deriving (Show, Eq)
+
+data PartialAttribute = PartialAttribute !AttributeDescription ![AttributeValue]
     deriving (Show, Eq)
 
--- | A RelativeLDAPDN is defined to be the representation of a Relative
--- Distinguished Name (RDN) after encoding according to the
--- specification in [RFC4514].
-newtype RelativeLdapDn = RelativeLdapDn LdapString
-    deriving (Show, Eq)
-
-newtype ReferralUris = ReferralUris (NonEmpty Uri)
-    deriving (Show, Eq)
-
-newtype Uri = Uri LdapString
-    deriving (Show, Eq)
-
-data Operation =
-    Add
-  | Delete
-  | Replace
-    deriving (Show, Eq)
-
--- | The LDAPString is a notational convenience to indicate that, although
--- strings of LDAPString type encode as ASN.1 OCTET STRING types, the
--- [ISO10646] character set (a superset of [Unicode]) is used, encoded
--- following the UTF-8 [RFC3629] algorithm. (Section 4.1.2.)
-newtype LdapString = LdapString Text
+
+
+-- | An LDAPDN is defined to be the representation of a Distinguished Name
+-- (DN) after encoding according to the specification in [RFC4514].
+newtype LdapDn = LdapDn LdapString
+    deriving (Show, Eq)
+
+-- | A RelativeLDAPDN is defined to be the representation of a Relative
+-- Distinguished Name (RDN) after encoding according to the
+-- specification in [RFC4514].
+newtype RelativeLdapDn = RelativeLdapDn LdapString
+    deriving (Show, Eq)
+
+newtype ReferralUris = ReferralUris (NonEmpty Uri)
+    deriving (Show, Eq)
+
+newtype Uri = Uri LdapString
+    deriving (Show, Eq)
+
+data Operation =
+    Add
+  | Delete
+  | Replace
     deriving (Show, Eq)
 
--- | The LDAPOID is a notational convenience to indicate that the
--- permitted value of this string is a (UTF-8 encoded) dotted-decimal
--- representation of an OBJECT IDENTIFIER.  Although an LDAPOID is
--- encoded as an OCTET STRING, values are limited to the definition of
--- \<numericoid\> given in Section 1.4 of [RFC4512].
-newtype LdapOid = LdapOid Text
-    deriving (Show, Eq)
+-- | The LDAPString is a notational convenience to indicate that, although
+-- strings of LDAPString type encode as ASN.1 OCTET STRING types, the
+-- [ISO10646] character set (a superset of [Unicode]) is used, encoded
+-- following the UTF-8 [RFC3629] algorithm. (Section 4.1.2.)
+newtype LdapString = LdapString Text
+    deriving (Show, Eq)
+
+-- | The LDAPOID is a notational convenience to indicate that the
+-- permitted value of this string is a (UTF-8 encoded) dotted-decimal
+-- representation of an OBJECT IDENTIFIER.  Although an LDAPOID is
+-- encoded as an OCTET STRING, values are limited to the definition of
+-- \<numericoid\> given in Section 1.4 of [RFC4512].
+newtype LdapOid = LdapOid Text
+    deriving (Show, Eq)
 

 
diff --git a/src/Ldap-Client-Bind.html b/src/Ldap-Client-Bind.html
index aed3193..f7f5cc1 100644
--- a/src/Ldap-Client-Bind.html
+++ b/src/Ldap-Client-Bind.html
@@ -21,57 +21,63 @@
 --
 -- Of those, the first one ('bind') is probably the most useful for the typical usecase.
 module Ldap.Client.Bind
-  ( bind
-  , bindEither
-  , bindAsync
-  , bindAsyncSTM
-  ) where
-
-import           Control.Monad.STM (STM, atomically)
-import           Data.List.NonEmpty (NonEmpty((:|)))
-
-import qualified Ldap.Asn1.Type as Type
-import           Ldap.Client.Internal
-
-
--- | Perform the Bind operation synchronously. Raises 'ResponseError' on failures.
-bind :: Ldap -> Dn -> Password -> IO ()
-bind l username password =
-  raise =<< bindEither l username password
-
--- | Perform the Bind operation synchronously. Returns @Left e@ where
--- @e@ is a 'ResponseError' on failures.
-bindEither :: Ldap -> Dn -> Password -> IO (Either ResponseError ())
-bindEither l username password =
-  wait =<< bindAsync l username password
+  ( Password(..)
+  , bind
+  , bindEither
+  , bindAsync
+  , bindAsyncSTM
+  ) where
+
+import           Control.Monad.STM (STM, atomically)
+import           Data.ByteString (ByteString)
+import           Data.List.NonEmpty (NonEmpty((:|)))
+
+import qualified Ldap.Asn1.Type as Type
+import           Ldap.Client.Internal
+
+
+-- | User's password.
+newtype Password = Password ByteString
+    deriving (Show, Eq)
+
+-- | Perform the Bind operation synchronously. Raises 'ResponseError' on failures.
+bind :: Ldap -> Dn -> Password -> IO ()
+bind l username password =
+  raise =<< bindEither l username password
 
--- | Perform the Bind operation asynchronously. Call 'Ldap.Client.wait' to wait
--- for its completion.
-bindAsync :: Ldap -> Dn -> Password -> IO (Async ())
-bindAsync l username password =
-  atomically (bindAsyncSTM l username password)
+-- | Perform the Bind operation synchronously. Returns @Left e@ where
+-- @e@ is a 'ResponseError' on failures.
+bindEither :: Ldap -> Dn -> Password -> IO (Either ResponseError ())
+bindEither l username password =
+  wait =<< bindAsync l username password
 
--- | Perform the Bind operation asynchronously.
---
--- Don't wait for its completion (with 'Ldap.Client.waitSTM') in the
--- same transaction you've performed it in.
-bindAsyncSTM :: Ldap -> Dn -> Password -> STM (Async ())
-bindAsyncSTM l username password =
-  let req = bindRequest username password in sendRequest l (bindResult req) req
-
-bindRequest :: Dn -> Password -> Request
-bindRequest (Dn username) (Password password) =
-  Type.BindRequest ldapVersion
-                   (Type.LdapDn (Type.LdapString username))
-                   (Type.Simple password)
- where
-  ldapVersion = 3
-
-bindResult :: Request -> Response -> Either ResponseError ()
-bindResult req (Type.BindResponse (Type.LdapResult code (Type.LdapDn (Type.LdapString dn))
-                                                        (Type.LdapString msg) _) _ :| [])
-  | Type.Success <- code = Right ()
-  | otherwise = Left (ResponseErrorCode req code (Dn dn) msg)
-bindResult req res = Left (ResponseInvalid req res)
+-- | Perform the Bind operation asynchronously. Call 'Ldap.Client.wait' to wait
+-- for its completion.
+bindAsync :: Ldap -> Dn -> Password -> IO (Async ())
+bindAsync l username password =
+  atomically (bindAsyncSTM l username password)
+
+-- | Perform the Bind operation asynchronously.
+--
+-- Don't wait for its completion (with 'Ldap.Client.waitSTM') in the
+-- same transaction you've performed it in.
+bindAsyncSTM :: Ldap -> Dn -> Password -> STM (Async ())
+bindAsyncSTM l username password =
+  let req = bindRequest username password in sendRequest l (bindResult req) req
+
+bindRequest :: Dn -> Password -> Request
+bindRequest (Dn username) (Password password) =
+  Type.BindRequest ldapVersion
+                   (Type.LdapDn (Type.LdapString username))
+                   (Type.Simple password)
+ where
+  ldapVersion = 3
+
+bindResult :: Request -> Response -> Either ResponseError ()
+bindResult req (Type.BindResponse (Type.LdapResult code (Type.LdapDn (Type.LdapString dn))
+                                                        (Type.LdapString msg) _) _ :| [])
+  | Type.Success <- code = Right ()
+  | otherwise = Left (ResponseErrorCode req code (Dn dn) msg)
+bindResult req res = Left (ResponseInvalid req res)
 
 
diff --git a/src/Ldap-Client-Extended.html b/src/Ldap-Client-Extended.html
index d41ef2d..2b5dd47 100644
--- a/src/Ldap-Client-Extended.html
+++ b/src/Ldap-Client-Extended.html
@@ -7,91 +7,105 @@
 
 
 
-
{-# LANGUAGE OverloadedStrings #-}
--- | <https://tools.ietf.org/html/rfc4511#section-4.12 Extended> operation.
---
--- This operation comes in four flavours:
---
---   * synchronous, exception throwing ('extended')
---
---   * synchronous, returning 'Either' 'ResponseError' @()@ ('extendedEither')
---
---   * asynchronous, 'IO' based ('extendedAsync')
---
---   * asynchronous, 'STM' based ('extendedAsyncSTM')
---
--- Of those, the first one ('extended') is probably the most useful for the typical usecase.
-module Ldap.Client.Extended
-  ( extended
-  , extendedEither
-  , extendedAsync
-  , extendedAsyncSTM
-  , startTls
-  , startTlsEither
-  , startTlsAsync
-  , startTlsAsyncSTM
-  ) where
-
-import           Control.Monad ((<=<))
-import           Control.Monad.STM (STM, atomically)
-import           Data.ByteString (ByteString)
-import           Data.List.NonEmpty (NonEmpty((:|)))
-
-import qualified Ldap.Asn1.Type as Type
-import           Ldap.Client.Internal
-
+
-- | <https://tools.ietf.org/html/rfc4511#section-4.12 Extended> operation.
+--
+-- This operation comes in four flavours:
+--
+--   * synchronous, exception throwing ('extended')
+--
+--   * synchronous, returning 'Either' 'ResponseError' @()@ ('extendedEither')
+--
+--   * asynchronous, 'IO' based ('extendedAsync')
+--
+--   * asynchronous, 'STM' based ('extendedAsyncSTM')
+--
+-- Of those, the first one ('extended') is probably the most useful for the typical usecase.
+module Ldap.Client.Extended
+  ( -- * Extended Operation
+    Oid(..)
+  , extended
+  , extendedEither
+  , extendedAsync
+  , extendedAsyncSTM
+    -- ** StartTLS Operation
+  , startTls
+  , startTlsEither
+  , startTlsAsync
+  , startTlsAsyncSTM
+  ) where
+
+import           Control.Monad ((<=<))
+import           Control.Monad.STM (STM, atomically)
+import           Data.ByteString (ByteString)
+import           Data.List.NonEmpty (NonEmpty((:|)))
+import           Data.String (fromString)
+import           Data.Text (Text)
 
--- | Perform the Extended operation synchronously. Raises 'ResponseError' on failures.
-extended :: Ldap -> Oid -> Maybe ByteString -> IO ()
-extended l oid mv =
-  raise =<< extendedEither l oid mv
-
--- | Perform the Extended operation synchronously. Returns @Left e@ where
--- @e@ is a 'ResponseError' on failures.
-extendedEither :: Ldap -> Oid -> Maybe ByteString -> IO (Either ResponseError ())
-extendedEither l oid mv =
-  wait =<< extendedAsync l oid mv
-
--- | Perform the Extended operation asynchronously. Call 'Ldap.Client.wait' to wait
--- for its completion.
-extendedAsync :: Ldap -> Oid -> Maybe ByteString -> IO (Async ())
-extendedAsync l oid mv =
-  atomically (extendedAsyncSTM l oid mv)
-
--- | Perform the Extended operation asynchronously.
---
--- Don't wait for its completion (with 'Ldap.Client.waitSTM') in the
--- same transaction you've performed it in.
-extendedAsyncSTM :: Ldap -> Oid -> Maybe ByteString -> STM (Async ())
-extendedAsyncSTM l oid mv =
-  let req = extendedRequest oid mv in sendRequest l (extendedResult req) req
+import qualified Ldap.Asn1.Type as Type
+import           Ldap.Client.Internal
+
+
+-- | Globally unique LDAP object identifier.
+newtype Oid = Oid Text
+    deriving (Show, Eq)
+
+-- | Perform the Extended operation synchronously. Raises 'ResponseError' on failures.
+extended :: Ldap -> Oid -> Maybe ByteString -> IO ()
+extended l oid mv =
+  raise =<< extendedEither l oid mv
+
+-- | Perform the Extended operation synchronously. Returns @Left e@ where
+-- @e@ is a 'ResponseError' on failures.
+extendedEither :: Ldap -> Oid -> Maybe ByteString -> IO (Either ResponseError ())
+extendedEither l oid mv =
+  wait =<< extendedAsync l oid mv
+
+-- | Perform the Extended operation asynchronously. Call 'Ldap.Client.wait' to wait
+-- for its completion.
+extendedAsync :: Ldap -> Oid -> Maybe ByteString -> IO (Async ())
+extendedAsync l oid mv =
+  atomically (extendedAsyncSTM l oid mv)
 
-extendedRequest :: Oid -> Maybe ByteString -> Request
-extendedRequest (Oid oid) =
-  Type.ExtendedRequest (Type.LdapOid oid)
-
-extendedResult :: Request -> Response -> Either ResponseError ()
-extendedResult req (Type.ExtendedResponse (Type.LdapResult code (Type.LdapDn (Type.LdapString dn))
-                                                                (Type.LdapString msg) _) _ _ :| [])
-  | Type.Success <- code = Right ()
-  | otherwise = Left (ResponseErrorCode req code (Dn dn) msg)
-extendedResult req res = Left (ResponseInvalid req res)
-
+-- | Perform the Extended operation asynchronously.
+--
+-- Don't wait for its completion (with 'Ldap.Client.waitSTM') in the
+-- same transaction you've performed it in.
+extendedAsyncSTM :: Ldap -> Oid -> Maybe ByteString -> STM (Async ())
+extendedAsyncSTM l oid mv =
+  let req = extendedRequest oid mv in sendRequest l (extendedResult req) req
+
+extendedRequest :: Oid -> Maybe ByteString -> Request
+extendedRequest (Oid oid) =
+  Type.ExtendedRequest (Type.LdapOid oid)
 
-startTls :: Ldap -> IO ()
-startTls =
-  raise <=< startTlsEither
-
-startTlsEither :: Ldap -> IO (Either ResponseError ())
-startTlsEither =
-  wait <=< startTlsAsync
+extendedResult :: Request -> Response -> Either ResponseError ()
+extendedResult req (Type.ExtendedResponse
+                     (Type.LdapResult code (Type.LdapDn (Type.LdapString dn))
+                                           (Type.LdapString msg) _) _ _ :| [])
+  | Type.Success <- code = Right ()
+  | otherwise = Left (ResponseErrorCode req code (Dn dn) msg)
+extendedResult req res = Left (ResponseInvalid req res)
 
-startTlsAsync :: Ldap -> IO (Async ())
-startTlsAsync =
-  atomically . startTlsAsyncSTM
-
-startTlsAsyncSTM :: Ldap -> STM (Async ())
-startTlsAsyncSTM l =
-  extendedAsyncSTM l (Oid "1.3.6.1.4.1.1466.20037") Nothing
+
+-- | An example of @Extended Operation@, cf. 'extended'.
+startTls :: Ldap -> IO ()
+startTls =
+  raise <=< startTlsEither
+
+-- | An example of @Extended Operation@, cf. 'extendedEither'.
+startTlsEither :: Ldap -> IO (Either ResponseError ())
+startTlsEither =
+  wait <=< startTlsAsync
+
+-- | An example of @Extended Operation@, cf. 'extendedAsync'.
+startTlsAsync :: Ldap -> IO (Async ())
+startTlsAsync =
+  atomically . startTlsAsyncSTM
+
+-- | An example of @Extended Operation@, cf. 'extendedAsyncSTM'.
+startTlsAsyncSTM :: Ldap -> STM (Async ())
+startTlsAsyncSTM l =
+  extendedAsyncSTM l (Oid (fromString "1.3.6.1.4.1.1466.20037"))
+                     Nothing
 

 
diff --git a/src/Ldap-Client-Internal.html b/src/Ldap-Client-Internal.html
index 4bc9031..3a74cd7 100644
--- a/src/Ldap-Client-Internal.html
+++ b/src/Ldap-Client-Internal.html
@@ -16,127 +16,137 @@
   , ClientMessage(..)
   , Type.ResultCode(..)
   , Async
-  , Oid(..)
-  , AttrList
-    -- * Waiting for Request Completion
-  , wait
-  , waitSTM
-  , unbindAsync
-  , unbindAsyncSTM
-    -- * Misc
-  , Response
-  , ResponseError(..)
-  , Request
-  , raise
-  , sendRequest
-  , Dn(..)
-  , RelativeDn(..)
-  , Password(..)
-  , Attr(..)
-  , AttrValue
-  , unAttr
-  ) where
-
-import           Control.Concurrent.STM (STM, atomically)
-import           Control.Concurrent.STM.TMVar (TMVar, newEmptyTMVar, readTMVar)
-import           Control.Concurrent.STM.TQueue (TQueue, writeTQueue)
-import           Control.Exception (Exception, throwIO)
-import           Control.Monad (void)
-import           Data.ByteString (ByteString)
-import           Data.List.NonEmpty (NonEmpty)
-import           Data.Text (Text)
-import           Data.Typeable (Typeable)
-import           Network (PortNumber)
+  , AttrList
+    -- * Waiting for Request Completion
+  , wait
+  , waitSTM
+    -- * Misc
+  , Response
+  , ResponseError(..)
+  , Request
+  , raise
+  , sendRequest
+  , Dn(..)
+  , Attr(..)
+  , AttrValue
+  , unAttr
+    -- * Unbind operation
+  , unbindAsync
+  , unbindAsyncSTM
+  ) where
+
+import           Control.Concurrent.STM (STM, atomically)
+import           Control.Concurrent.STM.TMVar (TMVar, newEmptyTMVar, readTMVar)
+import           Control.Concurrent.STM.TQueue (TQueue, writeTQueue)
+import           Control.Exception (Exception, throwIO)
+import           Control.Monad (void)
+import           Data.ByteString (ByteString)
+import           Data.List.NonEmpty (NonEmpty)
+import           Data.Text (Text)
+import           Data.Typeable (Typeable)
+import           Network (PortNumber)
+
+import qualified Ldap.Asn1.Type as Type
 
-import qualified Ldap.Asn1.Type as Type
-
-
-data Host =
-    Plain String
-  | Secure String
-  | Insecure String
+
+-- | LDAP host.
+data Host =
+    Plain String    -- ^ Plain LDAP. Do not use!
+  | Insecure String -- ^ LDAP over TLS without the certificate validity check.
+                    --   Only use for testing!
+  | Secure String   -- ^ LDAP over TLS. Use!
     deriving (Show, Eq, Ord)
 
-data Ldap = Ldap
-  { client  :: TQueue ClientMessage
-  } deriving (Eq)
-
-data ClientMessage = New Request (TMVar (NonEmpty Type.ProtocolServerOp))
-type Request = Type.ProtocolClientOp
-type InMessage = Type.ProtocolServerOp
-type Response = NonEmpty InMessage
-
-data Async a = Async (STM (Either ResponseError a))
-
-instance Functor Async where
-  fmap f (Async stm) = Async (fmap (fmap f) stm)
-
-newtype Dn = Dn Text
-    deriving (Show, Eq)
-
-newtype RelativeDn = RelativeDn Text
+-- | A token. All functions that interact with the Directory require one.
+data Ldap = Ldap
+  { client  :: TQueue ClientMessage
+  } deriving (Eq)
+
+data ClientMessage = New Request (TMVar (NonEmpty Type.ProtocolServerOp))
+type Request = Type.ProtocolClientOp
+type InMessage = Type.ProtocolServerOp
+type Response = NonEmpty InMessage
+
+-- | Asynchronous LDAP operation. Use 'wait' or 'waitSTM' to wait for its completion.
+data Async a = Async (STM (Either ResponseError a))
+
+instance Functor Async where
+  fmap f (Async stm) = Async (fmap (fmap f) stm)
+
+-- | Unique identifier of an LDAP entry.
+newtype Dn = Dn Text
     deriving (Show, Eq)
 
-newtype Oid = Oid Text
-    deriving (Show, Eq)
-
-newtype Password = Password ByteString
-    deriving (Show, Eq)
+-- | Response indicates a failed operation.
+data ResponseError =
+    ResponseInvalid Request Response -- ^ LDAP server did not follow the protocol, so @ldap-client@ couldn't make sense of the response.
+  | ResponseErrorCode Request Type.ResultCode Dn Text -- ^ The response contains a result code indicating failure and an error message.
+    deriving (Show, Eq, Typeable)
 
-data ResponseError =
-    ResponseInvalid Request Response
-  | ResponseErrorCode Request Type.ResultCode Dn Text
-    deriving (Show, Eq, Typeable)
-
-instance Exception ResponseError
-
-newtype Attr = Attr Text
-    deriving (Show, Eq)
-
-type AttrValue = ByteString
-
-type AttrList f = [(Attr, f AttrValue)]
-
--- 'Attr' unwrapper. This is a separate function not to turn 'Attr''s
--- 'Show' instance into complete and utter shit.
-unAttr :: Attr -> Text
-unAttr (Attr a) = a
-
-wait :: Async a -> IO (Either ResponseError a)
+instance Exception ResponseError
+
+-- | Attribute name.
+newtype Attr = Attr Text
+    deriving (Show, Eq)
+
+-- | Attribute value.
+type AttrValue = ByteString
+
+-- | List of attributes and their values. @f@ is the structure these
+-- values are in, e.g. 'NonEmpty'.
+type AttrList f = [(Attr, f AttrValue)]
+
+-- 'Attr' unwrapper. This is a separate function not to turn 'Attr''s
+-- 'Show' instance into complete and utter shit.
+unAttr :: Attr -> Text
+unAttr (Attr a) = a
+
+-- | Wait for operation completion.
+wait :: Async a -> IO (Either ResponseError a)
 wait = atomically . waitSTM
 
-waitSTM :: Async a -> STM (Either ResponseError a)
-waitSTM (Async stm) = stm
-
-sendRequest :: Ldap -> (Response -> Either ResponseError a) -> Request -> STM (Async a)
-sendRequest l p msg =
-  do var <- newEmptyTMVar
-     writeRequest l var msg
-     return (Async (fmap p (readTMVar var)))
+-- | Wait for operation completion inside 'STM'.
+--
+-- Do not use this inside the same 'STM' transaction the operation was
+-- requested in! To give LDAP the chance to respond to it that transaction
+-- should commit. After that, applying 'waitSTM' to the corresponding 'Async'
+-- starts to make sense.
+waitSTM :: Async a -> STM (Either ResponseError a)
+waitSTM (Async stm) = stm
 
-writeRequest :: Ldap -> TMVar Response -> Request -> STM ()
-writeRequest Ldap { client } var msg = writeTQueue client (New msg var)
-
-raise :: Exception e => Either e a -> IO a
-raise = either throwIO return
+sendRequest :: Ldap -> (Response -> Either ResponseError a) -> Request -> STM (Async a)
+sendRequest l p msg =
+  do var <- newEmptyTMVar
+     writeRequest l var msg
+     return (Async (fmap p (readTMVar var)))
 
-
--- | Note that 'unbindAsync' does not return an 'Async',
--- because LDAP server never responds to @UnbindRequest@s, hence
--- a call to 'wait' on a hypothetical 'Async' would have resulted
--- in an exception anyway.
-unbindAsync :: Ldap -> IO ()
-unbindAsync =
-  atomically . unbindAsyncSTM
-
--- | Note that 'unbindAsyncSTM' does not return an 'Async',
+writeRequest :: Ldap -> TMVar Response -> Request -> STM ()
+writeRequest Ldap { client } var msg = writeTQueue client (New msg var)
+
+raise :: Exception e => Either e a -> IO a
+raise = either throwIO return
+
+
+-- | Terminate the connection to the Directory.
+--
+-- Note that 'unbindAsync' does not return an 'Async',
 -- because LDAP server never responds to @UnbindRequest@s, hence
 -- a call to 'wait' on a hypothetical 'Async' would have resulted
 -- in an exception anyway.
-unbindAsyncSTM :: Ldap -> STM ()
-unbindAsyncSTM l =
-  void (sendRequest l die Type.UnbindRequest)
- where
-  die = error "Ldap.Client: do not wait for the response to UnbindRequest"
+unbindAsync :: Ldap -> IO ()
+unbindAsync =
+  atomically . unbindAsyncSTM
+
+-- | Terminate the connection to the Directory.
+--
+-- Note that 'unbindAsyncSTM' does not return an 'Async',
+-- because LDAP server never responds to @UnbindRequest@s, hence
+-- a call to 'wait' on a hypothetical 'Async' would have resulted
+-- in an exception anyway.
+unbindAsyncSTM :: Ldap -> STM ()
+unbindAsyncSTM l =
+  void (sendRequest l die Type.UnbindRequest)
+ where
+  die = error "Ldap.Client: do not wait for the response to UnbindRequest"
 

 
diff --git a/src/Ldap-Client-Modify.html b/src/Ldap-Client-Modify.html
index e88eab1..ee6a204 100644
--- a/src/Ldap-Client-Modify.html
+++ b/src/Ldap-Client-Modify.html
@@ -29,108 +29,114 @@
   , modifyEither
   , modifyAsync
   , modifyAsyncSTM
-  , modifyDn
-  , modifyDnEither
-  , modifyDnAsync
-  , modifyDnAsyncSTM
-  ) where
-
-import           Control.Monad.STM (STM, atomically)
-import           Data.List.NonEmpty (NonEmpty((:|)))
-
-import qualified Ldap.Asn1.Type as Type
-import           Ldap.Client.Internal
-
-
--- | Type of modification being performed.
-data Operation =
-    Delete Attr [AttrValue] -- ^ Delete values from the attribute. Deletes the attribute if the list is empty or all current values are listed.
-  | Add Attr [AttrValue] -- ^ Add values to the attribute, creating it if necessary.
-  | Replace Attr [AttrValue] -- ^ Replace all existing values of the attribute with the new list. Deletes the attribute if the list is empty.
-    deriving (Show, Eq)
-
--- | Perform the Modify operation synchronously. Raises 'ResponseError' on failures.
-modify :: Ldap -> Dn -> [Operation] -> IO ()
-modify l dn as =
-  raise =<< modifyEither l dn as
-
--- | Perform the Modify operation synchronously. Returns @Left e@ where
--- @e@ is a 'ResponseError' on failures.
-modifyEither :: Ldap -> Dn -> [Operation] -> IO (Either ResponseError ())
-modifyEither l dn as =
-  wait =<< modifyAsync l dn as
-
--- | Perform the Modify operation asynchronously. Call 'Ldap.Client.wait' to wait
--- for its completion.
-modifyAsync :: Ldap -> Dn -> [Operation] -> IO (Async ())
-modifyAsync l dn as =
-  atomically (modifyAsyncSTM l dn as)
-
--- | Perform the Modify operation asynchronously.
---
--- Don't wait for its completion (with 'Ldap.Client.waitSTM') in the
--- same transaction you've performed it in.
-modifyAsyncSTM :: Ldap -> Dn -> [Operation] -> STM (Async ())
-modifyAsyncSTM l dn xs =
-  let req = modifyRequest dn xs in sendRequest l (modifyResult req) req
-
-modifyRequest :: Dn -> [Operation] -> Request
-modifyRequest (Dn dn) xs =
-  Type.ModifyRequest (Type.LdapDn (Type.LdapString dn)) (map f xs)
- where
-  f (Delete (Attr k) vs) =
-    (Type.Delete, Type.PartialAttribute (Type.AttributeDescription (Type.LdapString k))
-                                        (map Type.AttributeValue vs))
-  f (Add (Attr k) vs) =
-    (Type.Add, Type.PartialAttribute (Type.AttributeDescription (Type.LdapString k))
-                                     (map Type.AttributeValue vs))
-  f (Replace (Attr k) vs) =
-    (Type.Replace, Type.PartialAttribute (Type.AttributeDescription (Type.LdapString k))
-                                         (map Type.AttributeValue vs))
-
-modifyResult :: Request -> Response -> Either ResponseError ()
-modifyResult req (Type.ModifyResponse (Type.LdapResult code (Type.LdapDn (Type.LdapString dn)) (Type.LdapString msg) _) :| [])
-  | Type.Success <- code = Right ()
-  | otherwise = Left (ResponseErrorCode req code (Dn dn) msg)
-modifyResult req res = Left (ResponseInvalid req res)
-
-
--- | Perform the Modify DN operation synchronously. Raises 'ResponseError' on failures.
-modifyDn :: Ldap -> Dn -> RelativeDn -> Bool -> Maybe Dn -> IO ()
-modifyDn l dn rdn del new =
-  raise =<< modifyDnEither l dn rdn del new
-
--- | Perform the Modify DN operation synchronously. Returns @Left e@ where
--- @e@ is a 'ResponseError' on failures.
-modifyDnEither :: Ldap -> Dn -> RelativeDn -> Bool -> Maybe Dn -> IO (Either ResponseError ())
-modifyDnEither l dn rdn del new =
-  wait =<< modifyDnAsync l dn rdn del new
+  , RelativeDn(..)
+  , modifyDn
+  , modifyDnEither
+  , modifyDnAsync
+  , modifyDnAsyncSTM
+  ) where
+
+import           Control.Monad.STM (STM, atomically)
+import           Data.List.NonEmpty (NonEmpty((:|)))
+import           Data.Text (Text)
+
+import qualified Ldap.Asn1.Type as Type
+import           Ldap.Client.Internal
+
+
+-- | Type of modification being performed.
+data Operation =
+    Delete Attr [AttrValue] -- ^ Delete values from the attribute. Deletes the attribute if the list is empty or all current values are listed.
+  | Add Attr [AttrValue] -- ^ Add values to the attribute, creating it if necessary.
+  | Replace Attr [AttrValue] -- ^ Replace all existing values of the attribute with the new list. Deletes the attribute if the list is empty.
+    deriving (Show, Eq)
+
+-- | Perform the Modify operation synchronously. Raises 'ResponseError' on failures.
+modify :: Ldap -> Dn -> [Operation] -> IO ()
+modify l dn as =
+  raise =<< modifyEither l dn as
+
+-- | Perform the Modify operation synchronously. Returns @Left e@ where
+-- @e@ is a 'ResponseError' on failures.
+modifyEither :: Ldap -> Dn -> [Operation] -> IO (Either ResponseError ())
+modifyEither l dn as =
+  wait =<< modifyAsync l dn as
+
+-- | Perform the Modify operation asynchronously. Call 'Ldap.Client.wait' to wait
+-- for its completion.
+modifyAsync :: Ldap -> Dn -> [Operation] -> IO (Async ())
+modifyAsync l dn as =
+  atomically (modifyAsyncSTM l dn as)
+
+-- | Perform the Modify operation asynchronously.
+--
+-- Don't wait for its completion (with 'Ldap.Client.waitSTM') in the
+-- same transaction you've performed it in.
+modifyAsyncSTM :: Ldap -> Dn -> [Operation] -> STM (Async ())
+modifyAsyncSTM l dn xs =
+  let req = modifyRequest dn xs in sendRequest l (modifyResult req) req
+
+modifyRequest :: Dn -> [Operation] -> Request
+modifyRequest (Dn dn) xs =
+  Type.ModifyRequest (Type.LdapDn (Type.LdapString dn)) (map f xs)
+ where
+  f (Delete (Attr k) vs) =
+    (Type.Delete, Type.PartialAttribute (Type.AttributeDescription (Type.LdapString k))
+                                        (map Type.AttributeValue vs))
+  f (Add (Attr k) vs) =
+    (Type.Add, Type.PartialAttribute (Type.AttributeDescription (Type.LdapString k))
+                                     (map Type.AttributeValue vs))
+  f (Replace (Attr k) vs) =
+    (Type.Replace, Type.PartialAttribute (Type.AttributeDescription (Type.LdapString k))
+                                         (map Type.AttributeValue vs))
+
+modifyResult :: Request -> Response -> Either ResponseError ()
+modifyResult req (Type.ModifyResponse (Type.LdapResult code (Type.LdapDn (Type.LdapString dn)) (Type.LdapString msg) _) :| [])
+  | Type.Success <- code = Right ()
+  | otherwise = Left (ResponseErrorCode req code (Dn dn) msg)
+modifyResult req res = Left (ResponseInvalid req res)
+
+
+-- | A component of 'Dn'.
+newtype RelativeDn = RelativeDn Text
+    deriving (Show, Eq)
+
+-- | Perform the Modify DN operation synchronously. Raises 'ResponseError' on failures.
+modifyDn :: Ldap -> Dn -> RelativeDn -> Bool -> Maybe Dn -> IO ()
+modifyDn l dn rdn del new =
+  raise =<< modifyDnEither l dn rdn del new
 
--- | Perform the Modify DN operation asynchronously. Call 'Ldap.Client.wait' to wait
--- for its completion.
-modifyDnAsync :: Ldap -> Dn -> RelativeDn -> Bool -> Maybe Dn -> IO (Async ())
-modifyDnAsync l dn rdn del new =
-  atomically (modifyDnAsyncSTM l dn rdn del new)
+-- | Perform the Modify DN operation synchronously. Returns @Left e@ where
+-- @e@ is a 'ResponseError' on failures.
+modifyDnEither :: Ldap -> Dn -> RelativeDn -> Bool -> Maybe Dn -> IO (Either ResponseError ())
+modifyDnEither l dn rdn del new =
+  wait =<< modifyDnAsync l dn rdn del new
 
--- | Perform the Modify DN operation asynchronously.
---
--- Don't wait for its completion (with 'Ldap.Client.waitSTM') in the
--- same transaction you've performed it in.
-modifyDnAsyncSTM :: Ldap -> Dn -> RelativeDn -> Bool -> Maybe Dn -> STM (Async ())
-modifyDnAsyncSTM l dn rdn del new =
-  let req = modifyDnRequest dn rdn del new in sendRequest l (modifyDnResult req) req
-
-modifyDnRequest :: Dn -> RelativeDn -> Bool -> Maybe Dn -> Request
-modifyDnRequest (Dn dn) (RelativeDn rdn) del new =
-  Type.ModifyDnRequest (Type.LdapDn (Type.LdapString dn))
-                       (Type.RelativeLdapDn (Type.LdapString rdn))
-                       del
-                       (fmap (\(Dn dn') -> Type.LdapDn (Type.LdapString dn')) new)
-
-modifyDnResult :: Request -> Response -> Either ResponseError ()
-modifyDnResult req (Type.ModifyDnResponse (Type.LdapResult code (Type.LdapDn (Type.LdapString dn)) (Type.LdapString msg) _) :| [])
-  | Type.Success <- code = Right ()
-  | otherwise = Left (ResponseErrorCode req code (Dn dn) msg)
-modifyDnResult req res = Left (ResponseInvalid req res)
+-- | Perform the Modify DN operation asynchronously. Call 'Ldap.Client.wait' to wait
+-- for its completion.
+modifyDnAsync :: Ldap -> Dn -> RelativeDn -> Bool -> Maybe Dn -> IO (Async ())
+modifyDnAsync l dn rdn del new =
+  atomically (modifyDnAsyncSTM l dn rdn del new)
+
+-- | Perform the Modify DN operation asynchronously.
+--
+-- Don't wait for its completion (with 'Ldap.Client.waitSTM') in the
+-- same transaction you've performed it in.
+modifyDnAsyncSTM :: Ldap -> Dn -> RelativeDn -> Bool -> Maybe Dn -> STM (Async ())
+modifyDnAsyncSTM l dn rdn del new =
+  let req = modifyDnRequest dn rdn del new in sendRequest l (modifyDnResult req) req
+
+modifyDnRequest :: Dn -> RelativeDn -> Bool -> Maybe Dn -> Request
+modifyDnRequest (Dn dn) (RelativeDn rdn) del new =
+  Type.ModifyDnRequest (Type.LdapDn (Type.LdapString dn))
+                       (Type.RelativeLdapDn (Type.LdapString rdn))
+                       del
+                       (fmap (\(Dn dn') -> Type.LdapDn (Type.LdapString dn')) new)
+
+modifyDnResult :: Request -> Response -> Either ResponseError ()
+modifyDnResult req (Type.ModifyDnResponse (Type.LdapResult code (Type.LdapDn (Type.LdapString dn)) (Type.LdapString msg) _) :| [])
+  | Type.Success <- code = Right ()
+  | otherwise = Left (ResponseErrorCode req code (Dn dn) msg)
+modifyDnResult req res = Left (ResponseInvalid req res)
 
 
diff --git a/src/Ldap-Client-Search.html b/src/Ldap-Client-Search.html
index fe98327..65781ea 100644
--- a/src/Ldap-Client-Search.html
+++ b/src/Ldap-Client-Search.html
@@ -34,183 +34,198 @@
   , size
   , time
   , typesOnly
-  , derefAliases
-  , Filter(..)
-  , SearchEntry(..)
-  ) where
-
-import           Control.Monad.STM (STM, atomically)
-import           Data.Int (Int32)
-import           Data.List.NonEmpty (NonEmpty((:|)))
-import qualified Data.List.NonEmpty as NonEmpty
-import           Data.Maybe (mapMaybe)
-#if __GLASGOW_HASKELL__ >= 710
-import           Data.Semigroup (Semigroup(..))
-#else
-import           Data.Semigroup (Semigroup(..), Monoid(..))
-#endif
-
-import qualified Ldap.Asn1.Type as Type
-import           Ldap.Client.Internal
-
+  , Type.DerefAliases(..)
+  , derefAliases
+  , Filter(..)
+  , SearchEntry(..)
+  ) where
+
+import           Control.Monad.STM (STM, atomically)
+import           Data.Int (Int32)
+import           Data.List.NonEmpty (NonEmpty((:|)))
+import qualified Data.List.NonEmpty as NonEmpty
+import           Data.Maybe (mapMaybe)
+#if __GLASGOW_HASKELL__ >= 710
+import           Data.Semigroup (Semigroup(..))
+#else
+import           Data.Semigroup (Semigroup(..), Monoid(..))
+#endif
+
+import qualified Ldap.Asn1.Type as Type
+import           Ldap.Client.Internal
 
--- | Perform the Search operation synchronously. Raises 'ResponseError' on failures.
-search :: Ldap -> Dn -> Mod Search -> Filter -> [Attr] -> IO [SearchEntry]
-search l base opts flt attributes =
-  raise =<< searchEither l base opts flt attributes
-
--- | Perform the Search operation synchronously. Returns @Left e@ where
--- @e@ is a 'ResponseError' on failures.
-searchEither
-  :: Ldap
-  -> Dn
-  -> Mod Search
-  -> Filter
-  -> [Attr]
-  -> IO (Either ResponseError [SearchEntry])
-searchEither l base opts flt attributes =
-  wait =<< searchAsync l base opts flt attributes
-
--- | Perform the Search operation asynchronously. Call 'Ldap.Client.wait' to wait
--- for its completion.
-searchAsync :: Ldap -> Dn -> Mod Search -> Filter -> [Attr] -> IO (Async [SearchEntry])
-searchAsync l base opts flt attributes =
-  atomically (searchAsyncSTM l base opts flt attributes)
-
--- | Perform the Search operation asynchronously.
---
--- Don't wait for its completion (with 'Ldap.Client.waitSTM') in the
--- same transaction you've performed it in.
-searchAsyncSTM
-  :: Ldap
-  -> Dn
-  -> Mod Search
-  -> Filter
-  -> [Attr]
-  -> STM (Async [SearchEntry])
-searchAsyncSTM l base opts flt attributes =
-  let req = searchRequest base opts flt attributes in sendRequest l (searchResult req) req
-
-searchRequest :: Dn -> Mod Search -> Filter -> [Attr] -> Request
-searchRequest (Dn base) (Mod m) flt attributes =
-  Type.SearchRequest (Type.LdapDn (Type.LdapString base))
-                     _scope
-                     _derefAliases
-                     _size
-                     _time
-                     _typesOnly
-                     (fromFilter flt)
-                     (Type.AttributeSelection (map (Type.LdapString . unAttr) attributes))
- where
-  Search { _scope, _derefAliases, _size, _time, _typesOnly } =
-    m defaultSearch
-  fromFilter (Not x) = Type.Not (fromFilter x)
-  fromFilter (And xs) = Type.And (fmap fromFilter xs)
-  fromFilter (Or xs) = Type.Or (fmap fromFilter xs)
-  fromFilter (Present (Attr x)) =
-    Type.Present (Type.AttributeDescription (Type.LdapString x))
-  fromFilter (Attr x := y) =
-    Type.EqualityMatch
-      (Type.AttributeValueAssertion (Type.AttributeDescription (Type.LdapString x))
-                                    (Type.AssertionValue y))
-  fromFilter (Attr x :>= y) =
-    Type.GreaterOrEqual
-      (Type.AttributeValueAssertion (Type.AttributeDescription (Type.LdapString x))
-                                    (Type.AssertionValue y))
-  fromFilter (Attr x :<= y) =
-    Type.LessOrEqual
-      (Type.AttributeValueAssertion (Type.AttributeDescription (Type.LdapString x))
-                                    (Type.AssertionValue y))
-  fromFilter (Attr x :~= y) =
-    Type.ApproxMatch
-      (Type.AttributeValueAssertion (Type.AttributeDescription (Type.LdapString x))
-                                    (Type.AssertionValue y))
-  fromFilter (Attr x :=* (mi, xs, mf)) =
-    Type.Substrings
-      (Type.SubstringFilter (Type.AttributeDescription (Type.LdapString x))
-                            (NonEmpty.fromList (concat
-                              [ maybe [] (\i -> [Type.Initial (Type.AssertionValue i)]) mi
-                              , fmap (Type.Any . Type.AssertionValue) xs
-                              , maybe [] (\f -> [Type.Final (Type.AssertionValue f)]) mf
-                              ])))
-  fromFilter ((mx, mr, b) ::= y) =
-    Type.ExtensibleMatch
-      (Type.MatchingRuleAssertion (fmap (\(Attr r) -> Type.MatchingRuleId (Type.LdapString r)) mr)
-                                  (fmap (\(Attr x) -> Type.AttributeDescription (Type.LdapString x)) mx)
-                                  (Type.AssertionValue y)
-                                  b)
-
-searchResult :: Request -> Response -> Either ResponseError [SearchEntry]
-searchResult req (Type.SearchResultDone (Type.LdapResult code (Type.LdapDn (Type.LdapString dn'))
-                                                              (Type.LdapString msg) _) :| xs)
-  | Type.Success <- code = Right (mapMaybe g xs)
-  | Type.AdminLimitExceeded <- code = Right (mapMaybe g xs)
-  | Type.SizeLimitExceeded <- code = Right (mapMaybe g xs)
-  | otherwise = Left (ResponseErrorCode req code (Dn dn') msg)
- where
-  g (Type.SearchResultEntry (Type.LdapDn (Type.LdapString dn))
-                            (Type.PartialAttributeList ys)) =
-    Just (SearchEntry (Dn dn) (map h ys))
-  g _ = Nothing
-  h (Type.PartialAttribute (Type.AttributeDescription (Type.LdapString x))
-                           y) = (Attr x, fmap j y)
-  j (Type.AttributeValue x) = x
-searchResult req res = Left (ResponseInvalid req res)
-
-data Search = Search
-  { _scope        :: Type.Scope
-  , _derefAliases :: Type.DerefAliases
-  , _size         :: Int32
-  , _time         :: Int32
-  , _typesOnly    :: Bool
-  } deriving (Show, Eq)
-
-defaultSearch :: Search
-defaultSearch = Search
-  { _scope        = Type.BaseObject
-  , _size         = 0
-  , _time         = 0
-  , _typesOnly    = False
-  , _derefAliases = Type.NeverDerefAliases
-  }
-
-scope :: Type.Scope -> Mod Search
-scope x = Mod (\y -> y { _scope = x })
-
-size :: Int32 -> Mod Search
-size x = Mod (\y -> y { _size = x })
+
+-- | Perform the Search operation synchronously. Raises 'ResponseError' on failures.
+search :: Ldap -> Dn -> Mod Search -> Filter -> [Attr] -> IO [SearchEntry]
+search l base opts flt attributes =
+  raise =<< searchEither l base opts flt attributes
+
+-- | Perform the Search operation synchronously. Returns @Left e@ where
+-- @e@ is a 'ResponseError' on failures.
+searchEither
+  :: Ldap
+  -> Dn
+  -> Mod Search
+  -> Filter
+  -> [Attr]
+  -> IO (Either ResponseError [SearchEntry])
+searchEither l base opts flt attributes =
+  wait =<< searchAsync l base opts flt attributes
+
+-- | Perform the Search operation asynchronously. Call 'Ldap.Client.wait' to wait
+-- for its completion.
+searchAsync :: Ldap -> Dn -> Mod Search -> Filter -> [Attr] -> IO (Async [SearchEntry])
+searchAsync l base opts flt attributes =
+  atomically (searchAsyncSTM l base opts flt attributes)
+
+-- | Perform the Search operation asynchronously.
+--
+-- Don't wait for its completion (with 'Ldap.Client.waitSTM') in the
+-- same transaction you've performed it in.
+searchAsyncSTM
+  :: Ldap
+  -> Dn
+  -> Mod Search
+  -> Filter
+  -> [Attr]
+  -> STM (Async [SearchEntry])
+searchAsyncSTM l base opts flt attributes =
+  let req = searchRequest base opts flt attributes in sendRequest l (searchResult req) req
+
+searchRequest :: Dn -> Mod Search -> Filter -> [Attr] -> Request
+searchRequest (Dn base) (Mod m) flt attributes =
+  Type.SearchRequest (Type.LdapDn (Type.LdapString base))
+                     _scope
+                     _derefAliases
+                     _size
+                     _time
+                     _typesOnly
+                     (fromFilter flt)
+                     (Type.AttributeSelection (map (Type.LdapString . unAttr) attributes))
+ where
+  Search { _scope, _derefAliases, _size, _time, _typesOnly } =
+    m defaultSearch
+  fromFilter (Not x) = Type.Not (fromFilter x)
+  fromFilter (And xs) = Type.And (fmap fromFilter xs)
+  fromFilter (Or xs) = Type.Or (fmap fromFilter xs)
+  fromFilter (Present (Attr x)) =
+    Type.Present (Type.AttributeDescription (Type.LdapString x))
+  fromFilter (Attr x := y) =
+    Type.EqualityMatch
+      (Type.AttributeValueAssertion (Type.AttributeDescription (Type.LdapString x))
+                                    (Type.AssertionValue y))
+  fromFilter (Attr x :>= y) =
+    Type.GreaterOrEqual
+      (Type.AttributeValueAssertion (Type.AttributeDescription (Type.LdapString x))
+                                    (Type.AssertionValue y))
+  fromFilter (Attr x :<= y) =
+    Type.LessOrEqual
+      (Type.AttributeValueAssertion (Type.AttributeDescription (Type.LdapString x))
+                                    (Type.AssertionValue y))
+  fromFilter (Attr x :~= y) =
+    Type.ApproxMatch
+      (Type.AttributeValueAssertion (Type.AttributeDescription (Type.LdapString x))
+                                    (Type.AssertionValue y))
+  fromFilter (Attr x :=* (mi, xs, mf)) =
+    Type.Substrings
+      (Type.SubstringFilter (Type.AttributeDescription (Type.LdapString x))
+                            (NonEmpty.fromList (concat
+                              [ maybe [] (\i -> [Type.Initial (Type.AssertionValue i)]) mi
+                              , fmap (Type.Any . Type.AssertionValue) xs
+                              , maybe [] (\f -> [Type.Final (Type.AssertionValue f)]) mf
+                              ])))
+  fromFilter ((mx, mr, b) ::= y) =
+    Type.ExtensibleMatch
+      (Type.MatchingRuleAssertion (fmap (\(Attr r) -> Type.MatchingRuleId (Type.LdapString r)) mr)
+                                  (fmap (\(Attr x) -> Type.AttributeDescription (Type.LdapString x)) mx)
+                                  (Type.AssertionValue y)
+                                  b)
+
+searchResult :: Request -> Response -> Either ResponseError [SearchEntry]
+searchResult req (Type.SearchResultDone (Type.LdapResult code (Type.LdapDn (Type.LdapString dn'))
+                                                              (Type.LdapString msg) _) :| xs)
+  | Type.Success <- code = Right (mapMaybe g xs)
+  | Type.AdminLimitExceeded <- code = Right (mapMaybe g xs)
+  | Type.SizeLimitExceeded <- code = Right (mapMaybe g xs)
+  | otherwise = Left (ResponseErrorCode req code (Dn dn') msg)
+ where
+  g (Type.SearchResultEntry (Type.LdapDn (Type.LdapString dn))
+                            (Type.PartialAttributeList ys)) =
+    Just (SearchEntry (Dn dn) (map h ys))
+  g _ = Nothing
+  h (Type.PartialAttribute (Type.AttributeDescription (Type.LdapString x))
+                           y) = (Attr x, fmap j y)
+  j (Type.AttributeValue x) = x
+searchResult req res = Left (ResponseInvalid req res)
+
+-- | Search options. Use 'Mod' to change some of those.
+data Search = Search
+  { _scope        :: !Type.Scope
+  , _derefAliases :: !Type.DerefAliases
+  , _size         :: !Int32
+  , _time         :: !Int32
+  , _typesOnly    :: !Bool
+  } deriving (Show, Eq)
+
+defaultSearch :: Search
+defaultSearch = Search
+  { _scope        = Type.WholeSubtree
+  , _size         = 0
+  , _time         = 0
+  , _typesOnly    = False
+  , _derefAliases = Type.NeverDerefAliases
+  }
+
+-- | Scope of the search (default: 'WholeSubtree').
+scope :: Type.Scope -> Mod Search
+scope x = Mod (\y -> y { _scope = x })
 
-time :: Int32 -> Mod Search
-time x = Mod (\y -> y { _time = x })
-
-typesOnly :: Bool -> Mod Search
-typesOnly x = Mod (\y -> y { _typesOnly = x })
-
-derefAliases :: Type.DerefAliases -> Mod Search
-derefAliases x = Mod (\y -> y { _derefAliases = x })
-
-newtype Mod a = Mod (a -> a)
-
-instance Semigroup (Mod a) where
-  Mod f <> Mod g = Mod (g . f)
-
-instance Monoid (Mod a) where
-  mempty = Mod id
-  mappend = (<>)
-
-data Filter =
-    Not Filter
-  | And (NonEmpty Filter)
-  | Or (NonEmpty Filter)
-  | Present Attr
-  | Attr := AttrValue
-  | Attr :>= AttrValue
-  | Attr :<= AttrValue
-  | Attr :~= AttrValue
-  | Attr :=* (Maybe AttrValue, [AttrValue], Maybe AttrValue)
-  | (Maybe Attr, Maybe Attr, Bool) ::= AttrValue
-
-data SearchEntry = SearchEntry Dn (AttrList [])
-    deriving (Show, Eq)
+-- | Maximum number of entries to be returned as a result of the Search.
+-- No limit if the value is @0@ (default: @0@).
+size :: Int32 -> Mod Search
+size x = Mod (\y -> y { _size = x })
+
+-- | Maximum time (in seconds) allowed for the Search. No limit if the value
+-- is @0@ (default: @0@).
+time :: Int32 -> Mod Search
+time x = Mod (\y -> y { _time = x })
+
+-- | Whether Search results are to contain just attribute descriptions, or
+-- both attribute descriptions and values (default: 'False').
+typesOnly :: Bool -> Mod Search
+typesOnly x = Mod (\y -> y { _typesOnly = x })
+
+-- | Alias dereference policy (default: 'NeverDerefAliases').
+derefAliases :: Type.DerefAliases -> Mod Search
+derefAliases x = Mod (\y -> y { _derefAliases = x })
+
+-- | Search modifier. Combine using 'Semigroup' and/or 'Monoid' instance.
+newtype Mod a = Mod (a -> a)
+
+instance Semigroup (Mod a) where
+  Mod f <> Mod g = Mod (g . f)
+
+instance Monoid (Mod a) where
+  mempty = Mod id
+  mappend = (<>)
+
+-- | Conditions that must be fulfilled in order for the Search to match a given entry.
+data Filter =
+    Not !Filter             -- ^ Filter does not match the entry
+  | And !(NonEmpty Filter)  -- ^ All filters match the entry
+  | Or !(NonEmpty Filter)   -- ^ Any filter matches the entry
+  | Present !Attr           -- ^ Attribute is present in the entry
+  | !Attr := !AttrValue     -- ^ Attribute's value is equal to the assertion
+  | !Attr :>= !AttrValue    -- ^ Attribute's value is equal to or greater than the assertion
+  | !Attr :<= !AttrValue    -- ^ Attribute's value is equal to or less than the assertion
+  | !Attr :~= !AttrValue    -- ^ Attribute's value approximately matches the assertion
+  | !Attr :=* !(Maybe AttrValue, [AttrValue], Maybe AttrValue)
+                            -- ^ Glob match
+  | (Maybe Attr, Maybe Attr, Bool) ::= AttrValue
+                            -- ^ Extensible match
+
+-- | Entry found during the Search.
+data SearchEntry = SearchEntry !Dn !(AttrList [])
+    deriving (Show, Eq)
 
 
diff --git a/src/Ldap-Client.html b/src/Ldap-Client.html
index b91e5f0..32b4b9e 100644
--- a/src/Ldap-Client.html
+++ b/src/Ldap-Client.html
@@ -11,256 +11,266 @@
 {-# LANGUAGE BangPatterns #-}
 {-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE NamedFieldPuns #-}
-module Ldap.Client
-  ( Host(..)
-  , Ldap
-  , LdapError(..)
-  , ResponseError(..)
-  , Type.ResultCode(..)
-  , Async
-  , with
-    -- * Bind
-  , bind
-    -- * Search
-  , search
-  , SearchEntry(..)
-    -- ** Search modifiers
-  , Search
-  , Mod
-  , scope
-  , Type.Scope(..)
-  , size
-  , time
-  , typesOnly
-  , derefAliases
-  , Filter(..)
-    -- * Modify
-  , modify
-  , Operation(..)
-    -- * Add
-  , add
-    -- * Delete
-  , delete
-    -- * ModifyDn
-  , modifyDn
-    -- * Compare
-  , compare
-    -- * Extended
-  , extended
-    -- * Waiting for completion
-  , wait
-    -- * Miscellanous
-  , Dn(..)
-  , RelativeDn(..)
-  , Oid(..)
-  , Password(..)
-  , AttrList
-  , Attr(..)
-  , AttrValue
-    -- * Re-exports
-  , NonEmpty
-  , PortNumber
-  ) where
-
-#if __GLASGOW_HASKELL__ < 710
-import           Control.Applicative ((<$>))
-#endif
-import qualified Control.Concurrent.Async as Async
-import           Control.Concurrent.STM (atomically, throwSTM)
-import           Control.Concurrent.STM.TMVar (putTMVar)
-import           Control.Concurrent.STM.TQueue (TQueue, newTQueueIO, writeTQueue, readTQueue)
-import           Control.Exception (Exception, Handler(..), bracket, throwIO, catch, catches)
-import           Control.Monad (forever)
-import qualified Data.ASN1.BinaryEncoding as Asn1
-import qualified Data.ASN1.Encoding as Asn1
-import qualified Data.ASN1.Error as Asn1
-import qualified Data.ByteString as ByteString
-import qualified Data.ByteString.Lazy as ByteString.Lazy
-import           Data.Foldable (asum)
-import           Data.Function (fix)
-import           Data.List.NonEmpty (NonEmpty((:|)))
-import qualified Data.Map.Strict as Map
-import           Data.Monoid (Endo(appEndo))
-import           Data.String (fromString)
-import           Data.Text (Text)
-import           Data.Typeable (Typeable)
-import           Network.Connection (Connection)
-import qualified Network.Connection as Conn
-import           Prelude hiding (compare)
-import qualified System.IO.Error as IO
-
-import           Ldap.Asn1.ToAsn1 (ToAsn1(toAsn1))
-import           Ldap.Asn1.FromAsn1 (FromAsn1, parseAsn1)
-import qualified Ldap.Asn1.Type as Type
-import           Ldap.Client.Internal
-import           Ldap.Client.Bind (bind)
-import           Ldap.Client.Search
-  ( search
-  , Search
-  , Mod
-  , scope
-  , size
-  , time
-  , typesOnly
-  , derefAliases
-  , Filter(..)
-  , SearchEntry(..)
-  )
-import           Ldap.Client.Modify (Operation(..), modify, modifyDn)
-import           Ldap.Client.Add (add)
-import           Ldap.Client.Delete (delete)
-import           Ldap.Client.Compare (compare)
-import           Ldap.Client.Extended (extended)
-
-{-# ANN module "HLint: ignore Use first" #-}
-
-
-newLdap :: IO Ldap
-newLdap = Ldap
-  <$> newTQueueIO
+-- | Pure Haskell LDAP client library.
+module Ldap.Client
+  ( Host(..)
+  , Ldap
+  , LdapError(..)
+  , ResponseError(..)
+  , Type.ResultCode(..)
+  , Async
+  , with
+    -- * Bind
+  , Password(..)
+  , bind
+    -- * Search
+  , search
+  , SearchEntry(..)
+    -- ** Search modifiers
+  , Search
+  , Mod
+  , Type.Scope(..)
+  , scope
+  , size
+  , time
+  , typesOnly
+  , Type.DerefAliases(..)
+  , derefAliases
+  , Filter(..)
+    -- * Modify
+  , modify
+  , Operation(..)
+    -- * Add
+  , add
+    -- * Delete
+  , delete
+    -- * ModifyDn
+  , RelativeDn(..)
+  , modifyDn
+    -- * Compare
+  , compare
+    -- * Extended
+  , Oid(..)
+  , extended
+    -- * Waiting for completion
+  , wait
+    -- * Miscellanous
+  , Dn(..)
+  , Attr(..)
+  , AttrValue
+  , AttrList
+    -- * Re-exports
+  , NonEmpty
+  , PortNumber
+  ) where
+
+#if __GLASGOW_HASKELL__ < 710
+import           Control.Applicative ((<$>))
+#endif
+import qualified Control.Concurrent.Async as Async
+import           Control.Concurrent.STM (atomically, throwSTM)
+import           Control.Concurrent.STM.TMVar (putTMVar)
+import           Control.Concurrent.STM.TQueue (TQueue, newTQueueIO, writeTQueue, readTQueue)
+import           Control.Exception (Exception, Handler(..), bracket, throwIO, catch, catches)
+import           Control.Monad (forever)
+import qualified Data.ASN1.BinaryEncoding as Asn1
+import qualified Data.ASN1.Encoding as Asn1
+import qualified Data.ASN1.Error as Asn1
+import qualified Data.ByteString as ByteString
+import qualified Data.ByteString.Lazy as ByteString.Lazy
+import           Data.Foldable (asum)
+import           Data.Function (fix)
+import           Data.List.NonEmpty (NonEmpty((:|)))
+import qualified Data.Map.Strict as Map
+import           Data.Monoid (Endo(appEndo))
+import           Data.String (fromString)
+import           Data.Text (Text)
+#if __GLASGOW_HASKELL__ < 710
+import           Data.Traversable (traverse)
+#endif
+import           Data.Typeable (Typeable)
+import           Network.Connection (Connection)
+import qualified Network.Connection as Conn
+import           Prelude hiding (compare)
+import qualified System.IO.Error as IO
+
+import           Ldap.Asn1.ToAsn1 (ToAsn1(toAsn1))
+import           Ldap.Asn1.FromAsn1 (FromAsn1, parseAsn1)
+import qualified Ldap.Asn1.Type as Type
+import           Ldap.Client.Internal
+import           Ldap.Client.Bind (Password(..), bind)
+import           Ldap.Client.Search
+  ( search
+  , Search
+  , Mod
+  , scope
+  , size
+  , time
+  , typesOnly
+  , derefAliases
+  , Filter(..)
+  , SearchEntry(..)
+  )
+import           Ldap.Client.Modify (Operation(..), modify, RelativeDn(..), modifyDn)
+import           Ldap.Client.Add (add)
+import           Ldap.Client.Delete (delete)
+import           Ldap.Client.Compare (compare)
+import           Ldap.Client.Extended (Oid(..), extended)
+
+{-# ANN module "HLint: ignore Use first" #-}
 
-data LdapError =
-    IOError IOError
-  | ParseError Asn1.ASN1Error
-  | ResponseError ResponseError
-  | DisconnectError Disconnect
-    deriving (Show, Eq)
-
-newtype WrappedIOError = WrappedIOError IOError
-    deriving (Show, Eq, Typeable)
-
-instance Exception WrappedIOError
-
-data Disconnect = Disconnect Type.ResultCode Dn Text
-    deriving (Show, Eq, Typeable)
-
-instance Exception Disconnect
-
--- | The entrypoint into LDAP.
-with :: Host -> PortNumber -> (Ldap -> IO a) -> IO (Either LdapError a)
-with host port f = do
-  context <- Conn.initConnectionContext
-  bracket (Conn.connectTo context params) Conn.connectionClose (\conn ->
-    bracket newLdap unbindAsync (\l -> do
-      inq  <- newTQueueIO
-      outq <- newTQueueIO
-      Async.withAsync (input inq conn) $ \i ->
-        Async.withAsync (output outq conn) $ \o ->
-          Async.withAsync (dispatch l inq outq) $ \d ->
-            Async.withAsync (f l) $ \u ->
-              fmap (Right . snd) (Async.waitAnyCancel [i, o, d, u])))
- `catches`
-  [ Handler (\(WrappedIOError e) -> return (Left (IOError e)))
-  , Handler (return . Left . ParseError)
-  , Handler (return . Left . ResponseError)
-  ]
- where
-  params = Conn.ConnectionParams
-    { Conn.connectionHostname =
-        case host of
-          Plain    h -> h
-          Secure   h -> h
-          Insecure h -> h
-    , Conn.connectionPort = port
-    , Conn.connectionUseSecure =
-        case host of
-          Plain  _ -> Nothing
-          Secure _ -> Just Conn.TLSSettingsSimple
-            { Conn.settingDisableCertificateValidation = False
-            , Conn.settingDisableSession = False
-            , Conn.settingUseServerName = False
-            }
-          Insecure _ -> Just Conn.TLSSettingsSimple
-            { Conn.settingDisableCertificateValidation = True
-            , Conn.settingDisableSession = False
-            , Conn.settingUseServerName = False
-            }
-    , Conn.connectionUseSocks = Nothing
-    }
-
-input :: FromAsn1 a => TQueue a -> Connection -> IO b
-input inq conn = wrap . flip fix [] $ \loop chunks -> do
-  chunk <- Conn.connectionGet conn 8192
-  case ByteString.length chunk of
-    0 -> throwIO (IO.mkIOError IO.eofErrorType "Ldap.Client.input" Nothing Nothing)
-    _ -> do
-      let chunks' = chunk : chunks
-      case Asn1.decodeASN1 Asn1.DER (ByteString.Lazy.fromChunks (reverse chunks')) of
-        Left  Asn1.ParsingPartial
-                   -> loop chunks'
-        Left  e    -> throwIO e
-        Right asn1 -> do
-          flip fix asn1 $ \loop' asn1' ->
-            case parseAsn1 asn1' of
-              Nothing -> return ()
-              Just (asn1'', a) -> do
-                atomically (writeTQueue inq a)
-                loop' asn1''
-          loop []
-
-output :: ToAsn1 a => TQueue a -> Connection -> IO b
-output out conn = wrap . forever $ do
-  msg <- atomically (readTQueue out)
-  Conn.connectionPut conn (encode (toAsn1 msg))
- where
-  encode x = Asn1.encodeASN1' Asn1.DER (appEndo x [])
-
-dispatch
-  :: Ldap
-  -> TQueue (Type.LdapMessage Type.ProtocolServerOp)
-  -> TQueue (Type.LdapMessage Request)
-  -> IO a
-dispatch Ldap { client } inq outq =
-  flip fix (Map.empty, 1) $ \loop (!req, !counter) ->
-    loop =<< atomically (asum
-      [ do New new var <- readTQueue client
-           writeTQueue outq (Type.LdapMessage (Type.Id counter) new Nothing)
-           return (Map.insert (Type.Id counter) ([], var) req, counter + 1)
-      , do Type.LdapMessage mid op _
-               <- readTQueue inq
-           res <- case op of
-             Type.BindResponse {}          -> done mid op req
-             Type.SearchResultEntry {}     -> saveUp mid op req
-             Type.SearchResultReference {} -> return req
-             Type.SearchResultDone {}      -> done mid op req
-             Type.ModifyResponse {}        -> done mid op req
-             Type.AddResponse {}           -> done mid op req
-             Type.DeleteResponse {}        -> done mid op req
-             Type.ModifyDnResponse {}      -> done mid op req
-             Type.CompareResponse {}       -> done mid op req
-             Type.ExtendedResponse {}      -> probablyDisconnect mid op req
-             Type.IntermediateResponse {}  -> saveUp mid op req
-           return (res, counter)
-      ])
- where
-  saveUp mid op res =
-    return (Map.adjust (\(stack, var) -> (op : stack, var)) mid res)
-
-  done mid op req =
-    case Map.lookup mid req of
-      Nothing -> return req
-      Just (stack, var) -> do
-        putTMVar var (op :| stack)
-        return (Map.delete mid req)
-
-  probablyDisconnect (Type.Id 0)
-                     (Type.ExtendedResponse
-                       (Type.LdapResult code
-                                        (Type.LdapDn (Type.LdapString dn))
-                                        (Type.LdapString reason)
-                                        _)
-                       moid _)
-                     req =
-    case moid of
-      Just (Type.LdapOid oid)
-        | oid == noticeOfDisconnection -> throwSTM (Disconnect code (Dn dn) reason)
-      _ -> return req
-  probablyDisconnect mid op req = done mid op req
-
-  noticeOfDisconnection :: Text
-  noticeOfDisconnection = fromString "1.3.6.1.4.1.1466.20036"
-
-wrap :: IO a -> IO a
-wrap m = m `catch` (throwIO . WrappedIOError)
+
+newLdap :: IO Ldap
+newLdap = Ldap
+  <$> newTQueueIO
+
+-- | Various failures that can happen when working with LDAP.
+data LdapError =
+    IOError IOError             -- ^ Network failure.
+  | ParseError Asn1.ASN1Error   -- ^ Invalid ASN.1 data received from the server.
+  | ResponseError ResponseError -- ^ An LDAP operation failed.
+  | DisconnectError Disconnect  -- ^ Notice of Disconnection has been received.
+    deriving (Show, Eq)
+
+newtype WrappedIOError = WrappedIOError IOError
+    deriving (Show, Eq, Typeable)
+
+instance Exception WrappedIOError
+
+data Disconnect = Disconnect Type.ResultCode Dn Text
+    deriving (Show, Eq, Typeable)
+
+instance Exception Disconnect
+
+-- | The entrypoint into LDAP.
+--
+-- It catches all LDAP-related exceptions.
+with :: Host -> PortNumber -> (Ldap -> IO a) -> IO (Either LdapError a)
+with host port f = do
+  context <- Conn.initConnectionContext
+  bracket (Conn.connectTo context params) Conn.connectionClose (\conn ->
+    bracket newLdap unbindAsync (\l -> do
+      inq  <- newTQueueIO
+      outq <- newTQueueIO
+      as   <- traverse Async.async
+        [ input inq conn
+        , output outq conn
+        , dispatch l inq outq
+        , f l
+        ]
+      fmap (Right . snd) (Async.waitAnyCancel as)))
+ `catches`
+  [ Handler (\(WrappedIOError e) -> return (Left (IOError e)))
+  , Handler (return . Left . ParseError)
+  , Handler (return . Left . ResponseError)
+  ]
+ where
+  params = Conn.ConnectionParams
+    { Conn.connectionHostname =
+        case host of
+          Plain    h -> h
+          Secure   h -> h
+          Insecure h -> h
+    , Conn.connectionPort = port
+    , Conn.connectionUseSecure =
+        case host of
+          Plain  _ -> Nothing
+          Secure _ -> Just Conn.TLSSettingsSimple
+            { Conn.settingDisableCertificateValidation = False
+            , Conn.settingDisableSession = False
+            , Conn.settingUseServerName = False
+            }
+          Insecure _ -> Just Conn.TLSSettingsSimple
+            { Conn.settingDisableCertificateValidation = True
+            , Conn.settingDisableSession = False
+            , Conn.settingUseServerName = False
+            }
+    , Conn.connectionUseSocks = Nothing
+    }
+
+input :: FromAsn1 a => TQueue a -> Connection -> IO b
+input inq conn = wrap . flip fix [] $ \loop chunks -> do
+  chunk <- Conn.connectionGet conn 8192
+  case ByteString.length chunk of
+    0 -> throwIO (IO.mkIOError IO.eofErrorType "Ldap.Client.input" Nothing Nothing)
+    _ -> do
+      let chunks' = chunk : chunks
+      case Asn1.decodeASN1 Asn1.DER (ByteString.Lazy.fromChunks (reverse chunks')) of
+        Left  Asn1.ParsingPartial
+                   -> loop chunks'
+        Left  e    -> throwIO e
+        Right asn1 -> do
+          flip fix asn1 $ \loop' asn1' ->
+            case parseAsn1 asn1' of
+              Nothing -> return ()
+              Just (asn1'', a) -> do
+                atomically (writeTQueue inq a)
+                loop' asn1''
+          loop []
+
+output :: ToAsn1 a => TQueue a -> Connection -> IO b
+output out conn = wrap . forever $ do
+  msg <- atomically (readTQueue out)
+  Conn.connectionPut conn (encode (toAsn1 msg))
+ where
+  encode x = Asn1.encodeASN1' Asn1.DER (appEndo x [])
+
+dispatch
+  :: Ldap
+  -> TQueue (Type.LdapMessage Type.ProtocolServerOp)
+  -> TQueue (Type.LdapMessage Request)
+  -> IO a
+dispatch Ldap { client } inq outq =
+  flip fix (Map.empty, 1) $ \loop (!req, !counter) ->
+    loop =<< atomically (asum
+      [ do New new var <- readTQueue client
+           writeTQueue outq (Type.LdapMessage (Type.Id counter) new Nothing)
+           return (Map.insert (Type.Id counter) ([], var) req, counter + 1)
+      , do Type.LdapMessage mid op _
+               <- readTQueue inq
+           res <- case op of
+             Type.BindResponse {}          -> done mid op req
+             Type.SearchResultEntry {}     -> saveUp mid op req
+             Type.SearchResultReference {} -> return req
+             Type.SearchResultDone {}      -> done mid op req
+             Type.ModifyResponse {}        -> done mid op req
+             Type.AddResponse {}           -> done mid op req
+             Type.DeleteResponse {}        -> done mid op req
+             Type.ModifyDnResponse {}      -> done mid op req
+             Type.CompareResponse {}       -> done mid op req
+             Type.ExtendedResponse {}      -> probablyDisconnect mid op req
+             Type.IntermediateResponse {}  -> saveUp mid op req
+           return (res, counter)
+      ])
+ where
+  saveUp mid op res =
+    return (Map.adjust (\(stack, var) -> (op : stack, var)) mid res)
+
+  done mid op req =
+    case Map.lookup mid req of
+      Nothing -> return req
+      Just (stack, var) -> do
+        putTMVar var (op :| stack)
+        return (Map.delete mid req)
+
+  probablyDisconnect (Type.Id 0)
+                     (Type.ExtendedResponse
+                       (Type.LdapResult code
+                                        (Type.LdapDn (Type.LdapString dn))
+                                        (Type.LdapString reason)
+                                        _)
+                       moid _)
+                     req =
+    case moid of
+      Just (Type.LdapOid oid)
+        | oid == noticeOfDisconnection -> throwSTM (Disconnect code (Dn dn) reason)
+      _ -> return req
+  probablyDisconnect mid op req = done mid op req
+
+  noticeOfDisconnection :: Text
+  noticeOfDisconnection = fromString "1.3.6.1.4.1.1466.20036"
+
+wrap :: IO a -> IO a
+wrap m = m `catch` (throwIO . WrappedIOError)