func (up *Update) Hide() error {
	r, err := oleutil.PutProperty(up.Item, "IsHidden", true)
	if err != nil {
		return fmt.Errorf("unable to hide update: [%s] [%v]", errors.UpdateError(r.Val), err)
	}
	up.IsHidden = true
	return nil
}
Hide sets a Boolean value that hides the update from future search results.
package updates
import (
	"fmt"
	"reflect"
	"time"
	"github.com/google/cabbie/cablib"
	"github.com/google/cabbie/errors"
	"github.com/go-ole/go-ole"
	"github.com/go-ole/go-ole/oleutil"
)
type Identity struct {
	RevisionNumber int
	UpdateID       string
}
type Category struct {
	Name       string
	Type       string
	CategoryID string
}
type Update struct {
	Item                     *ole.IDispatch
	Title                    string
	CanRequireSource         bool
	Categories               []Category
	Deadline                 time.Time
	Description              string
	EulaAccepted             bool
	Identity                 Identity
	IsBeta                   bool
	IsDownloaded             bool
	IsHidden                 bool
	IsInstalled              bool
	IsMandatory              bool
	IsUninstallable          bool
	LastDeploymentChangeTime time.Time
	MaxDownloadSize          int
	MinDownloadSize          int
	MsrcSeverity             string
	RecommendedCPUSpeed      int
	RecommendedHardDiskSpace int
	RecommendedMemory        int
	SecurityBulletinIDs      []string
	SupersededUpdateIDs      []string
	SupportURL               string
	Type                     string
	KBArticleIDs             []string
	RebootRequired           bool
	IsPresent                bool
	CveIDs                   []string
	BrowseOnly               bool
	PerUser                  bool
	AutoSelection            int
	AutoDownload             int
}
func New(item *ole.IDispatch) (*Update, []error) {
	var errors []error
	u := &Update{Item: item}
	fields := reflect.TypeOf(*u)
	data := make(map[string]interface{})
	var err error
	for i := 0; i < fields.NumField(); i++ {
		field := fields.Field(i)
		p := field.Name
		switch field.Type.String() {
		case "string":
			data[p], err = u.toString(p)
			if err != nil {
				errors = append(errors, err)
			}
		case "bool":
			data[p], err = u.toBool(p)
			if err != nil {
				errors = append(errors, err)
			}
		case "int":
			data[p], err = u.toInt(p)
			if err != nil {
				errors = append(errors, err)
			}
		case "[]string":
			data[p], err = u.toStringSlice(p)
			if err != nil {
				errors = append(errors, err)
			}
		case "time.Time":
			data[p], err = u.toDateTime(p)
			if err != nil {
				errors = append(errors, err)
			}
		case "[]updates.Category":
			data[p], err = u.toCategories(p)
			if err != nil {
				errors = append(errors, err)
			}
		case "updates.Identity":
			data[p], err = u.toIdentity(p)
			if err != nil {
				errors = append(errors, err)
			}
		}
	}
	if err := u.fillStruct(data); err != nil {
		errors = append(errors, err)
	}
	return u, errors
}
func (up *Update) AcceptEula() error {
	r, err := oleutil.CallMethod(up.Item, "AcceptEula")
	if err != nil {
		return fmt.Errorf("unable to accept Eula: [%s] [%v]", errors.UpdateError(r.Val), err)
	}
	up.EulaAccepted = true
	return nil
}