public async override Task<ServiceInfo> GetServiceInfo(
            AppConfig appConfig,
            CredentialCache credentialCache,
            IHttpProvider httpProvider,
            ClientType clientType = ClientType.Business)
        {
            if (clientType == ClientType.Consumer)
            {
                throw new OneDriveException(
                    new Error
                    {
                        Code = OneDriveErrorCode.AuthenticationFailure.ToString(),
                        Message = "AdalServiceInfoProvider only supports Active Directory authentication."
                    });
            }

            var serviceInfo = await base.GetServiceInfo(appConfig, null, httpProvider, clientType);

            serviceInfo.ServiceResource = appConfig.ActiveDirectoryServiceResource;

            if (string.IsNullOrEmpty(serviceInfo.BaseUrl) && !string.IsNullOrEmpty(serviceInfo.ServiceResource))
            {
                serviceInfo.BaseUrl = string.Format(
                    Constants.Authentication.OneDriveBusinessBaseUrlFormatString,
                    serviceInfo.ServiceResource.TrimEnd('/'),
                    "v2.0");
            }

            if (serviceInfo.AuthenticationProvider == null)
            {
                serviceInfo.AuthenticationProvider = new AdalAuthenticationProvider(serviceInfo);
            }

            return serviceInfo;
        }

 public static IOneDriveClient GetUniversalClient(
     string[] scopes,
     string returnUrl = null,
     IHttpProvider httpProvider = null)
 {
     return OneDriveClientExtensions.GetClientUsingOnlineIdAuthenticator(scopes, returnUrl, httpProvider);
 }

        /// <summary>
        /// Generates the <see cref="ServiceInfo"/> for the current application configuration.
        /// </summary>
        /// <param name="appConfig">The <see cref="AppConfig"/> for the current application.</param>
        /// <param name="credentialCache">The cache instance for storing user credentials.</param>
        /// <param name="httpProvider">The <see cref="IHttpProvider"/> for sending HTTP requests.</param>
        /// <param name="clientType">The <see cref="ClientType"/> to specify the business or consumer service.</param>
        /// <returns>The <see cref="ServiceInfo"/> for the current session.</returns>
        public virtual Task<ServiceInfo> GetServiceInfo(
            AppConfig appConfig,
            CredentialCache credentialCache,
            IHttpProvider httpProvider,
            ClientType clientType)
        {
            if (clientType == ClientType.Consumer)
            {
                var microsoftAccountServiceInfo = new MicrosoftAccountServiceInfo
                {
                    AppId = appConfig.MicrosoftAccountAppId,
                    ClientSecret = appConfig.MicrosoftAccountClientSecret,
                    CredentialCache = credentialCache,
                    HttpProvider = httpProvider,
                    ReturnUrl = appConfig.MicrosoftAccountReturnUrl,
                    Scopes = appConfig.MicrosoftAccountScopes,
                    WebAuthenticationUi = this.webAuthenticationUi,
                };

                microsoftAccountServiceInfo.AuthenticationProvider = this.AuthenticationProvider?? new MicrosoftAccountAuthenticationProvider(microsoftAccountServiceInfo);
                return Task.FromResult<ServiceInfo>(microsoftAccountServiceInfo);
            }

            var activeDirectoryServiceInfo = new ActiveDirectoryServiceInfo
            {
                AppId = appConfig.ActiveDirectoryAppId,
                AuthenticationProvider = this.AuthenticationProvider,
                ClientSecret = appConfig.ActiveDirectoryClientSecret,
                CredentialCache = credentialCache,
                HttpProvider = httpProvider,
                ReturnUrl = appConfig.ActiveDirectoryReturnUrl,
            };
            
            return Task.FromResult<ServiceInfo>(activeDirectoryServiceInfo);
        }

        public async override Task<ServiceInfo> GetServiceInfo(
            AppConfig appConfig,
            CredentialCache credentialCache,
            IHttpProvider httpProvider,
            ClientType clientType = ClientType.Business)
        {
            if (clientType == ClientType.Consumer)
            {
                throw new OneDriveException(
                    new Error
                    {
                        Code = OneDriveErrorCode.AuthenticationFailure.ToString(),
                        Message = "AdalServiceInfoProvider only supports Active Directory authentication."
                    });
            }

            var serviceInfo = await base.GetServiceInfo(appConfig, credentialCache, httpProvider, clientType);

            serviceInfo.BaseUrl = appConfig.ActiveDirectoryServiceEndpointUrl;
            serviceInfo.ServiceResource = appConfig.ActiveDirectoryServiceResource;

            if (serviceInfo.AuthenticationProvider == null)
            {
                serviceInfo.AuthenticationProvider = new AdalAuthenticationProvider(serviceInfo);
            }

            return serviceInfo;
        }

 public PneumaticClient(IConfigService configService, IHttpProvider httpProvider,
                             IDiskProvider diskProvider)
 {
     _configService = configService;
     _httpProvider = httpProvider;
     _diskProvider = diskProvider;
 }

 public NzbgetClient(IConfigService configService, IHttpProvider httpProvider, IParsingService parsingService, Logger logger)
 {
     _configService = configService;
     _httpProvider = httpProvider;
     _parsingService = parsingService;
     _logger = logger;
 }

        public Task<ServiceInfo> GetServiceInfo(
            AppConfig appConfig,
            CredentialCache credentialCache,
            IHttpProvider httpProvider,
            ClientType clientType = ClientType.Consumer)
        {
            if (clientType == ClientType.Business)
            {
                throw new OneDriveException(
                    new Error
                    {
                        Code = OneDriveErrorCode.AuthenticationFailure.ToString(),
                        Message = "OnlineIdServiceProvider only supports Microsoft Account authentication."
                    });
            }

            var microsoftAccountServiceInfo = new MicrosoftAccountServiceInfo
            {
                AppId = appConfig.MicrosoftAccountAppId,
                ClientSecret = appConfig.MicrosoftAccountClientSecret,
                CredentialCache = credentialCache,
                HttpProvider = httpProvider,
                Scopes = appConfig.MicrosoftAccountScopes,
            };

            microsoftAccountServiceInfo.AuthenticationProvider = this.AuthenticationProvider ?? new OnlineIdAuthenticationProvider(microsoftAccountServiceInfo);
            return Task.FromResult<ServiceInfo>(microsoftAccountServiceInfo);
        }

 /// <summary>
 /// Instantiates a new OneDriveClient.
 /// </summary>
 /// <param name="baseUrl">The base service URL. For example, "https://api.onedrive.com/v1.0."</param>
 /// <param name="authenticationProvider">The <see cref="IAuthenticationProvider"/> for authenticating request messages.</param>
 /// <param name="httpProvider">The <see cref="IHttpProvider"/> for sending requests.</param>
 public OneDriveClient(
     string baseUrl,
     IAuthenticationProvider authenticationProvider,
     IHttpProvider httpProvider = null)
     : base(baseUrl, authenticationProvider, httpProvider)
 {
 }

 /// <summary>
 /// Instantiates a new OneDriveClient.
 /// </summary>
 public OneDriveClient(
     AppConfig appConfig,
     CredentialCache credentialCache = null,
     IHttpProvider httpProvider = null,
     IServiceInfoProvider serviceInfoProvider = null)
     : base(appConfig, credentialCache, httpProvider, serviceInfoProvider)
 {
 }

 /// <summary>
 /// Instantiates a new OneDriveClient.
 /// </summary>
 public OneDriveClient(
     AppConfig appConfig,
     CredentialCache credentialCache = null,
     IHttpProvider httpProvider = null,
     IServiceInfoProvider serviceInfoProvider = null,
     ClientType clientType = ClientType.Consumer)
     : base(appConfig, credentialCache, httpProvider, serviceInfoProvider, clientType)
 {
 }

 public static IOneDriveClient GetClientUsingOnlineIdAuthenticator(
     string[] scopes,
     string returnUrl = null,
     IHttpProvider httpProvider = null)
 {
     return new OneDriveClient(
         new AppConfig { MicrosoftAccountScopes = scopes },
         /* credentialCache */ null,
         httpProvider ?? new HttpProvider(),
         new OnlineIdServiceInfoProvider());
 }

 /// <summary>
 /// Creates an authenticated client that uses the WebAuthenticationBroker API in SSO mode for authentication.
 /// </summary>
 /// <param name="appId">The application ID for Microsoft account authentication.</param>
 /// <param name="scopes">The requested scopes for Microsoft account authentication.</param>
 /// <param name="httpProvider">The <see cref="IHttpProvider"/> for sending HTTP requests.</param>
 /// <returns>The <see cref="IOneDriveClient"/> for the session.</returns>
 public static Task<IOneDriveClient> GetAuthenticatedClientUsingWebAuthenticationBroker(
     string appId,
     string[] scopes,
     IHttpProvider httpProvider = null)
 {
     return OneDriveClientExtensions.GetAuthenticatedClientUsingWebAuthenticationBroker(
         appId,
         /* returnUrl */ null,
         scopes,
         httpProvider);
 }

        /// <summary>
        /// Creates an authenticated client that uses the OnlineIdAuthenticator API for authentication.
        /// </summary>
        /// <param name="scopes">The requested scopes for Microsoft account authentication.</param>
        /// <param name="httpProvider">The <see cref="IHttpProvider"/> for sending HTTP requests.</param>
        /// <returns>The <see cref="IOneDriveClient"/> for the session.</returns>
        public static async Task<IOneDriveClient> GetAuthenticatedClientUsingOnlineIdAuthenticator(
            string[] scopes,
            IHttpProvider httpProvider = null)
        {
            var client = OneDriveClientExtensions.GetClientUsingOnlineIdAuthenticator(
                scopes,
                httpProvider: httpProvider);

            await client.AuthenticateAsync();

            return client;
        }

 public NzbImportProvider(IDiskProvider disk, IHttpProvider http, IDecompressProvider decompress, INzbParseProvider parse, INzbQueueProvider queue, INntpProvider nntp, IPreQueueProvider preQueue, IConfigProvider config)
 {
     _disk = disk;
     _http = http;
     _decompress = decompress;
     _parse = parse;
     _queue = queue;
     _list = new List<NzbImportModel>();
     _nntp = nntp;
     _preQueue = preQueue;
     _config = config;
 }

 public SabnzbdClient(IConfigService configService,
                      IHttpProvider httpProvider,
                      ICacheManger cacheManger,
                      IParsingService parsingService,
                      Logger logger)
 {
     _configService = configService;
     _httpProvider = httpProvider;
     _parsingService = parsingService;
     _queueCache = cacheManger.GetCache<IEnumerable<QueueItem>>(GetType(), "queue");
     _logger = logger;
 }

 public static IOneDriveClient GetClientUsingWebAuthenticationBroker(
     string appId,
     string[] scopes,
     string returnUrl = null,
     IHttpProvider httpProvider = null)
 {
     return new OneDriveClient(
         new AppConfig { MicrosoftAccountScopes = scopes },
         /* credentialCache */ null,
         httpProvider ?? new HttpProvider(new Serializer()),
         new WebAuthenticationBrokerServiceInfoProvider());
 }

        /// <summary>
        /// Constructs a new <see cref="BaseClient"/>.
        /// </summary>
        public BaseClient(
            AppConfig appConfig,
            CredentialCache credentialCache = null,
            IHttpProvider httpProvider = null,
            IServiceInfoProvider serviceInfoProvider = null)
        {

            this.appConfig = appConfig;
            this.credentialCache = credentialCache ?? new CredentialCache();
            this.HttpProvider = httpProvider ?? new HttpProvider(new Serializer());
            this.serviceInfoProvider = serviceInfoProvider ?? new ServiceInfoProvider();
        }

        public override async Task<ServiceInfo> GetServiceInfo(AppConfig appConfig, CredentialCache credentialCache, IHttpProvider httpProvider)
        {
            ServiceInfo serviceInfo = await base.GetServiceInfo(appConfig, credentialCache, httpProvider);

            if (credentialCache.cacheDictionary.Count > 0)
            {
                var credentialPair = credentialCache.cacheDictionary.First();
                serviceInfo.UserId = credentialPair.Key.UserId;
            }

            return serviceInfo;
        }

        public override async Task<ServiceInfo> GetServiceInfo(
            AppConfig appConfig,
            CredentialCache credentialCache,
            IHttpProvider httpProvider,
            ClientType clientType) {
            var serviceInfo = await base.GetServiceInfo(appConfig, credentialCache, httpProvider, clientType);

            var authProvider = new IosAuthenticationProvider(serviceInfo);
            serviceInfo.AuthenticationProvider = authProvider;

            return serviceInfo;
        }

 /// <summary>
 /// Constructs a new <see cref="BaseClient"/>.
 /// </summary>
 public BaseClient(
     AppConfig appConfig,
     CredentialCache credentialCache = null,
     IHttpProvider httpProvider = null,
     IServiceInfoProvider serviceInfoProvider = null,
     ClientType clientType = ClientType.Consumer)
 {
     this.appConfig = appConfig;
     this.ClientType = clientType;
     this.credentialCache = credentialCache;
     this.HttpProvider = httpProvider ?? new HttpProvider(new Serializer());
     this.serviceInfoProvider = serviceInfoProvider ?? new ServiceInfoProvider();
 }