how do I use this? I want to start tts with a button but its not working because idk what void to use

using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;

public class TTSClientRunner : MonoBehaviour
{
    [Header("TTS Server Settings")]
    [Tooltip("Your TTS server URL")]
    public string url = "YOUR_URL";

    [Tooltip("API key for authorization")]
    public string apiKey = "YOUR_API_KEY";

    [Header("Text Settings")]
    [TextArea]
    public string text = "Hello, this is a test!";

    [Header("Reference Data (optional)")]
    [Tooltip("Reference texts for voice adaptation")]
    public List<string> referenceTexts = new List<string>() { "Hello" };

    [Tooltip("File paths for reference audio files (relative or absolute)")]
    public List<string> referenceAudioFilePaths = new List<string>();

    [Header("TTS Parameters")]
    [Tooltip("Audio output format (e.g., wav, mp3)")]
    public string format = "wav";

    [Tooltip("Chunk length for streaming (0 disables chunking)")]
    public int chunkLength = 0;

    [Tooltip("Top P parameter")]
    public float topP = 0.9f;

    [Tooltip("Temperature parameter")]
    public float temperature = 0.9f;

    [Tooltip("Random seed (nullable, 0 or null disables)")]
    public int? seed = 0;

    [Tooltip("Maximum new tokens")]
    public int maxNewTokens = 0;

    [Tooltip("Repetition penalty")]
    public float repetitionPenalty = 1.1f;

    [Tooltip("Optional explicit output file path. Leave empty to use persistentDataPath.")]
    public string outputFilePath = "";

    private void Start()
    {
        StartCoroutine(RunTTS());
    }

    private IEnumerator RunTTS()
    {
        Debug.Log("Starting TTS request...");

        // Load reference audio files into List<byte[]>
        List<byte[]> referenceAudios = new List<byte[]>();

        foreach (var filePath in referenceAudioFilePaths)
        {
            if (string.IsNullOrEmpty(filePath))
            {
                referenceAudios.Add(new byte[0]);
                continue;
            }

            string fullPath = filePath;

            // If path is relative, try combining with Application.persistentDataPath or StreamingAssetsPath
            if (!Path.IsPathRooted(filePath))
            {
                // Try persistentDataPath first
                fullPath = Path.Combine(Application.persistentDataPath, filePath);

                // If file doesn't exist there, try StreamingAssets (on Android StreamingAssets is not simple folder)
                if (!File.Exists(fullPath))
                {
#if UNITY_ANDROID && !UNITY_EDITOR
                    // Android StreamingAssets must be accessed via UnityWebRequest
                    yield return LoadFileFromAndroidStreamingAssets(filePath, audioBytes =>
                    {
                        if (audioBytes != null)
                            referenceAudios.Add(audioBytes);
                        else
                            referenceAudios.Add(new byte[0]);
                    });
                    continue;
#else
                    fullPath = Path.Combine(Application.streamingAssetsPath, filePath);
#endif
                }
            }

            if (File.Exists(fullPath))
            {
                byte[] bytes = null;
                try
                {
                    bytes = File.ReadAllBytes(fullPath);
                }
                catch (System.Exception ex)
                {
                    Debug.LogWarning($"Failed to read reference audio file '{fullPath}': {ex.Message}");
                }

                referenceAudios.Add(bytes ?? new byte[0]);
            }
            else
            {
                Debug.LogWarning($"Reference audio file not found: {fullPath}");
                referenceAudios.Add(new byte[0]);
            }
        }

        string finalOutputFilePath = string.IsNullOrEmpty(outputFilePath) ? null : outputFilePath;

        var ttsClient = new TTSClient(
            url,
            text,
            apiKey,
            referenceTexts,
            referenceAudios,
            format,
            chunkLength,
            topP,
            temperature,
            seed,
            maxNewTokens,
            repetitionPenalty,
            finalOutputFilePath);

        yield return ttsClient.SendRequestAndSaveAudioCoroutine(result =>
        {
            if (result.success)
                Debug.Log($"TTS success! Audio saved to: {result.message}");
            else
                Debug.LogError($"TTS failed: {result.message}");
        });
    }

#if UNITY_ANDROID && !UNITY_EDITOR
    // Special helper to load StreamingAssets on Android
    private IEnumerator LoadFileFromAndroidStreamingAssets(string relativePath, System.Action<byte[]> onComplete)
    {
        string streamingAssetsPath = Path.Combine(Application.streamingAssetsPath, relativePath);
        using UnityEngine.Networking.UnityWebRequest request = UnityEngine.Networking.UnityWebRequest.Get(streamingAssetsPath);
        yield return request.SendWebRequest();

#if UNITY_2020_1_OR_NEWER
        if (request.result == UnityEngine.Networking.UnityWebRequest.Result.Success)
#else
        if (!request.isNetworkError && !request.isHttpError)
#endif
        {
            onComplete?.Invoke(request.downloadHandler.data);
        }
        else
        {
            Debug.LogWarning($"Failed to load {streamingAssetsPath}: {request.error}");
            onComplete?.Invoke(null);
        }
    }
#endif
}