2024-07-18 00:24:43 +02:00
|
|
|
// Copyright 2024, Command Line Inc.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
|
2024-08-28 03:49:49 +02:00
|
|
|
// Generated Code. DO NOT EDIT.
|
2024-07-18 00:24:43 +02:00
|
|
|
|
|
|
|
package wshclient
|
|
|
|
|
|
|
|
import (
|
2024-09-05 23:25:45 +02:00
|
|
|
"github.com/wavetermdev/waveterm/pkg/wshutil"
|
|
|
|
"github.com/wavetermdev/waveterm/pkg/wshrpc"
|
|
|
|
"github.com/wavetermdev/waveterm/pkg/waveobj"
|
|
|
|
"github.com/wavetermdev/waveterm/pkg/wconfig"
|
2024-07-18 00:24:43 +02:00
|
|
|
)
|
|
|
|
|
2024-08-17 01:49:49 +02:00
|
|
|
// command "announce", wshserver.AnnounceCommand
|
|
|
|
func AnnounceCommand(w *wshutil.WshRpc, data string, opts *wshrpc.RpcOpts) error {
|
2024-08-28 03:49:49 +02:00
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "announce", data, opts)
|
|
|
|
return err
|
2024-08-17 01:49:49 +02:00
|
|
|
}
|
|
|
|
|
2024-07-26 22:30:11 +02:00
|
|
|
// command "authenticate", wshserver.AuthenticateCommand
|
2024-08-20 23:56:48 +02:00
|
|
|
func AuthenticateCommand(w *wshutil.WshRpc, data string, opts *wshrpc.RpcOpts) (wshrpc.CommandAuthenticateRtnData, error) {
|
2024-08-28 03:49:49 +02:00
|
|
|
resp, err := sendRpcRequestCallHelper[wshrpc.CommandAuthenticateRtnData](w, "authenticate", data, opts)
|
|
|
|
return resp, err
|
2024-07-18 00:24:43 +02:00
|
|
|
}
|
|
|
|
|
2024-09-04 08:04:19 +02:00
|
|
|
// command "connconnect", wshserver.ConnConnectCommand
|
|
|
|
func ConnConnectCommand(w *wshutil.WshRpc, data string, opts *wshrpc.RpcOpts) error {
|
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "connconnect", data, opts)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2024-09-04 07:15:02 +02:00
|
|
|
// command "conndisconnect", wshserver.ConnDisconnectCommand
|
|
|
|
func ConnDisconnectCommand(w *wshutil.WshRpc, data string, opts *wshrpc.RpcOpts) error {
|
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "conndisconnect", data, opts)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// command "connensure", wshserver.ConnEnsureCommand
|
|
|
|
func ConnEnsureCommand(w *wshutil.WshRpc, data string, opts *wshrpc.RpcOpts) error {
|
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "connensure", data, opts)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2024-09-06 02:02:44 +02:00
|
|
|
// command "connlist", wshserver.ConnListCommand
|
|
|
|
func ConnListCommand(w *wshutil.WshRpc, opts *wshrpc.RpcOpts) ([]string, error) {
|
|
|
|
resp, err := sendRpcRequestCallHelper[[]string](w, "connlist", nil, opts)
|
|
|
|
return resp, err
|
|
|
|
}
|
|
|
|
|
2024-09-04 07:15:02 +02:00
|
|
|
// command "connreinstallwsh", wshserver.ConnReinstallWshCommand
|
|
|
|
func ConnReinstallWshCommand(w *wshutil.WshRpc, data string, opts *wshrpc.RpcOpts) error {
|
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "connreinstallwsh", data, opts)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2024-09-04 08:04:19 +02:00
|
|
|
// command "connstatus", wshserver.ConnStatusCommand
|
|
|
|
func ConnStatusCommand(w *wshutil.WshRpc, opts *wshrpc.RpcOpts) ([]wshrpc.ConnStatus, error) {
|
|
|
|
resp, err := sendRpcRequestCallHelper[[]wshrpc.ConnStatus](w, "connstatus", nil, opts)
|
|
|
|
return resp, err
|
|
|
|
}
|
|
|
|
|
2024-07-26 22:30:11 +02:00
|
|
|
// command "controllerinput", wshserver.ControllerInputCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func ControllerInputCommand(w *wshutil.WshRpc, data wshrpc.CommandBlockInputData, opts *wshrpc.RpcOpts) error {
|
2024-08-28 03:49:49 +02:00
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "controllerinput", data, opts)
|
|
|
|
return err
|
2024-07-26 22:30:11 +02:00
|
|
|
}
|
|
|
|
|
2024-09-05 09:21:08 +02:00
|
|
|
// command "controllerresync", wshserver.ControllerResyncCommand
|
|
|
|
func ControllerResyncCommand(w *wshutil.WshRpc, data wshrpc.CommandControllerResyncData, opts *wshrpc.RpcOpts) error {
|
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "controllerresync", data, opts)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// command "controllerstop", wshserver.ControllerStopCommand
|
|
|
|
func ControllerStopCommand(w *wshutil.WshRpc, data string, opts *wshrpc.RpcOpts) error {
|
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "controllerstop", data, opts)
|
2024-08-28 03:49:49 +02:00
|
|
|
return err
|
2024-07-18 00:24:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// command "createblock", wshserver.CreateBlockCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func CreateBlockCommand(w *wshutil.WshRpc, data wshrpc.CommandCreateBlockData, opts *wshrpc.RpcOpts) (waveobj.ORef, error) {
|
2024-08-28 03:49:49 +02:00
|
|
|
resp, err := sendRpcRequestCallHelper[waveobj.ORef](w, "createblock", data, opts)
|
|
|
|
return resp, err
|
2024-07-18 00:24:43 +02:00
|
|
|
}
|
|
|
|
|
2024-07-19 03:13:59 +02:00
|
|
|
// command "deleteblock", wshserver.DeleteBlockCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func DeleteBlockCommand(w *wshutil.WshRpc, data wshrpc.CommandDeleteBlockData, opts *wshrpc.RpcOpts) error {
|
2024-08-28 03:49:49 +02:00
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "deleteblock", data, opts)
|
|
|
|
return err
|
2024-07-19 03:13:59 +02:00
|
|
|
}
|
|
|
|
|
2024-07-26 22:30:11 +02:00
|
|
|
// command "eventpublish", wshserver.EventPublishCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func EventPublishCommand(w *wshutil.WshRpc, data wshrpc.WaveEvent, opts *wshrpc.RpcOpts) error {
|
2024-08-28 03:49:49 +02:00
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "eventpublish", data, opts)
|
|
|
|
return err
|
2024-07-26 22:30:11 +02:00
|
|
|
}
|
|
|
|
|
2024-08-30 20:33:04 +02:00
|
|
|
// command "eventreadhistory", wshserver.EventReadHistoryCommand
|
|
|
|
func EventReadHistoryCommand(w *wshutil.WshRpc, data wshrpc.CommandEventReadHistoryData, opts *wshrpc.RpcOpts) ([]*wshrpc.WaveEvent, error) {
|
|
|
|
resp, err := sendRpcRequestCallHelper[[]*wshrpc.WaveEvent](w, "eventreadhistory", data, opts)
|
|
|
|
return resp, err
|
|
|
|
}
|
|
|
|
|
2024-07-26 22:30:11 +02:00
|
|
|
// command "eventrecv", wshserver.EventRecvCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func EventRecvCommand(w *wshutil.WshRpc, data wshrpc.WaveEvent, opts *wshrpc.RpcOpts) error {
|
2024-08-28 03:49:49 +02:00
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "eventrecv", data, opts)
|
|
|
|
return err
|
2024-07-26 22:30:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// command "eventsub", wshserver.EventSubCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func EventSubCommand(w *wshutil.WshRpc, data wshrpc.SubscriptionRequest, opts *wshrpc.RpcOpts) error {
|
2024-08-28 03:49:49 +02:00
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "eventsub", data, opts)
|
|
|
|
return err
|
2024-07-26 22:30:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// command "eventunsub", wshserver.EventUnsubCommand
|
2024-08-24 03:12:40 +02:00
|
|
|
func EventUnsubCommand(w *wshutil.WshRpc, data string, opts *wshrpc.RpcOpts) error {
|
2024-08-28 03:49:49 +02:00
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "eventunsub", data, opts)
|
|
|
|
return err
|
2024-07-26 22:30:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// command "eventunsuball", wshserver.EventUnsubAllCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func EventUnsubAllCommand(w *wshutil.WshRpc, opts *wshrpc.RpcOpts) error {
|
2024-08-28 03:49:49 +02:00
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "eventunsuball", nil, opts)
|
|
|
|
return err
|
2024-07-18 00:24:43 +02:00
|
|
|
}
|
|
|
|
|
2024-07-26 22:30:11 +02:00
|
|
|
// command "fileappend", wshserver.FileAppendCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func FileAppendCommand(w *wshutil.WshRpc, data wshrpc.CommandFileData, opts *wshrpc.RpcOpts) error {
|
2024-08-28 03:49:49 +02:00
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "fileappend", data, opts)
|
|
|
|
return err
|
2024-07-18 00:24:43 +02:00
|
|
|
}
|
|
|
|
|
2024-07-26 22:30:11 +02:00
|
|
|
// command "fileappendijson", wshserver.FileAppendIJsonCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func FileAppendIJsonCommand(w *wshutil.WshRpc, data wshrpc.CommandAppendIJsonData, opts *wshrpc.RpcOpts) error {
|
2024-08-28 03:49:49 +02:00
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "fileappendijson", data, opts)
|
|
|
|
return err
|
2024-07-26 22:30:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// command "fileread", wshserver.FileReadCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func FileReadCommand(w *wshutil.WshRpc, data wshrpc.CommandFileData, opts *wshrpc.RpcOpts) (string, error) {
|
2024-08-28 03:49:49 +02:00
|
|
|
resp, err := sendRpcRequestCallHelper[string](w, "fileread", data, opts)
|
|
|
|
return resp, err
|
2024-07-23 22:16:53 +02:00
|
|
|
}
|
|
|
|
|
2024-07-26 22:30:11 +02:00
|
|
|
// command "filewrite", wshserver.FileWriteCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func FileWriteCommand(w *wshutil.WshRpc, data wshrpc.CommandFileData, opts *wshrpc.RpcOpts) error {
|
2024-08-28 03:49:49 +02:00
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "filewrite", data, opts)
|
|
|
|
return err
|
2024-07-23 22:16:53 +02:00
|
|
|
}
|
|
|
|
|
2024-07-18 00:24:43 +02:00
|
|
|
// command "getmeta", wshserver.GetMetaCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func GetMetaCommand(w *wshutil.WshRpc, data wshrpc.CommandGetMetaData, opts *wshrpc.RpcOpts) (waveobj.MetaMapType, error) {
|
2024-08-28 03:49:49 +02:00
|
|
|
resp, err := sendRpcRequestCallHelper[waveobj.MetaMapType](w, "getmeta", data, opts)
|
|
|
|
return resp, err
|
2024-07-18 00:24:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// command "message", wshserver.MessageCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func MessageCommand(w *wshutil.WshRpc, data wshrpc.CommandMessageData, opts *wshrpc.RpcOpts) error {
|
2024-08-28 03:49:49 +02:00
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "message", data, opts)
|
|
|
|
return err
|
2024-07-18 00:24:43 +02:00
|
|
|
}
|
|
|
|
|
2024-08-19 20:02:40 +02:00
|
|
|
// command "remotefiledelete", wshserver.RemoteFileDeleteCommand
|
|
|
|
func RemoteFileDeleteCommand(w *wshutil.WshRpc, data string, opts *wshrpc.RpcOpts) error {
|
2024-08-28 03:49:49 +02:00
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "remotefiledelete", data, opts)
|
|
|
|
return err
|
2024-08-19 20:02:40 +02:00
|
|
|
}
|
|
|
|
|
2024-08-12 19:58:39 +02:00
|
|
|
// command "remotefileinfo", wshserver.RemoteFileInfoCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func RemoteFileInfoCommand(w *wshutil.WshRpc, data string, opts *wshrpc.RpcOpts) (*wshrpc.FileInfo, error) {
|
2024-08-28 03:49:49 +02:00
|
|
|
resp, err := sendRpcRequestCallHelper[*wshrpc.FileInfo](w, "remotefileinfo", data, opts)
|
|
|
|
return resp, err
|
2024-08-12 19:58:39 +02:00
|
|
|
}
|
|
|
|
|
2024-09-04 06:08:51 +02:00
|
|
|
// command "remotefilejoin", wshserver.RemoteFileJoinCommand
|
|
|
|
func RemoteFileJoinCommand(w *wshutil.WshRpc, data []string, opts *wshrpc.RpcOpts) (*wshrpc.FileInfo, error) {
|
|
|
|
resp, err := sendRpcRequestCallHelper[*wshrpc.FileInfo](w, "remotefilejoin", data, opts)
|
|
|
|
return resp, err
|
|
|
|
}
|
|
|
|
|
2024-08-20 00:01:00 +02:00
|
|
|
// command "remotestreamcpudata", wshserver.RemoteStreamCpuDataCommand
|
|
|
|
func RemoteStreamCpuDataCommand(w *wshutil.WshRpc, opts *wshrpc.RpcOpts) chan wshrpc.RespOrErrorUnion[wshrpc.TimeSeriesData] {
|
2024-08-28 03:49:49 +02:00
|
|
|
return sendRpcRequestResponseStreamHelper[wshrpc.TimeSeriesData](w, "remotestreamcpudata", nil, opts)
|
2024-08-20 00:01:00 +02:00
|
|
|
}
|
|
|
|
|
2024-08-12 19:58:39 +02:00
|
|
|
// command "remotestreamfile", wshserver.RemoteStreamFileCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func RemoteStreamFileCommand(w *wshutil.WshRpc, data wshrpc.CommandRemoteStreamFileData, opts *wshrpc.RpcOpts) chan wshrpc.RespOrErrorUnion[wshrpc.CommandRemoteStreamFileRtnData] {
|
2024-08-28 03:49:49 +02:00
|
|
|
return sendRpcRequestResponseStreamHelper[wshrpc.CommandRemoteStreamFileRtnData](w, "remotestreamfile", data, opts)
|
2024-08-12 19:58:39 +02:00
|
|
|
}
|
|
|
|
|
2024-08-14 03:36:11 +02:00
|
|
|
// command "remotewritefile", wshserver.RemoteWriteFileCommand
|
|
|
|
func RemoteWriteFileCommand(w *wshutil.WshRpc, data wshrpc.CommandRemoteWriteFileData, opts *wshrpc.RpcOpts) error {
|
2024-08-28 03:49:49 +02:00
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "remotewritefile", data, opts)
|
|
|
|
return err
|
2024-08-14 03:36:11 +02:00
|
|
|
}
|
|
|
|
|
2024-07-18 00:24:43 +02:00
|
|
|
// command "resolveids", wshserver.ResolveIdsCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func ResolveIdsCommand(w *wshutil.WshRpc, data wshrpc.CommandResolveIdsData, opts *wshrpc.RpcOpts) (wshrpc.CommandResolveIdsRtnData, error) {
|
2024-08-28 03:49:49 +02:00
|
|
|
resp, err := sendRpcRequestCallHelper[wshrpc.CommandResolveIdsRtnData](w, "resolveids", data, opts)
|
|
|
|
return resp, err
|
2024-07-18 00:24:43 +02:00
|
|
|
}
|
|
|
|
|
2024-08-28 07:02:21 +02:00
|
|
|
// command "setconfig", wshserver.SetConfigCommand
|
2024-09-03 05:21:35 +02:00
|
|
|
func SetConfigCommand(w *wshutil.WshRpc, data wconfig.MetaSettingsType, opts *wshrpc.RpcOpts) error {
|
2024-08-28 07:02:21 +02:00
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "setconfig", data, opts)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2024-07-18 00:24:43 +02:00
|
|
|
// command "setmeta", wshserver.SetMetaCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func SetMetaCommand(w *wshutil.WshRpc, data wshrpc.CommandSetMetaData, opts *wshrpc.RpcOpts) error {
|
2024-08-28 03:49:49 +02:00
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "setmeta", data, opts)
|
|
|
|
return err
|
2024-07-18 00:24:43 +02:00
|
|
|
}
|
|
|
|
|
2024-07-26 22:30:11 +02:00
|
|
|
// command "setview", wshserver.SetViewCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func SetViewCommand(w *wshutil.WshRpc, data wshrpc.CommandBlockSetViewData, opts *wshrpc.RpcOpts) error {
|
2024-08-28 03:49:49 +02:00
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "setview", data, opts)
|
|
|
|
return err
|
2024-07-18 00:24:43 +02:00
|
|
|
}
|
|
|
|
|
2024-07-31 23:13:36 +02:00
|
|
|
// command "streamcpudata", wshserver.StreamCpuDataCommand
|
2024-08-20 00:01:00 +02:00
|
|
|
func StreamCpuDataCommand(w *wshutil.WshRpc, data wshrpc.CpuDataRequest, opts *wshrpc.RpcOpts) chan wshrpc.RespOrErrorUnion[wshrpc.TimeSeriesData] {
|
2024-08-28 03:49:49 +02:00
|
|
|
return sendRpcRequestResponseStreamHelper[wshrpc.TimeSeriesData](w, "streamcpudata", data, opts)
|
2024-07-31 23:13:36 +02:00
|
|
|
}
|
|
|
|
|
2024-07-26 22:30:11 +02:00
|
|
|
// command "streamtest", wshserver.StreamTestCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func StreamTestCommand(w *wshutil.WshRpc, opts *wshrpc.RpcOpts) chan wshrpc.RespOrErrorUnion[int] {
|
2024-08-28 03:49:49 +02:00
|
|
|
return sendRpcRequestResponseStreamHelper[int](w, "streamtest", nil, opts)
|
2024-07-25 11:30:49 +02:00
|
|
|
}
|
|
|
|
|
2024-07-26 22:30:11 +02:00
|
|
|
// command "streamwaveai", wshserver.StreamWaveAiCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func StreamWaveAiCommand(w *wshutil.WshRpc, data wshrpc.OpenAiStreamRequest, opts *wshrpc.RpcOpts) chan wshrpc.RespOrErrorUnion[wshrpc.OpenAIPacketType] {
|
2024-08-28 03:49:49 +02:00
|
|
|
return sendRpcRequestResponseStreamHelper[wshrpc.OpenAIPacketType](w, "streamwaveai", data, opts)
|
2024-07-19 00:56:04 +02:00
|
|
|
}
|
|
|
|
|
2024-08-12 19:58:39 +02:00
|
|
|
// command "test", wshserver.TestCommand
|
2024-08-14 01:52:35 +02:00
|
|
|
func TestCommand(w *wshutil.WshRpc, data string, opts *wshrpc.RpcOpts) error {
|
2024-08-28 03:49:49 +02:00
|
|
|
_, err := sendRpcRequestCallHelper[any](w, "test", data, opts)
|
|
|
|
return err
|
2024-08-12 19:58:39 +02:00
|
|
|
}
|
2024-08-28 22:21:08 +02:00
|
|
|
|
|
|
|
|