diff --git a/sam/channel.go b/sam/channel.go
index e8cc00e65..547759b96 100644
--- a/sam/channel.go
+++ b/sam/channel.go
@@ -4,24 +4,24 @@ import (
 	"github.com/pkg/errors"
 )
 
-func (c *Channel) Edit(r *ChannelEditRequest) (interface{}, error) {
+func (c *Channel) Edit(r *channelEditRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Channel.edit")
 }
-func (c *Channel) Remove(r *ChannelRemoveRequest) (interface{}, error) {
+func (c *Channel) Remove(r *channelRemoveRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Channel.remove")
 }
-func (c *Channel) Read(r *ChannelReadRequest) (interface{}, error) {
+func (c *Channel) Read(r *channelReadRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Channel.read")
 }
-func (c *Channel) Search(r *ChannelSearchRequest) (interface{}, error) {
+func (c *Channel) Search(r *channelSearchRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Channel.search")
 }
-func (c *Channel) Archive(r *ChannelArchiveRequest) (interface{}, error) {
+func (c *Channel) Archive(r *channelArchiveRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Channel.archive")
 }
-func (c *Channel) Move(r *ChannelMoveRequest) (interface{}, error) {
+func (c *Channel) Move(r *channelMoveRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Channel.move")
 }
-func (c *Channel) Merge(r *ChannelMergeRequest) (interface{}, error) {
+func (c *Channel) Merge(r *channelMergeRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Channel.merge")
 }
diff --git a/sam/channel.handlers.go b/sam/channel.handlers.go
index 96a7d6634..f08579c81 100644
--- a/sam/channel.handlers.go
+++ b/sam/channel.handlers.go
@@ -7,30 +7,30 @@ import (
 )
 
 func (ch *ChannelHandlers) Edit(w http.ResponseWriter, r *http.Request) {
-	params := ChannelEditRequest{}.new()
+	params := channelEditRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return ch.Channel.Edit(params) })
 }
 func (ch *ChannelHandlers) Remove(w http.ResponseWriter, r *http.Request) {
-	params := ChannelRemoveRequest{}.new()
+	params := channelRemoveRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return ch.Channel.Remove(params) })
 }
 func (ch *ChannelHandlers) Read(w http.ResponseWriter, r *http.Request) {
-	params := ChannelReadRequest{}.new()
+	params := channelReadRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return ch.Channel.Read(params) })
 }
 func (ch *ChannelHandlers) Search(w http.ResponseWriter, r *http.Request) {
-	params := ChannelSearchRequest{}.new()
+	params := channelSearchRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return ch.Channel.Search(params) })
 }
 func (ch *ChannelHandlers) Archive(w http.ResponseWriter, r *http.Request) {
-	params := ChannelArchiveRequest{}.new()
+	params := channelArchiveRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return ch.Channel.Archive(params) })
 }
 func (ch *ChannelHandlers) Move(w http.ResponseWriter, r *http.Request) {
-	params := ChannelMoveRequest{}.new()
+	params := channelMoveRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return ch.Channel.Move(params) })
 }
 func (ch *ChannelHandlers) Merge(w http.ResponseWriter, r *http.Request) {
-	params := ChannelMergeRequest{}.new()
+	params := channelMergeRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return ch.Channel.Merge(params) })
 }
diff --git a/sam/channel.interfaces.go b/sam/channel.interfaces.go
index f0e640bb6..15d1ff7db 100644
--- a/sam/channel.interfaces.go
+++ b/sam/channel.interfaces.go
@@ -17,13 +17,13 @@ func (ChannelHandlers) new() *ChannelHandlers {
 
 // Internal API interface
 type ChannelAPI interface {
-	Edit(*ChannelEditRequest) (interface{}, error)
-	Remove(*ChannelRemoveRequest) (interface{}, error)
-	Read(*ChannelReadRequest) (interface{}, error)
-	Search(*ChannelSearchRequest) (interface{}, error)
-	Archive(*ChannelArchiveRequest) (interface{}, error)
-	Move(*ChannelMoveRequest) (interface{}, error)
-	Merge(*ChannelMergeRequest) (interface{}, error)
+	Edit(*channelEditRequest) (interface{}, error)
+	Remove(*channelRemoveRequest) (interface{}, error)
+	Read(*channelReadRequest) (interface{}, error)
+	Search(*channelSearchRequest) (interface{}, error)
+	Archive(*channelArchiveRequest) (interface{}, error)
+	Move(*channelMoveRequest) (interface{}, error)
+	Merge(*channelMergeRequest) (interface{}, error)
 }
 
 // HTTP API interface
diff --git a/sam/channel.request.go b/sam/channel.request.go
index 6b4c3d130..127aec82d 100644
--- a/sam/channel.request.go
+++ b/sam/channel.request.go
@@ -2,22 +2,20 @@ package sam
 
 import (
 	"net/http"
-
-	"github.com/pkg/errors"
 )
 
 // Channel edit request parameters
-type ChannelEditRequest struct {
+type channelEditRequest struct {
 	id    uint64
 	name  string
 	topic string
 }
 
-func (ChannelEditRequest) new() *ChannelEditRequest {
-	return &ChannelEditRequest{}
+func (channelEditRequest) new() *channelEditRequest {
+	return &channelEditRequest{}
 }
 
-func (c *ChannelEditRequest) Fill(r *http.Request) error {
+func (c *channelEditRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -34,21 +32,21 @@ func (c *ChannelEditRequest) Fill(r *http.Request) error {
 	c.name = post["name"]
 
 	c.topic = post["topic"]
-	return errors.New("Not implemented: ChannelEditRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = ChannelEditRequest{}.new()
+var _ RequestFiller = channelEditRequest{}.new()
 
 // Channel remove request parameters
-type ChannelRemoveRequest struct {
+type channelRemoveRequest struct {
 	id uint64
 }
 
-func (ChannelRemoveRequest) new() *ChannelRemoveRequest {
-	return &ChannelRemoveRequest{}
+func (channelRemoveRequest) new() *channelRemoveRequest {
+	return &channelRemoveRequest{}
 }
 
-func (c *ChannelRemoveRequest) Fill(r *http.Request) error {
+func (c *channelRemoveRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -61,21 +59,21 @@ func (c *ChannelRemoveRequest) Fill(r *http.Request) error {
 	}
 
 	c.id = parseUInt64(get["id"])
-	return errors.New("Not implemented: ChannelRemoveRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = ChannelRemoveRequest{}.new()
+var _ RequestFiller = channelRemoveRequest{}.new()
 
 // Channel read request parameters
-type ChannelReadRequest struct {
+type channelReadRequest struct {
 	id uint64
 }
 
-func (ChannelReadRequest) new() *ChannelReadRequest {
-	return &ChannelReadRequest{}
+func (channelReadRequest) new() *channelReadRequest {
+	return &channelReadRequest{}
 }
 
-func (c *ChannelReadRequest) Fill(r *http.Request) error {
+func (c *channelReadRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -88,21 +86,21 @@ func (c *ChannelReadRequest) Fill(r *http.Request) error {
 	}
 
 	c.id = parseUInt64(get["id"])
-	return errors.New("Not implemented: ChannelReadRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = ChannelReadRequest{}.new()
+var _ RequestFiller = channelReadRequest{}.new()
 
 // Channel search request parameters
-type ChannelSearchRequest struct {
+type channelSearchRequest struct {
 	query string
 }
 
-func (ChannelSearchRequest) new() *ChannelSearchRequest {
-	return &ChannelSearchRequest{}
+func (channelSearchRequest) new() *channelSearchRequest {
+	return &channelSearchRequest{}
 }
 
-func (c *ChannelSearchRequest) Fill(r *http.Request) error {
+func (c *channelSearchRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -115,21 +113,21 @@ func (c *ChannelSearchRequest) Fill(r *http.Request) error {
 	}
 
 	c.query = get["query"]
-	return errors.New("Not implemented: ChannelSearchRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = ChannelSearchRequest{}.new()
+var _ RequestFiller = channelSearchRequest{}.new()
 
 // Channel archive request parameters
-type ChannelArchiveRequest struct {
+type channelArchiveRequest struct {
 	id uint64
 }
 
-func (ChannelArchiveRequest) new() *ChannelArchiveRequest {
-	return &ChannelArchiveRequest{}
+func (channelArchiveRequest) new() *channelArchiveRequest {
+	return &channelArchiveRequest{}
 }
 
-func (c *ChannelArchiveRequest) Fill(r *http.Request) error {
+func (c *channelArchiveRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -142,21 +140,21 @@ func (c *ChannelArchiveRequest) Fill(r *http.Request) error {
 	}
 
 	c.id = parseUInt64(post["id"])
-	return errors.New("Not implemented: ChannelArchiveRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = ChannelArchiveRequest{}.new()
+var _ RequestFiller = channelArchiveRequest{}.new()
 
 // Channel move request parameters
-type ChannelMoveRequest struct {
+type channelMoveRequest struct {
 	id uint64
 }
 
-func (ChannelMoveRequest) new() *ChannelMoveRequest {
-	return &ChannelMoveRequest{}
+func (channelMoveRequest) new() *channelMoveRequest {
+	return &channelMoveRequest{}
 }
 
-func (c *ChannelMoveRequest) Fill(r *http.Request) error {
+func (c *channelMoveRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -169,22 +167,22 @@ func (c *ChannelMoveRequest) Fill(r *http.Request) error {
 	}
 
 	c.id = parseUInt64(post["id"])
-	return errors.New("Not implemented: ChannelMoveRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = ChannelMoveRequest{}.new()
+var _ RequestFiller = channelMoveRequest{}.new()
 
 // Channel merge request parameters
-type ChannelMergeRequest struct {
+type channelMergeRequest struct {
 	destination uint64
 	source      uint64
 }
 
-func (ChannelMergeRequest) new() *ChannelMergeRequest {
-	return &ChannelMergeRequest{}
+func (channelMergeRequest) new() *channelMergeRequest {
+	return &channelMergeRequest{}
 }
 
-func (c *ChannelMergeRequest) Fill(r *http.Request) error {
+func (c *channelMergeRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -199,7 +197,7 @@ func (c *ChannelMergeRequest) Fill(r *http.Request) error {
 	c.destination = parseUInt64(post["destination"])
 
 	c.source = parseUInt64(post["source"])
-	return errors.New("Not implemented: ChannelMergeRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = ChannelMergeRequest{}.new()
+var _ RequestFiller = channelMergeRequest{}.new()
diff --git a/sam/message.go b/sam/message.go
index 4598d889d..14c2851fe 100644
--- a/sam/message.go
+++ b/sam/message.go
@@ -4,24 +4,24 @@ import (
 	"github.com/pkg/errors"
 )
 
-func (m *Message) Edit(r *MessageEditRequest) (interface{}, error) {
+func (m *Message) Edit(r *messageEditRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Message.edit")
 }
-func (m *Message) Attach(r *MessageAttachRequest) (interface{}, error) {
+func (m *Message) Attach(r *messageAttachRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Message.attach")
 }
-func (m *Message) Remove(r *MessageRemoveRequest) (interface{}, error) {
+func (m *Message) Remove(r *messageRemoveRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Message.remove")
 }
-func (m *Message) Read(r *MessageReadRequest) (interface{}, error) {
+func (m *Message) Read(r *messageReadRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Message.read")
 }
-func (m *Message) Search(r *MessageSearchRequest) (interface{}, error) {
+func (m *Message) Search(r *messageSearchRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Message.search")
 }
-func (m *Message) Pin(r *MessagePinRequest) (interface{}, error) {
+func (m *Message) Pin(r *messagePinRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Message.pin")
 }
-func (m *Message) Flag(r *MessageFlagRequest) (interface{}, error) {
+func (m *Message) Flag(r *messageFlagRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Message.flag")
 }
diff --git a/sam/message.handlers.go b/sam/message.handlers.go
index f3352bfd0..ce727a59a 100644
--- a/sam/message.handlers.go
+++ b/sam/message.handlers.go
@@ -7,30 +7,30 @@ import (
 )
 
 func (mh *MessageHandlers) Edit(w http.ResponseWriter, r *http.Request) {
-	params := MessageEditRequest{}.new()
+	params := messageEditRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return mh.Message.Edit(params) })
 }
 func (mh *MessageHandlers) Attach(w http.ResponseWriter, r *http.Request) {
-	params := MessageAttachRequest{}.new()
+	params := messageAttachRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return mh.Message.Attach(params) })
 }
 func (mh *MessageHandlers) Remove(w http.ResponseWriter, r *http.Request) {
-	params := MessageRemoveRequest{}.new()
+	params := messageRemoveRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return mh.Message.Remove(params) })
 }
 func (mh *MessageHandlers) Read(w http.ResponseWriter, r *http.Request) {
-	params := MessageReadRequest{}.new()
+	params := messageReadRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return mh.Message.Read(params) })
 }
 func (mh *MessageHandlers) Search(w http.ResponseWriter, r *http.Request) {
-	params := MessageSearchRequest{}.new()
+	params := messageSearchRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return mh.Message.Search(params) })
 }
 func (mh *MessageHandlers) Pin(w http.ResponseWriter, r *http.Request) {
-	params := MessagePinRequest{}.new()
+	params := messagePinRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return mh.Message.Pin(params) })
 }
 func (mh *MessageHandlers) Flag(w http.ResponseWriter, r *http.Request) {
-	params := MessageFlagRequest{}.new()
+	params := messageFlagRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return mh.Message.Flag(params) })
 }
diff --git a/sam/message.interfaces.go b/sam/message.interfaces.go
index f240ee8ac..22e17bef0 100644
--- a/sam/message.interfaces.go
+++ b/sam/message.interfaces.go
@@ -17,13 +17,13 @@ func (MessageHandlers) new() *MessageHandlers {
 
 // Internal API interface
 type MessageAPI interface {
-	Edit(*MessageEditRequest) (interface{}, error)
-	Attach(*MessageAttachRequest) (interface{}, error)
-	Remove(*MessageRemoveRequest) (interface{}, error)
-	Read(*MessageReadRequest) (interface{}, error)
-	Search(*MessageSearchRequest) (interface{}, error)
-	Pin(*MessagePinRequest) (interface{}, error)
-	Flag(*MessageFlagRequest) (interface{}, error)
+	Edit(*messageEditRequest) (interface{}, error)
+	Attach(*messageAttachRequest) (interface{}, error)
+	Remove(*messageRemoveRequest) (interface{}, error)
+	Read(*messageReadRequest) (interface{}, error)
+	Search(*messageSearchRequest) (interface{}, error)
+	Pin(*messagePinRequest) (interface{}, error)
+	Flag(*messageFlagRequest) (interface{}, error)
 }
 
 // HTTP API interface
diff --git a/sam/message.request.go b/sam/message.request.go
index 34fb71731..cf480b32c 100644
--- a/sam/message.request.go
+++ b/sam/message.request.go
@@ -2,22 +2,20 @@ package sam
 
 import (
 	"net/http"
-
-	"github.com/pkg/errors"
 )
 
 // Message edit request parameters
-type MessageEditRequest struct {
+type messageEditRequest struct {
 	id         uint64
 	channel_id uint64
 	contents   string
 }
 
-func (MessageEditRequest) new() *MessageEditRequest {
-	return &MessageEditRequest{}
+func (messageEditRequest) new() *messageEditRequest {
+	return &messageEditRequest{}
 }
 
-func (m *MessageEditRequest) Fill(r *http.Request) error {
+func (m *messageEditRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -34,20 +32,20 @@ func (m *MessageEditRequest) Fill(r *http.Request) error {
 	m.channel_id = parseUInt64(post["channel_id"])
 
 	m.contents = post["contents"]
-	return errors.New("Not implemented: MessageEditRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = MessageEditRequest{}.new()
+var _ RequestFiller = messageEditRequest{}.new()
 
 // Message attach request parameters
-type MessageAttachRequest struct {
+type messageAttachRequest struct {
 }
 
-func (MessageAttachRequest) new() *MessageAttachRequest {
-	return &MessageAttachRequest{}
+func (messageAttachRequest) new() *messageAttachRequest {
+	return &messageAttachRequest{}
 }
 
-func (m *MessageAttachRequest) Fill(r *http.Request) error {
+func (m *messageAttachRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -58,21 +56,21 @@ func (m *MessageAttachRequest) Fill(r *http.Request) error {
 	for name, param := range postVars {
 		post[name] = string(param[0])
 	}
-	return errors.New("Not implemented: MessageAttachRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = MessageAttachRequest{}.new()
+var _ RequestFiller = messageAttachRequest{}.new()
 
 // Message remove request parameters
-type MessageRemoveRequest struct {
+type messageRemoveRequest struct {
 	id uint64
 }
 
-func (MessageRemoveRequest) new() *MessageRemoveRequest {
-	return &MessageRemoveRequest{}
+func (messageRemoveRequest) new() *messageRemoveRequest {
+	return &messageRemoveRequest{}
 }
 
-func (m *MessageRemoveRequest) Fill(r *http.Request) error {
+func (m *messageRemoveRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -85,21 +83,21 @@ func (m *MessageRemoveRequest) Fill(r *http.Request) error {
 	}
 
 	m.id = parseUInt64(get["id"])
-	return errors.New("Not implemented: MessageRemoveRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = MessageRemoveRequest{}.new()
+var _ RequestFiller = messageRemoveRequest{}.new()
 
 // Message read request parameters
-type MessageReadRequest struct {
+type messageReadRequest struct {
 	channel_id uint64
 }
 
-func (MessageReadRequest) new() *MessageReadRequest {
-	return &MessageReadRequest{}
+func (messageReadRequest) new() *messageReadRequest {
+	return &messageReadRequest{}
 }
 
-func (m *MessageReadRequest) Fill(r *http.Request) error {
+func (m *messageReadRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -112,22 +110,22 @@ func (m *MessageReadRequest) Fill(r *http.Request) error {
 	}
 
 	m.channel_id = parseUInt64(post["channel_id"])
-	return errors.New("Not implemented: MessageReadRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = MessageReadRequest{}.new()
+var _ RequestFiller = messageReadRequest{}.new()
 
 // Message search request parameters
-type MessageSearchRequest struct {
+type messageSearchRequest struct {
 	query        string
 	message_type string
 }
 
-func (MessageSearchRequest) new() *MessageSearchRequest {
-	return &MessageSearchRequest{}
+func (messageSearchRequest) new() *messageSearchRequest {
+	return &messageSearchRequest{}
 }
 
-func (m *MessageSearchRequest) Fill(r *http.Request) error {
+func (m *messageSearchRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -142,21 +140,21 @@ func (m *MessageSearchRequest) Fill(r *http.Request) error {
 	m.query = get["query"]
 
 	m.message_type = get["message_type"]
-	return errors.New("Not implemented: MessageSearchRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = MessageSearchRequest{}.new()
+var _ RequestFiller = messageSearchRequest{}.new()
 
 // Message pin request parameters
-type MessagePinRequest struct {
+type messagePinRequest struct {
 	id uint64
 }
 
-func (MessagePinRequest) new() *MessagePinRequest {
-	return &MessagePinRequest{}
+func (messagePinRequest) new() *messagePinRequest {
+	return &messagePinRequest{}
 }
 
-func (m *MessagePinRequest) Fill(r *http.Request) error {
+func (m *messagePinRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -169,21 +167,21 @@ func (m *MessagePinRequest) Fill(r *http.Request) error {
 	}
 
 	m.id = parseUInt64(post["id"])
-	return errors.New("Not implemented: MessagePinRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = MessagePinRequest{}.new()
+var _ RequestFiller = messagePinRequest{}.new()
 
 // Message flag request parameters
-type MessageFlagRequest struct {
+type messageFlagRequest struct {
 	id uint64
 }
 
-func (MessageFlagRequest) new() *MessageFlagRequest {
-	return &MessageFlagRequest{}
+func (messageFlagRequest) new() *messageFlagRequest {
+	return &messageFlagRequest{}
 }
 
-func (m *MessageFlagRequest) Fill(r *http.Request) error {
+func (m *messageFlagRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -196,7 +194,7 @@ func (m *MessageFlagRequest) Fill(r *http.Request) error {
 	}
 
 	m.id = parseUInt64(post["id"])
-	return errors.New("Not implemented: MessageFlagRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = MessageFlagRequest{}.new()
+var _ RequestFiller = messageFlagRequest{}.new()
diff --git a/sam/organisation.go b/sam/organisation.go
index c6eac38bb..66ee89873 100644
--- a/sam/organisation.go
+++ b/sam/organisation.go
@@ -4,18 +4,18 @@ import (
 	"github.com/pkg/errors"
 )
 
-func (o *Organisation) Edit(r *OrganisationEditRequest) (interface{}, error) {
+func (o *Organisation) Edit(r *organisationEditRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Organisation.edit")
 }
-func (o *Organisation) Remove(r *OrganisationRemoveRequest) (interface{}, error) {
+func (o *Organisation) Remove(r *organisationRemoveRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Organisation.remove")
 }
-func (o *Organisation) Read(r *OrganisationReadRequest) (interface{}, error) {
+func (o *Organisation) Read(r *organisationReadRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Organisation.read")
 }
-func (o *Organisation) Search(r *OrganisationSearchRequest) (interface{}, error) {
+func (o *Organisation) Search(r *organisationSearchRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Organisation.search")
 }
-func (o *Organisation) Archive(r *OrganisationArchiveRequest) (interface{}, error) {
+func (o *Organisation) Archive(r *organisationArchiveRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Organisation.archive")
 }
diff --git a/sam/organisation.handlers.go b/sam/organisation.handlers.go
index 446085bd6..501cd7882 100644
--- a/sam/organisation.handlers.go
+++ b/sam/organisation.handlers.go
@@ -7,22 +7,22 @@ import (
 )
 
 func (oh *OrganisationHandlers) Edit(w http.ResponseWriter, r *http.Request) {
-	params := OrganisationEditRequest{}.new()
+	params := organisationEditRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return oh.Organisation.Edit(params) })
 }
 func (oh *OrganisationHandlers) Remove(w http.ResponseWriter, r *http.Request) {
-	params := OrganisationRemoveRequest{}.new()
+	params := organisationRemoveRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return oh.Organisation.Remove(params) })
 }
 func (oh *OrganisationHandlers) Read(w http.ResponseWriter, r *http.Request) {
-	params := OrganisationReadRequest{}.new()
+	params := organisationReadRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return oh.Organisation.Read(params) })
 }
 func (oh *OrganisationHandlers) Search(w http.ResponseWriter, r *http.Request) {
-	params := OrganisationSearchRequest{}.new()
+	params := organisationSearchRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return oh.Organisation.Search(params) })
 }
 func (oh *OrganisationHandlers) Archive(w http.ResponseWriter, r *http.Request) {
-	params := OrganisationArchiveRequest{}.new()
+	params := organisationArchiveRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return oh.Organisation.Archive(params) })
 }
diff --git a/sam/organisation.interfaces.go b/sam/organisation.interfaces.go
index 9f6ca8ea1..dc88f7355 100644
--- a/sam/organisation.interfaces.go
+++ b/sam/organisation.interfaces.go
@@ -17,11 +17,11 @@ func (OrganisationHandlers) new() *OrganisationHandlers {
 
 // Internal API interface
 type OrganisationAPI interface {
-	Edit(*OrganisationEditRequest) (interface{}, error)
-	Remove(*OrganisationRemoveRequest) (interface{}, error)
-	Read(*OrganisationReadRequest) (interface{}, error)
-	Search(*OrganisationSearchRequest) (interface{}, error)
-	Archive(*OrganisationArchiveRequest) (interface{}, error)
+	Edit(*organisationEditRequest) (interface{}, error)
+	Remove(*organisationRemoveRequest) (interface{}, error)
+	Read(*organisationReadRequest) (interface{}, error)
+	Search(*organisationSearchRequest) (interface{}, error)
+	Archive(*organisationArchiveRequest) (interface{}, error)
 }
 
 // HTTP API interface
diff --git a/sam/organisation.request.go b/sam/organisation.request.go
index 58d071491..5b738b398 100644
--- a/sam/organisation.request.go
+++ b/sam/organisation.request.go
@@ -2,21 +2,19 @@ package sam
 
 import (
 	"net/http"
-
-	"github.com/pkg/errors"
 )
 
 // Organisation edit request parameters
-type OrganisationEditRequest struct {
+type organisationEditRequest struct {
 	id   uint64
 	name string
 }
 
-func (OrganisationEditRequest) new() *OrganisationEditRequest {
-	return &OrganisationEditRequest{}
+func (organisationEditRequest) new() *organisationEditRequest {
+	return &organisationEditRequest{}
 }
 
-func (o *OrganisationEditRequest) Fill(r *http.Request) error {
+func (o *organisationEditRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -31,21 +29,21 @@ func (o *OrganisationEditRequest) Fill(r *http.Request) error {
 	o.id = parseUInt64(post["id"])
 
 	o.name = post["name"]
-	return errors.New("Not implemented: OrganisationEditRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = OrganisationEditRequest{}.new()
+var _ RequestFiller = organisationEditRequest{}.new()
 
 // Organisation remove request parameters
-type OrganisationRemoveRequest struct {
+type organisationRemoveRequest struct {
 	id uint64
 }
 
-func (OrganisationRemoveRequest) new() *OrganisationRemoveRequest {
-	return &OrganisationRemoveRequest{}
+func (organisationRemoveRequest) new() *organisationRemoveRequest {
+	return &organisationRemoveRequest{}
 }
 
-func (o *OrganisationRemoveRequest) Fill(r *http.Request) error {
+func (o *organisationRemoveRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -58,21 +56,21 @@ func (o *OrganisationRemoveRequest) Fill(r *http.Request) error {
 	}
 
 	o.id = parseUInt64(get["id"])
-	return errors.New("Not implemented: OrganisationRemoveRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = OrganisationRemoveRequest{}.new()
+var _ RequestFiller = organisationRemoveRequest{}.new()
 
 // Organisation read request parameters
-type OrganisationReadRequest struct {
+type organisationReadRequest struct {
 	id uint64
 }
 
-func (OrganisationReadRequest) new() *OrganisationReadRequest {
-	return &OrganisationReadRequest{}
+func (organisationReadRequest) new() *organisationReadRequest {
+	return &organisationReadRequest{}
 }
 
-func (o *OrganisationReadRequest) Fill(r *http.Request) error {
+func (o *organisationReadRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -85,21 +83,21 @@ func (o *OrganisationReadRequest) Fill(r *http.Request) error {
 	}
 
 	o.id = parseUInt64(get["id"])
-	return errors.New("Not implemented: OrganisationReadRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = OrganisationReadRequest{}.new()
+var _ RequestFiller = organisationReadRequest{}.new()
 
 // Organisation search request parameters
-type OrganisationSearchRequest struct {
+type organisationSearchRequest struct {
 	query string
 }
 
-func (OrganisationSearchRequest) new() *OrganisationSearchRequest {
-	return &OrganisationSearchRequest{}
+func (organisationSearchRequest) new() *organisationSearchRequest {
+	return &organisationSearchRequest{}
 }
 
-func (o *OrganisationSearchRequest) Fill(r *http.Request) error {
+func (o *organisationSearchRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -112,21 +110,21 @@ func (o *OrganisationSearchRequest) Fill(r *http.Request) error {
 	}
 
 	o.query = get["query"]
-	return errors.New("Not implemented: OrganisationSearchRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = OrganisationSearchRequest{}.new()
+var _ RequestFiller = organisationSearchRequest{}.new()
 
 // Organisation archive request parameters
-type OrganisationArchiveRequest struct {
+type organisationArchiveRequest struct {
 	id uint64
 }
 
-func (OrganisationArchiveRequest) new() *OrganisationArchiveRequest {
-	return &OrganisationArchiveRequest{}
+func (organisationArchiveRequest) new() *organisationArchiveRequest {
+	return &organisationArchiveRequest{}
 }
 
-func (o *OrganisationArchiveRequest) Fill(r *http.Request) error {
+func (o *organisationArchiveRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -139,7 +137,7 @@ func (o *OrganisationArchiveRequest) Fill(r *http.Request) error {
 	}
 
 	o.id = parseUInt64(post["id"])
-	return errors.New("Not implemented: OrganisationArchiveRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = OrganisationArchiveRequest{}.new()
+var _ RequestFiller = organisationArchiveRequest{}.new()
diff --git a/sam/team.go b/sam/team.go
index 5bb32cdf8..f8d5f91c7 100644
--- a/sam/team.go
+++ b/sam/team.go
@@ -4,21 +4,21 @@ import (
 	"github.com/pkg/errors"
 )
 
-func (t *Team) Edit(r *TeamEditRequest) (interface{}, error) {
+func (t *Team) Edit(r *teamEditRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Team.edit")
 }
-func (t *Team) Remove(r *TeamRemoveRequest) (interface{}, error) {
+func (t *Team) Remove(r *teamRemoveRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Team.remove")
 }
-func (t *Team) Read(r *TeamReadRequest) (interface{}, error) {
+func (t *Team) Read(r *teamReadRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Team.read")
 }
-func (t *Team) Search(r *TeamSearchRequest) (interface{}, error) {
+func (t *Team) Search(r *teamSearchRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Team.search")
 }
-func (t *Team) Archive(r *TeamArchiveRequest) (interface{}, error) {
+func (t *Team) Archive(r *teamArchiveRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Team.archive")
 }
-func (t *Team) Move(r *TeamMoveRequest) (interface{}, error) {
+func (t *Team) Move(r *teamMoveRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Team.move")
 }
diff --git a/sam/team.handlers.go b/sam/team.handlers.go
index 6a175459b..3133ff993 100644
--- a/sam/team.handlers.go
+++ b/sam/team.handlers.go
@@ -7,26 +7,26 @@ import (
 )
 
 func (th *TeamHandlers) Edit(w http.ResponseWriter, r *http.Request) {
-	params := TeamEditRequest{}.new()
+	params := teamEditRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return th.Team.Edit(params) })
 }
 func (th *TeamHandlers) Remove(w http.ResponseWriter, r *http.Request) {
-	params := TeamRemoveRequest{}.new()
+	params := teamRemoveRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return th.Team.Remove(params) })
 }
 func (th *TeamHandlers) Read(w http.ResponseWriter, r *http.Request) {
-	params := TeamReadRequest{}.new()
+	params := teamReadRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return th.Team.Read(params) })
 }
 func (th *TeamHandlers) Search(w http.ResponseWriter, r *http.Request) {
-	params := TeamSearchRequest{}.new()
+	params := teamSearchRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return th.Team.Search(params) })
 }
 func (th *TeamHandlers) Archive(w http.ResponseWriter, r *http.Request) {
-	params := TeamArchiveRequest{}.new()
+	params := teamArchiveRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return th.Team.Archive(params) })
 }
 func (th *TeamHandlers) Move(w http.ResponseWriter, r *http.Request) {
-	params := TeamMoveRequest{}.new()
+	params := teamMoveRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return th.Team.Move(params) })
 }
diff --git a/sam/team.interfaces.go b/sam/team.interfaces.go
index 77f0e0db0..ff418b7ef 100644
--- a/sam/team.interfaces.go
+++ b/sam/team.interfaces.go
@@ -17,12 +17,12 @@ func (TeamHandlers) new() *TeamHandlers {
 
 // Internal API interface
 type TeamAPI interface {
-	Edit(*TeamEditRequest) (interface{}, error)
-	Remove(*TeamRemoveRequest) (interface{}, error)
-	Read(*TeamReadRequest) (interface{}, error)
-	Search(*TeamSearchRequest) (interface{}, error)
-	Archive(*TeamArchiveRequest) (interface{}, error)
-	Move(*TeamMoveRequest) (interface{}, error)
+	Edit(*teamEditRequest) (interface{}, error)
+	Remove(*teamRemoveRequest) (interface{}, error)
+	Read(*teamReadRequest) (interface{}, error)
+	Search(*teamSearchRequest) (interface{}, error)
+	Archive(*teamArchiveRequest) (interface{}, error)
+	Move(*teamMoveRequest) (interface{}, error)
 }
 
 // HTTP API interface
diff --git a/sam/team.request.go b/sam/team.request.go
index 2ba550a0a..245e313ad 100644
--- a/sam/team.request.go
+++ b/sam/team.request.go
@@ -2,22 +2,20 @@ package sam
 
 import (
 	"net/http"
-
-	"github.com/pkg/errors"
 )
 
 // Team edit request parameters
-type TeamEditRequest struct {
+type teamEditRequest struct {
 	id      uint64
 	name    string
 	members []uint64
 }
 
-func (TeamEditRequest) new() *TeamEditRequest {
-	return &TeamEditRequest{}
+func (teamEditRequest) new() *teamEditRequest {
+	return &teamEditRequest{}
 }
 
-func (t *TeamEditRequest) Fill(r *http.Request) error {
+func (t *teamEditRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -32,21 +30,21 @@ func (t *TeamEditRequest) Fill(r *http.Request) error {
 	t.id = parseUInt64(post["id"])
 
 	t.name = post["name"]
-	return errors.New("Not implemented: TeamEditRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = TeamEditRequest{}.new()
+var _ RequestFiller = teamEditRequest{}.new()
 
 // Team remove request parameters
-type TeamRemoveRequest struct {
+type teamRemoveRequest struct {
 	id uint64
 }
 
-func (TeamRemoveRequest) new() *TeamRemoveRequest {
-	return &TeamRemoveRequest{}
+func (teamRemoveRequest) new() *teamRemoveRequest {
+	return &teamRemoveRequest{}
 }
 
-func (t *TeamRemoveRequest) Fill(r *http.Request) error {
+func (t *teamRemoveRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -59,21 +57,21 @@ func (t *TeamRemoveRequest) Fill(r *http.Request) error {
 	}
 
 	t.id = parseUInt64(get["id"])
-	return errors.New("Not implemented: TeamRemoveRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = TeamRemoveRequest{}.new()
+var _ RequestFiller = teamRemoveRequest{}.new()
 
 // Team read request parameters
-type TeamReadRequest struct {
+type teamReadRequest struct {
 	id uint64
 }
 
-func (TeamReadRequest) new() *TeamReadRequest {
-	return &TeamReadRequest{}
+func (teamReadRequest) new() *teamReadRequest {
+	return &teamReadRequest{}
 }
 
-func (t *TeamReadRequest) Fill(r *http.Request) error {
+func (t *teamReadRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -86,21 +84,21 @@ func (t *TeamReadRequest) Fill(r *http.Request) error {
 	}
 
 	t.id = parseUInt64(get["id"])
-	return errors.New("Not implemented: TeamReadRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = TeamReadRequest{}.new()
+var _ RequestFiller = teamReadRequest{}.new()
 
 // Team search request parameters
-type TeamSearchRequest struct {
+type teamSearchRequest struct {
 	query string
 }
 
-func (TeamSearchRequest) new() *TeamSearchRequest {
-	return &TeamSearchRequest{}
+func (teamSearchRequest) new() *teamSearchRequest {
+	return &teamSearchRequest{}
 }
 
-func (t *TeamSearchRequest) Fill(r *http.Request) error {
+func (t *teamSearchRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -113,21 +111,21 @@ func (t *TeamSearchRequest) Fill(r *http.Request) error {
 	}
 
 	t.query = get["query"]
-	return errors.New("Not implemented: TeamSearchRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = TeamSearchRequest{}.new()
+var _ RequestFiller = teamSearchRequest{}.new()
 
 // Team archive request parameters
-type TeamArchiveRequest struct {
+type teamArchiveRequest struct {
 	id uint64
 }
 
-func (TeamArchiveRequest) new() *TeamArchiveRequest {
-	return &TeamArchiveRequest{}
+func (teamArchiveRequest) new() *teamArchiveRequest {
+	return &teamArchiveRequest{}
 }
 
-func (t *TeamArchiveRequest) Fill(r *http.Request) error {
+func (t *teamArchiveRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -140,22 +138,22 @@ func (t *TeamArchiveRequest) Fill(r *http.Request) error {
 	}
 
 	t.id = parseUInt64(post["id"])
-	return errors.New("Not implemented: TeamArchiveRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = TeamArchiveRequest{}.new()
+var _ RequestFiller = teamArchiveRequest{}.new()
 
 // Team move request parameters
-type TeamMoveRequest struct {
+type teamMoveRequest struct {
 	id              uint64
 	organisation_id uint64
 }
 
-func (TeamMoveRequest) new() *TeamMoveRequest {
-	return &TeamMoveRequest{}
+func (teamMoveRequest) new() *teamMoveRequest {
+	return &teamMoveRequest{}
 }
 
-func (t *TeamMoveRequest) Fill(r *http.Request) error {
+func (t *teamMoveRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -170,7 +168,7 @@ func (t *TeamMoveRequest) Fill(r *http.Request) error {
 	t.id = parseUInt64(post["id"])
 
 	t.organisation_id = parseUInt64(post["organisation_id"])
-	return errors.New("Not implemented: TeamMoveRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = TeamMoveRequest{}.new()
+var _ RequestFiller = teamMoveRequest{}.new()
diff --git a/sam/templates/http_.tpl b/sam/templates/http_.tpl
index 4b540449e..abc4b9ec1 100644
--- a/sam/templates/http_.tpl
+++ b/sam/templates/http_.tpl
@@ -5,7 +5,7 @@ import (
 )
 
 {foreach $calls as $call}
-func ({self} *{name}) {call.name|ucfirst}(r *{name}{call.name|ucfirst}Request) (interface{}, error) {
+func ({self} *{name}) {call.name|ucfirst}(r *{name|lcfirst}{call.name|ucfirst}Request) (interface{}, error) {
 	return nil, errors.New("Not implemented: {name}.{call.name}")
 }
 {/foreach}
diff --git a/sam/templates/http_handlers.tpl b/sam/templates/http_handlers.tpl
index 77660f19f..3eab30652 100644
--- a/sam/templates/http_handlers.tpl
+++ b/sam/templates/http_handlers.tpl
@@ -8,7 +8,7 @@ import (
 
 {foreach $calls as $call}
 func ({self}h *{name}Handlers) {call.name|ucfirst}(w http.ResponseWriter, r *http.Request) {
-	params := {name}{call.name|ucfirst}Request{}.new()
+	params := {name|lcfirst}{call.name|ucfirst}Request{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return {self}h.{name}.{call.name|ucfirst}(params) })
 }
 {/foreach}
diff --git a/sam/templates/http_interfaces.tpl b/sam/templates/http_interfaces.tpl
index c8da0855c..8f2e2f213 100644
--- a/sam/templates/http_interfaces.tpl
+++ b/sam/templates/http_interfaces.tpl
@@ -18,7 +18,7 @@ func ({name}Handlers) new() *{name}Handlers {
 // Internal API interface
 type {name}API interface {
 {foreach $calls as $call}
-	{call.name|ucfirst}(*{name}{call.name|ucfirst}Request) (interface{}, error)
+	{call.name|ucfirst}(*{name|lcfirst}{call.name|ucfirst}Request) (interface{}, error)
 {/foreach}
 }
 
diff --git a/sam/templates/http_request.tpl b/sam/templates/http_request.tpl
index 91f3c6229..92215dd16 100644
--- a/sam/templates/http_request.tpl
+++ b/sam/templates/http_request.tpl
@@ -2,13 +2,11 @@ package {package}
 
 import (
 	"net/http"
-
-	"github.com/pkg/errors"
 )
 
 {foreach $calls as $call}
 // {name} {call.name} request parameters
-type {name}{call.name|ucfirst}Request struct {
+type {name|lcfirst}{call.name|ucfirst}Request struct {
 {foreach $call.parameters as $params}
 {foreach $params as $method => $param}
 	{param.name} {param.type}{newline}
@@ -16,11 +14,11 @@ type {name}{call.name|ucfirst}Request struct {
 {/foreach}
 }
 
-func ({name}{call.name|ucfirst}Request) new() *{name}{call.name|ucfirst}Request {
-	return &{name}{call.name|ucfirst}Request{}
+func ({name|lcfirst}{call.name|ucfirst}Request) new() *{name|lcfirst}{call.name|ucfirst}Request {
+	return &{name|lcfirst}{call.name|ucfirst}Request{}
 }
 
-func ({self} *{name}{call.name|ucfirst}Request) Fill(r *http.Request) error {
+func ({self} *{name|lcfirst}{call.name|ucfirst}Request) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -38,8 +36,8 @@ func ({self} *{name}{call.name|ucfirst}Request) Fill(r *http.Request) error {
 {/if}
 {/foreach}
 {/foreach}
-	return errors.New("Not implemented: {name}{call.name|ucfirst}Request.Fill")
+	return nil
 }
 
-var _ RequestFiller = {name}{call.name|ucfirst}Request{}.new()
+var _ RequestFiller = {name|lcfirst}{call.name|ucfirst}Request{}.new()
 {/foreach}
diff --git a/sam/user.go b/sam/user.go
index 66f813c9f..ac5ebd016 100644
--- a/sam/user.go
+++ b/sam/user.go
@@ -4,9 +4,9 @@ import (
 	"github.com/pkg/errors"
 )
 
-func (u *User) Login(r *UserLoginRequest) (interface{}, error) {
+func (u *User) Login(r *userLoginRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: User.login")
 }
-func (u *User) Search(r *UserSearchRequest) (interface{}, error) {
+func (u *User) Search(r *userSearchRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: User.search")
 }
diff --git a/sam/user.handlers.go b/sam/user.handlers.go
index 86ea5e2e5..1ffa1072d 100644
--- a/sam/user.handlers.go
+++ b/sam/user.handlers.go
@@ -7,10 +7,10 @@ import (
 )
 
 func (uh *UserHandlers) Login(w http.ResponseWriter, r *http.Request) {
-	params := UserLoginRequest{}.new()
+	params := userLoginRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return uh.User.Login(params) })
 }
 func (uh *UserHandlers) Search(w http.ResponseWriter, r *http.Request) {
-	params := UserSearchRequest{}.new()
+	params := userSearchRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return uh.User.Search(params) })
 }
diff --git a/sam/user.interfaces.go b/sam/user.interfaces.go
index 39cbf8c67..c26611da9 100644
--- a/sam/user.interfaces.go
+++ b/sam/user.interfaces.go
@@ -17,8 +17,8 @@ func (UserHandlers) new() *UserHandlers {
 
 // Internal API interface
 type UserAPI interface {
-	Login(*UserLoginRequest) (interface{}, error)
-	Search(*UserSearchRequest) (interface{}, error)
+	Login(*userLoginRequest) (interface{}, error)
+	Search(*userSearchRequest) (interface{}, error)
 }
 
 // HTTP API interface
diff --git a/sam/user.request.go b/sam/user.request.go
index 1483cd1fc..affa62ad7 100644
--- a/sam/user.request.go
+++ b/sam/user.request.go
@@ -2,21 +2,19 @@ package sam
 
 import (
 	"net/http"
-
-	"github.com/pkg/errors"
 )
 
 // User login request parameters
-type UserLoginRequest struct {
+type userLoginRequest struct {
 	username string
 	password string
 }
 
-func (UserLoginRequest) new() *UserLoginRequest {
-	return &UserLoginRequest{}
+func (userLoginRequest) new() *userLoginRequest {
+	return &userLoginRequest{}
 }
 
-func (u *UserLoginRequest) Fill(r *http.Request) error {
+func (u *userLoginRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -31,21 +29,21 @@ func (u *UserLoginRequest) Fill(r *http.Request) error {
 	u.username = post["username"]
 
 	u.password = post["password"]
-	return errors.New("Not implemented: UserLoginRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = UserLoginRequest{}.new()
+var _ RequestFiller = userLoginRequest{}.new()
 
 // User search request parameters
-type UserSearchRequest struct {
+type userSearchRequest struct {
 	query string
 }
 
-func (UserSearchRequest) new() *UserSearchRequest {
-	return &UserSearchRequest{}
+func (userSearchRequest) new() *userSearchRequest {
+	return &userSearchRequest{}
 }
 
-func (u *UserSearchRequest) Fill(r *http.Request) error {
+func (u *userSearchRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -58,7 +56,7 @@ func (u *UserSearchRequest) Fill(r *http.Request) error {
 	}
 
 	u.query = get["query"]
-	return errors.New("Not implemented: UserSearchRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = UserSearchRequest{}.new()
+var _ RequestFiller = userSearchRequest{}.new()
diff --git a/sam/websocket.go b/sam/websocket.go
index 669466244..4b76e2266 100644
--- a/sam/websocket.go
+++ b/sam/websocket.go
@@ -4,6 +4,6 @@ import (
 	"github.com/pkg/errors"
 )
 
-func (w *Websocket) Client(r *WebsocketClientRequest) (interface{}, error) {
+func (w *Websocket) Client(r *websocketClientRequest) (interface{}, error) {
 	return nil, errors.New("Not implemented: Websocket.client")
 }
diff --git a/sam/websocket.handlers.go b/sam/websocket.handlers.go
index b1f0dccad..b04a51e2f 100644
--- a/sam/websocket.handlers.go
+++ b/sam/websocket.handlers.go
@@ -7,6 +7,6 @@ import (
 )
 
 func (wh *WebsocketHandlers) Client(w http.ResponseWriter, r *http.Request) {
-	params := WebsocketClientRequest{}.new()
+	params := websocketClientRequest{}.new()
 	resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return wh.Websocket.Client(params) })
 }
diff --git a/sam/websocket.interfaces.go b/sam/websocket.interfaces.go
index 8f1050e0c..58407c717 100644
--- a/sam/websocket.interfaces.go
+++ b/sam/websocket.interfaces.go
@@ -17,7 +17,7 @@ func (WebsocketHandlers) new() *WebsocketHandlers {
 
 // Internal API interface
 type WebsocketAPI interface {
-	Client(*WebsocketClientRequest) (interface{}, error)
+	Client(*websocketClientRequest) (interface{}, error)
 }
 
 // HTTP API interface
diff --git a/sam/websocket.request.go b/sam/websocket.request.go
index b117032b4..c00e69527 100644
--- a/sam/websocket.request.go
+++ b/sam/websocket.request.go
@@ -2,19 +2,17 @@ package sam
 
 import (
 	"net/http"
-
-	"github.com/pkg/errors"
 )
 
 // Websocket client request parameters
-type WebsocketClientRequest struct {
+type websocketClientRequest struct {
 }
 
-func (WebsocketClientRequest) new() *WebsocketClientRequest {
-	return &WebsocketClientRequest{}
+func (websocketClientRequest) new() *websocketClientRequest {
+	return &websocketClientRequest{}
 }
 
-func (w *WebsocketClientRequest) Fill(r *http.Request) error {
+func (w *websocketClientRequest) Fill(r *http.Request) error {
 	get := map[string]string{}
 	post := map[string]string{}
 	urlQuery := r.URL.Query()
@@ -25,7 +23,7 @@ func (w *WebsocketClientRequest) Fill(r *http.Request) error {
 	for name, param := range postVars {
 		post[name] = string(param[0])
 	}
-	return errors.New("Not implemented: WebsocketClientRequest.Fill")
+	return nil
 }
 
-var _ RequestFiller = WebsocketClientRequest{}.new()
+var _ RequestFiller = websocketClientRequest{}.new()