docs: function (options, mCb) {
  		options.params.info = options.infra.info;
  		const envCode = options.params.envCode.toUpperCase();
  		const opts = {
  			name: options.params.name,
  			ElbName: options.params.ElbName
  		};
  		const stack = options.infra.stack;
  		const aws = options.infra.api;
  		const ports = options.params.ports;
  		let deleted = [];
  		const elb = getConnector({
  			api: 'elb',
  			region: stack.options.zone,
  			keyId: aws.keyId,
  			secretAccessKey: aws.secretAccessKey
  		});
  		let params = {
  			LoadBalancerNames: [opts.ElbName.name]
  		};
  		elb.describeLoadBalancers(params, function (err, loadBalancer) {
  			if (err) {
  				return mCb(err);
  			}
  			else {
  				let listenerDescriptions;
  				//get listeners
  				if (loadBalancer.LoadBalancerDescriptions && loadBalancer.LoadBalancerDescriptions.length > 0
  					&& loadBalancer.LoadBalancerDescriptions[0].ListenerDescriptions
  					&& loadBalancer.LoadBalancerDescriptions[0].ListenerDescriptions.length > 0) {
  					listenerDescriptions = loadBalancer.LoadBalancerDescriptions[0].ListenerDescriptions;
  				}
  				//check if listener is found
  				if (listenerDescriptions) {
  					for (let s = 0; s < ports.length; s++) {
  						for (let y = listenerDescriptions.length - 1; y >= 0; y--) {
  							if (listenerDescriptions[y] && listenerDescriptions[y].Listener && listenerDescriptions[y].Listener.LoadBalancerPort) {
  								if (ports[s].target === listenerDescriptions[y].Listener.LoadBalancerPort &&
  									ports[s].published === listenerDescriptions[y].Listener.InstancePort) {
  									listenerDescriptions.splice(y, 1);
  								}
  							}
  						}
  					}
  					//get list of listeners to be deleted
  					if (listenerDescriptions.length > 0) {
  						listenerDescriptions.forEach(function (oneListen) {
  							deleted.push(oneListen.Listener.LoadBalancerPort)
  						});
  					}
  				}
  				if (deleted.length > 0) {
  					let deletedParams = {
  						LoadBalancerName: opts.ElbName.name,
  						LoadBalancerPorts: deleted
  					};
  					options.soajs.log.debug(deletedParams);
  					//delete unused listeners
  					elb.deleteLoadBalancerListeners(deletedParams, function (err) {
  						if (err) {
  							return mCb(err);
  						}
  						else {
  							updateListeners();
  						}
  					});
  				}
  				else {
  					updateListeners();
  				}
  			}
  			
  			function updateListeners() {
  				let listener = {};
  				params = {
  					Listeners: [],
  					LoadBalancerName: opts.ElbName.name
  				};
  				let healthCheckPort;
  				for (let i = 0; i < ports.length; i++) {
  					listener = {
  						InstancePort: ports[i].published,
  						InstanceProtocol: "TCP",
  						LoadBalancerPort: ports[i].target,
  						Protocol: "TCP",
  					};
  					if (ports[i].target === 80) {
  						listener.Protocol = 'HTTP';
  						listener.InstanceProtocol = 'HTTP';
  						healthCheckPort = listener.InstancePort;
  					}
  					params.Listeners.push(listener);
  				}
  				if (!healthCheckPort) {
  					healthCheckPort = params.Listeners[0].InstancePort;
  				}
  				options.soajs.log.debug(params);
  				elb.createLoadBalancerListeners(params, function (err) {
  					if (err) {
  						return mCb(err);
  					}
  					//check if health check port is deleted ==> if yes update the health check
  					if (loadBalancer.LoadBalancerDescriptions[0].HealthCheck && loadBalancer.LoadBalancerDescriptions[0].HealthCheck.Target
  						&& loadBalancer.LoadBalancerDescriptions[0].HealthCheck.Target.split(":")[1]
  						&& deleted.indexOf(loadBalancer.LoadBalancerDescriptions[0].HealthCheck.Target.split(":")[1]) === -1) {
  						updateHealthCheck(elb, healthCheckPort, function (err) {
  							if (err) {
  								return mCb(err);
  							}
  							//update the exposed ports of the service //check if db was tampered with
  							if (options.infra.deployments && options.infra.deployments[options.params.info[2]]
  								&& options.infra.deployments[options.params.info[2]].loadBalancers
  								&& options.infra.deployments[options.params.info[2]].loadBalancers[envCode]
  								&& options.infra.deployments[options.params.info[2]].loadBalancers[envCode][opts.name]) {
  								options.infra.deployments[options.params.info[2]].loadBalancers[envCode][opts.name].ports = ports;
  							}
  							return mCb(null, true);
  						});
  					}
  					else {
  						//update the exposed ports of the service //check if db was tampered with
  						if (options.infra.deployments && options.infra.deployments[options.params.info[2]]
  							&& options.infra.deployments[options.params.info[2]].loadBalancers
  							&& options.infra.deployments[options.params.info[2]].loadBalancers[envCode]
  							&& options.infra.deployments[options.params.info[2]].loadBalancers[envCode][opts.name]) {
  							options.infra.deployments[options.params.info[2]].loadBalancers[envCode][opts.name].ports = ports;
  						}
  						return mCb(null, true);
  					}
  				});
  			}
  			
  			function updateHealthCheck(elb, healthCheckPort, cb) {
  				let healthCheckParams = {
  					HealthCheck: loadBalancer.LoadBalancerDescriptions[0].HealthCheck,
  					LoadBalancerName: opts.ElbName.name
  				};
  				if (healthCheckPort === 80) {
  					healthCheckParams.HealthCheck.Target = "HTTP:80/";
  				}
  				else {
  					healthCheckParams.HealthCheck.Target = `TCP:${healthCheckPort}`;
  				}
  				options.soajs.log.debug(healthCheckParams);
  				elb.configureHealthCheck(healthCheckParams, function (err) {
  					return cb(err, true);
  				});
  			}
  		});
  	}