// Code generated by go-swagger; DO NOT EDIT.

package a_bit_of_everything

import (
	"context"
	"net/http"
	"time"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/runtime"
	cr "github.com/go-openapi/runtime/client"
	"github.com/go-openapi/strfmt"
	"github.com/go-openapi/swag"
)

// NewABitOfEverythingServiceDoubleColonParams creates a new ABitOfEverythingServiceDoubleColonParams object,
// with the default timeout for this client.
//
// Default values are not hydrated, since defaults are normally applied by the API server side.
//
// To enforce default values in parameter, use SetDefaults or WithDefaults.
func NewABitOfEverythingServiceDoubleColonParams() *ABitOfEverythingServiceDoubleColonParams {
	return &ABitOfEverythingServiceDoubleColonParams{
		timeout: cr.DefaultTimeout,
	}
}

// NewABitOfEverythingServiceDoubleColonParamsWithTimeout creates a new ABitOfEverythingServiceDoubleColonParams object
// with the ability to set a timeout on a request.
func NewABitOfEverythingServiceDoubleColonParamsWithTimeout(timeout time.Duration) *ABitOfEverythingServiceDoubleColonParams {
	return &ABitOfEverythingServiceDoubleColonParams{
		timeout: timeout,
	}
}

// NewABitOfEverythingServiceDoubleColonParamsWithContext creates a new ABitOfEverythingServiceDoubleColonParams object
// with the ability to set a context for a request.
func NewABitOfEverythingServiceDoubleColonParamsWithContext(ctx context.Context) *ABitOfEverythingServiceDoubleColonParams {
	return &ABitOfEverythingServiceDoubleColonParams{
		Context: ctx,
	}
}

// NewABitOfEverythingServiceDoubleColonParamsWithHTTPClient creates a new ABitOfEverythingServiceDoubleColonParams object
// with the ability to set a custom HTTPClient for a request.
func NewABitOfEverythingServiceDoubleColonParamsWithHTTPClient(client *http.Client) *ABitOfEverythingServiceDoubleColonParams {
	return &ABitOfEverythingServiceDoubleColonParams{
		HTTPClient: client,
	}
}

/*
ABitOfEverythingServiceDoubleColonParams contains all the parameters to send to the API endpoint

	for the a bit of everything service double colon operation.

	Typically these are written to a http.Request.
*/
type ABitOfEverythingServiceDoubleColonParams struct {

	// BoolValue.
	BoolValue *bool

	// BytesValue.
	//
	// Format: byte
	BytesValue *strfmt.Base64

	// DoubleValue.
	//
	// Format: double
	DoubleValue float64

	/* EnumValue.

	     - ZERO: ZERO means 0
	- ONE: ONE means 1

	    Default: "ZERO"
	*/
	EnumValue *string

	/* EnumValueAnnotation.

	     Numeric enum title

	Numeric enum description.

	 - ZERO: ZERO means 0
	 - ONE: ONE means 1

	     Default: "ZERO"
	*/
	EnumValueAnnotation *string

	// Fixed32Value.
	//
	// Format: int64
	Fixed32Value *int64

	// Fixed64Value.
	//
	// Format: uint64
	Fixed64Value *string

	/* FloatValue.

	   Float value field

	   Format: float
	   Default: 0.2
	*/
	FloatValue float32

	// Int32Value.
	//
	// Format: int32
	Int32Value *int32

	// Int64OverrideType.
	//
	// Format: int64
	Int64OverrideType *string

	// Int64Value.
	//
	// Format: int64
	Int64Value string

	/* MapValue.

	   map of numeric enum
	*/
	MapValue *string

	// MappedNestedValue.
	MappedNestedValue *string

	/* MappedStringValue.

	     Map of string title

	Map of string description.
	*/
	MappedStringValue *string

	// NestedAnnotationAmount.
	//
	// Format: int64
	NestedAnnotationAmount *int64

	/* NestedAnnotationName.

	   name is nested field.
	*/
	NestedAnnotationName *string

	/* NestedAnnotationOk.

	    DeepEnum description.

	- FALSE: FALSE is false.
	- TRUE: TRUE is true.

	    Default: "FALSE"
	*/
	NestedAnnotationOk *string

	// NestedPathEnumValue.
	//
	// Default: "GHI"
	NestedPathEnumValue *string

	// NonConventionalNameValue.
	NonConventionalNameValue *string

	// OneofEmpty.
	OneofEmpty *string

	// OneofString.
	OneofString *string

	/* OptionalStringField.

	   Test openapiv2 generation of required fields with annotation and jsonschema to reproduce
	*/
	OptionalStringField *string

	// OptionalStringValue.
	OptionalStringValue *string

	/* OutputOnlyStringViaFieldBehaviorAnnotation.

	   mark a field as readonly in Open API definition
	*/
	OutputOnlyStringViaFieldBehaviorAnnotation *string

	// PathEnumValue.
	//
	// Default: "ABC"
	PathEnumValue *string

	/* ProductID.

	     Test openapiv2 generation of repeated fields

	Only digits are allowed.
	*/
	ProductID []string

	/* RepeatedEnumAnnotation.

	     Repeated numeric enum title

	Repeated numeric enum description.

	 - ZERO: ZERO means 0
	 - ONE: ONE means 1
	*/
	RepeatedEnumAnnotation []string

	/* RepeatedEnumValue.

	    repeated enum value. it is comma-separated in query

	- ZERO: ZERO means 0
	- ONE: ONE means 1
	*/
	RepeatedEnumValue []string

	/* RepeatedStringAnnotation.

	     Repeated string title

	Repeated string description.
	*/
	RepeatedStringAnnotation []string

	// RepeatedStringValue.
	RepeatedStringValue []string

	// RequiredStringField1.
	RequiredStringField1 string

	// RequiredStringField2.
	RequiredStringField2 string

	/* RequiredStringViaFieldBehaviorAnnotation.

	   mark a field as required in Open API definition
	*/
	RequiredStringViaFieldBehaviorAnnotation string

	/* RequiredFieldBehaviorJSONNameCustom.

	   Test openapiv2 handling of required json_name fields
	*/
	RequiredFieldBehaviorJSONNameCustom string

	// RequiredFieldSchemaJSONNameCustom.
	RequiredFieldSchemaJSONNameCustom string

	// Sfixed32Value.
	//
	// Format: int32
	Sfixed32Value *int32

	// Sfixed64Value.
	//
	// Format: int64
	Sfixed64Value *string

	// SingleNestedAmount.
	//
	// Format: int64
	SingleNestedAmount *int64

	/* SingleNestedName.

	   name is nested field.
	*/
	SingleNestedName *string

	/* SingleNestedOk.

	    DeepEnum description.

	- FALSE: FALSE is false.
	- TRUE: TRUE is true.

	    Default: "FALSE"
	*/
	SingleNestedOk *string

	// Sint32Value.
	//
	// Format: int32
	Sint32Value *int32

	// Sint64Value.
	//
	// Format: int64
	Sint64Value *string

	// StringValue.
	StringValue *string

	// TimestampValue.
	//
	// Format: date-time
	TimestampValue *strfmt.DateTime

	/* TrailingBoth.

	     Leading both

	Trailing both.
	*/
	TrailingBoth *string

	/* TrailingMultiline.

	     Leading multiline

	This is an example of a multi-line comment.

	Trailing multiline.
	*/
	TrailingMultiline *string

	/* TrailingOnly.

	   Trailing only
	*/
	TrailingOnly *string

	/* TrailingOnlyDot.

	   Trailing only dot.
	*/
	TrailingOnlyDot *string

	// Uint32Value.
	//
	// Format: int64
	Uint32Value *int64

	// Uint64Value.
	//
	// Format: uint64
	Uint64Value *string

	// UUIDName.
	//
	// Format: uuid
	UUIDName strfmt.UUID

	/* Uuids.

	   Specify a custom format of repeated field items
	*/
	Uuids []strfmt.UUID

	timeout    time.Duration
	Context    context.Context
	HTTPClient *http.Client
}

// WithDefaults hydrates default values in the a bit of everything service double colon params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *ABitOfEverythingServiceDoubleColonParams) WithDefaults() *ABitOfEverythingServiceDoubleColonParams {
	o.SetDefaults()
	return o
}

// SetDefaults hydrates default values in the a bit of everything service double colon params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *ABitOfEverythingServiceDoubleColonParams) SetDefaults() {
	var (
		enumValueDefault = string("ZERO")

		enumValueAnnotationDefault = string("ZERO")

		floatValueDefault = float32(0.2)

		nestedAnnotationOkDefault = string("FALSE")

		nestedPathEnumValueDefault = string("GHI")

		pathEnumValueDefault = string("ABC")

		singleNestedOkDefault = string("FALSE")
	)

	val := ABitOfEverythingServiceDoubleColonParams{
		EnumValue:           &enumValueDefault,
		EnumValueAnnotation: &enumValueAnnotationDefault,
		FloatValue:          floatValueDefault,
		NestedAnnotationOk:  &nestedAnnotationOkDefault,
		NestedPathEnumValue: &nestedPathEnumValueDefault,
		PathEnumValue:       &pathEnumValueDefault,
		SingleNestedOk:      &singleNestedOkDefault,
	}

	val.timeout = o.timeout
	val.Context = o.Context
	val.HTTPClient = o.HTTPClient
	*o = val
}

// WithTimeout adds the timeout to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithTimeout(timeout time.Duration) *ABitOfEverythingServiceDoubleColonParams {
	o.SetTimeout(timeout)
	return o
}

// SetTimeout adds the timeout to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetTimeout(timeout time.Duration) {
	o.timeout = timeout
}

// WithContext adds the context to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithContext(ctx context.Context) *ABitOfEverythingServiceDoubleColonParams {
	o.SetContext(ctx)
	return o
}

// SetContext adds the context to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetContext(ctx context.Context) {
	o.Context = ctx
}

// WithHTTPClient adds the HTTPClient to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithHTTPClient(client *http.Client) *ABitOfEverythingServiceDoubleColonParams {
	o.SetHTTPClient(client)
	return o
}

// SetHTTPClient adds the HTTPClient to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetHTTPClient(client *http.Client) {
	o.HTTPClient = client
}

// WithBoolValue adds the boolValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithBoolValue(boolValue *bool) *ABitOfEverythingServiceDoubleColonParams {
	o.SetBoolValue(boolValue)
	return o
}

// SetBoolValue adds the boolValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetBoolValue(boolValue *bool) {
	o.BoolValue = boolValue
}

// WithBytesValue adds the bytesValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithBytesValue(bytesValue *strfmt.Base64) *ABitOfEverythingServiceDoubleColonParams {
	o.SetBytesValue(bytesValue)
	return o
}

// SetBytesValue adds the bytesValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetBytesValue(bytesValue *strfmt.Base64) {
	o.BytesValue = bytesValue
}

// WithDoubleValue adds the doubleValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithDoubleValue(doubleValue float64) *ABitOfEverythingServiceDoubleColonParams {
	o.SetDoubleValue(doubleValue)
	return o
}

// SetDoubleValue adds the doubleValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetDoubleValue(doubleValue float64) {
	o.DoubleValue = doubleValue
}

// WithEnumValue adds the enumValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithEnumValue(enumValue *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetEnumValue(enumValue)
	return o
}

// SetEnumValue adds the enumValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetEnumValue(enumValue *string) {
	o.EnumValue = enumValue
}

// WithEnumValueAnnotation adds the enumValueAnnotation to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithEnumValueAnnotation(enumValueAnnotation *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetEnumValueAnnotation(enumValueAnnotation)
	return o
}

// SetEnumValueAnnotation adds the enumValueAnnotation to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetEnumValueAnnotation(enumValueAnnotation *string) {
	o.EnumValueAnnotation = enumValueAnnotation
}

// WithFixed32Value adds the fixed32Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithFixed32Value(fixed32Value *int64) *ABitOfEverythingServiceDoubleColonParams {
	o.SetFixed32Value(fixed32Value)
	return o
}

// SetFixed32Value adds the fixed32Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetFixed32Value(fixed32Value *int64) {
	o.Fixed32Value = fixed32Value
}

// WithFixed64Value adds the fixed64Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithFixed64Value(fixed64Value *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetFixed64Value(fixed64Value)
	return o
}

// SetFixed64Value adds the fixed64Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetFixed64Value(fixed64Value *string) {
	o.Fixed64Value = fixed64Value
}

// WithFloatValue adds the floatValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithFloatValue(floatValue float32) *ABitOfEverythingServiceDoubleColonParams {
	o.SetFloatValue(floatValue)
	return o
}

// SetFloatValue adds the floatValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetFloatValue(floatValue float32) {
	o.FloatValue = floatValue
}

// WithInt32Value adds the int32Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithInt32Value(int32Value *int32) *ABitOfEverythingServiceDoubleColonParams {
	o.SetInt32Value(int32Value)
	return o
}

// SetInt32Value adds the int32Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetInt32Value(int32Value *int32) {
	o.Int32Value = int32Value
}

// WithInt64OverrideType adds the int64OverrideType to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithInt64OverrideType(int64OverrideType *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetInt64OverrideType(int64OverrideType)
	return o
}

// SetInt64OverrideType adds the int64OverrideType to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetInt64OverrideType(int64OverrideType *string) {
	o.Int64OverrideType = int64OverrideType
}

// WithInt64Value adds the int64Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithInt64Value(int64Value string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetInt64Value(int64Value)
	return o
}

// SetInt64Value adds the int64Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetInt64Value(int64Value string) {
	o.Int64Value = int64Value
}

// WithMapValue adds the mapValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithMapValue(mapValue *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetMapValue(mapValue)
	return o
}

// SetMapValue adds the mapValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetMapValue(mapValue *string) {
	o.MapValue = mapValue
}

// WithMappedNestedValue adds the mappedNestedValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithMappedNestedValue(mappedNestedValue *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetMappedNestedValue(mappedNestedValue)
	return o
}

// SetMappedNestedValue adds the mappedNestedValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetMappedNestedValue(mappedNestedValue *string) {
	o.MappedNestedValue = mappedNestedValue
}

// WithMappedStringValue adds the mappedStringValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithMappedStringValue(mappedStringValue *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetMappedStringValue(mappedStringValue)
	return o
}

// SetMappedStringValue adds the mappedStringValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetMappedStringValue(mappedStringValue *string) {
	o.MappedStringValue = mappedStringValue
}

// WithNestedAnnotationAmount adds the nestedAnnotationAmount to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithNestedAnnotationAmount(nestedAnnotationAmount *int64) *ABitOfEverythingServiceDoubleColonParams {
	o.SetNestedAnnotationAmount(nestedAnnotationAmount)
	return o
}

// SetNestedAnnotationAmount adds the nestedAnnotationAmount to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetNestedAnnotationAmount(nestedAnnotationAmount *int64) {
	o.NestedAnnotationAmount = nestedAnnotationAmount
}

// WithNestedAnnotationName adds the nestedAnnotationName to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithNestedAnnotationName(nestedAnnotationName *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetNestedAnnotationName(nestedAnnotationName)
	return o
}

// SetNestedAnnotationName adds the nestedAnnotationName to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetNestedAnnotationName(nestedAnnotationName *string) {
	o.NestedAnnotationName = nestedAnnotationName
}

// WithNestedAnnotationOk adds the nestedAnnotationOk to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithNestedAnnotationOk(nestedAnnotationOk *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetNestedAnnotationOk(nestedAnnotationOk)
	return o
}

// SetNestedAnnotationOk adds the nestedAnnotationOk to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetNestedAnnotationOk(nestedAnnotationOk *string) {
	o.NestedAnnotationOk = nestedAnnotationOk
}

// WithNestedPathEnumValue adds the nestedPathEnumValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithNestedPathEnumValue(nestedPathEnumValue *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetNestedPathEnumValue(nestedPathEnumValue)
	return o
}

// SetNestedPathEnumValue adds the nestedPathEnumValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetNestedPathEnumValue(nestedPathEnumValue *string) {
	o.NestedPathEnumValue = nestedPathEnumValue
}

// WithNonConventionalNameValue adds the nonConventionalNameValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithNonConventionalNameValue(nonConventionalNameValue *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetNonConventionalNameValue(nonConventionalNameValue)
	return o
}

// SetNonConventionalNameValue adds the nonConventionalNameValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetNonConventionalNameValue(nonConventionalNameValue *string) {
	o.NonConventionalNameValue = nonConventionalNameValue
}

// WithOneofEmpty adds the oneofEmpty to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithOneofEmpty(oneofEmpty *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetOneofEmpty(oneofEmpty)
	return o
}

// SetOneofEmpty adds the oneofEmpty to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetOneofEmpty(oneofEmpty *string) {
	o.OneofEmpty = oneofEmpty
}

// WithOneofString adds the oneofString to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithOneofString(oneofString *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetOneofString(oneofString)
	return o
}

// SetOneofString adds the oneofString to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetOneofString(oneofString *string) {
	o.OneofString = oneofString
}

// WithOptionalStringField adds the optionalStringField to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithOptionalStringField(optionalStringField *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetOptionalStringField(optionalStringField)
	return o
}

// SetOptionalStringField adds the optionalStringField to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetOptionalStringField(optionalStringField *string) {
	o.OptionalStringField = optionalStringField
}

// WithOptionalStringValue adds the optionalStringValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithOptionalStringValue(optionalStringValue *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetOptionalStringValue(optionalStringValue)
	return o
}

// SetOptionalStringValue adds the optionalStringValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetOptionalStringValue(optionalStringValue *string) {
	o.OptionalStringValue = optionalStringValue
}

// WithOutputOnlyStringViaFieldBehaviorAnnotation adds the outputOnlyStringViaFieldBehaviorAnnotation to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithOutputOnlyStringViaFieldBehaviorAnnotation(outputOnlyStringViaFieldBehaviorAnnotation *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetOutputOnlyStringViaFieldBehaviorAnnotation(outputOnlyStringViaFieldBehaviorAnnotation)
	return o
}

// SetOutputOnlyStringViaFieldBehaviorAnnotation adds the outputOnlyStringViaFieldBehaviorAnnotation to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetOutputOnlyStringViaFieldBehaviorAnnotation(outputOnlyStringViaFieldBehaviorAnnotation *string) {
	o.OutputOnlyStringViaFieldBehaviorAnnotation = outputOnlyStringViaFieldBehaviorAnnotation
}

// WithPathEnumValue adds the pathEnumValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithPathEnumValue(pathEnumValue *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetPathEnumValue(pathEnumValue)
	return o
}

// SetPathEnumValue adds the pathEnumValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetPathEnumValue(pathEnumValue *string) {
	o.PathEnumValue = pathEnumValue
}

// WithProductID adds the productID to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithProductID(productID []string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetProductID(productID)
	return o
}

// SetProductID adds the productId to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetProductID(productID []string) {
	o.ProductID = productID
}

// WithRepeatedEnumAnnotation adds the repeatedEnumAnnotation to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithRepeatedEnumAnnotation(repeatedEnumAnnotation []string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetRepeatedEnumAnnotation(repeatedEnumAnnotation)
	return o
}

// SetRepeatedEnumAnnotation adds the repeatedEnumAnnotation to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetRepeatedEnumAnnotation(repeatedEnumAnnotation []string) {
	o.RepeatedEnumAnnotation = repeatedEnumAnnotation
}

// WithRepeatedEnumValue adds the repeatedEnumValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithRepeatedEnumValue(repeatedEnumValue []string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetRepeatedEnumValue(repeatedEnumValue)
	return o
}

// SetRepeatedEnumValue adds the repeatedEnumValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetRepeatedEnumValue(repeatedEnumValue []string) {
	o.RepeatedEnumValue = repeatedEnumValue
}

// WithRepeatedStringAnnotation adds the repeatedStringAnnotation to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithRepeatedStringAnnotation(repeatedStringAnnotation []string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetRepeatedStringAnnotation(repeatedStringAnnotation)
	return o
}

// SetRepeatedStringAnnotation adds the repeatedStringAnnotation to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetRepeatedStringAnnotation(repeatedStringAnnotation []string) {
	o.RepeatedStringAnnotation = repeatedStringAnnotation
}

// WithRepeatedStringValue adds the repeatedStringValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithRepeatedStringValue(repeatedStringValue []string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetRepeatedStringValue(repeatedStringValue)
	return o
}

// SetRepeatedStringValue adds the repeatedStringValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetRepeatedStringValue(repeatedStringValue []string) {
	o.RepeatedStringValue = repeatedStringValue
}

// WithRequiredStringField1 adds the requiredStringField1 to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithRequiredStringField1(requiredStringField1 string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetRequiredStringField1(requiredStringField1)
	return o
}

// SetRequiredStringField1 adds the requiredStringField1 to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetRequiredStringField1(requiredStringField1 string) {
	o.RequiredStringField1 = requiredStringField1
}

// WithRequiredStringField2 adds the requiredStringField2 to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithRequiredStringField2(requiredStringField2 string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetRequiredStringField2(requiredStringField2)
	return o
}

// SetRequiredStringField2 adds the requiredStringField2 to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetRequiredStringField2(requiredStringField2 string) {
	o.RequiredStringField2 = requiredStringField2
}

// WithRequiredStringViaFieldBehaviorAnnotation adds the requiredStringViaFieldBehaviorAnnotation to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithRequiredStringViaFieldBehaviorAnnotation(requiredStringViaFieldBehaviorAnnotation string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetRequiredStringViaFieldBehaviorAnnotation(requiredStringViaFieldBehaviorAnnotation)
	return o
}

// SetRequiredStringViaFieldBehaviorAnnotation adds the requiredStringViaFieldBehaviorAnnotation to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetRequiredStringViaFieldBehaviorAnnotation(requiredStringViaFieldBehaviorAnnotation string) {
	o.RequiredStringViaFieldBehaviorAnnotation = requiredStringViaFieldBehaviorAnnotation
}

// WithRequiredFieldBehaviorJSONNameCustom adds the requiredFieldBehaviorJSONNameCustom to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithRequiredFieldBehaviorJSONNameCustom(requiredFieldBehaviorJSONNameCustom string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetRequiredFieldBehaviorJSONNameCustom(requiredFieldBehaviorJSONNameCustom)
	return o
}

// SetRequiredFieldBehaviorJSONNameCustom adds the requiredFieldBehaviorJsonNameCustom to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetRequiredFieldBehaviorJSONNameCustom(requiredFieldBehaviorJSONNameCustom string) {
	o.RequiredFieldBehaviorJSONNameCustom = requiredFieldBehaviorJSONNameCustom
}

// WithRequiredFieldSchemaJSONNameCustom adds the requiredFieldSchemaJSONNameCustom to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithRequiredFieldSchemaJSONNameCustom(requiredFieldSchemaJSONNameCustom string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetRequiredFieldSchemaJSONNameCustom(requiredFieldSchemaJSONNameCustom)
	return o
}

// SetRequiredFieldSchemaJSONNameCustom adds the requiredFieldSchemaJsonNameCustom to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetRequiredFieldSchemaJSONNameCustom(requiredFieldSchemaJSONNameCustom string) {
	o.RequiredFieldSchemaJSONNameCustom = requiredFieldSchemaJSONNameCustom
}

// WithSfixed32Value adds the sfixed32Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithSfixed32Value(sfixed32Value *int32) *ABitOfEverythingServiceDoubleColonParams {
	o.SetSfixed32Value(sfixed32Value)
	return o
}

// SetSfixed32Value adds the sfixed32Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetSfixed32Value(sfixed32Value *int32) {
	o.Sfixed32Value = sfixed32Value
}

// WithSfixed64Value adds the sfixed64Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithSfixed64Value(sfixed64Value *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetSfixed64Value(sfixed64Value)
	return o
}

// SetSfixed64Value adds the sfixed64Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetSfixed64Value(sfixed64Value *string) {
	o.Sfixed64Value = sfixed64Value
}

// WithSingleNestedAmount adds the singleNestedAmount to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithSingleNestedAmount(singleNestedAmount *int64) *ABitOfEverythingServiceDoubleColonParams {
	o.SetSingleNestedAmount(singleNestedAmount)
	return o
}

// SetSingleNestedAmount adds the singleNestedAmount to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetSingleNestedAmount(singleNestedAmount *int64) {
	o.SingleNestedAmount = singleNestedAmount
}

// WithSingleNestedName adds the singleNestedName to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithSingleNestedName(singleNestedName *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetSingleNestedName(singleNestedName)
	return o
}

// SetSingleNestedName adds the singleNestedName to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetSingleNestedName(singleNestedName *string) {
	o.SingleNestedName = singleNestedName
}

// WithSingleNestedOk adds the singleNestedOk to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithSingleNestedOk(singleNestedOk *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetSingleNestedOk(singleNestedOk)
	return o
}

// SetSingleNestedOk adds the singleNestedOk to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetSingleNestedOk(singleNestedOk *string) {
	o.SingleNestedOk = singleNestedOk
}

// WithSint32Value adds the sint32Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithSint32Value(sint32Value *int32) *ABitOfEverythingServiceDoubleColonParams {
	o.SetSint32Value(sint32Value)
	return o
}

// SetSint32Value adds the sint32Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetSint32Value(sint32Value *int32) {
	o.Sint32Value = sint32Value
}

// WithSint64Value adds the sint64Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithSint64Value(sint64Value *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetSint64Value(sint64Value)
	return o
}

// SetSint64Value adds the sint64Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetSint64Value(sint64Value *string) {
	o.Sint64Value = sint64Value
}

// WithStringValue adds the stringValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithStringValue(stringValue *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetStringValue(stringValue)
	return o
}

// SetStringValue adds the stringValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetStringValue(stringValue *string) {
	o.StringValue = stringValue
}

// WithTimestampValue adds the timestampValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithTimestampValue(timestampValue *strfmt.DateTime) *ABitOfEverythingServiceDoubleColonParams {
	o.SetTimestampValue(timestampValue)
	return o
}

// SetTimestampValue adds the timestampValue to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetTimestampValue(timestampValue *strfmt.DateTime) {
	o.TimestampValue = timestampValue
}

// WithTrailingBoth adds the trailingBoth to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithTrailingBoth(trailingBoth *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetTrailingBoth(trailingBoth)
	return o
}

// SetTrailingBoth adds the trailingBoth to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetTrailingBoth(trailingBoth *string) {
	o.TrailingBoth = trailingBoth
}

// WithTrailingMultiline adds the trailingMultiline to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithTrailingMultiline(trailingMultiline *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetTrailingMultiline(trailingMultiline)
	return o
}

// SetTrailingMultiline adds the trailingMultiline to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetTrailingMultiline(trailingMultiline *string) {
	o.TrailingMultiline = trailingMultiline
}

// WithTrailingOnly adds the trailingOnly to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithTrailingOnly(trailingOnly *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetTrailingOnly(trailingOnly)
	return o
}

// SetTrailingOnly adds the trailingOnly to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetTrailingOnly(trailingOnly *string) {
	o.TrailingOnly = trailingOnly
}

// WithTrailingOnlyDot adds the trailingOnlyDot to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithTrailingOnlyDot(trailingOnlyDot *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetTrailingOnlyDot(trailingOnlyDot)
	return o
}

// SetTrailingOnlyDot adds the trailingOnlyDot to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetTrailingOnlyDot(trailingOnlyDot *string) {
	o.TrailingOnlyDot = trailingOnlyDot
}

// WithUint32Value adds the uint32Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithUint32Value(uint32Value *int64) *ABitOfEverythingServiceDoubleColonParams {
	o.SetUint32Value(uint32Value)
	return o
}

// SetUint32Value adds the uint32Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetUint32Value(uint32Value *int64) {
	o.Uint32Value = uint32Value
}

// WithUint64Value adds the uint64Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithUint64Value(uint64Value *string) *ABitOfEverythingServiceDoubleColonParams {
	o.SetUint64Value(uint64Value)
	return o
}

// SetUint64Value adds the uint64Value to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetUint64Value(uint64Value *string) {
	o.Uint64Value = uint64Value
}

// WithUUIDName adds the uuidName to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithUUIDName(uuidName strfmt.UUID) *ABitOfEverythingServiceDoubleColonParams {
	o.SetUUIDName(uuidName)
	return o
}

// SetUUIDName adds the uuidName to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetUUIDName(uuidName strfmt.UUID) {
	o.UUIDName = uuidName
}

// WithUuids adds the uuids to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) WithUuids(uuids []strfmt.UUID) *ABitOfEverythingServiceDoubleColonParams {
	o.SetUuids(uuids)
	return o
}

// SetUuids adds the uuids to the a bit of everything service double colon params
func (o *ABitOfEverythingServiceDoubleColonParams) SetUuids(uuids []strfmt.UUID) {
	o.Uuids = uuids
}

// WriteToRequest writes these params to a swagger request
func (o *ABitOfEverythingServiceDoubleColonParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {

	if err := r.SetTimeout(o.timeout); err != nil {
		return err
	}
	var res []error

	if o.BoolValue != nil {

		// query param boolValue
		var qrBoolValue bool

		if o.BoolValue != nil {
			qrBoolValue = *o.BoolValue
		}
		qBoolValue := swag.FormatBool(qrBoolValue)
		if qBoolValue != "" {

			if err := r.SetQueryParam("boolValue", qBoolValue); err != nil {
				return err
			}
		}
	}

	if o.BytesValue != nil {

		// query param bytesValue
		var qrBytesValue strfmt.Base64

		if o.BytesValue != nil {
			qrBytesValue = *o.BytesValue
		}
		qBytesValue := qrBytesValue.String()
		if qBytesValue != "" {

			if err := r.SetQueryParam("bytesValue", qBytesValue); err != nil {
				return err
			}
		}
	}

	// query param doubleValue
	qrDoubleValue := o.DoubleValue
	qDoubleValue := swag.FormatFloat64(qrDoubleValue)
	if qDoubleValue != "" {

		if err := r.SetQueryParam("doubleValue", qDoubleValue); err != nil {
			return err
		}
	}

	if o.EnumValue != nil {

		// query param enumValue
		var qrEnumValue string

		if o.EnumValue != nil {
			qrEnumValue = *o.EnumValue
		}
		qEnumValue := qrEnumValue
		if qEnumValue != "" {

			if err := r.SetQueryParam("enumValue", qEnumValue); err != nil {
				return err
			}
		}
	}

	if o.EnumValueAnnotation != nil {

		// query param enumValueAnnotation
		var qrEnumValueAnnotation string

		if o.EnumValueAnnotation != nil {
			qrEnumValueAnnotation = *o.EnumValueAnnotation
		}
		qEnumValueAnnotation := qrEnumValueAnnotation
		if qEnumValueAnnotation != "" {

			if err := r.SetQueryParam("enumValueAnnotation", qEnumValueAnnotation); err != nil {
				return err
			}
		}
	}

	if o.Fixed32Value != nil {

		// query param fixed32Value
		var qrFixed32Value int64

		if o.Fixed32Value != nil {
			qrFixed32Value = *o.Fixed32Value
		}
		qFixed32Value := swag.FormatInt64(qrFixed32Value)
		if qFixed32Value != "" {

			if err := r.SetQueryParam("fixed32Value", qFixed32Value); err != nil {
				return err
			}
		}
	}

	if o.Fixed64Value != nil {

		// query param fixed64Value
		var qrFixed64Value string

		if o.Fixed64Value != nil {
			qrFixed64Value = *o.Fixed64Value
		}
		qFixed64Value := qrFixed64Value
		if qFixed64Value != "" {

			if err := r.SetQueryParam("fixed64Value", qFixed64Value); err != nil {
				return err
			}
		}
	}

	// query param floatValue
	qrFloatValue := o.FloatValue
	qFloatValue := swag.FormatFloat32(qrFloatValue)
	if qFloatValue != "" {

		if err := r.SetQueryParam("floatValue", qFloatValue); err != nil {
			return err
		}
	}

	if o.Int32Value != nil {

		// query param int32Value
		var qrInt32Value int32

		if o.Int32Value != nil {
			qrInt32Value = *o.Int32Value
		}
		qInt32Value := swag.FormatInt32(qrInt32Value)
		if qInt32Value != "" {

			if err := r.SetQueryParam("int32Value", qInt32Value); err != nil {
				return err
			}
		}
	}

	if o.Int64OverrideType != nil {

		// query param int64OverrideType
		var qrInt64OverrideType string

		if o.Int64OverrideType != nil {
			qrInt64OverrideType = *o.Int64OverrideType
		}
		qInt64OverrideType := qrInt64OverrideType
		if qInt64OverrideType != "" {

			if err := r.SetQueryParam("int64OverrideType", qInt64OverrideType); err != nil {
				return err
			}
		}
	}

	// query param int64Value
	qrInt64Value := o.Int64Value
	qInt64Value := qrInt64Value
	if qInt64Value != "" {

		if err := r.SetQueryParam("int64Value", qInt64Value); err != nil {
			return err
		}
	}

	if o.MapValue != nil {

		// query param mapValue
		var qrMapValue string

		if o.MapValue != nil {
			qrMapValue = *o.MapValue
		}
		qMapValue := qrMapValue
		if qMapValue != "" {

			if err := r.SetQueryParam("mapValue", qMapValue); err != nil {
				return err
			}
		}
	}

	if o.MappedNestedValue != nil {

		// query param mappedNestedValue
		var qrMappedNestedValue string

		if o.MappedNestedValue != nil {
			qrMappedNestedValue = *o.MappedNestedValue
		}
		qMappedNestedValue := qrMappedNestedValue
		if qMappedNestedValue != "" {

			if err := r.SetQueryParam("mappedNestedValue", qMappedNestedValue); err != nil {
				return err
			}
		}
	}

	if o.MappedStringValue != nil {

		// query param mappedStringValue
		var qrMappedStringValue string

		if o.MappedStringValue != nil {
			qrMappedStringValue = *o.MappedStringValue
		}
		qMappedStringValue := qrMappedStringValue
		if qMappedStringValue != "" {

			if err := r.SetQueryParam("mappedStringValue", qMappedStringValue); err != nil {
				return err
			}
		}
	}

	if o.NestedAnnotationAmount != nil {

		// query param nestedAnnotation.amount
		var qrNestedAnnotationAmount int64

		if o.NestedAnnotationAmount != nil {
			qrNestedAnnotationAmount = *o.NestedAnnotationAmount
		}
		qNestedAnnotationAmount := swag.FormatInt64(qrNestedAnnotationAmount)
		if qNestedAnnotationAmount != "" {

			if err := r.SetQueryParam("nestedAnnotation.amount", qNestedAnnotationAmount); err != nil {
				return err
			}
		}
	}

	if o.NestedAnnotationName != nil {

		// query param nestedAnnotation.name
		var qrNestedAnnotationName string

		if o.NestedAnnotationName != nil {
			qrNestedAnnotationName = *o.NestedAnnotationName
		}
		qNestedAnnotationName := qrNestedAnnotationName
		if qNestedAnnotationName != "" {

			if err := r.SetQueryParam("nestedAnnotation.name", qNestedAnnotationName); err != nil {
				return err
			}
		}
	}

	if o.NestedAnnotationOk != nil {

		// query param nestedAnnotation.ok
		var qrNestedAnnotationOk string

		if o.NestedAnnotationOk != nil {
			qrNestedAnnotationOk = *o.NestedAnnotationOk
		}
		qNestedAnnotationOk := qrNestedAnnotationOk
		if qNestedAnnotationOk != "" {

			if err := r.SetQueryParam("nestedAnnotation.ok", qNestedAnnotationOk); err != nil {
				return err
			}
		}
	}

	if o.NestedPathEnumValue != nil {

		// query param nestedPathEnumValue
		var qrNestedPathEnumValue string

		if o.NestedPathEnumValue != nil {
			qrNestedPathEnumValue = *o.NestedPathEnumValue
		}
		qNestedPathEnumValue := qrNestedPathEnumValue
		if qNestedPathEnumValue != "" {

			if err := r.SetQueryParam("nestedPathEnumValue", qNestedPathEnumValue); err != nil {
				return err
			}
		}
	}

	if o.NonConventionalNameValue != nil {

		// query param nonConventionalNameValue
		var qrNonConventionalNameValue string

		if o.NonConventionalNameValue != nil {
			qrNonConventionalNameValue = *o.NonConventionalNameValue
		}
		qNonConventionalNameValue := qrNonConventionalNameValue
		if qNonConventionalNameValue != "" {

			if err := r.SetQueryParam("nonConventionalNameValue", qNonConventionalNameValue); err != nil {
				return err
			}
		}
	}

	if o.OneofEmpty != nil {

		// query param oneofEmpty
		var qrOneofEmpty string

		if o.OneofEmpty != nil {
			qrOneofEmpty = *o.OneofEmpty
		}
		qOneofEmpty := qrOneofEmpty
		if qOneofEmpty != "" {

			if err := r.SetQueryParam("oneofEmpty", qOneofEmpty); err != nil {
				return err
			}
		}
	}

	if o.OneofString != nil {

		// query param oneofString
		var qrOneofString string

		if o.OneofString != nil {
			qrOneofString = *o.OneofString
		}
		qOneofString := qrOneofString
		if qOneofString != "" {

			if err := r.SetQueryParam("oneofString", qOneofString); err != nil {
				return err
			}
		}
	}

	if o.OptionalStringField != nil {

		// query param optionalStringField
		var qrOptionalStringField string

		if o.OptionalStringField != nil {
			qrOptionalStringField = *o.OptionalStringField
		}
		qOptionalStringField := qrOptionalStringField
		if qOptionalStringField != "" {

			if err := r.SetQueryParam("optionalStringField", qOptionalStringField); err != nil {
				return err
			}
		}
	}

	if o.OptionalStringValue != nil {

		// query param optionalStringValue
		var qrOptionalStringValue string

		if o.OptionalStringValue != nil {
			qrOptionalStringValue = *o.OptionalStringValue
		}
		qOptionalStringValue := qrOptionalStringValue
		if qOptionalStringValue != "" {

			if err := r.SetQueryParam("optionalStringValue", qOptionalStringValue); err != nil {
				return err
			}
		}
	}

	if o.OutputOnlyStringViaFieldBehaviorAnnotation != nil {

		// query param outputOnlyStringViaFieldBehaviorAnnotation
		var qrOutputOnlyStringViaFieldBehaviorAnnotation string

		if o.OutputOnlyStringViaFieldBehaviorAnnotation != nil {
			qrOutputOnlyStringViaFieldBehaviorAnnotation = *o.OutputOnlyStringViaFieldBehaviorAnnotation
		}
		qOutputOnlyStringViaFieldBehaviorAnnotation := qrOutputOnlyStringViaFieldBehaviorAnnotation
		if qOutputOnlyStringViaFieldBehaviorAnnotation != "" {

			if err := r.SetQueryParam("outputOnlyStringViaFieldBehaviorAnnotation", qOutputOnlyStringViaFieldBehaviorAnnotation); err != nil {
				return err
			}
		}
	}

	if o.PathEnumValue != nil {

		// query param pathEnumValue
		var qrPathEnumValue string

		if o.PathEnumValue != nil {
			qrPathEnumValue = *o.PathEnumValue
		}
		qPathEnumValue := qrPathEnumValue
		if qPathEnumValue != "" {

			if err := r.SetQueryParam("pathEnumValue", qPathEnumValue); err != nil {
				return err
			}
		}
	}

	if o.ProductID != nil {

		// binding items for productId
		joinedProductID := o.bindParamProductID(reg)

		// query array param productId
		if err := r.SetQueryParam("productId", joinedProductID...); err != nil {
			return err
		}
	}

	if o.RepeatedEnumAnnotation != nil {

		// binding items for repeatedEnumAnnotation
		joinedRepeatedEnumAnnotation := o.bindParamRepeatedEnumAnnotation(reg)

		// query array param repeatedEnumAnnotation
		if err := r.SetQueryParam("repeatedEnumAnnotation", joinedRepeatedEnumAnnotation...); err != nil {
			return err
		}
	}

	if o.RepeatedEnumValue != nil {

		// binding items for repeatedEnumValue
		joinedRepeatedEnumValue := o.bindParamRepeatedEnumValue(reg)

		// query array param repeatedEnumValue
		if err := r.SetQueryParam("repeatedEnumValue", joinedRepeatedEnumValue...); err != nil {
			return err
		}
	}

	if o.RepeatedStringAnnotation != nil {

		// binding items for repeatedStringAnnotation
		joinedRepeatedStringAnnotation := o.bindParamRepeatedStringAnnotation(reg)

		// query array param repeatedStringAnnotation
		if err := r.SetQueryParam("repeatedStringAnnotation", joinedRepeatedStringAnnotation...); err != nil {
			return err
		}
	}

	if o.RepeatedStringValue != nil {

		// binding items for repeatedStringValue
		joinedRepeatedStringValue := o.bindParamRepeatedStringValue(reg)

		// query array param repeatedStringValue
		if err := r.SetQueryParam("repeatedStringValue", joinedRepeatedStringValue...); err != nil {
			return err
		}
	}

	// query param requiredStringField1
	qrRequiredStringField1 := o.RequiredStringField1
	qRequiredStringField1 := qrRequiredStringField1
	if qRequiredStringField1 != "" {

		if err := r.SetQueryParam("requiredStringField1", qRequiredStringField1); err != nil {
			return err
		}
	}

	// query param requiredStringField2
	qrRequiredStringField2 := o.RequiredStringField2
	qRequiredStringField2 := qrRequiredStringField2
	if qRequiredStringField2 != "" {

		if err := r.SetQueryParam("requiredStringField2", qRequiredStringField2); err != nil {
			return err
		}
	}

	// query param requiredStringViaFieldBehaviorAnnotation
	qrRequiredStringViaFieldBehaviorAnnotation := o.RequiredStringViaFieldBehaviorAnnotation
	qRequiredStringViaFieldBehaviorAnnotation := qrRequiredStringViaFieldBehaviorAnnotation
	if qRequiredStringViaFieldBehaviorAnnotation != "" {

		if err := r.SetQueryParam("requiredStringViaFieldBehaviorAnnotation", qRequiredStringViaFieldBehaviorAnnotation); err != nil {
			return err
		}
	}

	// query param required_field_behavior_json_name_custom
	qrRequiredFieldBehaviorJSONNameCustom := o.RequiredFieldBehaviorJSONNameCustom
	qRequiredFieldBehaviorJSONNameCustom := qrRequiredFieldBehaviorJSONNameCustom
	if qRequiredFieldBehaviorJSONNameCustom != "" {

		if err := r.SetQueryParam("required_field_behavior_json_name_custom", qRequiredFieldBehaviorJSONNameCustom); err != nil {
			return err
		}
	}

	// query param required_field_schema_json_name_custom
	qrRequiredFieldSchemaJSONNameCustom := o.RequiredFieldSchemaJSONNameCustom
	qRequiredFieldSchemaJSONNameCustom := qrRequiredFieldSchemaJSONNameCustom
	if qRequiredFieldSchemaJSONNameCustom != "" {

		if err := r.SetQueryParam("required_field_schema_json_name_custom", qRequiredFieldSchemaJSONNameCustom); err != nil {
			return err
		}
	}

	if o.Sfixed32Value != nil {

		// query param sfixed32Value
		var qrSfixed32Value int32

		if o.Sfixed32Value != nil {
			qrSfixed32Value = *o.Sfixed32Value
		}
		qSfixed32Value := swag.FormatInt32(qrSfixed32Value)
		if qSfixed32Value != "" {

			if err := r.SetQueryParam("sfixed32Value", qSfixed32Value); err != nil {
				return err
			}
		}
	}

	if o.Sfixed64Value != nil {

		// query param sfixed64Value
		var qrSfixed64Value string

		if o.Sfixed64Value != nil {
			qrSfixed64Value = *o.Sfixed64Value
		}
		qSfixed64Value := qrSfixed64Value
		if qSfixed64Value != "" {

			if err := r.SetQueryParam("sfixed64Value", qSfixed64Value); err != nil {
				return err
			}
		}
	}

	if o.SingleNestedAmount != nil {

		// query param singleNested.amount
		var qrSingleNestedAmount int64

		if o.SingleNestedAmount != nil {
			qrSingleNestedAmount = *o.SingleNestedAmount
		}
		qSingleNestedAmount := swag.FormatInt64(qrSingleNestedAmount)
		if qSingleNestedAmount != "" {

			if err := r.SetQueryParam("singleNested.amount", qSingleNestedAmount); err != nil {
				return err
			}
		}
	}

	if o.SingleNestedName != nil {

		// query param singleNested.name
		var qrSingleNestedName string

		if o.SingleNestedName != nil {
			qrSingleNestedName = *o.SingleNestedName
		}
		qSingleNestedName := qrSingleNestedName
		if qSingleNestedName != "" {

			if err := r.SetQueryParam("singleNested.name", qSingleNestedName); err != nil {
				return err
			}
		}
	}

	if o.SingleNestedOk != nil {

		// query param singleNested.ok
		var qrSingleNestedOk string

		if o.SingleNestedOk != nil {
			qrSingleNestedOk = *o.SingleNestedOk
		}
		qSingleNestedOk := qrSingleNestedOk
		if qSingleNestedOk != "" {

			if err := r.SetQueryParam("singleNested.ok", qSingleNestedOk); err != nil {
				return err
			}
		}
	}

	if o.Sint32Value != nil {

		// query param sint32Value
		var qrSint32Value int32

		if o.Sint32Value != nil {
			qrSint32Value = *o.Sint32Value
		}
		qSint32Value := swag.FormatInt32(qrSint32Value)
		if qSint32Value != "" {

			if err := r.SetQueryParam("sint32Value", qSint32Value); err != nil {
				return err
			}
		}
	}

	if o.Sint64Value != nil {

		// query param sint64Value
		var qrSint64Value string

		if o.Sint64Value != nil {
			qrSint64Value = *o.Sint64Value
		}
		qSint64Value := qrSint64Value
		if qSint64Value != "" {

			if err := r.SetQueryParam("sint64Value", qSint64Value); err != nil {
				return err
			}
		}
	}

	if o.StringValue != nil {

		// query param stringValue
		var qrStringValue string

		if o.StringValue != nil {
			qrStringValue = *o.StringValue
		}
		qStringValue := qrStringValue
		if qStringValue != "" {

			if err := r.SetQueryParam("stringValue", qStringValue); err != nil {
				return err
			}
		}
	}

	if o.TimestampValue != nil {

		// query param timestampValue
		var qrTimestampValue strfmt.DateTime

		if o.TimestampValue != nil {
			qrTimestampValue = *o.TimestampValue
		}
		qTimestampValue := qrTimestampValue.String()
		if qTimestampValue != "" {

			if err := r.SetQueryParam("timestampValue", qTimestampValue); err != nil {
				return err
			}
		}
	}

	if o.TrailingBoth != nil {

		// query param trailingBoth
		var qrTrailingBoth string

		if o.TrailingBoth != nil {
			qrTrailingBoth = *o.TrailingBoth
		}
		qTrailingBoth := qrTrailingBoth
		if qTrailingBoth != "" {

			if err := r.SetQueryParam("trailingBoth", qTrailingBoth); err != nil {
				return err
			}
		}
	}

	if o.TrailingMultiline != nil {

		// query param trailingMultiline
		var qrTrailingMultiline string

		if o.TrailingMultiline != nil {
			qrTrailingMultiline = *o.TrailingMultiline
		}
		qTrailingMultiline := qrTrailingMultiline
		if qTrailingMultiline != "" {

			if err := r.SetQueryParam("trailingMultiline", qTrailingMultiline); err != nil {
				return err
			}
		}
	}

	if o.TrailingOnly != nil {

		// query param trailingOnly
		var qrTrailingOnly string

		if o.TrailingOnly != nil {
			qrTrailingOnly = *o.TrailingOnly
		}
		qTrailingOnly := qrTrailingOnly
		if qTrailingOnly != "" {

			if err := r.SetQueryParam("trailingOnly", qTrailingOnly); err != nil {
				return err
			}
		}
	}

	if o.TrailingOnlyDot != nil {

		// query param trailingOnlyDot
		var qrTrailingOnlyDot string

		if o.TrailingOnlyDot != nil {
			qrTrailingOnlyDot = *o.TrailingOnlyDot
		}
		qTrailingOnlyDot := qrTrailingOnlyDot
		if qTrailingOnlyDot != "" {

			if err := r.SetQueryParam("trailingOnlyDot", qTrailingOnlyDot); err != nil {
				return err
			}
		}
	}

	if o.Uint32Value != nil {

		// query param uint32Value
		var qrUint32Value int64

		if o.Uint32Value != nil {
			qrUint32Value = *o.Uint32Value
		}
		qUint32Value := swag.FormatInt64(qrUint32Value)
		if qUint32Value != "" {

			if err := r.SetQueryParam("uint32Value", qUint32Value); err != nil {
				return err
			}
		}
	}

	if o.Uint64Value != nil {

		// query param uint64Value
		var qrUint64Value string

		if o.Uint64Value != nil {
			qrUint64Value = *o.Uint64Value
		}
		qUint64Value := qrUint64Value
		if qUint64Value != "" {

			if err := r.SetQueryParam("uint64Value", qUint64Value); err != nil {
				return err
			}
		}
	}

	// path param uuidName
	if err := r.SetPathParam("uuidName", o.UUIDName.String()); err != nil {
		return err
	}

	if o.Uuids != nil {

		// binding items for uuids
		joinedUuids := o.bindParamUuids(reg)

		// query array param uuids
		if err := r.SetQueryParam("uuids", joinedUuids...); err != nil {
			return err
		}
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

// bindParamABitOfEverythingServiceDoubleColon binds the parameter productId
func (o *ABitOfEverythingServiceDoubleColonParams) bindParamProductID(formats strfmt.Registry) []string {
	productIDIR := o.ProductID

	var productIDIC []string
	for _, productIDIIR := range productIDIR { // explode []string

		productIDIIV := productIDIIR // string as string
		productIDIC = append(productIDIC, productIDIIV)
	}

	// items.CollectionFormat: "multi"
	productIDIS := swag.JoinByFormat(productIDIC, "multi")

	return productIDIS
}

// bindParamABitOfEverythingServiceDoubleColon binds the parameter repeatedEnumAnnotation
func (o *ABitOfEverythingServiceDoubleColonParams) bindParamRepeatedEnumAnnotation(formats strfmt.Registry) []string {
	repeatedEnumAnnotationIR := o.RepeatedEnumAnnotation

	var repeatedEnumAnnotationIC []string
	for _, repeatedEnumAnnotationIIR := range repeatedEnumAnnotationIR { // explode []string

		repeatedEnumAnnotationIIV := repeatedEnumAnnotationIIR // string as string
		repeatedEnumAnnotationIC = append(repeatedEnumAnnotationIC, repeatedEnumAnnotationIIV)
	}

	// items.CollectionFormat: "multi"
	repeatedEnumAnnotationIS := swag.JoinByFormat(repeatedEnumAnnotationIC, "multi")

	return repeatedEnumAnnotationIS
}

// bindParamABitOfEverythingServiceDoubleColon binds the parameter repeatedEnumValue
func (o *ABitOfEverythingServiceDoubleColonParams) bindParamRepeatedEnumValue(formats strfmt.Registry) []string {
	repeatedEnumValueIR := o.RepeatedEnumValue

	var repeatedEnumValueIC []string
	for _, repeatedEnumValueIIR := range repeatedEnumValueIR { // explode []string

		repeatedEnumValueIIV := repeatedEnumValueIIR // string as string
		repeatedEnumValueIC = append(repeatedEnumValueIC, repeatedEnumValueIIV)
	}

	// items.CollectionFormat: "multi"
	repeatedEnumValueIS := swag.JoinByFormat(repeatedEnumValueIC, "multi")

	return repeatedEnumValueIS
}

// bindParamABitOfEverythingServiceDoubleColon binds the parameter repeatedStringAnnotation
func (o *ABitOfEverythingServiceDoubleColonParams) bindParamRepeatedStringAnnotation(formats strfmt.Registry) []string {
	repeatedStringAnnotationIR := o.RepeatedStringAnnotation

	var repeatedStringAnnotationIC []string
	for _, repeatedStringAnnotationIIR := range repeatedStringAnnotationIR { // explode []string

		repeatedStringAnnotationIIV := repeatedStringAnnotationIIR // string as string
		repeatedStringAnnotationIC = append(repeatedStringAnnotationIC, repeatedStringAnnotationIIV)
	}

	// items.CollectionFormat: "multi"
	repeatedStringAnnotationIS := swag.JoinByFormat(repeatedStringAnnotationIC, "multi")

	return repeatedStringAnnotationIS
}

// bindParamABitOfEverythingServiceDoubleColon binds the parameter repeatedStringValue
func (o *ABitOfEverythingServiceDoubleColonParams) bindParamRepeatedStringValue(formats strfmt.Registry) []string {
	repeatedStringValueIR := o.RepeatedStringValue

	var repeatedStringValueIC []string
	for _, repeatedStringValueIIR := range repeatedStringValueIR { // explode []string

		repeatedStringValueIIV := repeatedStringValueIIR // string as string
		repeatedStringValueIC = append(repeatedStringValueIC, repeatedStringValueIIV)
	}

	// items.CollectionFormat: "multi"
	repeatedStringValueIS := swag.JoinByFormat(repeatedStringValueIC, "multi")

	return repeatedStringValueIS
}

// bindParamABitOfEverythingServiceDoubleColon binds the parameter uuids
func (o *ABitOfEverythingServiceDoubleColonParams) bindParamUuids(formats strfmt.Registry) []string {
	uuidsIR := o.Uuids

	var uuidsIC []string
	for _, uuidsIIR := range uuidsIR { // explode []strfmt.UUID

		uuidsIIV := uuidsIIR.String() // strfmt.UUID as string
		uuidsIC = append(uuidsIC, uuidsIIV)
	}

	// items.CollectionFormat: "multi"
	uuidsIS := swag.JoinByFormat(uuidsIC, "multi")

	return uuidsIS
}
