upon 0.6.0

//! Code generated by *./tools/gen-filters*. DO NOT EDIT.

#![allow(clippy::needless_lifetimes)]

use std::collections::BTreeMap;

use crate::filters::args::{ListRef, MapRef, Str, ValueRef};
use crate::filters::{Filter, FilterArg, FilterArgs, FilterReturn};
use crate::Value;

#[doc(hidden)]
impl<Func, R> Filter<R, (Str,)> for Func
where
    Func: Fn(&str) -> R,
    R: FilterReturn,

    (Str,): for<'a> FilterArgs<Output<'a> = (&'a str,)>,
{
    fn filter<'a>(&self, (v,): (&'a str,)) -> R {
        self(v)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (ListRef,)> for Func
where
    Func: Fn(&[Value]) -> R,
    R: FilterReturn,

    (ListRef,): for<'a> FilterArgs<Output<'a> = (&'a [Value],)>,
{
    fn filter<'a>(&self, (v,): (&'a [Value],)) -> R {
        self(v)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (MapRef,)> for Func
where
    Func: Fn(&BTreeMap<String, Value>) -> R,
    R: FilterReturn,

    (MapRef,): for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>,)>,
{
    fn filter<'a>(&self, (v,): (&'a BTreeMap<String, Value>,)) -> R {
        self(v)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (ValueRef,)> for Func
where
    Func: Fn(&Value) -> R,
    R: FilterReturn,

    (ValueRef,): for<'a> FilterArgs<Output<'a> = (&'a Value,)>,
{
    fn filter<'a>(&self, (v,): (&'a Value,)) -> R {
        self(v)
    }
}

#[doc(hidden)]
impl<Func, R, V> Filter<R, (V, Str)> for Func
where
    Func: Fn(V, &str) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,

    (V, Str): for<'a> FilterArgs<Output<'a> = (V, &'a str)>,
{
    fn filter<'a>(&self, (v, a): (V, &'a str)) -> R {
        self(v, a)
    }
}

#[doc(hidden)]
impl<Func, R, A> Filter<R, (Str, A)> for Func
where
    Func: Fn(&str, A) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,

    (Str, A): for<'a> FilterArgs<Output<'a> = (&'a str, A)>,
{
    fn filter<'a>(&self, (v, a): (&'a str, A)) -> R {
        self(v, a)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (Str, Str)> for Func
where
    Func: Fn(&str, &str) -> R,
    R: FilterReturn,

    (Str, Str): for<'a> FilterArgs<Output<'a> = (&'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a): (&'a str, &'a str)) -> R {
        self(v, a)
    }
}

#[doc(hidden)]
impl<Func, R, A> Filter<R, (ListRef, A)> for Func
where
    Func: Fn(&[Value], A) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,

    (ListRef, A): for<'a> FilterArgs<Output<'a> = (&'a [Value], A)>,
{
    fn filter<'a>(&self, (v, a): (&'a [Value], A)) -> R {
        self(v, a)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (ListRef, Str)> for Func
where
    Func: Fn(&[Value], &str) -> R,
    R: FilterReturn,

    (ListRef, Str): for<'a> FilterArgs<Output<'a> = (&'a [Value], &'a str)>,
{
    fn filter<'a>(&self, (v, a): (&'a [Value], &'a str)) -> R {
        self(v, a)
    }
}

#[doc(hidden)]
impl<Func, R, A> Filter<R, (MapRef, A)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, A) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,

    (MapRef, A): for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, A)>,
{
    fn filter<'a>(&self, (v, a): (&'a BTreeMap<String, Value>, A)) -> R {
        self(v, a)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (MapRef, Str)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str) -> R,
    R: FilterReturn,

    (MapRef, Str): for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str)>,
{
    fn filter<'a>(&self, (v, a): (&'a BTreeMap<String, Value>, &'a str)) -> R {
        self(v, a)
    }
}

#[doc(hidden)]
impl<Func, R, A> Filter<R, (ValueRef, A)> for Func
where
    Func: Fn(&Value, A) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,

    (ValueRef, A): for<'a> FilterArgs<Output<'a> = (&'a Value, A)>,
{
    fn filter<'a>(&self, (v, a): (&'a Value, A)) -> R {
        self(v, a)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (ValueRef, Str)> for Func
where
    Func: Fn(&Value, &str) -> R,
    R: FilterReturn,

    (ValueRef, Str): for<'a> FilterArgs<Output<'a> = (&'a Value, &'a str)>,
{
    fn filter<'a>(&self, (v, a): (&'a Value, &'a str)) -> R {
        self(v, a)
    }
}

#[doc(hidden)]
impl<Func, R, V, A> Filter<R, (V, A, Str)> for Func
where
    Func: Fn(V, A, &str) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    A: for<'a> FilterArg<Output<'a> = A>,

    (V, A, Str): for<'a> FilterArgs<Output<'a> = (V, A, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b): (V, A, &'a str)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R, V, B> Filter<R, (V, Str, B)> for Func
where
    Func: Fn(V, &str, B) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    B: for<'a> FilterArg<Output<'a> = B>,

    (V, Str, B): for<'a> FilterArgs<Output<'a> = (V, &'a str, B)>,
{
    fn filter<'a>(&self, (v, a, b): (V, &'a str, B)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R, V> Filter<R, (V, Str, Str)> for Func
where
    Func: Fn(V, &str, &str) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,

    (V, Str, Str): for<'a> FilterArgs<Output<'a> = (V, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b): (V, &'a str, &'a str)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R, A, B> Filter<R, (Str, A, B)> for Func
where
    Func: Fn(&str, A, B) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,

    (Str, A, B): for<'a> FilterArgs<Output<'a> = (&'a str, A, B)>,
{
    fn filter<'a>(&self, (v, a, b): (&'a str, A, B)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R, A> Filter<R, (Str, A, Str)> for Func
where
    Func: Fn(&str, A, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,

    (Str, A, Str): for<'a> FilterArgs<Output<'a> = (&'a str, A, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b): (&'a str, A, &'a str)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R, B> Filter<R, (Str, Str, B)> for Func
where
    Func: Fn(&str, &str, B) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,

    (Str, Str, B): for<'a> FilterArgs<Output<'a> = (&'a str, &'a str, B)>,
{
    fn filter<'a>(&self, (v, a, b): (&'a str, &'a str, B)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (Str, Str, Str)> for Func
where
    Func: Fn(&str, &str, &str) -> R,
    R: FilterReturn,

    (Str, Str, Str): for<'a> FilterArgs<Output<'a> = (&'a str, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b): (&'a str, &'a str, &'a str)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R, A, B> Filter<R, (ListRef, A, B)> for Func
where
    Func: Fn(&[Value], A, B) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,

    (ListRef, A, B): for<'a> FilterArgs<Output<'a> = (&'a [Value], A, B)>,
{
    fn filter<'a>(&self, (v, a, b): (&'a [Value], A, B)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R, A> Filter<R, (ListRef, A, Str)> for Func
where
    Func: Fn(&[Value], A, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,

    (ListRef, A, Str): for<'a> FilterArgs<Output<'a> = (&'a [Value], A, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b): (&'a [Value], A, &'a str)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R, B> Filter<R, (ListRef, Str, B)> for Func
where
    Func: Fn(&[Value], &str, B) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,

    (ListRef, Str, B): for<'a> FilterArgs<Output<'a> = (&'a [Value], &'a str, B)>,
{
    fn filter<'a>(&self, (v, a, b): (&'a [Value], &'a str, B)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (ListRef, Str, Str)> for Func
where
    Func: Fn(&[Value], &str, &str) -> R,
    R: FilterReturn,

    (ListRef, Str, Str): for<'a> FilterArgs<Output<'a> = (&'a [Value], &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b): (&'a [Value], &'a str, &'a str)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R, A, B> Filter<R, (MapRef, A, B)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, A, B) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,

    (MapRef, A, B): for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, A, B)>,
{
    fn filter<'a>(&self, (v, a, b): (&'a BTreeMap<String, Value>, A, B)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R, A> Filter<R, (MapRef, A, Str)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, A, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,

    (MapRef, A, Str): for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, A, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b): (&'a BTreeMap<String, Value>, A, &'a str)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R, B> Filter<R, (MapRef, Str, B)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, B) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,

    (MapRef, Str, B): for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, B)>,
{
    fn filter<'a>(&self, (v, a, b): (&'a BTreeMap<String, Value>, &'a str, B)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (MapRef, Str, Str)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, &str) -> R,
    R: FilterReturn,

    (MapRef, Str, Str):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b): (&'a BTreeMap<String, Value>, &'a str, &'a str)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R, A, B> Filter<R, (ValueRef, A, B)> for Func
where
    Func: Fn(&Value, A, B) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,

    (ValueRef, A, B): for<'a> FilterArgs<Output<'a> = (&'a Value, A, B)>,
{
    fn filter<'a>(&self, (v, a, b): (&'a Value, A, B)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R, A> Filter<R, (ValueRef, A, Str)> for Func
where
    Func: Fn(&Value, A, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,

    (ValueRef, A, Str): for<'a> FilterArgs<Output<'a> = (&'a Value, A, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b): (&'a Value, A, &'a str)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R, B> Filter<R, (ValueRef, Str, B)> for Func
where
    Func: Fn(&Value, &str, B) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,

    (ValueRef, Str, B): for<'a> FilterArgs<Output<'a> = (&'a Value, &'a str, B)>,
{
    fn filter<'a>(&self, (v, a, b): (&'a Value, &'a str, B)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (ValueRef, Str, Str)> for Func
where
    Func: Fn(&Value, &str, &str) -> R,
    R: FilterReturn,

    (ValueRef, Str, Str): for<'a> FilterArgs<Output<'a> = (&'a Value, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b): (&'a Value, &'a str, &'a str)) -> R {
        self(v, a, b)
    }
}

#[doc(hidden)]
impl<Func, R, V, A, B> Filter<R, (V, A, B, Str)> for Func
where
    Func: Fn(V, A, B, &str) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,

    (V, A, B, Str): for<'a> FilterArgs<Output<'a> = (V, A, B, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (V, A, B, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, V, A, C> Filter<R, (V, A, Str, C)> for Func
where
    Func: Fn(V, A, &str, C) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    A: for<'a> FilterArg<Output<'a> = A>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (V, A, Str, C): for<'a> FilterArgs<Output<'a> = (V, A, &'a str, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (V, A, &'a str, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, V, A> Filter<R, (V, A, Str, Str)> for Func
where
    Func: Fn(V, A, &str, &str) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    A: for<'a> FilterArg<Output<'a> = A>,

    (V, A, Str, Str): for<'a> FilterArgs<Output<'a> = (V, A, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (V, A, &'a str, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, V, B, C> Filter<R, (V, Str, B, C)> for Func
where
    Func: Fn(V, &str, B, C) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (V, Str, B, C): for<'a> FilterArgs<Output<'a> = (V, &'a str, B, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (V, &'a str, B, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, V, B> Filter<R, (V, Str, B, Str)> for Func
where
    Func: Fn(V, &str, B, &str) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    B: for<'a> FilterArg<Output<'a> = B>,

    (V, Str, B, Str): for<'a> FilterArgs<Output<'a> = (V, &'a str, B, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (V, &'a str, B, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, V, C> Filter<R, (V, Str, Str, C)> for Func
where
    Func: Fn(V, &str, &str, C) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (V, Str, Str, C): for<'a> FilterArgs<Output<'a> = (V, &'a str, &'a str, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (V, &'a str, &'a str, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, V> Filter<R, (V, Str, Str, Str)> for Func
where
    Func: Fn(V, &str, &str, &str) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,

    (V, Str, Str, Str): for<'a> FilterArgs<Output<'a> = (V, &'a str, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (V, &'a str, &'a str, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, C> Filter<R, (Str, A, B, C)> for Func
where
    Func: Fn(&str, A, B, C) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (Str, A, B, C): for<'a> FilterArgs<Output<'a> = (&'a str, A, B, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a str, A, B, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A, B> Filter<R, (Str, A, B, Str)> for Func
where
    Func: Fn(&str, A, B, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,

    (Str, A, B, Str): for<'a> FilterArgs<Output<'a> = (&'a str, A, B, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a str, A, B, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A, C> Filter<R, (Str, A, Str, C)> for Func
where
    Func: Fn(&str, A, &str, C) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (Str, A, Str, C): for<'a> FilterArgs<Output<'a> = (&'a str, A, &'a str, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a str, A, &'a str, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A> Filter<R, (Str, A, Str, Str)> for Func
where
    Func: Fn(&str, A, &str, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,

    (Str, A, Str, Str): for<'a> FilterArgs<Output<'a> = (&'a str, A, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a str, A, &'a str, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Filter<R, (Str, Str, B, C)> for Func
where
    Func: Fn(&str, &str, B, C) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (Str, Str, B, C): for<'a> FilterArgs<Output<'a> = (&'a str, &'a str, B, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a str, &'a str, B, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, B> Filter<R, (Str, Str, B, Str)> for Func
where
    Func: Fn(&str, &str, B, &str) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,

    (Str, Str, B, Str): for<'a> FilterArgs<Output<'a> = (&'a str, &'a str, B, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a str, &'a str, B, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, C> Filter<R, (Str, Str, Str, C)> for Func
where
    Func: Fn(&str, &str, &str, C) -> R,
    R: FilterReturn,

    C: for<'a> FilterArg<Output<'a> = C>,

    (Str, Str, Str, C): for<'a> FilterArgs<Output<'a> = (&'a str, &'a str, &'a str, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a str, &'a str, &'a str, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (Str, Str, Str, Str)> for Func
where
    Func: Fn(&str, &str, &str, &str) -> R,
    R: FilterReturn,

    (Str, Str, Str, Str): for<'a> FilterArgs<Output<'a> = (&'a str, &'a str, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a str, &'a str, &'a str, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, C> Filter<R, (ListRef, A, B, C)> for Func
where
    Func: Fn(&[Value], A, B, C) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (ListRef, A, B, C): for<'a> FilterArgs<Output<'a> = (&'a [Value], A, B, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a [Value], A, B, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A, B> Filter<R, (ListRef, A, B, Str)> for Func
where
    Func: Fn(&[Value], A, B, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,

    (ListRef, A, B, Str): for<'a> FilterArgs<Output<'a> = (&'a [Value], A, B, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a [Value], A, B, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A, C> Filter<R, (ListRef, A, Str, C)> for Func
where
    Func: Fn(&[Value], A, &str, C) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (ListRef, A, Str, C): for<'a> FilterArgs<Output<'a> = (&'a [Value], A, &'a str, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a [Value], A, &'a str, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A> Filter<R, (ListRef, A, Str, Str)> for Func
where
    Func: Fn(&[Value], A, &str, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,

    (ListRef, A, Str, Str): for<'a> FilterArgs<Output<'a> = (&'a [Value], A, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a [Value], A, &'a str, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Filter<R, (ListRef, Str, B, C)> for Func
where
    Func: Fn(&[Value], &str, B, C) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (ListRef, Str, B, C): for<'a> FilterArgs<Output<'a> = (&'a [Value], &'a str, B, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a [Value], &'a str, B, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, B> Filter<R, (ListRef, Str, B, Str)> for Func
where
    Func: Fn(&[Value], &str, B, &str) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,

    (ListRef, Str, B, Str): for<'a> FilterArgs<Output<'a> = (&'a [Value], &'a str, B, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a [Value], &'a str, B, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, C> Filter<R, (ListRef, Str, Str, C)> for Func
where
    Func: Fn(&[Value], &str, &str, C) -> R,
    R: FilterReturn,

    C: for<'a> FilterArg<Output<'a> = C>,

    (ListRef, Str, Str, C): for<'a> FilterArgs<Output<'a> = (&'a [Value], &'a str, &'a str, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a [Value], &'a str, &'a str, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (ListRef, Str, Str, Str)> for Func
where
    Func: Fn(&[Value], &str, &str, &str) -> R,
    R: FilterReturn,

    (ListRef, Str, Str, Str):
        for<'a> FilterArgs<Output<'a> = (&'a [Value], &'a str, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a [Value], &'a str, &'a str, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, C> Filter<R, (MapRef, A, B, C)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, A, B, C) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (MapRef, A, B, C): for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, A, B, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a BTreeMap<String, Value>, A, B, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A, B> Filter<R, (MapRef, A, B, Str)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, A, B, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,

    (MapRef, A, B, Str):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, A, B, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a BTreeMap<String, Value>, A, B, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A, C> Filter<R, (MapRef, A, Str, C)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, A, &str, C) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (MapRef, A, Str, C):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, A, &'a str, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a BTreeMap<String, Value>, A, &'a str, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A> Filter<R, (MapRef, A, Str, Str)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, A, &str, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,

    (MapRef, A, Str, Str):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, A, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a BTreeMap<String, Value>, A, &'a str, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Filter<R, (MapRef, Str, B, C)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, B, C) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (MapRef, Str, B, C):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, B, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a BTreeMap<String, Value>, &'a str, B, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, B> Filter<R, (MapRef, Str, B, Str)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, B, &str) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,

    (MapRef, Str, B, Str):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, B, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a BTreeMap<String, Value>, &'a str, B, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, C> Filter<R, (MapRef, Str, Str, C)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, &str, C) -> R,
    R: FilterReturn,

    C: for<'a> FilterArg<Output<'a> = C>,

    (MapRef, Str, Str, C):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, &'a str, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a BTreeMap<String, Value>, &'a str, &'a str, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (MapRef, Str, Str, Str)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, &str, &str) -> R,
    R: FilterReturn,

    (MapRef, Str, Str, Str):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, &'a str, &'a str)>,
{
    fn filter<'a>(
        &self,
        (v, a, b, c): (&'a BTreeMap<String, Value>, &'a str, &'a str, &'a str),
    ) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, C> Filter<R, (ValueRef, A, B, C)> for Func
where
    Func: Fn(&Value, A, B, C) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (ValueRef, A, B, C): for<'a> FilterArgs<Output<'a> = (&'a Value, A, B, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a Value, A, B, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A, B> Filter<R, (ValueRef, A, B, Str)> for Func
where
    Func: Fn(&Value, A, B, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,

    (ValueRef, A, B, Str): for<'a> FilterArgs<Output<'a> = (&'a Value, A, B, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a Value, A, B, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A, C> Filter<R, (ValueRef, A, Str, C)> for Func
where
    Func: Fn(&Value, A, &str, C) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (ValueRef, A, Str, C): for<'a> FilterArgs<Output<'a> = (&'a Value, A, &'a str, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a Value, A, &'a str, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A> Filter<R, (ValueRef, A, Str, Str)> for Func
where
    Func: Fn(&Value, A, &str, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,

    (ValueRef, A, Str, Str): for<'a> FilterArgs<Output<'a> = (&'a Value, A, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a Value, A, &'a str, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Filter<R, (ValueRef, Str, B, C)> for Func
where
    Func: Fn(&Value, &str, B, C) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (ValueRef, Str, B, C): for<'a> FilterArgs<Output<'a> = (&'a Value, &'a str, B, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a Value, &'a str, B, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, B> Filter<R, (ValueRef, Str, B, Str)> for Func
where
    Func: Fn(&Value, &str, B, &str) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,

    (ValueRef, Str, B, Str): for<'a> FilterArgs<Output<'a> = (&'a Value, &'a str, B, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a Value, &'a str, B, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, C> Filter<R, (ValueRef, Str, Str, C)> for Func
where
    Func: Fn(&Value, &str, &str, C) -> R,
    R: FilterReturn,

    C: for<'a> FilterArg<Output<'a> = C>,

    (ValueRef, Str, Str, C): for<'a> FilterArgs<Output<'a> = (&'a Value, &'a str, &'a str, C)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a Value, &'a str, &'a str, C)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (ValueRef, Str, Str, Str)> for Func
where
    Func: Fn(&Value, &str, &str, &str) -> R,
    R: FilterReturn,

    (ValueRef, Str, Str, Str):
        for<'a> FilterArgs<Output<'a> = (&'a Value, &'a str, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c): (&'a Value, &'a str, &'a str, &'a str)) -> R {
        self(v, a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, V, A, B, C> Filter<R, (V, A, B, C, Str)> for Func
where
    Func: Fn(V, A, B, C, &str) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (V, A, B, C, Str): for<'a> FilterArgs<Output<'a> = (V, A, B, C, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (V, A, B, C, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, V, A, B, D> Filter<R, (V, A, B, Str, D)> for Func
where
    Func: Fn(V, A, B, &str, D) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (V, A, B, Str, D): for<'a> FilterArgs<Output<'a> = (V, A, B, &'a str, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (V, A, B, &'a str, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, V, A, B> Filter<R, (V, A, B, Str, Str)> for Func
where
    Func: Fn(V, A, B, &str, &str) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,

    (V, A, B, Str, Str): for<'a> FilterArgs<Output<'a> = (V, A, B, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (V, A, B, &'a str, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, V, A, C, D> Filter<R, (V, A, Str, C, D)> for Func
where
    Func: Fn(V, A, &str, C, D) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    A: for<'a> FilterArg<Output<'a> = A>,
    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (V, A, Str, C, D): for<'a> FilterArgs<Output<'a> = (V, A, &'a str, C, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (V, A, &'a str, C, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, V, A, C> Filter<R, (V, A, Str, C, Str)> for Func
where
    Func: Fn(V, A, &str, C, &str) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    A: for<'a> FilterArg<Output<'a> = A>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (V, A, Str, C, Str): for<'a> FilterArgs<Output<'a> = (V, A, &'a str, C, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (V, A, &'a str, C, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, V, A, D> Filter<R, (V, A, Str, Str, D)> for Func
where
    Func: Fn(V, A, &str, &str, D) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    A: for<'a> FilterArg<Output<'a> = A>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (V, A, Str, Str, D): for<'a> FilterArgs<Output<'a> = (V, A, &'a str, &'a str, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (V, A, &'a str, &'a str, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, V, A> Filter<R, (V, A, Str, Str, Str)> for Func
where
    Func: Fn(V, A, &str, &str, &str) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    A: for<'a> FilterArg<Output<'a> = A>,

    (V, A, Str, Str, Str): for<'a> FilterArgs<Output<'a> = (V, A, &'a str, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (V, A, &'a str, &'a str, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, V, B, C, D> Filter<R, (V, Str, B, C, D)> for Func
where
    Func: Fn(V, &str, B, C, D) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (V, Str, B, C, D): for<'a> FilterArgs<Output<'a> = (V, &'a str, B, C, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (V, &'a str, B, C, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, V, B, C> Filter<R, (V, Str, B, C, Str)> for Func
where
    Func: Fn(V, &str, B, C, &str) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (V, Str, B, C, Str): for<'a> FilterArgs<Output<'a> = (V, &'a str, B, C, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (V, &'a str, B, C, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, V, B, D> Filter<R, (V, Str, B, Str, D)> for Func
where
    Func: Fn(V, &str, B, &str, D) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    B: for<'a> FilterArg<Output<'a> = B>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (V, Str, B, Str, D): for<'a> FilterArgs<Output<'a> = (V, &'a str, B, &'a str, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (V, &'a str, B, &'a str, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, V, B> Filter<R, (V, Str, B, Str, Str)> for Func
where
    Func: Fn(V, &str, B, &str, &str) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    B: for<'a> FilterArg<Output<'a> = B>,

    (V, Str, B, Str, Str): for<'a> FilterArgs<Output<'a> = (V, &'a str, B, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (V, &'a str, B, &'a str, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, V, C, D> Filter<R, (V, Str, Str, C, D)> for Func
where
    Func: Fn(V, &str, &str, C, D) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (V, Str, Str, C, D): for<'a> FilterArgs<Output<'a> = (V, &'a str, &'a str, C, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (V, &'a str, &'a str, C, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, V, C> Filter<R, (V, Str, Str, C, Str)> for Func
where
    Func: Fn(V, &str, &str, C, &str) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (V, Str, Str, C, Str): for<'a> FilterArgs<Output<'a> = (V, &'a str, &'a str, C, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (V, &'a str, &'a str, C, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, V, D> Filter<R, (V, Str, Str, Str, D)> for Func
where
    Func: Fn(V, &str, &str, &str, D) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (V, Str, Str, Str, D): for<'a> FilterArgs<Output<'a> = (V, &'a str, &'a str, &'a str, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (V, &'a str, &'a str, &'a str, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, V> Filter<R, (V, Str, Str, Str, Str)> for Func
where
    Func: Fn(V, &str, &str, &str, &str) -> R,
    R: FilterReturn,

    V: for<'a> FilterArg<Output<'a> = V>,

    (V, Str, Str, Str, Str):
        for<'a> FilterArgs<Output<'a> = (V, &'a str, &'a str, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (V, &'a str, &'a str, &'a str, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, C, D> Filter<R, (Str, A, B, C, D)> for Func
where
    Func: Fn(&str, A, B, C, D) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (Str, A, B, C, D): for<'a> FilterArgs<Output<'a> = (&'a str, A, B, C, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a str, A, B, C, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, C> Filter<R, (Str, A, B, C, Str)> for Func
where
    Func: Fn(&str, A, B, C, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (Str, A, B, C, Str): for<'a> FilterArgs<Output<'a> = (&'a str, A, B, C, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a str, A, B, C, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, D> Filter<R, (Str, A, B, Str, D)> for Func
where
    Func: Fn(&str, A, B, &str, D) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (Str, A, B, Str, D): for<'a> FilterArgs<Output<'a> = (&'a str, A, B, &'a str, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a str, A, B, &'a str, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B> Filter<R, (Str, A, B, Str, Str)> for Func
where
    Func: Fn(&str, A, B, &str, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,

    (Str, A, B, Str, Str): for<'a> FilterArgs<Output<'a> = (&'a str, A, B, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a str, A, B, &'a str, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, C, D> Filter<R, (Str, A, Str, C, D)> for Func
where
    Func: Fn(&str, A, &str, C, D) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (Str, A, Str, C, D): for<'a> FilterArgs<Output<'a> = (&'a str, A, &'a str, C, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a str, A, &'a str, C, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, C> Filter<R, (Str, A, Str, C, Str)> for Func
where
    Func: Fn(&str, A, &str, C, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (Str, A, Str, C, Str): for<'a> FilterArgs<Output<'a> = (&'a str, A, &'a str, C, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a str, A, &'a str, C, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, D> Filter<R, (Str, A, Str, Str, D)> for Func
where
    Func: Fn(&str, A, &str, &str, D) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (Str, A, Str, Str, D): for<'a> FilterArgs<Output<'a> = (&'a str, A, &'a str, &'a str, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a str, A, &'a str, &'a str, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A> Filter<R, (Str, A, Str, Str, Str)> for Func
where
    Func: Fn(&str, A, &str, &str, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,

    (Str, A, Str, Str, Str):
        for<'a> FilterArgs<Output<'a> = (&'a str, A, &'a str, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a str, A, &'a str, &'a str, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, D> Filter<R, (Str, Str, B, C, D)> for Func
where
    Func: Fn(&str, &str, B, C, D) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (Str, Str, B, C, D): for<'a> FilterArgs<Output<'a> = (&'a str, &'a str, B, C, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a str, &'a str, B, C, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Filter<R, (Str, Str, B, C, Str)> for Func
where
    Func: Fn(&str, &str, B, C, &str) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (Str, Str, B, C, Str): for<'a> FilterArgs<Output<'a> = (&'a str, &'a str, B, C, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a str, &'a str, B, C, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, D> Filter<R, (Str, Str, B, Str, D)> for Func
where
    Func: Fn(&str, &str, B, &str, D) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (Str, Str, B, Str, D): for<'a> FilterArgs<Output<'a> = (&'a str, &'a str, B, &'a str, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a str, &'a str, B, &'a str, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B> Filter<R, (Str, Str, B, Str, Str)> for Func
where
    Func: Fn(&str, &str, B, &str, &str) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,

    (Str, Str, B, Str, Str):
        for<'a> FilterArgs<Output<'a> = (&'a str, &'a str, B, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a str, &'a str, B, &'a str, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Filter<R, (Str, Str, Str, C, D)> for Func
where
    Func: Fn(&str, &str, &str, C, D) -> R,
    R: FilterReturn,

    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (Str, Str, Str, C, D): for<'a> FilterArgs<Output<'a> = (&'a str, &'a str, &'a str, C, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a str, &'a str, &'a str, C, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C> Filter<R, (Str, Str, Str, C, Str)> for Func
where
    Func: Fn(&str, &str, &str, C, &str) -> R,
    R: FilterReturn,

    C: for<'a> FilterArg<Output<'a> = C>,

    (Str, Str, Str, C, Str):
        for<'a> FilterArgs<Output<'a> = (&'a str, &'a str, &'a str, C, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a str, &'a str, &'a str, C, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, D> Filter<R, (Str, Str, Str, Str, D)> for Func
where
    Func: Fn(&str, &str, &str, &str, D) -> R,
    R: FilterReturn,

    D: for<'a> FilterArg<Output<'a> = D>,

    (Str, Str, Str, Str, D):
        for<'a> FilterArgs<Output<'a> = (&'a str, &'a str, &'a str, &'a str, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a str, &'a str, &'a str, &'a str, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (Str, Str, Str, Str, Str)> for Func
where
    Func: Fn(&str, &str, &str, &str, &str) -> R,
    R: FilterReturn,

    (Str, Str, Str, Str, Str):
        for<'a> FilterArgs<Output<'a> = (&'a str, &'a str, &'a str, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a str, &'a str, &'a str, &'a str, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, C, D> Filter<R, (ListRef, A, B, C, D)> for Func
where
    Func: Fn(&[Value], A, B, C, D) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (ListRef, A, B, C, D): for<'a> FilterArgs<Output<'a> = (&'a [Value], A, B, C, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a [Value], A, B, C, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, C> Filter<R, (ListRef, A, B, C, Str)> for Func
where
    Func: Fn(&[Value], A, B, C, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (ListRef, A, B, C, Str): for<'a> FilterArgs<Output<'a> = (&'a [Value], A, B, C, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a [Value], A, B, C, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, D> Filter<R, (ListRef, A, B, Str, D)> for Func
where
    Func: Fn(&[Value], A, B, &str, D) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (ListRef, A, B, Str, D): for<'a> FilterArgs<Output<'a> = (&'a [Value], A, B, &'a str, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a [Value], A, B, &'a str, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B> Filter<R, (ListRef, A, B, Str, Str)> for Func
where
    Func: Fn(&[Value], A, B, &str, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,

    (ListRef, A, B, Str, Str):
        for<'a> FilterArgs<Output<'a> = (&'a [Value], A, B, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a [Value], A, B, &'a str, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, C, D> Filter<R, (ListRef, A, Str, C, D)> for Func
where
    Func: Fn(&[Value], A, &str, C, D) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (ListRef, A, Str, C, D): for<'a> FilterArgs<Output<'a> = (&'a [Value], A, &'a str, C, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a [Value], A, &'a str, C, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, C> Filter<R, (ListRef, A, Str, C, Str)> for Func
where
    Func: Fn(&[Value], A, &str, C, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (ListRef, A, Str, C, Str):
        for<'a> FilterArgs<Output<'a> = (&'a [Value], A, &'a str, C, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a [Value], A, &'a str, C, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, D> Filter<R, (ListRef, A, Str, Str, D)> for Func
where
    Func: Fn(&[Value], A, &str, &str, D) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (ListRef, A, Str, Str, D):
        for<'a> FilterArgs<Output<'a> = (&'a [Value], A, &'a str, &'a str, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a [Value], A, &'a str, &'a str, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A> Filter<R, (ListRef, A, Str, Str, Str)> for Func
where
    Func: Fn(&[Value], A, &str, &str, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,

    (ListRef, A, Str, Str, Str):
        for<'a> FilterArgs<Output<'a> = (&'a [Value], A, &'a str, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a [Value], A, &'a str, &'a str, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, D> Filter<R, (ListRef, Str, B, C, D)> for Func
where
    Func: Fn(&[Value], &str, B, C, D) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (ListRef, Str, B, C, D): for<'a> FilterArgs<Output<'a> = (&'a [Value], &'a str, B, C, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a [Value], &'a str, B, C, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Filter<R, (ListRef, Str, B, C, Str)> for Func
where
    Func: Fn(&[Value], &str, B, C, &str) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (ListRef, Str, B, C, Str):
        for<'a> FilterArgs<Output<'a> = (&'a [Value], &'a str, B, C, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a [Value], &'a str, B, C, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, D> Filter<R, (ListRef, Str, B, Str, D)> for Func
where
    Func: Fn(&[Value], &str, B, &str, D) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (ListRef, Str, B, Str, D):
        for<'a> FilterArgs<Output<'a> = (&'a [Value], &'a str, B, &'a str, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a [Value], &'a str, B, &'a str, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B> Filter<R, (ListRef, Str, B, Str, Str)> for Func
where
    Func: Fn(&[Value], &str, B, &str, &str) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,

    (ListRef, Str, B, Str, Str):
        for<'a> FilterArgs<Output<'a> = (&'a [Value], &'a str, B, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a [Value], &'a str, B, &'a str, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Filter<R, (ListRef, Str, Str, C, D)> for Func
where
    Func: Fn(&[Value], &str, &str, C, D) -> R,
    R: FilterReturn,

    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (ListRef, Str, Str, C, D):
        for<'a> FilterArgs<Output<'a> = (&'a [Value], &'a str, &'a str, C, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a [Value], &'a str, &'a str, C, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C> Filter<R, (ListRef, Str, Str, C, Str)> for Func
where
    Func: Fn(&[Value], &str, &str, C, &str) -> R,
    R: FilterReturn,

    C: for<'a> FilterArg<Output<'a> = C>,

    (ListRef, Str, Str, C, Str):
        for<'a> FilterArgs<Output<'a> = (&'a [Value], &'a str, &'a str, C, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a [Value], &'a str, &'a str, C, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, D> Filter<R, (ListRef, Str, Str, Str, D)> for Func
where
    Func: Fn(&[Value], &str, &str, &str, D) -> R,
    R: FilterReturn,

    D: for<'a> FilterArg<Output<'a> = D>,

    (ListRef, Str, Str, Str, D):
        for<'a> FilterArgs<Output<'a> = (&'a [Value], &'a str, &'a str, &'a str, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a [Value], &'a str, &'a str, &'a str, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (ListRef, Str, Str, Str, Str)> for Func
where
    Func: Fn(&[Value], &str, &str, &str, &str) -> R,
    R: FilterReturn,

    (ListRef, Str, Str, Str, Str):
        for<'a> FilterArgs<Output<'a> = (&'a [Value], &'a str, &'a str, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a [Value], &'a str, &'a str, &'a str, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, C, D> Filter<R, (MapRef, A, B, C, D)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, A, B, C, D) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (MapRef, A, B, C, D):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, A, B, C, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a BTreeMap<String, Value>, A, B, C, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, C> Filter<R, (MapRef, A, B, C, Str)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, A, B, C, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (MapRef, A, B, C, Str):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, A, B, C, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a BTreeMap<String, Value>, A, B, C, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, D> Filter<R, (MapRef, A, B, Str, D)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, A, B, &str, D) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (MapRef, A, B, Str, D):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, A, B, &'a str, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a BTreeMap<String, Value>, A, B, &'a str, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B> Filter<R, (MapRef, A, B, Str, Str)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, A, B, &str, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,

    (MapRef, A, B, Str, Str):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, A, B, &'a str, &'a str)>,
{
    fn filter<'a>(
        &self,
        (v, a, b, c, d): (&'a BTreeMap<String, Value>, A, B, &'a str, &'a str),
    ) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, C, D> Filter<R, (MapRef, A, Str, C, D)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, A, &str, C, D) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (MapRef, A, Str, C, D):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, A, &'a str, C, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a BTreeMap<String, Value>, A, &'a str, C, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, C> Filter<R, (MapRef, A, Str, C, Str)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, A, &str, C, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (MapRef, A, Str, C, Str):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, A, &'a str, C, &'a str)>,
{
    fn filter<'a>(
        &self,
        (v, a, b, c, d): (&'a BTreeMap<String, Value>, A, &'a str, C, &'a str),
    ) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, D> Filter<R, (MapRef, A, Str, Str, D)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, A, &str, &str, D) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (MapRef, A, Str, Str, D):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, A, &'a str, &'a str, D)>,
{
    fn filter<'a>(
        &self,
        (v, a, b, c, d): (&'a BTreeMap<String, Value>, A, &'a str, &'a str, D),
    ) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A> Filter<R, (MapRef, A, Str, Str, Str)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, A, &str, &str, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,

    (MapRef, A, Str, Str, Str): for<'a> FilterArgs<
        Output<'a> = (&'a BTreeMap<String, Value>, A, &'a str, &'a str, &'a str),
    >,
{
    fn filter<'a>(
        &self,
        (v, a, b, c, d): (&'a BTreeMap<String, Value>, A, &'a str, &'a str, &'a str),
    ) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, D> Filter<R, (MapRef, Str, B, C, D)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, B, C, D) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (MapRef, Str, B, C, D):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, B, C, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a BTreeMap<String, Value>, &'a str, B, C, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Filter<R, (MapRef, Str, B, C, Str)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, B, C, &str) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (MapRef, Str, B, C, Str):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, B, C, &'a str)>,
{
    fn filter<'a>(
        &self,
        (v, a, b, c, d): (&'a BTreeMap<String, Value>, &'a str, B, C, &'a str),
    ) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, D> Filter<R, (MapRef, Str, B, Str, D)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, B, &str, D) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (MapRef, Str, B, Str, D):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, B, &'a str, D)>,
{
    fn filter<'a>(
        &self,
        (v, a, b, c, d): (&'a BTreeMap<String, Value>, &'a str, B, &'a str, D),
    ) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B> Filter<R, (MapRef, Str, B, Str, Str)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, B, &str, &str) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,

    (MapRef, Str, B, Str, Str): for<'a> FilterArgs<
        Output<'a> = (&'a BTreeMap<String, Value>, &'a str, B, &'a str, &'a str),
    >,
{
    fn filter<'a>(
        &self,
        (v, a, b, c, d): (&'a BTreeMap<String, Value>, &'a str, B, &'a str, &'a str),
    ) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Filter<R, (MapRef, Str, Str, C, D)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, &str, C, D) -> R,
    R: FilterReturn,

    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (MapRef, Str, Str, C, D):
        for<'a> FilterArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, &'a str, C, D)>,
{
    fn filter<'a>(
        &self,
        (v, a, b, c, d): (&'a BTreeMap<String, Value>, &'a str, &'a str, C, D),
    ) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C> Filter<R, (MapRef, Str, Str, C, Str)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, &str, C, &str) -> R,
    R: FilterReturn,

    C: for<'a> FilterArg<Output<'a> = C>,

    (MapRef, Str, Str, C, Str): for<'a> FilterArgs<
        Output<'a> = (&'a BTreeMap<String, Value>, &'a str, &'a str, C, &'a str),
    >,
{
    fn filter<'a>(
        &self,
        (v, a, b, c, d): (&'a BTreeMap<String, Value>, &'a str, &'a str, C, &'a str),
    ) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, D> Filter<R, (MapRef, Str, Str, Str, D)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, &str, &str, D) -> R,
    R: FilterReturn,

    D: for<'a> FilterArg<Output<'a> = D>,

    (MapRef, Str, Str, Str, D): for<'a> FilterArgs<
        Output<'a> = (&'a BTreeMap<String, Value>, &'a str, &'a str, &'a str, D),
    >,
{
    fn filter<'a>(
        &self,
        (v, a, b, c, d): (&'a BTreeMap<String, Value>, &'a str, &'a str, &'a str, D),
    ) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (MapRef, Str, Str, Str, Str)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, &str, &str, &str) -> R,
    R: FilterReturn,

    (MapRef, Str, Str, Str, Str): for<'a> FilterArgs<
        Output<'a> = (
            &'a BTreeMap<String, Value>,
            &'a str,
            &'a str,
            &'a str,
            &'a str,
        ),
    >,
{
    fn filter<'a>(
        &self,
        (v, a, b, c, d): (
            &'a BTreeMap<String, Value>,
            &'a str,
            &'a str,
            &'a str,
            &'a str,
        ),
    ) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, C, D> Filter<R, (ValueRef, A, B, C, D)> for Func
where
    Func: Fn(&Value, A, B, C, D) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (ValueRef, A, B, C, D): for<'a> FilterArgs<Output<'a> = (&'a Value, A, B, C, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a Value, A, B, C, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, C> Filter<R, (ValueRef, A, B, C, Str)> for Func
where
    Func: Fn(&Value, A, B, C, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (ValueRef, A, B, C, Str): for<'a> FilterArgs<Output<'a> = (&'a Value, A, B, C, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a Value, A, B, C, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, D> Filter<R, (ValueRef, A, B, Str, D)> for Func
where
    Func: Fn(&Value, A, B, &str, D) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (ValueRef, A, B, Str, D): for<'a> FilterArgs<Output<'a> = (&'a Value, A, B, &'a str, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a Value, A, B, &'a str, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B> Filter<R, (ValueRef, A, B, Str, Str)> for Func
where
    Func: Fn(&Value, A, B, &str, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    B: for<'a> FilterArg<Output<'a> = B>,

    (ValueRef, A, B, Str, Str):
        for<'a> FilterArgs<Output<'a> = (&'a Value, A, B, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a Value, A, B, &'a str, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, C, D> Filter<R, (ValueRef, A, Str, C, D)> for Func
where
    Func: Fn(&Value, A, &str, C, D) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (ValueRef, A, Str, C, D): for<'a> FilterArgs<Output<'a> = (&'a Value, A, &'a str, C, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a Value, A, &'a str, C, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, C> Filter<R, (ValueRef, A, Str, C, Str)> for Func
where
    Func: Fn(&Value, A, &str, C, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (ValueRef, A, Str, C, Str):
        for<'a> FilterArgs<Output<'a> = (&'a Value, A, &'a str, C, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a Value, A, &'a str, C, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, D> Filter<R, (ValueRef, A, Str, Str, D)> for Func
where
    Func: Fn(&Value, A, &str, &str, D) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (ValueRef, A, Str, Str, D):
        for<'a> FilterArgs<Output<'a> = (&'a Value, A, &'a str, &'a str, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a Value, A, &'a str, &'a str, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A> Filter<R, (ValueRef, A, Str, Str, Str)> for Func
where
    Func: Fn(&Value, A, &str, &str, &str) -> R,
    R: FilterReturn,

    A: for<'a> FilterArg<Output<'a> = A>,

    (ValueRef, A, Str, Str, Str):
        for<'a> FilterArgs<Output<'a> = (&'a Value, A, &'a str, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a Value, A, &'a str, &'a str, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, D> Filter<R, (ValueRef, Str, B, C, D)> for Func
where
    Func: Fn(&Value, &str, B, C, D) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (ValueRef, Str, B, C, D): for<'a> FilterArgs<Output<'a> = (&'a Value, &'a str, B, C, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a Value, &'a str, B, C, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Filter<R, (ValueRef, Str, B, C, Str)> for Func
where
    Func: Fn(&Value, &str, B, C, &str) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,
    C: for<'a> FilterArg<Output<'a> = C>,

    (ValueRef, Str, B, C, Str):
        for<'a> FilterArgs<Output<'a> = (&'a Value, &'a str, B, C, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a Value, &'a str, B, C, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, D> Filter<R, (ValueRef, Str, B, Str, D)> for Func
where
    Func: Fn(&Value, &str, B, &str, D) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (ValueRef, Str, B, Str, D):
        for<'a> FilterArgs<Output<'a> = (&'a Value, &'a str, B, &'a str, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a Value, &'a str, B, &'a str, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B> Filter<R, (ValueRef, Str, B, Str, Str)> for Func
where
    Func: Fn(&Value, &str, B, &str, &str) -> R,
    R: FilterReturn,

    B: for<'a> FilterArg<Output<'a> = B>,

    (ValueRef, Str, B, Str, Str):
        for<'a> FilterArgs<Output<'a> = (&'a Value, &'a str, B, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a Value, &'a str, B, &'a str, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Filter<R, (ValueRef, Str, Str, C, D)> for Func
where
    Func: Fn(&Value, &str, &str, C, D) -> R,
    R: FilterReturn,

    C: for<'a> FilterArg<Output<'a> = C>,
    D: for<'a> FilterArg<Output<'a> = D>,

    (ValueRef, Str, Str, C, D):
        for<'a> FilterArgs<Output<'a> = (&'a Value, &'a str, &'a str, C, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a Value, &'a str, &'a str, C, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C> Filter<R, (ValueRef, Str, Str, C, Str)> for Func
where
    Func: Fn(&Value, &str, &str, C, &str) -> R,
    R: FilterReturn,

    C: for<'a> FilterArg<Output<'a> = C>,

    (ValueRef, Str, Str, C, Str):
        for<'a> FilterArgs<Output<'a> = (&'a Value, &'a str, &'a str, C, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a Value, &'a str, &'a str, C, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, D> Filter<R, (ValueRef, Str, Str, Str, D)> for Func
where
    Func: Fn(&Value, &str, &str, &str, D) -> R,
    R: FilterReturn,

    D: for<'a> FilterArg<Output<'a> = D>,

    (ValueRef, Str, Str, Str, D):
        for<'a> FilterArgs<Output<'a> = (&'a Value, &'a str, &'a str, &'a str, D)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a Value, &'a str, &'a str, &'a str, D)) -> R {
        self(v, a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R> Filter<R, (ValueRef, Str, Str, Str, Str)> for Func
where
    Func: Fn(&Value, &str, &str, &str, &str) -> R,
    R: FilterReturn,

    (ValueRef, Str, Str, Str, Str):
        for<'a> FilterArgs<Output<'a> = (&'a Value, &'a str, &'a str, &'a str, &'a str)>,
{
    fn filter<'a>(&self, (v, a, b, c, d): (&'a Value, &'a str, &'a str, &'a str, &'a str)) -> R {
        self(v, a, b, c, d)
    }
}