// Client for UPnP Device Control Protocol MediaServer v1 and MediaRenderer v1.
//
// This DCP is documented in detail at:
// - http://upnp.org/specs/av/av1/
//
// Typically, use one of the New* functions to create clients for services.
package av1

// ***********************************************************
// GENERATED FILE - DO NOT EDIT BY HAND. See README.md
// ***********************************************************

import (
	"context"
	"net/url"
	"time"

	"git.cyrilix.bzh/cyrilix/goupnp"
	"git.cyrilix.bzh/cyrilix/goupnp/soap"
)

// Hack to avoid Go complaining if time isn't used.
var _ time.Time

// Device URNs:
const ()

// Service URNs:
const (
	URN_AVTransport_1        = "urn:schemas-upnp-org:service:AVTransport:1"
	URN_AVTransport_2        = "urn:schemas-upnp-org:service:AVTransport:2"
	URN_ConnectionManager_1  = "urn:schemas-upnp-org:service:ConnectionManager:1"
	URN_ConnectionManager_2  = "urn:schemas-upnp-org:service:ConnectionManager:2"
	URN_ContentDirectory_1   = "urn:schemas-upnp-org:service:ContentDirectory:1"
	URN_ContentDirectory_2   = "urn:schemas-upnp-org:service:ContentDirectory:2"
	URN_ContentDirectory_3   = "urn:schemas-upnp-org:service:ContentDirectory:3"
	URN_RenderingControl_1   = "urn:schemas-upnp-org:service:RenderingControl:1"
	URN_RenderingControl_2   = "urn:schemas-upnp-org:service:RenderingControl:2"
	URN_ScheduledRecording_1 = "urn:schemas-upnp-org:service:ScheduledRecording:1"
	URN_ScheduledRecording_2 = "urn:schemas-upnp-org:service:ScheduledRecording:2"
)

// AVTransport1 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:AVTransport:1". See
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
// are provided for informational value.
type AVTransport1 struct {
	goupnp.ServiceClient
}

// NewAVTransport1ClientsCtx discovers instances of the service on the network,
// and returns clients to any that are found. errors will contain an error for
// any devices that replied but which could not be queried, and err will be set
// if the discovery process failed outright.
//
// This is a typical entry calling point into this package.
func NewAVTransport1ClientsCtx(ctx context.Context) (clients []*AVTransport1, errors []error, err error) {
	var genericClients []goupnp.ServiceClient
	if genericClients, errors, err = goupnp.NewServiceClientsCtx(ctx, URN_AVTransport_1); err != nil {
		return
	}
	clients = newAVTransport1ClientsFromGenericClients(genericClients)
	return
}

// NewAVTransport1Clients is the legacy version of NewAVTransport1ClientsCtx, but uses
// context.Background() as the context.
func NewAVTransport1Clients() (clients []*AVTransport1, errors []error, err error) {
	return NewAVTransport1ClientsCtx(context.Background())
}

// NewAVTransport1ClientsByURLCtx discovers instances of the service at the given
// URL, and returns clients to any that are found. An error is returned if
// there was an error probing the service.
//
// This is a typical entry calling point into this package when reusing an
// previously discovered service URL.
func NewAVTransport1ClientsByURLCtx(ctx context.Context, loc *url.URL) ([]*AVTransport1, error) {
	genericClients, err := goupnp.NewServiceClientsByURLCtx(ctx, loc, URN_AVTransport_1)
	if err != nil {
		return nil, err
	}
	return newAVTransport1ClientsFromGenericClients(genericClients), nil
}

// NewAVTransport1ClientsByURL is the legacy version of NewAVTransport1ClientsByURLCtx, but uses
// context.Background() as the context.
func NewAVTransport1ClientsByURL(loc *url.URL) ([]*AVTransport1, error) {
	return NewAVTransport1ClientsByURLCtx(context.Background(), loc)
}

// NewAVTransport1ClientsFromRootDevice discovers instances of the service in
// a given root device, and returns clients to any that are found. An error is
// returned if there was not at least one instance of the service within the
// device. The location parameter is simply assigned to the Location attribute
// of the wrapped ServiceClient(s).
//
// This is a typical entry calling point into this package when reusing an
// previously discovered root device.
func NewAVTransport1ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*AVTransport1, error) {
	genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_AVTransport_1)
	if err != nil {
		return nil, err
	}
	return newAVTransport1ClientsFromGenericClients(genericClients), nil
}

func newAVTransport1ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*AVTransport1 {
	clients := make([]*AVTransport1, len(genericClients))
	for i := range genericClients {
		clients[i] = &AVTransport1{genericClients[i]}
	}
	return clients
}

func (client *AVTransport1) GetCurrentTransportActionsCtx(
	ctx context.Context,
	InstanceID uint32,
) (Actions string, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Actions string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_1, "GetCurrentTransportActions", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Actions, err = soap.UnmarshalString(response.Actions); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetCurrentTransportActions is the legacy version of GetCurrentTransportActionsCtx, but uses
// context.Background() as the context.
func (client *AVTransport1) GetCurrentTransportActions(InstanceID uint32) (Actions string, err error) {
	return client.GetCurrentTransportActionsCtx(context.Background(),
		InstanceID,
	)
}

func (client *AVTransport1) GetDeviceCapabilitiesCtx(
	ctx context.Context,
	InstanceID uint32,
) (PlayMedia string, RecMedia string, RecQualityModes string, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		PlayMedia       string
		RecMedia        string
		RecQualityModes string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_1, "GetDeviceCapabilities", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if PlayMedia, err = soap.UnmarshalString(response.PlayMedia); err != nil {
		return
	}
	if RecMedia, err = soap.UnmarshalString(response.RecMedia); err != nil {
		return
	}
	if RecQualityModes, err = soap.UnmarshalString(response.RecQualityModes); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetDeviceCapabilities is the legacy version of GetDeviceCapabilitiesCtx, but uses
// context.Background() as the context.
func (client *AVTransport1) GetDeviceCapabilities(InstanceID uint32) (PlayMedia string, RecMedia string, RecQualityModes string, err error) {
	return client.GetDeviceCapabilitiesCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * NrTracks: allowed value range: minimum=0
func (client *AVTransport1) GetMediaInfoCtx(
	ctx context.Context,
	InstanceID uint32,
) (NrTracks uint32, MediaDuration string, CurrentURI string, CurrentURIMetaData string, NextURI string, NextURIMetaData string, PlayMedium string, RecordMedium string, WriteStatus string, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		NrTracks           string
		MediaDuration      string
		CurrentURI         string
		CurrentURIMetaData string
		NextURI            string
		NextURIMetaData    string
		PlayMedium         string
		RecordMedium       string
		WriteStatus        string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_1, "GetMediaInfo", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if NrTracks, err = soap.UnmarshalUi4(response.NrTracks); err != nil {
		return
	}
	if MediaDuration, err = soap.UnmarshalString(response.MediaDuration); err != nil {
		return
	}
	if CurrentURI, err = soap.UnmarshalString(response.CurrentURI); err != nil {
		return
	}
	if CurrentURIMetaData, err = soap.UnmarshalString(response.CurrentURIMetaData); err != nil {
		return
	}
	if NextURI, err = soap.UnmarshalString(response.NextURI); err != nil {
		return
	}
	if NextURIMetaData, err = soap.UnmarshalString(response.NextURIMetaData); err != nil {
		return
	}
	if PlayMedium, err = soap.UnmarshalString(response.PlayMedium); err != nil {
		return
	}
	if RecordMedium, err = soap.UnmarshalString(response.RecordMedium); err != nil {
		return
	}
	if WriteStatus, err = soap.UnmarshalString(response.WriteStatus); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetMediaInfo is the legacy version of GetMediaInfoCtx, but uses
// context.Background() as the context.
func (client *AVTransport1) GetMediaInfo(InstanceID uint32) (NrTracks uint32, MediaDuration string, CurrentURI string, CurrentURIMetaData string, NextURI string, NextURIMetaData string, PlayMedium string, RecordMedium string, WriteStatus string, err error) {
	return client.GetMediaInfoCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * Track: allowed value range: minimum=0, step=1
func (client *AVTransport1) GetPositionInfoCtx(
	ctx context.Context,
	InstanceID uint32,
) (Track uint32, TrackDuration string, TrackMetaData string, TrackURI string, RelTime string, AbsTime string, RelCount int32, AbsCount int32, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Track         string
		TrackDuration string
		TrackMetaData string
		TrackURI      string
		RelTime       string
		AbsTime       string
		RelCount      string
		AbsCount      string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_1, "GetPositionInfo", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Track, err = soap.UnmarshalUi4(response.Track); err != nil {
		return
	}
	if TrackDuration, err = soap.UnmarshalString(response.TrackDuration); err != nil {
		return
	}
	if TrackMetaData, err = soap.UnmarshalString(response.TrackMetaData); err != nil {
		return
	}
	if TrackURI, err = soap.UnmarshalString(response.TrackURI); err != nil {
		return
	}
	if RelTime, err = soap.UnmarshalString(response.RelTime); err != nil {
		return
	}
	if AbsTime, err = soap.UnmarshalString(response.AbsTime); err != nil {
		return
	}
	if RelCount, err = soap.UnmarshalI4(response.RelCount); err != nil {
		return
	}
	if AbsCount, err = soap.UnmarshalI4(response.AbsCount); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetPositionInfo is the legacy version of GetPositionInfoCtx, but uses
// context.Background() as the context.
func (client *AVTransport1) GetPositionInfo(InstanceID uint32) (Track uint32, TrackDuration string, TrackMetaData string, TrackURI string, RelTime string, AbsTime string, RelCount int32, AbsCount int32, err error) {
	return client.GetPositionInfoCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentTransportState: allowed values: STOPPED, PLAYING
//
// * CurrentTransportStatus: allowed values: OK, ERROR_OCCURRED
//
// * CurrentSpeed: allowed values: 1
func (client *AVTransport1) GetTransportInfoCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentTransportState string, CurrentTransportStatus string, CurrentSpeed string, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentTransportState  string
		CurrentTransportStatus string
		CurrentSpeed           string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_1, "GetTransportInfo", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentTransportState, err = soap.UnmarshalString(response.CurrentTransportState); err != nil {
		return
	}
	if CurrentTransportStatus, err = soap.UnmarshalString(response.CurrentTransportStatus); err != nil {
		return
	}
	if CurrentSpeed, err = soap.UnmarshalString(response.CurrentSpeed); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetTransportInfo is the legacy version of GetTransportInfoCtx, but uses
// context.Background() as the context.
func (client *AVTransport1) GetTransportInfo(InstanceID uint32) (CurrentTransportState string, CurrentTransportStatus string, CurrentSpeed string, err error) {
	return client.GetTransportInfoCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * PlayMode: allowed values: NORMAL
func (client *AVTransport1) GetTransportSettingsCtx(
	ctx context.Context,
	InstanceID uint32,
) (PlayMode string, RecQualityMode string, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		PlayMode       string
		RecQualityMode string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_1, "GetTransportSettings", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if PlayMode, err = soap.UnmarshalString(response.PlayMode); err != nil {
		return
	}
	if RecQualityMode, err = soap.UnmarshalString(response.RecQualityMode); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetTransportSettings is the legacy version of GetTransportSettingsCtx, but uses
// context.Background() as the context.
func (client *AVTransport1) GetTransportSettings(InstanceID uint32) (PlayMode string, RecQualityMode string, err error) {
	return client.GetTransportSettingsCtx(context.Background(),
		InstanceID,
	)
}

func (client *AVTransport1) NextCtx(
	ctx context.Context,
	InstanceID uint32,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_1, "Next", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// Next is the legacy version of NextCtx, but uses
// context.Background() as the context.
func (client *AVTransport1) Next(InstanceID uint32) (err error) {
	return client.NextCtx(context.Background(),
		InstanceID,
	)
}

func (client *AVTransport1) PauseCtx(
	ctx context.Context,
	InstanceID uint32,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_1, "Pause", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// Pause is the legacy version of PauseCtx, but uses
// context.Background() as the context.
func (client *AVTransport1) Pause(InstanceID uint32) (err error) {
	return client.PauseCtx(context.Background(),
		InstanceID,
	)
}

//
// Arguments:
//
// * Speed: allowed values: 1

func (client *AVTransport1) PlayCtx(
	ctx context.Context,
	InstanceID uint32,
	Speed string,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID string
		Speed      string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Speed, err = soap.MarshalString(Speed); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_1, "Play", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// Play is the legacy version of PlayCtx, but uses
// context.Background() as the context.
func (client *AVTransport1) Play(InstanceID uint32, Speed string) (err error) {
	return client.PlayCtx(context.Background(),
		InstanceID,
		Speed,
	)
}

func (client *AVTransport1) PreviousCtx(
	ctx context.Context,
	InstanceID uint32,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_1, "Previous", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// Previous is the legacy version of PreviousCtx, but uses
// context.Background() as the context.
func (client *AVTransport1) Previous(InstanceID uint32) (err error) {
	return client.PreviousCtx(context.Background(),
		InstanceID,
	)
}

func (client *AVTransport1) RecordCtx(
	ctx context.Context,
	InstanceID uint32,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_1, "Record", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// Record is the legacy version of RecordCtx, but uses
// context.Background() as the context.
func (client *AVTransport1) Record(InstanceID uint32) (err error) {
	return client.RecordCtx(context.Background(),
		InstanceID,
	)
}

//
// Arguments:
//
// * Unit: allowed values: TRACK_NR

func (client *AVTransport1) SeekCtx(
	ctx context.Context,
	InstanceID uint32,
	Unit string,
	Target string,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID string
		Unit       string
		Target     string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Unit, err = soap.MarshalString(Unit); err != nil {
		return
	}
	if request.Target, err = soap.MarshalString(Target); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_1, "Seek", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// Seek is the legacy version of SeekCtx, but uses
// context.Background() as the context.
func (client *AVTransport1) Seek(InstanceID uint32, Unit string, Target string) (err error) {
	return client.SeekCtx(context.Background(),
		InstanceID,
		Unit,
		Target,
	)
}

func (client *AVTransport1) SetAVTransportURICtx(
	ctx context.Context,
	InstanceID uint32,
	CurrentURI string,
	CurrentURIMetaData string,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID         string
		CurrentURI         string
		CurrentURIMetaData string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.CurrentURI, err = soap.MarshalString(CurrentURI); err != nil {
		return
	}
	if request.CurrentURIMetaData, err = soap.MarshalString(CurrentURIMetaData); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_1, "SetAVTransportURI", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetAVTransportURI is the legacy version of SetAVTransportURICtx, but uses
// context.Background() as the context.
func (client *AVTransport1) SetAVTransportURI(InstanceID uint32, CurrentURI string, CurrentURIMetaData string) (err error) {
	return client.SetAVTransportURICtx(context.Background(),
		InstanceID,
		CurrentURI,
		CurrentURIMetaData,
	)
}

func (client *AVTransport1) SetNextAVTransportURICtx(
	ctx context.Context,
	InstanceID uint32,
	NextURI string,
	NextURIMetaData string,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID      string
		NextURI         string
		NextURIMetaData string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.NextURI, err = soap.MarshalString(NextURI); err != nil {
		return
	}
	if request.NextURIMetaData, err = soap.MarshalString(NextURIMetaData); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_1, "SetNextAVTransportURI", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetNextAVTransportURI is the legacy version of SetNextAVTransportURICtx, but uses
// context.Background() as the context.
func (client *AVTransport1) SetNextAVTransportURI(InstanceID uint32, NextURI string, NextURIMetaData string) (err error) {
	return client.SetNextAVTransportURICtx(context.Background(),
		InstanceID,
		NextURI,
		NextURIMetaData,
	)
}

//
// Arguments:
//
// * NewPlayMode: allowed values: NORMAL

func (client *AVTransport1) SetPlayModeCtx(
	ctx context.Context,
	InstanceID uint32,
	NewPlayMode string,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID  string
		NewPlayMode string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.NewPlayMode, err = soap.MarshalString(NewPlayMode); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_1, "SetPlayMode", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetPlayMode is the legacy version of SetPlayModeCtx, but uses
// context.Background() as the context.
func (client *AVTransport1) SetPlayMode(InstanceID uint32, NewPlayMode string) (err error) {
	return client.SetPlayModeCtx(context.Background(),
		InstanceID,
		NewPlayMode,
	)
}

func (client *AVTransport1) SetRecordQualityModeCtx(
	ctx context.Context,
	InstanceID uint32,
	NewRecordQualityMode string,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID           string
		NewRecordQualityMode string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.NewRecordQualityMode, err = soap.MarshalString(NewRecordQualityMode); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_1, "SetRecordQualityMode", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetRecordQualityMode is the legacy version of SetRecordQualityModeCtx, but uses
// context.Background() as the context.
func (client *AVTransport1) SetRecordQualityMode(InstanceID uint32, NewRecordQualityMode string) (err error) {
	return client.SetRecordQualityModeCtx(context.Background(),
		InstanceID,
		NewRecordQualityMode,
	)
}

func (client *AVTransport1) StopCtx(
	ctx context.Context,
	InstanceID uint32,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_1, "Stop", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// Stop is the legacy version of StopCtx, but uses
// context.Background() as the context.
func (client *AVTransport1) Stop(InstanceID uint32) (err error) {
	return client.StopCtx(context.Background(),
		InstanceID,
	)
}

// AVTransport2 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:AVTransport:2". See
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
// are provided for informational value.
type AVTransport2 struct {
	goupnp.ServiceClient
}

// NewAVTransport2ClientsCtx discovers instances of the service on the network,
// and returns clients to any that are found. errors will contain an error for
// any devices that replied but which could not be queried, and err will be set
// if the discovery process failed outright.
//
// This is a typical entry calling point into this package.
func NewAVTransport2ClientsCtx(ctx context.Context) (clients []*AVTransport2, errors []error, err error) {
	var genericClients []goupnp.ServiceClient
	if genericClients, errors, err = goupnp.NewServiceClientsCtx(ctx, URN_AVTransport_2); err != nil {
		return
	}
	clients = newAVTransport2ClientsFromGenericClients(genericClients)
	return
}

// NewAVTransport2Clients is the legacy version of NewAVTransport2ClientsCtx, but uses
// context.Background() as the context.
func NewAVTransport2Clients() (clients []*AVTransport2, errors []error, err error) {
	return NewAVTransport2ClientsCtx(context.Background())
}

// NewAVTransport2ClientsByURLCtx discovers instances of the service at the given
// URL, and returns clients to any that are found. An error is returned if
// there was an error probing the service.
//
// This is a typical entry calling point into this package when reusing an
// previously discovered service URL.
func NewAVTransport2ClientsByURLCtx(ctx context.Context, loc *url.URL) ([]*AVTransport2, error) {
	genericClients, err := goupnp.NewServiceClientsByURLCtx(ctx, loc, URN_AVTransport_2)
	if err != nil {
		return nil, err
	}
	return newAVTransport2ClientsFromGenericClients(genericClients), nil
}

// NewAVTransport2ClientsByURL is the legacy version of NewAVTransport2ClientsByURLCtx, but uses
// context.Background() as the context.
func NewAVTransport2ClientsByURL(loc *url.URL) ([]*AVTransport2, error) {
	return NewAVTransport2ClientsByURLCtx(context.Background(), loc)
}

// NewAVTransport2ClientsFromRootDevice discovers instances of the service in
// a given root device, and returns clients to any that are found. An error is
// returned if there was not at least one instance of the service within the
// device. The location parameter is simply assigned to the Location attribute
// of the wrapped ServiceClient(s).
//
// This is a typical entry calling point into this package when reusing an
// previously discovered root device.
func NewAVTransport2ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*AVTransport2, error) {
	genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_AVTransport_2)
	if err != nil {
		return nil, err
	}
	return newAVTransport2ClientsFromGenericClients(genericClients), nil
}

func newAVTransport2ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*AVTransport2 {
	clients := make([]*AVTransport2, len(genericClients))
	for i := range genericClients {
		clients[i] = &AVTransport2{genericClients[i]}
	}
	return clients
}

func (client *AVTransport2) GetCurrentTransportActionsCtx(
	ctx context.Context,
	InstanceID uint32,
) (Actions string, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Actions string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "GetCurrentTransportActions", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Actions, err = soap.UnmarshalString(response.Actions); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetCurrentTransportActions is the legacy version of GetCurrentTransportActionsCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) GetCurrentTransportActions(InstanceID uint32) (Actions string, err error) {
	return client.GetCurrentTransportActionsCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentDRMState: allowed values: OK
func (client *AVTransport2) GetDRMStateCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentDRMState string, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentDRMState string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "GetDRMState", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentDRMState, err = soap.UnmarshalString(response.CurrentDRMState); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetDRMState is the legacy version of GetDRMStateCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) GetDRMState(InstanceID uint32) (CurrentDRMState string, err error) {
	return client.GetDRMStateCtx(context.Background(),
		InstanceID,
	)
}

func (client *AVTransport2) GetDeviceCapabilitiesCtx(
	ctx context.Context,
	InstanceID uint32,
) (PlayMedia string, RecMedia string, RecQualityModes string, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		PlayMedia       string
		RecMedia        string
		RecQualityModes string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "GetDeviceCapabilities", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if PlayMedia, err = soap.UnmarshalString(response.PlayMedia); err != nil {
		return
	}
	if RecMedia, err = soap.UnmarshalString(response.RecMedia); err != nil {
		return
	}
	if RecQualityModes, err = soap.UnmarshalString(response.RecQualityModes); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetDeviceCapabilities is the legacy version of GetDeviceCapabilitiesCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) GetDeviceCapabilities(InstanceID uint32) (PlayMedia string, RecMedia string, RecQualityModes string, err error) {
	return client.GetDeviceCapabilitiesCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * NrTracks: allowed value range: minimum=0
func (client *AVTransport2) GetMediaInfoCtx(
	ctx context.Context,
	InstanceID uint32,
) (NrTracks uint32, MediaDuration string, CurrentURI string, CurrentURIMetaData string, NextURI string, NextURIMetaData string, PlayMedium string, RecordMedium string, WriteStatus string, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		NrTracks           string
		MediaDuration      string
		CurrentURI         string
		CurrentURIMetaData string
		NextURI            string
		NextURIMetaData    string
		PlayMedium         string
		RecordMedium       string
		WriteStatus        string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "GetMediaInfo", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if NrTracks, err = soap.UnmarshalUi4(response.NrTracks); err != nil {
		return
	}
	if MediaDuration, err = soap.UnmarshalString(response.MediaDuration); err != nil {
		return
	}
	if CurrentURI, err = soap.UnmarshalString(response.CurrentURI); err != nil {
		return
	}
	if CurrentURIMetaData, err = soap.UnmarshalString(response.CurrentURIMetaData); err != nil {
		return
	}
	if NextURI, err = soap.UnmarshalString(response.NextURI); err != nil {
		return
	}
	if NextURIMetaData, err = soap.UnmarshalString(response.NextURIMetaData); err != nil {
		return
	}
	if PlayMedium, err = soap.UnmarshalString(response.PlayMedium); err != nil {
		return
	}
	if RecordMedium, err = soap.UnmarshalString(response.RecordMedium); err != nil {
		return
	}
	if WriteStatus, err = soap.UnmarshalString(response.WriteStatus); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetMediaInfo is the legacy version of GetMediaInfoCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) GetMediaInfo(InstanceID uint32) (NrTracks uint32, MediaDuration string, CurrentURI string, CurrentURIMetaData string, NextURI string, NextURIMetaData string, PlayMedium string, RecordMedium string, WriteStatus string, err error) {
	return client.GetMediaInfoCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentType: allowed values: NO_MEDIA, TRACK_AWARE, TRACK_UNAWARE
//
// * NrTracks: allowed value range: minimum=0
func (client *AVTransport2) GetMediaInfo_ExtCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentType string, NrTracks uint32, MediaDuration string, CurrentURI string, CurrentURIMetaData string, NextURI string, NextURIMetaData string, PlayMedium string, RecordMedium string, WriteStatus string, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentType        string
		NrTracks           string
		MediaDuration      string
		CurrentURI         string
		CurrentURIMetaData string
		NextURI            string
		NextURIMetaData    string
		PlayMedium         string
		RecordMedium       string
		WriteStatus        string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "GetMediaInfo_Ext", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentType, err = soap.UnmarshalString(response.CurrentType); err != nil {
		return
	}
	if NrTracks, err = soap.UnmarshalUi4(response.NrTracks); err != nil {
		return
	}
	if MediaDuration, err = soap.UnmarshalString(response.MediaDuration); err != nil {
		return
	}
	if CurrentURI, err = soap.UnmarshalString(response.CurrentURI); err != nil {
		return
	}
	if CurrentURIMetaData, err = soap.UnmarshalString(response.CurrentURIMetaData); err != nil {
		return
	}
	if NextURI, err = soap.UnmarshalString(response.NextURI); err != nil {
		return
	}
	if NextURIMetaData, err = soap.UnmarshalString(response.NextURIMetaData); err != nil {
		return
	}
	if PlayMedium, err = soap.UnmarshalString(response.PlayMedium); err != nil {
		return
	}
	if RecordMedium, err = soap.UnmarshalString(response.RecordMedium); err != nil {
		return
	}
	if WriteStatus, err = soap.UnmarshalString(response.WriteStatus); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetMediaInfo_Ext is the legacy version of GetMediaInfo_ExtCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) GetMediaInfo_Ext(InstanceID uint32) (CurrentType string, NrTracks uint32, MediaDuration string, CurrentURI string, CurrentURIMetaData string, NextURI string, NextURIMetaData string, PlayMedium string, RecordMedium string, WriteStatus string, err error) {
	return client.GetMediaInfo_ExtCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * Track: allowed value range: minimum=0, step=1
func (client *AVTransport2) GetPositionInfoCtx(
	ctx context.Context,
	InstanceID uint32,
) (Track uint32, TrackDuration string, TrackMetaData string, TrackURI string, RelTime string, AbsTime string, RelCount int32, AbsCount int32, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Track         string
		TrackDuration string
		TrackMetaData string
		TrackURI      string
		RelTime       string
		AbsTime       string
		RelCount      string
		AbsCount      string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "GetPositionInfo", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Track, err = soap.UnmarshalUi4(response.Track); err != nil {
		return
	}
	if TrackDuration, err = soap.UnmarshalString(response.TrackDuration); err != nil {
		return
	}
	if TrackMetaData, err = soap.UnmarshalString(response.TrackMetaData); err != nil {
		return
	}
	if TrackURI, err = soap.UnmarshalString(response.TrackURI); err != nil {
		return
	}
	if RelTime, err = soap.UnmarshalString(response.RelTime); err != nil {
		return
	}
	if AbsTime, err = soap.UnmarshalString(response.AbsTime); err != nil {
		return
	}
	if RelCount, err = soap.UnmarshalI4(response.RelCount); err != nil {
		return
	}
	if AbsCount, err = soap.UnmarshalI4(response.AbsCount); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetPositionInfo is the legacy version of GetPositionInfoCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) GetPositionInfo(InstanceID uint32) (Track uint32, TrackDuration string, TrackMetaData string, TrackURI string, RelTime string, AbsTime string, RelCount int32, AbsCount int32, err error) {
	return client.GetPositionInfoCtx(context.Background(),
		InstanceID,
	)
}

func (client *AVTransport2) GetStateVariablesCtx(
	ctx context.Context,
	InstanceID uint32,
	StateVariableList string,
) (StateVariableValuePairs string, err error) {
	// Request structure.
	request := &struct {
		InstanceID        string
		StateVariableList string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.StateVariableList, err = soap.MarshalString(StateVariableList); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		StateVariableValuePairs string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "GetStateVariables", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if StateVariableValuePairs, err = soap.UnmarshalString(response.StateVariableValuePairs); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetStateVariables is the legacy version of GetStateVariablesCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) GetStateVariables(InstanceID uint32, StateVariableList string) (StateVariableValuePairs string, err error) {
	return client.GetStateVariablesCtx(context.Background(),
		InstanceID,
		StateVariableList,
	)
}

// Return values:
//
// * CurrentTransportState: allowed values: STOPPED, PLAYING
//
// * CurrentTransportStatus: allowed values: OK, ERROR_OCCURRED
//
// * CurrentSpeed: allowed values: 1
func (client *AVTransport2) GetTransportInfoCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentTransportState string, CurrentTransportStatus string, CurrentSpeed string, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentTransportState  string
		CurrentTransportStatus string
		CurrentSpeed           string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "GetTransportInfo", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentTransportState, err = soap.UnmarshalString(response.CurrentTransportState); err != nil {
		return
	}
	if CurrentTransportStatus, err = soap.UnmarshalString(response.CurrentTransportStatus); err != nil {
		return
	}
	if CurrentSpeed, err = soap.UnmarshalString(response.CurrentSpeed); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetTransportInfo is the legacy version of GetTransportInfoCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) GetTransportInfo(InstanceID uint32) (CurrentTransportState string, CurrentTransportStatus string, CurrentSpeed string, err error) {
	return client.GetTransportInfoCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * PlayMode: allowed values: NORMAL
func (client *AVTransport2) GetTransportSettingsCtx(
	ctx context.Context,
	InstanceID uint32,
) (PlayMode string, RecQualityMode string, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		PlayMode       string
		RecQualityMode string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "GetTransportSettings", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if PlayMode, err = soap.UnmarshalString(response.PlayMode); err != nil {
		return
	}
	if RecQualityMode, err = soap.UnmarshalString(response.RecQualityMode); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetTransportSettings is the legacy version of GetTransportSettingsCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) GetTransportSettings(InstanceID uint32) (PlayMode string, RecQualityMode string, err error) {
	return client.GetTransportSettingsCtx(context.Background(),
		InstanceID,
	)
}

func (client *AVTransport2) NextCtx(
	ctx context.Context,
	InstanceID uint32,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "Next", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// Next is the legacy version of NextCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) Next(InstanceID uint32) (err error) {
	return client.NextCtx(context.Background(),
		InstanceID,
	)
}

func (client *AVTransport2) PauseCtx(
	ctx context.Context,
	InstanceID uint32,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "Pause", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// Pause is the legacy version of PauseCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) Pause(InstanceID uint32) (err error) {
	return client.PauseCtx(context.Background(),
		InstanceID,
	)
}

//
// Arguments:
//
// * Speed: allowed values: 1

func (client *AVTransport2) PlayCtx(
	ctx context.Context,
	InstanceID uint32,
	Speed string,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID string
		Speed      string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Speed, err = soap.MarshalString(Speed); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "Play", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// Play is the legacy version of PlayCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) Play(InstanceID uint32, Speed string) (err error) {
	return client.PlayCtx(context.Background(),
		InstanceID,
		Speed,
	)
}

func (client *AVTransport2) PreviousCtx(
	ctx context.Context,
	InstanceID uint32,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "Previous", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// Previous is the legacy version of PreviousCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) Previous(InstanceID uint32) (err error) {
	return client.PreviousCtx(context.Background(),
		InstanceID,
	)
}

func (client *AVTransport2) RecordCtx(
	ctx context.Context,
	InstanceID uint32,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "Record", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// Record is the legacy version of RecordCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) Record(InstanceID uint32) (err error) {
	return client.RecordCtx(context.Background(),
		InstanceID,
	)
}

//
// Arguments:
//
// * Unit: allowed values: TRACK_NR

func (client *AVTransport2) SeekCtx(
	ctx context.Context,
	InstanceID uint32,
	Unit string,
	Target string,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID string
		Unit       string
		Target     string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Unit, err = soap.MarshalString(Unit); err != nil {
		return
	}
	if request.Target, err = soap.MarshalString(Target); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "Seek", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// Seek is the legacy version of SeekCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) Seek(InstanceID uint32, Unit string, Target string) (err error) {
	return client.SeekCtx(context.Background(),
		InstanceID,
		Unit,
		Target,
	)
}

func (client *AVTransport2) SetAVTransportURICtx(
	ctx context.Context,
	InstanceID uint32,
	CurrentURI string,
	CurrentURIMetaData string,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID         string
		CurrentURI         string
		CurrentURIMetaData string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.CurrentURI, err = soap.MarshalString(CurrentURI); err != nil {
		return
	}
	if request.CurrentURIMetaData, err = soap.MarshalString(CurrentURIMetaData); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "SetAVTransportURI", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetAVTransportURI is the legacy version of SetAVTransportURICtx, but uses
// context.Background() as the context.
func (client *AVTransport2) SetAVTransportURI(InstanceID uint32, CurrentURI string, CurrentURIMetaData string) (err error) {
	return client.SetAVTransportURICtx(context.Background(),
		InstanceID,
		CurrentURI,
		CurrentURIMetaData,
	)
}

func (client *AVTransport2) SetNextAVTransportURICtx(
	ctx context.Context,
	InstanceID uint32,
	NextURI string,
	NextURIMetaData string,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID      string
		NextURI         string
		NextURIMetaData string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.NextURI, err = soap.MarshalString(NextURI); err != nil {
		return
	}
	if request.NextURIMetaData, err = soap.MarshalString(NextURIMetaData); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "SetNextAVTransportURI", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetNextAVTransportURI is the legacy version of SetNextAVTransportURICtx, but uses
// context.Background() as the context.
func (client *AVTransport2) SetNextAVTransportURI(InstanceID uint32, NextURI string, NextURIMetaData string) (err error) {
	return client.SetNextAVTransportURICtx(context.Background(),
		InstanceID,
		NextURI,
		NextURIMetaData,
	)
}

//
// Arguments:
//
// * NewPlayMode: allowed values: NORMAL

func (client *AVTransport2) SetPlayModeCtx(
	ctx context.Context,
	InstanceID uint32,
	NewPlayMode string,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID  string
		NewPlayMode string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.NewPlayMode, err = soap.MarshalString(NewPlayMode); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "SetPlayMode", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetPlayMode is the legacy version of SetPlayModeCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) SetPlayMode(InstanceID uint32, NewPlayMode string) (err error) {
	return client.SetPlayModeCtx(context.Background(),
		InstanceID,
		NewPlayMode,
	)
}

func (client *AVTransport2) SetRecordQualityModeCtx(
	ctx context.Context,
	InstanceID uint32,
	NewRecordQualityMode string,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID           string
		NewRecordQualityMode string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.NewRecordQualityMode, err = soap.MarshalString(NewRecordQualityMode); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "SetRecordQualityMode", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetRecordQualityMode is the legacy version of SetRecordQualityModeCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) SetRecordQualityMode(InstanceID uint32, NewRecordQualityMode string) (err error) {
	return client.SetRecordQualityModeCtx(context.Background(),
		InstanceID,
		NewRecordQualityMode,
	)
}

func (client *AVTransport2) SetStateVariablesCtx(
	ctx context.Context,
	InstanceID uint32,
	AVTransportUDN string,
	ServiceType string,
	ServiceId string,
	StateVariableValuePairs string,
) (StateVariableList string, err error) {
	// Request structure.
	request := &struct {
		InstanceID              string
		AVTransportUDN          string
		ServiceType             string
		ServiceId               string
		StateVariableValuePairs string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.AVTransportUDN, err = soap.MarshalString(AVTransportUDN); err != nil {
		return
	}
	if request.ServiceType, err = soap.MarshalString(ServiceType); err != nil {
		return
	}
	if request.ServiceId, err = soap.MarshalString(ServiceId); err != nil {
		return
	}
	if request.StateVariableValuePairs, err = soap.MarshalString(StateVariableValuePairs); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		StateVariableList string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "SetStateVariables", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if StateVariableList, err = soap.UnmarshalString(response.StateVariableList); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// SetStateVariables is the legacy version of SetStateVariablesCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) SetStateVariables(InstanceID uint32, AVTransportUDN string, ServiceType string, ServiceId string, StateVariableValuePairs string) (StateVariableList string, err error) {
	return client.SetStateVariablesCtx(context.Background(),
		InstanceID,
		AVTransportUDN,
		ServiceType,
		ServiceId,
		StateVariableValuePairs,
	)
}

func (client *AVTransport2) StopCtx(
	ctx context.Context,
	InstanceID uint32,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_AVTransport_2, "Stop", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// Stop is the legacy version of StopCtx, but uses
// context.Background() as the context.
func (client *AVTransport2) Stop(InstanceID uint32) (err error) {
	return client.StopCtx(context.Background(),
		InstanceID,
	)
}

// ConnectionManager1 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:ConnectionManager:1". See
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
// are provided for informational value.
type ConnectionManager1 struct {
	goupnp.ServiceClient
}

// NewConnectionManager1ClientsCtx discovers instances of the service on the network,
// and returns clients to any that are found. errors will contain an error for
// any devices that replied but which could not be queried, and err will be set
// if the discovery process failed outright.
//
// This is a typical entry calling point into this package.
func NewConnectionManager1ClientsCtx(ctx context.Context) (clients []*ConnectionManager1, errors []error, err error) {
	var genericClients []goupnp.ServiceClient
	if genericClients, errors, err = goupnp.NewServiceClientsCtx(ctx, URN_ConnectionManager_1); err != nil {
		return
	}
	clients = newConnectionManager1ClientsFromGenericClients(genericClients)
	return
}

// NewConnectionManager1Clients is the legacy version of NewConnectionManager1ClientsCtx, but uses
// context.Background() as the context.
func NewConnectionManager1Clients() (clients []*ConnectionManager1, errors []error, err error) {
	return NewConnectionManager1ClientsCtx(context.Background())
}

// NewConnectionManager1ClientsByURLCtx discovers instances of the service at the given
// URL, and returns clients to any that are found. An error is returned if
// there was an error probing the service.
//
// This is a typical entry calling point into this package when reusing an
// previously discovered service URL.
func NewConnectionManager1ClientsByURLCtx(ctx context.Context, loc *url.URL) ([]*ConnectionManager1, error) {
	genericClients, err := goupnp.NewServiceClientsByURLCtx(ctx, loc, URN_ConnectionManager_1)
	if err != nil {
		return nil, err
	}
	return newConnectionManager1ClientsFromGenericClients(genericClients), nil
}

// NewConnectionManager1ClientsByURL is the legacy version of NewConnectionManager1ClientsByURLCtx, but uses
// context.Background() as the context.
func NewConnectionManager1ClientsByURL(loc *url.URL) ([]*ConnectionManager1, error) {
	return NewConnectionManager1ClientsByURLCtx(context.Background(), loc)
}

// NewConnectionManager1ClientsFromRootDevice discovers instances of the service in
// a given root device, and returns clients to any that are found. An error is
// returned if there was not at least one instance of the service within the
// device. The location parameter is simply assigned to the Location attribute
// of the wrapped ServiceClient(s).
//
// This is a typical entry calling point into this package when reusing an
// previously discovered root device.
func NewConnectionManager1ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*ConnectionManager1, error) {
	genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_ConnectionManager_1)
	if err != nil {
		return nil, err
	}
	return newConnectionManager1ClientsFromGenericClients(genericClients), nil
}

func newConnectionManager1ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*ConnectionManager1 {
	clients := make([]*ConnectionManager1, len(genericClients))
	for i := range genericClients {
		clients[i] = &ConnectionManager1{genericClients[i]}
	}
	return clients
}

func (client *ConnectionManager1) ConnectionCompleteCtx(
	ctx context.Context,
	ConnectionID int32,
) (err error) {
	// Request structure.
	request := &struct {
		ConnectionID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ConnectionID, err = soap.MarshalI4(ConnectionID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ConnectionManager_1, "ConnectionComplete", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// ConnectionComplete is the legacy version of ConnectionCompleteCtx, but uses
// context.Background() as the context.
func (client *ConnectionManager1) ConnectionComplete(ConnectionID int32) (err error) {
	return client.ConnectionCompleteCtx(context.Background(),
		ConnectionID,
	)
}

func (client *ConnectionManager1) GetCurrentConnectionIDsCtx(
	ctx context.Context,
) (ConnectionIDs string, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		ConnectionIDs string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ConnectionManager_1, "GetCurrentConnectionIDs", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if ConnectionIDs, err = soap.UnmarshalString(response.ConnectionIDs); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetCurrentConnectionIDs is the legacy version of GetCurrentConnectionIDsCtx, but uses
// context.Background() as the context.
func (client *ConnectionManager1) GetCurrentConnectionIDs() (ConnectionIDs string, err error) {
	return client.GetCurrentConnectionIDsCtx(context.Background())
}

// Return values:
//
// * Direction: allowed values: Input, Output
//
// * Status: allowed values: OK, ContentFormatMismatch, InsufficientBandwidth, UnreliableChannel, Unknown
func (client *ConnectionManager1) GetCurrentConnectionInfoCtx(
	ctx context.Context,
	ConnectionID int32,
) (RcsID int32, AVTransportID int32, ProtocolInfo string, PeerConnectionManager string, PeerConnectionID int32, Direction string, Status string, err error) {
	// Request structure.
	request := &struct {
		ConnectionID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ConnectionID, err = soap.MarshalI4(ConnectionID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		RcsID                 string
		AVTransportID         string
		ProtocolInfo          string
		PeerConnectionManager string
		PeerConnectionID      string
		Direction             string
		Status                string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ConnectionManager_1, "GetCurrentConnectionInfo", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if RcsID, err = soap.UnmarshalI4(response.RcsID); err != nil {
		return
	}
	if AVTransportID, err = soap.UnmarshalI4(response.AVTransportID); err != nil {
		return
	}
	if ProtocolInfo, err = soap.UnmarshalString(response.ProtocolInfo); err != nil {
		return
	}
	if PeerConnectionManager, err = soap.UnmarshalString(response.PeerConnectionManager); err != nil {
		return
	}
	if PeerConnectionID, err = soap.UnmarshalI4(response.PeerConnectionID); err != nil {
		return
	}
	if Direction, err = soap.UnmarshalString(response.Direction); err != nil {
		return
	}
	if Status, err = soap.UnmarshalString(response.Status); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetCurrentConnectionInfo is the legacy version of GetCurrentConnectionInfoCtx, but uses
// context.Background() as the context.
func (client *ConnectionManager1) GetCurrentConnectionInfo(ConnectionID int32) (RcsID int32, AVTransportID int32, ProtocolInfo string, PeerConnectionManager string, PeerConnectionID int32, Direction string, Status string, err error) {
	return client.GetCurrentConnectionInfoCtx(context.Background(),
		ConnectionID,
	)
}

func (client *ConnectionManager1) GetProtocolInfoCtx(
	ctx context.Context,
) (Source string, Sink string, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Source string
		Sink   string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ConnectionManager_1, "GetProtocolInfo", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Source, err = soap.UnmarshalString(response.Source); err != nil {
		return
	}
	if Sink, err = soap.UnmarshalString(response.Sink); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetProtocolInfo is the legacy version of GetProtocolInfoCtx, but uses
// context.Background() as the context.
func (client *ConnectionManager1) GetProtocolInfo() (Source string, Sink string, err error) {
	return client.GetProtocolInfoCtx(context.Background())
}

//
// Arguments:
//
// * Direction: allowed values: Input, Output

func (client *ConnectionManager1) PrepareForConnectionCtx(
	ctx context.Context,
	RemoteProtocolInfo string,
	PeerConnectionManager string,
	PeerConnectionID int32,
	Direction string,
) (ConnectionID int32, AVTransportID int32, RcsID int32, err error) {
	// Request structure.
	request := &struct {
		RemoteProtocolInfo    string
		PeerConnectionManager string
		PeerConnectionID      string
		Direction             string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RemoteProtocolInfo, err = soap.MarshalString(RemoteProtocolInfo); err != nil {
		return
	}
	if request.PeerConnectionManager, err = soap.MarshalString(PeerConnectionManager); err != nil {
		return
	}
	if request.PeerConnectionID, err = soap.MarshalI4(PeerConnectionID); err != nil {
		return
	}
	if request.Direction, err = soap.MarshalString(Direction); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		ConnectionID  string
		AVTransportID string
		RcsID         string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ConnectionManager_1, "PrepareForConnection", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if ConnectionID, err = soap.UnmarshalI4(response.ConnectionID); err != nil {
		return
	}
	if AVTransportID, err = soap.UnmarshalI4(response.AVTransportID); err != nil {
		return
	}
	if RcsID, err = soap.UnmarshalI4(response.RcsID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// PrepareForConnection is the legacy version of PrepareForConnectionCtx, but uses
// context.Background() as the context.
func (client *ConnectionManager1) PrepareForConnection(RemoteProtocolInfo string, PeerConnectionManager string, PeerConnectionID int32, Direction string) (ConnectionID int32, AVTransportID int32, RcsID int32, err error) {
	return client.PrepareForConnectionCtx(context.Background(),
		RemoteProtocolInfo,
		PeerConnectionManager,
		PeerConnectionID,
		Direction,
	)
}

// ConnectionManager2 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:ConnectionManager:2". See
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
// are provided for informational value.
type ConnectionManager2 struct {
	goupnp.ServiceClient
}

// NewConnectionManager2ClientsCtx discovers instances of the service on the network,
// and returns clients to any that are found. errors will contain an error for
// any devices that replied but which could not be queried, and err will be set
// if the discovery process failed outright.
//
// This is a typical entry calling point into this package.
func NewConnectionManager2ClientsCtx(ctx context.Context) (clients []*ConnectionManager2, errors []error, err error) {
	var genericClients []goupnp.ServiceClient
	if genericClients, errors, err = goupnp.NewServiceClientsCtx(ctx, URN_ConnectionManager_2); err != nil {
		return
	}
	clients = newConnectionManager2ClientsFromGenericClients(genericClients)
	return
}

// NewConnectionManager2Clients is the legacy version of NewConnectionManager2ClientsCtx, but uses
// context.Background() as the context.
func NewConnectionManager2Clients() (clients []*ConnectionManager2, errors []error, err error) {
	return NewConnectionManager2ClientsCtx(context.Background())
}

// NewConnectionManager2ClientsByURLCtx discovers instances of the service at the given
// URL, and returns clients to any that are found. An error is returned if
// there was an error probing the service.
//
// This is a typical entry calling point into this package when reusing an
// previously discovered service URL.
func NewConnectionManager2ClientsByURLCtx(ctx context.Context, loc *url.URL) ([]*ConnectionManager2, error) {
	genericClients, err := goupnp.NewServiceClientsByURLCtx(ctx, loc, URN_ConnectionManager_2)
	if err != nil {
		return nil, err
	}
	return newConnectionManager2ClientsFromGenericClients(genericClients), nil
}

// NewConnectionManager2ClientsByURL is the legacy version of NewConnectionManager2ClientsByURLCtx, but uses
// context.Background() as the context.
func NewConnectionManager2ClientsByURL(loc *url.URL) ([]*ConnectionManager2, error) {
	return NewConnectionManager2ClientsByURLCtx(context.Background(), loc)
}

// NewConnectionManager2ClientsFromRootDevice discovers instances of the service in
// a given root device, and returns clients to any that are found. An error is
// returned if there was not at least one instance of the service within the
// device. The location parameter is simply assigned to the Location attribute
// of the wrapped ServiceClient(s).
//
// This is a typical entry calling point into this package when reusing an
// previously discovered root device.
func NewConnectionManager2ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*ConnectionManager2, error) {
	genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_ConnectionManager_2)
	if err != nil {
		return nil, err
	}
	return newConnectionManager2ClientsFromGenericClients(genericClients), nil
}

func newConnectionManager2ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*ConnectionManager2 {
	clients := make([]*ConnectionManager2, len(genericClients))
	for i := range genericClients {
		clients[i] = &ConnectionManager2{genericClients[i]}
	}
	return clients
}

func (client *ConnectionManager2) ConnectionCompleteCtx(
	ctx context.Context,
	ConnectionID int32,
) (err error) {
	// Request structure.
	request := &struct {
		ConnectionID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ConnectionID, err = soap.MarshalI4(ConnectionID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ConnectionManager_2, "ConnectionComplete", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// ConnectionComplete is the legacy version of ConnectionCompleteCtx, but uses
// context.Background() as the context.
func (client *ConnectionManager2) ConnectionComplete(ConnectionID int32) (err error) {
	return client.ConnectionCompleteCtx(context.Background(),
		ConnectionID,
	)
}

func (client *ConnectionManager2) GetCurrentConnectionIDsCtx(
	ctx context.Context,
) (ConnectionIDs string, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		ConnectionIDs string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ConnectionManager_2, "GetCurrentConnectionIDs", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if ConnectionIDs, err = soap.UnmarshalString(response.ConnectionIDs); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetCurrentConnectionIDs is the legacy version of GetCurrentConnectionIDsCtx, but uses
// context.Background() as the context.
func (client *ConnectionManager2) GetCurrentConnectionIDs() (ConnectionIDs string, err error) {
	return client.GetCurrentConnectionIDsCtx(context.Background())
}

// Return values:
//
// * Direction: allowed values: Input, Output
//
// * Status: allowed values: OK, ContentFormatMismatch, InsufficientBandwidth, UnreliableChannel, Unknown
func (client *ConnectionManager2) GetCurrentConnectionInfoCtx(
	ctx context.Context,
	ConnectionID int32,
) (RcsID int32, AVTransportID int32, ProtocolInfo string, PeerConnectionManager string, PeerConnectionID int32, Direction string, Status string, err error) {
	// Request structure.
	request := &struct {
		ConnectionID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ConnectionID, err = soap.MarshalI4(ConnectionID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		RcsID                 string
		AVTransportID         string
		ProtocolInfo          string
		PeerConnectionManager string
		PeerConnectionID      string
		Direction             string
		Status                string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ConnectionManager_2, "GetCurrentConnectionInfo", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if RcsID, err = soap.UnmarshalI4(response.RcsID); err != nil {
		return
	}
	if AVTransportID, err = soap.UnmarshalI4(response.AVTransportID); err != nil {
		return
	}
	if ProtocolInfo, err = soap.UnmarshalString(response.ProtocolInfo); err != nil {
		return
	}
	if PeerConnectionManager, err = soap.UnmarshalString(response.PeerConnectionManager); err != nil {
		return
	}
	if PeerConnectionID, err = soap.UnmarshalI4(response.PeerConnectionID); err != nil {
		return
	}
	if Direction, err = soap.UnmarshalString(response.Direction); err != nil {
		return
	}
	if Status, err = soap.UnmarshalString(response.Status); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetCurrentConnectionInfo is the legacy version of GetCurrentConnectionInfoCtx, but uses
// context.Background() as the context.
func (client *ConnectionManager2) GetCurrentConnectionInfo(ConnectionID int32) (RcsID int32, AVTransportID int32, ProtocolInfo string, PeerConnectionManager string, PeerConnectionID int32, Direction string, Status string, err error) {
	return client.GetCurrentConnectionInfoCtx(context.Background(),
		ConnectionID,
	)
}

func (client *ConnectionManager2) GetProtocolInfoCtx(
	ctx context.Context,
) (Source string, Sink string, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Source string
		Sink   string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ConnectionManager_2, "GetProtocolInfo", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Source, err = soap.UnmarshalString(response.Source); err != nil {
		return
	}
	if Sink, err = soap.UnmarshalString(response.Sink); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetProtocolInfo is the legacy version of GetProtocolInfoCtx, but uses
// context.Background() as the context.
func (client *ConnectionManager2) GetProtocolInfo() (Source string, Sink string, err error) {
	return client.GetProtocolInfoCtx(context.Background())
}

//
// Arguments:
//
// * Direction: allowed values: Input, Output

func (client *ConnectionManager2) PrepareForConnectionCtx(
	ctx context.Context,
	RemoteProtocolInfo string,
	PeerConnectionManager string,
	PeerConnectionID int32,
	Direction string,
) (ConnectionID int32, AVTransportID int32, RcsID int32, err error) {
	// Request structure.
	request := &struct {
		RemoteProtocolInfo    string
		PeerConnectionManager string
		PeerConnectionID      string
		Direction             string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RemoteProtocolInfo, err = soap.MarshalString(RemoteProtocolInfo); err != nil {
		return
	}
	if request.PeerConnectionManager, err = soap.MarshalString(PeerConnectionManager); err != nil {
		return
	}
	if request.PeerConnectionID, err = soap.MarshalI4(PeerConnectionID); err != nil {
		return
	}
	if request.Direction, err = soap.MarshalString(Direction); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		ConnectionID  string
		AVTransportID string
		RcsID         string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ConnectionManager_2, "PrepareForConnection", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if ConnectionID, err = soap.UnmarshalI4(response.ConnectionID); err != nil {
		return
	}
	if AVTransportID, err = soap.UnmarshalI4(response.AVTransportID); err != nil {
		return
	}
	if RcsID, err = soap.UnmarshalI4(response.RcsID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// PrepareForConnection is the legacy version of PrepareForConnectionCtx, but uses
// context.Background() as the context.
func (client *ConnectionManager2) PrepareForConnection(RemoteProtocolInfo string, PeerConnectionManager string, PeerConnectionID int32, Direction string) (ConnectionID int32, AVTransportID int32, RcsID int32, err error) {
	return client.PrepareForConnectionCtx(context.Background(),
		RemoteProtocolInfo,
		PeerConnectionManager,
		PeerConnectionID,
		Direction,
	)
}

// ContentDirectory1 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:ContentDirectory:1". See
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
// are provided for informational value.
type ContentDirectory1 struct {
	goupnp.ServiceClient
}

// NewContentDirectory1ClientsCtx discovers instances of the service on the network,
// and returns clients to any that are found. errors will contain an error for
// any devices that replied but which could not be queried, and err will be set
// if the discovery process failed outright.
//
// This is a typical entry calling point into this package.
func NewContentDirectory1ClientsCtx(ctx context.Context) (clients []*ContentDirectory1, errors []error, err error) {
	var genericClients []goupnp.ServiceClient
	if genericClients, errors, err = goupnp.NewServiceClientsCtx(ctx, URN_ContentDirectory_1); err != nil {
		return
	}
	clients = newContentDirectory1ClientsFromGenericClients(genericClients)
	return
}

// NewContentDirectory1Clients is the legacy version of NewContentDirectory1ClientsCtx, but uses
// context.Background() as the context.
func NewContentDirectory1Clients() (clients []*ContentDirectory1, errors []error, err error) {
	return NewContentDirectory1ClientsCtx(context.Background())
}

// NewContentDirectory1ClientsByURLCtx discovers instances of the service at the given
// URL, and returns clients to any that are found. An error is returned if
// there was an error probing the service.
//
// This is a typical entry calling point into this package when reusing an
// previously discovered service URL.
func NewContentDirectory1ClientsByURLCtx(ctx context.Context, loc *url.URL) ([]*ContentDirectory1, error) {
	genericClients, err := goupnp.NewServiceClientsByURLCtx(ctx, loc, URN_ContentDirectory_1)
	if err != nil {
		return nil, err
	}
	return newContentDirectory1ClientsFromGenericClients(genericClients), nil
}

// NewContentDirectory1ClientsByURL is the legacy version of NewContentDirectory1ClientsByURLCtx, but uses
// context.Background() as the context.
func NewContentDirectory1ClientsByURL(loc *url.URL) ([]*ContentDirectory1, error) {
	return NewContentDirectory1ClientsByURLCtx(context.Background(), loc)
}

// NewContentDirectory1ClientsFromRootDevice discovers instances of the service in
// a given root device, and returns clients to any that are found. An error is
// returned if there was not at least one instance of the service within the
// device. The location parameter is simply assigned to the Location attribute
// of the wrapped ServiceClient(s).
//
// This is a typical entry calling point into this package when reusing an
// previously discovered root device.
func NewContentDirectory1ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*ContentDirectory1, error) {
	genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_ContentDirectory_1)
	if err != nil {
		return nil, err
	}
	return newContentDirectory1ClientsFromGenericClients(genericClients), nil
}

func newContentDirectory1ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*ContentDirectory1 {
	clients := make([]*ContentDirectory1, len(genericClients))
	for i := range genericClients {
		clients[i] = &ContentDirectory1{genericClients[i]}
	}
	return clients
}

//
// Arguments:
//
// * BrowseFlag: allowed values: BrowseMetadata, BrowseDirectChildren

func (client *ContentDirectory1) BrowseCtx(
	ctx context.Context,
	ObjectID string,
	BrowseFlag string,
	Filter string,
	StartingIndex uint32,
	RequestedCount uint32,
	SortCriteria string,
) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		ObjectID       string
		BrowseFlag     string
		Filter         string
		StartingIndex  string
		RequestedCount string
		SortCriteria   string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ObjectID, err = soap.MarshalString(ObjectID); err != nil {
		return
	}
	if request.BrowseFlag, err = soap.MarshalString(BrowseFlag); err != nil {
		return
	}
	if request.Filter, err = soap.MarshalString(Filter); err != nil {
		return
	}
	if request.StartingIndex, err = soap.MarshalUi4(StartingIndex); err != nil {
		return
	}
	if request.RequestedCount, err = soap.MarshalUi4(RequestedCount); err != nil {
		return
	}
	if request.SortCriteria, err = soap.MarshalString(SortCriteria); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Result         string
		NumberReturned string
		TotalMatches   string
		UpdateID       string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_1, "Browse", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	if NumberReturned, err = soap.UnmarshalUi4(response.NumberReturned); err != nil {
		return
	}
	if TotalMatches, err = soap.UnmarshalUi4(response.TotalMatches); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// Browse is the legacy version of BrowseCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory1) Browse(ObjectID string, BrowseFlag string, Filter string, StartingIndex uint32, RequestedCount uint32, SortCriteria string) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	return client.BrowseCtx(context.Background(),
		ObjectID,
		BrowseFlag,
		Filter,
		StartingIndex,
		RequestedCount,
		SortCriteria,
	)
}

func (client *ContentDirectory1) CreateObjectCtx(
	ctx context.Context,
	ContainerID string,
	Elements string,
) (ObjectID string, Result string, err error) {
	// Request structure.
	request := &struct {
		ContainerID string
		Elements    string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ContainerID, err = soap.MarshalString(ContainerID); err != nil {
		return
	}
	if request.Elements, err = soap.MarshalString(Elements); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		ObjectID string
		Result   string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_1, "CreateObject", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if ObjectID, err = soap.UnmarshalString(response.ObjectID); err != nil {
		return
	}
	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// CreateObject is the legacy version of CreateObjectCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory1) CreateObject(ContainerID string, Elements string) (ObjectID string, Result string, err error) {
	return client.CreateObjectCtx(context.Background(),
		ContainerID,
		Elements,
	)
}

func (client *ContentDirectory1) CreateReferenceCtx(
	ctx context.Context,
	ContainerID string,
	ObjectID string,
) (NewID string, err error) {
	// Request structure.
	request := &struct {
		ContainerID string
		ObjectID    string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ContainerID, err = soap.MarshalString(ContainerID); err != nil {
		return
	}
	if request.ObjectID, err = soap.MarshalString(ObjectID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		NewID string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_1, "CreateReference", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if NewID, err = soap.UnmarshalString(response.NewID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// CreateReference is the legacy version of CreateReferenceCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory1) CreateReference(ContainerID string, ObjectID string) (NewID string, err error) {
	return client.CreateReferenceCtx(context.Background(),
		ContainerID,
		ObjectID,
	)
}

func (client *ContentDirectory1) DeleteResourceCtx(
	ctx context.Context,
	ResourceURI *url.URL,
) (err error) {
	// Request structure.
	request := &struct {
		ResourceURI string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ResourceURI, err = soap.MarshalURI(ResourceURI); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_1, "DeleteResource", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// DeleteResource is the legacy version of DeleteResourceCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory1) DeleteResource(ResourceURI *url.URL) (err error) {
	return client.DeleteResourceCtx(context.Background(),
		ResourceURI,
	)
}

func (client *ContentDirectory1) DestroyObjectCtx(
	ctx context.Context,
	ObjectID string,
) (err error) {
	// Request structure.
	request := &struct {
		ObjectID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ObjectID, err = soap.MarshalString(ObjectID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_1, "DestroyObject", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// DestroyObject is the legacy version of DestroyObjectCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory1) DestroyObject(ObjectID string) (err error) {
	return client.DestroyObjectCtx(context.Background(),
		ObjectID,
	)
}

func (client *ContentDirectory1) ExportResourceCtx(
	ctx context.Context,
	SourceURI *url.URL,
	DestinationURI *url.URL,
) (TransferID uint32, err error) {
	// Request structure.
	request := &struct {
		SourceURI      string
		DestinationURI string
	}{}
	// BEGIN Marshal arguments into request.

	if request.SourceURI, err = soap.MarshalURI(SourceURI); err != nil {
		return
	}
	if request.DestinationURI, err = soap.MarshalURI(DestinationURI); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		TransferID string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_1, "ExportResource", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if TransferID, err = soap.UnmarshalUi4(response.TransferID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// ExportResource is the legacy version of ExportResourceCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory1) ExportResource(SourceURI *url.URL, DestinationURI *url.URL) (TransferID uint32, err error) {
	return client.ExportResourceCtx(context.Background(),
		SourceURI,
		DestinationURI,
	)
}

func (client *ContentDirectory1) GetSearchCapabilitiesCtx(
	ctx context.Context,
) (SearchCaps string, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		SearchCaps string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_1, "GetSearchCapabilities", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if SearchCaps, err = soap.UnmarshalString(response.SearchCaps); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetSearchCapabilities is the legacy version of GetSearchCapabilitiesCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory1) GetSearchCapabilities() (SearchCaps string, err error) {
	return client.GetSearchCapabilitiesCtx(context.Background())
}

func (client *ContentDirectory1) GetSortCapabilitiesCtx(
	ctx context.Context,
) (SortCaps string, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		SortCaps string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_1, "GetSortCapabilities", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if SortCaps, err = soap.UnmarshalString(response.SortCaps); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetSortCapabilities is the legacy version of GetSortCapabilitiesCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory1) GetSortCapabilities() (SortCaps string, err error) {
	return client.GetSortCapabilitiesCtx(context.Background())
}

func (client *ContentDirectory1) GetSystemUpdateIDCtx(
	ctx context.Context,
) (Id uint32, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Id string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_1, "GetSystemUpdateID", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Id, err = soap.UnmarshalUi4(response.Id); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetSystemUpdateID is the legacy version of GetSystemUpdateIDCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory1) GetSystemUpdateID() (Id uint32, err error) {
	return client.GetSystemUpdateIDCtx(context.Background())
}

// Return values:
//
// * TransferStatus: allowed values: COMPLETED, ERROR, IN_PROGRESS, STOPPED
func (client *ContentDirectory1) GetTransferProgressCtx(
	ctx context.Context,
	TransferID uint32,
) (TransferStatus string, TransferLength string, TransferTotal string, err error) {
	// Request structure.
	request := &struct {
		TransferID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.TransferID, err = soap.MarshalUi4(TransferID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		TransferStatus string
		TransferLength string
		TransferTotal  string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_1, "GetTransferProgress", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if TransferStatus, err = soap.UnmarshalString(response.TransferStatus); err != nil {
		return
	}
	if TransferLength, err = soap.UnmarshalString(response.TransferLength); err != nil {
		return
	}
	if TransferTotal, err = soap.UnmarshalString(response.TransferTotal); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetTransferProgress is the legacy version of GetTransferProgressCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory1) GetTransferProgress(TransferID uint32) (TransferStatus string, TransferLength string, TransferTotal string, err error) {
	return client.GetTransferProgressCtx(context.Background(),
		TransferID,
	)
}

func (client *ContentDirectory1) ImportResourceCtx(
	ctx context.Context,
	SourceURI *url.URL,
	DestinationURI *url.URL,
) (TransferID uint32, err error) {
	// Request structure.
	request := &struct {
		SourceURI      string
		DestinationURI string
	}{}
	// BEGIN Marshal arguments into request.

	if request.SourceURI, err = soap.MarshalURI(SourceURI); err != nil {
		return
	}
	if request.DestinationURI, err = soap.MarshalURI(DestinationURI); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		TransferID string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_1, "ImportResource", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if TransferID, err = soap.UnmarshalUi4(response.TransferID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// ImportResource is the legacy version of ImportResourceCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory1) ImportResource(SourceURI *url.URL, DestinationURI *url.URL) (TransferID uint32, err error) {
	return client.ImportResourceCtx(context.Background(),
		SourceURI,
		DestinationURI,
	)
}

func (client *ContentDirectory1) SearchCtx(
	ctx context.Context,
	ContainerID string,
	SearchCriteria string,
	Filter string,
	StartingIndex uint32,
	RequestedCount uint32,
	SortCriteria string,
) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		ContainerID    string
		SearchCriteria string
		Filter         string
		StartingIndex  string
		RequestedCount string
		SortCriteria   string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ContainerID, err = soap.MarshalString(ContainerID); err != nil {
		return
	}
	if request.SearchCriteria, err = soap.MarshalString(SearchCriteria); err != nil {
		return
	}
	if request.Filter, err = soap.MarshalString(Filter); err != nil {
		return
	}
	if request.StartingIndex, err = soap.MarshalUi4(StartingIndex); err != nil {
		return
	}
	if request.RequestedCount, err = soap.MarshalUi4(RequestedCount); err != nil {
		return
	}
	if request.SortCriteria, err = soap.MarshalString(SortCriteria); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Result         string
		NumberReturned string
		TotalMatches   string
		UpdateID       string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_1, "Search", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	if NumberReturned, err = soap.UnmarshalUi4(response.NumberReturned); err != nil {
		return
	}
	if TotalMatches, err = soap.UnmarshalUi4(response.TotalMatches); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// Search is the legacy version of SearchCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory1) Search(ContainerID string, SearchCriteria string, Filter string, StartingIndex uint32, RequestedCount uint32, SortCriteria string) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	return client.SearchCtx(context.Background(),
		ContainerID,
		SearchCriteria,
		Filter,
		StartingIndex,
		RequestedCount,
		SortCriteria,
	)
}

func (client *ContentDirectory1) StopTransferResourceCtx(
	ctx context.Context,
	TransferID uint32,
) (err error) {
	// Request structure.
	request := &struct {
		TransferID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.TransferID, err = soap.MarshalUi4(TransferID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_1, "StopTransferResource", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// StopTransferResource is the legacy version of StopTransferResourceCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory1) StopTransferResource(TransferID uint32) (err error) {
	return client.StopTransferResourceCtx(context.Background(),
		TransferID,
	)
}

func (client *ContentDirectory1) UpdateObjectCtx(
	ctx context.Context,
	ObjectID string,
	CurrentTagValue string,
	NewTagValue string,
) (err error) {
	// Request structure.
	request := &struct {
		ObjectID        string
		CurrentTagValue string
		NewTagValue     string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ObjectID, err = soap.MarshalString(ObjectID); err != nil {
		return
	}
	if request.CurrentTagValue, err = soap.MarshalString(CurrentTagValue); err != nil {
		return
	}
	if request.NewTagValue, err = soap.MarshalString(NewTagValue); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_1, "UpdateObject", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// UpdateObject is the legacy version of UpdateObjectCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory1) UpdateObject(ObjectID string, CurrentTagValue string, NewTagValue string) (err error) {
	return client.UpdateObjectCtx(context.Background(),
		ObjectID,
		CurrentTagValue,
		NewTagValue,
	)
}

// ContentDirectory2 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:ContentDirectory:2". See
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
// are provided for informational value.
type ContentDirectory2 struct {
	goupnp.ServiceClient
}

// NewContentDirectory2ClientsCtx discovers instances of the service on the network,
// and returns clients to any that are found. errors will contain an error for
// any devices that replied but which could not be queried, and err will be set
// if the discovery process failed outright.
//
// This is a typical entry calling point into this package.
func NewContentDirectory2ClientsCtx(ctx context.Context) (clients []*ContentDirectory2, errors []error, err error) {
	var genericClients []goupnp.ServiceClient
	if genericClients, errors, err = goupnp.NewServiceClientsCtx(ctx, URN_ContentDirectory_2); err != nil {
		return
	}
	clients = newContentDirectory2ClientsFromGenericClients(genericClients)
	return
}

// NewContentDirectory2Clients is the legacy version of NewContentDirectory2ClientsCtx, but uses
// context.Background() as the context.
func NewContentDirectory2Clients() (clients []*ContentDirectory2, errors []error, err error) {
	return NewContentDirectory2ClientsCtx(context.Background())
}

// NewContentDirectory2ClientsByURLCtx discovers instances of the service at the given
// URL, and returns clients to any that are found. An error is returned if
// there was an error probing the service.
//
// This is a typical entry calling point into this package when reusing an
// previously discovered service URL.
func NewContentDirectory2ClientsByURLCtx(ctx context.Context, loc *url.URL) ([]*ContentDirectory2, error) {
	genericClients, err := goupnp.NewServiceClientsByURLCtx(ctx, loc, URN_ContentDirectory_2)
	if err != nil {
		return nil, err
	}
	return newContentDirectory2ClientsFromGenericClients(genericClients), nil
}

// NewContentDirectory2ClientsByURL is the legacy version of NewContentDirectory2ClientsByURLCtx, but uses
// context.Background() as the context.
func NewContentDirectory2ClientsByURL(loc *url.URL) ([]*ContentDirectory2, error) {
	return NewContentDirectory2ClientsByURLCtx(context.Background(), loc)
}

// NewContentDirectory2ClientsFromRootDevice discovers instances of the service in
// a given root device, and returns clients to any that are found. An error is
// returned if there was not at least one instance of the service within the
// device. The location parameter is simply assigned to the Location attribute
// of the wrapped ServiceClient(s).
//
// This is a typical entry calling point into this package when reusing an
// previously discovered root device.
func NewContentDirectory2ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*ContentDirectory2, error) {
	genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_ContentDirectory_2)
	if err != nil {
		return nil, err
	}
	return newContentDirectory2ClientsFromGenericClients(genericClients), nil
}

func newContentDirectory2ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*ContentDirectory2 {
	clients := make([]*ContentDirectory2, len(genericClients))
	for i := range genericClients {
		clients[i] = &ContentDirectory2{genericClients[i]}
	}
	return clients
}

//
// Arguments:
//
// * BrowseFlag: allowed values: BrowseMetadata, BrowseDirectChildren

func (client *ContentDirectory2) BrowseCtx(
	ctx context.Context,
	ObjectID string,
	BrowseFlag string,
	Filter string,
	StartingIndex uint32,
	RequestedCount uint32,
	SortCriteria string,
) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		ObjectID       string
		BrowseFlag     string
		Filter         string
		StartingIndex  string
		RequestedCount string
		SortCriteria   string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ObjectID, err = soap.MarshalString(ObjectID); err != nil {
		return
	}
	if request.BrowseFlag, err = soap.MarshalString(BrowseFlag); err != nil {
		return
	}
	if request.Filter, err = soap.MarshalString(Filter); err != nil {
		return
	}
	if request.StartingIndex, err = soap.MarshalUi4(StartingIndex); err != nil {
		return
	}
	if request.RequestedCount, err = soap.MarshalUi4(RequestedCount); err != nil {
		return
	}
	if request.SortCriteria, err = soap.MarshalString(SortCriteria); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Result         string
		NumberReturned string
		TotalMatches   string
		UpdateID       string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_2, "Browse", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	if NumberReturned, err = soap.UnmarshalUi4(response.NumberReturned); err != nil {
		return
	}
	if TotalMatches, err = soap.UnmarshalUi4(response.TotalMatches); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// Browse is the legacy version of BrowseCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory2) Browse(ObjectID string, BrowseFlag string, Filter string, StartingIndex uint32, RequestedCount uint32, SortCriteria string) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	return client.BrowseCtx(context.Background(),
		ObjectID,
		BrowseFlag,
		Filter,
		StartingIndex,
		RequestedCount,
		SortCriteria,
	)
}

func (client *ContentDirectory2) CreateObjectCtx(
	ctx context.Context,
	ContainerID string,
	Elements string,
) (ObjectID string, Result string, err error) {
	// Request structure.
	request := &struct {
		ContainerID string
		Elements    string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ContainerID, err = soap.MarshalString(ContainerID); err != nil {
		return
	}
	if request.Elements, err = soap.MarshalString(Elements); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		ObjectID string
		Result   string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_2, "CreateObject", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if ObjectID, err = soap.UnmarshalString(response.ObjectID); err != nil {
		return
	}
	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// CreateObject is the legacy version of CreateObjectCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory2) CreateObject(ContainerID string, Elements string) (ObjectID string, Result string, err error) {
	return client.CreateObjectCtx(context.Background(),
		ContainerID,
		Elements,
	)
}

func (client *ContentDirectory2) CreateReferenceCtx(
	ctx context.Context,
	ContainerID string,
	ObjectID string,
) (NewID string, err error) {
	// Request structure.
	request := &struct {
		ContainerID string
		ObjectID    string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ContainerID, err = soap.MarshalString(ContainerID); err != nil {
		return
	}
	if request.ObjectID, err = soap.MarshalString(ObjectID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		NewID string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_2, "CreateReference", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if NewID, err = soap.UnmarshalString(response.NewID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// CreateReference is the legacy version of CreateReferenceCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory2) CreateReference(ContainerID string, ObjectID string) (NewID string, err error) {
	return client.CreateReferenceCtx(context.Background(),
		ContainerID,
		ObjectID,
	)
}

func (client *ContentDirectory2) DeleteResourceCtx(
	ctx context.Context,
	ResourceURI *url.URL,
) (err error) {
	// Request structure.
	request := &struct {
		ResourceURI string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ResourceURI, err = soap.MarshalURI(ResourceURI); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_2, "DeleteResource", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// DeleteResource is the legacy version of DeleteResourceCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory2) DeleteResource(ResourceURI *url.URL) (err error) {
	return client.DeleteResourceCtx(context.Background(),
		ResourceURI,
	)
}

func (client *ContentDirectory2) DestroyObjectCtx(
	ctx context.Context,
	ObjectID string,
) (err error) {
	// Request structure.
	request := &struct {
		ObjectID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ObjectID, err = soap.MarshalString(ObjectID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_2, "DestroyObject", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// DestroyObject is the legacy version of DestroyObjectCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory2) DestroyObject(ObjectID string) (err error) {
	return client.DestroyObjectCtx(context.Background(),
		ObjectID,
	)
}

func (client *ContentDirectory2) ExportResourceCtx(
	ctx context.Context,
	SourceURI *url.URL,
	DestinationURI *url.URL,
) (TransferID uint32, err error) {
	// Request structure.
	request := &struct {
		SourceURI      string
		DestinationURI string
	}{}
	// BEGIN Marshal arguments into request.

	if request.SourceURI, err = soap.MarshalURI(SourceURI); err != nil {
		return
	}
	if request.DestinationURI, err = soap.MarshalURI(DestinationURI); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		TransferID string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_2, "ExportResource", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if TransferID, err = soap.UnmarshalUi4(response.TransferID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// ExportResource is the legacy version of ExportResourceCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory2) ExportResource(SourceURI *url.URL, DestinationURI *url.URL) (TransferID uint32, err error) {
	return client.ExportResourceCtx(context.Background(),
		SourceURI,
		DestinationURI,
	)
}

func (client *ContentDirectory2) GetFeatureListCtx(
	ctx context.Context,
) (FeatureList string, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		FeatureList string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_2, "GetFeatureList", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if FeatureList, err = soap.UnmarshalString(response.FeatureList); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetFeatureList is the legacy version of GetFeatureListCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory2) GetFeatureList() (FeatureList string, err error) {
	return client.GetFeatureListCtx(context.Background())
}

func (client *ContentDirectory2) GetSearchCapabilitiesCtx(
	ctx context.Context,
) (SearchCaps string, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		SearchCaps string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_2, "GetSearchCapabilities", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if SearchCaps, err = soap.UnmarshalString(response.SearchCaps); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetSearchCapabilities is the legacy version of GetSearchCapabilitiesCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory2) GetSearchCapabilities() (SearchCaps string, err error) {
	return client.GetSearchCapabilitiesCtx(context.Background())
}

func (client *ContentDirectory2) GetSortCapabilitiesCtx(
	ctx context.Context,
) (SortCaps string, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		SortCaps string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_2, "GetSortCapabilities", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if SortCaps, err = soap.UnmarshalString(response.SortCaps); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetSortCapabilities is the legacy version of GetSortCapabilitiesCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory2) GetSortCapabilities() (SortCaps string, err error) {
	return client.GetSortCapabilitiesCtx(context.Background())
}

func (client *ContentDirectory2) GetSortExtensionCapabilitiesCtx(
	ctx context.Context,
) (SortExtensionCaps string, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		SortExtensionCaps string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_2, "GetSortExtensionCapabilities", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if SortExtensionCaps, err = soap.UnmarshalString(response.SortExtensionCaps); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetSortExtensionCapabilities is the legacy version of GetSortExtensionCapabilitiesCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory2) GetSortExtensionCapabilities() (SortExtensionCaps string, err error) {
	return client.GetSortExtensionCapabilitiesCtx(context.Background())
}

func (client *ContentDirectory2) GetSystemUpdateIDCtx(
	ctx context.Context,
) (Id uint32, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Id string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_2, "GetSystemUpdateID", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Id, err = soap.UnmarshalUi4(response.Id); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetSystemUpdateID is the legacy version of GetSystemUpdateIDCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory2) GetSystemUpdateID() (Id uint32, err error) {
	return client.GetSystemUpdateIDCtx(context.Background())
}

// Return values:
//
// * TransferStatus: allowed values: COMPLETED, ERROR, IN_PROGRESS, STOPPED
func (client *ContentDirectory2) GetTransferProgressCtx(
	ctx context.Context,
	TransferID uint32,
) (TransferStatus string, TransferLength string, TransferTotal string, err error) {
	// Request structure.
	request := &struct {
		TransferID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.TransferID, err = soap.MarshalUi4(TransferID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		TransferStatus string
		TransferLength string
		TransferTotal  string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_2, "GetTransferProgress", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if TransferStatus, err = soap.UnmarshalString(response.TransferStatus); err != nil {
		return
	}
	if TransferLength, err = soap.UnmarshalString(response.TransferLength); err != nil {
		return
	}
	if TransferTotal, err = soap.UnmarshalString(response.TransferTotal); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetTransferProgress is the legacy version of GetTransferProgressCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory2) GetTransferProgress(TransferID uint32) (TransferStatus string, TransferLength string, TransferTotal string, err error) {
	return client.GetTransferProgressCtx(context.Background(),
		TransferID,
	)
}

func (client *ContentDirectory2) ImportResourceCtx(
	ctx context.Context,
	SourceURI *url.URL,
	DestinationURI *url.URL,
) (TransferID uint32, err error) {
	// Request structure.
	request := &struct {
		SourceURI      string
		DestinationURI string
	}{}
	// BEGIN Marshal arguments into request.

	if request.SourceURI, err = soap.MarshalURI(SourceURI); err != nil {
		return
	}
	if request.DestinationURI, err = soap.MarshalURI(DestinationURI); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		TransferID string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_2, "ImportResource", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if TransferID, err = soap.UnmarshalUi4(response.TransferID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// ImportResource is the legacy version of ImportResourceCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory2) ImportResource(SourceURI *url.URL, DestinationURI *url.URL) (TransferID uint32, err error) {
	return client.ImportResourceCtx(context.Background(),
		SourceURI,
		DestinationURI,
	)
}

func (client *ContentDirectory2) MoveObjectCtx(
	ctx context.Context,
	ObjectID string,
	NewParentID string,
) (NewObjectID string, err error) {
	// Request structure.
	request := &struct {
		ObjectID    string
		NewParentID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ObjectID, err = soap.MarshalString(ObjectID); err != nil {
		return
	}
	if request.NewParentID, err = soap.MarshalString(NewParentID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		NewObjectID string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_2, "MoveObject", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if NewObjectID, err = soap.UnmarshalString(response.NewObjectID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// MoveObject is the legacy version of MoveObjectCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory2) MoveObject(ObjectID string, NewParentID string) (NewObjectID string, err error) {
	return client.MoveObjectCtx(context.Background(),
		ObjectID,
		NewParentID,
	)
}

func (client *ContentDirectory2) SearchCtx(
	ctx context.Context,
	ContainerID string,
	SearchCriteria string,
	Filter string,
	StartingIndex uint32,
	RequestedCount uint32,
	SortCriteria string,
) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		ContainerID    string
		SearchCriteria string
		Filter         string
		StartingIndex  string
		RequestedCount string
		SortCriteria   string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ContainerID, err = soap.MarshalString(ContainerID); err != nil {
		return
	}
	if request.SearchCriteria, err = soap.MarshalString(SearchCriteria); err != nil {
		return
	}
	if request.Filter, err = soap.MarshalString(Filter); err != nil {
		return
	}
	if request.StartingIndex, err = soap.MarshalUi4(StartingIndex); err != nil {
		return
	}
	if request.RequestedCount, err = soap.MarshalUi4(RequestedCount); err != nil {
		return
	}
	if request.SortCriteria, err = soap.MarshalString(SortCriteria); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Result         string
		NumberReturned string
		TotalMatches   string
		UpdateID       string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_2, "Search", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	if NumberReturned, err = soap.UnmarshalUi4(response.NumberReturned); err != nil {
		return
	}
	if TotalMatches, err = soap.UnmarshalUi4(response.TotalMatches); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// Search is the legacy version of SearchCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory2) Search(ContainerID string, SearchCriteria string, Filter string, StartingIndex uint32, RequestedCount uint32, SortCriteria string) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	return client.SearchCtx(context.Background(),
		ContainerID,
		SearchCriteria,
		Filter,
		StartingIndex,
		RequestedCount,
		SortCriteria,
	)
}

func (client *ContentDirectory2) StopTransferResourceCtx(
	ctx context.Context,
	TransferID uint32,
) (err error) {
	// Request structure.
	request := &struct {
		TransferID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.TransferID, err = soap.MarshalUi4(TransferID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_2, "StopTransferResource", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// StopTransferResource is the legacy version of StopTransferResourceCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory2) StopTransferResource(TransferID uint32) (err error) {
	return client.StopTransferResourceCtx(context.Background(),
		TransferID,
	)
}

func (client *ContentDirectory2) UpdateObjectCtx(
	ctx context.Context,
	ObjectID string,
	CurrentTagValue string,
	NewTagValue string,
) (err error) {
	// Request structure.
	request := &struct {
		ObjectID        string
		CurrentTagValue string
		NewTagValue     string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ObjectID, err = soap.MarshalString(ObjectID); err != nil {
		return
	}
	if request.CurrentTagValue, err = soap.MarshalString(CurrentTagValue); err != nil {
		return
	}
	if request.NewTagValue, err = soap.MarshalString(NewTagValue); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_2, "UpdateObject", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// UpdateObject is the legacy version of UpdateObjectCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory2) UpdateObject(ObjectID string, CurrentTagValue string, NewTagValue string) (err error) {
	return client.UpdateObjectCtx(context.Background(),
		ObjectID,
		CurrentTagValue,
		NewTagValue,
	)
}

// ContentDirectory3 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:ContentDirectory:3". See
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
// are provided for informational value.
type ContentDirectory3 struct {
	goupnp.ServiceClient
}

// NewContentDirectory3ClientsCtx discovers instances of the service on the network,
// and returns clients to any that are found. errors will contain an error for
// any devices that replied but which could not be queried, and err will be set
// if the discovery process failed outright.
//
// This is a typical entry calling point into this package.
func NewContentDirectory3ClientsCtx(ctx context.Context) (clients []*ContentDirectory3, errors []error, err error) {
	var genericClients []goupnp.ServiceClient
	if genericClients, errors, err = goupnp.NewServiceClientsCtx(ctx, URN_ContentDirectory_3); err != nil {
		return
	}
	clients = newContentDirectory3ClientsFromGenericClients(genericClients)
	return
}

// NewContentDirectory3Clients is the legacy version of NewContentDirectory3ClientsCtx, but uses
// context.Background() as the context.
func NewContentDirectory3Clients() (clients []*ContentDirectory3, errors []error, err error) {
	return NewContentDirectory3ClientsCtx(context.Background())
}

// NewContentDirectory3ClientsByURLCtx discovers instances of the service at the given
// URL, and returns clients to any that are found. An error is returned if
// there was an error probing the service.
//
// This is a typical entry calling point into this package when reusing an
// previously discovered service URL.
func NewContentDirectory3ClientsByURLCtx(ctx context.Context, loc *url.URL) ([]*ContentDirectory3, error) {
	genericClients, err := goupnp.NewServiceClientsByURLCtx(ctx, loc, URN_ContentDirectory_3)
	if err != nil {
		return nil, err
	}
	return newContentDirectory3ClientsFromGenericClients(genericClients), nil
}

// NewContentDirectory3ClientsByURL is the legacy version of NewContentDirectory3ClientsByURLCtx, but uses
// context.Background() as the context.
func NewContentDirectory3ClientsByURL(loc *url.URL) ([]*ContentDirectory3, error) {
	return NewContentDirectory3ClientsByURLCtx(context.Background(), loc)
}

// NewContentDirectory3ClientsFromRootDevice discovers instances of the service in
// a given root device, and returns clients to any that are found. An error is
// returned if there was not at least one instance of the service within the
// device. The location parameter is simply assigned to the Location attribute
// of the wrapped ServiceClient(s).
//
// This is a typical entry calling point into this package when reusing an
// previously discovered root device.
func NewContentDirectory3ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*ContentDirectory3, error) {
	genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_ContentDirectory_3)
	if err != nil {
		return nil, err
	}
	return newContentDirectory3ClientsFromGenericClients(genericClients), nil
}

func newContentDirectory3ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*ContentDirectory3 {
	clients := make([]*ContentDirectory3, len(genericClients))
	for i := range genericClients {
		clients[i] = &ContentDirectory3{genericClients[i]}
	}
	return clients
}

//
// Arguments:
//
// * BrowseFlag: allowed values: BrowseMetadata, BrowseDirectChildren

func (client *ContentDirectory3) BrowseCtx(
	ctx context.Context,
	ObjectID string,
	BrowseFlag string,
	Filter string,
	StartingIndex uint32,
	RequestedCount uint32,
	SortCriteria string,
) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		ObjectID       string
		BrowseFlag     string
		Filter         string
		StartingIndex  string
		RequestedCount string
		SortCriteria   string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ObjectID, err = soap.MarshalString(ObjectID); err != nil {
		return
	}
	if request.BrowseFlag, err = soap.MarshalString(BrowseFlag); err != nil {
		return
	}
	if request.Filter, err = soap.MarshalString(Filter); err != nil {
		return
	}
	if request.StartingIndex, err = soap.MarshalUi4(StartingIndex); err != nil {
		return
	}
	if request.RequestedCount, err = soap.MarshalUi4(RequestedCount); err != nil {
		return
	}
	if request.SortCriteria, err = soap.MarshalString(SortCriteria); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Result         string
		NumberReturned string
		TotalMatches   string
		UpdateID       string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "Browse", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	if NumberReturned, err = soap.UnmarshalUi4(response.NumberReturned); err != nil {
		return
	}
	if TotalMatches, err = soap.UnmarshalUi4(response.TotalMatches); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// Browse is the legacy version of BrowseCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) Browse(ObjectID string, BrowseFlag string, Filter string, StartingIndex uint32, RequestedCount uint32, SortCriteria string) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	return client.BrowseCtx(context.Background(),
		ObjectID,
		BrowseFlag,
		Filter,
		StartingIndex,
		RequestedCount,
		SortCriteria,
	)
}

func (client *ContentDirectory3) CreateObjectCtx(
	ctx context.Context,
	ContainerID string,
	Elements string,
) (ObjectID string, Result string, err error) {
	// Request structure.
	request := &struct {
		ContainerID string
		Elements    string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ContainerID, err = soap.MarshalString(ContainerID); err != nil {
		return
	}
	if request.Elements, err = soap.MarshalString(Elements); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		ObjectID string
		Result   string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "CreateObject", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if ObjectID, err = soap.UnmarshalString(response.ObjectID); err != nil {
		return
	}
	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// CreateObject is the legacy version of CreateObjectCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) CreateObject(ContainerID string, Elements string) (ObjectID string, Result string, err error) {
	return client.CreateObjectCtx(context.Background(),
		ContainerID,
		Elements,
	)
}

func (client *ContentDirectory3) CreateReferenceCtx(
	ctx context.Context,
	ContainerID string,
	ObjectID string,
) (NewID string, err error) {
	// Request structure.
	request := &struct {
		ContainerID string
		ObjectID    string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ContainerID, err = soap.MarshalString(ContainerID); err != nil {
		return
	}
	if request.ObjectID, err = soap.MarshalString(ObjectID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		NewID string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "CreateReference", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if NewID, err = soap.UnmarshalString(response.NewID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// CreateReference is the legacy version of CreateReferenceCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) CreateReference(ContainerID string, ObjectID string) (NewID string, err error) {
	return client.CreateReferenceCtx(context.Background(),
		ContainerID,
		ObjectID,
	)
}

func (client *ContentDirectory3) DeleteResourceCtx(
	ctx context.Context,
	ResourceURI *url.URL,
) (err error) {
	// Request structure.
	request := &struct {
		ResourceURI string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ResourceURI, err = soap.MarshalURI(ResourceURI); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "DeleteResource", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// DeleteResource is the legacy version of DeleteResourceCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) DeleteResource(ResourceURI *url.URL) (err error) {
	return client.DeleteResourceCtx(context.Background(),
		ResourceURI,
	)
}

func (client *ContentDirectory3) DestroyObjectCtx(
	ctx context.Context,
	ObjectID string,
) (err error) {
	// Request structure.
	request := &struct {
		ObjectID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ObjectID, err = soap.MarshalString(ObjectID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "DestroyObject", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// DestroyObject is the legacy version of DestroyObjectCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) DestroyObject(ObjectID string) (err error) {
	return client.DestroyObjectCtx(context.Background(),
		ObjectID,
	)
}

func (client *ContentDirectory3) ExportResourceCtx(
	ctx context.Context,
	SourceURI *url.URL,
	DestinationURI *url.URL,
) (TransferID uint32, err error) {
	// Request structure.
	request := &struct {
		SourceURI      string
		DestinationURI string
	}{}
	// BEGIN Marshal arguments into request.

	if request.SourceURI, err = soap.MarshalURI(SourceURI); err != nil {
		return
	}
	if request.DestinationURI, err = soap.MarshalURI(DestinationURI); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		TransferID string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "ExportResource", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if TransferID, err = soap.UnmarshalUi4(response.TransferID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// ExportResource is the legacy version of ExportResourceCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) ExportResource(SourceURI *url.URL, DestinationURI *url.URL) (TransferID uint32, err error) {
	return client.ExportResourceCtx(context.Background(),
		SourceURI,
		DestinationURI,
	)
}

func (client *ContentDirectory3) FreeFormQueryCtx(
	ctx context.Context,
	ContainerID string,
	CDSView uint32,
	QueryRequest string,
) (QueryResult string, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		ContainerID  string
		CDSView      string
		QueryRequest string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ContainerID, err = soap.MarshalString(ContainerID); err != nil {
		return
	}
	if request.CDSView, err = soap.MarshalUi4(CDSView); err != nil {
		return
	}
	if request.QueryRequest, err = soap.MarshalString(QueryRequest); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		QueryResult string
		UpdateID    string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "FreeFormQuery", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if QueryResult, err = soap.UnmarshalString(response.QueryResult); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// FreeFormQuery is the legacy version of FreeFormQueryCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) FreeFormQuery(ContainerID string, CDSView uint32, QueryRequest string) (QueryResult string, UpdateID uint32, err error) {
	return client.FreeFormQueryCtx(context.Background(),
		ContainerID,
		CDSView,
		QueryRequest,
	)
}

func (client *ContentDirectory3) GetFeatureListCtx(
	ctx context.Context,
) (FeatureList string, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		FeatureList string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "GetFeatureList", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if FeatureList, err = soap.UnmarshalString(response.FeatureList); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetFeatureList is the legacy version of GetFeatureListCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) GetFeatureList() (FeatureList string, err error) {
	return client.GetFeatureListCtx(context.Background())
}

func (client *ContentDirectory3) GetFreeFormQueryCapabilitiesCtx(
	ctx context.Context,
) (FFQCapabilities string, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		FFQCapabilities string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "GetFreeFormQueryCapabilities", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if FFQCapabilities, err = soap.UnmarshalString(response.FFQCapabilities); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetFreeFormQueryCapabilities is the legacy version of GetFreeFormQueryCapabilitiesCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) GetFreeFormQueryCapabilities() (FFQCapabilities string, err error) {
	return client.GetFreeFormQueryCapabilitiesCtx(context.Background())
}

func (client *ContentDirectory3) GetSearchCapabilitiesCtx(
	ctx context.Context,
) (SearchCaps string, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		SearchCaps string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "GetSearchCapabilities", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if SearchCaps, err = soap.UnmarshalString(response.SearchCaps); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetSearchCapabilities is the legacy version of GetSearchCapabilitiesCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) GetSearchCapabilities() (SearchCaps string, err error) {
	return client.GetSearchCapabilitiesCtx(context.Background())
}

func (client *ContentDirectory3) GetServiceResetTokenCtx(
	ctx context.Context,
) (ResetToken string, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		ResetToken string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "GetServiceResetToken", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if ResetToken, err = soap.UnmarshalString(response.ResetToken); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetServiceResetToken is the legacy version of GetServiceResetTokenCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) GetServiceResetToken() (ResetToken string, err error) {
	return client.GetServiceResetTokenCtx(context.Background())
}

func (client *ContentDirectory3) GetSortCapabilitiesCtx(
	ctx context.Context,
) (SortCaps string, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		SortCaps string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "GetSortCapabilities", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if SortCaps, err = soap.UnmarshalString(response.SortCaps); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetSortCapabilities is the legacy version of GetSortCapabilitiesCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) GetSortCapabilities() (SortCaps string, err error) {
	return client.GetSortCapabilitiesCtx(context.Background())
}

func (client *ContentDirectory3) GetSortExtensionCapabilitiesCtx(
	ctx context.Context,
) (SortExtensionCaps string, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		SortExtensionCaps string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "GetSortExtensionCapabilities", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if SortExtensionCaps, err = soap.UnmarshalString(response.SortExtensionCaps); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetSortExtensionCapabilities is the legacy version of GetSortExtensionCapabilitiesCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) GetSortExtensionCapabilities() (SortExtensionCaps string, err error) {
	return client.GetSortExtensionCapabilitiesCtx(context.Background())
}

func (client *ContentDirectory3) GetSystemUpdateIDCtx(
	ctx context.Context,
) (Id uint32, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Id string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "GetSystemUpdateID", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Id, err = soap.UnmarshalUi4(response.Id); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetSystemUpdateID is the legacy version of GetSystemUpdateIDCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) GetSystemUpdateID() (Id uint32, err error) {
	return client.GetSystemUpdateIDCtx(context.Background())
}

// Return values:
//
// * TransferStatus: allowed values: COMPLETED, ERROR, IN_PROGRESS, STOPPED
func (client *ContentDirectory3) GetTransferProgressCtx(
	ctx context.Context,
	TransferID uint32,
) (TransferStatus string, TransferLength string, TransferTotal string, err error) {
	// Request structure.
	request := &struct {
		TransferID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.TransferID, err = soap.MarshalUi4(TransferID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		TransferStatus string
		TransferLength string
		TransferTotal  string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "GetTransferProgress", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if TransferStatus, err = soap.UnmarshalString(response.TransferStatus); err != nil {
		return
	}
	if TransferLength, err = soap.UnmarshalString(response.TransferLength); err != nil {
		return
	}
	if TransferTotal, err = soap.UnmarshalString(response.TransferTotal); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetTransferProgress is the legacy version of GetTransferProgressCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) GetTransferProgress(TransferID uint32) (TransferStatus string, TransferLength string, TransferTotal string, err error) {
	return client.GetTransferProgressCtx(context.Background(),
		TransferID,
	)
}

func (client *ContentDirectory3) ImportResourceCtx(
	ctx context.Context,
	SourceURI *url.URL,
	DestinationURI *url.URL,
) (TransferID uint32, err error) {
	// Request structure.
	request := &struct {
		SourceURI      string
		DestinationURI string
	}{}
	// BEGIN Marshal arguments into request.

	if request.SourceURI, err = soap.MarshalURI(SourceURI); err != nil {
		return
	}
	if request.DestinationURI, err = soap.MarshalURI(DestinationURI); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		TransferID string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "ImportResource", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if TransferID, err = soap.UnmarshalUi4(response.TransferID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// ImportResource is the legacy version of ImportResourceCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) ImportResource(SourceURI *url.URL, DestinationURI *url.URL) (TransferID uint32, err error) {
	return client.ImportResourceCtx(context.Background(),
		SourceURI,
		DestinationURI,
	)
}

func (client *ContentDirectory3) MoveObjectCtx(
	ctx context.Context,
	ObjectID string,
	NewParentID string,
) (NewObjectID string, err error) {
	// Request structure.
	request := &struct {
		ObjectID    string
		NewParentID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ObjectID, err = soap.MarshalString(ObjectID); err != nil {
		return
	}
	if request.NewParentID, err = soap.MarshalString(NewParentID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		NewObjectID string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "MoveObject", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if NewObjectID, err = soap.UnmarshalString(response.NewObjectID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// MoveObject is the legacy version of MoveObjectCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) MoveObject(ObjectID string, NewParentID string) (NewObjectID string, err error) {
	return client.MoveObjectCtx(context.Background(),
		ObjectID,
		NewParentID,
	)
}

func (client *ContentDirectory3) SearchCtx(
	ctx context.Context,
	ContainerID string,
	SearchCriteria string,
	Filter string,
	StartingIndex uint32,
	RequestedCount uint32,
	SortCriteria string,
) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		ContainerID    string
		SearchCriteria string
		Filter         string
		StartingIndex  string
		RequestedCount string
		SortCriteria   string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ContainerID, err = soap.MarshalString(ContainerID); err != nil {
		return
	}
	if request.SearchCriteria, err = soap.MarshalString(SearchCriteria); err != nil {
		return
	}
	if request.Filter, err = soap.MarshalString(Filter); err != nil {
		return
	}
	if request.StartingIndex, err = soap.MarshalUi4(StartingIndex); err != nil {
		return
	}
	if request.RequestedCount, err = soap.MarshalUi4(RequestedCount); err != nil {
		return
	}
	if request.SortCriteria, err = soap.MarshalString(SortCriteria); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Result         string
		NumberReturned string
		TotalMatches   string
		UpdateID       string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "Search", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	if NumberReturned, err = soap.UnmarshalUi4(response.NumberReturned); err != nil {
		return
	}
	if TotalMatches, err = soap.UnmarshalUi4(response.TotalMatches); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// Search is the legacy version of SearchCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) Search(ContainerID string, SearchCriteria string, Filter string, StartingIndex uint32, RequestedCount uint32, SortCriteria string) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	return client.SearchCtx(context.Background(),
		ContainerID,
		SearchCriteria,
		Filter,
		StartingIndex,
		RequestedCount,
		SortCriteria,
	)
}

func (client *ContentDirectory3) StopTransferResourceCtx(
	ctx context.Context,
	TransferID uint32,
) (err error) {
	// Request structure.
	request := &struct {
		TransferID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.TransferID, err = soap.MarshalUi4(TransferID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "StopTransferResource", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// StopTransferResource is the legacy version of StopTransferResourceCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) StopTransferResource(TransferID uint32) (err error) {
	return client.StopTransferResourceCtx(context.Background(),
		TransferID,
	)
}

func (client *ContentDirectory3) UpdateObjectCtx(
	ctx context.Context,
	ObjectID string,
	CurrentTagValue string,
	NewTagValue string,
) (err error) {
	// Request structure.
	request := &struct {
		ObjectID        string
		CurrentTagValue string
		NewTagValue     string
	}{}
	// BEGIN Marshal arguments into request.

	if request.ObjectID, err = soap.MarshalString(ObjectID); err != nil {
		return
	}
	if request.CurrentTagValue, err = soap.MarshalString(CurrentTagValue); err != nil {
		return
	}
	if request.NewTagValue, err = soap.MarshalString(NewTagValue); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ContentDirectory_3, "UpdateObject", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// UpdateObject is the legacy version of UpdateObjectCtx, but uses
// context.Background() as the context.
func (client *ContentDirectory3) UpdateObject(ObjectID string, CurrentTagValue string, NewTagValue string) (err error) {
	return client.UpdateObjectCtx(context.Background(),
		ObjectID,
		CurrentTagValue,
		NewTagValue,
	)
}

// RenderingControl1 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:RenderingControl:1". See
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
// are provided for informational value.
type RenderingControl1 struct {
	goupnp.ServiceClient
}

// NewRenderingControl1ClientsCtx discovers instances of the service on the network,
// and returns clients to any that are found. errors will contain an error for
// any devices that replied but which could not be queried, and err will be set
// if the discovery process failed outright.
//
// This is a typical entry calling point into this package.
func NewRenderingControl1ClientsCtx(ctx context.Context) (clients []*RenderingControl1, errors []error, err error) {
	var genericClients []goupnp.ServiceClient
	if genericClients, errors, err = goupnp.NewServiceClientsCtx(ctx, URN_RenderingControl_1); err != nil {
		return
	}
	clients = newRenderingControl1ClientsFromGenericClients(genericClients)
	return
}

// NewRenderingControl1Clients is the legacy version of NewRenderingControl1ClientsCtx, but uses
// context.Background() as the context.
func NewRenderingControl1Clients() (clients []*RenderingControl1, errors []error, err error) {
	return NewRenderingControl1ClientsCtx(context.Background())
}

// NewRenderingControl1ClientsByURLCtx discovers instances of the service at the given
// URL, and returns clients to any that are found. An error is returned if
// there was an error probing the service.
//
// This is a typical entry calling point into this package when reusing an
// previously discovered service URL.
func NewRenderingControl1ClientsByURLCtx(ctx context.Context, loc *url.URL) ([]*RenderingControl1, error) {
	genericClients, err := goupnp.NewServiceClientsByURLCtx(ctx, loc, URN_RenderingControl_1)
	if err != nil {
		return nil, err
	}
	return newRenderingControl1ClientsFromGenericClients(genericClients), nil
}

// NewRenderingControl1ClientsByURL is the legacy version of NewRenderingControl1ClientsByURLCtx, but uses
// context.Background() as the context.
func NewRenderingControl1ClientsByURL(loc *url.URL) ([]*RenderingControl1, error) {
	return NewRenderingControl1ClientsByURLCtx(context.Background(), loc)
}

// NewRenderingControl1ClientsFromRootDevice discovers instances of the service in
// a given root device, and returns clients to any that are found. An error is
// returned if there was not at least one instance of the service within the
// device. The location parameter is simply assigned to the Location attribute
// of the wrapped ServiceClient(s).
//
// This is a typical entry calling point into this package when reusing an
// previously discovered root device.
func NewRenderingControl1ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*RenderingControl1, error) {
	genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_RenderingControl_1)
	if err != nil {
		return nil, err
	}
	return newRenderingControl1ClientsFromGenericClients(genericClients), nil
}

func newRenderingControl1ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*RenderingControl1 {
	clients := make([]*RenderingControl1, len(genericClients))
	for i := range genericClients {
		clients[i] = &RenderingControl1{genericClients[i]}
	}
	return clients
}

// Return values:
//
// * CurrentBlueVideoBlackLevel: allowed value range: minimum=0, step=1
func (client *RenderingControl1) GetBlueVideoBlackLevelCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentBlueVideoBlackLevel uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentBlueVideoBlackLevel string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "GetBlueVideoBlackLevel", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentBlueVideoBlackLevel, err = soap.UnmarshalUi2(response.CurrentBlueVideoBlackLevel); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetBlueVideoBlackLevel is the legacy version of GetBlueVideoBlackLevelCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) GetBlueVideoBlackLevel(InstanceID uint32) (CurrentBlueVideoBlackLevel uint16, err error) {
	return client.GetBlueVideoBlackLevelCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentBlueVideoGain: allowed value range: minimum=0, step=1
func (client *RenderingControl1) GetBlueVideoGainCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentBlueVideoGain uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentBlueVideoGain string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "GetBlueVideoGain", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentBlueVideoGain, err = soap.UnmarshalUi2(response.CurrentBlueVideoGain); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetBlueVideoGain is the legacy version of GetBlueVideoGainCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) GetBlueVideoGain(InstanceID uint32) (CurrentBlueVideoGain uint16, err error) {
	return client.GetBlueVideoGainCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentBrightness: allowed value range: minimum=0, step=1
func (client *RenderingControl1) GetBrightnessCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentBrightness uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentBrightness string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "GetBrightness", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentBrightness, err = soap.UnmarshalUi2(response.CurrentBrightness); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetBrightness is the legacy version of GetBrightnessCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) GetBrightness(InstanceID uint32) (CurrentBrightness uint16, err error) {
	return client.GetBrightnessCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentColorTemperature: allowed value range: minimum=0, step=1
func (client *RenderingControl1) GetColorTemperatureCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentColorTemperature uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentColorTemperature string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "GetColorTemperature", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentColorTemperature, err = soap.UnmarshalUi2(response.CurrentColorTemperature); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetColorTemperature is the legacy version of GetColorTemperatureCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) GetColorTemperature(InstanceID uint32) (CurrentColorTemperature uint16, err error) {
	return client.GetColorTemperatureCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentContrast: allowed value range: minimum=0, step=1
func (client *RenderingControl1) GetContrastCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentContrast uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentContrast string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "GetContrast", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentContrast, err = soap.UnmarshalUi2(response.CurrentContrast); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetContrast is the legacy version of GetContrastCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) GetContrast(InstanceID uint32) (CurrentContrast uint16, err error) {
	return client.GetContrastCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentGreenVideoBlackLevel: allowed value range: minimum=0, step=1
func (client *RenderingControl1) GetGreenVideoBlackLevelCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentGreenVideoBlackLevel uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentGreenVideoBlackLevel string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "GetGreenVideoBlackLevel", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentGreenVideoBlackLevel, err = soap.UnmarshalUi2(response.CurrentGreenVideoBlackLevel); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetGreenVideoBlackLevel is the legacy version of GetGreenVideoBlackLevelCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) GetGreenVideoBlackLevel(InstanceID uint32) (CurrentGreenVideoBlackLevel uint16, err error) {
	return client.GetGreenVideoBlackLevelCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentGreenVideoGain: allowed value range: minimum=0, step=1
func (client *RenderingControl1) GetGreenVideoGainCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentGreenVideoGain uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentGreenVideoGain string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "GetGreenVideoGain", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentGreenVideoGain, err = soap.UnmarshalUi2(response.CurrentGreenVideoGain); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetGreenVideoGain is the legacy version of GetGreenVideoGainCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) GetGreenVideoGain(InstanceID uint32) (CurrentGreenVideoGain uint16, err error) {
	return client.GetGreenVideoGainCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentHorizontalKeystone: allowed value range: step=1
func (client *RenderingControl1) GetHorizontalKeystoneCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentHorizontalKeystone int16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentHorizontalKeystone string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "GetHorizontalKeystone", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentHorizontalKeystone, err = soap.UnmarshalI2(response.CurrentHorizontalKeystone); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetHorizontalKeystone is the legacy version of GetHorizontalKeystoneCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) GetHorizontalKeystone(InstanceID uint32) (CurrentHorizontalKeystone int16, err error) {
	return client.GetHorizontalKeystoneCtx(context.Background(),
		InstanceID,
	)
}

//
// Arguments:
//
// * Channel: allowed values: Master

func (client *RenderingControl1) GetLoudnessCtx(
	ctx context.Context,
	InstanceID uint32,
	Channel string,
) (CurrentLoudness bool, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
		Channel    string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentLoudness string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "GetLoudness", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentLoudness, err = soap.UnmarshalBoolean(response.CurrentLoudness); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetLoudness is the legacy version of GetLoudnessCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) GetLoudness(InstanceID uint32, Channel string) (CurrentLoudness bool, err error) {
	return client.GetLoudnessCtx(context.Background(),
		InstanceID,
		Channel,
	)
}

//
// Arguments:
//
// * Channel: allowed values: Master

func (client *RenderingControl1) GetMuteCtx(
	ctx context.Context,
	InstanceID uint32,
	Channel string,
) (CurrentMute bool, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
		Channel    string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentMute string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "GetMute", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentMute, err = soap.UnmarshalBoolean(response.CurrentMute); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetMute is the legacy version of GetMuteCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) GetMute(InstanceID uint32, Channel string) (CurrentMute bool, err error) {
	return client.GetMuteCtx(context.Background(),
		InstanceID,
		Channel,
	)
}

// Return values:
//
// * CurrentRedVideoBlackLevel: allowed value range: minimum=0, step=1
func (client *RenderingControl1) GetRedVideoBlackLevelCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentRedVideoBlackLevel uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentRedVideoBlackLevel string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "GetRedVideoBlackLevel", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentRedVideoBlackLevel, err = soap.UnmarshalUi2(response.CurrentRedVideoBlackLevel); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetRedVideoBlackLevel is the legacy version of GetRedVideoBlackLevelCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) GetRedVideoBlackLevel(InstanceID uint32) (CurrentRedVideoBlackLevel uint16, err error) {
	return client.GetRedVideoBlackLevelCtx(context.Background(),
		InstanceID,
	)
}

func (client *RenderingControl1) GetRedVideoGainCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentRedVideoGain uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentRedVideoGain string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "GetRedVideoGain", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentRedVideoGain, err = soap.UnmarshalUi2(response.CurrentRedVideoGain); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetRedVideoGain is the legacy version of GetRedVideoGainCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) GetRedVideoGain(InstanceID uint32) (CurrentRedVideoGain uint16, err error) {
	return client.GetRedVideoGainCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentSharpness: allowed value range: minimum=0, step=1
func (client *RenderingControl1) GetSharpnessCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentSharpness uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentSharpness string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "GetSharpness", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentSharpness, err = soap.UnmarshalUi2(response.CurrentSharpness); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetSharpness is the legacy version of GetSharpnessCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) GetSharpness(InstanceID uint32) (CurrentSharpness uint16, err error) {
	return client.GetSharpnessCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentVerticalKeystone: allowed value range: step=1
func (client *RenderingControl1) GetVerticalKeystoneCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentVerticalKeystone int16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentVerticalKeystone string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "GetVerticalKeystone", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentVerticalKeystone, err = soap.UnmarshalI2(response.CurrentVerticalKeystone); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetVerticalKeystone is the legacy version of GetVerticalKeystoneCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) GetVerticalKeystone(InstanceID uint32) (CurrentVerticalKeystone int16, err error) {
	return client.GetVerticalKeystoneCtx(context.Background(),
		InstanceID,
	)
}

//
// Arguments:
//
// * Channel: allowed values: Master

// Return values:
//
// * CurrentVolume: allowed value range: minimum=0, step=1
func (client *RenderingControl1) GetVolumeCtx(
	ctx context.Context,
	InstanceID uint32,
	Channel string,
) (CurrentVolume uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
		Channel    string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentVolume string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "GetVolume", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentVolume, err = soap.UnmarshalUi2(response.CurrentVolume); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetVolume is the legacy version of GetVolumeCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) GetVolume(InstanceID uint32, Channel string) (CurrentVolume uint16, err error) {
	return client.GetVolumeCtx(context.Background(),
		InstanceID,
		Channel,
	)
}

//
// Arguments:
//
// * Channel: allowed values: Master

func (client *RenderingControl1) GetVolumeDBCtx(
	ctx context.Context,
	InstanceID uint32,
	Channel string,
) (CurrentVolume int16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
		Channel    string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentVolume string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "GetVolumeDB", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentVolume, err = soap.UnmarshalI2(response.CurrentVolume); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetVolumeDB is the legacy version of GetVolumeDBCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) GetVolumeDB(InstanceID uint32, Channel string) (CurrentVolume int16, err error) {
	return client.GetVolumeDBCtx(context.Background(),
		InstanceID,
		Channel,
	)
}

//
// Arguments:
//
// * Channel: allowed values: Master

func (client *RenderingControl1) GetVolumeDBRangeCtx(
	ctx context.Context,
	InstanceID uint32,
	Channel string,
) (MinValue int16, MaxValue int16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
		Channel    string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		MinValue string
		MaxValue string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "GetVolumeDBRange", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if MinValue, err = soap.UnmarshalI2(response.MinValue); err != nil {
		return
	}
	if MaxValue, err = soap.UnmarshalI2(response.MaxValue); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetVolumeDBRange is the legacy version of GetVolumeDBRangeCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) GetVolumeDBRange(InstanceID uint32, Channel string) (MinValue int16, MaxValue int16, err error) {
	return client.GetVolumeDBRangeCtx(context.Background(),
		InstanceID,
		Channel,
	)
}

func (client *RenderingControl1) ListPresetsCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentPresetNameList string, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentPresetNameList string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "ListPresets", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentPresetNameList, err = soap.UnmarshalString(response.CurrentPresetNameList); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// ListPresets is the legacy version of ListPresetsCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) ListPresets(InstanceID uint32) (CurrentPresetNameList string, err error) {
	return client.ListPresetsCtx(context.Background(),
		InstanceID,
	)
}

//
// Arguments:
//
// * PresetName: allowed values: FactoryDefaults

func (client *RenderingControl1) SelectPresetCtx(
	ctx context.Context,
	InstanceID uint32,
	PresetName string,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID string
		PresetName string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.PresetName, err = soap.MarshalString(PresetName); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "SelectPreset", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SelectPreset is the legacy version of SelectPresetCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) SelectPreset(InstanceID uint32, PresetName string) (err error) {
	return client.SelectPresetCtx(context.Background(),
		InstanceID,
		PresetName,
	)
}

//
// Arguments:
//
// * DesiredBlueVideoBlackLevel: allowed value range: minimum=0, step=1

func (client *RenderingControl1) SetBlueVideoBlackLevelCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredBlueVideoBlackLevel uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID                 string
		DesiredBlueVideoBlackLevel string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredBlueVideoBlackLevel, err = soap.MarshalUi2(DesiredBlueVideoBlackLevel); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "SetBlueVideoBlackLevel", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetBlueVideoBlackLevel is the legacy version of SetBlueVideoBlackLevelCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) SetBlueVideoBlackLevel(InstanceID uint32, DesiredBlueVideoBlackLevel uint16) (err error) {
	return client.SetBlueVideoBlackLevelCtx(context.Background(),
		InstanceID,
		DesiredBlueVideoBlackLevel,
	)
}

//
// Arguments:
//
// * DesiredBlueVideoGain: allowed value range: minimum=0, step=1

func (client *RenderingControl1) SetBlueVideoGainCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredBlueVideoGain uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID           string
		DesiredBlueVideoGain string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredBlueVideoGain, err = soap.MarshalUi2(DesiredBlueVideoGain); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "SetBlueVideoGain", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetBlueVideoGain is the legacy version of SetBlueVideoGainCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) SetBlueVideoGain(InstanceID uint32, DesiredBlueVideoGain uint16) (err error) {
	return client.SetBlueVideoGainCtx(context.Background(),
		InstanceID,
		DesiredBlueVideoGain,
	)
}

//
// Arguments:
//
// * DesiredBrightness: allowed value range: minimum=0, step=1

func (client *RenderingControl1) SetBrightnessCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredBrightness uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID        string
		DesiredBrightness string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredBrightness, err = soap.MarshalUi2(DesiredBrightness); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "SetBrightness", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetBrightness is the legacy version of SetBrightnessCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) SetBrightness(InstanceID uint32, DesiredBrightness uint16) (err error) {
	return client.SetBrightnessCtx(context.Background(),
		InstanceID,
		DesiredBrightness,
	)
}

//
// Arguments:
//
// * DesiredColorTemperature: allowed value range: minimum=0, step=1

func (client *RenderingControl1) SetColorTemperatureCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredColorTemperature uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID              string
		DesiredColorTemperature string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredColorTemperature, err = soap.MarshalUi2(DesiredColorTemperature); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "SetColorTemperature", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetColorTemperature is the legacy version of SetColorTemperatureCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) SetColorTemperature(InstanceID uint32, DesiredColorTemperature uint16) (err error) {
	return client.SetColorTemperatureCtx(context.Background(),
		InstanceID,
		DesiredColorTemperature,
	)
}

//
// Arguments:
//
// * DesiredContrast: allowed value range: minimum=0, step=1

func (client *RenderingControl1) SetContrastCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredContrast uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID      string
		DesiredContrast string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredContrast, err = soap.MarshalUi2(DesiredContrast); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "SetContrast", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetContrast is the legacy version of SetContrastCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) SetContrast(InstanceID uint32, DesiredContrast uint16) (err error) {
	return client.SetContrastCtx(context.Background(),
		InstanceID,
		DesiredContrast,
	)
}

//
// Arguments:
//
// * DesiredGreenVideoBlackLevel: allowed value range: minimum=0, step=1

func (client *RenderingControl1) SetGreenVideoBlackLevelCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredGreenVideoBlackLevel uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID                  string
		DesiredGreenVideoBlackLevel string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredGreenVideoBlackLevel, err = soap.MarshalUi2(DesiredGreenVideoBlackLevel); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "SetGreenVideoBlackLevel", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetGreenVideoBlackLevel is the legacy version of SetGreenVideoBlackLevelCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) SetGreenVideoBlackLevel(InstanceID uint32, DesiredGreenVideoBlackLevel uint16) (err error) {
	return client.SetGreenVideoBlackLevelCtx(context.Background(),
		InstanceID,
		DesiredGreenVideoBlackLevel,
	)
}

//
// Arguments:
//
// * DesiredGreenVideoGain: allowed value range: minimum=0, step=1

func (client *RenderingControl1) SetGreenVideoGainCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredGreenVideoGain uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID            string
		DesiredGreenVideoGain string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredGreenVideoGain, err = soap.MarshalUi2(DesiredGreenVideoGain); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "SetGreenVideoGain", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetGreenVideoGain is the legacy version of SetGreenVideoGainCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) SetGreenVideoGain(InstanceID uint32, DesiredGreenVideoGain uint16) (err error) {
	return client.SetGreenVideoGainCtx(context.Background(),
		InstanceID,
		DesiredGreenVideoGain,
	)
}

//
// Arguments:
//
// * DesiredHorizontalKeystone: allowed value range: step=1

func (client *RenderingControl1) SetHorizontalKeystoneCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredHorizontalKeystone int16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID                string
		DesiredHorizontalKeystone string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredHorizontalKeystone, err = soap.MarshalI2(DesiredHorizontalKeystone); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "SetHorizontalKeystone", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetHorizontalKeystone is the legacy version of SetHorizontalKeystoneCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) SetHorizontalKeystone(InstanceID uint32, DesiredHorizontalKeystone int16) (err error) {
	return client.SetHorizontalKeystoneCtx(context.Background(),
		InstanceID,
		DesiredHorizontalKeystone,
	)
}

//
// Arguments:
//
// * Channel: allowed values: Master

func (client *RenderingControl1) SetLoudnessCtx(
	ctx context.Context,
	InstanceID uint32,
	Channel string,
	DesiredLoudness bool,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID      string
		Channel         string
		DesiredLoudness string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	if request.DesiredLoudness, err = soap.MarshalBoolean(DesiredLoudness); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "SetLoudness", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetLoudness is the legacy version of SetLoudnessCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) SetLoudness(InstanceID uint32, Channel string, DesiredLoudness bool) (err error) {
	return client.SetLoudnessCtx(context.Background(),
		InstanceID,
		Channel,
		DesiredLoudness,
	)
}

//
// Arguments:
//
// * Channel: allowed values: Master

func (client *RenderingControl1) SetMuteCtx(
	ctx context.Context,
	InstanceID uint32,
	Channel string,
	DesiredMute bool,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID  string
		Channel     string
		DesiredMute string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	if request.DesiredMute, err = soap.MarshalBoolean(DesiredMute); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "SetMute", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetMute is the legacy version of SetMuteCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) SetMute(InstanceID uint32, Channel string, DesiredMute bool) (err error) {
	return client.SetMuteCtx(context.Background(),
		InstanceID,
		Channel,
		DesiredMute,
	)
}

//
// Arguments:
//
// * DesiredRedVideoBlackLevel: allowed value range: minimum=0, step=1

func (client *RenderingControl1) SetRedVideoBlackLevelCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredRedVideoBlackLevel uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID                string
		DesiredRedVideoBlackLevel string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredRedVideoBlackLevel, err = soap.MarshalUi2(DesiredRedVideoBlackLevel); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "SetRedVideoBlackLevel", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetRedVideoBlackLevel is the legacy version of SetRedVideoBlackLevelCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) SetRedVideoBlackLevel(InstanceID uint32, DesiredRedVideoBlackLevel uint16) (err error) {
	return client.SetRedVideoBlackLevelCtx(context.Background(),
		InstanceID,
		DesiredRedVideoBlackLevel,
	)
}

func (client *RenderingControl1) SetRedVideoGainCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredRedVideoGain uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID          string
		DesiredRedVideoGain string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredRedVideoGain, err = soap.MarshalUi2(DesiredRedVideoGain); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "SetRedVideoGain", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetRedVideoGain is the legacy version of SetRedVideoGainCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) SetRedVideoGain(InstanceID uint32, DesiredRedVideoGain uint16) (err error) {
	return client.SetRedVideoGainCtx(context.Background(),
		InstanceID,
		DesiredRedVideoGain,
	)
}

//
// Arguments:
//
// * DesiredSharpness: allowed value range: minimum=0, step=1

func (client *RenderingControl1) SetSharpnessCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredSharpness uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID       string
		DesiredSharpness string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredSharpness, err = soap.MarshalUi2(DesiredSharpness); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "SetSharpness", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetSharpness is the legacy version of SetSharpnessCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) SetSharpness(InstanceID uint32, DesiredSharpness uint16) (err error) {
	return client.SetSharpnessCtx(context.Background(),
		InstanceID,
		DesiredSharpness,
	)
}

//
// Arguments:
//
// * DesiredVerticalKeystone: allowed value range: step=1

func (client *RenderingControl1) SetVerticalKeystoneCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredVerticalKeystone int16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID              string
		DesiredVerticalKeystone string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredVerticalKeystone, err = soap.MarshalI2(DesiredVerticalKeystone); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "SetVerticalKeystone", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetVerticalKeystone is the legacy version of SetVerticalKeystoneCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) SetVerticalKeystone(InstanceID uint32, DesiredVerticalKeystone int16) (err error) {
	return client.SetVerticalKeystoneCtx(context.Background(),
		InstanceID,
		DesiredVerticalKeystone,
	)
}

//
// Arguments:
//
// * Channel: allowed values: Master
//
// * DesiredVolume: allowed value range: minimum=0, step=1

func (client *RenderingControl1) SetVolumeCtx(
	ctx context.Context,
	InstanceID uint32,
	Channel string,
	DesiredVolume uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID    string
		Channel       string
		DesiredVolume string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	if request.DesiredVolume, err = soap.MarshalUi2(DesiredVolume); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "SetVolume", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetVolume is the legacy version of SetVolumeCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) SetVolume(InstanceID uint32, Channel string, DesiredVolume uint16) (err error) {
	return client.SetVolumeCtx(context.Background(),
		InstanceID,
		Channel,
		DesiredVolume,
	)
}

//
// Arguments:
//
// * Channel: allowed values: Master

func (client *RenderingControl1) SetVolumeDBCtx(
	ctx context.Context,
	InstanceID uint32,
	Channel string,
	DesiredVolume int16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID    string
		Channel       string
		DesiredVolume string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	if request.DesiredVolume, err = soap.MarshalI2(DesiredVolume); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_1, "SetVolumeDB", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetVolumeDB is the legacy version of SetVolumeDBCtx, but uses
// context.Background() as the context.
func (client *RenderingControl1) SetVolumeDB(InstanceID uint32, Channel string, DesiredVolume int16) (err error) {
	return client.SetVolumeDBCtx(context.Background(),
		InstanceID,
		Channel,
		DesiredVolume,
	)
}

// RenderingControl2 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:RenderingControl:2". See
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
// are provided for informational value.
type RenderingControl2 struct {
	goupnp.ServiceClient
}

// NewRenderingControl2ClientsCtx discovers instances of the service on the network,
// and returns clients to any that are found. errors will contain an error for
// any devices that replied but which could not be queried, and err will be set
// if the discovery process failed outright.
//
// This is a typical entry calling point into this package.
func NewRenderingControl2ClientsCtx(ctx context.Context) (clients []*RenderingControl2, errors []error, err error) {
	var genericClients []goupnp.ServiceClient
	if genericClients, errors, err = goupnp.NewServiceClientsCtx(ctx, URN_RenderingControl_2); err != nil {
		return
	}
	clients = newRenderingControl2ClientsFromGenericClients(genericClients)
	return
}

// NewRenderingControl2Clients is the legacy version of NewRenderingControl2ClientsCtx, but uses
// context.Background() as the context.
func NewRenderingControl2Clients() (clients []*RenderingControl2, errors []error, err error) {
	return NewRenderingControl2ClientsCtx(context.Background())
}

// NewRenderingControl2ClientsByURLCtx discovers instances of the service at the given
// URL, and returns clients to any that are found. An error is returned if
// there was an error probing the service.
//
// This is a typical entry calling point into this package when reusing an
// previously discovered service URL.
func NewRenderingControl2ClientsByURLCtx(ctx context.Context, loc *url.URL) ([]*RenderingControl2, error) {
	genericClients, err := goupnp.NewServiceClientsByURLCtx(ctx, loc, URN_RenderingControl_2)
	if err != nil {
		return nil, err
	}
	return newRenderingControl2ClientsFromGenericClients(genericClients), nil
}

// NewRenderingControl2ClientsByURL is the legacy version of NewRenderingControl2ClientsByURLCtx, but uses
// context.Background() as the context.
func NewRenderingControl2ClientsByURL(loc *url.URL) ([]*RenderingControl2, error) {
	return NewRenderingControl2ClientsByURLCtx(context.Background(), loc)
}

// NewRenderingControl2ClientsFromRootDevice discovers instances of the service in
// a given root device, and returns clients to any that are found. An error is
// returned if there was not at least one instance of the service within the
// device. The location parameter is simply assigned to the Location attribute
// of the wrapped ServiceClient(s).
//
// This is a typical entry calling point into this package when reusing an
// previously discovered root device.
func NewRenderingControl2ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*RenderingControl2, error) {
	genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_RenderingControl_2)
	if err != nil {
		return nil, err
	}
	return newRenderingControl2ClientsFromGenericClients(genericClients), nil
}

func newRenderingControl2ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*RenderingControl2 {
	clients := make([]*RenderingControl2, len(genericClients))
	for i := range genericClients {
		clients[i] = &RenderingControl2{genericClients[i]}
	}
	return clients
}

// Return values:
//
// * CurrentBlueVideoBlackLevel: allowed value range: minimum=0, step=1
func (client *RenderingControl2) GetBlueVideoBlackLevelCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentBlueVideoBlackLevel uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentBlueVideoBlackLevel string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "GetBlueVideoBlackLevel", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentBlueVideoBlackLevel, err = soap.UnmarshalUi2(response.CurrentBlueVideoBlackLevel); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetBlueVideoBlackLevel is the legacy version of GetBlueVideoBlackLevelCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) GetBlueVideoBlackLevel(InstanceID uint32) (CurrentBlueVideoBlackLevel uint16, err error) {
	return client.GetBlueVideoBlackLevelCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentBlueVideoGain: allowed value range: minimum=0, step=1
func (client *RenderingControl2) GetBlueVideoGainCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentBlueVideoGain uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentBlueVideoGain string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "GetBlueVideoGain", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentBlueVideoGain, err = soap.UnmarshalUi2(response.CurrentBlueVideoGain); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetBlueVideoGain is the legacy version of GetBlueVideoGainCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) GetBlueVideoGain(InstanceID uint32) (CurrentBlueVideoGain uint16, err error) {
	return client.GetBlueVideoGainCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentBrightness: allowed value range: minimum=0, step=1
func (client *RenderingControl2) GetBrightnessCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentBrightness uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentBrightness string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "GetBrightness", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentBrightness, err = soap.UnmarshalUi2(response.CurrentBrightness); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetBrightness is the legacy version of GetBrightnessCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) GetBrightness(InstanceID uint32) (CurrentBrightness uint16, err error) {
	return client.GetBrightnessCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentColorTemperature: allowed value range: minimum=0, step=1
func (client *RenderingControl2) GetColorTemperatureCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentColorTemperature uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentColorTemperature string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "GetColorTemperature", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentColorTemperature, err = soap.UnmarshalUi2(response.CurrentColorTemperature); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetColorTemperature is the legacy version of GetColorTemperatureCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) GetColorTemperature(InstanceID uint32) (CurrentColorTemperature uint16, err error) {
	return client.GetColorTemperatureCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentContrast: allowed value range: minimum=0, step=1
func (client *RenderingControl2) GetContrastCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentContrast uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentContrast string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "GetContrast", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentContrast, err = soap.UnmarshalUi2(response.CurrentContrast); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetContrast is the legacy version of GetContrastCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) GetContrast(InstanceID uint32) (CurrentContrast uint16, err error) {
	return client.GetContrastCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentGreenVideoBlackLevel: allowed value range: minimum=0, step=1
func (client *RenderingControl2) GetGreenVideoBlackLevelCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentGreenVideoBlackLevel uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentGreenVideoBlackLevel string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "GetGreenVideoBlackLevel", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentGreenVideoBlackLevel, err = soap.UnmarshalUi2(response.CurrentGreenVideoBlackLevel); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetGreenVideoBlackLevel is the legacy version of GetGreenVideoBlackLevelCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) GetGreenVideoBlackLevel(InstanceID uint32) (CurrentGreenVideoBlackLevel uint16, err error) {
	return client.GetGreenVideoBlackLevelCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentGreenVideoGain: allowed value range: minimum=0, step=1
func (client *RenderingControl2) GetGreenVideoGainCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentGreenVideoGain uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentGreenVideoGain string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "GetGreenVideoGain", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentGreenVideoGain, err = soap.UnmarshalUi2(response.CurrentGreenVideoGain); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetGreenVideoGain is the legacy version of GetGreenVideoGainCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) GetGreenVideoGain(InstanceID uint32) (CurrentGreenVideoGain uint16, err error) {
	return client.GetGreenVideoGainCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentHorizontalKeystone: allowed value range: step=1
func (client *RenderingControl2) GetHorizontalKeystoneCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentHorizontalKeystone int16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentHorizontalKeystone string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "GetHorizontalKeystone", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentHorizontalKeystone, err = soap.UnmarshalI2(response.CurrentHorizontalKeystone); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetHorizontalKeystone is the legacy version of GetHorizontalKeystoneCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) GetHorizontalKeystone(InstanceID uint32) (CurrentHorizontalKeystone int16, err error) {
	return client.GetHorizontalKeystoneCtx(context.Background(),
		InstanceID,
	)
}

//
// Arguments:
//
// * Channel: allowed values: Master

func (client *RenderingControl2) GetLoudnessCtx(
	ctx context.Context,
	InstanceID uint32,
	Channel string,
) (CurrentLoudness bool, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
		Channel    string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentLoudness string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "GetLoudness", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentLoudness, err = soap.UnmarshalBoolean(response.CurrentLoudness); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetLoudness is the legacy version of GetLoudnessCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) GetLoudness(InstanceID uint32, Channel string) (CurrentLoudness bool, err error) {
	return client.GetLoudnessCtx(context.Background(),
		InstanceID,
		Channel,
	)
}

//
// Arguments:
//
// * Channel: allowed values: Master

func (client *RenderingControl2) GetMuteCtx(
	ctx context.Context,
	InstanceID uint32,
	Channel string,
) (CurrentMute bool, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
		Channel    string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentMute string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "GetMute", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentMute, err = soap.UnmarshalBoolean(response.CurrentMute); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetMute is the legacy version of GetMuteCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) GetMute(InstanceID uint32, Channel string) (CurrentMute bool, err error) {
	return client.GetMuteCtx(context.Background(),
		InstanceID,
		Channel,
	)
}

// Return values:
//
// * CurrentRedVideoBlackLevel: allowed value range: minimum=0, step=1
func (client *RenderingControl2) GetRedVideoBlackLevelCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentRedVideoBlackLevel uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentRedVideoBlackLevel string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "GetRedVideoBlackLevel", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentRedVideoBlackLevel, err = soap.UnmarshalUi2(response.CurrentRedVideoBlackLevel); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetRedVideoBlackLevel is the legacy version of GetRedVideoBlackLevelCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) GetRedVideoBlackLevel(InstanceID uint32) (CurrentRedVideoBlackLevel uint16, err error) {
	return client.GetRedVideoBlackLevelCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentRedVideoGain: allowed value range: minimum=0, step=1
func (client *RenderingControl2) GetRedVideoGainCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentRedVideoGain uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentRedVideoGain string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "GetRedVideoGain", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentRedVideoGain, err = soap.UnmarshalUi2(response.CurrentRedVideoGain); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetRedVideoGain is the legacy version of GetRedVideoGainCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) GetRedVideoGain(InstanceID uint32) (CurrentRedVideoGain uint16, err error) {
	return client.GetRedVideoGainCtx(context.Background(),
		InstanceID,
	)
}

// Return values:
//
// * CurrentSharpness: allowed value range: minimum=0, step=1
func (client *RenderingControl2) GetSharpnessCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentSharpness uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentSharpness string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "GetSharpness", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentSharpness, err = soap.UnmarshalUi2(response.CurrentSharpness); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetSharpness is the legacy version of GetSharpnessCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) GetSharpness(InstanceID uint32) (CurrentSharpness uint16, err error) {
	return client.GetSharpnessCtx(context.Background(),
		InstanceID,
	)
}

func (client *RenderingControl2) GetStateVariablesCtx(
	ctx context.Context,
	InstanceID uint32,
	StateVariableList string,
) (StateVariableValuePairs string, err error) {
	// Request structure.
	request := &struct {
		InstanceID        string
		StateVariableList string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.StateVariableList, err = soap.MarshalString(StateVariableList); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		StateVariableValuePairs string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "GetStateVariables", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if StateVariableValuePairs, err = soap.UnmarshalString(response.StateVariableValuePairs); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetStateVariables is the legacy version of GetStateVariablesCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) GetStateVariables(InstanceID uint32, StateVariableList string) (StateVariableValuePairs string, err error) {
	return client.GetStateVariablesCtx(context.Background(),
		InstanceID,
		StateVariableList,
	)
}

// Return values:
//
// * CurrentVerticalKeystone: allowed value range: step=1
func (client *RenderingControl2) GetVerticalKeystoneCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentVerticalKeystone int16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentVerticalKeystone string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "GetVerticalKeystone", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentVerticalKeystone, err = soap.UnmarshalI2(response.CurrentVerticalKeystone); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetVerticalKeystone is the legacy version of GetVerticalKeystoneCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) GetVerticalKeystone(InstanceID uint32) (CurrentVerticalKeystone int16, err error) {
	return client.GetVerticalKeystoneCtx(context.Background(),
		InstanceID,
	)
}

//
// Arguments:
//
// * Channel: allowed values: Master

// Return values:
//
// * CurrentVolume: allowed value range: minimum=0, step=1
func (client *RenderingControl2) GetVolumeCtx(
	ctx context.Context,
	InstanceID uint32,
	Channel string,
) (CurrentVolume uint16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
		Channel    string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentVolume string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "GetVolume", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentVolume, err = soap.UnmarshalUi2(response.CurrentVolume); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetVolume is the legacy version of GetVolumeCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) GetVolume(InstanceID uint32, Channel string) (CurrentVolume uint16, err error) {
	return client.GetVolumeCtx(context.Background(),
		InstanceID,
		Channel,
	)
}

//
// Arguments:
//
// * Channel: allowed values: Master

func (client *RenderingControl2) GetVolumeDBCtx(
	ctx context.Context,
	InstanceID uint32,
	Channel string,
) (CurrentVolume int16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
		Channel    string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentVolume string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "GetVolumeDB", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentVolume, err = soap.UnmarshalI2(response.CurrentVolume); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetVolumeDB is the legacy version of GetVolumeDBCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) GetVolumeDB(InstanceID uint32, Channel string) (CurrentVolume int16, err error) {
	return client.GetVolumeDBCtx(context.Background(),
		InstanceID,
		Channel,
	)
}

//
// Arguments:
//
// * Channel: allowed values: Master

func (client *RenderingControl2) GetVolumeDBRangeCtx(
	ctx context.Context,
	InstanceID uint32,
	Channel string,
) (MinValue int16, MaxValue int16, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
		Channel    string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		MinValue string
		MaxValue string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "GetVolumeDBRange", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if MinValue, err = soap.UnmarshalI2(response.MinValue); err != nil {
		return
	}
	if MaxValue, err = soap.UnmarshalI2(response.MaxValue); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetVolumeDBRange is the legacy version of GetVolumeDBRangeCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) GetVolumeDBRange(InstanceID uint32, Channel string) (MinValue int16, MaxValue int16, err error) {
	return client.GetVolumeDBRangeCtx(context.Background(),
		InstanceID,
		Channel,
	)
}

func (client *RenderingControl2) ListPresetsCtx(
	ctx context.Context,
	InstanceID uint32,
) (CurrentPresetNameList string, err error) {
	// Request structure.
	request := &struct {
		InstanceID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		CurrentPresetNameList string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "ListPresets", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if CurrentPresetNameList, err = soap.UnmarshalString(response.CurrentPresetNameList); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// ListPresets is the legacy version of ListPresetsCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) ListPresets(InstanceID uint32) (CurrentPresetNameList string, err error) {
	return client.ListPresetsCtx(context.Background(),
		InstanceID,
	)
}

//
// Arguments:
//
// * PresetName: allowed values: FactoryDefaults

func (client *RenderingControl2) SelectPresetCtx(
	ctx context.Context,
	InstanceID uint32,
	PresetName string,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID string
		PresetName string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.PresetName, err = soap.MarshalString(PresetName); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "SelectPreset", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SelectPreset is the legacy version of SelectPresetCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) SelectPreset(InstanceID uint32, PresetName string) (err error) {
	return client.SelectPresetCtx(context.Background(),
		InstanceID,
		PresetName,
	)
}

//
// Arguments:
//
// * DesiredBlueVideoBlackLevel: allowed value range: minimum=0, step=1

func (client *RenderingControl2) SetBlueVideoBlackLevelCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredBlueVideoBlackLevel uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID                 string
		DesiredBlueVideoBlackLevel string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredBlueVideoBlackLevel, err = soap.MarshalUi2(DesiredBlueVideoBlackLevel); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "SetBlueVideoBlackLevel", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetBlueVideoBlackLevel is the legacy version of SetBlueVideoBlackLevelCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) SetBlueVideoBlackLevel(InstanceID uint32, DesiredBlueVideoBlackLevel uint16) (err error) {
	return client.SetBlueVideoBlackLevelCtx(context.Background(),
		InstanceID,
		DesiredBlueVideoBlackLevel,
	)
}

//
// Arguments:
//
// * DesiredBlueVideoGain: allowed value range: minimum=0, step=1

func (client *RenderingControl2) SetBlueVideoGainCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredBlueVideoGain uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID           string
		DesiredBlueVideoGain string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredBlueVideoGain, err = soap.MarshalUi2(DesiredBlueVideoGain); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "SetBlueVideoGain", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetBlueVideoGain is the legacy version of SetBlueVideoGainCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) SetBlueVideoGain(InstanceID uint32, DesiredBlueVideoGain uint16) (err error) {
	return client.SetBlueVideoGainCtx(context.Background(),
		InstanceID,
		DesiredBlueVideoGain,
	)
}

//
// Arguments:
//
// * DesiredBrightness: allowed value range: minimum=0, step=1

func (client *RenderingControl2) SetBrightnessCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredBrightness uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID        string
		DesiredBrightness string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredBrightness, err = soap.MarshalUi2(DesiredBrightness); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "SetBrightness", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetBrightness is the legacy version of SetBrightnessCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) SetBrightness(InstanceID uint32, DesiredBrightness uint16) (err error) {
	return client.SetBrightnessCtx(context.Background(),
		InstanceID,
		DesiredBrightness,
	)
}

//
// Arguments:
//
// * DesiredColorTemperature: allowed value range: minimum=0, step=1

func (client *RenderingControl2) SetColorTemperatureCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredColorTemperature uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID              string
		DesiredColorTemperature string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredColorTemperature, err = soap.MarshalUi2(DesiredColorTemperature); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "SetColorTemperature", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetColorTemperature is the legacy version of SetColorTemperatureCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) SetColorTemperature(InstanceID uint32, DesiredColorTemperature uint16) (err error) {
	return client.SetColorTemperatureCtx(context.Background(),
		InstanceID,
		DesiredColorTemperature,
	)
}

//
// Arguments:
//
// * DesiredContrast: allowed value range: minimum=0, step=1

func (client *RenderingControl2) SetContrastCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredContrast uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID      string
		DesiredContrast string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredContrast, err = soap.MarshalUi2(DesiredContrast); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "SetContrast", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetContrast is the legacy version of SetContrastCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) SetContrast(InstanceID uint32, DesiredContrast uint16) (err error) {
	return client.SetContrastCtx(context.Background(),
		InstanceID,
		DesiredContrast,
	)
}

//
// Arguments:
//
// * DesiredGreenVideoBlackLevel: allowed value range: minimum=0, step=1

func (client *RenderingControl2) SetGreenVideoBlackLevelCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredGreenVideoBlackLevel uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID                  string
		DesiredGreenVideoBlackLevel string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredGreenVideoBlackLevel, err = soap.MarshalUi2(DesiredGreenVideoBlackLevel); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "SetGreenVideoBlackLevel", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetGreenVideoBlackLevel is the legacy version of SetGreenVideoBlackLevelCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) SetGreenVideoBlackLevel(InstanceID uint32, DesiredGreenVideoBlackLevel uint16) (err error) {
	return client.SetGreenVideoBlackLevelCtx(context.Background(),
		InstanceID,
		DesiredGreenVideoBlackLevel,
	)
}

//
// Arguments:
//
// * DesiredGreenVideoGain: allowed value range: minimum=0, step=1

func (client *RenderingControl2) SetGreenVideoGainCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredGreenVideoGain uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID            string
		DesiredGreenVideoGain string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredGreenVideoGain, err = soap.MarshalUi2(DesiredGreenVideoGain); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "SetGreenVideoGain", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetGreenVideoGain is the legacy version of SetGreenVideoGainCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) SetGreenVideoGain(InstanceID uint32, DesiredGreenVideoGain uint16) (err error) {
	return client.SetGreenVideoGainCtx(context.Background(),
		InstanceID,
		DesiredGreenVideoGain,
	)
}

//
// Arguments:
//
// * DesiredHorizontalKeystone: allowed value range: step=1

func (client *RenderingControl2) SetHorizontalKeystoneCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredHorizontalKeystone int16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID                string
		DesiredHorizontalKeystone string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredHorizontalKeystone, err = soap.MarshalI2(DesiredHorizontalKeystone); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "SetHorizontalKeystone", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetHorizontalKeystone is the legacy version of SetHorizontalKeystoneCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) SetHorizontalKeystone(InstanceID uint32, DesiredHorizontalKeystone int16) (err error) {
	return client.SetHorizontalKeystoneCtx(context.Background(),
		InstanceID,
		DesiredHorizontalKeystone,
	)
}

//
// Arguments:
//
// * Channel: allowed values: Master

func (client *RenderingControl2) SetLoudnessCtx(
	ctx context.Context,
	InstanceID uint32,
	Channel string,
	DesiredLoudness bool,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID      string
		Channel         string
		DesiredLoudness string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	if request.DesiredLoudness, err = soap.MarshalBoolean(DesiredLoudness); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "SetLoudness", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetLoudness is the legacy version of SetLoudnessCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) SetLoudness(InstanceID uint32, Channel string, DesiredLoudness bool) (err error) {
	return client.SetLoudnessCtx(context.Background(),
		InstanceID,
		Channel,
		DesiredLoudness,
	)
}

//
// Arguments:
//
// * Channel: allowed values: Master

func (client *RenderingControl2) SetMuteCtx(
	ctx context.Context,
	InstanceID uint32,
	Channel string,
	DesiredMute bool,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID  string
		Channel     string
		DesiredMute string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	if request.DesiredMute, err = soap.MarshalBoolean(DesiredMute); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "SetMute", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetMute is the legacy version of SetMuteCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) SetMute(InstanceID uint32, Channel string, DesiredMute bool) (err error) {
	return client.SetMuteCtx(context.Background(),
		InstanceID,
		Channel,
		DesiredMute,
	)
}

//
// Arguments:
//
// * DesiredRedVideoBlackLevel: allowed value range: minimum=0, step=1

func (client *RenderingControl2) SetRedVideoBlackLevelCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredRedVideoBlackLevel uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID                string
		DesiredRedVideoBlackLevel string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredRedVideoBlackLevel, err = soap.MarshalUi2(DesiredRedVideoBlackLevel); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "SetRedVideoBlackLevel", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetRedVideoBlackLevel is the legacy version of SetRedVideoBlackLevelCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) SetRedVideoBlackLevel(InstanceID uint32, DesiredRedVideoBlackLevel uint16) (err error) {
	return client.SetRedVideoBlackLevelCtx(context.Background(),
		InstanceID,
		DesiredRedVideoBlackLevel,
	)
}

//
// Arguments:
//
// * DesiredRedVideoGain: allowed value range: minimum=0, step=1

func (client *RenderingControl2) SetRedVideoGainCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredRedVideoGain uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID          string
		DesiredRedVideoGain string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredRedVideoGain, err = soap.MarshalUi2(DesiredRedVideoGain); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "SetRedVideoGain", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetRedVideoGain is the legacy version of SetRedVideoGainCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) SetRedVideoGain(InstanceID uint32, DesiredRedVideoGain uint16) (err error) {
	return client.SetRedVideoGainCtx(context.Background(),
		InstanceID,
		DesiredRedVideoGain,
	)
}

//
// Arguments:
//
// * DesiredSharpness: allowed value range: minimum=0, step=1

func (client *RenderingControl2) SetSharpnessCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredSharpness uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID       string
		DesiredSharpness string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredSharpness, err = soap.MarshalUi2(DesiredSharpness); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "SetSharpness", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetSharpness is the legacy version of SetSharpnessCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) SetSharpness(InstanceID uint32, DesiredSharpness uint16) (err error) {
	return client.SetSharpnessCtx(context.Background(),
		InstanceID,
		DesiredSharpness,
	)
}

func (client *RenderingControl2) SetStateVariablesCtx(
	ctx context.Context,
	InstanceID uint32,
	RenderingControlUDN string,
	ServiceType string,
	ServiceId string,
	StateVariableValuePairs string,
) (StateVariableList string, err error) {
	// Request structure.
	request := &struct {
		InstanceID              string
		RenderingControlUDN     string
		ServiceType             string
		ServiceId               string
		StateVariableValuePairs string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.RenderingControlUDN, err = soap.MarshalString(RenderingControlUDN); err != nil {
		return
	}
	if request.ServiceType, err = soap.MarshalString(ServiceType); err != nil {
		return
	}
	if request.ServiceId, err = soap.MarshalString(ServiceId); err != nil {
		return
	}
	if request.StateVariableValuePairs, err = soap.MarshalString(StateVariableValuePairs); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		StateVariableList string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "SetStateVariables", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if StateVariableList, err = soap.UnmarshalString(response.StateVariableList); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// SetStateVariables is the legacy version of SetStateVariablesCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) SetStateVariables(InstanceID uint32, RenderingControlUDN string, ServiceType string, ServiceId string, StateVariableValuePairs string) (StateVariableList string, err error) {
	return client.SetStateVariablesCtx(context.Background(),
		InstanceID,
		RenderingControlUDN,
		ServiceType,
		ServiceId,
		StateVariableValuePairs,
	)
}

//
// Arguments:
//
// * DesiredVerticalKeystone: allowed value range: step=1

func (client *RenderingControl2) SetVerticalKeystoneCtx(
	ctx context.Context,
	InstanceID uint32,
	DesiredVerticalKeystone int16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID              string
		DesiredVerticalKeystone string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.DesiredVerticalKeystone, err = soap.MarshalI2(DesiredVerticalKeystone); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "SetVerticalKeystone", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetVerticalKeystone is the legacy version of SetVerticalKeystoneCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) SetVerticalKeystone(InstanceID uint32, DesiredVerticalKeystone int16) (err error) {
	return client.SetVerticalKeystoneCtx(context.Background(),
		InstanceID,
		DesiredVerticalKeystone,
	)
}

//
// Arguments:
//
// * Channel: allowed values: Master
//
// * DesiredVolume: allowed value range: minimum=0, step=1

func (client *RenderingControl2) SetVolumeCtx(
	ctx context.Context,
	InstanceID uint32,
	Channel string,
	DesiredVolume uint16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID    string
		Channel       string
		DesiredVolume string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	if request.DesiredVolume, err = soap.MarshalUi2(DesiredVolume); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "SetVolume", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetVolume is the legacy version of SetVolumeCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) SetVolume(InstanceID uint32, Channel string, DesiredVolume uint16) (err error) {
	return client.SetVolumeCtx(context.Background(),
		InstanceID,
		Channel,
		DesiredVolume,
	)
}

//
// Arguments:
//
// * Channel: allowed values: Master

func (client *RenderingControl2) SetVolumeDBCtx(
	ctx context.Context,
	InstanceID uint32,
	Channel string,
	DesiredVolume int16,
) (err error) {
	// Request structure.
	request := &struct {
		InstanceID    string
		Channel       string
		DesiredVolume string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	if request.DesiredVolume, err = soap.MarshalI2(DesiredVolume); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_RenderingControl_2, "SetVolumeDB", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// SetVolumeDB is the legacy version of SetVolumeDBCtx, but uses
// context.Background() as the context.
func (client *RenderingControl2) SetVolumeDB(InstanceID uint32, Channel string, DesiredVolume int16) (err error) {
	return client.SetVolumeDBCtx(context.Background(),
		InstanceID,
		Channel,
		DesiredVolume,
	)
}

// ScheduledRecording1 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:ScheduledRecording:1". See
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
// are provided for informational value.
type ScheduledRecording1 struct {
	goupnp.ServiceClient
}

// NewScheduledRecording1ClientsCtx discovers instances of the service on the network,
// and returns clients to any that are found. errors will contain an error for
// any devices that replied but which could not be queried, and err will be set
// if the discovery process failed outright.
//
// This is a typical entry calling point into this package.
func NewScheduledRecording1ClientsCtx(ctx context.Context) (clients []*ScheduledRecording1, errors []error, err error) {
	var genericClients []goupnp.ServiceClient
	if genericClients, errors, err = goupnp.NewServiceClientsCtx(ctx, URN_ScheduledRecording_1); err != nil {
		return
	}
	clients = newScheduledRecording1ClientsFromGenericClients(genericClients)
	return
}

// NewScheduledRecording1Clients is the legacy version of NewScheduledRecording1ClientsCtx, but uses
// context.Background() as the context.
func NewScheduledRecording1Clients() (clients []*ScheduledRecording1, errors []error, err error) {
	return NewScheduledRecording1ClientsCtx(context.Background())
}

// NewScheduledRecording1ClientsByURLCtx discovers instances of the service at the given
// URL, and returns clients to any that are found. An error is returned if
// there was an error probing the service.
//
// This is a typical entry calling point into this package when reusing an
// previously discovered service URL.
func NewScheduledRecording1ClientsByURLCtx(ctx context.Context, loc *url.URL) ([]*ScheduledRecording1, error) {
	genericClients, err := goupnp.NewServiceClientsByURLCtx(ctx, loc, URN_ScheduledRecording_1)
	if err != nil {
		return nil, err
	}
	return newScheduledRecording1ClientsFromGenericClients(genericClients), nil
}

// NewScheduledRecording1ClientsByURL is the legacy version of NewScheduledRecording1ClientsByURLCtx, but uses
// context.Background() as the context.
func NewScheduledRecording1ClientsByURL(loc *url.URL) ([]*ScheduledRecording1, error) {
	return NewScheduledRecording1ClientsByURLCtx(context.Background(), loc)
}

// NewScheduledRecording1ClientsFromRootDevice discovers instances of the service in
// a given root device, and returns clients to any that are found. An error is
// returned if there was not at least one instance of the service within the
// device. The location parameter is simply assigned to the Location attribute
// of the wrapped ServiceClient(s).
//
// This is a typical entry calling point into this package when reusing an
// previously discovered root device.
func NewScheduledRecording1ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*ScheduledRecording1, error) {
	genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_ScheduledRecording_1)
	if err != nil {
		return nil, err
	}
	return newScheduledRecording1ClientsFromGenericClients(genericClients), nil
}

func newScheduledRecording1ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*ScheduledRecording1 {
	clients := make([]*ScheduledRecording1, len(genericClients))
	for i := range genericClients {
		clients[i] = &ScheduledRecording1{genericClients[i]}
	}
	return clients
}

func (client *ScheduledRecording1) BrowseRecordSchedulesCtx(
	ctx context.Context,
	Filter string,
	StartingIndex uint32,
	RequestedCount uint32,
	SortCriteria string,
) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		Filter         string
		StartingIndex  string
		RequestedCount string
		SortCriteria   string
	}{}
	// BEGIN Marshal arguments into request.

	if request.Filter, err = soap.MarshalString(Filter); err != nil {
		return
	}
	if request.StartingIndex, err = soap.MarshalUi4(StartingIndex); err != nil {
		return
	}
	if request.RequestedCount, err = soap.MarshalUi4(RequestedCount); err != nil {
		return
	}
	if request.SortCriteria, err = soap.MarshalString(SortCriteria); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Result         string
		NumberReturned string
		TotalMatches   string
		UpdateID       string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_1, "BrowseRecordSchedules", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	if NumberReturned, err = soap.UnmarshalUi4(response.NumberReturned); err != nil {
		return
	}
	if TotalMatches, err = soap.UnmarshalUi4(response.TotalMatches); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// BrowseRecordSchedules is the legacy version of BrowseRecordSchedulesCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording1) BrowseRecordSchedules(Filter string, StartingIndex uint32, RequestedCount uint32, SortCriteria string) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	return client.BrowseRecordSchedulesCtx(context.Background(),
		Filter,
		StartingIndex,
		RequestedCount,
		SortCriteria,
	)
}

func (client *ScheduledRecording1) BrowseRecordTasksCtx(
	ctx context.Context,
	RecordScheduleID string,
	Filter string,
	StartingIndex uint32,
	RequestedCount uint32,
	SortCriteria string,
) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		RecordScheduleID string
		Filter           string
		StartingIndex    string
		RequestedCount   string
		SortCriteria     string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordScheduleID, err = soap.MarshalString(RecordScheduleID); err != nil {
		return
	}
	if request.Filter, err = soap.MarshalString(Filter); err != nil {
		return
	}
	if request.StartingIndex, err = soap.MarshalUi4(StartingIndex); err != nil {
		return
	}
	if request.RequestedCount, err = soap.MarshalUi4(RequestedCount); err != nil {
		return
	}
	if request.SortCriteria, err = soap.MarshalString(SortCriteria); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Result         string
		NumberReturned string
		TotalMatches   string
		UpdateID       string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_1, "BrowseRecordTasks", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	if NumberReturned, err = soap.UnmarshalUi4(response.NumberReturned); err != nil {
		return
	}
	if TotalMatches, err = soap.UnmarshalUi4(response.TotalMatches); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// BrowseRecordTasks is the legacy version of BrowseRecordTasksCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording1) BrowseRecordTasks(RecordScheduleID string, Filter string, StartingIndex uint32, RequestedCount uint32, SortCriteria string) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	return client.BrowseRecordTasksCtx(context.Background(),
		RecordScheduleID,
		Filter,
		StartingIndex,
		RequestedCount,
		SortCriteria,
	)
}

func (client *ScheduledRecording1) CreateRecordScheduleCtx(
	ctx context.Context,
	Elements string,
) (RecordScheduleID string, Result string, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		Elements string
	}{}
	// BEGIN Marshal arguments into request.

	if request.Elements, err = soap.MarshalString(Elements); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		RecordScheduleID string
		Result           string
		UpdateID         string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_1, "CreateRecordSchedule", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if RecordScheduleID, err = soap.UnmarshalString(response.RecordScheduleID); err != nil {
		return
	}
	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// CreateRecordSchedule is the legacy version of CreateRecordScheduleCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording1) CreateRecordSchedule(Elements string) (RecordScheduleID string, Result string, UpdateID uint32, err error) {
	return client.CreateRecordScheduleCtx(context.Background(),
		Elements,
	)
}

func (client *ScheduledRecording1) DeleteRecordScheduleCtx(
	ctx context.Context,
	RecordScheduleID string,
) (err error) {
	// Request structure.
	request := &struct {
		RecordScheduleID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordScheduleID, err = soap.MarshalString(RecordScheduleID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_1, "DeleteRecordSchedule", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// DeleteRecordSchedule is the legacy version of DeleteRecordScheduleCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording1) DeleteRecordSchedule(RecordScheduleID string) (err error) {
	return client.DeleteRecordScheduleCtx(context.Background(),
		RecordScheduleID,
	)
}

func (client *ScheduledRecording1) DeleteRecordTaskCtx(
	ctx context.Context,
	RecordTaskID string,
) (err error) {
	// Request structure.
	request := &struct {
		RecordTaskID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordTaskID, err = soap.MarshalString(RecordTaskID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_1, "DeleteRecordTask", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// DeleteRecordTask is the legacy version of DeleteRecordTaskCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording1) DeleteRecordTask(RecordTaskID string) (err error) {
	return client.DeleteRecordTaskCtx(context.Background(),
		RecordTaskID,
	)
}

func (client *ScheduledRecording1) DisableRecordScheduleCtx(
	ctx context.Context,
	RecordScheduleID string,
) (err error) {
	// Request structure.
	request := &struct {
		RecordScheduleID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordScheduleID, err = soap.MarshalString(RecordScheduleID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_1, "DisableRecordSchedule", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// DisableRecordSchedule is the legacy version of DisableRecordScheduleCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording1) DisableRecordSchedule(RecordScheduleID string) (err error) {
	return client.DisableRecordScheduleCtx(context.Background(),
		RecordScheduleID,
	)
}

func (client *ScheduledRecording1) DisableRecordTaskCtx(
	ctx context.Context,
	RecordTaskID string,
) (err error) {
	// Request structure.
	request := &struct {
		RecordTaskID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordTaskID, err = soap.MarshalString(RecordTaskID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_1, "DisableRecordTask", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// DisableRecordTask is the legacy version of DisableRecordTaskCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording1) DisableRecordTask(RecordTaskID string) (err error) {
	return client.DisableRecordTaskCtx(context.Background(),
		RecordTaskID,
	)
}

func (client *ScheduledRecording1) EnableRecordScheduleCtx(
	ctx context.Context,
	RecordScheduleID string,
) (err error) {
	// Request structure.
	request := &struct {
		RecordScheduleID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordScheduleID, err = soap.MarshalString(RecordScheduleID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_1, "EnableRecordSchedule", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// EnableRecordSchedule is the legacy version of EnableRecordScheduleCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording1) EnableRecordSchedule(RecordScheduleID string) (err error) {
	return client.EnableRecordScheduleCtx(context.Background(),
		RecordScheduleID,
	)
}

func (client *ScheduledRecording1) EnableRecordTaskCtx(
	ctx context.Context,
	RecordTaskID string,
) (err error) {
	// Request structure.
	request := &struct {
		RecordTaskID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordTaskID, err = soap.MarshalString(RecordTaskID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_1, "EnableRecordTask", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// EnableRecordTask is the legacy version of EnableRecordTaskCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording1) EnableRecordTask(RecordTaskID string) (err error) {
	return client.EnableRecordTaskCtx(context.Background(),
		RecordTaskID,
	)
}

//
// Arguments:
//
// * DataTypeID: allowed values: A_ARG_TYPE_RecordSchedule, A_ARG_TYPE_RecordTask, A_ARG_TYPE_RecordScheduleParts

func (client *ScheduledRecording1) GetAllowedValuesCtx(
	ctx context.Context,
	DataTypeID string,
	Filter string,
) (PropertyInfo string, err error) {
	// Request structure.
	request := &struct {
		DataTypeID string
		Filter     string
	}{}
	// BEGIN Marshal arguments into request.

	if request.DataTypeID, err = soap.MarshalString(DataTypeID); err != nil {
		return
	}
	if request.Filter, err = soap.MarshalString(Filter); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		PropertyInfo string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_1, "GetAllowedValues", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if PropertyInfo, err = soap.UnmarshalString(response.PropertyInfo); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetAllowedValues is the legacy version of GetAllowedValuesCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording1) GetAllowedValues(DataTypeID string, Filter string) (PropertyInfo string, err error) {
	return client.GetAllowedValuesCtx(context.Background(),
		DataTypeID,
		Filter,
	)
}

//
// Arguments:
//
// * DataTypeID: allowed values: A_ARG_TYPE_RecordSchedule, A_ARG_TYPE_RecordTask, A_ARG_TYPE_RecordScheduleParts

func (client *ScheduledRecording1) GetPropertyListCtx(
	ctx context.Context,
	DataTypeID string,
) (PropertyList string, err error) {
	// Request structure.
	request := &struct {
		DataTypeID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.DataTypeID, err = soap.MarshalString(DataTypeID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		PropertyList string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_1, "GetPropertyList", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if PropertyList, err = soap.UnmarshalString(response.PropertyList); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetPropertyList is the legacy version of GetPropertyListCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording1) GetPropertyList(DataTypeID string) (PropertyList string, err error) {
	return client.GetPropertyListCtx(context.Background(),
		DataTypeID,
	)
}

func (client *ScheduledRecording1) GetRecordScheduleCtx(
	ctx context.Context,
	RecordScheduleID string,
	Filter string,
) (Result string, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		RecordScheduleID string
		Filter           string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordScheduleID, err = soap.MarshalString(RecordScheduleID); err != nil {
		return
	}
	if request.Filter, err = soap.MarshalString(Filter); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Result   string
		UpdateID string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_1, "GetRecordSchedule", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetRecordSchedule is the legacy version of GetRecordScheduleCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording1) GetRecordSchedule(RecordScheduleID string, Filter string) (Result string, UpdateID uint32, err error) {
	return client.GetRecordScheduleCtx(context.Background(),
		RecordScheduleID,
		Filter,
	)
}

func (client *ScheduledRecording1) GetRecordScheduleConflictsCtx(
	ctx context.Context,
	RecordScheduleID string,
) (RecordScheduleConflictIDList string, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		RecordScheduleID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordScheduleID, err = soap.MarshalString(RecordScheduleID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		RecordScheduleConflictIDList string
		UpdateID                     string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_1, "GetRecordScheduleConflicts", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if RecordScheduleConflictIDList, err = soap.UnmarshalString(response.RecordScheduleConflictIDList); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetRecordScheduleConflicts is the legacy version of GetRecordScheduleConflictsCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording1) GetRecordScheduleConflicts(RecordScheduleID string) (RecordScheduleConflictIDList string, UpdateID uint32, err error) {
	return client.GetRecordScheduleConflictsCtx(context.Background(),
		RecordScheduleID,
	)
}

func (client *ScheduledRecording1) GetRecordTaskCtx(
	ctx context.Context,
	RecordTaskID string,
	Filter string,
) (Result string, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		RecordTaskID string
		Filter       string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordTaskID, err = soap.MarshalString(RecordTaskID); err != nil {
		return
	}
	if request.Filter, err = soap.MarshalString(Filter); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Result   string
		UpdateID string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_1, "GetRecordTask", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetRecordTask is the legacy version of GetRecordTaskCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording1) GetRecordTask(RecordTaskID string, Filter string) (Result string, UpdateID uint32, err error) {
	return client.GetRecordTaskCtx(context.Background(),
		RecordTaskID,
		Filter,
	)
}

func (client *ScheduledRecording1) GetRecordTaskConflictsCtx(
	ctx context.Context,
	RecordTaskID string,
) (RecordTaskConflictIDList string, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		RecordTaskID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordTaskID, err = soap.MarshalString(RecordTaskID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		RecordTaskConflictIDList string
		UpdateID                 string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_1, "GetRecordTaskConflicts", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if RecordTaskConflictIDList, err = soap.UnmarshalString(response.RecordTaskConflictIDList); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetRecordTaskConflicts is the legacy version of GetRecordTaskConflictsCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording1) GetRecordTaskConflicts(RecordTaskID string) (RecordTaskConflictIDList string, UpdateID uint32, err error) {
	return client.GetRecordTaskConflictsCtx(context.Background(),
		RecordTaskID,
	)
}

func (client *ScheduledRecording1) GetSortCapabilitiesCtx(
	ctx context.Context,
) (SortCaps string, SortLevelCap uint32, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		SortCaps     string
		SortLevelCap string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_1, "GetSortCapabilities", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if SortCaps, err = soap.UnmarshalString(response.SortCaps); err != nil {
		return
	}
	if SortLevelCap, err = soap.UnmarshalUi4(response.SortLevelCap); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetSortCapabilities is the legacy version of GetSortCapabilitiesCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording1) GetSortCapabilities() (SortCaps string, SortLevelCap uint32, err error) {
	return client.GetSortCapabilitiesCtx(context.Background())
}

func (client *ScheduledRecording1) GetStateUpdateIDCtx(
	ctx context.Context,
) (Id uint32, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Id string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_1, "GetStateUpdateID", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Id, err = soap.UnmarshalUi4(response.Id); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetStateUpdateID is the legacy version of GetStateUpdateIDCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording1) GetStateUpdateID() (Id uint32, err error) {
	return client.GetStateUpdateIDCtx(context.Background())
}

func (client *ScheduledRecording1) ResetRecordTaskCtx(
	ctx context.Context,
	RecordTaskID string,
) (err error) {
	// Request structure.
	request := &struct {
		RecordTaskID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordTaskID, err = soap.MarshalString(RecordTaskID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_1, "ResetRecordTask", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// ResetRecordTask is the legacy version of ResetRecordTaskCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording1) ResetRecordTask(RecordTaskID string) (err error) {
	return client.ResetRecordTaskCtx(context.Background(),
		RecordTaskID,
	)
}

// ScheduledRecording2 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:ScheduledRecording:2". See
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
// are provided for informational value.
type ScheduledRecording2 struct {
	goupnp.ServiceClient
}

// NewScheduledRecording2ClientsCtx discovers instances of the service on the network,
// and returns clients to any that are found. errors will contain an error for
// any devices that replied but which could not be queried, and err will be set
// if the discovery process failed outright.
//
// This is a typical entry calling point into this package.
func NewScheduledRecording2ClientsCtx(ctx context.Context) (clients []*ScheduledRecording2, errors []error, err error) {
	var genericClients []goupnp.ServiceClient
	if genericClients, errors, err = goupnp.NewServiceClientsCtx(ctx, URN_ScheduledRecording_2); err != nil {
		return
	}
	clients = newScheduledRecording2ClientsFromGenericClients(genericClients)
	return
}

// NewScheduledRecording2Clients is the legacy version of NewScheduledRecording2ClientsCtx, but uses
// context.Background() as the context.
func NewScheduledRecording2Clients() (clients []*ScheduledRecording2, errors []error, err error) {
	return NewScheduledRecording2ClientsCtx(context.Background())
}

// NewScheduledRecording2ClientsByURLCtx discovers instances of the service at the given
// URL, and returns clients to any that are found. An error is returned if
// there was an error probing the service.
//
// This is a typical entry calling point into this package when reusing an
// previously discovered service URL.
func NewScheduledRecording2ClientsByURLCtx(ctx context.Context, loc *url.URL) ([]*ScheduledRecording2, error) {
	genericClients, err := goupnp.NewServiceClientsByURLCtx(ctx, loc, URN_ScheduledRecording_2)
	if err != nil {
		return nil, err
	}
	return newScheduledRecording2ClientsFromGenericClients(genericClients), nil
}

// NewScheduledRecording2ClientsByURL is the legacy version of NewScheduledRecording2ClientsByURLCtx, but uses
// context.Background() as the context.
func NewScheduledRecording2ClientsByURL(loc *url.URL) ([]*ScheduledRecording2, error) {
	return NewScheduledRecording2ClientsByURLCtx(context.Background(), loc)
}

// NewScheduledRecording2ClientsFromRootDevice discovers instances of the service in
// a given root device, and returns clients to any that are found. An error is
// returned if there was not at least one instance of the service within the
// device. The location parameter is simply assigned to the Location attribute
// of the wrapped ServiceClient(s).
//
// This is a typical entry calling point into this package when reusing an
// previously discovered root device.
func NewScheduledRecording2ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*ScheduledRecording2, error) {
	genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_ScheduledRecording_2)
	if err != nil {
		return nil, err
	}
	return newScheduledRecording2ClientsFromGenericClients(genericClients), nil
}

func newScheduledRecording2ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*ScheduledRecording2 {
	clients := make([]*ScheduledRecording2, len(genericClients))
	for i := range genericClients {
		clients[i] = &ScheduledRecording2{genericClients[i]}
	}
	return clients
}

func (client *ScheduledRecording2) BrowseRecordSchedulesCtx(
	ctx context.Context,
	Filter string,
	StartingIndex uint32,
	RequestedCount uint32,
	SortCriteria string,
) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		Filter         string
		StartingIndex  string
		RequestedCount string
		SortCriteria   string
	}{}
	// BEGIN Marshal arguments into request.

	if request.Filter, err = soap.MarshalString(Filter); err != nil {
		return
	}
	if request.StartingIndex, err = soap.MarshalUi4(StartingIndex); err != nil {
		return
	}
	if request.RequestedCount, err = soap.MarshalUi4(RequestedCount); err != nil {
		return
	}
	if request.SortCriteria, err = soap.MarshalString(SortCriteria); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Result         string
		NumberReturned string
		TotalMatches   string
		UpdateID       string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_2, "BrowseRecordSchedules", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	if NumberReturned, err = soap.UnmarshalUi4(response.NumberReturned); err != nil {
		return
	}
	if TotalMatches, err = soap.UnmarshalUi4(response.TotalMatches); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// BrowseRecordSchedules is the legacy version of BrowseRecordSchedulesCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording2) BrowseRecordSchedules(Filter string, StartingIndex uint32, RequestedCount uint32, SortCriteria string) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	return client.BrowseRecordSchedulesCtx(context.Background(),
		Filter,
		StartingIndex,
		RequestedCount,
		SortCriteria,
	)
}

func (client *ScheduledRecording2) BrowseRecordTasksCtx(
	ctx context.Context,
	RecordScheduleID string,
	Filter string,
	StartingIndex uint32,
	RequestedCount uint32,
	SortCriteria string,
) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		RecordScheduleID string
		Filter           string
		StartingIndex    string
		RequestedCount   string
		SortCriteria     string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordScheduleID, err = soap.MarshalString(RecordScheduleID); err != nil {
		return
	}
	if request.Filter, err = soap.MarshalString(Filter); err != nil {
		return
	}
	if request.StartingIndex, err = soap.MarshalUi4(StartingIndex); err != nil {
		return
	}
	if request.RequestedCount, err = soap.MarshalUi4(RequestedCount); err != nil {
		return
	}
	if request.SortCriteria, err = soap.MarshalString(SortCriteria); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Result         string
		NumberReturned string
		TotalMatches   string
		UpdateID       string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_2, "BrowseRecordTasks", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	if NumberReturned, err = soap.UnmarshalUi4(response.NumberReturned); err != nil {
		return
	}
	if TotalMatches, err = soap.UnmarshalUi4(response.TotalMatches); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// BrowseRecordTasks is the legacy version of BrowseRecordTasksCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording2) BrowseRecordTasks(RecordScheduleID string, Filter string, StartingIndex uint32, RequestedCount uint32, SortCriteria string) (Result string, NumberReturned uint32, TotalMatches uint32, UpdateID uint32, err error) {
	return client.BrowseRecordTasksCtx(context.Background(),
		RecordScheduleID,
		Filter,
		StartingIndex,
		RequestedCount,
		SortCriteria,
	)
}

func (client *ScheduledRecording2) CreateRecordScheduleCtx(
	ctx context.Context,
	Elements string,
) (RecordScheduleID string, Result string, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		Elements string
	}{}
	// BEGIN Marshal arguments into request.

	if request.Elements, err = soap.MarshalString(Elements); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		RecordScheduleID string
		Result           string
		UpdateID         string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_2, "CreateRecordSchedule", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if RecordScheduleID, err = soap.UnmarshalString(response.RecordScheduleID); err != nil {
		return
	}
	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// CreateRecordSchedule is the legacy version of CreateRecordScheduleCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording2) CreateRecordSchedule(Elements string) (RecordScheduleID string, Result string, UpdateID uint32, err error) {
	return client.CreateRecordScheduleCtx(context.Background(),
		Elements,
	)
}

func (client *ScheduledRecording2) DeleteRecordScheduleCtx(
	ctx context.Context,
	RecordScheduleID string,
) (err error) {
	// Request structure.
	request := &struct {
		RecordScheduleID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordScheduleID, err = soap.MarshalString(RecordScheduleID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_2, "DeleteRecordSchedule", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// DeleteRecordSchedule is the legacy version of DeleteRecordScheduleCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording2) DeleteRecordSchedule(RecordScheduleID string) (err error) {
	return client.DeleteRecordScheduleCtx(context.Background(),
		RecordScheduleID,
	)
}

func (client *ScheduledRecording2) DeleteRecordTaskCtx(
	ctx context.Context,
	RecordTaskID string,
) (err error) {
	// Request structure.
	request := &struct {
		RecordTaskID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordTaskID, err = soap.MarshalString(RecordTaskID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_2, "DeleteRecordTask", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// DeleteRecordTask is the legacy version of DeleteRecordTaskCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording2) DeleteRecordTask(RecordTaskID string) (err error) {
	return client.DeleteRecordTaskCtx(context.Background(),
		RecordTaskID,
	)
}

func (client *ScheduledRecording2) DisableRecordScheduleCtx(
	ctx context.Context,
	RecordScheduleID string,
) (err error) {
	// Request structure.
	request := &struct {
		RecordScheduleID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordScheduleID, err = soap.MarshalString(RecordScheduleID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_2, "DisableRecordSchedule", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// DisableRecordSchedule is the legacy version of DisableRecordScheduleCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording2) DisableRecordSchedule(RecordScheduleID string) (err error) {
	return client.DisableRecordScheduleCtx(context.Background(),
		RecordScheduleID,
	)
}

func (client *ScheduledRecording2) DisableRecordTaskCtx(
	ctx context.Context,
	RecordTaskID string,
) (err error) {
	// Request structure.
	request := &struct {
		RecordTaskID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordTaskID, err = soap.MarshalString(RecordTaskID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_2, "DisableRecordTask", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// DisableRecordTask is the legacy version of DisableRecordTaskCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording2) DisableRecordTask(RecordTaskID string) (err error) {
	return client.DisableRecordTaskCtx(context.Background(),
		RecordTaskID,
	)
}

func (client *ScheduledRecording2) EnableRecordScheduleCtx(
	ctx context.Context,
	RecordScheduleID string,
) (err error) {
	// Request structure.
	request := &struct {
		RecordScheduleID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordScheduleID, err = soap.MarshalString(RecordScheduleID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_2, "EnableRecordSchedule", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// EnableRecordSchedule is the legacy version of EnableRecordScheduleCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording2) EnableRecordSchedule(RecordScheduleID string) (err error) {
	return client.EnableRecordScheduleCtx(context.Background(),
		RecordScheduleID,
	)
}

func (client *ScheduledRecording2) EnableRecordTaskCtx(
	ctx context.Context,
	RecordTaskID string,
) (err error) {
	// Request structure.
	request := &struct {
		RecordTaskID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordTaskID, err = soap.MarshalString(RecordTaskID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_2, "EnableRecordTask", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// EnableRecordTask is the legacy version of EnableRecordTaskCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording2) EnableRecordTask(RecordTaskID string) (err error) {
	return client.EnableRecordTaskCtx(context.Background(),
		RecordTaskID,
	)
}

//
// Arguments:
//
// * DataTypeID: allowed values: A_ARG_TYPE_RecordSchedule, A_ARG_TYPE_RecordTask, A_ARG_TYPE_RecordScheduleParts

func (client *ScheduledRecording2) GetAllowedValuesCtx(
	ctx context.Context,
	DataTypeID string,
	Filter string,
) (PropertyInfo string, err error) {
	// Request structure.
	request := &struct {
		DataTypeID string
		Filter     string
	}{}
	// BEGIN Marshal arguments into request.

	if request.DataTypeID, err = soap.MarshalString(DataTypeID); err != nil {
		return
	}
	if request.Filter, err = soap.MarshalString(Filter); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		PropertyInfo string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_2, "GetAllowedValues", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if PropertyInfo, err = soap.UnmarshalString(response.PropertyInfo); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetAllowedValues is the legacy version of GetAllowedValuesCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording2) GetAllowedValues(DataTypeID string, Filter string) (PropertyInfo string, err error) {
	return client.GetAllowedValuesCtx(context.Background(),
		DataTypeID,
		Filter,
	)
}

//
// Arguments:
//
// * DataTypeID: allowed values: A_ARG_TYPE_RecordSchedule, A_ARG_TYPE_RecordTask, A_ARG_TYPE_RecordScheduleParts

func (client *ScheduledRecording2) GetPropertyListCtx(
	ctx context.Context,
	DataTypeID string,
) (PropertyList string, err error) {
	// Request structure.
	request := &struct {
		DataTypeID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.DataTypeID, err = soap.MarshalString(DataTypeID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		PropertyList string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_2, "GetPropertyList", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if PropertyList, err = soap.UnmarshalString(response.PropertyList); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetPropertyList is the legacy version of GetPropertyListCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording2) GetPropertyList(DataTypeID string) (PropertyList string, err error) {
	return client.GetPropertyListCtx(context.Background(),
		DataTypeID,
	)
}

func (client *ScheduledRecording2) GetRecordScheduleCtx(
	ctx context.Context,
	RecordScheduleID string,
	Filter string,
) (Result string, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		RecordScheduleID string
		Filter           string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordScheduleID, err = soap.MarshalString(RecordScheduleID); err != nil {
		return
	}
	if request.Filter, err = soap.MarshalString(Filter); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Result   string
		UpdateID string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_2, "GetRecordSchedule", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetRecordSchedule is the legacy version of GetRecordScheduleCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording2) GetRecordSchedule(RecordScheduleID string, Filter string) (Result string, UpdateID uint32, err error) {
	return client.GetRecordScheduleCtx(context.Background(),
		RecordScheduleID,
		Filter,
	)
}

func (client *ScheduledRecording2) GetRecordScheduleConflictsCtx(
	ctx context.Context,
	RecordScheduleID string,
) (RecordScheduleConflictIDList string, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		RecordScheduleID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordScheduleID, err = soap.MarshalString(RecordScheduleID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		RecordScheduleConflictIDList string
		UpdateID                     string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_2, "GetRecordScheduleConflicts", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if RecordScheduleConflictIDList, err = soap.UnmarshalString(response.RecordScheduleConflictIDList); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetRecordScheduleConflicts is the legacy version of GetRecordScheduleConflictsCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording2) GetRecordScheduleConflicts(RecordScheduleID string) (RecordScheduleConflictIDList string, UpdateID uint32, err error) {
	return client.GetRecordScheduleConflictsCtx(context.Background(),
		RecordScheduleID,
	)
}

func (client *ScheduledRecording2) GetRecordTaskCtx(
	ctx context.Context,
	RecordTaskID string,
	Filter string,
) (Result string, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		RecordTaskID string
		Filter       string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordTaskID, err = soap.MarshalString(RecordTaskID); err != nil {
		return
	}
	if request.Filter, err = soap.MarshalString(Filter); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Result   string
		UpdateID string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_2, "GetRecordTask", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Result, err = soap.UnmarshalString(response.Result); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetRecordTask is the legacy version of GetRecordTaskCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording2) GetRecordTask(RecordTaskID string, Filter string) (Result string, UpdateID uint32, err error) {
	return client.GetRecordTaskCtx(context.Background(),
		RecordTaskID,
		Filter,
	)
}

func (client *ScheduledRecording2) GetRecordTaskConflictsCtx(
	ctx context.Context,
	RecordTaskID string,
) (RecordTaskConflictIDList string, UpdateID uint32, err error) {
	// Request structure.
	request := &struct {
		RecordTaskID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordTaskID, err = soap.MarshalString(RecordTaskID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		RecordTaskConflictIDList string
		UpdateID                 string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_2, "GetRecordTaskConflicts", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if RecordTaskConflictIDList, err = soap.UnmarshalString(response.RecordTaskConflictIDList); err != nil {
		return
	}
	if UpdateID, err = soap.UnmarshalUi4(response.UpdateID); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetRecordTaskConflicts is the legacy version of GetRecordTaskConflictsCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording2) GetRecordTaskConflicts(RecordTaskID string) (RecordTaskConflictIDList string, UpdateID uint32, err error) {
	return client.GetRecordTaskConflictsCtx(context.Background(),
		RecordTaskID,
	)
}

func (client *ScheduledRecording2) GetSortCapabilitiesCtx(
	ctx context.Context,
) (SortCaps string, SortLevelCap uint32, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		SortCaps     string
		SortLevelCap string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_2, "GetSortCapabilities", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if SortCaps, err = soap.UnmarshalString(response.SortCaps); err != nil {
		return
	}
	if SortLevelCap, err = soap.UnmarshalUi4(response.SortLevelCap); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetSortCapabilities is the legacy version of GetSortCapabilitiesCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording2) GetSortCapabilities() (SortCaps string, SortLevelCap uint32, err error) {
	return client.GetSortCapabilitiesCtx(context.Background())
}

func (client *ScheduledRecording2) GetStateUpdateIDCtx(
	ctx context.Context,
) (Id uint32, err error) {
	// Request structure.
	request := interface{}(nil)
	// BEGIN Marshal arguments into request.

	// END Marshal arguments into request.

	// Response structure.
	response := &struct {
		Id string
	}{}

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_2, "GetStateUpdateID", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	if Id, err = soap.UnmarshalUi4(response.Id); err != nil {
		return
	}
	// END Unmarshal arguments from response.
	return
}

// GetStateUpdateID is the legacy version of GetStateUpdateIDCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording2) GetStateUpdateID() (Id uint32, err error) {
	return client.GetStateUpdateIDCtx(context.Background())
}

func (client *ScheduledRecording2) ResetRecordTaskCtx(
	ctx context.Context,
	RecordTaskID string,
) (err error) {
	// Request structure.
	request := &struct {
		RecordTaskID string
	}{}
	// BEGIN Marshal arguments into request.

	if request.RecordTaskID, err = soap.MarshalString(RecordTaskID); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformActionCtx(ctx, URN_ScheduledRecording_2, "ResetRecordTask", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}

// ResetRecordTask is the legacy version of ResetRecordTaskCtx, but uses
// context.Background() as the context.
func (client *ScheduledRecording2) ResetRecordTask(RecordTaskID string) (err error) {
	return client.ResetRecordTaskCtx(context.Background(),
		RecordTaskID,
	)
}