@putdotio/sdk 11.0.2 → 11.1.0

package/dist/index.js

@@ -5434,242 +5434,282 @@ const provideSdk = async (state, effect) => {
 	return rejectWithSdkFailure(await getPromiseClientRuntime(state).runPromiseExit(operation));
 };
 const snapshotUrl = (value) => typeof value === "string" || value === void 0 ? value : new URL(value.href);
-const createPutioSdkEffectClient = () => ({
+const operationEntryMarker = Symbol("PutioSdkOperationEntry");
+const operationAtBoundary = (run, boundary) => {
+	const entry = {
+		boundary,
+		run
+	};
+	Object.defineProperty(entry, operationEntryMarker, { value: true });
+	return Object.freeze(entry);
+};
+const inputFree = (operation) => operationAtBoundary(operation, "input-free");
+const pure = (operation) => operationAtBoundary(operation, "pure");
+const validated = (operation) => operationAtBoundary(operation, "validated");
+const isOperationEntry = (value) => typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype && Object.isFrozen(value) && Object.hasOwn(value, operationEntryMarker) && value[operationEntryMarker] === true && Object.hasOwn(value, "boundary") && Object.hasOwn(value, "run") && Reflect.ownKeys(value).length === 3 && (value.boundary === "input-free" || value.boundary === "pure" || value.boundary === "validated") && typeof value.run === "function";
+const runClassifiedOperation = (entry, args) => {
+	const result = Reflect.apply(entry.run, void 0, args);
+	if (entry.boundary === "pure") {
+		if (Effect.isEffect(result)) throw new TypeError("Pure SDK operation returned an Effect");
+		return result;
+	}
+	if (!Effect.isEffect(result)) throw new TypeError(`${entry.boundary} SDK operation did not return an Effect`);
+	return result;
+};
+const cloneOperationTree = (tree) => Object.fromEntries(Object.entries(tree).map(([key, value]) => [key, isOperationEntry(value) ? value.run : cloneOperationTree(value)]));
+const runPromiseOperation = (entry, state, args) => {
+	const result = runClassifiedOperation(entry, args);
+	return entry.boundary === "pure" ? result : provideSdk(state, result);
+};
+const makePromiseOperationTree = (tree, state) => Object.fromEntries(Object.entries(tree).map(([key, value]) => [key, isOperationEntry(value) ? (...args) => runPromiseOperation(value, state, args) : makePromiseOperationTree(value, state)]));
+const assertClassifiedOperationTree = (tree, parentPath = "") => {
+	const entries = Object.entries(tree);
+	if (Object.getPrototypeOf(tree) !== Object.prototype || entries.length === 0) throw new TypeError(`SDK operation namespace ${parentPath || "<root>"} is not a non-empty plain object`);
+	for (const [key, value] of entries) {
+		const path = parentPath ? `${parentPath}.${key}` : key;
+		if (isOperationEntry(value)) continue;
+		if (typeof value === "object" && value !== null) assertClassifiedOperationTree(value, path);
+		else throw new TypeError(`SDK operation ${path} has no request-boundary classification`);
+	}
+};
+const sharedOperationTree = {
 	account: {
 		appSpecificPasswords: {
-			create: createAppSpecificPassword,
-			delete: deleteAppSpecificPassword,
-			deleteAll: deleteAllAppSpecificPasswords,
-			list: listAppSpecificPasswords
-		},
-		clear: clearAccount,
-		destroy: destroyAccount,
-		getInfo: getAccountInfo,
-		getSettings: getAccountSettings,
-		listSubtitleLanguages: listAccountSubtitleLanguages,
-		listConfirmations: listAccountConfirmations,
-		saveSettings: saveAccountSettings
+			create: validated(createAppSpecificPassword),
+			delete: validated(deleteAppSpecificPassword),
+			deleteAll: inputFree(deleteAllAppSpecificPasswords),
+			list: inputFree(listAppSpecificPasswords)
+		},
+		clear: validated(clearAccount),
+		destroy: validated(destroyAccount),
+		getInfo: validated(getAccountInfo),
+		getSettings: inputFree(getAccountSettings),
+		listSubtitleLanguages: inputFree(listAccountSubtitleLanguages),
+		listConfirmations: validated(listAccountConfirmations),
+		saveSettings: validated(saveAccountSettings)
 	},
 	auth: {
-		buildLoginUrl: buildAuthLoginUrl,
-		checkCodeMatch,
-		clients,
-		exchangeAuthorizationCode: exchangeOAuthAuthorizationCode,
-		exists,
-		forgotPassword,
-		getCode,
-		getFamilyInvite,
-		getFriendInvite,
-		getGiftCard,
-		getVoucher,
-		grants,
-		linkDevice,
-		login,
-		logout,
-		register,
-		resetPassword,
-		revokeAllClients,
-		revokeApp,
-		revokeClient,
+		buildLoginUrl: pure(buildAuthLoginUrl),
+		checkCodeMatch: validated(checkCodeMatch),
+		clients: inputFree(clients),
+		exchangeAuthorizationCode: validated(exchangeOAuthAuthorizationCode),
+		exists: validated(exists),
+		forgotPassword: validated(forgotPassword),
+		getCode: validated(getCode),
+		getFamilyInvite: validated(getFamilyInvite),
+		getFriendInvite: validated(getFriendInvite),
+		getGiftCard: validated(getGiftCard),
+		getVoucher: validated(getVoucher),
+		grants: inputFree(grants),
+		linkDevice: validated(linkDevice),
+		login: validated(login),
+		logout: inputFree(logout),
+		register: validated(register),
+		resetPassword: validated(resetPassword),
+		revokeAllClients: inputFree(revokeAllClients),
+		revokeApp: validated(revokeApp),
+		revokeClient: validated(revokeClient),
 		twoFactor: {
-			generateTOTP,
-			getRecoveryCodes,
-			regenerateRecoveryCodes,
-			verifyTOTP
+			generateTOTP: inputFree(generateTOTP),
+			getRecoveryCodes: inputFree(getRecoveryCodes),
+			regenerateRecoveryCodes: inputFree(regenerateRecoveryCodes),
+			verifyTOTP: validated(verifyTOTP)
 		},
-		validateToken
+		validateToken: validated(validateToken)
 	},
 	config: {
-		deleteKey: deleteConfigKey,
-		getKey: getConfigKey,
-		getKeyWith: getConfigKeyWith,
-		read: readConfig,
-		readWith: readConfigWith,
-		setKey: setConfigKey,
-		write: writeConfig
+		deleteKey: validated(deleteConfigKey),
+		getKey: validated(getConfigKey),
+		getKeyWith: validated(getConfigKeyWith),
+		read: inputFree(readConfig),
+		readWith: validated(readConfigWith),
+		setKey: validated(setConfigKey),
+		write: validated(writeConfig)
 	},
 	downloadLinks: {
-		create: createDownloadLinks,
-		get: getDownloadLinks
+		create: validated(createDownloadLinks),
+		get: validated(getDownloadLinks)
 	},
 	events: {
-		clear: clearEvents,
-		delete: deleteEvent,
-		getTorrent: getEventTorrent,
-		list: listEvents
+		clear: inputFree(clearEvents),
+		delete: validated(deleteEvent),
+		getTorrent: validated(getEventTorrent),
+		list: validated(listEvents)
 	},
 	family: {
-		createInvite: createFamilyInvite,
-		join: joinFamily,
-		listInvites: listFamilyInvites,
-		listMembers: listFamilyMembers,
-		removeMember: removeFamilyMember
+		createInvite: inputFree(createFamilyInvite),
+		join: validated(joinFamily),
+		listInvites: inputFree(listFamilyInvites),
+		listMembers: inputFree(listFamilyMembers),
+		removeMember: validated(removeFamilyMember)
 	},
 	ifttt: {
-		getStatus: getIftttStatus,
-		sendEvent: sendIftttEvent
+		getStatus: inputFree(getIftttStatus),
+		sendEvent: validated(sendIftttEvent)
 	},
-	podcast: { getLinks: getPodcastLinks },
+	podcast: { getLinks: validated(getPodcastLinks) },
 	files: {
-		canWrite: canWriteFile,
-		continue: continueFiles,
-		continueSearch,
-		copy: copyFile,
-		convertToMp4: convertFileToMp4,
-		convertManyToMp4: convertFilesToMp4,
-		convertSelectionToMp4: convertFileSelectionToMp4,
-		createUploadRequest: createFileUploadRequest,
-		createFolder,
-		deleteExtraction: deleteFileExtraction,
-		deleteMp4: deleteFileMp4,
-		deleteSelection: deleteFileSelection,
-		delete: deleteFiles,
-		extract: extractFiles,
-		findNext: findNextFile,
-		findNextVideo,
-		getApiContentUrl,
-		getApiDownloadUrl,
-		getApiMp4DownloadUrl,
-		get: getFile,
-		getChild: getFileChild,
-		getDownloadUrl,
-		getHlsStreamUrl,
-		getMp4Status,
-		getStartFrom,
-		list: queryFiles,
-		listActiveConversions: listActiveMp4Conversions,
-		listExtractions: listFileExtractions,
-		listSubtitles: listFileSubtitles,
-		move: moveFiles,
-		moveSelection: moveFileSelection,
-		putMp4ToMyFiles,
-		rename: renameFile,
-		resetSortSettings: resetFileSortSettings,
-		resetStartFrom,
-		search: searchFiles,
-		setSort: setFileSort,
-		setWatchStatus: setFilesWatchStatus,
-		setStartFrom,
-		touch: touchFiles,
-		upload: uploadFile
+		canWrite: validated(canWriteFile),
+		continue: validated(continueFiles),
+		continueSearch: validated(continueSearch),
+		copy: validated(copyFile),
+		convertToMp4: validated(convertFileToMp4),
+		convertManyToMp4: validated(convertFilesToMp4),
+		convertSelectionToMp4: validated(convertFileSelectionToMp4),
+		createUploadRequest: validated(createFileUploadRequest),
+		createFolder: validated(createFolder),
+		deleteExtraction: validated(deleteFileExtraction),
+		deleteMp4: validated(deleteFileMp4),
+		deleteSelection: validated(deleteFileSelection),
+		delete: validated(deleteFiles),
+		extract: validated(extractFiles),
+		findNext: validated(findNextFile),
+		findNextVideo: validated(findNextVideo),
+		getApiContentUrl: validated(getApiContentUrl),
+		getApiDownloadUrl: validated(getApiDownloadUrl),
+		getApiMp4DownloadUrl: validated(getApiMp4DownloadUrl),
+		get: validated(getFile),
+		getChild: validated(getFileChild),
+		getDownloadUrl: validated(getDownloadUrl),
+		getHlsStreamUrl: validated(getHlsStreamUrl),
+		getMp4Status: validated(getMp4Status),
+		getStartFrom: validated(getStartFrom),
+		list: validated(queryFiles),
+		listActiveConversions: inputFree(listActiveMp4Conversions),
+		listExtractions: inputFree(listFileExtractions),
+		listSubtitles: validated(listFileSubtitles),
+		move: validated(moveFiles),
+		moveSelection: validated(moveFileSelection),
+		putMp4ToMyFiles: validated(putMp4ToMyFiles),
+		rename: validated(renameFile),
+		resetSortSettings: inputFree(resetFileSortSettings),
+		resetStartFrom: validated(resetStartFrom),
+		search: validated(searchFiles),
+		setSort: validated(setFileSort),
+		setWatchStatus: validated(setFilesWatchStatus),
+		setStartFrom: validated(setStartFrom),
+		touch: validated(touchFiles),
+		upload: validated(uploadFile)
 	},
 	friendInvites: {
-		create: createFriendInvite,
-		list: listFriendInvites
+		create: inputFree(createFriendInvite),
+		list: inputFree(listFriendInvites)
 	},
 	friends: {
-		approve: approveFriendRequest,
-		countWaitingRequests,
-		deny: denyFriendRequest,
-		list: listFriends,
-		listSentRequests,
-		listWaitingRequests,
-		remove: removeFriend,
-		search: searchFriends,
-		sendRequest: sendFriendRequest,
-		sharedFolder: getFriendSharedFolder
+		approve: validated(approveFriendRequest),
+		countWaitingRequests: inputFree(countWaitingRequests),
+		deny: validated(denyFriendRequest),
+		list: inputFree(listFriends),
+		listSentRequests: inputFree(listSentRequests),
+		listWaitingRequests: inputFree(listWaitingRequests),
+		remove: validated(removeFriend),
+		search: validated(searchFriends),
+		sendRequest: validated(sendFriendRequest),
+		sharedFolder: validated(getFriendSharedFolder)
 	},
 	oauth: {
-		buildAuthorizeUrl: buildOAuthAuthorizeUrl,
-		buildIconUrl: buildOAuthAppIconUrl,
-		create: createOAuthApp,
-		delete: deleteOAuthApp,
-		get: getOAuthApp,
-		getPopularApps: getPopularOAuthApps,
-		query: queryOAuthApps,
-		regenerateToken: regenerateOAuthAppToken,
-		setIcon: setOAuthAppIcon,
-		update: updateOAuthApp
+		buildAuthorizeUrl: pure(buildOAuthAuthorizeUrl),
+		buildIconUrl: pure(buildOAuthAppIconUrl),
+		create: validated(createOAuthApp),
+		delete: validated(deleteOAuthApp),
+		get: validated(getOAuthApp),
+		getPopularApps: inputFree(getPopularOAuthApps),
+		query: inputFree(queryOAuthApps),
+		regenerateToken: validated(regenerateOAuthAppToken),
+		setIcon: validated(setOAuthAppIcon),
+		update: validated(updateOAuthApp)
 	},
 	payment: {
 		changePlan: {
-			classifyResponse: classifyPaymentChangePlanResponse,
-			preview: previewPaymentChangePlan,
-			submit: submitPaymentChangePlan
-		},
-		confirmFastspringOrder,
-		getInfo: getPaymentInfo,
-		listHistory: listPaymentHistory,
-		listInvites: listPaymentInvites,
-		listOptions: listPaymentOptions,
-		listPlans: listPaymentPlans,
+			classifyResponse: pure(classifyPaymentChangePlanResponse),
+			preview: validated(previewPaymentChangePlan),
+			submit: validated(submitPaymentChangePlan)
+		},
+		confirmFastspringOrder: validated(confirmFastspringOrder),
+		getInfo: inputFree(getPaymentInfo),
+		listHistory: validated(listPaymentHistory),
+		listInvites: inputFree(listPaymentInvites),
+		listOptions: inputFree(listPaymentOptions),
+		listPlans: inputFree(listPaymentPlans),
 		methods: {
-			addPaddleWaitingPayment: createPaddleWaitingPayment,
-			createOpenNodeCharge,
-			createPaddleBillingUpdatePaymentMethodTransaction,
-			getPaddleBillingInvoiceUrl
+			addPaddleWaitingPayment: validated(createPaddleWaitingPayment),
+			createOpenNodeCharge: validated(createOpenNodeCharge),
+			createPaddleBillingUpdatePaymentMethodTransaction: validated(createPaddleBillingUpdatePaymentMethodTransaction),
+			getPaddleBillingInvoiceUrl: validated(getPaddleBillingInvoiceUrl)
 		},
-		report: reportPayments,
-		stopSubscription: stopPaymentSubscription,
+		report: validated(reportPayments),
+		stopSubscription: inputFree(stopPaymentSubscription),
 		voucher: {
-			getInfo: getPaymentVoucherInfo,
-			redeem: redeemPaymentVoucher
+			getInfo: validated(getPaymentVoucherInfo),
+			redeem: validated(redeemPaymentVoucher)
 		}
 	},
 	rss: {
-		clearLogs: clearRssFeedLogs,
-		create: createRssFeed,
-		delete: deleteRssFeed,
-		get: getRssFeed,
-		list: listRssFeeds,
-		listItems: listRssFeedItems,
-		pause: pauseRssFeed,
-		resume: resumeRssFeed,
-		retryAll: retryAllRssFeedItems,
-		retryItem: retryRssFeedItem,
-		update: updateRssFeed
+		clearLogs: validated(clearRssFeedLogs),
+		create: validated(createRssFeed),
+		delete: validated(deleteRssFeed),
+		get: validated(getRssFeed),
+		list: inputFree(listRssFeeds),
+		listItems: validated(listRssFeedItems),
+		pause: validated(pauseRssFeed),
+		resume: validated(resumeRssFeed),
+		retryAll: validated(retryAllRssFeedItems),
+		retryItem: validated(retryRssFeedItem),
+		update: validated(updateRssFeed)
 	},
 	sharing: {
-		clone: cloneSharedFiles,
-		getCloneInfo: getSharingCloneInfo,
-		getSharedWith,
-		listSharedFiles,
+		clone: validated(cloneSharedFiles),
+		getCloneInfo: validated(getSharingCloneInfo),
+		getSharedWith: validated(getSharedWith),
+		listSharedFiles: inputFree(listSharedFiles),
 		publicAccess: {
-			continueFiles: continuePublicShareFiles,
-			get: getPublicShare,
-			getFileUrl: getPublicShareFileUrl,
-			listFiles: listPublicShareFiles
+			continueFiles: validated(continuePublicShareFiles),
+			get: inputFree(getPublicShare),
+			getFileUrl: validated(getPublicShareFileUrl),
+			listFiles: validated(listPublicShareFiles)
 		},
 		publicShares: {
-			create: createPublicShare,
-			delete: deletePublicShare,
-			list: listPublicShares
+			create: validated(createPublicShare),
+			delete: validated(deletePublicShare),
+			list: inputFree(listPublicShares)
 		},
-		shareFiles,
-		unshare: unshareFile
+		shareFiles: validated(shareFiles),
+		unshare: validated(unshareFile)
 	},
-	tunnel: { listRoutes: listTunnelRoutes },
+	tunnel: { listRoutes: inputFree(listTunnelRoutes) },
 	trash: {
-		continue: continueTrash,
-		delete: deleteTrash,
-		empty: emptyTrash,
-		list: listTrash,
-		restore: restoreTrash
+		continue: validated(continueTrash),
+		delete: validated(deleteTrash),
+		empty: inputFree(emptyTrash),
+		list: validated(listTrash),
+		restore: validated(restoreTrash)
 	},
 	transfers: {
-		add: addTransfer,
-		addMany: addManyTransfers,
-		addTrackers: addTransferTrackers,
-		cancel: cancelTransfers,
-		clean: cleanTransfers,
-		continue: continueTransfers,
-		count: countTransfers,
-		get: getTransfer,
-		getTorrent: getTransferTorrent,
-		info: getTransferInfo,
-		list: listTransfers,
-		reannounce: reannounceTransfer,
-		remove: removeTransfers,
-		retry: retryTransfer,
-		stopRecording: stopTransferRecording
+		add: validated(addTransfer),
+		addMany: validated(addManyTransfers),
+		addTrackers: validated(addTransferTrackers),
+		cancel: validated(cancelTransfers),
+		clean: validated(cleanTransfers),
+		continue: validated(continueTransfers),
+		count: inputFree(countTransfers),
+		get: validated(getTransfer),
+		getTorrent: validated(getTransferTorrent),
+		info: validated(getTransferInfo),
+		list: validated(listTransfers),
+		reannounce: validated(reannounceTransfer),
+		remove: validated(removeTransfers),
+		retry: validated(retryTransfer),
+		stopRecording: validated(stopTransferRecording)
 	},
 	zips: {
-		cancel: cancelZip,
-		create: createZip,
-		get: getZip,
-		list: listZips
+		cancel: validated(cancelZip),
+		create: validated(createZip),
+		get: validated(getZip),
+		list: inputFree(listZips)
 	}
-});
+};
+assertClassifiedOperationTree(sharedOperationTree);
+const createPutioSdkEffectClient = () => cloneOperationTree(sharedOperationTree);
 var PutioSdk = class extends Context.Service()("PutioSdk") {};
 const makePutioSdkEffectClientLayer = () => Layer.succeed(PutioSdk, createPutioSdkEffectClient());
 const makePutioSdkLiveClientLayer = (config) => Layer.mergeAll(makePutioSdkEffectClientLayer(), makePutioSdkLiveLayer(config));
@@ -5698,248 +5738,34 @@ const createPutioSdkPromiseClient = (initialConfig = {}) => {
 	function getChildByName(input) {
 		return provideSdk(config, getFileChild(input));
 	}
+	const operations = makePromiseOperationTree(sharedOperationTree, config);
 	return {
 		dispose: () => disposePromiseClientRuntime(config),
 		setAccessToken: (accessToken) => {
 			config.accessToken = accessToken;
 		},
+		...operations,
 		account: {
-			appSpecificPasswords: {
-				create: (input) => provideSdk(config, createAppSpecificPassword(input)),
-				delete: (id) => provideSdk(config, deleteAppSpecificPassword(id)),
-				deleteAll: () => provideSdk(config, deleteAllAppSpecificPasswords()),
-				list: () => provideSdk(config, listAppSpecificPasswords())
-			},
-			clear: (options) => provideSdk(config, clearAccount(options)),
-			destroy: (currentPassword) => provideSdk(config, destroyAccount(currentPassword)),
-			getInfo,
-			getSettings: () => provideSdk(config, getAccountSettings()),
-			listSubtitleLanguages: () => provideSdk(config, listAccountSubtitleLanguages()),
-			listConfirmations: (subject) => provideSdk(config, listAccountConfirmations(subject)),
-			saveSettings: (payload) => provideSdk(config, saveAccountSettings(payload))
+			...operations.account,
+			getInfo
 		},
 		auth: {
+			...operations.auth,
 			buildLoginUrl: (options) => buildAuthLoginUrl({
 				...options,
 				webAppUrl: options.webAppUrl ?? config.runtimeConfig.webAppUrl
-			}),
-			checkCodeMatch: (code) => provideSdk(config, checkCodeMatch(code)),
-			clients: () => provideSdk(config, clients()),
-			exchangeAuthorizationCode: (input) => provideSdk(config, exchangeOAuthAuthorizationCode(input)),
-			exists: (key, value) => provideSdk(config, exists(key, value)),
-			forgotPassword: (mail) => provideSdk(config, forgotPassword(mail)),
-			getCode: (input) => provideSdk(config, getCode(input)),
-			getFamilyInvite: (code) => provideSdk(config, getFamilyInvite(code)),
-			getFriendInvite: (code) => provideSdk(config, getFriendInvite(code)),
-			getGiftCard: (code) => provideSdk(config, getGiftCard(code)),
-			getVoucher: (code) => provideSdk(config, getVoucher(code)),
-			grants: () => provideSdk(config, grants()),
-			linkDevice: (code) => provideSdk(config, linkDevice(code)),
-			login: (input) => provideSdk(config, login(input)),
-			logout: () => provideSdk(config, logout()),
-			register: (input) => provideSdk(config, register(input)),
-			resetPassword: (key, password) => provideSdk(config, resetPassword(key, password)),
-			revokeAllClients: () => provideSdk(config, revokeAllClients()),
-			revokeApp: (id) => provideSdk(config, revokeApp(id)),
-			revokeClient: (id) => provideSdk(config, revokeClient(id)),
-			twoFactor: {
-				generateTOTP: () => provideSdk(config, generateTOTP()),
-				getRecoveryCodes: () => provideSdk(config, getRecoveryCodes()),
-				regenerateRecoveryCodes: () => provideSdk(config, regenerateRecoveryCodes()),
-				verifyTOTP: (twoFactorScopedToken, code) => provideSdk(config, verifyTOTP(twoFactorScopedToken, code))
-			},
-			validateToken: (token) => provideSdk(config, validateToken(token))
+			})
 		},
 		config: {
-			deleteKey: (key) => provideSdk(config, deleteConfigKey(key)),
-			getKey: (key) => provideSdk(config, getConfigKey(key)),
+			...operations.config,
 			getKeyWith: (key, schema) => provideSdk(config, getConfigKeyWith(key, schema)),
-			read: () => provideSdk(config, readConfig()),
-			readWith: (schema) => provideSdk(config, readConfigWith(schema)),
-			setKey: (key, value) => provideSdk(config, setConfigKey(key, value)),
-			write: (value) => provideSdk(config, writeConfig(value))
-		},
-		downloadLinks: {
-			create: (input) => provideSdk(config, createDownloadLinks(input)),
-			get: (id) => provideSdk(config, getDownloadLinks(id))
-		},
-		events: {
-			clear: () => provideSdk(config, clearEvents()),
-			delete: (id) => provideSdk(config, deleteEvent(id)),
-			getTorrent: (id) => provideSdk(config, getEventTorrent(id)),
-			list: (query) => provideSdk(config, listEvents(query))
-		},
-		family: {
-			createInvite: () => provideSdk(config, createFamilyInvite()),
-			join: (inviteCode) => provideSdk(config, joinFamily(inviteCode)),
-			listInvites: () => provideSdk(config, listFamilyInvites()),
-			listMembers: () => provideSdk(config, listFamilyMembers()),
-			removeMember: (username) => provideSdk(config, removeFamilyMember(username))
-		},
-		ifttt: {
-			getStatus: () => provideSdk(config, getIftttStatus()),
-			sendEvent: (input) => provideSdk(config, sendIftttEvent(input))
-		},
-		podcast: { getLinks: (input) => provideSdk(config, getPodcastLinks(input)) },
+			readWith: (schema) => provideSdk(config, readConfigWith(schema))
+		},
 		files: {
-			canWrite: (fileId) => provideSdk(config, canWriteFile(fileId)),
-			continue: (cursor, query) => provideSdk(config, continueFiles(cursor, query)),
-			continueSearch: (cursor, query) => provideSdk(config, continueSearch(cursor, query)),
-			copy: (input) => provideSdk(config, copyFile(input)),
-			convertManyToMp4: (ids) => provideSdk(config, convertFilesToMp4(ids)),
-			convertSelectionToMp4: (selection) => provideSdk(config, convertFileSelectionToMp4(selection)),
+			...operations.files,
 			createUploadFormData: createFileUploadFormData,
-			createUploadRequest: (input) => provideSdk(config, createFileUploadRequest(input)),
-			convertToMp4: (fileId) => provideSdk(config, convertFileToMp4(fileId)),
-			createFolder: (input) => provideSdk(config, createFolder(input)),
-			deleteExtraction: (extractionId) => provideSdk(config, deleteFileExtraction(extractionId)),
-			deleteMp4: (fileId) => provideSdk(config, deleteFileMp4(fileId)),
-			deleteSelection: (selection, options) => provideSdk(config, deleteFileSelection(selection, options)),
-			delete: (ids, options) => provideSdk(config, deleteFiles(ids, options)),
-			extract: (selection) => provideSdk(config, extractFiles(selection)),
-			findNext: (fileId, fileType) => provideSdk(config, findNextFile(fileId, fileType)),
-			findNextVideo: (fileId) => provideSdk(config, findNextVideo(fileId)),
-			getApiContentUrl: (fileId, options) => provideSdk(config, getApiContentUrl(fileId, options)),
-			getApiDownloadUrl: (fileId, options) => provideSdk(config, getApiDownloadUrl(fileId, options)),
-			getApiMp4DownloadUrl: (fileId, options) => provideSdk(config, getApiMp4DownloadUrl(fileId, options)),
 			get: getFileById,
-			getChild: getChildByName,
-			getDownloadUrl: (fileId) => provideSdk(config, getDownloadUrl(fileId)),
-			getHlsStreamUrl: (fileId, options) => provideSdk(config, getHlsStreamUrl(fileId, options)),
-			getMp4Status: (fileId) => provideSdk(config, getMp4Status(fileId)),
-			getStartFrom: (fileId) => provideSdk(config, getStartFrom(fileId)),
-			list: (parent, query) => provideSdk(config, queryFiles(parent, query)),
-			listActiveConversions: () => provideSdk(config, listActiveMp4Conversions()),
-			listExtractions: () => provideSdk(config, listFileExtractions()),
-			listSubtitles: (fileId, options) => provideSdk(config, listFileSubtitles(fileId, options)),
-			move: (ids, parentId) => provideSdk(config, moveFiles(ids, parentId)),
-			moveSelection: (selection, parentId) => provideSdk(config, moveFileSelection(selection, parentId)),
-			putMp4ToMyFiles: (fileId) => provideSdk(config, putMp4ToMyFiles(fileId)),
-			rename: (input) => provideSdk(config, renameFile(input)),
-			resetSortSettings: () => provideSdk(config, resetFileSortSettings()),
-			resetStartFrom: (fileId) => provideSdk(config, resetStartFrom(fileId)),
-			search: (query) => provideSdk(config, searchFiles(query)),
-			setSort: (input) => provideSdk(config, setFileSort(input)),
-			setWatchStatus: (selection) => provideSdk(config, setFilesWatchStatus(selection)),
-			setStartFrom: (input) => provideSdk(config, setStartFrom(input)),
-			touch: (input) => provideSdk(config, touchFiles(input)),
-			upload: (input) => provideSdk(config, uploadFile(input))
-		},
-		friendInvites: {
-			create: () => provideSdk(config, createFriendInvite()),
-			list: () => provideSdk(config, listFriendInvites())
-		},
-		friends: {
-			approve: (username) => provideSdk(config, approveFriendRequest(username)),
-			countWaitingRequests: () => provideSdk(config, countWaitingRequests()),
-			deny: (username) => provideSdk(config, denyFriendRequest(username)),
-			list: () => provideSdk(config, listFriends()),
-			listSentRequests: () => provideSdk(config, listSentRequests()),
-			listWaitingRequests: () => provideSdk(config, listWaitingRequests()),
-			remove: (username) => provideSdk(config, removeFriend(username)),
-			search: (username) => provideSdk(config, searchFriends(username)),
-			sendRequest: (username) => provideSdk(config, sendFriendRequest(username)),
-			sharedFolder: (username) => provideSdk(config, getFriendSharedFolder(username))
-		},
-		oauth: {
-			buildAuthorizeUrl: buildOAuthAuthorizeUrl,
-			buildIconUrl: buildOAuthAppIconUrl,
-			create: (input) => provideSdk(config, createOAuthApp(input)),
-			delete: (id) => provideSdk(config, deleteOAuthApp(id)),
-			get: (id, options) => provideSdk(config, getOAuthApp(id, options)),
-			getPopularApps: () => provideSdk(config, getPopularOAuthApps()),
-			query: () => provideSdk(config, queryOAuthApps()),
-			regenerateToken: (id) => provideSdk(config, regenerateOAuthAppToken(id)),
-			setIcon: (id, input) => provideSdk(config, setOAuthAppIcon(id, input)),
-			update: (input) => provideSdk(config, updateOAuthApp(input))
-		},
-		payment: {
-			changePlan: {
-				classifyResponse: classifyPaymentChangePlanResponse,
-				preview: (input) => provideSdk(config, previewPaymentChangePlan(input)),
-				submit: (input) => provideSdk(config, submitPaymentChangePlan(input))
-			},
-			confirmFastspringOrder: (reference) => provideSdk(config, confirmFastspringOrder(reference)),
-			getInfo: () => provideSdk(config, getPaymentInfo()),
-			listHistory: (query) => provideSdk(config, listPaymentHistory(query)),
-			listInvites: () => provideSdk(config, listPaymentInvites()),
-			listOptions: () => provideSdk(config, listPaymentOptions()),
-			listPlans: () => provideSdk(config, listPaymentPlans()),
-			methods: {
-				addPaddleWaitingPayment: (input) => provideSdk(config, createPaddleWaitingPayment(input)),
-				createOpenNodeCharge: (planPath) => provideSdk(config, createOpenNodeCharge(planPath)),
-				createPaddleBillingUpdatePaymentMethodTransaction: (userSubscriptionId) => provideSdk(config, createPaddleBillingUpdatePaymentMethodTransaction(userSubscriptionId)),
-				getPaddleBillingInvoiceUrl: (paymentId) => provideSdk(config, getPaddleBillingInvoiceUrl(paymentId))
-			},
-			report: (paymentIds) => provideSdk(config, reportPayments(paymentIds)),
-			stopSubscription: () => provideSdk(config, stopPaymentSubscription()),
-			voucher: {
-				getInfo: (code) => provideSdk(config, getPaymentVoucherInfo(code)),
-				redeem: (code) => provideSdk(config, redeemPaymentVoucher(code))
-			}
-		},
-		rss: {
-			clearLogs: (id) => provideSdk(config, clearRssFeedLogs(id)),
-			create: (params) => provideSdk(config, createRssFeed(params)),
-			delete: (id) => provideSdk(config, deleteRssFeed(id)),
-			get: (id) => provideSdk(config, getRssFeed(id)),
-			list: () => provideSdk(config, listRssFeeds()),
-			listItems: (id) => provideSdk(config, listRssFeedItems(id)),
-			pause: (id) => provideSdk(config, pauseRssFeed(id)),
-			resume: (id) => provideSdk(config, resumeRssFeed(id)),
-			retryAll: (id) => provideSdk(config, retryAllRssFeedItems(id)),
-			retryItem: (feedId, itemId) => provideSdk(config, retryRssFeedItem(feedId, itemId)),
-			update: (id, params) => provideSdk(config, updateRssFeed(id, params))
-		},
-		sharing: {
-			clone: (input) => provideSdk(config, cloneSharedFiles(input)),
-			getCloneInfo: (id) => provideSdk(config, getSharingCloneInfo(id)),
-			getSharedWith: (fileId) => provideSdk(config, getSharedWith(fileId)),
-			listSharedFiles: () => provideSdk(config, listSharedFiles()),
-			publicAccess: {
-				continueFiles: (cursor, query) => provideSdk(config, continuePublicShareFiles(cursor, query)),
-				get: () => provideSdk(config, getPublicShare()),
-				getFileUrl: (fileId) => provideSdk(config, getPublicShareFileUrl(fileId)),
-				listFiles: (query) => provideSdk(config, listPublicShareFiles(query))
-			},
-			publicShares: {
-				create: (fileId) => provideSdk(config, createPublicShare(fileId)),
-				delete: (id) => provideSdk(config, deletePublicShare(id)),
-				list: () => provideSdk(config, listPublicShares())
-			},
-			shareFiles: (input) => provideSdk(config, shareFiles(input)),
-			unshare: (input) => provideSdk(config, unshareFile(input))
-		},
-		tunnel: { listRoutes: () => provideSdk(config, listTunnelRoutes()) },
-		trash: {
-			continue: (cursor, query) => provideSdk(config, continueTrash(cursor, query)),
-			delete: (input) => provideSdk(config, deleteTrash(input)),
-			empty: () => provideSdk(config, emptyTrash()),
-			list: (query) => provideSdk(config, listTrash(query)),
-			restore: (input) => provideSdk(config, restoreTrash(input))
-		},
-		transfers: {
-			add: (input) => provideSdk(config, addTransfer(input)),
-			addMany: (inputs) => provideSdk(config, addManyTransfers(inputs)),
-			addTrackers: (input) => provideSdk(config, addTransferTrackers(input)),
-			cancel: (ids) => provideSdk(config, cancelTransfers(ids)),
-			clean: (ids) => provideSdk(config, cleanTransfers(ids)),
-			continue: (cursor, query) => provideSdk(config, continueTransfers(cursor, query)),
-			count: () => provideSdk(config, countTransfers()),
-			get: (id) => provideSdk(config, getTransfer(id)),
-			getTorrent: (id) => provideSdk(config, getTransferTorrent(id)),
-			info: (urls) => provideSdk(config, getTransferInfo(urls)),
-			list: (query) => provideSdk(config, listTransfers(query)),
-			reannounce: (id) => provideSdk(config, reannounceTransfer(id)),
-			remove: (input) => provideSdk(config, removeTransfers(input)),
-			retry: (id) => provideSdk(config, retryTransfer(id)),
-			stopRecording: (id) => provideSdk(config, stopTransferRecording(id))
-		},
-		zips: {
-			cancel: (id) => provideSdk(config, cancelZip(id)),
-			create: (input) => provideSdk(config, createZip(input)),
-			get: (id) => provideSdk(config, getZip(id)),
-			list: () => provideSdk(config, listZips())
+			getChild: getChildByName
 		}
 	};
 };