/* Generated: 29/02/2020 6:41:34 AM */
// Create namespace
if (typeof DataAction === 'undefined') {
  DataAction = {};
}
if (typeof DataAction.Edc === 'undefined') {
  DataAction.Edc = {};
}
if (typeof DataAction.Edc.Services === 'undefined') {
  DataAction.Edc.Services = {};
}
if (typeof DataAction.Edc.Services.Asl === 'undefined') {
  DataAction.Edc.Services.Asl = {};
}
if (typeof DataAction.Edc.Services.Asl.Interfaces === 'undefined') {
  DataAction.Edc.Services.Asl.Interfaces = {};
}
if (typeof DataAction.Edc.Services.Asl.Interfaces.IdentityCheckService === 'undefined') {
  DataAction.Edc.Services.Asl.Interfaces.IdentityCheckService = {};
}
if (typeof DataAction.Edc.Services.Asl.InternationalTransferService === 'undefined') {
  DataAction.Edc.Services.Asl.InternationalTransferService = {};
}
if (typeof DataAction.Edc.Services.Asl.UserService === 'undefined') {
  DataAction.Edc.Services.Asl.UserService = {};
}
if (typeof DataAction.Edc.Services.Asl.AccountService === 'undefined') {
  DataAction.Edc.Services.Asl.AccountService = {};
}
if (typeof DataAction.Edc.Services.Asl.Interfaces.Loans === 'undefined') {
  DataAction.Edc.Services.Asl.Interfaces.Loans = {};
}
if (typeof DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService === 'undefined') {
  DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService = {};
}
if (typeof DataAction.Edc.Services.Asl.Interfaces.ConfigurationValuesService === 'undefined') {
  DataAction.Edc.Services.Asl.Interfaces.ConfigurationValuesService = {};
}
if (typeof DataAction.Edc.Services.Asl.Interfaces.AddressVerificationService === 'undefined') {
  DataAction.Edc.Services.Asl.Interfaces.AddressVerificationService = {};
}
if (typeof DataAction.Edc.Services.Asl.TransactionService === 'undefined') {
  DataAction.Edc.Services.Asl.TransactionService = {};
}
if (typeof DataAction.Edc.Services.Asl.Interfaces.ModelService === 'undefined') {
  DataAction.Edc.Services.Asl.Interfaces.ModelService = {};
}
if (typeof DataAction.Edc.Services.Asl.Interfaces.Staff === 'undefined') {
  DataAction.Edc.Services.Asl.Interfaces.Staff = {};
}
if (typeof DataAction.Edc.Services.Asl.Interfaces.Staff.StaffService === 'undefined') {
  DataAction.Edc.Services.Asl.Interfaces.Staff.StaffService = {};
}
if (typeof DataAction.Edc.Services.Asl.DeviceService === 'undefined') {
  DataAction.Edc.Services.Asl.DeviceService = {};
}
if (typeof DataAction.Edc.Services.Asl.Loans === 'undefined') {
  DataAction.Edc.Services.Asl.Loans = {};
}
if (typeof DataAction.Edc.Services.Asl.Loans.LoanService === 'undefined') {
  DataAction.Edc.Services.Asl.Loans.LoanService = {};
}
if (typeof DataAction.Edc.Services.Asl.PersonToPersonTransferService === 'undefined') {
  DataAction.Edc.Services.Asl.PersonToPersonTransferService = {};
}
if (typeof DataAction.Edc.Services.Asl.Interfaces.ECorrespondenceService === 'undefined') {
  DataAction.Edc.Services.Asl.Interfaces.ECorrespondenceService = {};
}
if (typeof DataAction.Edc.Services.Asl.Interfaces.CardStatusService === 'undefined') {
  DataAction.Edc.Services.Asl.Interfaces.CardStatusService = {};
}
if (typeof DataAction.Edc.Services.Asl.Loans.LookupService === 'undefined') {
  DataAction.Edc.Services.Asl.Loans.LookupService = {};
}
if (typeof DataAction.Edc.Services.Asl.Loans.PurposeService === 'undefined') {
  DataAction.Edc.Services.Asl.Loans.PurposeService = {};
}
if (typeof DataAction.Edc.Services.Asl.Interfaces.VedaService === 'undefined') {
  DataAction.Edc.Services.Asl.Interfaces.VedaService = {};
}
if (typeof DataAction.Edc.Services.Asl.AlertService === 'undefined') {
  DataAction.Edc.Services.Asl.AlertService = {};
}
if (typeof DataAction.Edc.Services.Asl.Interfaces.Factor2Service === 'undefined') {
  DataAction.Edc.Services.Asl.Interfaces.Factor2Service = {};
}
if (typeof DataAction.Edc.Services.Asl.BpayService === 'undefined') {
  DataAction.Edc.Services.Asl.BpayService = {};
}
if (typeof DataAction.Edc.Services.Asl.SessionService === 'undefined') {
  DataAction.Edc.Services.Asl.SessionService = {};
}

// Requires: jQuery
// Requires: JSON2
// Requires: Models
// Requires: Meta
// Requires: Validation

DataAction.Edc.Services.Asl.ApiUrl = '/platform/';
DataAction.Edc.Services.Asl.ApiKey = '';
DataAction.Edc.Services.Asl.AuthToken = '';
DataAction.Edc.Services.Asl.SessionTimeout = '';
DataAction.Edc.Services.Asl.ModelValidationMethod = function(model) { return []; };
DataAction.Edc.Services.Asl.SessionExpiredMethod = function() {};

DataAction.Edc.Services.Asl.AjaxCall = function(apiUrl, apiKey, authToken, uriTemplate, type, postData) {
  return $.ajax({
    url: apiUrl + uriTemplate,
    type: type,
    dataType: 'json',
    data: postData,
    cache: false,
    contentType: 'application/json; charset=utf-8',
    crossDomain: false,
    headers: { 'MP-API-KEY': apiKey, 'MP-AUTH-TOKEN': authToken },
    context: document.body
  })
  .done(function(data, textStatus, jqxhr) {
       if(jqxhr!=null && jqxhr.getResponseHeader('Session-Timeout')!=null){
           var sessionTimeoutDate = new Date();
           sessionTimeoutDate.setMinutes(sessionTimeoutDate.getMinutes() + parseInt(jqxhr.getResponseHeader('Session-Timeout')));
           DataAction.Edc.Services.Asl.SessionTimeout = sessionTimeoutDate
       }
   })
  .fail(function(jqxhr, textStatus, errorThrown) {
       if(jqxhr.status==401){
           DataAction.Edc.Services.Asl.SessionExpiredMethod();
       }
       if(jqxhr!=null && jqxhr.getResponseHeader('Session-Timeout')!=null){
           var sessionTimeoutDate = new Date();
           sessionTimeoutDate.setMinutes(sessionTimeoutDate.getMinutes() + parseInt(jqxhr.getResponseHeader('Session-Timeout')));
           DataAction.Edc.Services.Asl.SessionTimeout = sessionTimeoutDate
       }
   });
};

DataAction.Edc.Services.Asl.AjaxHTTPError = function(statusCode) {
  switch (statusCode) {
    case 0:   return 'JSON REST API throw error 0 - Possible cross-site scripting error?';
    case 400: return 'Bad Request when calling JSON REST API.';
    case 401: return 'Not authorised to use JSON REST API.';
    case 404: return 'Unable to locate JSON REST API URI or unable to located requested resource.';
    case 405: return 'Method Not Allowed. Possibly HTTP Verb or Uri is incorrect.';
    default:  return 'Unknown JSON REST API error.';
  }
};

DataAction.Edc.Services.Asl.AjaxError = function(jqxhr, textStatus, errorThrown) {
  var errorResponse = new DataAction.Edc.Services.Asl.Faults.MatrixFault();
  try {
    jQuery.extend(errorResponse, JSON.parse(jqxhr.responseText));
  } catch (e) {
    errorResponse.ErrorCategory  = 0;
    errorResponse.ErrorCode = jqxhr.status;
    errorResponse.ErrorDescription  = DataAction.Edc.Services.Asl.AjaxHTTPError(jqxhr.status) + ' (HTTP Error: ' + errorThrown + ')';
  }
  return errorResponse;
};

DataAction.Edc.Services.Asl.ValidationError = function(invalidValidators) {
  var errorResponse = new DataAction.Edc.Services.Exceptions.ModelValidationException();
  errorResponse.ErrorCategory  = 5;
  errorResponse.ErrorCode = 0;
  errorResponse.ErrorDescription  = 'Validation Errors';
  errorResponse.Validations  = invalidValidators;
  return errorResponse;
};

DataAction.Edc.Services.Asl.Interfaces.IdentityCheckService.GetIdentityVerificationResult = function (dataForIdentityVerification) {
  var uriTemplate = 'IdentityCheck/IdentityCheck';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(dataForIdentityVerification));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(dataForIdentityVerification);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Veda.IdentityVerificationResponse();
    jQuery.extend(ret, data);
    ret.IdentityVerificationError = new DataAction.Edc.Services.Model.Veda.IdentityVerificationError();
    jQuery.extend(ret.IdentityVerificationError, data.IdentityVerificationError);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.IdentityCheckService.GetDetailsFromLoanObject = function (guid, applicantId) {
  var uriTemplate = 'IdentityCheck/DetailsFromLoanObject/{guid}/{applicantId}';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(guid));
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(applicantId));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(guid);
  uriTemplate = uriTemplate.replace('{guid}', guid);

  postData += JSON.stringify(applicantId);
  uriTemplate = uriTemplate.replace('{applicantId}', applicantId);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Veda.IdentityVerificationDvs();
    jQuery.extend(ret, data);
    ret.BirthCertificateRegisteredOtherName =  new Array();
    $.each(data.BirthCertificateRegisteredOtherName, function(indexBirthCertificateRegisteredOtherName, valueBirthCertificateRegisteredOtherName) {
      ret.BirthCertificateRegisteredOtherName[indexBirthCertificateRegisteredOtherName] = new System.String();
      jQuery.extend(ret.BirthCertificateRegisteredOtherName[indexBirthCertificateRegisteredOtherName], valueBirthCertificateRegisteredOtherName);
    });
    ret.OtherGivenName =  new Array();
    $.each(data.OtherGivenName, function(indexOtherGivenName, valueOtherGivenName) {
      ret.OtherGivenName[indexOtherGivenName] = new System.String();
      jQuery.extend(ret.OtherGivenName[indexOtherGivenName], valueOtherGivenName);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.InternationalTransferService.GetExchangeRate = function (quoteRequestDetails) {
  var uriTemplate = 'internationalTransfer/exchangeRate';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(quoteRequestDetails));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(quoteRequestDetails);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.InternationalTransfer.QuoteResponse();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.InternationalTransferService.PostInternationalTransfer = function (immediateInternationalPostRequest) {
  var uriTemplate = 'internationalTransfer/now';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(immediateInternationalPostRequest));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(immediateInternationalPostRequest);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.InternationalTransfer.InternationalTransferReceipt();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.InternationalTransferService.GetCountries = function () {
  var uriTemplate = 'internationalTransfer/countries';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexCountry, valueCountry) {
      ret[indexCountry] = new DataAction.Edc.Services.Model.InternationalTransfer.Country();
      jQuery.extend(ret[indexCountry], valueCountry);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.InternationalTransferService.GetCurrencies = function () {
  var uriTemplate = 'internationalTransfer/currencies';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexCurrency, valueCurrency) {
      ret[indexCurrency] = new DataAction.Edc.Services.Model.InternationalTransfer.Currency();
      jQuery.extend(ret[indexCurrency], valueCurrency);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.UserService.GetUser = function () {
  var uriTemplate = 'user/';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.User.User();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.UserService.ChangePassword = function (changePasswordRequest) {
  var uriTemplate = 'user/password';
  var type = 'PUT';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(changePasswordRequest));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(changePasswordRequest);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.UserService.GetUserPreference = function () {
  var uriTemplate = 'user/preference';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.User.UserPreference();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.UserService.UpdateUserPreference = function (userPreference) {
  var uriTemplate = 'user/preference';
  var type = 'PUT';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(userPreference));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(userPreference);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.UserService.AcceptTerms = function (terms) {
  var uriTemplate = 'user/acceptTerms';
  var type = 'PUT';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(terms));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(terms);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AccountService.GetAccounts = function () {
  var uriTemplate = 'accounts/';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexAccount, valueAccount) {
      ret[indexAccount] = new DataAction.Edc.Services.Model.Accounts.Account();
      jQuery.extend(ret[indexAccount], valueAccount);
      ret[indexAccount].InterestDetails = new DataAction.Edc.Services.Model.Accounts.InterestDetails();
      jQuery.extend(ret[indexAccount].InterestDetails, valueAccount.InterestDetails);
      ret[indexAccount].LoanDetails = new DataAction.Edc.Services.Model.Accounts.LoanDetails();
      jQuery.extend(ret[indexAccount].LoanDetails, valueAccount.LoanDetails);
      ret[indexAccount].DepositDetails = new DataAction.Edc.Services.Model.Accounts.DepositDetails();
      jQuery.extend(ret[indexAccount].DepositDetails, valueAccount.DepositDetails);
      ret[indexAccount].UncollectedFunds =  new Array();
      $.each(valueAccount.UncollectedFunds, function(indexUncollectedFunds, valueUncollectedFunds) {
        ret[indexAccount].UncollectedFunds[indexUncollectedFunds] = new DataAction.Edc.Services.Model.Accounts.UncollectedFunds();
        jQuery.extend(ret[indexAccount].UncollectedFunds[indexUncollectedFunds], valueUncollectedFunds);
      });
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AccountService.GetDebitAccounts = function () {
  var uriTemplate = 'accounts/debit';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexAccount, valueAccount) {
      ret[indexAccount] = new DataAction.Edc.Services.Model.Accounts.Account();
      jQuery.extend(ret[indexAccount], valueAccount);
      ret[indexAccount].InterestDetails = new DataAction.Edc.Services.Model.Accounts.InterestDetails();
      jQuery.extend(ret[indexAccount].InterestDetails, valueAccount.InterestDetails);
      ret[indexAccount].LoanDetails = new DataAction.Edc.Services.Model.Accounts.LoanDetails();
      jQuery.extend(ret[indexAccount].LoanDetails, valueAccount.LoanDetails);
      ret[indexAccount].DepositDetails = new DataAction.Edc.Services.Model.Accounts.DepositDetails();
      jQuery.extend(ret[indexAccount].DepositDetails, valueAccount.DepositDetails);
      ret[indexAccount].UncollectedFunds =  new Array();
      $.each(valueAccount.UncollectedFunds, function(indexUncollectedFunds, valueUncollectedFunds) {
        ret[indexAccount].UncollectedFunds[indexUncollectedFunds] = new DataAction.Edc.Services.Model.Accounts.UncollectedFunds();
        jQuery.extend(ret[indexAccount].UncollectedFunds[indexUncollectedFunds], valueUncollectedFunds);
      });
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AccountService.GetCreditAccounts = function () {
  var uriTemplate = 'accounts/credit';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexAccount, valueAccount) {
      ret[indexAccount] = new DataAction.Edc.Services.Model.Accounts.Account();
      jQuery.extend(ret[indexAccount], valueAccount);
      ret[indexAccount].InterestDetails = new DataAction.Edc.Services.Model.Accounts.InterestDetails();
      jQuery.extend(ret[indexAccount].InterestDetails, valueAccount.InterestDetails);
      ret[indexAccount].LoanDetails = new DataAction.Edc.Services.Model.Accounts.LoanDetails();
      jQuery.extend(ret[indexAccount].LoanDetails, valueAccount.LoanDetails);
      ret[indexAccount].DepositDetails = new DataAction.Edc.Services.Model.Accounts.DepositDetails();
      jQuery.extend(ret[indexAccount].DepositDetails, valueAccount.DepositDetails);
      ret[indexAccount].UncollectedFunds =  new Array();
      $.each(valueAccount.UncollectedFunds, function(indexUncollectedFunds, valueUncollectedFunds) {
        ret[indexAccount].UncollectedFunds[indexUncollectedFunds] = new DataAction.Edc.Services.Model.Accounts.UncollectedFunds();
        jQuery.extend(ret[indexAccount].UncollectedFunds[indexUncollectedFunds], valueUncollectedFunds);
      });
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService.GetLoanTypes = function () {
  var uriTemplate = 'mappings/mapping/loantypes';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexAvailableLoanTypes, valueAvailableLoanTypes) {
      ret[indexAvailableLoanTypes] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.AvailableLoanTypes();
      jQuery.extend(ret[indexAvailableLoanTypes], valueAvailableLoanTypes);
      ret[indexAvailableLoanTypes].LoanType = new DataAction.Edc.Services.Model.Loans.Public.Mapping.LoanTypeMapping();
      jQuery.extend(ret[indexAvailableLoanTypes].LoanType, valueAvailableLoanTypes.LoanType);
      ret[indexAvailableLoanTypes].ProductInformation = new DataAction.Edc.Services.Model.Loans.Product();
      jQuery.extend(ret[indexAvailableLoanTypes].ProductInformation, valueAvailableLoanTypes.ProductInformation);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService.GetPrimaryPurposes = function () {
  var uriTemplate = 'mappings/mapping/primarypurposes';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexGenericMapping, valueGenericMapping) {
      ret[indexGenericMapping] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret[indexGenericMapping], valueGenericMapping);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService.GetLiabilityTypes = function () {
  var uriTemplate = 'mappings/mapping/liabilitytypes';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexGenericMapping, valueGenericMapping) {
      ret[indexGenericMapping] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret[indexGenericMapping], valueGenericMapping);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService.GetExpenseTypes = function () {
  var uriTemplate = 'mappings/mapping/expensetypes';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexGenericMapping, valueGenericMapping) {
      ret[indexGenericMapping] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret[indexGenericMapping], valueGenericMapping);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService.GetMaritalTypes = function () {
  var uriTemplate = 'mappings/mapping/maritaltypes';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexGenericMapping, valueGenericMapping) {
      ret[indexGenericMapping] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret[indexGenericMapping], valueGenericMapping);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService.GetApplicantMaritalTypes = function () {
  var uriTemplate = 'mappings/mapping/applicant/maritaltypes';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexApplicantMaritalStatus, valueApplicantMaritalStatus) {
      ret[indexApplicantMaritalStatus] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.ApplicantMaritalStatus();
      jQuery.extend(ret[indexApplicantMaritalStatus], valueApplicantMaritalStatus);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService.GetResidentialTypes = function () {
  var uriTemplate = 'mappings/mapping/residentialtypes';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexGenericMapping, valueGenericMapping) {
      ret[indexGenericMapping] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret[indexGenericMapping], valueGenericMapping);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService.GetApplicantResidentialTypes = function () {
  var uriTemplate = 'mappings/mapping/applicant/residentialtypes';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexApplicantResidentialStatus, valueApplicantResidentialStatus) {
      ret[indexApplicantResidentialStatus] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.ApplicantResidentialStatus();
      jQuery.extend(ret[indexApplicantResidentialStatus], valueApplicantResidentialStatus);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService.GetLivingArrangements = function () {
  var uriTemplate = 'mappings/mapping/livingarrangements';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexGenericMapping, valueGenericMapping) {
      ret[indexGenericMapping] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret[indexGenericMapping], valueGenericMapping);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService.GetApplicantLivingArrangements = function () {
  var uriTemplate = 'mappings/mapping/applicant/livingarrangements';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexApplicantLivingArrangement, valueApplicantLivingArrangement) {
      ret[indexApplicantLivingArrangement] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.ApplicantLivingArrangement();
      jQuery.extend(ret[indexApplicantLivingArrangement], valueApplicantLivingArrangement);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService.GetIncomeTypes = function () {
  var uriTemplate = 'mappings/mapping/incometypes';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexGenericMapping, valueGenericMapping) {
      ret[indexGenericMapping] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret[indexGenericMapping], valueGenericMapping);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService.GetInsuranceProviders = function () {
  var uriTemplate = 'mappings/mapping/insuranceproviders';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexGenericMapping, valueGenericMapping) {
      ret[indexGenericMapping] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret[indexGenericMapping], valueGenericMapping);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService.GetCountries = function () {
  var uriTemplate = 'mappings/mapping/countries';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexGenericMapping, valueGenericMapping) {
      ret[indexGenericMapping] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret[indexGenericMapping], valueGenericMapping);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService.GetFlatOrBoxTypes = function () {
  var uriTemplate = 'mappings/mapping/flatorboxtypes';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexGenericMapping, valueGenericMapping) {
      ret[indexGenericMapping] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret[indexGenericMapping], valueGenericMapping);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService.GetInvalidResidentialStreetTypes = function () {
  var uriTemplate = 'mappings/mapping/invalidresidentialstreetaddresstypes';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexAddressTypeMapping, valueAddressTypeMapping) {
      ret[indexAddressTypeMapping] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.AddressTypeMapping();
      jQuery.extend(ret[indexAddressTypeMapping], valueAddressTypeMapping);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService.GetAllStreetTypes = function () {
  var uriTemplate = 'mappings/mapping/allstreetaddresstypes';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexAddressTypeMapping, valueAddressTypeMapping) {
      ret[indexAddressTypeMapping] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.AddressTypeMapping();
      jQuery.extend(ret[indexAddressTypeMapping], valueAddressTypeMapping);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService.GetAllMappedValues = function () {
  var uriTemplate = 'mappings/mapping/getallmapping';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Loans.Public.Mapping.AllMappedValues();
    jQuery.extend(ret, data);
    ret.LoanTypes =  new Array();
    $.each(data.LoanTypes, function(indexLoanTypes, valueLoanTypes) {
      ret.LoanTypes[indexLoanTypes] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.AvailableLoanTypes();
      jQuery.extend(ret.LoanTypes[indexLoanTypes], valueLoanTypes);
    });
    ret.PrimaryPurposes =  new Array();
    $.each(data.PrimaryPurposes, function(indexPrimaryPurposes, valuePrimaryPurposes) {
      ret.PrimaryPurposes[indexPrimaryPurposes] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret.PrimaryPurposes[indexPrimaryPurposes], valuePrimaryPurposes);
    });
    ret.LiabilityTypes =  new Array();
    $.each(data.LiabilityTypes, function(indexLiabilityTypes, valueLiabilityTypes) {
      ret.LiabilityTypes[indexLiabilityTypes] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret.LiabilityTypes[indexLiabilityTypes], valueLiabilityTypes);
    });
    ret.ExpenseTypes =  new Array();
    $.each(data.ExpenseTypes, function(indexExpenseTypes, valueExpenseTypes) {
      ret.ExpenseTypes[indexExpenseTypes] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret.ExpenseTypes[indexExpenseTypes], valueExpenseTypes);
    });
    ret.MaritalTypes =  new Array();
    $.each(data.MaritalTypes, function(indexMaritalTypes, valueMaritalTypes) {
      ret.MaritalTypes[indexMaritalTypes] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret.MaritalTypes[indexMaritalTypes], valueMaritalTypes);
    });
    ret.ApplicantMaritalTypes =  new Array();
    $.each(data.ApplicantMaritalTypes, function(indexApplicantMaritalTypes, valueApplicantMaritalTypes) {
      ret.ApplicantMaritalTypes[indexApplicantMaritalTypes] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.ApplicantMaritalStatus();
      jQuery.extend(ret.ApplicantMaritalTypes[indexApplicantMaritalTypes], valueApplicantMaritalTypes);
    });
    ret.ResidentialTypes =  new Array();
    $.each(data.ResidentialTypes, function(indexResidentialTypes, valueResidentialTypes) {
      ret.ResidentialTypes[indexResidentialTypes] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret.ResidentialTypes[indexResidentialTypes], valueResidentialTypes);
    });
    ret.ApplicantResidentialTypes =  new Array();
    $.each(data.ApplicantResidentialTypes, function(indexApplicantResidentialTypes, valueApplicantResidentialTypes) {
      ret.ApplicantResidentialTypes[indexApplicantResidentialTypes] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.ApplicantResidentialStatus();
      jQuery.extend(ret.ApplicantResidentialTypes[indexApplicantResidentialTypes], valueApplicantResidentialTypes);
    });
    ret.LivingArrangements =  new Array();
    $.each(data.LivingArrangements, function(indexLivingArrangements, valueLivingArrangements) {
      ret.LivingArrangements[indexLivingArrangements] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret.LivingArrangements[indexLivingArrangements], valueLivingArrangements);
    });
    ret.ApplicantLivingArrangements =  new Array();
    $.each(data.ApplicantLivingArrangements, function(indexApplicantLivingArrangements, valueApplicantLivingArrangements) {
      ret.ApplicantLivingArrangements[indexApplicantLivingArrangements] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.ApplicantLivingArrangement();
      jQuery.extend(ret.ApplicantLivingArrangements[indexApplicantLivingArrangements], valueApplicantLivingArrangements);
    });
    ret.IncomeTypes =  new Array();
    $.each(data.IncomeTypes, function(indexIncomeTypes, valueIncomeTypes) {
      ret.IncomeTypes[indexIncomeTypes] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret.IncomeTypes[indexIncomeTypes], valueIncomeTypes);
    });
    ret.InsuranceProviders =  new Array();
    $.each(data.InsuranceProviders, function(indexInsuranceProviders, valueInsuranceProviders) {
      ret.InsuranceProviders[indexInsuranceProviders] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret.InsuranceProviders[indexInsuranceProviders], valueInsuranceProviders);
    });
    ret.Countries =  new Array();
    $.each(data.Countries, function(indexCountries, valueCountries) {
      ret.Countries[indexCountries] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret.Countries[indexCountries], valueCountries);
    });
    ret.FlatOrBoxTypes =  new Array();
    $.each(data.FlatOrBoxTypes, function(indexFlatOrBoxTypes, valueFlatOrBoxTypes) {
      ret.FlatOrBoxTypes[indexFlatOrBoxTypes] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret.FlatOrBoxTypes[indexFlatOrBoxTypes], valueFlatOrBoxTypes);
    });
    ret.AddressStatus =  new Array();
    $.each(data.AddressStatus, function(indexAddressStatus, valueAddressStatus) {
      ret.AddressStatus[indexAddressStatus] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret.AddressStatus[indexAddressStatus], valueAddressStatus);
    });
    ret.RelationshipTypes =  new Array();
    $.each(data.RelationshipTypes, function(indexRelationshipTypes, valueRelationshipTypes) {
      ret.RelationshipTypes[indexRelationshipTypes] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret.RelationshipTypes[indexRelationshipTypes], valueRelationshipTypes);
    });
    ret.InvalidResidentialStreetTypes =  new Array();
    $.each(data.InvalidResidentialStreetTypes, function(indexInvalidResidentialStreetTypes, valueInvalidResidentialStreetTypes) {
      ret.InvalidResidentialStreetTypes[indexInvalidResidentialStreetTypes] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.AddressTypeMapping();
      jQuery.extend(ret.InvalidResidentialStreetTypes[indexInvalidResidentialStreetTypes], valueInvalidResidentialStreetTypes);
    });
    ret.AllStreetTypes =  new Array();
    $.each(data.AllStreetTypes, function(indexAllStreetTypes, valueAllStreetTypes) {
      ret.AllStreetTypes[indexAllStreetTypes] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.AddressTypeMapping();
      jQuery.extend(ret.AllStreetTypes[indexAllStreetTypes], valueAllStreetTypes);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Loans.MappingService.FindByGroup = function (group, lookup) {
  var uriTemplate = 'mappings/mapping/findbygroup/{group}/{lookup}';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(group));
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(lookup));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  uriTemplate = uriTemplate.replace('{group}', group);

  uriTemplate = uriTemplate.replace('{lookup}', lookup);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexGenericMapping, valueGenericMapping) {
      ret[indexGenericMapping] = new DataAction.Edc.Services.Model.Loans.Public.Mapping.GenericMapping();
      jQuery.extend(ret[indexGenericMapping], valueGenericMapping);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.ConfigurationValuesService.GetConfigurationValues = function () {
  var uriTemplate = 'ConfigurationValues/GetConfigurationValues';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Config.ConfigurationValues();
    jQuery.extend(ret, data);
    ret.factor2OnRegistration = new DataAction.Edc.Services.Model.Security.Factor2OnRegistration();
    jQuery.extend(ret.factor2OnRegistration, data.factor2OnRegistration);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.AddressVerificationService.AddressSearch = function (paritalAddress) {
  var uriTemplate = 'addresses/address_search';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(paritalAddress));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(paritalAddress);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Addresses.AddressSearchResult();
    jQuery.extend(ret, data);
    ret.Items =  new Array();
    $.each(data.Items, function(indexItems, valueItems) {
      ret.Items[indexItems] = new DataAction.Edc.Services.Model.Addresses.AddressSearchItem();
      jQuery.extend(ret.Items[indexItems], valueItems);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.AddressVerificationService.FormatAddress = function (moniker) {
  var uriTemplate = 'addresses/format_address';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(moniker));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(moniker);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Addresses.Address();
    jQuery.extend(ret, data);
    ret.AddressLines =  new Array();
    $.each(data.AddressLines, function(indexAddressLines, valueAddressLines) {
      ret.AddressLines[indexAddressLines] = new DataAction.Edc.Services.Model.Addresses.AddressLine();
      jQuery.extend(ret.AddressLines[indexAddressLines], valueAddressLines);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.TransactionService.GetTransactionHistory = function (search) {
  var uriTemplate = 'transactions/history';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(search));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(search);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.History.TransactionHistory();
    jQuery.extend(ret, data);
    ret.TransactionDetails =  new Array();
    $.each(data.TransactionDetails, function(indexTransactionDetails, valueTransactionDetails) {
      ret.TransactionDetails[indexTransactionDetails] = new DataAction.Edc.Services.Model.History.TransactionDetail();
      jQuery.extend(ret.TransactionDetails[indexTransactionDetails], valueTransactionDetails);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.TransactionService.MakeImmediateMembershipTransaction = function (transferDetails) {
  var uriTemplate = 'transactions/membership/now';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(transferDetails));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(transferDetails);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Transfer.Receipt();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.TransactionService.ValidateInstitutionSurname = function (search) {
  var uriTemplate = 'transactions/institution/valid';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(search));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(search);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.TransactionService.MakeImmediateInstitutionTransaction = function (transferDetails) {
  var uriTemplate = 'transactions/institution/now';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(transferDetails));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(transferDetails);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Transfer.Receipt();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.TransactionService.GetSavedInstitutionTransactions = function (search) {
  var uriTemplate = 'transactions/institution/search';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(search));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(search);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexInstitutionPayee, valueInstitutionPayee) {
      ret[indexInstitutionPayee] = new DataAction.Edc.Services.Model.SavedTransactions.InstitutionPayee();
      jQuery.extend(ret[indexInstitutionPayee], valueInstitutionPayee);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.TransactionService.GetExternalBsbName = function (bsb) {
  var uriTemplate = 'transactions/external/{bsb}/name';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(bsb));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  uriTemplate = uriTemplate.replace('{bsb}', bsb);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Transfer.ExternalBsb();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.TransactionService.MakeImmediateExternalTransaction = function (transferDetails) {
  var uriTemplate = 'transactions/external/now';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(transferDetails));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(transferDetails);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Transfer.Receipt();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.TransactionService.GetSavedExternalTransactions = function (search) {
  var uriTemplate = 'transactions/external/search';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(search));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(search);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexExternalPayee, valueExternalPayee) {
      ret[indexExternalPayee] = new DataAction.Edc.Services.Model.SavedTransactions.ExternalPayee();
      jQuery.extend(ret[indexExternalPayee], valueExternalPayee);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.ModelService.Model = function () {
  var uriTemplate = 'models/model';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.ModelService.Dal = function () {
  var uriTemplate = 'models/dal';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.ModelService.Meta = function () {
  var uriTemplate = 'models/meta';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.ModelService.Config = function () {
  var uriTemplate = 'models/config';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Staff.StaffService.CreateLog = function (request) {
  var uriTemplate = 'staff/staffchannel/createlog';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(request));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(request);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Staff.CreateStaffChannelLogResponse();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.DeviceService.GenerateDeviceId = function () {
  var uriTemplate = 'devices/deviceId';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.DeviceService.DeviceAuthorised = function (device) {
  var uriTemplate = 'devices/authorised';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(device));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(device);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.DeviceService.ChangeNotificationId = function (changeNotificationIdRequest) {
  var uriTemplate = 'devices/notificationId';
  var type = 'PUT';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(changeNotificationIdRequest));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(changeNotificationIdRequest);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.DeviceService.GetRegisteredDevices = function () {
  var uriTemplate = 'devices/';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexDevice, valueDevice) {
      ret[indexDevice] = new DataAction.Edc.Services.Model.Device.Device();
      jQuery.extend(ret[indexDevice], valueDevice);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.DeviceService.GetRegisteredDevicesForApplication = function (platformApplication) {
  var uriTemplate = 'devices/application/devices';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(platformApplication));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(platformApplication);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexDevice, valueDevice) {
      ret[indexDevice] = new DataAction.Edc.Services.Model.Device.Device();
      jQuery.extend(ret[indexDevice], valueDevice);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.DeviceService.Register = function (device) {
  var uriTemplate = 'devices/register';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(device));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(device);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Session.Session();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.DeviceService.ChangePin = function (changePinRequest) {
  var uriTemplate = 'devices/pin';
  var type = 'PUT';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(changePinRequest));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(changePinRequest);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.DeviceService.Deregister = function (device) {
  var uriTemplate = 'devices/deregister';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(device));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(device);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.DeviceService.ChangeAllowNotification = function (device) {
  var uriTemplate = 'devices/allowNotification';
  var type = 'PUT';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(device));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(device);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.AreLoansOnline = function (loanStatusRequest) {
  var uriTemplate = 'loans/public/areloansonline';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(loanStatusRequest));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(loanStatusRequest);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Loans.LoanStatusResponse();
    jQuery.extend(ret, data);
    ret.Error = new DataAction.Edc.Services.Model.Error.Error();
    jQuery.extend(ret.Error, data.Error);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.SavePublicApplication = function (loanObject) {
  var uriTemplate = 'loans/public/save';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(loanObject));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(loanObject);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Loans.Public.LoanSession();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.GetPublicApplications = function (loginDetails) {
  var uriTemplate = 'loans/public/load';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(loginDetails));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(loginDetails);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexLoanApplication, valueLoanApplication) {
      ret[indexLoanApplication] = new DataAction.Edc.Services.Model.Loans.Public.LoanApplication();
      jQuery.extend(ret[indexLoanApplication], valueLoanApplication);
      ret[indexLoanApplication].LoanObject = new DataAction.Edc.Services.Model.Loans.Public.LoanData();
      jQuery.extend(ret[indexLoanApplication].LoanObject, valueLoanApplication.LoanObject);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.GetPublicApplication = function (loanSession) {
  var uriTemplate = 'loans/public/load/session';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(loanSession));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(loanSession);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Loans.Public.LoanApplication();
    jQuery.extend(ret, data);
    ret.LoanObject = new DataAction.Edc.Services.Model.Loans.Public.LoanData();
    jQuery.extend(ret.LoanObject, data.LoanObject);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.StaffLogin = function (request) {
  var uriTemplate = 'loans/public/stafflogin';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(request));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(request);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Loans.Public.LoginResponse();
    jQuery.extend(ret, data);
    ret.Application = new DataAction.Edc.Services.Model.Loans.Public.LoanApplication();
    jQuery.extend(ret.Application, data.Application);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.DisablePublicApplication = function (loanObject) {
  var uriTemplate = 'loans/public/disable';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(loanObject));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(loanObject);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.SubmitPublicLoanApplication = function (loanObject) {
  var uriTemplate = 'loans/public/submit';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(loanObject));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(loanObject);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Loans.Public.LoanSession();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.GetNewLoanObject = function () {
  var uriTemplate = 'loans/public/loandata';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Loans.Public.LoanData();
    jQuery.extend(ret, data);
    ret.LoanConfig = new DataAction.Edc.Services.Model.Loans.Public.LoanConfig();
    jQuery.extend(ret.LoanConfig, data.LoanConfig);
    ret.LoanDetail = new DataAction.Edc.Services.Model.Loans.Public.LoanDetail();
    jQuery.extend(ret.LoanDetail, data.LoanDetail);
    ret.CompletionDetail = new DataAction.Edc.Services.Model.Loans.Public.CompletionDetail();
    jQuery.extend(ret.CompletionDetail, data.CompletionDetail);
    ret.KeyValues =  new Array();
    $.each(data.KeyValues, function(indexKeyValues, valueKeyValues) {
      ret.KeyValues[indexKeyValues] = new DataAction.Edc.Services.Model.Loans.Public.KeyValuePair();
      jQuery.extend(ret.KeyValues[indexKeyValues], valueKeyValues);
    });
    ret.Applicants =  new Array();
    $.each(data.Applicants, function(indexApplicants, valueApplicants) {
      ret.Applicants[indexApplicants] = new DataAction.Edc.Services.Model.Loans.Public.Applicant();
      jQuery.extend(ret.Applicants[indexApplicants], valueApplicants);
    });
    ret.Employments =  new Array();
    $.each(data.Employments, function(indexEmployments, valueEmployments) {
      ret.Employments[indexEmployments] = new DataAction.Edc.Services.Model.Loans.Public.Employment();
      jQuery.extend(ret.Employments[indexEmployments], valueEmployments);
    });
    ret.Incomes =  new Array();
    $.each(data.Incomes, function(indexIncomes, valueIncomes) {
      ret.Incomes[indexIncomes] = new DataAction.Edc.Services.Model.Loans.Public.Income();
      jQuery.extend(ret.Incomes[indexIncomes], valueIncomes);
    });
    ret.Deductions =  new Array();
    $.each(data.Deductions, function(indexDeductions, valueDeductions) {
      ret.Deductions[indexDeductions] = new DataAction.Edc.Services.Model.Loans.Public.Deduction();
      jQuery.extend(ret.Deductions[indexDeductions], valueDeductions);
    });
    ret.Dependants =  new Array();
    $.each(data.Dependants, function(indexDependants, valueDependants) {
      ret.Dependants[indexDependants] = new DataAction.Edc.Services.Model.Loans.Public.Dependant();
      jQuery.extend(ret.Dependants[indexDependants], valueDependants);
    });
    ret.Assets =  new Array();
    $.each(data.Assets, function(indexAssets, valueAssets) {
      ret.Assets[indexAssets] = new DataAction.Edc.Services.Model.Loans.Public.Asset();
      jQuery.extend(ret.Assets[indexAssets], valueAssets);
    });
    ret.Liabilities =  new Array();
    $.each(data.Liabilities, function(indexLiabilities, valueLiabilities) {
      ret.Liabilities[indexLiabilities] = new DataAction.Edc.Services.Model.Loans.Public.Liability();
      jQuery.extend(ret.Liabilities[indexLiabilities], valueLiabilities);
    });
    ret.Expenses =  new Array();
    $.each(data.Expenses, function(indexExpenses, valueExpenses) {
      ret.Expenses[indexExpenses] = new DataAction.Edc.Services.Model.Loans.Public.Expense();
      jQuery.extend(ret.Expenses[indexExpenses], valueExpenses);
    });
    ret.OtherAddresses =  new Array();
    $.each(data.OtherAddresses, function(indexOtherAddresses, valueOtherAddresses) {
      ret.OtherAddresses[indexOtherAddresses] = new DataAction.Edc.Services.Model.Loans.Public.OtherAddress();
      jQuery.extend(ret.OtherAddresses[indexOtherAddresses], valueOtherAddresses);
    });
    ret.References =  new Array();
    $.each(data.References, function(indexReferences, valueReferences) {
      ret.References[indexReferences] = new DataAction.Edc.Services.Model.Loans.Public.Reference();
      jQuery.extend(ret.References[indexReferences], valueReferences);
    });
    ret.ApplicantConfirmations =  new Array();
    $.each(data.ApplicantConfirmations, function(indexApplicantConfirmations, valueApplicantConfirmations) {
      ret.ApplicantConfirmations[indexApplicantConfirmations] = new DataAction.Edc.Services.Model.Loans.Public.ApplicantConfirmation();
      jQuery.extend(ret.ApplicantConfirmations[indexApplicantConfirmations], valueApplicantConfirmations);
    });
    ret.Questions =  new Array();
    $.each(data.Questions, function(indexQuestions, valueQuestions) {
      ret.Questions[indexQuestions] = new DataAction.Edc.Services.Model.Loans.Public.ApplicationQuestion();
      jQuery.extend(ret.Questions[indexQuestions], valueQuestions);
    });
    ret.Answers =  new Array();
    $.each(data.Answers, function(indexAnswers, valueAnswers) {
      ret.Answers[indexAnswers] = new DataAction.Edc.Services.Model.Loans.Public.ApplicantAnswer();
      jQuery.extend(ret.Answers[indexAnswers], valueAnswers);
    });
    ret.IdentityVerifications =  new Array();
    $.each(data.IdentityVerifications, function(indexIdentityVerifications, valueIdentityVerifications) {
      ret.IdentityVerifications[indexIdentityVerifications] = new DataAction.Edc.Services.Model.Veda.IdentityVerificationObject();
      jQuery.extend(ret.IdentityVerifications[indexIdentityVerifications], valueIdentityVerifications);
    });
    ret.Relationships =  new Array();
    $.each(data.Relationships, function(indexRelationships, valueRelationships) {
      ret.Relationships[indexRelationships] = new DataAction.Edc.Services.Model.Loans.Public.Relationship();
      jQuery.extend(ret.Relationships[indexRelationships], valueRelationships);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.GetIndicativeApproval = function (loanData) {
  var uriTemplate = 'loans/public/approval';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(loanData));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(loanData);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Loans.Public.IndicativeApprovalResult();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.GetLoanTypes = function () {
  var uriTemplate = 'loans/public/loantypes';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexLoanTypes, valueLoanTypes) {
      ret[indexLoanTypes] = new DataAction.Edc.Services.Model.Loans.Public.LoanTypes();
      jQuery.extend(ret[indexLoanTypes], valueLoanTypes);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.GetPrimaryPurposes = function () {
  var uriTemplate = 'loans/public/primarypurposes';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexPrimaryPurposes, valuePrimaryPurposes) {
      ret[indexPrimaryPurposes] = new DataAction.Edc.Services.Model.Loans.Public.PrimaryPurposes();
      jQuery.extend(ret[indexPrimaryPurposes], valuePrimaryPurposes);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.ForgotPassword = function (email) {
  var uriTemplate = 'loans/public/forgotpassword';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(email));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(email);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.ChangePassword = function (changePassword) {
  var uriTemplate = 'loans/public/changepassword';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(changePassword));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(changePassword);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.PasswordToBeChanged = function (loginDetails) {
  var uriTemplate = 'loans/public/passwordtobechanged';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(loginDetails));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(loginDetails);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.LoanToLoansOfficer = function (loansOfficerApplication) {
  var uriTemplate = 'loans/public/loantoloansofficer';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(loansOfficerApplication));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(loansOfficerApplication);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.IsLendingSwitchedOn = function () {
  var uriTemplate = 'loans/public/lendingswitchedon';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.IsLendingConfigured = function () {
  var uriTemplate = 'loans/public/lendingconfigured';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.FlagLoanApplicationAsSubmitted = function (loanApplication) {
  var uriTemplate = 'loans/public/flagloanassubmitted';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(loanApplication));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(loanApplication);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LoanService.LoanTypeAlreadyPresent = function (loanObject) {
  var uriTemplate = 'loans/public/loantypealreadypresent';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(loanObject));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(loanObject);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.PersonToPersonTransferService.MakePersonToPersonTransaction = function (transferDetails) {
  var uriTemplate = 'personToPersonTransfer/';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(transferDetails));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(transferDetails);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.P2P.TransactionReceipt();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.PersonToPersonTransferService.GetUnclaimedTransactions = function () {
  var uriTemplate = 'personToPersonTransfer/unclaimed';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexPersonToPersonTransaction, valuePersonToPersonTransaction) {
      ret[indexPersonToPersonTransaction] = new DataAction.Edc.Services.Model.P2P.PersonToPersonTransaction();
      jQuery.extend(ret[indexPersonToPersonTransaction], valuePersonToPersonTransaction);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.PersonToPersonTransferService.GetUnclaimedTransactionsByAccount = function (fromAccount) {
  var uriTemplate = 'personToPersonTransfer/unclaimedbyaccount';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(fromAccount));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(fromAccount);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexPersonToPersonTransaction, valuePersonToPersonTransaction) {
      ret[indexPersonToPersonTransaction] = new DataAction.Edc.Services.Model.P2P.PersonToPersonTransaction();
      jQuery.extend(ret[indexPersonToPersonTransaction], valuePersonToPersonTransaction);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.PersonToPersonTransferService.CancelClaim = function (request) {
  var uriTemplate = 'personToPersonTransfer/cancel';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(request));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(request);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.PersonToPersonTransferService.Claim = function (request) {
  var uriTemplate = 'personToPersonTransfer/claim';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(request));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(request);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.P2P.ClaimResponse();
    jQuery.extend(ret, data);
    ret.Error = new DataAction.Edc.Services.Model.Error.Error();
    jQuery.extend(ret.Error, data.Error);
    ret.Receipt = new DataAction.Edc.Services.Model.Transfer.Receipt();
    jQuery.extend(ret.Receipt, data.Receipt);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.ECorrespondenceService.GetECorrespondence = function () {
  var uriTemplate = 'ECorrespondence/GetECorrespondence';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.User.ECorrespondence();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.ECorrespondenceService.SetECorrespondence = function (eCorrespondence) {
  var uriTemplate = 'ECorrespondence/SetECorrespondence';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(eCorrespondence));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(eCorrespondence);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.CardStatusService.GetInactiveCards = function () {
  var uriTemplate = 'CardStatus/GetInactiveCards';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexCard, valueCard) {
      ret[indexCard] = new DataAction.Edc.Services.Model.CardStatus.Card();
      jQuery.extend(ret[indexCard], valueCard);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.CardStatusService.GetActiveCards = function () {
  var uriTemplate = 'CardStatus/GetActiveCards';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexCard, valueCard) {
      ret[indexCard] = new DataAction.Edc.Services.Model.CardStatus.Card();
      jQuery.extend(ret[indexCard], valueCard);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.CardStatusService.ActivateCard = function (cardId, expiryDate) {
  var uriTemplate = 'CardStatus/ActivateCard/{cardId}/{expiryDate}';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(cardId));
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(expiryDate));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(cardId);
  uriTemplate = uriTemplate.replace('{cardId}', cardId);

  postData += JSON.stringify(expiryDate);
  uriTemplate = uriTemplate.replace('{expiryDate}', expiryDate);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.CardStatus.Receipt();
    jQuery.extend(ret, data);
    ret.Card = new DataAction.Edc.Services.Model.CardStatus.Card();
    jQuery.extend(ret.Card, data.Card);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LookupService.GetSomeLookupValues = function (lookupList) {
  var uriTemplate = 'lookups/lookup/some/{lookupList}';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(lookupList));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  uriTemplate = uriTemplate.replace('{lookupList}', lookupList);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexAllLookupData, valueAllLookupData) {
      ret[indexAllLookupData] = new DataAction.Edc.Services.Model.Loans.AllLookupData();
      jQuery.extend(ret[indexAllLookupData], valueAllLookupData);
      ret[indexAllLookupData].LookupData =  new Array();
      $.each(valueAllLookupData.LookupData, function(indexLookupData, valueLookupData) {
        ret[indexAllLookupData].LookupData[indexLookupData] = new DataAction.Edc.Services.Model.Loans.Lookup();
        jQuery.extend(ret[indexAllLookupData].LookupData[indexLookupData], valueLookupData);
      });
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LookupService.GetProductQuestions = function (productQuestionFilter) {
  var uriTemplate = 'lookups/lookup/productquestions';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(productQuestionFilter));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(productQuestionFilter);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexApplicationQuestion, valueApplicationQuestion) {
      ret[indexApplicationQuestion] = new DataAction.Edc.Services.Model.Loans.Public.ApplicationQuestion();
      jQuery.extend(ret[indexApplicationQuestion], valueApplicationQuestion);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LookupService.IsProductConfiguredForCCI = function (productId) {
  var uriTemplate = 'lookups/lookup/productconfiguredforcci/{productId}';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(productId));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(productId);
  uriTemplate = uriTemplate.replace('{productId}', productId);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.LookupService.GetFinancialInstitutions = function () {
  var uriTemplate = 'lookups/lookup/financialinstitutions';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexFinancialInstitution, valueFinancialInstitution) {
      ret[indexFinancialInstitution] = new DataAction.Edc.Services.Model.Loans.Public.FinancialInstitution();
      jQuery.extend(ret[indexFinancialInstitution], valueFinancialInstitution);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Loans.PurposeService.GetAll = function (productId) {
  var uriTemplate = 'purposes/purpose/getall/{productId}';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(productId));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  uriTemplate = uriTemplate.replace('{productId}', productId);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexPurpose, valuePurpose) {
      ret[indexPurpose] = new DataAction.Edc.Services.Model.Loans.Purpose();
      jQuery.extend(ret[indexPurpose], valuePurpose);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.VedaService.GetIdentityVerificationResult = function (dataForIdentityVerification) {
  var uriTemplate = 'IdentityVerification/IdentityVerification';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(dataForIdentityVerification));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(dataForIdentityVerification);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Veda.IdentityVerificationResponse();
    jQuery.extend(ret, data);
    ret.IdentityVerificationError = new DataAction.Edc.Services.Model.Veda.IdentityVerificationError();
    jQuery.extend(ret.IdentityVerificationError, data.IdentityVerificationError);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.VedaService.GetDetailsFromLoanObject = function (guid, applicantId) {
  var uriTemplate = 'IdentityVerification/DetailsFromLoanObject/{guid}/{applicantId}';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(guid));
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(applicantId));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(guid);
  uriTemplate = uriTemplate.replace('{guid}', guid);

  postData += JSON.stringify(applicantId);
  uriTemplate = uriTemplate.replace('{applicantId}', applicantId);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Veda.IdentityVerification();
    jQuery.extend(ret, data);
    ret.BirthCertificateRegisteredOtherName =  new Array();
    $.each(data.BirthCertificateRegisteredOtherName, function(indexBirthCertificateRegisteredOtherName, valueBirthCertificateRegisteredOtherName) {
      ret.BirthCertificateRegisteredOtherName[indexBirthCertificateRegisteredOtherName] = new System.String();
      jQuery.extend(ret.BirthCertificateRegisteredOtherName[indexBirthCertificateRegisteredOtherName], valueBirthCertificateRegisteredOtherName);
    });
    ret.PassportOtherGivenNameAtCitizenship =  new Array();
    $.each(data.PassportOtherGivenNameAtCitizenship, function(indexPassportOtherGivenNameAtCitizenship, valuePassportOtherGivenNameAtCitizenship) {
      ret.PassportOtherGivenNameAtCitizenship[indexPassportOtherGivenNameAtCitizenship] = new System.String();
      jQuery.extend(ret.PassportOtherGivenNameAtCitizenship[indexPassportOtherGivenNameAtCitizenship], valuePassportOtherGivenNameAtCitizenship);
    });
    ret.OtherGivenName =  new Array();
    $.each(data.OtherGivenName, function(indexOtherGivenName, valueOtherGivenName) {
      ret.OtherGivenName[indexOtherGivenName] = new System.String();
      jQuery.extend(ret.OtherGivenName[indexOtherGivenName], valueOtherGivenName);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.GetMemberRegistration = function () {
  var uriTemplate = 'alerts/';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Alerts.MemberRegistrationDetails();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.UpdateMemberRegistration = function (registrationRequest) {
  var uriTemplate = 'alerts/';
  var type = 'PUT';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(registrationRequest));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(registrationRequest);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.DeregisterMember = function () {
  var uriTemplate = 'alerts/';
  var type = 'DELETE';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.RegisterDirectCreditAlert = function (alert) {
  var uriTemplate = 'alerts/alerts/direct_credit';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(alert));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(alert);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.RegisterDirectDebitAlert = function (alert) {
  var uriTemplate = 'alerts/alerts/direct_debit';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(alert));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(alert);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.RegisterAccountBalanceAlert = function (alert) {
  var uriTemplate = 'alerts/alerts/account_balance';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(alert));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(alert);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.ModifyAccountBalanceAlert = function (alert) {
  var uriTemplate = 'alerts/alerts/account_balance';
  var type = 'PUT';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(alert));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(alert);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.RegisterScheduleBalanceAdviceAlert = function (alert) {
  var uriTemplate = 'alerts/alerts/scheduled_balance_advice';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(alert));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(alert);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.ModifyScheduleBalanceAdviceAlert = function (alert) {
  var uriTemplate = 'alerts/alerts/scheduled_balance_advice';
  var type = 'PUT';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(alert));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(alert);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.RegisterPayWaveOrPayPassAlert = function (alert) {
  var uriTemplate = 'alerts/alerts/pay_wave_or_pay_pass';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(alert));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(alert);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.ModifyPayWaveOrPayPassAlert = function (alert) {
  var uriTemplate = 'alerts/alerts/pay_wave_or_pay_pass';
  var type = 'PUT';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(alert));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(alert);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.RegisterAtmWithdrawalAlert = function (alert) {
  var uriTemplate = 'alerts/alerts/atm_withdrawal';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(alert));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(alert);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.ModifyAtmWithdrawalAlert = function (alert) {
  var uriTemplate = 'alerts/alerts/atm_withdrawal';
  var type = 'PUT';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(alert));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(alert);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.RegisterCreditCardAlert = function (alert) {
  var uriTemplate = 'alerts/alerts/credit_card';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(alert));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(alert);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.ModifyCreditCardAlert = function (alert) {
  var uriTemplate = 'alerts/alerts/credit_card';
  var type = 'PUT';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(alert));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(alert);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.RegisterEFTPOSAlert = function (alert) {
  var uriTemplate = 'alerts/alerts/eftpos';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(alert));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(alert);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.ModifyEFTPOSAlert = function (alert) {
  var uriTemplate = 'alerts/alerts/eftpos';
  var type = 'PUT';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(alert));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(alert);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.RegisterThresholdAlert = function (alert) {
  var uriTemplate = 'alerts/alerts/threshold';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(alert));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(alert);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.ModifyThresholdAlert = function (alert) {
  var uriTemplate = 'alerts/alerts/threshold';
  var type = 'PUT';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(alert));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(alert);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.RegisterRegistrationConfirmAlert = function (alert) {
  var uriTemplate = 'alerts/alerts/registration_confirm';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(alert));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(alert);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.DeregisterAlert = function (registrationId) {
  var uriTemplate = 'alerts/alerts/{registrationId}';
  var type = 'DELETE';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(registrationId));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  uriTemplate = uriTemplate.replace('{registrationId}', registrationId);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.GetMemberAlertRegistration = function () {
  var uriTemplate = 'alerts/alerts';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Alerts.AlertCollection();
    jQuery.extend(ret, data);
    ret.DirectCreditAlerts =  new Array();
    $.each(data.DirectCreditAlerts, function(indexDirectCreditAlerts, valueDirectCreditAlerts) {
      ret.DirectCreditAlerts[indexDirectCreditAlerts] = new DataAction.Edc.Services.Model.Alerts.DirectCreditAlert();
      jQuery.extend(ret.DirectCreditAlerts[indexDirectCreditAlerts], valueDirectCreditAlerts);
    });
    ret.DirectDebitAlerts =  new Array();
    $.each(data.DirectDebitAlerts, function(indexDirectDebitAlerts, valueDirectDebitAlerts) {
      ret.DirectDebitAlerts[indexDirectDebitAlerts] = new DataAction.Edc.Services.Model.Alerts.DirectDebitAlert();
      jQuery.extend(ret.DirectDebitAlerts[indexDirectDebitAlerts], valueDirectDebitAlerts);
    });
    ret.AccountBalanceAlerts =  new Array();
    $.each(data.AccountBalanceAlerts, function(indexAccountBalanceAlerts, valueAccountBalanceAlerts) {
      ret.AccountBalanceAlerts[indexAccountBalanceAlerts] = new DataAction.Edc.Services.Model.Alerts.AccountBalanceAlert();
      jQuery.extend(ret.AccountBalanceAlerts[indexAccountBalanceAlerts], valueAccountBalanceAlerts);
    });
    ret.ScheduledBalanceAdviceAlerts =  new Array();
    $.each(data.ScheduledBalanceAdviceAlerts, function(indexScheduledBalanceAdviceAlerts, valueScheduledBalanceAdviceAlerts) {
      ret.ScheduledBalanceAdviceAlerts[indexScheduledBalanceAdviceAlerts] = new DataAction.Edc.Services.Model.Alerts.ScheduleBalanceAdviceAlert();
      jQuery.extend(ret.ScheduledBalanceAdviceAlerts[indexScheduledBalanceAdviceAlerts], valueScheduledBalanceAdviceAlerts);
    });
    ret.PayWaveOrPayPassAlerts =  new Array();
    $.each(data.PayWaveOrPayPassAlerts, function(indexPayWaveOrPayPassAlerts, valuePayWaveOrPayPassAlerts) {
      ret.PayWaveOrPayPassAlerts[indexPayWaveOrPayPassAlerts] = new DataAction.Edc.Services.Model.Alerts.PayWaveOrPayPassAlert();
      jQuery.extend(ret.PayWaveOrPayPassAlerts[indexPayWaveOrPayPassAlerts], valuePayWaveOrPayPassAlerts);
    });
    ret.AtmWithdrawalAlerts =  new Array();
    $.each(data.AtmWithdrawalAlerts, function(indexAtmWithdrawalAlerts, valueAtmWithdrawalAlerts) {
      ret.AtmWithdrawalAlerts[indexAtmWithdrawalAlerts] = new DataAction.Edc.Services.Model.Alerts.AtmWithdrawalAlert();
      jQuery.extend(ret.AtmWithdrawalAlerts[indexAtmWithdrawalAlerts], valueAtmWithdrawalAlerts);
    });
    ret.CreditCardAlerts =  new Array();
    $.each(data.CreditCardAlerts, function(indexCreditCardAlerts, valueCreditCardAlerts) {
      ret.CreditCardAlerts[indexCreditCardAlerts] = new DataAction.Edc.Services.Model.Alerts.CreditCardAlert();
      jQuery.extend(ret.CreditCardAlerts[indexCreditCardAlerts], valueCreditCardAlerts);
    });
    ret.EFTPOSAlerts =  new Array();
    $.each(data.EFTPOSAlerts, function(indexEFTPOSAlerts, valueEFTPOSAlerts) {
      ret.EFTPOSAlerts[indexEFTPOSAlerts] = new DataAction.Edc.Services.Model.Alerts.EFTPOSAlert();
      jQuery.extend(ret.EFTPOSAlerts[indexEFTPOSAlerts], valueEFTPOSAlerts);
    });
    ret.ThresholdAlerts =  new Array();
    $.each(data.ThresholdAlerts, function(indexThresholdAlerts, valueThresholdAlerts) {
      ret.ThresholdAlerts[indexThresholdAlerts] = new DataAction.Edc.Services.Model.Alerts.ThresholdAlert();
      jQuery.extend(ret.ThresholdAlerts[indexThresholdAlerts], valueThresholdAlerts);
    });
    ret.RegistrationConfirmAlerts =  new Array();
    $.each(data.RegistrationConfirmAlerts, function(indexRegistrationConfirmAlerts, valueRegistrationConfirmAlerts) {
      ret.RegistrationConfirmAlerts[indexRegistrationConfirmAlerts] = new DataAction.Edc.Services.Model.Alerts.RegistrationConfirmAlert();
      jQuery.extend(ret.RegistrationConfirmAlerts[indexRegistrationConfirmAlerts], valueRegistrationConfirmAlerts);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.GetMemberNotifications = function () {
  var uriTemplate = 'alerts/notifications';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexNotification, valueNotification) {
      ret[indexNotification] = new DataAction.Edc.Services.Model.Alerts.Notification();
      jQuery.extend(ret[indexNotification], valueNotification);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.GetAlertTypes = function () {
  var uriTemplate = 'alerts/alertTypes';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexAlertTypeDetails, valueAlertTypeDetails) {
      ret[indexAlertTypeDetails] = new DataAction.Edc.Services.Model.Alerts.AlertTypeDetails();
      jQuery.extend(ret[indexAlertTypeDetails], valueAlertTypeDetails);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.GetMessageTransactions = function (queueId) {
  var uriTemplate = 'alerts/{queueId}/transactions';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(queueId));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  uriTemplate = uriTemplate.replace('{queueId}', queueId);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexNotificationTransactionDetails, valueNotificationTransactionDetails) {
      ret[indexNotificationTransactionDetails] = new DataAction.Edc.Services.Model.Alerts.NotificationTransactionDetails();
      jQuery.extend(ret[indexNotificationTransactionDetails], valueNotificationTransactionDetails);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.GetMemberSettings = function () {
  var uriTemplate = 'alerts/settings';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Alerts.MemberSettings();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.AlertService.UpdateMemberSettings = function (memberSettings) {
  var uriTemplate = 'alerts/settings';
  var type = 'PUT';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(memberSettings));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(memberSettings);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Factor2Service.RequestChallenge = function (request) {
  var uriTemplate = 'factor2/challenge';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(request));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(request);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Factor2Service.RequestChallengeFromLogin = function (request) {
  var uriTemplate = 'factor2/challengefromlogin';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(request));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(request);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Security.ChallengeResponseFromLogin();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Factor2Service.ClearChallenge = function () {
  var uriTemplate = 'factor2/clear';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve();
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Factor2Service.ChallengeResponse = function (request) {
  var uriTemplate = 'factor2/response';
  var type = '';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(request));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }


  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Security.ChallengeResponse();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Factor2Service.GetEnabledFunctions = function () {
  var uriTemplate = 'factor2/enabled';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexFactor2SettingDto, valueFactor2SettingDto) {
      ret[indexFactor2SettingDto] = new DataAction.Edc.Services.Model.Security.Factor2SettingDto();
      jQuery.extend(ret[indexFactor2SettingDto], valueFactor2SettingDto);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.Interfaces.Factor2Service.GetMemberFactor2ForDeviceRegistration = function (request) {
  var uriTemplate = 'factor2/memberfactor2type';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(request));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(request);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Security.MemberFactor2Type();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.BpayService.MakeImmediateBpayTransaction = function (transferDetails) {
  var uriTemplate = 'bpay/now';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(transferDetails));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(transferDetails);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Transfer.Receipt();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.BpayService.GetBillerName = function (code) {
  var uriTemplate = 'bpay/{code}/name';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(code));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  uriTemplate = uriTemplate.replace('{code}', code);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Transfer.BpayBiller();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.BpayService.GetSavedBillers = function (search) {
  var uriTemplate = 'bpay/search';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(search));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(search);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new Array();
    $.each(data, function(indexBpayPayment, valueBpayPayment) {
      ret[indexBpayPayment] = new DataAction.Edc.Services.Model.SavedTransactions.BpayPayment();
      jQuery.extend(ret[indexBpayPayment], valueBpayPayment);
    });
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.SessionService.CreateSession = function (token) {
  var uriTemplate = 'session/';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(token));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(token);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Model.Session.Session();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.SessionService.EndSession = function () {
  var uriTemplate = 'session/';
  var type = 'DELETE';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    var ret = new DataAction.Edc.Services.Asl.Response();
    jQuery.extend(ret, data);
    dfd.resolve(ret);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.SessionService.KeepAlive = function (url) {
  var uriTemplate = 'session/keepalive';
  var type = 'POST';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  invalidValidators = invalidValidators.concat(DataAction.Edc.Services.Asl.ModelValidationMethod(url));
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  postData += JSON.stringify(url);

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};

DataAction.Edc.Services.Asl.SessionService.ServerDateTime = function () {
  var uriTemplate = 'session/';
  var type = 'GET';
  var postData = '';
  var dfd = new jQuery.Deferred();

  var invalidValidators = [];
  if (invalidValidators.length > 0) {
    dfd.reject(DataAction.Edc.Services.Asl.ValidationError(invalidValidators));
    return dfd.promise();
  }

  DataAction.Edc.Services.Asl.AjaxCall(DataAction.Edc.Services.Asl.ApiUrl, DataAction.Edc.Services.Asl.ApiKey, DataAction.Edc.Services.Asl.AuthToken, uriTemplate, type, postData)
  .done(function (data, textStatus, jqxhr) {
    dfd.resolve(data);
  }).fail(function (jqxhr, textStatus, errorThrown) {
    dfd.reject(DataAction.Edc.Services.Asl.AjaxError(jqxhr, textStatus, errorThrown));
  });
  return dfd.promise();
};