Is there a way to retrieve the inner types of a type using variadic templates in C++?

Assume I have a type using variadic templates:

template <typename... Args>
struct Outer
{
  // using Inner = something that captures ...Args ???;
}

How could I define Inner such that I could later use it elsewhere in some templated code like:

// ... some existing function accepting potentially other template arguments
template <typename... Args2>
foo(Args2 ...)
{
 // ...
};
// ... somewhere I define some specialized Outers, as examples but not limited to
using Specific1 = Outer<int, double, bool>;
using Specific2 = Outer<std::string>;
// ...
foo(Specific1::Inner... args)
// ...
foo(Specific2::Inner... args)

I am mainly interested on C++17, but open to learn however it could be done in any other version of C++. Ideally I would like to achieve this without joggling around with std::tuple.

A minimal reproducible example:

template <typename... Args>
struct Outer
{
	using Cb = std::function<void(Args...)>;

	//using Inner = Args; // this one complains "parameter pack must be expanded in this context"
	//using Inner = Args...; // this one complains "parameter pack cannot be expanded in this context"

	template<typename CbIn>
	void store(CbIn&& cb)
	{
		mCb = std::forward<CbIn>(cb);
	}

	void call(Args... args) noexcept
	{
		mCb(args...);
	}

	// cb here accepts Args... and returns OtherOuter* (specialized with different Args)
	template<typename OtherOuter, typename CbIn>
	void foo(CbIn&& cb)
	{
		store([cb{ std::forward<CbIn>(cb)}](Args... args)
		{
			OtherOuter * other = cb(std::forward<Args>(args)...);
			other->store([](/*OtherOuter::Inner*/ ... otherArgs) // what to put here if not OtherOuter::Inner ???
			{
				// do something with otherArgs
				([&]
				{
					std::cout << "second " << otherArgs << std::endl;
				} (), ...);
			});
			std::cout << "first " << other->mFlag << std::endl;
		});
	}

	Cb mCb;
	bool mFlag = false;
};

And using the example:

using OuterIntBool = Outer<int, bool>;
using OuterString = Outer<std::string>;
// works
{
	OuterIntBool outerIntBool;
	outerIntBool.store([](int i, bool b)
	{
		bool isValid = i > 0 && b;
		assert(isValid);
	});
	outerIntBool.call(1, true);
}
// does not work
{
	OuterIntBool outerIntBool;
	OuterString otherString;
	outerIntBool.foo<OuterString>([&otherString](int/* i*/, bool b)
	{
		otherString.mFlag = b;
		return &otherString;
	});
	outerIntBool.call(1, true);
	otherString.call("bar");
}

> How to "save" variadic template parameter?

The direct way, as we do with regular template argument is not possible:

template <typename T>
struct s1
{
    using type = T; // OK
};

template <typename... Ts>
struct s2
{
    using types = Ts...; // KO
};

but, they are several ways to "save" variadic arguments:

• Use some variadic type to keep it std::tuple or your own type_list

  template <typename... Ts> struct type_list {};
  
  template <typename... Args>
  struct Outer
  {
      using type1s = std::tuple<Args...>;
      using type2s = type_list<Args...>;
  };
  

• A destructured way:

  template <typename... Args>
  struct Outer
  {
      constexpr type_size = sizeof...(Args);
      template <std::size_t I>
      using type = std::tuple_element_t<I, std::tuple<Args...>>;
  };
  

• an external type_trait (with any of the above result). so destructured way example:

  template <typename T>
  constexpr std::size_t outer_size;
  
  template <typename... Ts>
  constexpr std::size_t outer_size<Outer<Ts...>> = sizeof...(Ts);
  
  template <std::size_t I, typename T>
  struct arg_element;
  
  template <std::size_t I, typename... Ts>
  struct arg_element<I, Outer<Ts...>> {
      using type = std::tuple_element_t<Is, std::tuple<Ts...>>;
  };
  

> How to use saved parameters?

std::index_sequence might help:

template <typename Outer>
void get_printer(const Outer&)
{
    []<std::size_t... Is>(std::index_sequence<Is...>){
        // typename Outer::template type<Is>... is not equivalent to the Ts...
        // std::tuple_element_t<Is, typename Outer::types>... for tuple case

        return [](const typename Outer::template type<Is>&... args){
            (std::cout << args), ...);
        };
    }(std::make_index_sequence<Outer::size_type>()); // tuple_size<Outer::types>


}

Did you try other->store([](auto&& ... otherArgs)?