/*
Hindsight HTTP API

HTTP API for Hindsight

API version: 0.5.3
*/

// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

package hindsight

import (
	"encoding/json"
	"bytes"
	"fmt"
)

// checks if the ReflectToolCall type satisfies the MappedNullable interface at compile time
var _ MappedNullable = &ReflectToolCall{}

// ReflectToolCall A tool call made during reflect agent execution.
type ReflectToolCall struct {
	// Tool name: lookup, recall, learn, expand
	Tool string `json:"tool"`
	// Tool input parameters
	Input map[string]interface{} `json:"input"`
	Output map[string]interface{} `json:"output,omitempty"`
	// Execution time in milliseconds
	DurationMs int32 `json:"duration_ms"`
	// Iteration number (1-based) when this tool was called
	Iteration *int32 `json:"iteration,omitempty"`
}

type _ReflectToolCall ReflectToolCall

// NewReflectToolCall instantiates a new ReflectToolCall object
// This constructor will assign default values to properties that have it defined,
// and makes sure properties required by API are set, but the set of arguments
// will change when the set of required properties is changed
func NewReflectToolCall(tool string, input map[string]interface{}, durationMs int32) *ReflectToolCall {
	this := ReflectToolCall{}
	this.Tool = tool
	this.Input = input
	this.DurationMs = durationMs
	var iteration int32 = 0
	this.Iteration = &iteration
	return &this
}

// NewReflectToolCallWithDefaults instantiates a new ReflectToolCall object
// This constructor will only assign default values to properties that have it defined,
// but it doesn't guarantee that properties required by API are set
func NewReflectToolCallWithDefaults() *ReflectToolCall {
	this := ReflectToolCall{}
	var iteration int32 = 0
	this.Iteration = &iteration
	return &this
}

// GetTool returns the Tool field value
func (o *ReflectToolCall) GetTool() string {
	if o == nil {
		var ret string
		return ret
	}

	return o.Tool
}

// GetToolOk returns a tuple with the Tool field value
// and a boolean to check if the value has been set.
func (o *ReflectToolCall) GetToolOk() (*string, bool) {
	if o == nil {
		return nil, false
	}
	return &o.Tool, true
}

// SetTool sets field value
func (o *ReflectToolCall) SetTool(v string) {
	o.Tool = v
}

// GetInput returns the Input field value
func (o *ReflectToolCall) GetInput() map[string]interface{} {
	if o == nil {
		var ret map[string]interface{}
		return ret
	}

	return o.Input
}

// GetInputOk returns a tuple with the Input field value
// and a boolean to check if the value has been set.
func (o *ReflectToolCall) GetInputOk() (map[string]interface{}, bool) {
	if o == nil {
		return map[string]interface{}{}, false
	}
	return o.Input, true
}

// SetInput sets field value
func (o *ReflectToolCall) SetInput(v map[string]interface{}) {
	o.Input = v
}

// GetOutput returns the Output field value if set, zero value otherwise (both if not set or set to explicit null).
func (o *ReflectToolCall) GetOutput() map[string]interface{} {
	if o == nil {
		var ret map[string]interface{}
		return ret
	}
	return o.Output
}

// GetOutputOk returns a tuple with the Output field value if set, nil otherwise
// and a boolean to check if the value has been set.
// NOTE: If the value is an explicit nil, `nil, true` will be returned
func (o *ReflectToolCall) GetOutputOk() (map[string]interface{}, bool) {
	if o == nil || IsNil(o.Output) {
		return map[string]interface{}{}, false
	}
	return o.Output, true
}

// HasOutput returns a boolean if a field has been set.
func (o *ReflectToolCall) HasOutput() bool {
	if o != nil && !IsNil(o.Output) {
		return true
	}

	return false
}

// SetOutput gets a reference to the given map[string]interface{} and assigns it to the Output field.
func (o *ReflectToolCall) SetOutput(v map[string]interface{}) {
	o.Output = v
}

// GetDurationMs returns the DurationMs field value
func (o *ReflectToolCall) GetDurationMs() int32 {
	if o == nil {
		var ret int32
		return ret
	}

	return o.DurationMs
}

// GetDurationMsOk returns a tuple with the DurationMs field value
// and a boolean to check if the value has been set.
func (o *ReflectToolCall) GetDurationMsOk() (*int32, bool) {
	if o == nil {
		return nil, false
	}
	return &o.DurationMs, true
}

// SetDurationMs sets field value
func (o *ReflectToolCall) SetDurationMs(v int32) {
	o.DurationMs = v
}

// GetIteration returns the Iteration field value if set, zero value otherwise.
func (o *ReflectToolCall) GetIteration() int32 {
	if o == nil || IsNil(o.Iteration) {
		var ret int32
		return ret
	}
	return *o.Iteration
}

// GetIterationOk returns a tuple with the Iteration field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *ReflectToolCall) GetIterationOk() (*int32, bool) {
	if o == nil || IsNil(o.Iteration) {
		return nil, false
	}
	return o.Iteration, true
}

// HasIteration returns a boolean if a field has been set.
func (o *ReflectToolCall) HasIteration() bool {
	if o != nil && !IsNil(o.Iteration) {
		return true
	}

	return false
}

// SetIteration gets a reference to the given int32 and assigns it to the Iteration field.
func (o *ReflectToolCall) SetIteration(v int32) {
	o.Iteration = &v
}

func (o ReflectToolCall) MarshalJSON() ([]byte, error) {
	toSerialize,err := o.ToMap()
	if err != nil {
		return []byte{}, err
	}
	return json.Marshal(toSerialize)
}

func (o ReflectToolCall) ToMap() (map[string]interface{}, error) {
	toSerialize := map[string]interface{}{}
	toSerialize["tool"] = o.Tool
	toSerialize["input"] = o.Input
	if o.Output != nil {
		toSerialize["output"] = o.Output
	}
	toSerialize["duration_ms"] = o.DurationMs
	if !IsNil(o.Iteration) {
		toSerialize["iteration"] = o.Iteration
	}
	return toSerialize, nil
}

func (o *ReflectToolCall) UnmarshalJSON(data []byte) (err error) {
	// This validates that all required properties are included in the JSON object
	// by unmarshalling the object into a generic map with string keys and checking
	// that every required field exists as a key in the generic map.
	requiredProperties := []string{
		"tool",
		"input",
		"duration_ms",
	}

	allProperties := make(map[string]interface{})

	err = json.Unmarshal(data, &allProperties)

	if err != nil {
		return err;
	}

	for _, requiredProperty := range(requiredProperties) {
		if _, exists := allProperties[requiredProperty]; !exists {
			return fmt.Errorf("no value given for required property %v", requiredProperty)
		}
	}

	varReflectToolCall := _ReflectToolCall{}

	decoder := json.NewDecoder(bytes.NewReader(data))
	decoder.DisallowUnknownFields()
	err = decoder.Decode(&varReflectToolCall)

	if err != nil {
		return err
	}

	*o = ReflectToolCall(varReflectToolCall)

	return err
}

type NullableReflectToolCall struct {
	value *ReflectToolCall
	isSet bool
}

func (v NullableReflectToolCall) Get() *ReflectToolCall {
	return v.value
}

func (v *NullableReflectToolCall) Set(val *ReflectToolCall) {
	v.value = val
	v.isSet = true
}

func (v NullableReflectToolCall) IsSet() bool {
	return v.isSet
}

func (v *NullableReflectToolCall) Unset() {
	v.value = nil
	v.isSet = false
}

func NewNullableReflectToolCall(val *ReflectToolCall) *NullableReflectToolCall {
	return &NullableReflectToolCall{value: val, isSet: true}
}

func (v NullableReflectToolCall) MarshalJSON() ([]byte, error) {
	return json.Marshal(v.value)
}

func (v *NullableReflectToolCall) UnmarshalJSON(src []byte) error {
	v.isSet = true
	return json.Unmarshal(src, &v.value)
}


