Register Apple Pay and Google Pay as payment method for future usage without making a purchase

[kekko7072]

I'm currently facing some issue on registering Apple Pay and Google Pay as payments methods. I want to know how to save a customer's payment method (in particular Apple Pay or Google Pay) for future use without making a purchase. In fact I successfully registered them and used via stripe.Stripe.instance.initPaymentSheet(), but this way I need to do a purchase, I successfully save a customer's payment method if it's a card with this codec inn front end and calling my backend in typescript:

Front END:

Future<String> createCustomerWithCard(
      {required CurrentUser user, required UserData userData}) async {
    try {
      final UserData userDataUpdated =
          await DatabaseUser(uid: userData.uid).getSingleUser;

      // Call API
      final HttpsCallableResult result =
          await kApiStripeCreateCustomerWithCard.call(<String, dynamic>{
        'customerId': userDataUpdated.billing.customerId.isNotEmpty
            ? userDataUpdated.billing.customerId
            : 'false',
        'email': userDataUpdated.profileUser.email,
        'name':
            '${userDataUpdated.profileUser.name} ${userDataUpdated.profileUser.surname}',
        'phoneNumber': '${user.phoneNumber}',
      });
      final Map<String, dynamic> bodyResponse =
          json.decode(json.encode(result.data));
      if (kDebugMode) {
        print(bodyResponse);
      }

      final clientSecret = bodyResponse['clientSecret'] as String;

      return clientSecret;
    } on FirebaseFunctionsException catch (e) {
      if (kDebugMode) {
        print('-----------------------------------------------');
        print(e.code);
        print(e.message);
        print(e.details);
        print('-----------------------------------------------');
      }
      return json.decode(json.encode(e.message!));
    }
  }

API EDNPOINT on backend:

exports.call = functions
  .region("europe-west3")
  .https.onCall(async (req, context) => {
    const {
      customerId = req.createNewCustomer,
      email = req.email,
      name = req.fullName,
      phoneNumber = req.phoneNumber,
      payment_method_types = ["card"],
    }: {
      customerId: string;
      email: string;
      name: string;
      phoneNumber: string;
      payment_method_types: string[];
    } = req;

    const customer =
      customerId == "false"
        ? await stripe.customers.create({
            email: email,
            description: context.auth?.uid,
            name: name,
            phone: phoneNumber,
          })
        : await stripe.customers.retrieve(customerId);

    const setupIntent = await stripe.setupIntents.create({
      customer: customer.id,
      payment_method_types,
      usage: "off_session",
    });

    const uid = context.auth?.uid || null;
    if (uid != null) {
      await userCollection
        .doc(uid)
        .update({
          "billing.configured": true,
          "billing.customerId": customer.id,
        })
        .catch((error) => {
          throw new functions.https.HttpsError(
            "invalid-argument",
            error.errorInfo.message
          );
        });
      return { clientSecret: setupIntent.client_secret };
    } else if (uid == null) {
      throw new functions.https.HttpsError(
        "unauthenticated",
        `Il uid passato non è vaildo ${uid}`
      );
    } else {
      return { success: false, setupIntentStatus: setupIntent.status };
    }
  });