login.capn.go

// Copyright (C) 2020 Finogeeks Co., Ltd
//
// This program is free software: you can redistribute it and/or  modify
// it under the terms of the GNU Affero General Public License, version 3,
// as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

// Code generated by capnpc-go. DO NOT EDIT.

package external

import (
	capnp "zombiezen.com/go/capnproto2"
	text "zombiezen.com/go/capnproto2/encoding/text"
	schemas "zombiezen.com/go/capnproto2/schemas"
)

type FlowCapn struct{ capnp.Struct }

// FlowCapn_TypeID is the unique identifier for the type FlowCapn.
const FlowCapn_TypeID = 0x9ab73643587fe10c

func NewFlowCapn(s *capnp.Segment) (FlowCapn, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
	return FlowCapn{st}, err
}

func NewRootFlowCapn(s *capnp.Segment) (FlowCapn, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
	return FlowCapn{st}, err
}

func ReadRootFlowCapn(msg *capnp.Message) (FlowCapn, error) {
	root, err := msg.RootPtr()
	return FlowCapn{root.Struct()}, err
}

func (s FlowCapn) String() string {
	str, _ := text.Marshal(0x9ab73643587fe10c, s.Struct)
	return str
}

func (s FlowCapn) Type() (string, error) {
	p, err := s.Struct.Ptr(0)
	return p.Text(), err
}

func (s FlowCapn) HasType() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s FlowCapn) TypeBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(0)
	return p.TextBytes(), err
}

func (s FlowCapn) SetType(v string) error {
	return s.Struct.SetText(0, v)
}

func (s FlowCapn) Stages() (capnp.TextList, error) {
	p, err := s.Struct.Ptr(1)
	return capnp.TextList{List: p.List()}, err
}

func (s FlowCapn) HasStages() bool {
	p, err := s.Struct.Ptr(1)
	return p.IsValid() || err != nil
}

func (s FlowCapn) SetStages(v capnp.TextList) error {
	return s.Struct.SetPtr(1, v.List.ToPtr())
}

// NewStages sets the stages field to a newly
// allocated capnp.TextList, preferring placement in s's segment.
func (s FlowCapn) NewStages(n int32) (capnp.TextList, error) {
	l, err := capnp.NewTextList(s.Struct.Segment(), n)
	if err != nil {
		return capnp.TextList{}, err
	}
	err = s.Struct.SetPtr(1, l.List.ToPtr())
	return l, err
}

// FlowCapn_List is a list of FlowCapn.
type FlowCapn_List struct{ capnp.List }

// NewFlowCapn creates a new list of FlowCapn.
func NewFlowCapn_List(s *capnp.Segment, sz int32) (FlowCapn_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
	return FlowCapn_List{l}, err
}

func (s FlowCapn_List) At(i int) FlowCapn { return FlowCapn{s.List.Struct(i)} }

func (s FlowCapn_List) Set(i int, v FlowCapn) error { return s.List.SetStruct(i, v.Struct) }

func (s FlowCapn_List) String() string {
	str, _ := text.MarshalList(0x9ab73643587fe10c, s.List)
	return str
}

// FlowCapn_Promise is a wrapper for a FlowCapn promised by a client call.
type FlowCapn_Promise struct{ *capnp.Pipeline }

func (p FlowCapn_Promise) Struct() (FlowCapn, error) {
	s, err := p.Pipeline.Struct()
	return FlowCapn{s}, err
}

type GetLoginRequestCapn struct{ capnp.Struct }

// GetLoginRequestCapn_TypeID is the unique identifier for the type GetLoginRequestCapn.
const GetLoginRequestCapn_TypeID = 0xf9423d522bc945c9

func NewGetLoginRequestCapn(s *capnp.Segment) (GetLoginRequestCapn, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0})
	return GetLoginRequestCapn{st}, err
}

func NewRootGetLoginRequestCapn(s *capnp.Segment) (GetLoginRequestCapn, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0})
	return GetLoginRequestCapn{st}, err
}

func ReadRootGetLoginRequestCapn(msg *capnp.Message) (GetLoginRequestCapn, error) {
	root, err := msg.RootPtr()
	return GetLoginRequestCapn{root.Struct()}, err
}

func (s GetLoginRequestCapn) String() string {
	str, _ := text.Marshal(0xf9423d522bc945c9, s.Struct)
	return str
}

func (s GetLoginRequestCapn) IsAdmin() bool {
	return s.Struct.Bit(0)
}

func (s GetLoginRequestCapn) SetIsAdmin(v bool) {
	s.Struct.SetBit(0, v)
}

// GetLoginRequestCapn_List is a list of GetLoginRequestCapn.
type GetLoginRequestCapn_List struct{ capnp.List }

// NewGetLoginRequestCapn creates a new list of GetLoginRequestCapn.
func NewGetLoginRequestCapn_List(s *capnp.Segment, sz int32) (GetLoginRequestCapn_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0}, sz)
	return GetLoginRequestCapn_List{l}, err
}

func (s GetLoginRequestCapn_List) At(i int) GetLoginRequestCapn {
	return GetLoginRequestCapn{s.List.Struct(i)}
}

func (s GetLoginRequestCapn_List) Set(i int, v GetLoginRequestCapn) error {
	return s.List.SetStruct(i, v.Struct)
}

func (s GetLoginRequestCapn_List) String() string {
	str, _ := text.MarshalList(0xf9423d522bc945c9, s.List)
	return str
}

// GetLoginRequestCapn_Promise is a wrapper for a GetLoginRequestCapn promised by a client call.
type GetLoginRequestCapn_Promise struct{ *capnp.Pipeline }

func (p GetLoginRequestCapn_Promise) Struct() (GetLoginRequestCapn, error) {
	s, err := p.Pipeline.Struct()
	return GetLoginRequestCapn{s}, err
}

type GetLoginResponseCapn struct{ capnp.Struct }

// GetLoginResponseCapn_TypeID is the unique identifier for the type GetLoginResponseCapn.
const GetLoginResponseCapn_TypeID = 0x9aa6454a3699f75b

func NewGetLoginResponseCapn(s *capnp.Segment) (GetLoginResponseCapn, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return GetLoginResponseCapn{st}, err
}

func NewRootGetLoginResponseCapn(s *capnp.Segment) (GetLoginResponseCapn, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return GetLoginResponseCapn{st}, err
}

func ReadRootGetLoginResponseCapn(msg *capnp.Message) (GetLoginResponseCapn, error) {
	root, err := msg.RootPtr()
	return GetLoginResponseCapn{root.Struct()}, err
}

func (s GetLoginResponseCapn) String() string {
	str, _ := text.Marshal(0x9aa6454a3699f75b, s.Struct)
	return str
}

func (s GetLoginResponseCapn) Flows() (FlowCapn_List, error) {
	p, err := s.Struct.Ptr(0)
	return FlowCapn_List{List: p.List()}, err
}

func (s GetLoginResponseCapn) HasFlows() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s GetLoginResponseCapn) SetFlows(v FlowCapn_List) error {
	return s.Struct.SetPtr(0, v.List.ToPtr())
}

// NewFlows sets the flows field to a newly
// allocated FlowCapn_List, preferring placement in s's segment.
func (s GetLoginResponseCapn) NewFlows(n int32) (FlowCapn_List, error) {
	l, err := NewFlowCapn_List(s.Struct.Segment(), n)
	if err != nil {
		return FlowCapn_List{}, err
	}
	err = s.Struct.SetPtr(0, l.List.ToPtr())
	return l, err
}

// GetLoginResponseCapn_List is a list of GetLoginResponseCapn.
type GetLoginResponseCapn_List struct{ capnp.List }

// NewGetLoginResponseCapn creates a new list of GetLoginResponseCapn.
func NewGetLoginResponseCapn_List(s *capnp.Segment, sz int32) (GetLoginResponseCapn_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
	return GetLoginResponseCapn_List{l}, err
}

func (s GetLoginResponseCapn_List) At(i int) GetLoginResponseCapn {
	return GetLoginResponseCapn{s.List.Struct(i)}
}

func (s GetLoginResponseCapn_List) Set(i int, v GetLoginResponseCapn) error {
	return s.List.SetStruct(i, v.Struct)
}

func (s GetLoginResponseCapn_List) String() string {
	str, _ := text.MarshalList(0x9aa6454a3699f75b, s.List)
	return str
}

// GetLoginResponseCapn_Promise is a wrapper for a GetLoginResponseCapn promised by a client call.
type GetLoginResponseCapn_Promise struct{ *capnp.Pipeline }

func (p GetLoginResponseCapn_Promise) Struct() (GetLoginResponseCapn, error) {
	s, err := p.Pipeline.Struct()
	return GetLoginResponseCapn{s}, err
}

type PostLoginResponseCapn struct{ capnp.Struct }

// PostLoginResponseCapn_TypeID is the unique identifier for the type PostLoginResponseCapn.
const PostLoginResponseCapn_TypeID = 0xc853484cccd8383e

func NewPostLoginResponseCapn(s *capnp.Segment) (PostLoginResponseCapn, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 4})
	return PostLoginResponseCapn{st}, err
}

func NewRootPostLoginResponseCapn(s *capnp.Segment) (PostLoginResponseCapn, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 4})
	return PostLoginResponseCapn{st}, err
}

func ReadRootPostLoginResponseCapn(msg *capnp.Message) (PostLoginResponseCapn, error) {
	root, err := msg.RootPtr()
	return PostLoginResponseCapn{root.Struct()}, err
}

func (s PostLoginResponseCapn) String() string {
	str, _ := text.Marshal(0xc853484cccd8383e, s.Struct)
	return str
}

func (s PostLoginResponseCapn) UserID() (string, error) {
	p, err := s.Struct.Ptr(0)
	return p.Text(), err
}

func (s PostLoginResponseCapn) HasUserID() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s PostLoginResponseCapn) UserIDBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(0)
	return p.TextBytes(), err
}

func (s PostLoginResponseCapn) SetUserID(v string) error {
	return s.Struct.SetText(0, v)
}

func (s PostLoginResponseCapn) AccessToken() (string, error) {
	p, err := s.Struct.Ptr(1)
	return p.Text(), err
}

func (s PostLoginResponseCapn) HasAccessToken() bool {
	p, err := s.Struct.Ptr(1)
	return p.IsValid() || err != nil
}

func (s PostLoginResponseCapn) AccessTokenBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(1)
	return p.TextBytes(), err
}

func (s PostLoginResponseCapn) SetAccessToken(v string) error {
	return s.Struct.SetText(1, v)
}

func (s PostLoginResponseCapn) HomeServer() (string, error) {
	p, err := s.Struct.Ptr(2)
	return p.Text(), err
}

func (s PostLoginResponseCapn) HasHomeServer() bool {
	p, err := s.Struct.Ptr(2)
	return p.IsValid() || err != nil
}

func (s PostLoginResponseCapn) HomeServerBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(2)
	return p.TextBytes(), err
}

func (s PostLoginResponseCapn) SetHomeServer(v string) error {
	return s.Struct.SetText(2, v)
}

func (s PostLoginResponseCapn) DeviceID() (string, error) {
	p, err := s.Struct.Ptr(3)
	return p.Text(), err
}

func (s PostLoginResponseCapn) HasDeviceID() bool {
	p, err := s.Struct.Ptr(3)
	return p.IsValid() || err != nil
}

func (s PostLoginResponseCapn) DeviceIDBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(3)
	return p.TextBytes(), err
}

func (s PostLoginResponseCapn) SetDeviceID(v string) error {
	return s.Struct.SetText(3, v)
}

// PostLoginResponseCapn_List is a list of PostLoginResponseCapn.
type PostLoginResponseCapn_List struct{ capnp.List }

// NewPostLoginResponseCapn creates a new list of PostLoginResponseCapn.
func NewPostLoginResponseCapn_List(s *capnp.Segment, sz int32) (PostLoginResponseCapn_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 4}, sz)
	return PostLoginResponseCapn_List{l}, err
}

func (s PostLoginResponseCapn_List) At(i int) PostLoginResponseCapn {
	return PostLoginResponseCapn{s.List.Struct(i)}
}

func (s PostLoginResponseCapn_List) Set(i int, v PostLoginResponseCapn) error {
	return s.List.SetStruct(i, v.Struct)
}

func (s PostLoginResponseCapn_List) String() string {
	str, _ := text.MarshalList(0xc853484cccd8383e, s.List)
	return str
}

// PostLoginResponseCapn_Promise is a wrapper for a PostLoginResponseCapn promised by a client call.
type PostLoginResponseCapn_Promise struct{ *capnp.Pipeline }

func (p PostLoginResponseCapn_Promise) Struct() (PostLoginResponseCapn, error) {
	s, err := p.Pipeline.Struct()
	return PostLoginResponseCapn{s}, err
}

type UserIdentifierCapn struct{ capnp.Struct }

// UserIdentifierCapn_TypeID is the unique identifier for the type UserIdentifierCapn.
const UserIdentifierCapn_TypeID = 0xa7908122e94773cc

func NewUserIdentifierCapn(s *capnp.Segment) (UserIdentifierCapn, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return UserIdentifierCapn{st}, err
}

func NewRootUserIdentifierCapn(s *capnp.Segment) (UserIdentifierCapn, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return UserIdentifierCapn{st}, err
}

func ReadRootUserIdentifierCapn(msg *capnp.Message) (UserIdentifierCapn, error) {
	root, err := msg.RootPtr()
	return UserIdentifierCapn{root.Struct()}, err
}

func (s UserIdentifierCapn) String() string {
	str, _ := text.Marshal(0xa7908122e94773cc, s.Struct)
	return str
}

func (s UserIdentifierCapn) UserType() (string, error) {
	p, err := s.Struct.Ptr(0)
	return p.Text(), err
}

func (s UserIdentifierCapn) HasUserType() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s UserIdentifierCapn) UserTypeBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(0)
	return p.TextBytes(), err
}

func (s UserIdentifierCapn) SetUserType(v string) error {
	return s.Struct.SetText(0, v)
}

// UserIdentifierCapn_List is a list of UserIdentifierCapn.
type UserIdentifierCapn_List struct{ capnp.List }

// NewUserIdentifierCapn creates a new list of UserIdentifierCapn.
func NewUserIdentifierCapn_List(s *capnp.Segment, sz int32) (UserIdentifierCapn_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
	return UserIdentifierCapn_List{l}, err
}

func (s UserIdentifierCapn_List) At(i int) UserIdentifierCapn {
	return UserIdentifierCapn{s.List.Struct(i)}
}

func (s UserIdentifierCapn_List) Set(i int, v UserIdentifierCapn) error {
	return s.List.SetStruct(i, v.Struct)
}

func (s UserIdentifierCapn_List) String() string {
	str, _ := text.MarshalList(0xa7908122e94773cc, s.List)
	return str
}

// UserIdentifierCapn_Promise is a wrapper for a UserIdentifierCapn promised by a client call.
type UserIdentifierCapn_Promise struct{ *capnp.Pipeline }

func (p UserIdentifierCapn_Promise) Struct() (UserIdentifierCapn, error) {
	s, err := p.Pipeline.Struct()
	return UserIdentifierCapn{s}, err
}

const schema_d2a718af8a61f4a1 = "x\xdal\x91Ok\x13Q\x14\xc5\xefy/1\xc5\xa6" +
	"\xdaa\xb2\xa8\x0b\xe9$t\xe1\x1f\x94\xaaP4\xa0i" +
	"\x9b\xc4\x9a\xd2E^SA\xd4\xcd\x98\xbc\xb6\x83\xc9\xcc" +
	"t\xde\xa41\xab\xea\xd6\x95[\xdd\xe9\xc2,]\xfa\x15" +
	"\x0ct\xe5\xca\x95\xd0\x95t!\x88\x08R7#/\xd4" +
	"1)a6\xf3\x0e?\xce=\xf7\xdc\xf9\xfe\xc4\"\xbb" +
	"\x96\xec-\x12\xd5~\xb0\xe4\xa9\xe8\xd1\xef\xd7\x0b\xab\xe5" +
	"\xf7o\xc8\x98D\xf4\xf6\x97\xfd\xf2\xc3L\xef3%\x91" +
	"\"\xbaq\xcbb0\xcbV\x8a\xc8\\\xb2\x0a\x84(}" +
	"\xb0\xf7\xa0\xb8\xf0\xf1$\xcc4\xb1c\xbd3\xbb\x03\xb6" +
	"mu\x08\xd1\xbeZ9\xcc\xbdx\xd5\x1bcl\x1eX" +
	"?\xcd\xef\x03\xf6p\xe0{\xe7\xe6\x97\xfd\xb5{\xb5O" +
	"'\xd8\x84\x0e1\x95=\x0d\xf3|V\xc3\xe7\xb2\xdf\x08" +
	"Q\xbf\xdc\xbf\xbc~{\xf9\x88\xc4$\x86h\x0d\x9bG" +
	"\xd9?f2\xa7\xff\x90+P4\xf2}\x8d\x9a\xde\x96" +
	"\xe3^\xad\xdb\xdcw\xf3+2\\\xd3\xcfu\xa9|\xcf" +
	"U\xb2h\xfb.U\x01\x91\xe0\x09\xa2\x04\x88\x8c\xa9\xeb" +
	"Db\x82C\xcc1\xccn6\xbd\x8e\xc2\x19B\x95\x03" +
	"\xd3\xff\x9b h1\xb6\x86\xef\xe6\xef6\xbdN1e" +
	"\xfb\xae\xb6\x9b\x88\xed.^\"\x12s\x1cb\x9e\xc1\x00" +
	"2\xd0\xe2\x95<\x91\xb8\xc0!J\x0cg\xc3\xae/\x91" +
	"&\x864\xa1\xa0B{K\xc6\x13\xb5:<\x87\xf9n" +
	"\xfe\xbe\x92A\xa5!\xdd\xd0\xd9t\xe4lP<\x9e8" +
	"\xb4\xc0*\x91Hs\x88\x19\x86\xa8\xadd\xb0\xd1\xf5%" +
	"\x11\xfd\x9b1RH\xd5Sc\x1a\x19T2\x1d;\xda" +
	":\xeec\x0e\xb1=\xb4\x83|B$\x1a\x1c\xc2g0" +
	"\x18\xcb\x80\x11\x19\xad\x87D\xa2\xc9!\x9e1\x18\x9cg" +
	"\xc0\x89\x8c\xb6\x0e\x14r\x88\xe7\x0c\x05\x1d\xa8R\x8a\xb3" +
	"\xd8\xf5\xbaTj\xc3\xa3\xd4S\xe9\xc6\xea\xb6\xd7\x925" +
	"\x19\xec\x12\x97A,6\xe4\xaeS\x97\x95\xd2\xb8U\xd8" +
	"\xc8mw\xda\xb2\xa0\xc21\xcd,\x1f\x9f6\xc3\xb0\xe7" +
	"\xa8\xa5F\xcbq\x01b\x00\xe1o\x00\x00\x00\xff\xff/" +
	"\xa6\xc5\xfa"

func init() {
	schemas.Register(schema_d2a718af8a61f4a1,
		0x9aa6454a3699f75b,
		0x9ab73643587fe10c,
		0xa7908122e94773cc,
		0xc853484cccd8383e,
		0xf9423d522bc945c9)
}