Skip to content

A modern, self-hosted backup solution for secure, encrypted backups across local and cloud storage.

37.2 KB
Raw Blame
import azureblobSettings from './providers/azureblob';
import b2Settings from './providers/b2';
import boxSettings from './providers/box';
import dropboxSettings from './providers/dropbox';
import fichierSettings from './providers/fichier';
import gcsSettings from './providers/gcs';
import googleDriveSettings from './providers/gdrive';
import gofileSettings from './providers/gofile';
import gphotosSettings from './providers/gphotos';
import hdfsSettings from './providers/hdfs';
import hidriveSettings from './providers/hidrive';
import internetarchiveSettings from './providers/internetarchive';
import jottacloudSettings from './providers/jottacloud';
import koofrSettings from './providers/koofr';
import linkboxSettings from './providers/linkbox';
import mailruSettings from './providers/mailru';
import megaSettings from './providers/mega';
import netstorageSettings from './providers/netstorage';
import onedriveSettings from './providers/onedrive';
import opendriveSettings from './providers/opendrive';
import oracleSettings from './providers/oracleobjectstorage';
import pikpakSettings from './providers/pikpak';
import pixeldrainSettings from './providers/pixeldrain';
import premiumizemeSettings from './providers/premiumizeme';
import protondriveSettings from './providers/protondrive';
import putioSettings from './providers/putio';
import qingstorSettings from './providers/qingstor';
import quatrixSettings from './providers/quatrix';
import s3Settings from './providers/s3';
import seafileSettings from './providers/seafile';
import citrixSharefileSettings from './providers/sharefile';
import siaSettings from './providers/sia';
import storjSettings from './providers/storj';
import sugarsyncSettings from './providers/sugarsync';
import swiftSettings from './providers/swift';
import uloztoSettings from './providers/ulozto';
import webdavSettings from './providers/webdav';
import yandexSettings from './providers/yandex';
import zohoSettings from './providers/zoho';
import pcloudSettings from './providers/pcloud';
import filesComSettings from './providers/filescom';
import smbSettings from './providers/smb';
import ftpSettings from './providers/ftp';
import sftpSettings from './providers/sftp';
import httpSettings from './providers/http';
import providerFeatures from './providers/_features';
import r2Settings from './providers/r2';
import ossSettings from './providers/oss';
import cephSettings from './providers/ceph';
import dreamobjectsSettings from './providers/dreamobjects';
import spacesSettings from './providers/spaces';
import obsSettings from './providers/obs';
import ibmcosSettings from './providers/ibmcos';
import idriveSettings from './providers/idrive';
import ionosSettings from './providers/ionos';
import minioSettings from './providers/minio';
import outscaleSettings from './providers/outscale';
import qiniuSettings from './providers/qiniu';
import rackcorpSettings from './providers/rackcorp';
import rcloneSettings from './providers/rclone';
import scalewaySettings from './providers/scaleway';
import lyvecloudSettings from './providers/lyvecloud';
import seaweedfsSettings from './providers/seaweedfs';
import selectelSettings from './providers/selectel';
import leviiaSettings from './providers/leviia';
import liaraSettings from './providers/liara';
import linodeSettings from './providers/linode';
import arvanSettings from './providers/arvan';
import petaboxSettings from './providers/petabox';
import tencentSettings from './providers/tencent';
import magaluSettings from './providers/magalu';
import wasabiSettings from './providers/wasabi';
import synologySettings from './providers/synologyc2';
import localSettings from './providers/local';
import drimeSettings from './providers/drime';
import fileluSettings from './providers/filelu';
import filenSettings from './providers/filen';
import internxtSettings from './providers/internxt';
import shadeSettings from './providers/shade';
import s3CompatibleSettings from './providers/s3compatible';
import type { ProviderSetting } from './providers/types';

export interface ProviderConfig {
	name: string;
	authTypes: string[];
	features: {
		Purge: boolean;
		Copy: boolean;
		Move: boolean;
		DirMove: boolean;
		CleanUp: boolean;
		ListR: boolean;
		StreamUpload: boolean;
		MultithreadUpload: boolean;
		LinkSharing: boolean;
		About: boolean;
		EmptyDir: boolean;
	};
	type?: string;
	settings?: ProviderSetting[];
	doc?: string;
	setup: (credentials: Record<string, string>, type?: string) => string[] | false;
}

/**
 * Builds `key value` argument pairs for optional credential fields.
 * Fields the user left blank are skipped so rclone keeps its own default.
 * Values are stringified because spawn() rejects non-string arguments.
 */
const optionalCreds = (creds: Record<string, string>, keys: string[]): string[] =>
	keys.flatMap(key => {
		const value = creds[key];
		if (value === undefined || value === null || value === '') {
			return [];
		}
		return [key, String(value)];
	});

export const providers: Record<string, ProviderConfig> = {
	local: {
		name: 'Local',
		settings: localSettings,
		authTypes: ['client'],
		features: providerFeatures['local'],
		setup: creds => [],
	},
	b2: {
		name: 'Backblaze B2',
		doc: '/storages/connecting-backblaze-b2',
		settings: b2Settings,
		authTypes: ['client'],
		features: providerFeatures['b2'],
		setup: creds => ['account', creds.account, 'key', creds.key],
	},
	drive: {
		name: 'Google Drive',
		doc: '/storages/connecting-google-drive',
		settings: googleDriveSettings,
		authTypes: ['client', 'oauth'],
		features: providerFeatures['drive'],
		setup: (creds, type) => {
			if (type === 'oauth') {
				if (!creds.token) {
					return false;
				}
				return [
					'token',
					creds.token,
					'scope',
					creds.scope || 'drive',
					...optionalCreds(creds, ['service_account_credentials']),
				];
			} else {
				if (!creds.client_id || !creds.client_secret) {
					return false;
				}
				return [
					'client_id',
					creds.client_id,
					'client_secret',
					creds.client_secret,
					'scope',
					creds.scope || 'drive',
					...optionalCreds(creds, ['service_account_credentials']),
					'--drive-client-credentials',
				];
			}
		},
	},
	onedrive: {
		name: 'One Drive',
		doc: '/storages/connecting-onedrive',
		settings: onedriveSettings,
		authTypes: ['client', 'oauth'],
		features: providerFeatures['onedrive'],
		setup: (creds, type) => {
			if (type === 'oauth') {
				if (!creds.token) {
					return false;
				}
				return ['token', creds.token];
			} else {
				if (!creds.client_id || !creds.client_secret) {
					return false;
				}
				return [
					'client_id',
					creds.client_id,
					'client_secret',
					creds.client_secret,
					'--onedrive-client-credentials',
				];
			}
		},
	},
	dropbox: {
		name: 'DropBox',
		doc: '/storages/connecting-dropbox',
		settings: dropboxSettings,
		authTypes: ['client', 'oauth'],
		features: providerFeatures['dropbox'],
		setup: (creds, type) => {
			if (type === 'oauth') {
				if (!creds.token) {
					return false;
				}
				return ['token', creds.token];
			} else {
				if (!creds.client_id || !creds.client_secret) {
					return false;
				}
				return [
					'client_id',
					creds.client_id,
					'client_secret',
					creds.client_secret,
					'--dropbox-client-credentials',
				];
			}
		},
	},
	box: {
		name: 'Box.com',
		doc: '/storages/connecting-box',
		settings: boxSettings,
		authTypes: ['client', 'oauth'],
		features: providerFeatures['box'],
		setup: (creds, type) => {
			if (type === 'oauth') {
				if (!creds.token) {
					return false;
				}
				return ['token', creds.token];
			} else {
				if (!creds.client_id || !creds.client_secret) {
					return false;
				}
				return [
					'client_id',
					creds.client_id,
					'client_secret',
					creds.client_secret,
					'--box-client-credentials',
				];
			}
		},
	},
	azureblob: {
		name: 'Azure Blob Storage',
		doc: '/storages/connecting-azure-blob-storage',
		settings: azureblobSettings,
		authTypes: ['client'],
		setup: creds => {
			if (!creds.account || !creds.key) {
				return false;
			}
			// The key is the base64 string from the Azure portal. rclone passes it
			// through and the Azure SDK decodes it, so do not encode it here.
			return [
				'account',
				creds.account,
				'key',
				creds.key,
				...optionalCreds(creds, ['client_secret', 'client_certificate_password', 'password']),
			];
		},
		features: providerFeatures['azureblob'],
	},
	gcs: {
		name: 'Google Cloud Storage',
		type: 'google cloud storage',
		doc: '/storages/connecting-google-cloud-storage',
		settings: gcsSettings,
		authTypes: ['client', 'oauth'],
		setup: (creds, type) => {
			if (type === 'oauth') {
				if (!creds.token) {
					return false;
				}
				return ['token', creds.token, ...optionalCreds(creds, ['access_token'])];
			} else {
				if (!creds.project_number || !creds.service_account_file) {
					return false;
				}
				return [
					'project_number',
					creds.project_number,
					'service_account_file',
					creds.service_account_file,
					...optionalCreds(creds, ['access_token']),
				];
			}
		},
		features: providerFeatures['gcs'],
	},
	mega: {
		name: 'Mega',
		doc: '/storages/connecting-mega',
		authTypes: ['password'],
		settings: megaSettings,
		setup: creds => ['user', creds.user, 'pass', creds.pass],
		features: providerFeatures['mega'],
	},
	pcloud: {
		name: 'pCloud',
		doc: '/storages/connecting-pcloud',
		authTypes: ['oauth', 'client'],
		settings: pcloudSettings,
		setup: (creds, type) => {
			if (type === 'oauth') {
				if (!creds.token) {
					return false;
				}
				return ['token', creds.token];
			} else {
				if (!creds.client_id || !creds.client_secret) {
					return false;
				}
				return [
					'client_id',
					creds.client_id,
					'client_secret',
					creds.client_secret,
					'--pcloud-client-credentials',
				];
			}
		},

		features: providerFeatures['pcloud'],
	},
	swift: {
		name: 'Oracle Swift',
		doc: '/storages/connecting-openstack-swift',
		settings: swiftSettings,
		authTypes: ['password', 'client'],
		setup: (creds, type) => {
			// Client login uses a pre-issued token and skips the auth server.
			if (type === 'client') {
				if (!creds.auth_token || !creds.storage_url) {
					return false;
				}
				return ['auth_token', creds.auth_token, 'storage_url', creds.storage_url];
			}
			if (!creds.user || !creds.key || !creds.auth) {
				return false;
			}
			return [
				'user',
				creds.user,
				'key',
				creds.key,
				'auth',
				creds.auth,
				...optionalCreds(creds, ['tenant', 'storage_url', 'auth_token']),
			];
		},
		features: providerFeatures['swift'],
	},
	storj: {
		name: 'Storj',
		doc: '/storages/connecting-storj',
		settings: storjSettings,
		authTypes: ['client', 'password'],
		setup: (creds, type) => {
			if (type === 'client') {
				if (!creds.satellite_address || !creds.api_key || !creds.passphrase) {
					return false;
				}
				return [
					'provider',
					'new',
					'satellite_address',
					creds.satellite_address,
					'api_key',
					creds.api_key,
					'passphrase',
					creds.passphrase,
				];
			}
			if (!creds.access_grant) {
				return false;
			}
			return ['provider', 'existing', 'access_grant', creds.access_grant];
		},
		features: providerFeatures['storj'],
	},
	seafile: {
		name: 'SeaFile',
		doc: '/storages/connecting-seafile',
		settings: seafileSettings,
		authTypes: ['password'],
		setup: creds => {
			const config = [
				'url',
				creds.url,
				'user',
				creds.user,
				'pass',
				creds.pass,
				'library',
				creds.library,
				...optionalCreds(creds, ['auth_token']),
			];
			if (creds['2fa']) {
				config.push('2fa', creds['2fa']);
			}
			return config;
		},
		features: providerFeatures['seafile'],
	},
	jottacloud: {
		name: 'Jotta Cloud',
		doc: '/storages/connecting-jottacloud',
		authTypes: ['client', 'password'],
		settings: jottacloudSettings,
		features: providerFeatures['jottacloud'],
		setup: (creds, type) => {
			if (type === 'password') {
				if (!creds.login_token) {
					return false;
				}
				return [
					'config_login_token',
					creds.login_token,
					'config_type',
					'standard',
					...optionalCreds(creds, ['token']),
				];
			} else {
				if (!creds.client_id || !creds.client_secret) {
					return false;
				}
				return [
					'client_id',
					creds.client_id,
					'client_secret',
					creds.client_secret,
					...optionalCreds(creds, ['token']),
					'--jottacloud-client-credentials',
				];
			}
		},
	},
	yandex: {
		name: 'Yandex Disk',
		doc: '/storages/connecting-yandex-disk',
		authTypes: ['client', 'oauth'],
		settings: yandexSettings,
		setup: (creds, type) => {
			if (type === 'oauth') {
				if (!creds.token) {
					return false;
				}
				return ['token', creds.token];
			} else {
				if (!creds.client_id || !creds.client_secret) {
					return false;
				}
				return [
					'client_id',
					creds.client_id,
					'client_secret',
					creds.client_secret,
					'--yandex-client-credentials',
				];
			}
		},
		features: providerFeatures['yandex'],
	},
	zoho: {
		name: 'Zoho WorkDrive',
		doc: '/storages/connecting-zoho-workdrive',
		authTypes: ['client', 'oauth'],
		settings: zohoSettings,
		setup: (creds, type) => {
			if (type === 'oauth') {
				if (!creds.token) {
					return false;
				}
				return ['token', creds.token];
			} else {
				if (!creds.client_id || !creds.client_secret) {
					return false;
				}
				return [
					'client_id',
					creds.client_id,
					'client_secret',
					creds.client_secret,
					'region',
					creds.region,
					'--zoho-client-credentials',
				];
			}
		},
		features: providerFeatures['zoho'],
	},
	hidrive: {
		name: 'HiDrive',
		doc: '/storages/connecting-hidrive',
		settings: hidriveSettings,
		authTypes: ['client', 'oauth'],
		setup: (creds, type) => {
			if (type === 'oauth') {
				if (!creds.token) {
					return false;
				}
				return ['token', creds.token];
			} else {
				if (!creds.client_id || !creds.client_secret) {
					return false;
				}
				return [
					'client_id',
					creds.client_id,
					'client_secret',
					creds.client_secret,
					'scope_access',
					creds.scope_access,
					'--hidrive-client-credentials',
				];
			}
		},
		features: providerFeatures['hidrive'],
	},
	koofr: {
		name: 'Koofr',
		doc: '/storages/connecting-koofr',
		settings: koofrSettings,
		authTypes: ['client'],
		setup: creds => ['provider', creds.provider, 'user', creds.user, 'password', creds.password],
		features: providerFeatures['koofr'],
	},
	mailru: {
		name: 'Mail.ru Cloud',
		doc: '/storages/connecting-mail-ru-cloud',
		authTypes: ['oauth', 'password'],
		settings: mailruSettings,
		setup: (creds, type) => {
			if (type === 'oauth') {
				if (!creds.token) {
					return false;
				}
				return ['token', creds.token, ...optionalCreds(creds, ['client_secret'])];
			} else {
				if (!creds.user || !creds.pass) {
					return false;
				}
				return [
					'user',
					creds.user,
					'pass',
					creds.pass,
					...optionalCreds(creds, ['client_secret']),
				];
			}
		},
		features: providerFeatures['mailru'],
	},
	opendrive: {
		name: 'Open Drive',
		doc: '/storages/connecting-opendrive',
		authTypes: ['password'],
		settings: opendriveSettings,
		setup: creds => ['username', creds.username, 'password', creds.password],
		features: providerFeatures['opendrive'],
	},
	qingstor: {
		name: 'QingStor',
		doc: '/storages/connecting-qingstor',
		authTypes: ['client'],
		settings: qingstorSettings,
		setup: creds => {
			const flags = [
				'access_key_id',
				creds.access_key_id,
				'secret_access_key',
				creds.secret_access_key,
				'zone',
				creds.zone,
			];
			if (creds.endpoint) {
				flags.push('endpoint', creds.endpoint);
			}

			return flags;
		},
		features: providerFeatures['qingstor'],
	},
	premiumizeme: {
		name: 'Premiumize.me',
		doc: '/storages/connecting-premiumize-me',
		settings: premiumizemeSettings,
		authTypes: ['client', 'oauth'],
		setup: (creds, type) => {
			if (type === 'oauth') {
				if (!creds.token) {
					return false;
				}
				return ['token', creds.token];
			} else {
				if (!creds.api_key || !creds.client_id || !creds.client_secret) {
					return false;
				}
				return [
					'client_id',
					creds.client_id,
					'client_secret',
					creds.client_secret,
					'api_key',
					creds.api_key,
					'--premiumizeme-client-credentials',
				];
			}
		},
		features: providerFeatures['premiumizeme'],
	},
	putio: {
		name: 'Put.io',
		doc: '/storages/connecting-put-io',
		settings: putioSettings,
		authTypes: ['client', 'oauth'],
		setup: (creds, type) => {
			if (type === 'oauth') {
				if (!creds.token) {
					return false;
				}
				return ['token', creds.token];
			} else {
				if (!creds.token) {
					return false;
				}
				return ['token', creds.token];
			}
		},
		features: providerFeatures['putio'],
	},
	sharefile: {
		name: 'Citrix ShareFile',
		doc: '/storages/connecting-citrix-sharefile',
		authTypes: ['client', 'oauth'],
		settings: citrixSharefileSettings,
		setup: (creds, type) => {
			if (type === 'oauth') {
				if (!creds.token) {
					return false;
				}
				return ['token', creds.token];
			} else {
				if (!creds.hostname || !creds.client_id || !creds.client_secret) {
					return false;
				}
				return [
					'hostname',
					creds.hostname,
					'client_id',
					creds.client_id,
					'client_secret',
					creds.client_secret,
					'--sharefile-client-credentials',
				];
			}
		},
		features: providerFeatures['sharefile'],
	},
	sugarsync: {
		name: 'SugarSync',
		doc: '/storages/connecting-sugarsync',
		authTypes: ['client'],
		settings: sugarsyncSettings,
		setup: creds => [
			'access_key_id',
			creds.access_key_id,
			'private_access_key',
			creds.private_access_key,
			'refresh_token',
			creds.refresh_token,
		],
		features: providerFeatures['sugarsync'],
	},

	fichier: {
		name: '1Fichier',
		doc: '/storages/connecting-1fichier',
		authTypes: ['client'],
		settings: fichierSettings,
		setup: creds => {
			return ['api_key', creds.api_key];
		},
		features: providerFeatures['1fichier'],
	},
	netstorage: {
		name: 'Akamai NetStorage',
		doc: '/storages/connecting-akamai-netstorage',
		authTypes: ['client'],
		settings: netstorageSettings,
		setup: creds => [
			'hostname',
			creds.hostname,
			'account_name',
			creds.account_name,
			'key',
			creds.key,
		],
		features: providerFeatures['netstorage'],
	},
	filescom: {
		name: 'Files.com', // authentication either using apiKey or username/password
		doc: '/storages/connecting-files-com',
		authTypes: ['client', 'password'],
		settings: filesComSettings,
		setup: (creds, type) => {
			if (type === 'password') {
				if (!creds.site || !creds.username || !creds.password) {
					return false;
				}
				return ['site', creds.site, 'username', creds.username, 'password', creds.password];
			}
			if (!creds.api_key) {
				return false;
			}
			const args = ['api_key', creds.api_key];
			if (creds.site) {
				args.push('site', creds.site);
			}
			return args;
		},
		features: providerFeatures['filescom'],
	},
	gofile: {
		name: 'GoFile',
		doc: '/storages/connecting-gofile',
		authTypes: ['client'],
		settings: gofileSettings,
		setup: creds => ['access_token', creds.access_token],
		features: providerFeatures['gofile'],
	},
	gphotos: {
		name: 'Google Photos',
		type: 'google photos',
		doc: '/storages/connecting-google-photos',
		authTypes: ['client', 'password'],
		settings: gphotosSettings,
		setup: creds => ['client_id', creds.client_id, 'client_secret', creds.client_secret],
		features: providerFeatures['gphotos'],
	},
	internetarchive: {
		name: 'Internet Archive',
		doc: '/storages/connecting-internet-archive',
		authTypes: ['client'],
		settings: internetarchiveSettings,
		setup: creds => [
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
		],
		features: providerFeatures['internetarchive'],
	},
	linkbox: {
		name: 'Linkbox',
		doc: '/storages/connecting-linkbox',
		authTypes: ['client'],
		settings: linkboxSettings,
		setup: creds => ['token', creds.token, 'email', creds.email, 'password', creds.password],
		features: providerFeatures['linkbox'],
	},
	oracleobjectstorage: {
		name: 'Oracle Object Storage',
		doc: '/storages/connecting-oracle-object-storage',
		authTypes: ['client'],
		settings: oracleSettings,
		setup: creds => [
			'namespace',
			creds.namespace,
			'compartment',
			creds.compartment,
			'region',
			creds.region,
			'access_key',
			creds.access_key,
			'secret_key',
			creds.secret_key,
		],
		features: providerFeatures['oracleobjectstorage'],
	},
	pikpak: {
		name: 'PikPak',
		doc: '/storages/connecting-pikpak',
		authTypes: ['password'],
		settings: pikpakSettings,
		setup: creds => ['user', creds.user, 'pass', creds.pass],
		features: providerFeatures['pikpak'],
	},
	pixeldrain: {
		name: 'Pixeldrain',
		doc: '/storages/connecting-pixeldrain',
		authTypes: ['client'],
		settings: pixeldrainSettings,
		setup: creds => ['api_key', creds.api_key],
		features: providerFeatures['pixeldrain'],
	},
	protondrive: {
		name: 'Proton Drive',
		doc: '/storages/connecting-proton-drive',
		authTypes: ['password'],
		settings: protondriveSettings,
		setup: creds => {
			const config = [
				'username',
				creds.username,
				'password',
				creds.password,
				...optionalCreds(creds, ['mailbox_password']),
			];
			if (creds['2fa']) {
				config.push('2fa', creds['2fa']);
			}
			return config;
		},
		features: providerFeatures['protondrive'],
	},
	quatrix: {
		name: 'Quatrix by Maytech',
		doc: '/storages/connecting-quatrix',
		authTypes: ['client'],
		settings: quatrixSettings,
		setup: creds => ['api_key', creds.api_key, 'host', creds.host],
		features: providerFeatures['quatrix'],
	},
	sia: {
		name: 'Sia',
		doc: '/storages/connecting-sia',
		authTypes: ['client'],
		settings: siaSettings,
		setup: creds => ['api_url', creds.api_url, 'api_password', creds.api_password],
		features: providerFeatures['sia'],
	},
	ulozto: {
		name: 'Uloz.to',
		doc: '/storages/connecting-uloz-to',
		authTypes: ['password'],
		settings: uloztoSettings,
		setup: creds => ['username', creds.username, 'password', creds.password],
		features: providerFeatures['ulozto'],
	},
	hdfs: {
		name: 'HDFS',
		doc: '/storages/connecting-hdfs',
		authTypes: ['password'],
		settings: hdfsSettings,
		setup: creds => ['namenode', creds.namenode, 'username', creds.username],
		features: providerFeatures['hdfs'],
	},
	smb: {
		name: 'Samba (SMB)',
		doc: '/storages/connecting-smb',
		authTypes: ['password'],
		settings: smbSettings,
		setup: creds => [
			'host',
			creds.host,
			'user',
			creds.user,
			'pass',
			creds.pass,
			...optionalCreds(creds, ['port', 'domain']),
		],
		features: providerFeatures['smb'],
	},
	sftp: {
		name: 'SFTP',
		doc: '/storages/connecting-sftp',
		authTypes: ['password'],
		settings: sftpSettings,
		setup: creds => [
			'host',
			creds.host,
			'user',
			creds.user,
			'pass',
			creds.pass,
			...optionalCreds(creds, ['port', 'key_file_pass']),
		],
		features: providerFeatures['sftp'],
	},
	ftp: {
		name: 'FTP',
		doc: '/storages/connecting-ftp',
		authTypes: ['password'],
		settings: ftpSettings,
		setup: creds => [
			'host',
			creds.host,
			'user',
			creds.user,
			'pass',
			creds.pass,
			...optionalCreds(creds, ['port', 'tls', 'explicit_tls']),
		],
		features: providerFeatures['ftp'],
	},
	webdav: {
		name: 'WebDav',
		doc: '/storages/connecting-webdav',
		authTypes: ['password'],
		settings: webdavSettings,
		setup: creds => ['url', creds.url, ...optionalCreds(creds, ['user', 'pass', 'bearer_token'])],
		features: providerFeatures['webdav'],
	},
	http: {
		name: 'HTTP (Read Only)',
		doc: '/storages/connecting-http',
		authTypes: ['noauth'],
		settings: httpSettings,
		setup: creds => ['url', creds.url],
		features: providerFeatures['http'],
	},
	drime: {
		name: 'Drime',
		doc: '/storages/connecting-drime',
		authTypes: ['client'],
		settings: drimeSettings,
		setup: creds => ['access_token', creds.access_token],
		features: providerFeatures['drime'],
	},
	filelu: {
		name: 'FileLu',
		doc: '/storages/connecting-filelu',
		authTypes: ['client'],
		settings: fileluSettings,
		setup: creds => ['key', creds.key],
		features: providerFeatures['filelu'],
	},
	filen: {
		name: 'Filen',
		doc: '/storages/connecting-filen',
		authTypes: ['password'],
		settings: filenSettings,
		setup: creds => ['email', creds.email, 'password', creds.password, 'api_key', creds.api_key],
		features: providerFeatures['filen'],
	},
	internxt: {
		name: 'Internxt Drive',
		doc: '/storages/connecting-internxt',
		authTypes: ['password'],
		settings: internxtSettings,
		setup: creds => ['email', creds.email, 'pass', creds.pass],
		features: providerFeatures['internxt'],
	},
	shade: {
		name: 'Shade',
		doc: '/storages/connecting-shade',
		authTypes: ['client'],
		settings: shadeSettings,
		setup: creds => ['drive_id', creds.drive_id, 'api_key', creds.api_key],
		features: providerFeatures['shade'],
	},

	/* ===================== S3 Compatible Storages ========================== */
	s3: {
		name: 'AWS S3',
		type: 's3',
		doc: '/storages/connecting-aws-s3',
		settings: s3Settings,
		authTypes: ['client'],
		features: providerFeatures['s3'],
		setup: creds => {
			const args = [
				'provider',
				'AWS',
				'access_key_id',
				creds.access_key_id,
				'secret_access_key',
				creds.secret_access_key,
				'region',
				creds.region,
				'acl',
				creds.acl || 'private',
			];
			if (creds.location_constraint && creds.location_constraint !== 'us-east-1') {
				args.push('location_constraint', creds.location_constraint);
			}
			if (creds.endpoint) {
				args.push('endpoint', creds.endpoint);
			}

			return args;
		},
	},
	r2: {
		name: 'Cloudflare R2',
		type: 's3',
		doc: '/storages/connecting-cloudflare-r2',
		authTypes: ['client'],
		settings: r2Settings,
		features: providerFeatures['s3'],
		setup: creds => [
			'provider',
			'Cloudflare',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			`https://${creds.endpoint}.${creds.jurisdiction ? creds.jurisdiction + '.' : ''}r2.cloudflarestorage.com`,
			'region',
			'auto',
			'no_check_bucket',
			'true',
		],
	},
	oss: {
		name: 'Alibaba Cloud Object Storage System (OSS)',
		type: 's3',
		doc: '/storages/connecting-alibaba-cloud-oss',
		authTypes: ['client'],
		settings: ossSettings,
		features: providerFeatures['s3'],
		setup: creds => [
			'provider',
			'Alibaba',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			creds.endpoint,
			'storage_class',
			creds.storage_class,
		],
	},
	ceph: {
		name: 'Ceph',
		type: 's3',
		doc: '/storages/connecting-ceph',
		authTypes: ['client'],
		settings: cephSettings,
		features: providerFeatures['s3'],
		setup: creds => [
			'provider',
			'Ceph', //TODO: No region field
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			`${creds.endpoint}`,
			'acl',
			'private',
		],
	},
	dreamobjects: {
		name: 'DreamObjects',
		type: 's3',
		doc: '/storages/connecting-dreamhost',
		authTypes: ['client'],
		settings: dreamobjectsSettings,
		features: providerFeatures['s3'],
		setup: creds => [
			'provider',
			'DreamHost', //TODO: No region field
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			creds.endpoint,
			'acl',
			'private',
		],
	},
	spaces: {
		name: 'DigitalOcean Spaces',
		type: 's3',
		doc: '/storages/connecting-digitalocean-spaces',
		authTypes: ['client'],
		settings: spacesSettings,
		features: providerFeatures['s3'],
		setup: creds => [
			'provider',
			'DigitalOcean', //TODO: No region field
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			creds.endpoint,
		],
	},
	obs: {
		name: 'Huawei OBS',
		type: 's3',
		doc: '/storages/connecting-huawei-obs',
		authTypes: ['client'],
		settings: obsSettings,
		features: providerFeatures['s3'],
		setup: creds => [
			'provider',
			'HuaweiOBS',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'region',
			creds.region,
			'endpoint',
			creds.endpoint,
			'acl',
			'private',
		],
	},
	ibmcos: {
		name: 'IBM Cloud Object Storage',
		type: 's3',
		doc: '/storages/connecting-ibm-cos-s3',
		authTypes: ['client'],
		settings: ibmcosSettings,
		features: providerFeatures['s3'],
		setup: creds => [
			'provider',
			'IBMCOS',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'region',
			creds.region,
			'endpoint',
			creds.endpoint,
			'location_constraint',
			creds.location_constraint,
			'acl',
			'private',
		],
	},
	idrive: {
		name: 'IDrive e2',
		type: 's3',
		doc: '/storages/connecting-idrive-e2',
		authTypes: ['client'],
		settings: idriveSettings,
		features: providerFeatures['s3'],
		setup: creds => [
			'provider',
			'IDrive',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			creds.endpoint,
		],
	},
	ionos: {
		name: 'IONOS Cloud',
		type: 's3',
		doc: '/storages/connecting-ionos-cloud',
		authTypes: ['client'],
		settings: ionosSettings,
		features: providerFeatures['s3'],
		setup: creds => [
			'provider',
			'IONOS', //TODO: No region field
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			creds.endpoint,
		],
	},
	minio: {
		name: 'Minio',
		type: 's3',
		doc: '/storages/connecting-minio',
		authTypes: ['client'],
		settings: minioSettings,
		features: providerFeatures['s3'],
		setup: creds => [
			'provider',
			'Minio',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			creds.endpoint,
			'region',
			creds.region,
		],
	},
	outscale: {
		name: 'Outscale Object Storage',
		type: 's3',
		doc: '/storages/connecting-outscale',
		authTypes: ['client'],
		settings: outscaleSettings,
		features: providerFeatures['s3'],
		setup: creds => [
			'provider',
			'Outscale',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			`oos.${creds.region}.outscale.com`,
			'region',
			creds.region,
		],
	},
	qiniu: {
		name: 'Qiniu Object Storage (KODO)',
		type: 's3',
		authTypes: ['client'],
		settings: qiniuSettings,
		features: providerFeatures['s3'],
		doc: '/storages/connecting-qiniu-kodo',
		setup: creds => [
			'provider',
			'Qiniu',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			`s3.${creds.region}.qiniucs.com	`,
			'region',
			creds.region,
			'location_constraint',
			creds.region,
			'storage_class',
			creds.storage_class,
			'acl',
			creds.acl,
		],
	},
	rackcorp: {
		name: 'RackCorp',
		type: 's3',
		authTypes: ['client'],
		settings: rackcorpSettings,
		features: providerFeatures['s3'],
		doc: '/storages/connecting-rackcorp',
		setup: creds => [
			'provider',
			'RackCorp',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			`${creds.region}.s3.rackcorp.com`,
			'region',
			creds.region,
			'location_constraint ',
			creds.region,
		],
	},
	rclone: {
		name: 'Rclone Serve S3',
		type: 's3',
		authTypes: ['client'],
		settings: rcloneSettings,
		features: providerFeatures['s3'],
		setup: creds => [
			'provider',
			'Rclone',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			creds.endpoint,
			'use_multipart_uploads',
			'false',
		],
	},
	scaleway: {
		name: 'Scaleway Object Storage',
		type: 's3',
		authTypes: ['client'],
		settings: scalewaySettings,
		features: providerFeatures['s3'],
		doc: '/storages/connecting-scaleway',
		setup: creds => [
			'provider',
			'Scaleway',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			creds.endpoint,
			'region',
			creds.region,
			'location_constraint ',
			creds.region,
			'acl',
			'private',
			'upload_cutoff',
			'5M',
			'chunk_size',
			'5M',
			'copy_cutoff',
			'5M',
			'acl',
			creds.acl || 'private',
		],
	},
	lyvecloud: {
		name: 'Seagate LyveCloud',
		type: 's3',
		authTypes: ['client'],
		settings: lyvecloudSettings,
		features: providerFeatures['s3'],
		doc: '/storages/connecting-seagate-lyve-cloud',
		setup: creds => [
			'provider',
			'LyveCloud',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			creds.endpoint,
		],
	},
	seaweedfs: {
		name: 'SeaweedFS',
		type: 's3',
		authTypes: ['client'],
		settings: seaweedfsSettings,
		features: providerFeatures['s3'],
		doc: '/storages/connecting-seaweedfs',
		setup: creds => [
			'provider',
			'SeaweedFS',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			creds.endpoint,
		],
	},
	selectel: {
		name: 'Selectel',
		type: 's3',
		authTypes: ['client'],
		settings: selectelSettings,
		features: providerFeatures['s3'],
		doc: '/storages/connecting-selectel',
		setup: creds => [
			'provider',
			'Selectel',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			's3.ru-1.storage.selcloud.ru',
			'region',
			'ru-1',
			'acl',
			'private',
		],
	},
	wasabi: {
		name: 'Wasabi',
		type: 's3',
		authTypes: ['client'],
		settings: wasabiSettings,
		features: providerFeatures['s3'],
		doc: '/storages/connecting-wasabi',
		setup: creds => [
			'provider',
			'Wasabi',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			`s3.${creds.region && creds.region !== 'us-east-1' ? creds.region + '.' : ''}wasabisys.com`,
			'region',
			creds.region,
		],
	},
	leviia: {
		name: 'Leviia',
		type: 's3',
		doc: '/storages/connecting-leviia',
		authTypes: ['client'],
		settings: leviiaSettings,
		features: providerFeatures['s3'],
		setup: creds => [
			'provider',
			'Leviia',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			creds.endpoint,
			'acl',
			'private',
		],
	},
	liara: {
		name: 'Liara',
		type: 's3',
		authTypes: ['client'],
		settings: liaraSettings,
		features: providerFeatures['s3'],
		doc: '/storages/connecting-liara',
		setup: creds => [
			'provider',
			'Liara',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			'storage.iran.liara.space',
		],
	},
	linode: {
		name: 'Linode Object Storage',
		type: 's3',
		authTypes: ['client'],
		settings: linodeSettings,
		features: providerFeatures['s3'],
		doc: '/storages/connecting-linode',
		setup: creds => [
			'provider',
			'Linode',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			creds.endpoint,
		],
	},
	magalu: {
		name: 'Magalu',
		type: 's3',
		authTypes: ['client'],
		settings: magaluSettings,
		features: providerFeatures['s3'],
		doc: '/storages/connecting-magalu',
		setup: creds => [
			'provider',
			'Magalu',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			creds.endpoint,
		],
	},
	arvan: {
		name: 'ArvanCloud',
		type: 's3',
		authTypes: ['client'],
		settings: arvanSettings,
		features: providerFeatures['s3'],
		doc: '/storages/connecting-arvan-cloud',
		setup: creds => [
			'provider',
			'ArvanCloud',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'region',
			creds.region,
			'endpoint',
			creds.endpoint || `s3.${creds.region}.arvanstorage.ir`,
		],
	},
	tencent: {
		name: 'Tencent Cloud Object Storage (COS)',
		type: 's3',
		authTypes: ['client'],
		settings: tencentSettings,
		features: providerFeatures['s3'],
		doc: '/storages/connecting-tencent-cos',
		setup: creds => [
			'provider',
			'TencentCOS',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			creds.endpoint,
		],
	},
	petabox: {
		name: 'Petabox',
		type: 's3',
		authTypes: ['client'],
		settings: petaboxSettings,
		features: providerFeatures['s3'],
		doc: '/storages/connecting-petabox',
		setup: creds => [
			'provider',
			'Petabox',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'endpoint',
			's3.petabox.io',
			'region',
			'eu-east-1', //Available in One location only: https://docs.petabox.io/http-api-compatible-with-amazon-s3/api-reference/bucket/getbucketlocation
		],
	},
	synologyc2: {
		name: 'Synology C2',
		type: 's3',
		authTypes: ['client'],
		settings: synologySettings,
		features: providerFeatures['s3'],
		doc: '/storages/connecting-synology',
		setup: creds => [
			'provider',
			'SynologyC2',
			'access_key_id',
			creds.access_key_id,
			'secret_access_key',
			creds.secret_access_key,
			'region',
			creds.region,
			'endpoint',
			`${creds.region}.s3.synologyc2.net`,
			'no_check_bucket',
			'true',
		],
	},
	s3compatible: {
		name: 'S3 Compatible Storage',
		type: 's3',
		authTypes: ['client'],
		settings: s3CompatibleSettings,
		features: providerFeatures['s3'],
		setup: creds => {
			const args = [
				'provider',
				'Other',
				'access_key_id',
				creds.access_key_id,
				'secret_access_key',
				creds.secret_access_key,
			];
			if (creds.acl) {
				args.push('acl', creds.acl);
			}
			if (creds.region) {
				args.push('region', creds.region);
			}
			if (creds.location_constraint) {
				args.push('location_constraint', creds.location_constraint);
			}
			if (creds.endpoint) {
				args.push('endpoint', creds.endpoint);
			}

			return args;
		},
	},
};