#pragma once

/*
* SDK generated by Dumper-7
*
* https://github.com/Encryqed/Dumper-7
*/

// Package: UniversalVoiceChatPro

#include "Basic.hpp"

#include "UniversalVoiceChatPro_classes.hpp"
#include "UniversalVoiceChatPro_parameters.hpp"


SDK_NAMESPACE_START

// Function UniversalVoiceChatPro.AudioCaptureAndroid.AndroidAskPermission
// (Final, Native, Static, Public)

void UAudioCaptureAndroid::AndroidAskPermission()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AudioCaptureAndroid", "AndroidAskPermission");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.AudioCaptureAndroid.AndroidHasPermission
// (Final, Native, Static, Public)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAudioCaptureAndroid::AndroidHasPermission()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AudioCaptureAndroid", "AndroidHasPermission");

	Params::AudioCaptureAndroid_AndroidHasPermission Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.AudioCaptureAndroid.AndroidMicrophoneStart
// (Final, Native, Static, Public)
// Parameters:
// class UMicrophoneSpeakComponent*        callbackComp                                           (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   sampleRateToUse                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAudioCaptureAndroid::AndroidMicrophoneStart(class UMicrophoneSpeakComponent* callbackComp, int32 sampleRateToUse)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AudioCaptureAndroid", "AndroidMicrophoneStart");

	Params::AudioCaptureAndroid_AndroidMicrophoneStart Parms{};

	Parms.callbackComp = callbackComp;
	Parms.sampleRateToUse = sampleRateToUse;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.AudioCaptureAndroid.AndroidMicrophoneStop
// (Final, Native, Static, Public)
// Parameters:
// class UMicrophoneSpeakComponent*        callbackComp                                           (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAudioCaptureAndroid::AndroidMicrophoneStop(class UMicrophoneSpeakComponent* callbackComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AudioCaptureAndroid", "AndroidMicrophoneStop");

	Params::AudioCaptureAndroid_AndroidMicrophoneStop Parms{};

	Parms.callbackComp = callbackComp;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.MicrophoneSpeakComponent.endSpeaking
// (Final, Native, Public, BlueprintCallable)

void UMicrophoneSpeakComponent::endSpeaking()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicrophoneSpeakComponent", "endSpeaking");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.MicrophoneSpeakComponent.getLocallyMultiplierVolume
// (Final, Native, Public)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UMicrophoneSpeakComponent::getLocallyMultiplierVolume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicrophoneSpeakComponent", "getLocallyMultiplierVolume");

	Params::MicrophoneSpeakComponent_getLocallyMultiplierVolume Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.MicrophoneSpeakComponent.initAudioResources
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   voiceSampleRate                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   _voiceNumChannels                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   opusFramesPerSec                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMicrophoneSpeakComponent::initAudioResources(int32 voiceSampleRate, int32 _voiceNumChannels, int32 opusFramesPerSec)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicrophoneSpeakComponent", "initAudioResources");

	Params::MicrophoneSpeakComponent_initAudioResources Parms{};

	Parms.voiceSampleRate = voiceSampleRate;
	Parms._voiceNumChannels = _voiceNumChannels;
	Parms.opusFramesPerSec = opusFramesPerSec;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.MicrophoneSpeakComponent.isPlayingAudioVoice
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMicrophoneSpeakComponent::isPlayingAudioVoice()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicrophoneSpeakComponent", "isPlayingAudioVoice");

	Params::MicrophoneSpeakComponent_isPlayingAudioVoice Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.MicrophoneSpeakComponent.muteAudio
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    _isMuted                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMicrophoneSpeakComponent::muteAudio(bool _isMuted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicrophoneSpeakComponent", "muteAudio");

	Params::MicrophoneSpeakComponent_muteAudio Parms{};

	Parms._isMuted = _isMuted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.MicrophoneSpeakComponent.payloadReceivedVoiceData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<uint8>&                    dataEncoded                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   SampleRate                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumChannels                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   PCMSize                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   opusFramePerSec                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMicrophoneSpeakComponent::payloadReceivedVoiceData(const TArray<uint8>& dataEncoded, int32 SampleRate, int32 NumChannels, int32 PCMSize, int32 opusFramePerSec)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicrophoneSpeakComponent", "payloadReceivedVoiceData");

	Params::MicrophoneSpeakComponent_payloadReceivedVoiceData Parms{};

	Parms.dataEncoded = std::move(dataEncoded);
	Parms.SampleRate = SampleRate;
	Parms.NumChannels = NumChannels;
	Parms.PCMSize = PCMSize;
	Parms.opusFramePerSec = opusFramePerSec;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.MicrophoneSpeakComponent.RPCClientTransmitVoiceData
// (Net, Native, Event, Public, NetServer)
// Parameters:
// const TArray<uint8>&                    Data                                                   (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   SampleRate                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumChannels                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   PCMSize                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   opusFramePerSec                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    _isGlobal                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<int32>&                    _radioChannel                                          (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    _useRange                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   _maxRange                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMicrophoneSpeakComponent::RPCClientTransmitVoiceData(const TArray<uint8>& Data, int32 SampleRate, int32 NumChannels, int32 PCMSize, int32 opusFramePerSec, bool _isGlobal, const TArray<int32>& _radioChannel, bool _useRange, float _maxRange)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicrophoneSpeakComponent", "RPCClientTransmitVoiceData");

	Params::MicrophoneSpeakComponent_RPCClientTransmitVoiceData Parms{};

	Parms.Data = std::move(Data);
	Parms.SampleRate = SampleRate;
	Parms.NumChannels = NumChannels;
	Parms.PCMSize = PCMSize;
	Parms.opusFramePerSec = opusFramePerSec;
	Parms._isGlobal = _isGlobal;
	Parms._radioChannel = std::move(_radioChannel);
	Parms._useRange = _useRange;
	Parms._maxRange = _maxRange;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.MicrophoneSpeakComponent.RPCReceiveVoiceFromServer
// (Net, Native, Event, Public, NetClient)
// Parameters:
// class UMicrophoneSpeakComponent*        compToOutputVoice                                      (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<uint8>&                    dataEncoded                                            (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   SampleRate                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumChannels                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   PCMSize                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   opusFramePerSec                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMicrophoneSpeakComponent::RPCReceiveVoiceFromServer(class UMicrophoneSpeakComponent* compToOutputVoice, const TArray<uint8>& dataEncoded, int32 SampleRate, int32 NumChannels, int32 PCMSize, int32 opusFramePerSec)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicrophoneSpeakComponent", "RPCReceiveVoiceFromServer");

	Params::MicrophoneSpeakComponent_RPCReceiveVoiceFromServer Parms{};

	Parms.compToOutputVoice = compToOutputVoice;
	Parms.dataEncoded = std::move(dataEncoded);
	Parms.SampleRate = SampleRate;
	Parms.NumChannels = NumChannels;
	Parms.PCMSize = PCMSize;
	Parms.opusFramePerSec = opusFramePerSec;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.MicrophoneSpeakComponent.RPCServerBroadcastVoiceData
// (Net, Native, Event, NetMulticast, Public)
// Parameters:
// const TArray<uint8>&                    Data                                                   (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   SampleRate                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumChannels                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   PCMSize                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   opusFramePerSec                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMicrophoneSpeakComponent::RPCServerBroadcastVoiceData(const TArray<uint8>& Data, int32 SampleRate, int32 NumChannels, int32 PCMSize, int32 opusFramePerSec)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicrophoneSpeakComponent", "RPCServerBroadcastVoiceData");

	Params::MicrophoneSpeakComponent_RPCServerBroadcastVoiceData Parms{};

	Parms.Data = std::move(Data);
	Parms.SampleRate = SampleRate;
	Parms.NumChannels = NumChannels;
	Parms.PCMSize = PCMSize;
	Parms.opusFramePerSec = opusFramePerSec;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.MicrophoneSpeakComponent.setAttenuationAssetPath
// (Final, Native, Public)
// Parameters:
// bool                                    enableAttenuation                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    _pathToAttenuationAsset                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMicrophoneSpeakComponent::setAttenuationAssetPath(bool enableAttenuation, const class FString& _pathToAttenuationAsset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicrophoneSpeakComponent", "setAttenuationAssetPath");

	Params::MicrophoneSpeakComponent_setAttenuationAssetPath Parms{};

	Parms.enableAttenuation = enableAttenuation;
	Parms._pathToAttenuationAsset = std::move(_pathToAttenuationAsset);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.MicrophoneSpeakComponent.setLocallyMultiplierVolume
// (Final, Native, Public)
// Parameters:
// float                                   multiplierVolume                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMicrophoneSpeakComponent::setLocallyMultiplierVolume(float multiplierVolume)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicrophoneSpeakComponent", "setLocallyMultiplierVolume");

	Params::MicrophoneSpeakComponent_setLocallyMultiplierVolume Parms{};

	Parms.multiplierVolume = multiplierVolume;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.MicrophoneSpeakComponent.setOverrideLocallyAttenuationPath
// (Final, Native, Public)
// Parameters:
// bool                                    enableAttenuation                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    overrideLocally                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    _pathToAttenuationAsset                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMicrophoneSpeakComponent::setOverrideLocallyAttenuationPath(bool enableAttenuation, bool overrideLocally, const class FString& _pathToAttenuationAsset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicrophoneSpeakComponent", "setOverrideLocallyAttenuationPath");

	Params::MicrophoneSpeakComponent_setOverrideLocallyAttenuationPath Parms{};

	Parms.enableAttenuation = enableAttenuation;
	Parms.overrideLocally = overrideLocally;
	Parms._pathToAttenuationAsset = std::move(_pathToAttenuationAsset);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.MicrophoneSpeakComponent.setOverrideLocallySourceEffectPath
// (Final, Native, Public)
// Parameters:
// bool                                    enableSourceEffect                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    overrideLocally                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    _pathToSourceEffectAsset                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMicrophoneSpeakComponent::setOverrideLocallySourceEffectPath(bool enableSourceEffect, bool overrideLocally, const class FString& _pathToSourceEffectAsset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicrophoneSpeakComponent", "setOverrideLocallySourceEffectPath");

	Params::MicrophoneSpeakComponent_setOverrideLocallySourceEffectPath Parms{};

	Parms.enableSourceEffect = enableSourceEffect;
	Parms.overrideLocally = overrideLocally;
	Parms._pathToSourceEffectAsset = std::move(_pathToSourceEffectAsset);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.MicrophoneSpeakComponent.setSourceChainEffectAssetPath
// (Final, Native, Public)
// Parameters:
// bool                                    enableSourceChainEffect                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    _pathToSourceChainEffect                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMicrophoneSpeakComponent::setSourceChainEffectAssetPath(bool enableSourceChainEffect, const class FString& _pathToSourceChainEffect)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicrophoneSpeakComponent", "setSourceChainEffectAssetPath");

	Params::MicrophoneSpeakComponent_setSourceChainEffectAssetPath Parms{};

	Parms.enableSourceChainEffect = enableSourceChainEffect;
	Parms._pathToSourceChainEffect = std::move(_pathToSourceChainEffect);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.MicrophoneSpeakComponent.SetVoiceVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Volume                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMicrophoneSpeakComponent::SetVoiceVolume(float Volume)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicrophoneSpeakComponent", "SetVoiceVolume");

	Params::MicrophoneSpeakComponent_SetVoiceVolume Parms{};

	Parms.Volume = Volume;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.MicrophoneSpeakComponent.startSpeaking
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    _shouldHearMyOwnVoice                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IsGlobal                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<int32>&                    radioChannel                                           (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    useRange                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxRange                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMicrophoneSpeakComponent::startSpeaking(bool _shouldHearMyOwnVoice, bool IsGlobal, const TArray<int32>& radioChannel, bool useRange, float MaxRange)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicrophoneSpeakComponent", "startSpeaking");

	Params::MicrophoneSpeakComponent_startSpeaking Parms{};

	Parms._shouldHearMyOwnVoice = _shouldHearMyOwnVoice;
	Parms.IsGlobal = IsGlobal;
	Parms.radioChannel = std::move(radioChannel);
	Parms.useRange = useRange;
	Parms.MaxRange = MaxRange;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.DelegateEndPlayOwner
// (Final, Native, Public)
// Parameters:
// class AActor*                           act                                                    (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEndPlayReason                          EndPlayReason                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::DelegateEndPlayOwner(class AActor* act, EEndPlayReason EndPlayReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "DelegateEndPlayOwner");

	Params::PlayerVoiceChatActor_DelegateEndPlayOwner Parms{};

	Parms.act = act;
	Parms.EndPlayReason = EndPlayReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.getLocallyMultiplierVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APlayerVoiceChatActor::getLocallyMultiplierVolume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "getLocallyMultiplierVolume");

	Params::PlayerVoiceChatActor_getLocallyMultiplierVolume Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.IsMicrophoneComponentValid
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APlayerVoiceChatActor::IsMicrophoneComponentValid()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "IsMicrophoneComponentValid");

	Params::PlayerVoiceChatActor_IsMicrophoneComponentValid Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.muteAudio
// (Final, Native, Public)
// Parameters:
// bool                                    isMute                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::muteAudio(bool isMute)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "muteAudio");

	Params::PlayerVoiceChatActor_muteAudio Parms{};

	Parms.isMute = isMute;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.RepNotifyAttenuationAsset
// (Final, Native, Public)

void APlayerVoiceChatActor::RepNotifyAttenuationAsset()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "RepNotifyAttenuationAsset");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.RepNotifyIsMicrophoneOn
// (Final, Native, Public)

void APlayerVoiceChatActor::RepNotifyIsMicrophoneOn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "RepNotifyIsMicrophoneOn");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.RepNotifyMicComp
// (Final, Native, Public)

void APlayerVoiceChatActor::RepNotifyMicComp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "RepNotifyMicComp");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.RepNotifyPlayerName
// (Final, Native, Public)

void APlayerVoiceChatActor::RepNotifyPlayerName()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "RepNotifyPlayerName");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.RepNotifySourceEffectAsset
// (Final, Native, Public)

void APlayerVoiceChatActor::RepNotifySourceEffectAsset()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "RepNotifySourceEffectAsset");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.RepNotifyVoiceVolume
// (Final, Native, Public)

void APlayerVoiceChatActor::RepNotifyVoiceVolume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "RepNotifyVoiceVolume");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.RPCClientAskAddChannel
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// int32                                   channelToAdd                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::RPCClientAskAddChannel(int32 channelToAdd)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "RPCClientAskAddChannel");

	Params::PlayerVoiceChatActor_RPCClientAskAddChannel Parms{};

	Parms.channelToAdd = channelToAdd;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.RPCClientAskRemoveChannel
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// int32                                   channelToRemove                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::RPCClientAskRemoveChannel(int32 channelToRemove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "RPCClientAskRemoveChannel");

	Params::PlayerVoiceChatActor_RPCClientAskRemoveChannel Parms{};

	Parms.channelToRemove = channelToRemove;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.RPCClientSetAttenuationPath
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// const class FString&                    _attenuationPath                                       (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::RPCClientSetAttenuationPath(const class FString& _attenuationPath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "RPCClientSetAttenuationPath");

	Params::PlayerVoiceChatActor_RPCClientSetAttenuationPath Parms{};

	Parms._attenuationPath = std::move(_attenuationPath);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.RPCClientSetIsMicrophoneOn
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// bool                                    _isMicrophoneOn                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::RPCClientSetIsMicrophoneOn(bool _isMicrophoneOn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "RPCClientSetIsMicrophoneOn");

	Params::PlayerVoiceChatActor_RPCClientSetIsMicrophoneOn Parms{};

	Parms._isMicrophoneOn = _isMicrophoneOn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.RPCClientSetMicrophoneVolume
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// float                                   Volume                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::RPCClientSetMicrophoneVolume(float Volume)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "RPCClientSetMicrophoneVolume");

	Params::PlayerVoiceChatActor_RPCClientSetMicrophoneVolume Parms{};

	Parms.Volume = Volume;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.RPCClientSetPlayerName
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// const class FString&                    Name_0                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::RPCClientSetPlayerName(const class FString& Name_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "RPCClientSetPlayerName");

	Params::PlayerVoiceChatActor_RPCClientSetPlayerName Parms{};

	Parms.Name_0 = std::move(Name_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.RPCClientSetSourceChainEffectPath
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// const class FString&                    _pathToSourceChainEffectAsset                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::RPCClientSetSourceChainEffectPath(const class FString& _pathToSourceChainEffectAsset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "RPCClientSetSourceChainEffectPath");

	Params::PlayerVoiceChatActor_RPCClientSetSourceChainEffectPath Parms{};

	Parms._pathToSourceChainEffectAsset = std::move(_pathToSourceChainEffectAsset);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.RPCServerUpdatePosAudioComp
// (Net, Native, Event, NetMulticast, Public, HasDefaults)
// Parameters:
// const struct FVector&                   worldPos                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  worldRotation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::RPCServerUpdatePosAudioComp(const struct FVector& worldPos, const struct FRotator& worldRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "RPCServerUpdatePosAudioComp");

	Params::PlayerVoiceChatActor_RPCServerUpdatePosAudioComp Parms{};

	Parms.worldPos = std::move(worldPos);
	Parms.worldRotation = std::move(worldRotation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.ServerAddChannel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   channelToAdd                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::ServerAddChannel(int32 channelToAdd)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "ServerAddChannel");

	Params::PlayerVoiceChatActor_ServerAddChannel Parms{};

	Parms.channelToAdd = channelToAdd;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.ServerRemoveChannel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   channelToRemove                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::ServerRemoveChannel(int32 channelToRemove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "ServerRemoveChannel");

	Params::PlayerVoiceChatActor_ServerRemoveChannel Parms{};

	Parms.channelToRemove = channelToRemove;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.ServerSetAllowUseGlobal
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    _allowUseGlobal                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::ServerSetAllowUseGlobal(bool _allowUseGlobal)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "ServerSetAllowUseGlobal");

	Params::PlayerVoiceChatActor_ServerSetAllowUseGlobal Parms{};

	Parms._allowUseGlobal = _allowUseGlobal;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.ServerSetAllowUseProximity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    _allowUseRange                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::ServerSetAllowUseProximity(bool _allowUseRange)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "ServerSetAllowUseProximity");

	Params::PlayerVoiceChatActor_ServerSetAllowUseProximity Parms{};

	Parms._allowUseRange = _allowUseRange;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.ServerSetAttenuation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    enableAttenuation                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    _pathToAttenuationAsset                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::ServerSetAttenuation(bool enableAttenuation, const class FString& _pathToAttenuationAsset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "ServerSetAttenuation");

	Params::PlayerVoiceChatActor_ServerSetAttenuation Parms{};

	Parms.enableAttenuation = enableAttenuation;
	Parms._pathToAttenuationAsset = std::move(_pathToAttenuationAsset);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.ServerSetMaxProximityRange
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   _maxProximityRange                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::ServerSetMaxProximityRange(float _maxProximityRange)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "ServerSetMaxProximityRange");

	Params::PlayerVoiceChatActor_ServerSetMaxProximityRange Parms{};

	Parms._maxProximityRange = _maxProximityRange;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.ServerSetSourceChainEffect
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    enableSourceChainEffect                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    _pathToSourceChainEffect                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::ServerSetSourceChainEffect(bool enableSourceChainEffect, const class FString& _pathToSourceChainEffect)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "ServerSetSourceChainEffect");

	Params::PlayerVoiceChatActor_ServerSetSourceChainEffect Parms{};

	Parms.enableSourceChainEffect = enableSourceChainEffect;
	Parms._pathToSourceChainEffect = std::move(_pathToSourceChainEffect);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.setLocallyMultiplierVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   multiplierVolume                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::setLocallyMultiplierVolume(float multiplierVolume)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "setLocallyMultiplierVolume");

	Params::PlayerVoiceChatActor_setLocallyMultiplierVolume Parms{};

	Parms.multiplierVolume = multiplierVolume;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.setOverrideLocallyAttenuationPath
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    enableAttenuation                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    overrideLocally                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    _pathToAttenuationAsset                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::setOverrideLocallyAttenuationPath(bool enableAttenuation, bool overrideLocally, const class FString& _pathToAttenuationAsset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "setOverrideLocallyAttenuationPath");

	Params::PlayerVoiceChatActor_setOverrideLocallyAttenuationPath Parms{};

	Parms.enableAttenuation = enableAttenuation;
	Parms.overrideLocally = overrideLocally;
	Parms._pathToAttenuationAsset = std::move(_pathToAttenuationAsset);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.PlayerVoiceChatActor.setOverrideLocallySourceEffectPath
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    enableSourceEffect                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    overrideLocally                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    _pathToSourceEffectAsset                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlayerVoiceChatActor::setOverrideLocallySourceEffectPath(bool enableSourceEffect, bool overrideLocally, const class FString& _pathToSourceEffectAsset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerVoiceChatActor", "setOverrideLocallySourceEffectPath");

	Params::PlayerVoiceChatActor_setOverrideLocallySourceEffectPath Parms{};

	Parms.enableSourceEffect = enableSourceEffect;
	Parms.overrideLocally = overrideLocally;
	Parms._pathToSourceEffectAsset = std::move(_pathToSourceEffectAsset);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.IsMyPlayerVoiceChatActorReady
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUniversalVoiceChat::IsMyPlayerVoiceChatActorReady()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "IsMyPlayerVoiceChatActorReady");

	Params::UniversalVoiceChat_IsMyPlayerVoiceChatActorReady Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.RegisterCallbackDeleteVoiceChatActor
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TDelegate<void(const class APlayerVoiceChatActor* VoiceChatActor)>&Delegate                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUniversalVoiceChat::RegisterCallbackDeleteVoiceChatActor(const TDelegate<void(const class APlayerVoiceChatActor* VoiceChatActor)>& Delegate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "RegisterCallbackDeleteVoiceChatActor");

	Params::UniversalVoiceChat_RegisterCallbackDeleteVoiceChatActor Parms{};

	Parms.Delegate = Delegate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.RegisterCallbackMyVoiceChatActorReady
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TDelegate<void(const class APlayerVoiceChatActor* VoiceChatActor)>&Delegate                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUniversalVoiceChat::RegisterCallbackMyVoiceChatActorReady(const TDelegate<void(const class APlayerVoiceChatActor* VoiceChatActor)>& Delegate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "RegisterCallbackMyVoiceChatActorReady");

	Params::UniversalVoiceChat_RegisterCallbackMyVoiceChatActorReady Parms{};

	Parms.Delegate = Delegate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.RegisterCallbackNewVoiceChatActor
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TDelegate<void(const class APlayerVoiceChatActor* VoiceChatActor)>&Delegate                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUniversalVoiceChat::RegisterCallbackNewVoiceChatActor(const TDelegate<void(const class APlayerVoiceChatActor* VoiceChatActor)>& Delegate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "RegisterCallbackNewVoiceChatActor");

	Params::UniversalVoiceChat_RegisterCallbackNewVoiceChatActor Parms{};

	Parms.Delegate = Delegate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatAddChannel
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                                   channelToAdd                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUniversalVoiceChat::VoiceChatAddChannel(int32 channelToAdd)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatAddChannel");

	Params::UniversalVoiceChat_VoiceChatAddChannel Parms{};

	Parms.channelToAdd = channelToAdd;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatAskMicrophonePermission
// (Final, Native, Static, Public, BlueprintCallable)

void UUniversalVoiceChat::VoiceChatAskMicrophonePermission()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatAskMicrophonePermission");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatCheckRegisteredToChannel
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                                   channelToCheck                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUniversalVoiceChat::VoiceChatCheckRegisteredToChannel(int32 channelToCheck)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatCheckRegisteredToChannel");

	Params::UniversalVoiceChat_VoiceChatCheckRegisteredToChannel Parms{};

	Parms.channelToCheck = channelToCheck;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatEnableShouldHearMyOwnVoice
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    Enable                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUniversalVoiceChat::VoiceChatEnableShouldHearMyOwnVoice(bool Enable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatEnableShouldHearMyOwnVoice");

	Params::UniversalVoiceChat_VoiceChatEnableShouldHearMyOwnVoice Parms{};

	Parms.Enable = Enable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatGetActorFromPlayerState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerState*                     fromPlayerState                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerVoiceChatActor*            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APlayerVoiceChatActor* UUniversalVoiceChat::VoiceChatGetActorFromPlayerState(const class UObject* WorldContextObject, class APlayerState* fromPlayerState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatGetActorFromPlayerState");

	Params::UniversalVoiceChat_VoiceChatGetActorFromPlayerState Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.fromPlayerState = fromPlayerState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatGetAudioDevicesList
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TArray<class FString>*                  OutDevices                                             (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UUniversalVoiceChat::VoiceChatGetAudioDevicesList(TArray<class FString>* OutDevices)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatGetAudioDevicesList");

	Params::UniversalVoiceChat_VoiceChatGetAudioDevicesList Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDevices != nullptr)
		*OutDevices = std::move(Parms.OutDevices);
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatGetMicrophoneRuntimeVolumeFromPlayerState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerState*                     fromPlayerState                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UUniversalVoiceChat::VoiceChatGetMicrophoneRuntimeVolumeFromPlayerState(const class UObject* WorldContextObject, class APlayerState* fromPlayerState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatGetMicrophoneRuntimeVolumeFromPlayerState");

	Params::UniversalVoiceChat_VoiceChatGetMicrophoneRuntimeVolumeFromPlayerState Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.fromPlayerState = fromPlayerState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatGetMuteAllPlayers
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUniversalVoiceChat::VoiceChatGetMuteAllPlayers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatGetMuteAllPlayers");

	Params::UniversalVoiceChat_VoiceChatGetMuteAllPlayers Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatGetMyLocalPlayerVoiceChat
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APlayerVoiceChatActor*            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APlayerVoiceChatActor* UUniversalVoiceChat::VoiceChatGetMyLocalPlayerVoiceChat()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatGetMyLocalPlayerVoiceChat");

	Params::UniversalVoiceChat_VoiceChatGetMyLocalPlayerVoiceChat Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatHasMicrophonePermission
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUniversalVoiceChat::VoiceChatHasMicrophonePermission()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatHasMicrophonePermission");

	Params::UniversalVoiceChat_VoiceChatHasMicrophonePermission Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatInitAudioVoiceChatQuality
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                                   _sampleRate                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   _numChannels                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EOpusFramePerSec                        _opusFramePerSec                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUniversalVoiceChat::VoiceChatInitAudioVoiceChatQuality(int32 _sampleRate, int32 _numChannels, EOpusFramePerSec _opusFramePerSec)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatInitAudioVoiceChatQuality");

	Params::UniversalVoiceChat_VoiceChatInitAudioVoiceChatQuality Parms{};

	Parms._sampleRate = _sampleRate;
	Parms._numChannels = _numChannels;
	Parms._opusFramePerSec = _opusFramePerSec;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatIsSpeaking
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUniversalVoiceChat::VoiceChatIsSpeaking()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatIsSpeaking");

	Params::UniversalVoiceChat_VoiceChatIsSpeaking Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatLocalIsMutedSomeone
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerState*                     playerToCheckMute                                      (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUniversalVoiceChat::VoiceChatLocalIsMutedSomeone(const class UObject* WorldContextObject, class APlayerState* playerToCheckMute)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatLocalIsMutedSomeone");

	Params::UniversalVoiceChat_VoiceChatLocalIsMutedSomeone Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.playerToCheckMute = playerToCheckMute;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatLocalMuteSomeone
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerState*                     playerToMute                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    shouldMute                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUniversalVoiceChat::VoiceChatLocalMuteSomeone(const class UObject* WorldContextObject, class APlayerState* playerToMute, bool shouldMute)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatLocalMuteSomeone");

	Params::UniversalVoiceChat_VoiceChatLocalMuteSomeone Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.playerToMute = playerToMute;
	Parms.shouldMute = shouldMute;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatRemoveChannel
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                                   channelToRemove                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUniversalVoiceChat::VoiceChatRemoveChannel(int32 channelToRemove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatRemoveChannel");

	Params::UniversalVoiceChat_VoiceChatRemoveChannel Parms{};

	Parms.channelToRemove = channelToRemove;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatSetAttenuationPath
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    enableAttenuation                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    _attenuationPath                                       (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUniversalVoiceChat::VoiceChatSetAttenuationPath(bool enableAttenuation, const class FString& _attenuationPath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatSetAttenuationPath");

	Params::UniversalVoiceChat_VoiceChatSetAttenuationPath Parms{};

	Parms.enableAttenuation = enableAttenuation;
	Parms._attenuationPath = std::move(_attenuationPath);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatSetDefaultTickRateUpdateLocation
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// float                                   tickRate                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUniversalVoiceChat::VoiceChatSetDefaultTickRateUpdateLocation(float tickRate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatSetDefaultTickRateUpdateLocation");

	Params::UniversalVoiceChat_VoiceChatSetDefaultTickRateUpdateLocation Parms{};

	Parms.tickRate = tickRate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatSetGlobalVolume
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// float                                   globalVolume                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUniversalVoiceChat::VoiceChatSetGlobalVolume(float globalVolume)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatSetGlobalVolume");

	Params::UniversalVoiceChat_VoiceChatSetGlobalVolume Parms{};

	Parms.globalVolume = globalVolume;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatSetHardwareAudioInput
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    audioInputDeviceName                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUniversalVoiceChat::VoiceChatSetHardwareAudioInput(const class FString& audioInputDeviceName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatSetHardwareAudioInput");

	Params::UniversalVoiceChat_VoiceChatSetHardwareAudioInput Parms{};

	Parms.audioInputDeviceName = std::move(audioInputDeviceName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatSetMicrophoneVolume
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// float                                   Volume                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUniversalVoiceChat::VoiceChatSetMicrophoneVolume(float Volume)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatSetMicrophoneVolume");

	Params::UniversalVoiceChat_VoiceChatSetMicrophoneVolume Parms{};

	Parms.Volume = Volume;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatSetMuteAllPlayers
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    _muteAll                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUniversalVoiceChat::VoiceChatSetMuteAllPlayers(bool _muteAll)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatSetMuteAllPlayers");

	Params::UniversalVoiceChat_VoiceChatSetMuteAllPlayers Parms{};

	Parms._muteAll = _muteAll;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatSetPlayerName
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Name_0                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUniversalVoiceChat::VoiceChatSetPlayerName(const class FString& Name_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatSetPlayerName");

	Params::UniversalVoiceChat_VoiceChatSetPlayerName Parms{};

	Parms.Name_0 = std::move(Name_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatSetRawMicrophoneGain
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// float                                   Gain                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUniversalVoiceChat::VoiceChatSetRawMicrophoneGain(float Gain)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatSetRawMicrophoneGain");

	Params::UniversalVoiceChat_VoiceChatSetRawMicrophoneGain Parms{};

	Parms.Gain = Gain;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatSetSourceChainEffectPath
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    enableSourceChainEffect                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    _pathToSourceChainEffectAsset                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUniversalVoiceChat::VoiceChatSetSourceChainEffectPath(bool enableSourceChainEffect, const class FString& _pathToSourceChainEffectAsset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatSetSourceChainEffectPath");

	Params::UniversalVoiceChat_VoiceChatSetSourceChainEffectPath Parms{};

	Parms.enableSourceChainEffect = enableSourceChainEffect;
	Parms._pathToSourceChainEffectAsset = std::move(_pathToSourceChainEffectAsset);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatSetThresholdSendData
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// float                                   thresholdSendData                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUniversalVoiceChat::VoiceChatSetThresholdSendData(float thresholdSendData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatSetThresholdSendData");

	Params::UniversalVoiceChat_VoiceChatSetThresholdSendData Parms{};

	Parms.thresholdSendData = thresholdSendData;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatStartSpeak
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    _shouldHearMyOwnVoice                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IsGlobal                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   radioChannel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    useProximity                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   maxProximityRange                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUniversalVoiceChat::VoiceChatStartSpeak(bool _shouldHearMyOwnVoice, bool IsGlobal, int32 radioChannel, bool useProximity, float maxProximityRange)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatStartSpeak");

	Params::UniversalVoiceChat_VoiceChatStartSpeak Parms{};

	Parms._shouldHearMyOwnVoice = _shouldHearMyOwnVoice;
	Parms.IsGlobal = IsGlobal;
	Parms.radioChannel = radioChannel;
	Parms.useProximity = useProximity;
	Parms.maxProximityRange = maxProximityRange;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatStartSpeakTeamArray
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    _shouldHearMyOwnVoice                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IsGlobal                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<int32>&                    radioChannel                                           (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    useProximity                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   maxProximityRange                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUniversalVoiceChat::VoiceChatStartSpeakTeamArray(bool _shouldHearMyOwnVoice, bool IsGlobal, const TArray<int32>& radioChannel, bool useProximity, float maxProximityRange)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatStartSpeakTeamArray");

	Params::UniversalVoiceChat_VoiceChatStartSpeakTeamArray Parms{};

	Parms._shouldHearMyOwnVoice = _shouldHearMyOwnVoice;
	Parms.IsGlobal = IsGlobal;
	Parms.radioChannel = std::move(radioChannel);
	Parms.useProximity = useProximity;
	Parms.maxProximityRange = maxProximityRange;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatStopSpeak
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUniversalVoiceChat::VoiceChatStopSpeak()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatStopSpeak");

	Params::UniversalVoiceChat_VoiceChatStopSpeak Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatUseAndroidCommunicationMode
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    use                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUniversalVoiceChat::VoiceChatUseAndroidCommunicationMode(bool use)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatUseAndroidCommunicationMode");

	Params::UniversalVoiceChat_VoiceChatUseAndroidCommunicationMode Parms{};

	Parms.use = use;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatWasInitAudioVoiceChatQuality
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUniversalVoiceChat::VoiceChatWasInitAudioVoiceChatQuality()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UniversalVoiceChat", "VoiceChatWasInitAudioVoiceChatQuality");

	Params::UniversalVoiceChat_VoiceChatWasInitAudioVoiceChatQuality Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatGetSomeoneLocallyMultiplierVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerState*                     playerToOverride                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UUniversalVoiceChat::VoiceChatGetSomeoneLocallyMultiplierVolume(const class UObject* WorldContextObject, class APlayerState* playerToOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UniversalVoiceChat", "VoiceChatGetSomeoneLocallyMultiplierVolume");

	Params::UniversalVoiceChat_VoiceChatGetSomeoneLocallyMultiplierVolume Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.playerToOverride = playerToOverride;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatSetSomeoneLocallyMultiplierVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   multiplierVolume                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerState*                     playerToOverride                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUniversalVoiceChat::VoiceChatSetSomeoneLocallyMultiplierVolume(const class UObject* WorldContextObject, float multiplierVolume, class APlayerState* playerToOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UniversalVoiceChat", "VoiceChatSetSomeoneLocallyMultiplierVolume");

	Params::UniversalVoiceChat_VoiceChatSetSomeoneLocallyMultiplierVolume Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.multiplierVolume = multiplierVolume;
	Parms.playerToOverride = playerToOverride;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatSetSomeoneOverrideLocallyAttenuationPath
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    enableAttenuation                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    overrideLocally                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    _pathToAttenuationAsset                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerState*                     playerToOverride                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUniversalVoiceChat::VoiceChatSetSomeoneOverrideLocallyAttenuationPath(const class UObject* WorldContextObject, bool enableAttenuation, bool overrideLocally, const class FString& _pathToAttenuationAsset, class APlayerState* playerToOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UniversalVoiceChat", "VoiceChatSetSomeoneOverrideLocallyAttenuationPath");

	Params::UniversalVoiceChat_VoiceChatSetSomeoneOverrideLocallyAttenuationPath Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.enableAttenuation = enableAttenuation;
	Parms.overrideLocally = overrideLocally;
	Parms._pathToAttenuationAsset = std::move(_pathToAttenuationAsset);
	Parms.playerToOverride = playerToOverride;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UniversalVoiceChatPro.UniversalVoiceChat.VoiceChatSetSomeoneOverrideLocallySourceEffectPath
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    enableSourceEffect                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    overrideLocally                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    _pathToSourceEffectAsset                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerState*                     playerToOverride                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUniversalVoiceChat::VoiceChatSetSomeoneOverrideLocallySourceEffectPath(const class UObject* WorldContextObject, bool enableSourceEffect, bool overrideLocally, const class FString& _pathToSourceEffectAsset, class APlayerState* playerToOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UniversalVoiceChat", "VoiceChatSetSomeoneOverrideLocallySourceEffectPath");

	Params::UniversalVoiceChat_VoiceChatSetSomeoneOverrideLocallySourceEffectPath Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.enableSourceEffect = enableSourceEffect;
	Parms.overrideLocally = overrideLocally;
	Parms._pathToSourceEffectAsset = std::move(_pathToSourceEffectAsset);
	Parms.playerToOverride = playerToOverride;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


SDK_NAMESPACE_END
