// Type definitions for LDAPjs 0.7.1
// Project: https://www.npmjs.com/package/ldapjs
// Definitions by: Zorbing <https://github.com/Zorbing>

/* =================== USAGE ===================

    import * as ldapjs from "ldapjs";

 =============================================== */

/// <reference path="../../typings/node/node.d.ts" />

declare module "ldapjs"
{
	interface IControl {}
	interface IChange {}
	interface IChangeObject {
		modification;
		operation?;
		type?;
	}
	interface ICallback {
		(...args: any[]): any;
	}
	
	interface ICreateClientOptions {
		// timeout for connecting to server in milliseconds
		connectTimeout?: number | string;
		log?;
		maxConnections?: number;
		socketPath?: string;
		timeout?: number | string;
		// options see: https://nodejs.org/api/tls.html#tls_tls_connect_port_host_options_callback
		tlsOptions?/*: tls.ConnectionOptions*/;
		url?: string;
	}
	export function createClient(options: ICreateClientOptions): LDAPClient;
	export function createServer(options?)/*: LDAPServer*/;
	
	export var Server;
	export var Attribute;
	export var Change;
	export var PersistentSearchCache;
	export var RDN;
	export var dn: DN;
	export var persistentSearch;
	export var filters;
	export var parseURL;
	export var url;
	export var GUID_FORMAT_N;
	export var GUID_FORMAT_D;
	export var GUID_FORMAT_B;
	export var GUID_FORMAT_P;
	export var GUID_FORMAT_X;
	
	interface IUrl extends URL {
		attributes?: string[];
		DN?;
		extensions?: string;
		filter?: string;
		port: number;
		scope?: string;
		secure: boolean;
	}
	
	
	interface ISearchOptions
	{
		// One of base, one, or sub. Defaults to base.
		scope?: string;
		// A string version of an LDAP filter (see below), or a programatically constructed Filter object. Defaults to (objectclass=*).
		filter?: string | Filter;
		// attributes to select and return (if these are set, the server will return only these attributes). Defaults to the empty set, which means all attributes.
		attributes?;
		// boolean on whether you want the server to only return the names of the attributes, and not their values. Borderline useless. Defaults to false.
		attrsOnly?: boolean;
		// the maximum number of entries to return. Defaults to 0 (unlimited).
		sizeLimit?: number;
		// the maximum amount of time the server should take in responding, in seconds. Defaults to 10. Lots of servers will ignore this.
		timeLimit?: number;
	}
	/**
	 * Client
	 */
	export class LDAPClient {
		connectTimeout: number;
		host: string;
		log;
		port: number |  boolean;
		secure: boolean;
		tlsOptions;
		socketPath: string;
		timeout: number;
		url: IUrl;
		socket/*: Socket | ClearTextStream*/;
		
		abandon(messageID: number, callback: ICallback);
		abandon(messageID: number, controls: IControl | IControl[], callback: ICallback);
		
		add(name: string, entry: Object | Object[], callback: ICallback);
		add(name: string, entry: Object | Object[], controls, callback);
		
		bind(name: string | DN, credentials: string, callback: ICallback);
		bind(name: string | DN, credentials: string, controls: IControl | IControl[], callback: ICallback);
		
		compare(name: string, attr: string, value: string, callback: ICallback);
		compare(name: string, attr: string, value: string, controls: IControl | IControl[], callback: ICallback);
		
		del(name: string, callback: ICallback);
		del(name: string, controls: IControl | IControl[], callback: ICallback);
		
		exop(name: string, callback: ICallback);
		exop(name: string, value: string | Buffer, controls: IControl | IControl[], callback: ICallback);
		
		modify(name: string, change: IChange | IChange[] | Object | Object[], callback: ICallback);
		modify(name: string, change: IChange | IChange[] | Object | Object[], controls: IControl | IControl[], callback: ICallback);
		
		modifyDN(name: string, newName: string, callback: ICallback);
		modifyDN(name: string, newName: string, controls: IControl | IControl[], callback: ICallback);
		
		search(base: string | DN, callback: ICallback);
		search(base: string | DN, controls: IControl | IControl[], callback: ICallback);
		search(base: string | DN, options: string | ISearchOptions, callback: ICallback);
		search(base: string | DN, options: string | ISearchOptions, controls: IControl | IControl[], callback: ICallback);
		
		unbind(callback?: ICallback);
	}
	
	
	/**
	 * TODO: EventEmitter
	 */
	
	
	/**
	 * Parses the given distinguished names and returns an instance of the DN class
	 */
	export function parseDN(dn: string): DN;
	
	export class DN
	{
		childOf(dn: string | DN): boolean;
		parentOf(dn: string | DN): boolean;
		equals(dn: string | DN): boolean;
		parent(): DN;
		toString(): string;
	}
	
	
	/**
	 * Abstract filter class
	 */
	class Filter
	{
		// possible values are:
		// equal, present, substring, ge, le, and, or, not; (not implemented types: approx, ext)
		type: string;
		matches(entry: any): boolean;
	}
	
	/**
	 * Parses the given filter string and returns an instance of one Filter class
	 */
	export function parseFilter(filter: string): Filter;
	
	export class EqualityFilter extends Filter
	{
		constructor(config: {
			attribute: string;
			value: string;
		});
	}
	export class PresenceFilter extends Filter
	{
		constructor(config: {
			attribute: string;
		});
	}
	export class SubstringFilter extends Filter
	{
		constructor(config: {
			attribute?: string;
			initial: string;
  			any: string[];
  			final: string;
		});
	}
	export class GreaterThanEqualsFilter extends Filter
	{
		constructor(config: {
			attribute: string;
			value: string;
		});
	}
	export class LessThanEqualsFilter extends Filter
	{
		constructor(config: {
			attribute: string;
			value: string;
		});
	}
	export class AndFilter extends Filter
	{
		constructor(config: {
			filters: Filter[];
		});
	}
	export class OrFilter extends Filter
	{
		constructor(config: {
			filters: Filter[];
		});
	}
	export class NotFilter extends Filter
	{
		constructor(config: {
			filter: Filter;
		});
	}
	
	
	/**
	 * Abstact error class
	 */
	class LDAPError
	{
		stack;
		code: number;
		name: string;
		message: string;
	}
	export class OperationsError extends LDAPError
	{
		constructor(message: string);
	}
	export class ProtocolError extends LDAPError
	{
		constructor(message: string);
	}
	export class TimeLimitExceededError extends LDAPError
	{
		constructor(message: string);
	}
	export class SizeLimitExceededError extends LDAPError
	{
		constructor(message: string);
	}
	export class CompareFalseError extends LDAPError
	{
		constructor(message: string);
	}
	export class CompareTrueError extends LDAPError
	{
		constructor(message: string);
	}
	export class AuthMethodNotSupportedError extends LDAPError
	{
		constructor(message: string);
	}
	export class StrongAuthRequiredError extends LDAPError
	{
		constructor(message: string);
	}
	export class ReferralError extends LDAPError
	{
		constructor(message: string);
	}
	export class AdminLimitExceededError extends LDAPError
	{
		constructor(message: string);
	}
	export class UnavailableCriticalExtensionError extends LDAPError
	{
		constructor(message: string);
	}
	export class ConfidentialityRequiredError extends LDAPError
	{
		constructor(message: string);
	}
	export class SaslBindInProgressError extends LDAPError
	{
		constructor(message: string);
	}
	export class NoSuchAttributeError extends LDAPError
	{
		constructor(message: string);
	}
	export class UndefinedAttributeTypeError extends LDAPError
	{
		constructor(message: string);
	}
	export class InappropriateMatchingError extends LDAPError
	{
		constructor(message: string);
	}
	export class ConstraintViolationError extends LDAPError
	{
		constructor(message: string);
	}
	export class AttributeOrValueExistsError extends LDAPError
	{
		constructor(message: string);
	}
	export class InvalidAttriubteSyntaxError extends LDAPError
	{
		constructor(message: string);
	}
	export class NoSuchObjectError extends LDAPError
	{
		constructor(message: string);
	}
	export class AliasProblemError extends LDAPError
	{
		constructor(message: string);
	}
	export class InvalidDnSyntaxError extends LDAPError
	{
		constructor(message: string);
	}
	export class AliasDerefProblemError extends LDAPError
	{
		constructor(message: string);
	}
	export class InappropriateAuthenticationError extends LDAPError
	{
		constructor(message: string);
	}
	export class InvalidCredentialsError extends LDAPError
	{
		constructor(message: string);
	}
	export class InsufficientAccessRightsError extends LDAPError
	{
		constructor(message: string);
	}
	export class BusyError extends LDAPError
	{
		constructor(message: string);
	}
	export class UnavailableError extends LDAPError
	{
		constructor(message: string);
	}
	export class UnwillingToPerformError extends LDAPError
	{
		constructor(message: string);
	}
	export class LoopDetectError extends LDAPError
	{
		constructor(message: string);
	}
	export class NamingViolationError extends LDAPError
	{
		constructor(message: string);
	}
	export class ObjectclassViolationError extends LDAPError
	{
		constructor(message: string);
	}
	export class NotAllowedOnNonLeafError extends LDAPError
	{
		constructor(message: string);
	}
	export class NotAllowedOnRdnError extends LDAPError
	{
		constructor(message: string);
	}
	export class EntryAlreadyExistsError extends LDAPError
	{
		constructor(message: string);
	}
	export class ObjectclassModsProhibitedError extends LDAPError
	{
		constructor(message: string);
	}
	export class AffectsMultipleDsasError extends LDAPError
	{
		constructor(message: string);
	}
	export class OtherError extends LDAPError
	{
		constructor(message: string);
	}
}