@putdotio/sdk 11.0.0 → 11.0.1

package/dist/index.js

@@ -421,6 +421,17 @@ const deleteAllAppSpecificPasswords = () => requestJson(OkResponseSchema, {
 	path: "/v2/app_specific_password/delete_all"
 }).pipe(Effect.asVoid, withOperationErrors(DeleteAllAppSpecificPasswordsErrorSpec));
 //#endregion
+//#region src/core/validation.ts
+const PositiveIntegerSchema = Schema.Int.check(Schema.isGreaterThan(0));
+const NonEmptyStringSchema = Schema.String.check(Schema.isMinLength(1));
+const decodeAndRun = (schema, input, run) => Schema.decodeUnknownEffect(schema, { onExcessProperty: "error" })(input).pipe(Effect.mapError(mapDecodeErrorToValidationError), Effect.flatMap(run));
+const makeCursorSelectionSchema = (idsField, excludeIdsField, fields) => Schema.Struct({
+	cursor: Schema.optional(NonEmptyStringSchema),
+	[excludeIdsField]: Schema.optional(Schema.Array(PositiveIntegerSchema)),
+	[idsField]: Schema.optional(Schema.Array(PositiveIntegerSchema).check(Schema.isMinLength(1))),
+	...fields
+}).check(Schema.makeFilter((input) => input.cursor !== void 0 || input[idsField] !== void 0, { expected: "a non-empty cursor or file ID selection" }));
+//#endregion
 //#region src/domains/oauth.ts
 const OAuthAppBaseSchema = Schema.Struct({
 	description: Schema.String,
@@ -760,22 +771,48 @@ const RecoveryCodesEnvelopeSchema = Schema.Struct({
 	recovery_codes: TwoFactorRecoveryCodesSchema,
 	status: Schema.Literal("OK")
 });
+const AuthClientIdSchema = Schema.Union([NonEmptyStringSchema, PositiveIntegerSchema]);
+const LoginInputSchema = Schema.Struct({
+	callbackUrl: Schema.optional(NonEmptyStringSchema),
+	clientId: AuthClientIdSchema,
+	clientName: Schema.optional(NonEmptyStringSchema),
+	clientSecret: NonEmptyStringSchema,
+	fingerprint: Schema.optional(NonEmptyStringSchema),
+	password: NonEmptyStringSchema,
+	username: NonEmptyStringSchema
+});
 const RegisterInputSchema = Schema.Struct({
-	client_id: Schema.Union([Schema.String, Schema.Int]),
-	family_invite_code: Schema.optional(Schema.String),
-	friend_invite_code: Schema.optional(Schema.String),
-	gift_card_confirmation_code: Schema.optional(Schema.String),
-	mail: Schema.String,
-	password: Schema.String,
-	plan_name: Schema.optional(Schema.String),
-	username: Schema.String,
-	voucher_code: Schema.optional(Schema.String)
+	client_id: AuthClientIdSchema,
+	family_invite_code: Schema.optional(NonEmptyStringSchema),
+	friend_invite_code: Schema.optional(NonEmptyStringSchema),
+	gift_card_confirmation_code: Schema.optional(NonEmptyStringSchema),
+	mail: NonEmptyStringSchema,
+	password: NonEmptyStringSchema,
+	plan_name: Schema.optional(NonEmptyStringSchema),
+	username: NonEmptyStringSchema,
+	voucher_code: Schema.optional(NonEmptyStringSchema)
 });
 const OAuthAuthorizationCodeExchangeInputSchema = Schema.Struct({
-	clientId: Schema.Union([Schema.String.check(Schema.isMinLength(1)), Schema.Int.check(Schema.isGreaterThan(0))]),
-	clientSecret: Schema.String.check(Schema.isMinLength(1)),
-	code: Schema.String.check(Schema.isMinLength(1)),
-	redirectUri: Schema.optional(Schema.String.check(Schema.isMinLength(1)))
+	clientId: AuthClientIdSchema,
+	clientSecret: NonEmptyStringSchema,
+	code: NonEmptyStringSchema,
+	redirectUri: Schema.optional(NonEmptyStringSchema)
+});
+const AuthExistsInputSchema = Schema.Struct({
+	key: Schema.Literals(["mail", "username"]),
+	value: NonEmptyStringSchema
+});
+const AuthResetPasswordInputSchema = Schema.Struct({
+	key: NonEmptyStringSchema,
+	password: NonEmptyStringSchema
+});
+const AuthGetCodeInputSchema = Schema.Struct({
+	appId: AuthClientIdSchema,
+	clientName: Schema.optional(NonEmptyStringSchema)
+});
+const AuthVerifyTotpInputSchema = Schema.Struct({
+	code: NonEmptyStringSchema,
+	twoFactorScopedToken: NonEmptyStringSchema
 });
 const LoginErrorSpec = definePutioOperationErrorSpec({
 	domain: "auth",
@@ -1010,6 +1047,11 @@ const RegenerateRecoveryCodesErrorSpec = definePutioOperationErrorSpec({
 		statusCode: 401
 	}]
 });
+const decodeAuthInput = (operation, schema, input, run) => Schema.decodeUnknownEffect(schema, { onExcessProperty: "error" })(input).pipe(Effect.mapError(() => new PutioValidationError({ cause: {
+	domain: "auth",
+	operation,
+	reason: "Invalid request input"
+} })), Effect.flatMap(run));
 const buildAuthLoginUrl = (options) => buildPutioUrl(options.webAppUrl ?? "https://app.put.io", "/authenticate", {
 	client_id: options.clientId,
 	client_name: options.clientName,
@@ -1023,11 +1065,7 @@ const mapOAuthAuthorizationCodeExchangeError = (error) => error instanceof Putio
 	code: error.body.error,
 	status: 400
 }) : error;
-const exchangeOAuthAuthorizationCode = (input) => Schema.decodeUnknownEffect(OAuthAuthorizationCodeExchangeInputSchema)(input).pipe(Effect.mapError(() => new PutioValidationError({ cause: {
-	domain: "auth",
-	operation: "exchangeAuthorizationCode",
-	reason: "Invalid request input"
-} })), Effect.flatMap((decodedInput) => requestJson(OAuthAuthorizationCodeResponseSchema, {
+const exchangeOAuthAuthorizationCode = (input) => decodeAuthInput("exchangeAuthorizationCode", OAuthAuthorizationCodeExchangeInputSchema, input, (decodedInput) => requestJson(OAuthAuthorizationCodeResponseSchema, {
 	auth: { type: "none" },
 	body: {
 		type: "form",
@@ -1041,129 +1079,132 @@ const exchangeOAuthAuthorizationCode = (input) => Schema.decodeUnknownEffect(OAu
 	},
 	method: "POST",
 	path: "/v2/oauth2/access_token"
-}).pipe(selectJsonField("access_token"), Effect.mapError(mapOAuthAuthorizationCodeExchangeError))));
-const login = (input) => requestJson(LoginResponseSchema, {
+}).pipe(selectJsonField("access_token"), Effect.mapError(mapOAuthAuthorizationCodeExchangeError)));
+const login = (input) => decodeAuthInput("login", LoginInputSchema, input, (decodedInput) => requestJson(LoginResponseSchema, {
 	auth: {
 		type: "basic",
-		password: input.password,
-		username: input.username
+		password: decodedInput.password,
+		username: decodedInput.username
 	},
 	method: "PUT",
-	path: input.fingerprint ? `/v2/oauth2/authorizations/clients/${encodePathSegment(input.clientId)}/${encodePathSegment(input.fingerprint)}` : `/v2/oauth2/authorizations/clients/${encodePathSegment(input.clientId)}`,
+	path: decodedInput.fingerprint ? `/v2/oauth2/authorizations/clients/${encodePathSegment(decodedInput.clientId)}/${encodePathSegment(decodedInput.fingerprint)}` : `/v2/oauth2/authorizations/clients/${encodePathSegment(decodedInput.clientId)}`,
 	query: {
-		callback_url: input.callbackUrl,
-		client_name: input.clientName,
-		client_secret: input.clientSecret
+		callback_url: decodedInput.callbackUrl,
+		client_name: decodedInput.clientName,
+		client_secret: decodedInput.clientSecret
 	}
-}).pipe(selectJsonFields("access_token", "user_id"), withOperationErrors(LoginErrorSpec));
+}).pipe(selectJsonFields("access_token", "user_id"))).pipe(withOperationErrors(LoginErrorSpec));
 const logout = () => requestJson(OkResponseSchema, {
 	method: "POST",
 	path: "/v2/oauth/grants/logout"
 });
-const register = (input) => requestJson(ResetPasswordEnvelopeSchema, {
+const register = (input) => decodeAuthInput("register", RegisterInputSchema, input, (decodedInput) => requestJson(ResetPasswordEnvelopeSchema, {
 	auth: { type: "none" },
 	body: {
 		type: "form",
-		value: input
+		value: decodedInput
 	},
 	method: "POST",
 	path: "/v2/registration/register"
-}).pipe(selectJsonFields("access_token"), withOperationErrors(RegisterErrorSpec));
-const exists = (key, value) => requestJson(ExistsEnvelopeSchema, {
+}).pipe(selectJsonFields("access_token"))).pipe(withOperationErrors(RegisterErrorSpec));
+const exists = (key, value) => decodeAuthInput("exists", AuthExistsInputSchema, {
+	key,
+	value
+}, (decodedInput) => requestJson(ExistsEnvelopeSchema, {
 	auth: { type: "none" },
 	method: "GET",
-	path: `/v2/registration/exists/${encodePathSegment(key)}`,
-	query: { value }
-}).pipe(selectJsonField("exists"));
-const getVoucher = (code) => requestJson(VoucherEnvelopeSchema, {
+	path: `/v2/registration/exists/${encodePathSegment(decodedInput.key)}`,
+	query: { value: decodedInput.value }
+}).pipe(selectJsonField("exists")));
+const getVoucher = (code) => decodeAuthInput("getVoucher", NonEmptyStringSchema, code, (decodedCode) => requestJson(VoucherEnvelopeSchema, {
 	auth: { type: "none" },
 	method: "GET",
-	path: `/v2/registration/voucher/${encodePathSegment(code)}`
-}).pipe(selectJsonField("voucher"), withOperationErrors(VoucherLookupErrorSpec));
-const getGiftCard = (code) => requestJson(GiftCardEnvelopeSchema, {
+	path: `/v2/registration/voucher/${encodePathSegment(decodedCode)}`
+}).pipe(selectJsonField("voucher"))).pipe(withOperationErrors(VoucherLookupErrorSpec));
+const getGiftCard = (code) => decodeAuthInput("getGiftCard", NonEmptyStringSchema, code, (decodedCode) => requestJson(GiftCardEnvelopeSchema, {
 	auth: { type: "none" },
 	method: "GET",
-	path: `/v2/registration/gift_card/${encodePathSegment(code)}`
-}).pipe(selectJsonField("gift_card"), withOperationErrors(GiftCardLookupErrorSpec));
-const getFamilyInvite = (code) => requestJson(FamilyInviteEnvelopeSchema, {
+	path: `/v2/registration/gift_card/${encodePathSegment(decodedCode)}`
+}).pipe(selectJsonField("gift_card"))).pipe(withOperationErrors(GiftCardLookupErrorSpec));
+const getFamilyInvite = (code) => decodeAuthInput("getFamilyInvite", NonEmptyStringSchema, code, (decodedCode) => requestJson(FamilyInviteEnvelopeSchema, {
 	auth: { type: "none" },
 	method: "GET",
-	path: `/v2/registration/family/${encodePathSegment(code)}`
-}).pipe(selectJsonField("invite"), withOperationErrors(FamilyInviteLookupErrorSpec));
-const getFriendInvite = (code) => requestJson(FriendInviteEnvelopeSchema, {
+	path: `/v2/registration/family/${encodePathSegment(decodedCode)}`
+}).pipe(selectJsonField("invite"))).pipe(withOperationErrors(FamilyInviteLookupErrorSpec));
+const getFriendInvite = (code) => decodeAuthInput("getFriendInvite", NonEmptyStringSchema, code, (decodedCode) => requestJson(FriendInviteEnvelopeSchema, {
 	auth: { type: "none" },
 	method: "GET",
-	path: `/v2/registration/friend/${encodePathSegment(code)}`
-}).pipe(selectJsonField("invite"), withOperationErrors(FriendInviteLookupErrorSpec));
-const forgotPassword = (mail) => requestJson(OkResponseSchema, {
+	path: `/v2/registration/friend/${encodePathSegment(decodedCode)}`
+}).pipe(selectJsonField("invite"))).pipe(withOperationErrors(FriendInviteLookupErrorSpec));
+const forgotPassword = (mail) => decodeAuthInput("forgotPassword", NonEmptyStringSchema, mail, (decodedMail) => requestJson(OkResponseSchema, {
 	auth: { type: "none" },
 	body: {
 		type: "form",
-		value: { mail }
+		value: { mail: decodedMail }
 	},
 	method: "POST",
 	path: "/v2/registration/password/forgot"
-}).pipe(withOperationErrors(ForgotPasswordErrorSpec));
-const resetPassword = (key, password) => requestJson(ResetPasswordEnvelopeSchema, {
+})).pipe(withOperationErrors(ForgotPasswordErrorSpec));
+const resetPassword = (key, password) => decodeAuthInput("resetPassword", AuthResetPasswordInputSchema, {
+	key,
+	password
+}, (decodedInput) => requestJson(ResetPasswordEnvelopeSchema, {
 	auth: { type: "none" },
 	body: {
 		type: "form",
-		value: {
-			key,
-			password
-		}
+		value: decodedInput
 	},
 	method: "POST",
 	path: "/v2/registration/password/reset"
-}).pipe(selectJsonFields("access_token"), withOperationErrors(ResetPasswordErrorSpec));
-const getCode = (input) => requestJson(AuthorizationCodeEnvelopeSchema, {
+}).pipe(selectJsonFields("access_token"))).pipe(withOperationErrors(ResetPasswordErrorSpec));
+const getCode = (input) => decodeAuthInput("getCode", AuthGetCodeInputSchema, input, (decodedInput) => requestJson(AuthorizationCodeEnvelopeSchema, {
 	auth: { type: "none" },
 	method: "GET",
 	path: "/v2/oauth2/oob/code",
 	query: {
-		app_id: input.appId,
-		client_name: input.clientName
+		app_id: decodedInput.appId,
+		client_name: decodedInput.clientName
 	}
-}).pipe(selectJsonFields("code", "qr_code_url"));
-const checkCodeMatch = (code) => requestJson(CodeMatchEnvelopeSchema, {
+}).pipe(selectJsonFields("code", "qr_code_url")));
+const checkCodeMatch = (code) => decodeAuthInput("checkCodeMatch", NonEmptyStringSchema, code, (decodedCode) => requestJson(CodeMatchEnvelopeSchema, {
 	auth: { type: "none" },
 	method: "GET",
-	path: `/v2/oauth2/oob/code/${encodePathSegment(code)}`
-}).pipe(selectJsonField("oauth_token"));
-const linkDevice = (code) => requestJson(LinkDeviceEnvelopeSchema, {
+	path: `/v2/oauth2/oob/code/${encodePathSegment(decodedCode)}`
+}).pipe(selectJsonField("oauth_token")));
+const linkDevice = (code) => decodeAuthInput("linkDevice", NonEmptyStringSchema, code, (decodedCode) => requestJson(LinkDeviceEnvelopeSchema, {
 	body: {
 		type: "form",
-		value: { code }
+		value: { code: decodedCode }
 	},
 	method: "POST",
 	path: "/v2/oauth2/oob/code"
-}).pipe(selectJsonField("app"), withOperationErrors(LinkDeviceErrorSpec));
+}).pipe(selectJsonField("app"))).pipe(withOperationErrors(LinkDeviceErrorSpec));
 const grants = () => requestJson(GrantsEnvelopeSchema, {
 	method: "GET",
 	path: "/v2/oauth/grants/"
 }).pipe(selectJsonField("apps"), withOperationErrors(GrantsErrorSpec));
-const revokeApp = (id) => requestJson(OkResponseSchema, {
+const revokeApp = (id) => decodeAuthInput("revokeApp", PositiveIntegerSchema, id, (decodedId) => requestJson(OkResponseSchema, {
 	method: "POST",
-	path: `/v2/oauth/grants/${encodePathSegment(id)}/delete`
-}).pipe(withOperationErrors(RevokeOAuthGrantErrorSpec));
+	path: `/v2/oauth/grants/${encodePathSegment(decodedId)}/delete`
+})).pipe(withOperationErrors(RevokeOAuthGrantErrorSpec));
 const clients = () => requestJson(ClientsEnvelopeSchema, {
 	method: "GET",
 	path: "/v2/oauth/clients/"
 }).pipe(selectJsonField("clients"), withOperationErrors(ClientsErrorSpec));
-const revokeClient = (id) => requestJson(OkResponseSchema, {
+const revokeClient = (id) => decodeAuthInput("revokeClient", PositiveIntegerSchema, id, (decodedId) => requestJson(OkResponseSchema, {
 	method: "POST",
-	path: `/v2/oauth/clients/${encodePathSegment(id)}/delete`
-}).pipe(withOperationErrors(RevokeOAuthClientErrorSpec));
+	path: `/v2/oauth/clients/${encodePathSegment(decodedId)}/delete`
+})).pipe(withOperationErrors(RevokeOAuthClientErrorSpec));
 const revokeAllClients = () => requestJson(OkResponseSchema, {
 	method: "POST",
 	path: "/v2/oauth/clients/delete-all"
 }).pipe(withOperationErrors(RevokeAllOAuthClientsErrorSpec));
-const validateToken = (token) => requestJson(ValidateTokenResponseSchema, {
+const validateToken = (token) => decodeAuthInput("validateToken", NonEmptyStringSchema, token, (decodedToken) => requestJson(ValidateTokenResponseSchema, {
 	auth: { type: "none" },
 	method: "GET",
 	path: "/v2/oauth2/validate",
-	query: { oauth_token: token }
-});
+	query: { oauth_token: decodedToken }
+}));
 const generateTOTP = () => requestJson(GenerateTOTPEnvelopeSchema, {
 	method: "POST",
 	path: "/v2/two_factor/generate/totp"
@@ -1172,19 +1213,22 @@ const generateTOTP = () => requestJson(GenerateTOTPEnvelopeSchema, {
 	secret,
 	uri
 })), withOperationErrors(GenerateTOTPErrorSpec));
-const verifyTOTP = (twoFactorScopedToken, code) => requestJson(VerifyTOTPEnvelopeSchema, {
+const verifyTOTP = (twoFactorScopedToken, code) => decodeAuthInput("verifyTOTP", AuthVerifyTotpInputSchema, {
+	code,
+	twoFactorScopedToken
+}, (decodedInput) => requestJson(VerifyTOTPEnvelopeSchema, {
 	auth: { type: "none" },
 	body: {
 		type: "form",
-		value: { code }
+		value: { code: decodedInput.code }
 	},
 	method: "POST",
 	path: "/v2/two_factor/verify/totp",
-	query: { oauth_token: twoFactorScopedToken }
+	query: { oauth_token: decodedInput.twoFactorScopedToken }
 }).pipe(Effect.map(({ token, user_id }) => ({
 	token,
 	user_id
-})), withOperationErrors(VerifyTOTPErrorSpec));
+})))).pipe(withOperationErrors(VerifyTOTPErrorSpec));
 const getRecoveryCodes = () => requestJson(RecoveryCodesEnvelopeSchema, {
 	method: "GET",
 	path: "/v2/two_factor/recovery_codes"
@@ -1383,16 +1427,6 @@ const deleteConfigKey = (key) => Schema.decodeUnknownEffect(ConfigKeySchema)(key
 	path: `/v2/config/${encodePathSegment(decodedKey)}`
 })));
 //#endregion
-//#region src/core/validation.ts
-const PositiveIntegerSchema = Schema.Int.check(Schema.isGreaterThan(0));
-const NonEmptyStringSchema = Schema.String.check(Schema.isMinLength(1));
-const decodeAndRun = (schema, input, run) => Schema.decodeUnknownEffect(schema)(input).pipe(Effect.mapError(mapDecodeErrorToValidationError), Effect.flatMap(run));
-const makeCursorSelectionSchema = (idsField, excludeIdsField) => Schema.Struct({
-	cursor: Schema.optional(NonEmptyStringSchema),
-	[excludeIdsField]: Schema.optional(Schema.Array(PositiveIntegerSchema)),
-	[idsField]: Schema.optional(Schema.Array(PositiveIntegerSchema).check(Schema.isMinLength(1)))
-}).check(Schema.makeFilter((input) => input.cursor !== void 0 || input[idsField] !== void 0, { expected: "a non-empty cursor or file ID selection" }));
-//#endregion
 //#region src/domains/download-links.ts
 const DownloadLinksStatusSchema = Schema.Literals([
 	"NEW",
@@ -1400,7 +1434,7 @@ const DownloadLinksStatusSchema = Schema.Literals([
 	"DONE",
 	"ERROR"
 ]);
-const DownloadLinksCreateInputSchema = makeCursorSelectionSchema("ids", "excludeIds");
+const DownloadLinksCreateInputSchema = makeCursorSelectionSchema("ids", "excludeIds", {});
 const DownloadLinksPayloadSchema = Schema.Struct({
 	download_links: Schema.Array(Schema.String),
 	media_links: Schema.Array(Schema.String),
@@ -1784,6 +1818,17 @@ const IFTTTStatusEnvelopeSchema = Schema.Struct({
 	enabled: Schema.Boolean,
 	status: Schema.Literal("OK")
 });
+const IftttPlaybackIngredientsSchema = Schema.Struct({
+	file_id: PositiveIntegerSchema,
+	file_name: NonEmptyStringSchema,
+	file_type: NonEmptyStringSchema
+});
+const isIftttPlaybackIngredients = Schema.is(IftttPlaybackIngredientsSchema);
+const IftttEventInputSchema = Schema.Struct({
+	clientName: Schema.optional(NonEmptyStringSchema),
+	eventType: NonEmptyStringSchema,
+	ingredients: JsonObjectSchema
+}).check(Schema.makeFilter((input) => input.eventType !== "playback_started" && input.eventType !== "playback_stopped" ? true : isIftttPlaybackIngredients(input.ingredients), { expected: "complete playback ingredients for playback events" }));
 const GetIftttStatusErrorSpec = definePutioOperationErrorSpec({
 	domain: "ifttt",
 	operation: "getStatus",
@@ -1813,18 +1858,18 @@ const getIftttStatus = () => requestJson(IFTTTStatusEnvelopeSchema, {
 	method: "GET",
 	path: "/v2/ifttt-client/status"
 }).pipe(selectJsonFields("enabled"), withOperationErrors(GetIftttStatusErrorSpec));
-const sendIftttEvent = (input) => requestJson(OkResponseSchema, {
+const sendIftttEvent = (input) => decodeAndRun(IftttEventInputSchema, input, (decodedInput) => requestJson(OkResponseSchema, {
 	body: {
 		type: "form",
 		value: {
-			client_name: input.clientName,
-			event_type: input.eventType,
-			ingredients: input.ingredients
+			client_name: decodedInput.clientName,
+			event_type: decodedInput.eventType,
+			ingredients: decodedInput.ingredients
 		}
 	},
 	method: "POST",
 	path: "/v2/ifttt-client/event"
-}).pipe(Effect.asVoid, withOperationErrors(SendIftttEventErrorSpec));
+})).pipe(Effect.asVoid, withOperationErrors(SendIftttEventErrorSpec));
 //#endregion
 //#region src/domains/files.ts
 const RequestedFlag = Schema.Literal(1);
@@ -1997,18 +2042,42 @@ const FilesSearchEnvelopeSchema = Schema.Struct({
 	status: Schema.Literal("OK"),
 	total: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
 });
-Schema.Struct({
-	name: Schema.optional(Schema.String),
-	parent_id: Schema.optional(Schema.Int),
-	path: Schema.optional(Schema.String)
+const FilesListInputSchema = Schema.Struct({
+	parent: Schema.Union([NonNegativeFileIdSchema, Schema.Literal("friends")]),
+	query: FilesListQuerySchema
 });
-Schema.Struct({
-	file_id: Schema.Int,
-	name: Schema.String
+const FilesContinueInputSchema = Schema.Struct({
+	cursor: NonEmptyStringSchema,
+	query: Schema.Struct({ per_page: Schema.optional(PositiveIntegerSchema) })
 });
-Schema.Struct({
-	file_id: Schema.Int,
-	time: Schema.Number
+const FileGetInputSchema = Schema.Struct({
+	id: NonNegativeFileIdSchema,
+	query: Schema.optional(FileQuerySchema)
+});
+const FilesSearchContinueInputSchema = Schema.Struct({
+	cursor: NonEmptyStringSchema,
+	query: Schema.Struct({ per_page: Schema.optional(PositiveIntegerSchema) })
+});
+const FileSubtitlesInputSchema = Schema.Struct({
+	fileId: PositiveFileIdSchema,
+	options: Schema.Struct({ languages: Schema.optional(Schema.Array(NonEmptyStringSchema).check(Schema.isMinLength(1))) })
+});
+const FileNextInputSchema = Schema.Struct({
+	fileId: PositiveFileIdSchema,
+	fileType: FileTypeSchema
+});
+const FileCreateFolderInputSchema = Schema.Struct({
+	name: Schema.optional(NonEmptyStringSchema),
+	parent_id: Schema.optional(NonNegativeFileIdSchema),
+	path: Schema.optional(NonEmptyStringSchema)
+}).check(Schema.makeFilter((input) => input.name !== void 0 || input.path !== void 0, { expected: "a non-empty folder name or path" }));
+const FileRenameInputSchema = Schema.Struct({
+	file_id: PositiveFileIdSchema,
+	name: NonEmptyStringSchema
+});
+const FileStartFromSetInputSchema = Schema.Struct({
+	file_id: PositiveFileIdSchema,
+	time: Schema.Number.check(Schema.isGreaterThanOrEqualTo(0))
 });
 const FileStartFromEnvelopeSchema = Schema.Struct({
 	start_from: Schema.Number.check(Schema.isGreaterThanOrEqualTo(0)),
@@ -2128,10 +2197,51 @@ const FileExtractionsEnvelopeSchema = Schema.Struct({
 	extractions: Schema.Array(FileExtractionSchema),
 	status: Schema.optional(Schema.Literal("OK"))
 });
-Schema.Struct({
-	cursor: Schema.optional(Schema.String),
-	excludeIds: Schema.optional(Schema.Array(Schema.Int)),
-	ids: Schema.optional(Schema.Array(Schema.Int))
+const FilesBulkSelectionSchema = Schema.Struct({
+	cursor: Schema.optional(NonEmptyStringSchema),
+	excludeIds: Schema.optional(Schema.Array(PositiveIntegerSchema)),
+	ids: Schema.optional(Schema.Array(PositiveIntegerSchema).check(Schema.isMinLength(1)))
+}).check(Schema.makeFilter((input) => input.cursor !== void 0 || input.ids !== void 0, { expected: "a non-empty cursor or file ID selection" }));
+const FilesDeleteOptionsSchema = Schema.Struct({
+	ignoreFileOwner: Schema.optional(Schema.Boolean),
+	partialDelete: Schema.optional(Schema.Boolean),
+	skipTrash: Schema.optional(Schema.Boolean)
+});
+const FilesSelectionDeleteOptionsSchema = Schema.Struct({
+	partialDelete: Schema.optional(Schema.Boolean),
+	skipTrash: Schema.optional(Schema.Boolean)
+});
+const FilesIdsInputSchema = Schema.Array(PositiveFileIdSchema).check(Schema.isMinLength(1));
+const FilesMoveInputSchema = Schema.Struct({
+	ids: FilesIdsInputSchema,
+	parentId: NonNegativeFileIdSchema
+});
+const FilesMoveSelectionInputSchema = Schema.Struct({
+	parentId: NonNegativeFileIdSchema,
+	selection: FilesBulkSelectionSchema
+});
+const FilesWatchStatusInputSchema = makeCursorSelectionSchema("ids", "excludeIds", { watched: Schema.Boolean });
+const FilesExtractInputSchema = makeCursorSelectionSchema("ids", "excludeIds", { password: Schema.optional(NonEmptyStringSchema) });
+const FileUploadInputSchema = Schema.Struct({
+	file: Schema.instanceOf(Blob),
+	fileName: Schema.optional(NonEmptyStringSchema),
+	parentId: Schema.optional(NonNegativeFileIdSchema)
+});
+const FileUploadOptionsSchema = Schema.Struct({ oauthToken: Schema.optional(NonEmptyStringSchema) });
+const FileDirectAccessOptionsSchema = Schema.Struct({
+	oauthToken: Schema.optional(NonEmptyStringSchema),
+	useTunnel: Schema.optional(Schema.Boolean)
+});
+const FileApiDownloadUrlOptionsSchema = FileDirectAccessOptionsSchema.pipe(Schema.fieldsAssign({ name: Schema.optional(NonEmptyStringSchema) }));
+const FileApiMp4DownloadUrlOptionsSchema = FileDirectAccessOptionsSchema.pipe(Schema.fieldsAssign({
+	convert: Schema.optional(Schema.Boolean),
+	name: Schema.optional(NonEmptyStringSchema)
+}));
+const FileHlsStreamUrlOptionsSchema = Schema.Struct({
+	maxSubtitleCount: Schema.optional(PositiveIntegerSchema),
+	oauthToken: Schema.optional(NonEmptyStringSchema),
+	playOriginal: Schema.optional(Schema.Boolean),
+	subtitleLanguages: Schema.optional(Schema.Array(NonEmptyStringSchema).check(Schema.isMinLength(1)))
 });
 const FilesNextFileSchema = Schema.Struct({
 	id: Schema.Int,
@@ -2488,32 +2598,38 @@ const ensureFileQueryFields = (effect, query) => Effect.gen(function* () {
 	if (query.media_info === 1 && !hasMediaInfo(file)) return yield* failMissingField("media_info");
 	return file;
 });
-const queryFiles = (parent, query = {}) => requestJson(FilesListEnvelopeSchema, {
+const queryFiles = (parent, query = {}) => decodeAndRun(FilesListInputSchema, {
+	parent,
+	query
+}, (decodedInput) => requestJson(FilesListEnvelopeSchema, {
 	method: "GET",
-	path: parent === "friends" ? "/v2/files/list/items-shared-with-you" : "/v2/files/list",
-	query: parent === "friends" ? query : {
-		...query,
-		parent_id: parent
+	path: decodedInput.parent === "friends" ? "/v2/files/list/items-shared-with-you" : "/v2/files/list",
+	query: decodedInput.parent === "friends" ? decodedInput.query : {
+		...decodedInput.query,
+		parent_id: decodedInput.parent
 	}
-}).pipe(withOperationErrors(QueryFilesErrorSpec));
-const continueFiles = (cursor, query = {}) => requestJson(FilesListContinueEnvelopeSchema, {
+})).pipe(withOperationErrors(QueryFilesErrorSpec));
+const continueFiles = (cursor, query = {}) => decodeAndRun(FilesContinueInputSchema, {
+	cursor,
+	query
+}, (decodedInput) => requestJson(FilesListContinueEnvelopeSchema, {
 	body: {
 		type: "form",
-		value: { cursor }
+		value: { cursor: decodedInput.cursor }
 	},
 	method: "POST",
 	path: "/v2/files/list/continue",
-	query
-}).pipe(withOperationErrors(ContinueFilesErrorSpec));
+	query: decodedInput.query
+})).pipe(withOperationErrors(ContinueFilesErrorSpec));
 function getFile(input) {
-	if (input.query === null) return Effect.fail(new PutioValidationError({ cause: "getFile query must be an object when provided" }));
-	const effect = requestJson(FileEnvelopeSchema, {
-		method: "GET",
-		path: `/v2/files/${encodePathSegment(input.id)}`,
-		query: input.query
-	}).pipe(selectJsonField("file"), withOperationErrors(GetFileErrorSpec));
-	if (input.query === void 0) return effect;
-	return ensureFileQueryFields(effect, input.query);
+	return decodeAndRun(FileGetInputSchema, input, (decodedInput) => {
+		const effect = requestJson(FileEnvelopeSchema, {
+			method: "GET",
+			path: `/v2/files/${encodePathSegment(decodedInput.id)}`,
+			query: decodedInput.query
+		}).pipe(selectJsonField("file"), withOperationErrors(GetFileErrorSpec));
+		return decodedInput.query === void 0 ? effect : ensureFileQueryFields(effect, decodedInput.query);
+	});
 }
 function getFileChild(input) {
 	return Schema.decodeUnknownEffect(FileGetChildInputSchema)(input).pipe(Effect.mapError(mapDecodeErrorToValidationError), Effect.flatMap((decodedInput) => {
@@ -2560,15 +2676,18 @@ const searchFiles = (query) => Schema.decodeUnknownEffect(FilesSearchQuerySchema
 	path: "/v2/files/search",
 	query: decodedQuery
 })), withOperationErrors(SearchFilesErrorSpec));
-const continueSearch = (cursor, query = {}) => requestJson(FilesSearchEnvelopeSchema, {
+const continueSearch = (cursor, query = {}) => decodeAndRun(FilesSearchContinueInputSchema, {
+	cursor,
+	query
+}, (decodedInput) => requestJson(FilesSearchEnvelopeSchema, {
 	body: {
 		type: "form",
-		value: { cursor }
+		value: { cursor: decodedInput.cursor }
 	},
 	method: "POST",
 	path: "/v2/files/search/continue",
-	query
-}).pipe(withOperationErrors(SearchFilesErrorSpec));
+	query: decodedInput.query
+})).pipe(withOperationErrors(SearchFilesErrorSpec));
 const setFileSort = (input) => Schema.decodeUnknownEffect(FileSetSortInputSchema)(input).pipe(Effect.mapError(mapDecodeErrorToValidationError), Effect.flatMap((decodedInput) => requestJson(OkResponseSchema, {
 	body: {
 		type: "form",
@@ -2584,203 +2703,263 @@ const resetFileSortSettings = () => requestJson(OkResponseSchema, {
 	method: "POST",
 	path: "/v2/files/remove-sort-by-settings"
 }).pipe(Effect.asVoid);
-const createFolder = (input) => requestJson(FileEnvelopeSchema, {
+const createFolder = (input) => decodeAndRun(FileCreateFolderInputSchema, input, (decodedInput) => requestJson(FileEnvelopeSchema, {
 	body: {
 		type: "form",
-		value: input
+		value: decodedInput
 	},
 	method: "POST",
 	path: "/v2/files/create-folder"
-}).pipe(selectJsonField("file"), withOperationErrors(CreateFolderErrorSpec));
-const renameFile = (input) => requestJson(OkResponseSchema, {
+})).pipe(selectJsonField("file"), withOperationErrors(CreateFolderErrorSpec));
+const renameFile = (input) => decodeAndRun(FileRenameInputSchema, input, (decodedInput) => requestJson(OkResponseSchema, {
 	body: {
 		type: "form",
-		value: input
+		value: decodedInput
 	},
 	method: "POST",
 	path: "/v2/files/rename"
-}).pipe(withOperationErrors(RenameFileErrorSpec));
-const deleteFiles = (ids, options = {}) => requestJson(FileDeleteResultEnvelopeSchema, {
+})).pipe(withOperationErrors(RenameFileErrorSpec));
+const deleteFiles = (ids, options = {}) => decodeAndRun(Schema.Struct({
+	ids: FilesIdsInputSchema,
+	options: FilesDeleteOptionsSchema
+}), {
+	ids,
+	options
+}, (decodedInput) => requestJson(FileDeleteResultEnvelopeSchema, {
 	body: {
 		type: "form",
-		value: { file_ids: joinCsv(ids) }
+		value: { file_ids: joinCsv(decodedInput.ids) }
 	},
 	method: "POST",
 	path: "/v2/files/delete",
 	query: {
-		partial_delete: options.partialDelete,
+		partial_delete: decodedInput.options.partialDelete,
 		skip_nonexistents: true,
-		skip_owner_check: options.ignoreFileOwner,
-		skip_trash: options.skipTrash
+		skip_owner_check: decodedInput.options.ignoreFileOwner,
+		skip_trash: decodedInput.options.skipTrash
 	}
-});
-const deleteFileSelection = (selection, options = {}) => requestJson(FileDeleteResultEnvelopeSchema, {
+}));
+const deleteFileSelection = (selection, options = {}) => decodeAndRun(Schema.Struct({
+	options: FilesSelectionDeleteOptionsSchema,
+	selection: FilesBulkSelectionSchema
+}), {
+	options,
+	selection
+}, (decodedInput) => requestJson(FileDeleteResultEnvelopeSchema, {
 	body: {
 		type: "form",
-		value: toCursorSelectionForm(selection)
+		value: toCursorSelectionForm(decodedInput.selection)
 	},
 	method: "POST",
 	path: "/v2/files/delete",
 	query: {
-		partial_delete: options.partialDelete,
+		partial_delete: decodedInput.options.partialDelete,
 		skip_nonexistents: true,
-		skip_trash: options.skipTrash
+		skip_trash: decodedInput.options.skipTrash
 	}
-});
-const moveFiles = (ids, parentId) => requestJson(FilesMoveEnvelopeSchema, {
+}));
+const moveFiles = (ids, parentId) => decodeAndRun(FilesMoveInputSchema, {
+	ids,
+	parentId
+}, (decodedInput) => requestJson(FilesMoveEnvelopeSchema, {
 	body: {
 		type: "form",
 		value: {
-			file_ids: joinCsv(ids),
-			parent_id: parentId
+			file_ids: joinCsv(decodedInput.ids),
+			parent_id: decodedInput.parentId
 		}
 	},
 	method: "POST",
 	path: "/v2/files/move"
-}).pipe(selectJsonField("errors"));
-const moveFileSelection = (selection, parentId) => requestJson(FilesMoveEnvelopeSchema, {
+})).pipe(selectJsonField("errors"));
+const moveFileSelection = (selection, parentId) => decodeAndRun(FilesMoveSelectionInputSchema, {
+	parentId,
+	selection
+}, (decodedInput) => requestJson(FilesMoveEnvelopeSchema, {
 	body: {
 		type: "form",
 		value: {
-			...toCursorSelectionForm(selection),
-			parent_id: parentId
+			...toCursorSelectionForm(decodedInput.selection),
+			parent_id: decodedInput.parentId
 		}
 	},
 	method: "POST",
 	path: "/v2/files/move"
-}).pipe(selectJsonField("errors"));
-const getStartFrom = (fileId) => requestJson(FileStartFromEnvelopeSchema, {
+})).pipe(selectJsonField("errors"));
+const getStartFrom = (fileId) => decodeAndRun(PositiveFileIdSchema, fileId, (decodedFileId) => requestJson(FileStartFromEnvelopeSchema, {
 	method: "GET",
-	path: `/v2/files/${encodePathSegment(fileId)}/start-from`
-}).pipe(selectJsonField("start_from"), withOperationErrors(StartFromErrorSpec));
-const getDownloadUrl = (fileId) => requestJson(FileDownloadUrlEnvelopeSchema, {
+	path: `/v2/files/${encodePathSegment(decodedFileId)}/start-from`
+})).pipe(selectJsonField("start_from"), withOperationErrors(StartFromErrorSpec));
+const getDownloadUrl = (fileId) => decodeAndRun(PositiveFileIdSchema, fileId, (decodedFileId) => requestJson(FileDownloadUrlEnvelopeSchema, {
 	method: "GET",
-	path: `/v2/files/${encodePathSegment(fileId)}/url`
-}).pipe(selectJsonField("url"), withOperationErrors(DownloadUrlErrorSpec));
-const getApiDownloadUrl = (fileId, options = {}) => resolveRouteContext(options.oauthToken).pipe(Effect.map(({ config, oauthToken }) => buildFileApiDownloadUrl(config.baseUrl ?? "https://api.put.io", fileId, {
-	...options,
+	path: `/v2/files/${encodePathSegment(decodedFileId)}/url`
+})).pipe(selectJsonField("url"), withOperationErrors(DownloadUrlErrorSpec));
+const getApiDownloadUrl = (fileId, options = {}) => decodeAndRun(Schema.Struct({
+	fileId: PositiveFileIdSchema,
+	options: FileApiDownloadUrlOptionsSchema
+}), {
+	fileId,
+	options
+}, (decoded) => resolveRouteContext(decoded.options.oauthToken).pipe(Effect.map(({ config, oauthToken }) => buildFileApiDownloadUrl(config.baseUrl ?? "https://api.put.io", decoded.fileId, {
+	...decoded.options,
 	oauthToken
-})));
-const getApiContentUrl = (fileId, options = {}) => resolveRouteContext(options.oauthToken).pipe(Effect.map(({ config, oauthToken }) => buildFileApiContentUrl(config.baseUrl ?? "https://api.put.io", fileId, {
-	...options,
+}))));
+const getApiContentUrl = (fileId, options = {}) => decodeAndRun(Schema.Struct({
+	fileId: PositiveFileIdSchema,
+	options: FileDirectAccessOptionsSchema
+}), {
+	fileId,
+	options
+}, (decoded) => resolveRouteContext(decoded.options.oauthToken).pipe(Effect.map(({ config, oauthToken }) => buildFileApiContentUrl(config.baseUrl ?? "https://api.put.io", decoded.fileId, {
+	...decoded.options,
 	oauthToken
-})));
-const getApiMp4DownloadUrl = (fileId, options = {}) => resolveRouteContext(options.oauthToken).pipe(Effect.map(({ config, oauthToken }) => buildFileApiMp4DownloadUrl(config.baseUrl ?? "https://api.put.io", fileId, {
-	...options,
+}))));
+const getApiMp4DownloadUrl = (fileId, options = {}) => decodeAndRun(Schema.Struct({
+	fileId: PositiveFileIdSchema,
+	options: FileApiMp4DownloadUrlOptionsSchema
+}), {
+	fileId,
+	options
+}, (decoded) => resolveRouteContext(decoded.options.oauthToken).pipe(Effect.map(({ config, oauthToken }) => buildFileApiMp4DownloadUrl(config.baseUrl ?? "https://api.put.io", decoded.fileId, {
+	...decoded.options,
 	oauthToken
-})));
-const getHlsStreamUrl = (fileId, options = {}) => resolveRouteContext(options.oauthToken).pipe(Effect.map(({ config, oauthToken }) => buildFileHlsStreamUrl(config.baseUrl ?? "https://api.put.io", fileId, {
-	...options,
+}))));
+const getHlsStreamUrl = (fileId, options = {}) => decodeAndRun(Schema.Struct({
+	fileId: PositiveFileIdSchema,
+	options: FileHlsStreamUrlOptionsSchema
+}), {
+	fileId,
+	options
+}, (decoded) => resolveRouteContext(decoded.options.oauthToken).pipe(Effect.map(({ config, oauthToken }) => buildFileHlsStreamUrl(config.baseUrl ?? "https://api.put.io", decoded.fileId, {
+	...decoded.options,
 	oauthToken
-})));
-const listFileSubtitles = (fileId, options = {}) => requestJson(FileSubtitlesEnvelopeSchema, {
+}))));
+const listFileSubtitles = (fileId, options = {}) => decodeAndRun(FileSubtitlesInputSchema, {
+	fileId,
+	options
+}, (decodedInput) => requestJson(FileSubtitlesEnvelopeSchema, {
 	method: "GET",
-	path: `/v2/files/${encodePathSegment(fileId)}/subtitles`,
-	query: options.languages ? { languages: joinCsv(options.languages) } : void 0
-}).pipe(withOperationErrors(FileSubtitlesErrorSpec));
-const setStartFrom = (input) => requestJson(OkResponseSchema, {
+	path: `/v2/files/${encodePathSegment(decodedInput.fileId)}/subtitles`,
+	query: decodedInput.options.languages ? { languages: joinCsv(decodedInput.options.languages) } : void 0
+})).pipe(withOperationErrors(FileSubtitlesErrorSpec));
+const setStartFrom = (input) => decodeAndRun(FileStartFromSetInputSchema, input, (decodedInput) => requestJson(OkResponseSchema, {
 	body: {
 		type: "form",
-		value: { time: input.time }
+		value: { time: decodedInput.time }
 	},
 	method: "POST",
-	path: `/v2/files/${encodePathSegment(input.file_id)}/start-from`
-}).pipe(withOperationErrors(StartFromErrorSpec));
-const resetStartFrom = (fileId) => requestJson(OkResponseSchema, {
+	path: `/v2/files/${encodePathSegment(decodedInput.file_id)}/start-from`
+})).pipe(withOperationErrors(StartFromErrorSpec));
+const resetStartFrom = (fileId) => decodeAndRun(PositiveFileIdSchema, fileId, (decodedFileId) => requestJson(OkResponseSchema, {
 	method: "POST",
-	path: `/v2/files/${encodePathSegment(fileId)}/start-from/delete`
-}).pipe(withOperationErrors(StartFromErrorSpec));
-const getMp4Status = (fileId) => requestJson(FileConversionStatusEnvelopeSchema, {
+	path: `/v2/files/${encodePathSegment(decodedFileId)}/start-from/delete`
+})).pipe(withOperationErrors(StartFromErrorSpec));
+const getMp4Status = (fileId) => decodeAndRun(PositiveFileIdSchema, fileId, (decodedFileId) => requestJson(FileConversionStatusEnvelopeSchema, {
 	method: "GET",
-	path: `/v2/files/${encodePathSegment(fileId)}/mp4`
-}).pipe(selectJsonField("mp4"), withOperationErrors(FileMp4ErrorSpec));
-const convertFileToMp4 = (fileId) => requestJson(FileConversionStatusEnvelopeSchema, {
+	path: `/v2/files/${encodePathSegment(decodedFileId)}/mp4`
+})).pipe(selectJsonField("mp4"), withOperationErrors(FileMp4ErrorSpec));
+const convertFileToMp4 = (fileId) => decodeAndRun(PositiveFileIdSchema, fileId, (decodedFileId) => requestJson(FileConversionStatusEnvelopeSchema, {
 	method: "POST",
-	path: `/v2/files/${encodePathSegment(fileId)}/mp4`
-}).pipe(selectJsonField("mp4"), withOperationErrors(FileMp4ErrorSpec));
-const deleteFileMp4 = (fileId) => requestVoid({
+	path: `/v2/files/${encodePathSegment(decodedFileId)}/mp4`
+})).pipe(selectJsonField("mp4"), withOperationErrors(FileMp4ErrorSpec));
+const deleteFileMp4 = (fileId) => decodeAndRun(PositiveFileIdSchema, fileId, (decodedFileId) => requestVoid({
 	method: "DELETE",
-	path: `/v2/files/${encodePathSegment(fileId)}/mp4`
-}).pipe(withOperationErrors(FileMp4MutationErrorSpec));
-const putMp4ToMyFiles = (fileId) => requestVoid({
+	path: `/v2/files/${encodePathSegment(decodedFileId)}/mp4`
+})).pipe(withOperationErrors(FileMp4MutationErrorSpec));
+const putMp4ToMyFiles = (fileId) => decodeAndRun(PositiveFileIdSchema, fileId, (decodedFileId) => requestVoid({
 	method: "GET",
-	path: `/v2/files/${encodePathSegment(fileId)}/put-mp4-to-my-folders`
-}).pipe(withOperationErrors(FileMp4MutationErrorSpec));
-const convertFilesToMp4 = (ids) => requestJson(FilesBulkConvertEnvelopeSchema, {
+	path: `/v2/files/${encodePathSegment(decodedFileId)}/put-mp4-to-my-folders`
+})).pipe(withOperationErrors(FileMp4MutationErrorSpec));
+const convertFilesToMp4 = (ids) => decodeAndRun(FilesIdsInputSchema, ids, (decodedIds) => requestJson(FilesBulkConvertEnvelopeSchema, {
 	body: {
 		type: "form",
-		value: { file_ids: joinCsv(ids) }
+		value: { file_ids: joinCsv(decodedIds) }
 	},
 	method: "POST",
 	path: "/v2/files/convert_mp4"
-}).pipe(selectJsonField("count"));
-const convertFileSelectionToMp4 = (selection) => requestJson(FilesBulkConvertEnvelopeSchema, {
+})).pipe(selectJsonField("count"));
+const convertFileSelectionToMp4 = (selection) => decodeAndRun(FilesBulkSelectionSchema, selection, (decodedSelection) => requestJson(FilesBulkConvertEnvelopeSchema, {
 	body: {
 		type: "form",
-		value: toCursorSelectionForm(selection)
+		value: toCursorSelectionForm(decodedSelection)
 	},
 	method: "POST",
 	path: "/v2/files/convert_mp4"
-}).pipe(selectJsonField("count"));
+})).pipe(selectJsonField("count"));
 const listActiveMp4Conversions = () => requestJson(FileActiveConversionsEnvelopeSchema, {
 	method: "GET",
 	path: "/v2/mp4/queue"
 }).pipe(selectJsonField("mp4s"), withOperationErrors(FileActiveConversionsErrorSpec));
-const setFilesWatchStatus = (selection) => requestVoid({
+const setFilesWatchStatus = (selection) => decodeAndRun(FilesWatchStatusInputSchema, selection, (decodedSelection) => requestVoid({
 	body: {
 		type: "form",
 		value: {
-			...toCursorSelectionForm(selection),
-			watched: selection.watched
+			...toCursorSelectionForm(decodedSelection),
+			watched: decodedSelection.watched
 		}
 	},
 	method: "POST",
 	path: "/v2/files/watch-status"
-}).pipe(withOperationErrors(FileWatchStatusErrorSpec));
-const extractFiles = (selection) => requestJson(FileExtractionsEnvelopeSchema, {
+})).pipe(withOperationErrors(FileWatchStatusErrorSpec));
+const extractFiles = (selection) => decodeAndRun(FilesExtractInputSchema, selection, (decodedSelection) => requestJson(FileExtractionsEnvelopeSchema, {
 	body: {
 		type: "form",
 		value: {
-			...toCursorSelectionForm(selection, "user_file_ids"),
-			password: selection.password
+			...toCursorSelectionForm(decodedSelection, "user_file_ids"),
+			password: decodedSelection.password
 		}
 	},
 	method: "POST",
 	path: "/v2/files/extract"
-}).pipe(selectJsonField("extractions"), withOperationErrors(FileExtractionsErrorSpec));
+})).pipe(selectJsonField("extractions"), withOperationErrors(FileExtractionsErrorSpec));
 const listFileExtractions = () => requestJson(FileExtractionsEnvelopeSchema, {
 	method: "GET",
 	path: "/v2/files/extract"
 }).pipe(selectJsonField("extractions"), withOperationErrors(FileExtractionsErrorSpec));
-const deleteFileExtraction = (extractionId) => requestVoid({
+const deleteFileExtraction = (extractionId) => decodeAndRun(PositiveIntegerSchema, extractionId, (decodedExtractionId) => requestVoid({
 	method: "DELETE",
-	path: `/v2/files/extract/${encodePathSegment(extractionId)}`
-});
-const findNextFile = (fileId, fileType) => requestJson(FilesNextFileEnvelopeSchema, {
+	path: `/v2/files/extract/${encodePathSegment(decodedExtractionId)}`
+}));
+const findNextFile = (fileId, fileType) => decodeAndRun(FileNextInputSchema, {
+	fileId,
+	fileType
+}, (decodedInput) => requestJson(FilesNextFileEnvelopeSchema, {
 	method: "GET",
-	path: `/v2/files/${encodePathSegment(fileId)}/next-file`,
-	query: { file_type: fileType }
-}).pipe(selectJsonField("next_file"));
-const findNextVideo = (fileId) => requestJson(FilesNextVideoEnvelopeSchema, {
+	path: `/v2/files/${encodePathSegment(decodedInput.fileId)}/next-file`,
+	query: { file_type: decodedInput.fileType }
+})).pipe(selectJsonField("next_file"));
+const findNextVideo = (fileId) => decodeAndRun(PositiveFileIdSchema, fileId, (decodedFileId) => requestJson(FilesNextVideoEnvelopeSchema, {
 	method: "GET",
-	path: `/v2/files/${encodePathSegment(fileId)}/next-video`
-}).pipe(selectJsonField("next_video"));
-const createFileUploadRequest = (input, options = {}) => resolveRouteContext(options.oauthToken).pipe(Effect.map(({ config, oauthToken }) => ({
-	body: createFileUploadFormData(input),
+	path: `/v2/files/${encodePathSegment(decodedFileId)}/next-video`
+})).pipe(selectJsonField("next_video"));
+const createFileUploadRequest = (input, options = {}) => decodeAndRun(Schema.Struct({
+	input: FileUploadInputSchema,
+	options: FileUploadOptionsSchema
+}), {
+	input,
+	options
+}, (decoded) => resolveRouteContext(decoded.options.oauthToken).pipe(Effect.map(({ config, oauthToken }) => ({
+	body: createFileUploadFormData(decoded.input),
 	method: "POST",
 	url: buildPutioUrl(config.uploadBaseUrl ?? "https://upload.put.io", "/v2/files/upload", { oauth_token: oauthToken })
-})));
-const uploadFile = (input, options = {}) => resolveRouteContext(options.oauthToken).pipe(Effect.flatMap(({ config, oauthToken }) => requestJson(FileUploadEnvelopeSchema, {
+}))));
+const uploadFile = (input, options = {}) => decodeAndRun(Schema.Struct({
+	input: FileUploadInputSchema,
+	options: FileUploadOptionsSchema
+}), {
+	input,
+	options
+}, (decoded) => resolveRouteContext(decoded.options.oauthToken).pipe(Effect.flatMap(({ config, oauthToken }) => requestJson(FileUploadEnvelopeSchema, {
 	auth: { type: "none" },
 	baseUrl: config.uploadBaseUrl ?? "https://upload.put.io",
 	body: {
 		type: "form-data",
-		value: createFileUploadFormData(input)
+		value: createFileUploadFormData(decoded.input)
 	},
 	method: "POST",
 	path: "/v2/files/upload",
 	query: { oauth_token: oauthToken }
-})), Effect.map(toUploadResult), withOperationErrors(FileUploadErrorSpec));
+})))).pipe(Effect.map(toUploadResult), withOperationErrors(FileUploadErrorSpec));
 //#endregion
 //#region src/domains/friend-invites.ts
 const FriendInviteJoinedUserStatusSchema = Schema.Literals([
@@ -3291,6 +3470,23 @@ const PaymentOpenNodeChargeEnvelopeSchema = Schema.Struct({
 	opennode: Schema.Struct({ checkout_url: Schema.String }),
 	status: Schema.Literal("OK")
 });
+const PaymentHistoryQuerySchema = Schema.Struct({ unreported_only: Schema.optional(Schema.Boolean) });
+const PaymentChangePlanPreviewInputSchema = Schema.Struct({
+	coupon_code: Schema.optional(NonEmptyStringSchema),
+	payment_type: Schema.optional(PaymentTypeSchema),
+	plan_path: NonEmptyStringSchema
+});
+const PaymentChangePlanSubmitInputSchema = Schema.Struct({
+	confirmation_code: Schema.optional(NonEmptyStringSchema),
+	coupon_code: Schema.optional(NonEmptyStringSchema),
+	payment_type: Schema.optional(PaymentTypeSchema),
+	plan_path: NonEmptyStringSchema
+});
+const PaymentPaddleWaitingPaymentInputSchema = Schema.Struct({
+	checkout_id: NonEmptyStringSchema,
+	product_id: Schema.Union([NonEmptyStringSchema, PositiveIntegerSchema])
+});
+const PaymentIdsSchema = Schema.Array(PositiveIntegerSchema).check(Schema.isMinLength(1));
 const RestrictedPaymentError = {
 	errorType: "invalid_scope",
 	statusCode: 401
@@ -3603,83 +3799,83 @@ const listPaymentOptions = () => requestJson(PaymentOptionsEnvelopeSchema, {
 	method: "GET",
 	path: "/v2/payment/options"
 }).pipe(selectJsonField("options"), withOperationErrors(ListPaymentOptionsErrorSpec));
-const listPaymentHistory = (query) => requestJson(PaymentHistoryEnvelopeSchema, {
+const listPaymentHistory = (query = {}) => decodeAndRun(PaymentHistoryQuerySchema, query, (decodedQuery) => requestJson(PaymentHistoryEnvelopeSchema, {
 	method: "GET",
 	path: "/v2/payment/history",
-	query
-}).pipe(selectJsonField("payments"), withOperationErrors(ListPaymentHistoryErrorSpec));
+	query: decodedQuery
+}).pipe(selectJsonField("payments"))).pipe(withOperationErrors(ListPaymentHistoryErrorSpec));
 const listPaymentInvites = () => requestJson(PaymentInvitesEnvelopeSchema, {
 	method: "GET",
 	path: "/v2/payment/invites"
 }).pipe(selectJsonField("vouchers"), withOperationErrors(ListPaymentInvitesErrorSpec));
-const previewPaymentChangePlan = (input) => requestJson(PaymentChangePlanPreviewSchema, {
+const previewPaymentChangePlan = (input) => decodeAndRun(PaymentChangePlanPreviewInputSchema, input, (decodedInput) => requestJson(PaymentChangePlanPreviewSchema, {
 	method: "GET",
-	path: `/v2/payment/change_plan/${encodeURIComponent(input.plan_path)}`,
+	path: `/v2/payment/change_plan/${encodeURIComponent(decodedInput.plan_path)}`,
 	query: {
-		coupon_code: input.coupon_code,
-		payment_type: input.payment_type
+		coupon_code: decodedInput.coupon_code,
+		payment_type: decodedInput.payment_type
 	}
-}).pipe(withOperationErrors(PreviewPaymentChangePlanErrorSpec));
-const submitPaymentChangePlan = (input) => requestJson(PaymentChangePlanSubmitSchema, {
+})).pipe(withOperationErrors(PreviewPaymentChangePlanErrorSpec));
+const submitPaymentChangePlan = (input) => decodeAndRun(PaymentChangePlanSubmitInputSchema, input, (decodedInput) => requestJson(PaymentChangePlanSubmitSchema, {
 	body: {
 		type: "form",
 		value: {
-			confirmation_code: input.confirmation_code,
-			payment_type: input.payment_type
+			confirmation_code: decodedInput.confirmation_code,
+			payment_type: decodedInput.payment_type
 		}
 	},
 	method: "POST",
-	path: `/v2/payment/change_plan/${encodeURIComponent(input.plan_path)}`,
-	query: { coupon_code: input.coupon_code }
-}).pipe(withOperationErrors(SubmitPaymentChangePlanErrorSpec));
-const confirmFastspringOrder = (reference) => requestJson(PaymentFastspringConfirmEnvelopeSchema, {
+	path: `/v2/payment/change_plan/${encodeURIComponent(decodedInput.plan_path)}`,
+	query: { coupon_code: decodedInput.coupon_code }
+})).pipe(withOperationErrors(SubmitPaymentChangePlanErrorSpec));
+const confirmFastspringOrder = (reference) => decodeAndRun(NonEmptyStringSchema, reference, (decodedReference) => requestJson(PaymentFastspringConfirmEnvelopeSchema, {
 	method: "GET",
-	path: `/v2/payment/fs-confirm/${encodeURIComponent(reference)}`
-}).pipe(selectJsonField("confirmed"), withOperationErrors(ConfirmFastspringOrderErrorSpec));
+	path: `/v2/payment/fs-confirm/${encodeURIComponent(decodedReference)}`
+}).pipe(selectJsonField("confirmed"))).pipe(withOperationErrors(ConfirmFastspringOrderErrorSpec));
 const stopPaymentSubscription = () => requestJson(OkResponseSchema, {
 	method: "POST",
 	path: "/v2/payment/stop_subscription"
 }).pipe(Effect.asVoid, withOperationErrors(StopSubscriptionErrorSpec));
-const getPaymentVoucherInfo = (code) => requestJson(PaymentVoucherInfoSchema, {
+const getPaymentVoucherInfo = (code) => decodeAndRun(NonEmptyStringSchema, code, (decodedCode) => requestJson(PaymentVoucherInfoSchema, {
 	method: "GET",
-	path: `/v2/payment/redeem_voucher/${encodeURIComponent(code)}`
-}).pipe(withOperationErrors(GetPaymentVoucherInfoErrorSpec));
-const redeemPaymentVoucher = (code) => requestJson(OkResponseSchema, {
+	path: `/v2/payment/redeem_voucher/${encodeURIComponent(decodedCode)}`
+})).pipe(withOperationErrors(GetPaymentVoucherInfoErrorSpec));
+const redeemPaymentVoucher = (code) => decodeAndRun(NonEmptyStringSchema, code, (decodedCode) => requestJson(OkResponseSchema, {
 	method: "POST",
-	path: `/v2/payment/redeem_voucher/${encodeURIComponent(code)}`
-}).pipe(Effect.asVoid, withOperationErrors(RedeemPaymentVoucherErrorSpec));
-const reportPayments = (paymentIds) => requestJson(OkResponseSchema, {
+	path: `/v2/payment/redeem_voucher/${encodeURIComponent(decodedCode)}`
+})).pipe(Effect.asVoid, withOperationErrors(RedeemPaymentVoucherErrorSpec));
+const reportPayments = (paymentIds) => decodeAndRun(PaymentIdsSchema, paymentIds, (decodedPaymentIds) => requestJson(OkResponseSchema, {
 	body: {
 		type: "form",
-		value: { payment_ids: joinCsv(paymentIds) }
+		value: { payment_ids: joinCsv(decodedPaymentIds) }
 	},
 	method: "POST",
 	path: "/v2/payment/report"
-}).pipe(Effect.asVoid, withOperationErrors(ReportPaymentsErrorSpec));
-const createPaddleWaitingPayment = (input) => requestJson(OkResponseSchema, {
+})).pipe(Effect.asVoid, withOperationErrors(ReportPaymentsErrorSpec));
+const createPaddleWaitingPayment = (input) => decodeAndRun(PaymentPaddleWaitingPaymentInputSchema, input, (decodedInput) => requestJson(OkResponseSchema, {
 	body: {
 		type: "form",
-		value: input
+		value: decodedInput
 	},
 	method: "POST",
 	path: "/v2/payment/paddle_waiting_payment"
-}).pipe(Effect.asVoid, withOperationErrors(CreatePaddleWaitingPaymentErrorSpec));
-const getPaddleBillingInvoiceUrl = (paymentId) => requestJson(PaymentPaddleBillingInvoiceEnvelopeSchema, {
+})).pipe(Effect.asVoid, withOperationErrors(CreatePaddleWaitingPaymentErrorSpec));
+const getPaddleBillingInvoiceUrl = (paymentId) => decodeAndRun(PositiveIntegerSchema, paymentId, (decodedPaymentId) => requestJson(PaymentPaddleBillingInvoiceEnvelopeSchema, {
 	method: "GET",
-	path: `/v2/payment/methods/paddle_billing/invoice/${encodeURIComponent(paymentId)}`
-}).pipe(selectJsonField("url"), withOperationErrors(GetPaddleBillingInvoiceUrlErrorSpec));
-const createPaddleBillingUpdatePaymentMethodTransaction = (userSubscriptionId) => requestJson(PaymentPaddleBillingUpdatePaymentMethodEnvelopeSchema, {
+	path: `/v2/payment/methods/paddle_billing/invoice/${encodeURIComponent(decodedPaymentId)}`
+}).pipe(selectJsonField("url"))).pipe(withOperationErrors(GetPaddleBillingInvoiceUrlErrorSpec));
+const createPaddleBillingUpdatePaymentMethodTransaction = (userSubscriptionId) => decodeAndRun(PositiveIntegerSchema, userSubscriptionId, (decodedUserSubscriptionId) => requestJson(PaymentPaddleBillingUpdatePaymentMethodEnvelopeSchema, {
 	method: "GET",
-	path: `/v2/payment/methods/paddle_billing/update_payment_method/${encodeURIComponent(userSubscriptionId)}`
-}).pipe(selectJsonField("transaction_id"), withOperationErrors(CreatePaddleBillingUpdatePaymentMethodTransactionErrorSpec));
-const createOpenNodeCharge = (planPath) => requestJson(PaymentOpenNodeChargeEnvelopeSchema, {
+	path: `/v2/payment/methods/paddle_billing/update_payment_method/${encodeURIComponent(decodedUserSubscriptionId)}`
+}).pipe(selectJsonField("transaction_id"))).pipe(withOperationErrors(CreatePaddleBillingUpdatePaymentMethodTransactionErrorSpec));
+const createOpenNodeCharge = (planPath) => decodeAndRun(NonEmptyStringSchema, planPath, (decodedPlanPath) => requestJson(PaymentOpenNodeChargeEnvelopeSchema, {
 	body: {
 		type: "form",
-		value: { plan_fs_path: planPath }
+		value: { plan_fs_path: decodedPlanPath }
 	},
 	method: "POST",
 	path: "/v2/payment/methods/opennode/charge"
-}).pipe(selectJsonField("opennode"), Effect.map(({ checkout_url }) => checkout_url), withOperationErrors(CreateOpenNodeChargeErrorSpec));
+}).pipe(selectJsonField("opennode"), Effect.map(({ checkout_url }) => checkout_url))).pipe(withOperationErrors(CreateOpenNodeChargeErrorSpec));
 //#endregion
 //#region src/domains/podcast.ts
 const PodcastLinkTypeSchema = Schema.Literals([
@@ -4609,7 +4805,7 @@ const emptyTrash = () => requestJson(OkResponseSchema, {
 }).pipe(Effect.asVoid, withOperationErrors(EmptyTrashErrorSpec));
 //#endregion
 //#region src/domains/transfers.ts
-const TransferIdSchema = Schema.Int.check(Schema.isGreaterThan(0));
+const TransferIdSchema = PositiveIntegerSchema;
 const TransferIdsSchema = Schema.Array(TransferIdSchema).check(Schema.isMinLength(1));
 const TransferTypeSchema = Schema.Literals([
 	"URL",
@@ -4705,12 +4901,20 @@ const TransferSchema = Schema.Union([
 	TransferCompletedSchema,
 	TransferBaseSchema
 ]);
-const TransfersListQuerySchema = Schema.Struct({ per_page: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))) });
+const TransfersListQuerySchema = Schema.Struct({ per_page: Schema.optional(PositiveIntegerSchema) });
 const TransferAddInputSchema = Schema.Struct({
-	callback_url: Schema.optional(Schema.String),
-	save_parent_id: Schema.optional(Schema.Int),
-	url: Schema.String
+	callback_url: Schema.optional(NonEmptyStringSchema),
+	save_parent_id: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
+	url: NonEmptyStringSchema
 });
+const TransferContinueInputSchema = Schema.Struct({
+	cursor: NonEmptyStringSchema,
+	query: TransfersListQuerySchema
+});
+const TransferInfoUrlSchema = Schema.String.check(Schema.isMinLength(1), Schema.isPattern(/^[^\r\n]+$/));
+const TransferInfoUrlsSchema = Schema.Array(TransferInfoUrlSchema).check(Schema.isMinLength(1));
+const TransferAddManyInputSchema = Schema.Array(TransferAddInputSchema).check(Schema.isMinLength(1));
+const TransferCleanIdsSchema = Schema.Array(TransferIdSchema);
 const TrackerSchema = Schema.String.check(Schema.isPattern(/^[^,\s]+$/));
 const TransferAddTrackersInputSchema = Schema.Struct({
 	trackers: Schema.Array(TrackerSchema).check(Schema.isMinLength(1)),
@@ -4931,112 +5135,115 @@ const StopRecordingTransferErrorSpec = definePutioOperationErrorSpec({
 		{ statusCode: 404 }
 	]
 });
-const listTransfers = (query = {}) => requestJson(TransfersListEnvelopeSchema, {
+const listTransfers = (query = {}) => decodeAndRun(TransfersListQuerySchema, query, (decodedQuery) => requestJson(TransfersListEnvelopeSchema, {
 	method: "GET",
 	path: "/v2/transfers/list",
+	query: decodedQuery
+})).pipe(withOperationErrors(ListTransfersErrorSpec));
+const continueTransfers = (cursor, query = {}) => decodeAndRun(TransferContinueInputSchema, {
+	cursor,
 	query
-}).pipe(withOperationErrors(ListTransfersErrorSpec));
-const continueTransfers = (cursor, query = {}) => requestJson(TransfersContinueEnvelopeSchema, {
+}, (decodedInput) => requestJson(TransfersContinueEnvelopeSchema, {
 	body: {
 		type: "form",
-		value: { cursor }
+		value: { cursor: decodedInput.cursor }
 	},
 	method: "POST",
 	path: "/v2/transfers/list/continue",
-	query
-}).pipe(withOperationErrors(ListTransfersErrorSpec));
-const getTransfer = (id) => requestJson(TransferEnvelopeSchema, {
+	query: decodedInput.query
+})).pipe(withOperationErrors(ListTransfersErrorSpec));
+const getTransfer = (id) => decodeAndRun(TransferIdSchema, id, (decodedId) => requestJson(TransferEnvelopeSchema, {
 	method: "GET",
-	path: `/v2/transfers/${encodePathSegment(id)}`
-}).pipe(selectJsonField("transfer"), withOperationErrors(GetTransferErrorSpec));
-const getTransferTorrent = (id) => Schema.decodeUnknownEffect(TransferIdSchema)(id).pipe(Effect.mapError(mapDecodeErrorToValidationError), Effect.flatMap((decodedId) => requestArrayBuffer({
+	path: `/v2/transfers/${encodePathSegment(decodedId)}`
+}).pipe(selectJsonField("transfer"))).pipe(withOperationErrors(GetTransferErrorSpec));
+const getTransferTorrent = (id) => decodeAndRun(TransferIdSchema, id, (decodedId) => requestArrayBuffer({
 	method: "GET",
 	path: `/v2/transfers/${encodePathSegment(decodedId)}/torrent`
-})), withOperationErrors(GetTransferTorrentErrorSpec));
+})).pipe(withOperationErrors(GetTransferTorrentErrorSpec));
 const countTransfers = () => requestJson(TransferCountEnvelopeSchema, {
 	method: "GET",
 	path: "/v2/transfers/count"
 }).pipe(selectJsonField("count"));
-const getTransferInfo = (urls) => requestJson(TransferInfoEnvelopeSchema, {
+const getTransferInfo = (urls) => decodeAndRun(TransferInfoUrlsSchema, urls, (decodedUrls) => requestJson(TransferInfoEnvelopeSchema, {
 	body: {
 		type: "form",
-		value: { urls: urls.join("\n") }
+		value: { urls: decodedUrls.join("\n") }
 	},
 	method: "POST",
 	path: "/v2/transfers/info"
-}).pipe(selectJsonFields("disk_avail", "ret"));
-const addTransfer = (input) => requestJson(TransferEnvelopeSchema, {
+}).pipe(selectJsonFields("disk_avail", "ret")));
+const addTransfer = (input) => decodeAndRun(TransferAddInputSchema, input, (decodedInput) => requestJson(TransferEnvelopeSchema, {
 	body: {
 		type: "form",
-		value: input
+		value: decodedInput
 	},
 	method: "POST",
 	path: "/v2/transfers/add"
-}).pipe(selectJsonField("transfer"), withOperationErrors(AddTransferErrorSpec));
-const addManyTransfers = (inputs) => requestJson(TransfersAddMultiEnvelopeSchema, {
+}).pipe(selectJsonField("transfer"))).pipe(withOperationErrors(AddTransferErrorSpec));
+const addManyTransfers = (inputs) => decodeAndRun(TransferAddManyInputSchema, inputs, (decodedInputs) => requestJson(TransfersAddMultiEnvelopeSchema, {
 	body: {
 		type: "form",
-		value: { urls: JSON.stringify(inputs) }
+		value: { urls: JSON.stringify(decodedInputs) }
 	},
 	method: "POST",
 	path: "/v2/transfers/add-multi"
-}).pipe(selectJsonFields("errors", "transfers"), withOperationErrors(AddManyTransfersErrorSpec));
-const addTransferTrackers = (input) => Schema.decodeUnknownEffect(TransferAddTrackersInputSchema)(input).pipe(Effect.mapError(mapDecodeErrorToValidationError), Effect.flatMap((decodedInput) => requestJson(OkResponseSchema, {
+}).pipe(selectJsonFields("errors", "transfers"))).pipe(withOperationErrors(AddManyTransfersErrorSpec));
+const addTransferTrackers = (input) => decodeAndRun(TransferAddTrackersInputSchema, input, (decodedInput) => requestJson(OkResponseSchema, {
 	body: {
 		type: "form",
 		value: { trackers: joinCsv(decodedInput.trackers) }
 	},
 	method: "POST",
 	path: `/v2/transfers/add-trackers/${encodePathSegment(decodedInput.transferId)}`
-})), Effect.asVoid, withOperationErrors(AddTransferTrackersErrorSpec));
-const cancelTransfers = (ids) => requestJson(OkResponseSchema, {
+})).pipe(Effect.asVoid, withOperationErrors(AddTransferTrackersErrorSpec));
+const cancelTransfers = (ids) => decodeAndRun(TransferIdsSchema, ids, (decodedIds) => requestJson(OkResponseSchema, {
 	body: {
 		type: "form",
-		value: { transfer_ids: joinCsv(ids) }
+		value: { transfer_ids: joinCsv(decodedIds) }
 	},
 	method: "POST",
 	path: "/v2/transfers/cancel"
-});
-const cleanTransfers = (ids = []) => requestJson(TransfersCleanEnvelopeSchema, {
+}));
+const cleanTransfers = (ids = []) => decodeAndRun(TransferCleanIdsSchema, ids, (decodedIds) => requestJson(TransfersCleanEnvelopeSchema, {
 	body: {
 		type: "form",
-		value: ids.length > 0 ? { transfer_ids: joinCsv(ids) } : {}
+		value: decodedIds.length > 0 ? { transfer_ids: joinCsv(decodedIds) } : {}
 	},
 	method: "POST",
 	path: "/v2/transfers/clean"
-}).pipe(selectJsonFields("deleted_ids"));
-const removeTransfers = (input) => Schema.decodeUnknownEffect(TransferRemoveInputSchema)(input).pipe(Effect.mapError(mapDecodeErrorToValidationError), Effect.flatMap((decodedInput) => requestJson(OkResponseSchema, {
+}).pipe(selectJsonFields("deleted_ids")));
+const removeTransfers = (input) => decodeAndRun(TransferRemoveInputSchema, input, (decodedInput) => requestJson(OkResponseSchema, {
 	body: {
 		type: "form",
 		value: decodedInput.ids !== void 0 ? { transfer_ids: joinCsv(decodedInput.ids) } : { remove_filter: decodedInput.filter }
 	},
 	method: "POST",
 	path: "/v2/transfers/remove"
-})), Effect.asVoid, withOperationErrors(RemoveTransfersErrorSpec));
-const retryTransfer = (id) => requestJson(TransferEnvelopeSchema, {
+})).pipe(Effect.asVoid, withOperationErrors(RemoveTransfersErrorSpec));
+const retryTransfer = (id) => decodeAndRun(TransferIdSchema, id, (decodedId) => requestJson(TransferEnvelopeSchema, {
 	body: {
 		type: "form",
-		value: { id }
+		value: { id: decodedId }
 	},
 	method: "POST",
 	path: "/v2/transfers/retry"
-}).pipe(selectJsonField("transfer"), withOperationErrors(RetryTransferErrorSpec));
-const reannounceTransfer = (id) => requestJson(OkResponseSchema, {
+}).pipe(selectJsonField("transfer"))).pipe(withOperationErrors(RetryTransferErrorSpec));
+const reannounceTransfer = (id) => decodeAndRun(TransferIdSchema, id, (decodedId) => requestJson(OkResponseSchema, {
 	body: {
 		type: "form",
-		value: { id }
+		value: { id: decodedId }
 	},
 	method: "POST",
 	path: "/v2/transfers/reannounce"
-}).pipe(withOperationErrors(ReannounceTransferErrorSpec));
-const stopTransferRecording = (id) => requestJson(OkResponseSchema, {
+})).pipe(withOperationErrors(ReannounceTransferErrorSpec));
+const stopTransferRecording = (id) => decodeAndRun(TransferIdSchema, id, (decodedId) => requestJson(OkResponseSchema, {
 	body: {
 		type: "form",
-		value: { transfer_id: id }
+		value: { transfer_id: decodedId }
 	},
 	method: "POST",
 	path: "/v2/transfers/stop-recording"
-}).pipe(withOperationErrors(StopRecordingTransferErrorSpec));
+})).pipe(withOperationErrors(StopRecordingTransferErrorSpec));
 //#endregion
 //#region src/domains/tunnel.ts
 const TunnelRouteSchema = Schema.Struct({
@@ -5109,7 +5316,7 @@ const ZipInfoSchema = Schema.Union([
 	ZipInfoErrorSchema,
 	ZipInfoDoneSchema
 ]);
-const CreateZipInputSchema = makeCursorSelectionSchema("file_ids", "exclude_ids");
+const CreateZipInputSchema = makeCursorSelectionSchema("file_ids", "exclude_ids", {});
 const FilesReadScopeError = {
 	errorType: "invalid_scope",
 	statusCode: 401