func (self *Response) Init() *Response {
	if self.Schema == nil {
		self.Schema = make(Type)
	}
	return self
}
Init - sets up the instance according to its default field values, if any
package swagger
import (
	"encoding/json"
	"fmt"
	rdl "github.com/ardielle/ardielle-go/rdl"
)
var _ = rdl.Version
var _ = json.Marshal
var _ = fmt.Printf
type Contact struct {
	Name  string `json:"name,omitempty" rdl:"optional"`
	Url   string `json:"url,omitempty" rdl:"optional"`
	Email string `json:"email,omitempty" rdl:"optional"`
}
func NewContact(init ...*Contact) *Contact {
	var o *Contact
	if len(init) == 1 {
		o = init[0]
	} else {
		o = new(Contact)
	}
	return o
}
type rawContact Contact
func (self *Contact) UnmarshalJSON(b []byte) error {
	var r rawContact
	err := json.Unmarshal(b, &r)
	if err == nil {
		o := Contact(r)
		*self = o
		err = self.Validate()
	}
	return err
}
func (self *Contact) Validate() error {
	return nil
}
type License struct {
	Name string `json:"name,omitempty" rdl:"optional"`
	Url  string `json:"url,omitempty" rdl:"optional"`
}
func NewLicense(init ...*License) *License {
	var o *License
	if len(init) == 1 {
		o = init[0]
	} else {
		o = new(License)
	}
	return o
}
type rawLicense License
func (self *License) UnmarshalJSON(b []byte) error {
	var r rawLicense
	err := json.Unmarshal(b, &r)
	if err == nil {
		o := License(r)
		*self = o
		err = self.Validate()
	}
	return err
}
func (self *License) Validate() error {
	return nil
}
type Info struct {
	Title          string   `json:"title"`
	Version        string   `json:"version,omitempty" rdl:"optional"`
	Description    string   `json:"description,omitempty" rdl:"optional"`
	TermsOfService string   `json:"termsOfService,omitempty" rdl:"optional"`
	Contact        *Contact `json:"contact,omitempty" rdl:"optional"`
	License        *License `json:"license,omitempty" rdl:"optional"`
}
func NewInfo(init ...*Info) *Info {
	var o *Info
	if len(init) == 1 {
		o = init[0]
	} else {
		o = new(Info)
	}
	return o
}
type rawInfo Info
func (self *Info) UnmarshalJSON(b []byte) error {
	var r rawInfo
	err := json.Unmarshal(b, &r)
	if err == nil {
		o := Info(r)
		*self = o
		err = self.Validate()
	}
	return err
}
func (self *Info) Validate() error {
	if self.Title == "" {
		return fmt.Errorf("Info.title is missing but is a required field")
	} else {
		val := rdl.Validate(SwaggerSchema(), "String", self.Title)
		if !val.Valid {
			return fmt.Errorf("Info.title does not contain a valid String (%v)", val.Error)
		}
	}
	return nil
}
type Type map[string]interface{}
type Parameter struct {
	Name string `json:"name"`
	In               string `json:"in"`
	Schema           Type   `json:"schema,omitempty" rdl:"optional"`
	Type             string `json:"type,omitempty" rdl:"optional"`
	Format           string `json:"format,omitempty" rdl:"optional"`
	CollectionFormat string `json:"collectionFormat" rdl:"default=csv"`
	Required    bool   `json:"required,omitempty" rdl:"default=false"`
	Description string `json:"description,omitempty" rdl:"optional"`
}
func NewParameter(init ...*Parameter) *Parameter {
	var o *Parameter
	if len(init) == 1 {
		o = init[0]
	} else {
		o = new(Parameter)
	}
	return o.Init()
}
func (self *Parameter) Init() *Parameter {
	if self.CollectionFormat == "" {
		self.CollectionFormat = "csv"
	}
	return self
}
type rawParameter Parameter
func (self *Parameter) UnmarshalJSON(b []byte) error {
	var r rawParameter
	err := json.Unmarshal(b, &r)
	if err == nil {
		o := Parameter(r)
		*self = *((&o).Init())
		err = self.Validate()
	}
	return err
}
func (self *Parameter) Validate() error {
	if self.Name == "" {
		return fmt.Errorf("Parameter.name is missing but is a required field")
	} else {
		val := rdl.Validate(SwaggerSchema(), "String", self.Name)
		if !val.Valid {
			return fmt.Errorf("Parameter.name does not contain a valid String (%v)", val.Error)
		}
	}
	if self.In == "" {
		return fmt.Errorf("Parameter.in is missing but is a required field")
	} else {
		val := rdl.Validate(SwaggerSchema(), "String", self.In)
		if !val.Valid {
			return fmt.Errorf("Parameter.in does not contain a valid String (%v)", val.Error)
		}
	}
	if self.CollectionFormat == "" {
		return fmt.Errorf("Parameter.collectionFormat is missing but is a required field")
	} else {
		val := rdl.Validate(SwaggerSchema(), "String", self.CollectionFormat)
		if !val.Valid {
			return fmt.Errorf("Parameter.collectionFormat does not contain a valid String (%v)", val.Error)
		}
	}
	return nil
}
type Response struct {
	Description string `json:"description"`
	Schema      Type   `json:"schema"`
}
func NewResponse(init ...*Response) *Response {
	var o *Response
	if len(init) == 1 {
		o = init[0]
	} else {
		o = new(Response)
	}
	return o.Init()
}