// PutParams returns a map of parameters for an MaintenanceWindow that can be sent along.
17770
func (ck *MaintenanceWindow) PutParams() map[string]string {
	m := map[string]string{
		"description": ck.Description,
		"from":        strconv.FormatInt(ck.From, 10),
		"to":          strconv.FormatInt(ck.To, 10),
	}

	// Ignore if not defined
	if ck.RecurrenceType != "" {
		m["recurrencetype"] = ck.RecurrenceType
	}

	if ck.UptimeIDs != "" {
		m["uptimeids"] = ck.UptimeIDs
	}

	if ck.TmsIDs != "" {
		m["tmsids"] = ck.TmsIDs
	}

	if ck.RepeatEvery != 0 {
		m["repeatevery"] = strconv.Itoa(ck.RepeatEvery)
	}

	if ck.EffectiveTo != 0 {
		m["effectiveto"] = strconv.Itoa(ck.EffectiveTo)
	}

	return m
}
428634
func (s *JobDefinition) SetParameters(v map[string]*string) *JobDefinition {
	s.Parameters = v
	return s
}
600227
func (s *StartSessionInput) SetParameters(v map[string][]*string) *StartSessionInput {
	s.Parameters = v
	return s
}
1198929
func (s *GetMaintenanceWindowTaskOutput) SetTaskParameters(v map[string]*MaintenanceWindowTaskParameterValueExpression) *GetMaintenanceWindowTaskOutput {
	s.TaskParameters = v
	return s
}
424077
func (m *MultiMap) Put(key interface{}, value interface{}) {
	m.m[key] = append(m.m[key], value)
}
1082625
func SetViewUpdateParams(baseU string, params map[string]interface{}) (viewOpts map[string]interface{}, err error) {

	c := &Client{}
	c.BaseURL, err = ParseURL(baseU)
	if err != nil {
		return
	}
	c.ah = basicAuthFromURL(baseU)

	if len(params) < 1 {
		return nil, fmt.Errorf("No params to set")
	}

	err = c.parsePostURLResponse("/settings/viewUpdateDaemon", params, &viewOpts)
	if err != nil {
		return
	}
	return viewOpts, err
}
81740
func (s *UpdateStackInput) SetParameters(v []*Parameter) *UpdateStackInput {
	s.Parameters = v
	return s
}
650520
func (s *Connector) SetParameters(v map[string]*string) *Connector {
	s.Parameters = v
	return s
}
237368
func (m *Memory) Put(ctx context.Context, i backend.Item) (*backend.Lease, error) {
	if len(i.Key) == 0 {
		return nil, trace.BadParameter("missing parameter key")
	}
	m.Lock()
	defer m.Unlock()
	m.removeExpired()
	event := backend.Event{
		Type: backend.OpPut,
		Item: i,
	}
	m.processEvent(event)
	if !m.EventsOff {
		m.buf.Push(event)
	}
	return m.newLease(i), nil
}
170560
func (s *CreateProvisioningArtifactInput) SetParameters(v *ProvisioningArtifactProperties) *CreateProvisioningArtifactInput {
	s.Parameters = v
	return s
}
1107740
func (bridge *Bridge) Put(path string, params interface{}) ([]byte, io.Reader, error) {
	uri := fmt.Sprintf("http://" + bridge.IPAddress + path)
	client := &http.Client{Timeout: time.Second * 5}

	data, err := json.Marshal(params)
	if err != nil {
		err = errors.New("unable to marshal PUT request interface")
		return []byte{}, nil, err
	}
	//fmt.Println("\n\nPARAMS: ", params)

	request, _ := http.NewRequest("PUT", uri, bytes.NewReader(data))
	resp, err := client.Do(request)
	if err != nil {
		err = errors.New("unable to access bridge")
		return []byte{}, nil, err
	}
	return HandleResponse(resp)
}
640865
func (s *MaintenanceWindowAutomationParameters) SetParameters(v map[string][]*string) *MaintenanceWindowAutomationParameters {
	s.Parameters = v
	return s
}
1349423
func (s *TaskScheduledEventDetails) SetParameters(v string) *TaskScheduledEventDetails {
	s.Parameters = &v
	return s
}
233236
func (s *ServerProcess) SetParameters(v string) *ServerProcess {
	s.Parameters = &v
	return s
}
660106
func (r *Route) PutFunc(f http.HandlerFunc) *Route {
	return r.Put(http.HandlerFunc(f))
}
225902
func (s *CreateAssociationInput) SetParameters(v map[string][]*string) *CreateAssociationInput {
	s.Parameters = v
	return s
}
1205226
func (s *Update) SetParams(v []*UpdateParam) *Update {
	s.Params = v
	return s
}