Skip to content

Go client API definitions (vsapi)

import "vivesound.com/sdk/go/vsapi"

Package vsapi holds the API definitions for the ViveEngine Control API.

It defines the data types (DTOs) that map to the Control API. These types form the vocabulary of the Control API and carry no transport or connection logic.

The package is used by the vsctl client library, which exposes each Control API RPC as a method operating on these types.

Index

type ActivationType

ActivationType is the activation type, used both to request an activation method and to report the current one in LicenseState.

Which types an engine accepts depends on its edition. During activation the engine contacts the licensing service, which grants or denies the request; a granted activation stays in effect across restarts until it expires or is deactivated. Editions that require no license report ActivationNone and run without activation.

type ActivationType int

const (
    // ActivationNone means no license is active. In LicenseState this means the
    // engine runs without activation or has not been activated yet.
    ActivationNone ActivationType = iota
    // ActivationTrial is a time-limited trial bound to this computer. Requires no
    // credentials and expires after a fixed period.
    ActivationTrial
    // ActivationKey is a full activation using a license key. The activation is
    // granted to this computer and counts against the license's available
    // activations.
    ActivationKey
    // ActivationCreds is a full activation using user account credentials. The
    // activation is granted to this computer and counts against the license's
    // available activations.
    ActivationCreds
)

func (ActivationType) String 

func (i ActivationType) String() string

func (ActivationType) MarshalJSON 

func (i ActivationType) MarshalJSON() ([]byte, error)

MarshalJSON encodes the ActivationType as its snake_case name.

type Caption

Caption is a single caption produced by captioning.

Streamed by ReceiveCaptions.

type Caption struct {
    // Device whose audio stream this caption was transcribed from.
    DeviceUID string `json:"device_uid"`
    // Position of the caption within the audio stream, measured from the moment
    // captioning started.
    Timecode time.Duration `json:"timecode"`
    // Label of the detected speaker, when speaker identification is available.
    // Only populated by providers that support it, and otherwise left empty.
    Speaker string `json:"speaker"`
    // Whether this is a partial caption. While a phrase is being spoken, it is
    // delivered as a series of partial captions, each of which may hold an
    // incomplete phrase, be inaccurate, and change as the speaker continues. The
    // phrase ends with a single final caption (with IsPartial set to false) that
    // holds its settled text.
    IsPartial bool `json:"is_partial"`
    // Transcribed text of the caption.
    Text string `json:"text"`
}

type CaptioningEffect

CaptioningEffect is a speech captioning effect.

Adding this effect to a flow's effect chain enables live transcription of speech in that flow.

type CaptioningEffect struct {
    // BCP-47 language code of the spoken language to transcribe, for example
    // "en-US". If empty, the provider's default language is used.
    LanguageCode string `json:"language_code,omitempty"`
}

type CaptionsAuth

CaptionsAuth holds credentials for the Bring Your Own Cloud captioning provider.

Supplies the keys of the user's own AWS account, used to access AWS Transcribe.

type CaptionsAuth struct {
    // AWS access key ID. Required and must be non-empty.
    AWSAccessKey string `json:"aws_access_key"`
    // AWS secret access key. Required and must be non-empty.
    AWSSecretKey string `json:"aws_secret_key"`
}

type CaptionsConfig

CaptionsConfig is the captioning provider configuration.

Return value of ConfigureCaptions, also carried by its input argument. In a return value ByocAuth is never set, because the credentials are write-only.

type CaptionsConfig struct {
    // Captioning provider to use. See CaptionsProvider.
    Provider CaptionsProvider `json:"provider"`
    // Cloud credentials for the Bring Your Own Cloud provider. Required when
    // Provider is CaptionsProviderBYOC, and must be omitted otherwise. See
    // CaptionsAuth.
    ByocAuth *CaptionsAuth `json:"byoc_auth,omitempty"`
}

type CaptionsProvider

CaptionsProvider is the captioning provider.

type CaptionsProvider int

const (
    // CaptionsProviderBilled is the built-in provider billed by ViveSound.
    // Requires no credentials, but is only available when the license allows it.
    CaptionsProviderBilled CaptionsProvider = iota
    // CaptionsProviderBYOC is the Bring Your Own Cloud provider that uses the
    // user's own cloud account. Requires credentials to be supplied in
    // CaptionsConfig.ByocAuth.
    CaptionsProviderBYOC
)

func (CaptionsProvider) MarshalJSON 

func (i CaptionsProvider) MarshalJSON() ([]byte, error)

MarshalJSON encodes the CaptionsProvider as its snake_case name.

func (CaptionsProvider) String 

func (i CaptionsProvider) String() string

type Device

Device is a single audio device.

type Device struct {
    // Stable, engine-specific device identifier. This is not an operating-system
    // device name. It has a platform-independent format and is derived by the
    // engine so that the same physical device always keeps the same UID, even
    // after it is disconnected and connected again. Use it in Route to route a
    // flow to this device.
    UID string `json:"uid"`
    // Operating-system audio backend that provides the device: Core Audio on
    // macOS, WASAPI on Windows.
    Driver DeviceDriver `json:"driver"`
    // Platform-specific device identifier assigned by the operating system. On
    // macOS this is the Core Audio device UID; on Windows it is the WASAPI
    // endpoint ID. Its format is driver-dependent and may contain special
    // characters. This is a low-level identifier, not a name meant for display;
    // use UID to identify a device and DisplayName to present it to the user.
    SystemName string `json:"system_name"`
    // Human-readable, one-line device title suitable for display. On macOS it is
    // derived from the Core Audio data source or device name; on Windows it is
    // the WASAPI endpoint friendly name. Not guaranteed to be unique.
    DisplayName string `json:"display_name"`
    // Device properties, as a bitwise OR of DeviceFeature flags.
    FeatureMask DeviceFeature `json:"features"`
}

func (Device) HasFeature 

func (d Device) HasFeature(feature DeviceFeature) bool

HasFeature reports whether the given feature flag is set in FeatureMask.

func (Device) IsInput 

func (d Device) IsInput() bool

IsInput reports whether the device is an input (capture) device.

func (Device) IsOutput 

func (d Device) IsOutput() bool

IsOutput reports whether the device is an output (playback) device.

func (Device) IsDefault 

func (d Device) IsDefault() bool

IsDefault reports whether the device is the system default for its direction.

func (Device) IsVirtual 

func (d Device) IsVirtual() bool

IsVirtual reports whether the device is virtual (not backed by hardware).

func (Device) IsBuiltin 

func (d Device) IsBuiltin() bool

IsBuiltin reports whether the device is built into the computer.

func (Device) IsHeadset 

func (d Device) IsHeadset() bool

IsHeadset reports whether the device is headphones or a headset.

func (Device) IsBluetooth 

func (d Device) IsBluetooth() bool

IsBluetooth reports whether the device is connected via Bluetooth.

func (Device) IsAirplay 

func (d Device) IsAirplay() bool

IsAirplay reports whether the device is connected via AirPlay.

func (Device) IsUSB 

func (d Device) IsUSB() bool

IsUSB reports whether the device is connected via USB.

func (Device) IsThunderbolt 

func (d Device) IsThunderbolt() bool

IsThunderbolt reports whether the device is connected via Thunderbolt.

func (Device) IsHDMI 

func (d Device) IsHDMI() bool

IsHDMI reports whether the device is connected via HDMI.

func (Device) IsDisplayPort 

func (d Device) IsDisplayPort() bool

IsDisplayPort reports whether the device is connected via DisplayPort.

type DeviceDriver

DeviceDriver is the operating-system audio backend a device belongs to.

type DeviceDriver int

const (
    // DeviceDriverUnspecified means the backend is unknown or unspecified.
    DeviceDriverUnspecified DeviceDriver = iota
    // DeviceDriverCoreAudio is Core Audio, used on macOS.
    DeviceDriverCoreAudio
    // DeviceDriverWASAPI is WASAPI, used on Windows.
    DeviceDriverWASAPI
)

func (DeviceDriver) MarshalJSON 

func (i DeviceDriver) MarshalJSON() ([]byte, error)

MarshalJSON encodes the DeviceDriver as its snake_case name.

func (DeviceDriver) String 

func (i DeviceDriver) String() string

type DeviceFeature

DeviceFeature holds the individual flags of Device FeatureMask.

The connection and type flags (for example DeviceFeatureBluetooth or DeviceFeatureUSB) are best-effort hints reported by the operating system.

type DeviceFeature uint64

const (
    // DeviceFeatureInput marks an input (capture) device. Set for every device in
    // the input list.
    DeviceFeatureInput DeviceFeature = 1 << iota
    // DeviceFeatureOutput marks an output (playback) device. Set for every device
    // in the output list.
    DeviceFeatureOutput
    // DeviceFeatureDefault marks the current system default device for its
    // direction. Set on exactly one input and one output device.
    DeviceFeatureDefault
    // DeviceFeatureVirtual marks a virtual device not backed by physical
    // hardware.
    DeviceFeatureVirtual
    // DeviceFeatureBuiltin marks a microphone or speaker integrated into the
    // computer itself, rather than an external or removable device.
    DeviceFeatureBuiltin
    // DeviceFeatureHeadset marks headphones or a headset. Headphones provide
    // playback only, while a headset combines headphones with a microphone. May
    // be connected in any way, such as a wired jack, USB, or Bluetooth.
    DeviceFeatureHeadset
    // DeviceFeatureBluetooth marks a device connected via Bluetooth.
    DeviceFeatureBluetooth
    // DeviceFeatureAirplay marks a device connected via AirPlay.
    DeviceFeatureAirplay
    // DeviceFeatureUSB marks a device connected via USB. This may be a USB audio
    // device such as a USB headset, or a USB sound card, in which case the
    // attached hardware (headset, speakers, and so on) is usually unknown.
    DeviceFeatureUSB
    // DeviceFeatureThunderbolt marks a device connected via Thunderbolt.
    DeviceFeatureThunderbolt
    // DeviceFeatureHDMI marks a device connected via HDMI.
    DeviceFeatureHDMI
    // DeviceFeatureDisplayPort marks a device connected via DisplayPort.
    DeviceFeatureDisplayPort
    // MaxDeviceFeature is the exclusive upper bound of the DeviceFeature flags,
    // used to iterate over them. It is not itself a valid feature.
    MaxDeviceFeature
)

func (DeviceFeature) String 

func (f DeviceFeature) String() string

String returns the set flags joined by "|", or "Unspecified" if none are set.

func (DeviceFeature) MarshalJSON 

func (f DeviceFeature) MarshalJSON() ([]byte, error)

MarshalJSON encodes the DeviceFeature as an array of set flags, each as its snake_case name.

type EffectConfig

EffectConfig is the configuration of a single effect within an effect chain.

An effect is either one of the built-in effects provided by the engine or a plugin effect. Exactly one of the effect fields selects the kind of effect and carries its parameters.

type EffectConfig struct {
    // Caller-assigned key that identifies the effect within its chain. Must be
    // unique within the chain. Used to address the effect in QueryEffect,
    // ConfigureEffect, and DeleteEffect.
    EffectKey uint32 `json:"effect_key,omitempty"`

    // When true, the effect is kept in the chain but bypassed, passing audio
    // through unchanged. Defaults to false (active).
    Disabled bool `json:"disabled,omitempty"`

    // Per-channel gain. See GainEffect.
    Gain *GainEffect `json:"gain,omitempty"`

    // Multi-band equalizer. See EqualizerEffect.
    Equalizer *EqualizerEffect `json:"equalizer,omitempty"`

    // Dynamic range compression. See RangeCompressionEffect.
    RangeCompression *RangeCompressionEffect `json:"range_compression,omitempty"`

    // Noise reduction. See NoiseReductionEffect.
    NoiseReduction *NoiseReductionEffect `json:"noise_reduction,omitempty"`

    // Speech captioning. See CaptioningEffect.
    Captioning *CaptioningEffect `json:"captioning,omitempty"`

    // Plugin effect. See PluginEffect.
    Plugin *PluginEffect `json:"plugin,omitempty"`
}

type EffectSelector

EffectSelector addresses a single effect within a flow.

Combines a FlowSelector with the EffectKey of one effect in that flow's effect chain.

type EffectSelector struct {
    // Which flow the effect belongs to. See FlowScope.
    Scope FlowScope `json:"scope"`
    // Whether the effect belongs to the input or output flow. See FlowDirection.
    Direction FlowDirection `json:"direction"`
    // Key of the effect within the flow's effect chain.
    EffectKey uint32 `json:"effect_key"`
}

type EqualizerEffect

EqualizerEffect is a multi-band equalizer effect.

Shapes the spectrum by applying an independent gain to each of a series of contiguous frequency bands. BandFrequencies and BandGains are parallel arrays and must have the same length: entry i defines band i.

The bands are ordered from low to high frequency. BandFrequencies gives the upper edge of each band in ascending order; a band covers from the previous band's edge (or DC for the first band) up to its own edge. The final band extends up to the Nyquist frequency, so its edge only needs to be at or above the highest reproduced frequency.

type EqualizerEffect struct {
    // Upper edge frequency of each band, in Hz, in strictly ascending order. If
    // empty, a default of eight octave-spaced bands is used (from about 177 Hz up
    // to about 22627 Hz).
    BandFrequencies []float64 `json:"band_frequencies"`
    // Gain applied within each band, in dB. Parallel to BandFrequencies. A
    // positive value boosts the band, a negative value cuts it, and 0 leaves it
    // flat. If empty, all bands default to 0 dB (flat response).
    BandGains []float64 `json:"band_gains"`
}

type Event

Event is a single event reporting a change in the engine's state.

Streamed by ReceiveEvents. An event carries no payload beyond its Code and Time; it only signals that something changed. Subscribing reports later changes but not the current state.

type Event struct {
    // Point in time at which the engine emitted the event.
    Time time.Time `json:"time"`
    // What changed. See EventCode.
    Code EventCode `json:"code"`
}

type EventCode

EventCode is the kind of change reported by an Event.

type EventCode int

const (
    // EventRunModeChanged means the run mode changed; read the new value with
    // GetRunMode. This can happen after user interaction, for example a call to
    // SetRunMode, or on its own, for example when a license expires and the
    // engine disables itself.
    EventRunModeChanged EventCode = iota
    // EventLicenseStateChanged means the license state changed; read the new
    // state with GetLicense. This can happen after user interaction, for example
    // a call to ActivateTrial, ActivateWithKey, ActivateWithCreds, or
    // DeactivateLicense, or on its own, for example when a license expires or the
    // engine re-verifies it in the background.
    EventLicenseStateChanged
    // EventPluginListChanged means the set of loaded plugins changed; read the
    // new list with ListPlugins. This can happen after user interaction, for
    // example a call to LoadPlugin or UnloadPlugin, or on its own, for example
    // when a plugin fails or its process exits.
    EventPluginListChanged
    // EventDeviceListChanged means the set of available devices changed; read the
    // new list with ListDevices. This can happen after user interaction, for
    // example connecting or disconnecting a device, or on its own, for example
    // when the system default input or output device changes.
    EventDeviceListChanged
)

func (EventCode) String 

func (i EventCode) String() string

func (EventCode) MarshalJSON 

func (i EventCode) MarshalJSON() ([]byte, error)

MarshalJSON encodes the EventCode as its snake_case name.

type FlowConfig

FlowConfig is the configuration of a single flow.

Return value of QueryFlow and ConfigureFlow, and the configuration passed to ConfigureFlow.

type FlowConfig struct {
    // Route that selects the device used by the flow. If omitted, the default
    // route is used. Only meaningful for application flows; ignored for device
    // flows. See Route.
    Route *Route `json:"route,omitempty"`
    // Ordered list of effects applied to the audio, from first to last. An empty
    // chain means default processing, that is, no processing. See EffectConfig.
    EffectChain []EffectConfig `json:"effect_chain,omitempty"`
}

type FlowDirection

FlowDirection is the direction of a flow: capture or playback.

type FlowDirection int

const (
    // FlowDirectionInput is the input (capture) flow, for audio captured from an
    // input device.
    FlowDirectionInput FlowDirection = iota
    // FlowDirectionOutput is the output (playback) flow, for audio played to an
    // output device.
    FlowDirectionOutput
)

func (FlowDirection) MarshalJSON 

func (i FlowDirection) MarshalJSON() ([]byte, error)

MarshalJSON encodes the FlowDirection as its snake_case name.

func (FlowDirection) String 

func (i FlowDirection) String() string

type FlowScope

FlowScope is the scope of a flow: which entity it applies to.

type FlowScope int

const (
    // FlowScopeDefault is the default flow, applied to applications that have no
    // flow of their own.
    FlowScopeDefault FlowScope = iota
)

func (FlowScope) MarshalJSON 

func (i FlowScope) MarshalJSON() ([]byte, error)

MarshalJSON encodes the FlowScope as its snake_case name.

func (FlowScope) String 

func (i FlowScope) String() string

type FlowSelector

FlowSelector addresses a single flow by scope and direction.

type FlowSelector struct {
    // Which flow the selector refers to. See FlowScope.
    Scope FlowScope `json:"scope"`
    // Whether the input or the output flow is selected. See FlowDirection.
    Direction FlowDirection `json:"direction"`
}

type FullActivation

FullActivation holds the details of a full (key or credentials) license, reported in LicenseState.

type FullActivation struct {
    // Number of activations currently in use across all computers.
    UsedActivations int `json:"used_activations"`
    // Total number of activations the license permits.
    AvailableActivations int `json:"available_activations"`
    // Point in time when the license was issued.
    IssueDate time.Time `json:"issue_date,omitempty"`
    // Point in time when this computer was activated.
    ActivationDate time.Time `json:"activation_date,omitempty"`
    // Point in time after which the license expires.
    ExpirationDate time.Time `json:"expiration_date,omitempty"`
}

type GainEffect

GainEffect is a per-channel gain effect.

Applies a constant gain to each channel independently, in decibels. A positive value amplifies, a negative value attenuates, and 0 leaves the channel unchanged.

type GainEffect struct {
    // Gain per channel, in dB. The n-th entry applies to the n-th channel. If
    // fewer entries are given than there are channels, the last entry applies to
    // all remaining channels. If empty, a gain of 0 dB (unity) is applied to
    // every channel. Typical range is roughly -60 to +30 dB.
    ChannelGains []float64 `json:"channel_gains"`
}

type LicenseState

LicenseState is the return value of GetLicense, ActivateTrial, ActivateWithKey, ActivateWithCreds, and DeactivateLicense.

The details are present only when a license is active, and the populated field matches Type: a trial activation reports TrialActivation, a full (key or credentials) activation reports FullActivation. When Type is ActivationNone no license is active and both details are nil.

type LicenseState struct {
    // Current activation type, or ActivationNone when no license is active. See
    // ActivationType.
    Type ActivationType `json:"type"`
    // Details of a full license, set when Type is ActivationKey or
    // ActivationCreds.
    FullActivation *FullActivation `json:"full_activation,omitempty"`
    // Details of a trial license, set when Type is ActivationTrial.
    TrialActivation *TrialActivation `json:"trial_activation,omitempty"`
}

type NoiseReductionEffect

NoiseReductionEffect is a noise reduction effect.

Attenuates steady background noise while preserving the desired signal. The Mode selects the algorithm. See NoiseReductionMode.

type NoiseReductionEffect struct {
    // Noise reduction algorithm to use. See NoiseReductionMode.
    Mode NoiseReductionMode `json:"mode,omitempty"`
}

type NoiseReductionMode

NoiseReductionMode is the noise reduction algorithm.

type NoiseReductionMode int

const (
    // NoiseReductionDSP is classic spectral noise reduction. This is the default.
    NoiseReductionDSP NoiseReductionMode = iota
    // NoiseReductionRNN is neural-network noise reduction. More aggressive than
    // NoiseReductionDSP and generally more effective on speech.
    NoiseReductionRNN
)

func (NoiseReductionMode) MarshalJSON 

func (i NoiseReductionMode) MarshalJSON() ([]byte, error)

MarshalJSON encodes the NoiseReductionMode as its snake_case name.

func (NoiseReductionMode) String 

func (i NoiseReductionMode) String() string

type Plugin

Plugin is a plugin loaded in the engine.

Returned by LoadPlugin and listed by ListPlugins. This describes a loaded plugin binary, not an instance of it; instances are PluginEffect effects placed into flows.

type Plugin struct {
    // Identifier of the plugin. Derived from the plugin and stable across unload
    // and reload, so the same plugin keeps the same UID. Used to create
    // instances and to address the plugin in messaging calls.
    UID string `json:"uid"`
    // Kind of plugin binary. See PluginType.
    Type PluginType `json:"type"`
    // Filesystem path the plugin was loaded from, as passed to LoadPlugin.
    Location string `json:"location"`
    // Number of instances currently created from this plugin across all flows.
    InstanceCount uint32 `json:"instance_count"`
}

type PluginEffect

PluginEffect is a plugin effect.

Runs an instance of a loaded plugin as an effect in the chain.

type PluginEffect struct {
    // UID of the plugin to instantiate, as returned by LoadPlugin. The plugin
    // must be currently loaded.
    PluginUID string `json:"plugin_uid"`
    // Optional plugin-specific configuration passed to the plugin instance
    // constructor. An opaque protobuf message whose schema is defined by the
    // plugin developer and shared with the application.
    CustomConfig *anypb.Any `json:"custom_config,omitempty"`
}

type PluginMessage

PluginMessage is a message produced by a plugin instance.

Streamed by ReceiveMessages.

type PluginMessage struct {
    // Plugin that produced the message, as returned by LoadPlugin.
    SourcePluginUID string `json:"source_plugin_uid"`
    // Instance that produced the message, addressed by its effect within a flow.
    // See EffectSelector.
    SourceEffect *EffectSelector `json:"source_effect,omitempty"`
    // Message payload. An opaque protobuf message whose schema is defined by the
    // plugin developer and shared with the application.
    MessagePayload *anypb.Any `json:"message_payload,omitempty"`
}

type PluginType

PluginType is the kind of a plugin binary, selecting how the engine loads and runs it.

type PluginType int

const (
    // PluginTypeUnspecified is unset. Not a valid value in a LoadPlugin request.
    PluginTypeUnspecified PluginType = iota
    // PluginTypeNative is a native plugin, a shared library loaded directly into
    // the engine's address space for the lowest overhead. The binary is a shared
    // library with a platform-specific extension: .dll on Windows, .so on Linux
    // and macOS.
    PluginTypeNative
    // PluginTypeGolang is a managed plugin written in Go using the vsplug
    // package. The plugin is compiled into a regular executable that the engine
    // runs as a separate process and communicates with over IPC. The binary is
    // an executable with a platform-specific extension: .exe on Windows, no
    // extension on Linux and macOS.
    PluginTypeGolang
)

func (PluginType) MarshalJSON 

func (i PluginType) MarshalJSON() ([]byte, error)

MarshalJSON encodes the PluginType as its snake_case name.

func (PluginType) String 

func (i PluginType) String() string

type ProcessingMode

ProcessingMode is the state of the engine for a single audio direction (input or output).

type ProcessingMode struct {
    // Whether the engine is active on this direction. When false, the engine
    // detaches from the corresponding audio path and audio flows through the OS
    // unmodified.
    Enabled bool `json:"enabled"`
}

type RangeCompressionEffect

RangeCompressionEffect is a dynamic range compression effect.

A multi-band automatic gain control that raises the level of quiet signals and holds louder signals near a set of per-band target levels, reducing the overall dynamic range and evening out perceived loudness.

type RangeCompressionEffect struct {
    // Maximum gain applied to quiet signals, in dB. Bounds how much the effect
    // may boost signals below the target level. Range 0 to 40 dB; recommended
    // default 30 dB.
    BoostLevel float64 `json:"boost_level,omitempty"`
    // Compression ratio applied to signals that exceed the target level,
    // expressed as the input-to-output ratio (for example 10 means 10:1). A
    // higher ratio makes the level more even; a lower ratio sounds more natural.
    // Range 1 (no compression) to 20; recommended default 10.
    CompressionRatio float64 `json:"compression_ratio,omitempty"`
    // Per-band target loudness. If omitted, the default per-band targets are
    // used. See RangeCompressionLevels.
    Levels *RangeCompressionLevels `json:"levels,omitempty"`
}

type RangeCompressionLevels

RangeCompressionLevels is the per-band target loudness for RangeCompressionEffect.

Each field sets the loudness the compressor aims for in one frequency band, in dBFS (decibels relative to full scale, so 0 is the loudest possible and negative values are quieter). Range for each field is -40 to 0 dBFS.

type RangeCompressionLevels struct {
    // Target loudness for the low band, in dBFS. Recommended default -20 dBFS.
    BassTargetLevel float64 `json:"bass_target_level,omitempty"`
    // Target loudness for the mid band, in dBFS. Recommended default -8 dBFS.
    MidsTargetLevel float64 `json:"mids_target_level,omitempty"`
    // Target loudness for the high band, in dBFS. Recommended default -12 dBFS.
    TrebleTargetLevel float64 `json:"treble_target_level,omitempty"`
}

type Route

Route is the route of a flow: the device its audio is bound to.

type Route struct {
    // UID of the device the flow is routed to, as reported by ListDevices. See
    // Device.
    DeviceUID string `json:"device_uid,omitempty"`
}

type RunMode

RunMode is the return value of GetRunMode and SetRunMode.

Reports whether the engine is currently active on the input and output audio paths.

type RunMode struct {
    // Current state of input processing.
    InputProcessing ProcessingMode `json:"input_processing"`
    // Current state of output processing.
    OutputProcessing ProcessingMode `json:"output_processing"`
}

type TrialActivation

TrialActivation holds the details of a trial license, reported in LicenseState.

type TrialActivation struct {
    // Point in time after which the trial expires.
    ExpirationDate time.Time `json:"expiration_date,omitempty"`
}