sonr/api/did/v1/state.cosmos_orm.go

// Code generated by protoc-gen-go-cosmos-orm. DO NOT EDIT.

package didv1

import (
	context "context"
	ormlist "cosmossdk.io/orm/model/ormlist"
	ormtable "cosmossdk.io/orm/model/ormtable"
	ormerrors "cosmossdk.io/orm/types/ormerrors"
)

type AuthenticationTable interface {
	Insert(ctx context.Context, authentication *Authentication) error
	Update(ctx context.Context, authentication *Authentication) error
	Save(ctx context.Context, authentication *Authentication) error
	Delete(ctx context.Context, authentication *Authentication) error
	Has(ctx context.Context, id string) (found bool, err error)
	// Get returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	Get(ctx context.Context, id string) (*Authentication, error)
	HasBySubjectOrigin(ctx context.Context, subject string, origin string) (found bool, err error)
	// GetBySubjectOrigin returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	GetBySubjectOrigin(ctx context.Context, subject string, origin string) (*Authentication, error)
	HasByControllerOrigin(ctx context.Context, controller string, origin string) (found bool, err error)
	// GetByControllerOrigin returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	GetByControllerOrigin(ctx context.Context, controller string, origin string) (*Authentication, error)
	HasByControllerCredentialLabel(ctx context.Context, controller string, credential_label string) (found bool, err error)
	// GetByControllerCredentialLabel returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	GetByControllerCredentialLabel(ctx context.Context, controller string, credential_label string) (*Authentication, error)
	List(ctx context.Context, prefixKey AuthenticationIndexKey, opts ...ormlist.Option) (AuthenticationIterator, error)
	ListRange(ctx context.Context, from, to AuthenticationIndexKey, opts ...ormlist.Option) (AuthenticationIterator, error)
	DeleteBy(ctx context.Context, prefixKey AuthenticationIndexKey) error
	DeleteRange(ctx context.Context, from, to AuthenticationIndexKey) error

	doNotImplement()
}

type AuthenticationIterator struct {
	ormtable.Iterator
}

func (i AuthenticationIterator) Value() (*Authentication, error) {
	var authentication Authentication
	err := i.UnmarshalMessage(&authentication)
	return &authentication, err
}

type AuthenticationIndexKey interface {
	id() uint32
	values() []interface{}
	authenticationIndexKey()
}

// primary key starting index..
type AuthenticationPrimaryKey = AuthenticationIdIndexKey

type AuthenticationIdIndexKey struct {
	vs []interface{}
}

func (x AuthenticationIdIndexKey) id() uint32              { return 0 }
func (x AuthenticationIdIndexKey) values() []interface{}   { return x.vs }
func (x AuthenticationIdIndexKey) authenticationIndexKey() {}

func (this AuthenticationIdIndexKey) WithId(id string) AuthenticationIdIndexKey {
	this.vs = []interface{}{id}
	return this
}

type AuthenticationSubjectOriginIndexKey struct {
	vs []interface{}
}

func (x AuthenticationSubjectOriginIndexKey) id() uint32              { return 1 }
func (x AuthenticationSubjectOriginIndexKey) values() []interface{}   { return x.vs }
func (x AuthenticationSubjectOriginIndexKey) authenticationIndexKey() {}

func (this AuthenticationSubjectOriginIndexKey) WithSubject(subject string) AuthenticationSubjectOriginIndexKey {
	this.vs = []interface{}{subject}
	return this
}

func (this AuthenticationSubjectOriginIndexKey) WithSubjectOrigin(subject string, origin string) AuthenticationSubjectOriginIndexKey {
	this.vs = []interface{}{subject, origin}
	return this
}

type AuthenticationControllerOriginIndexKey struct {
	vs []interface{}
}

func (x AuthenticationControllerOriginIndexKey) id() uint32              { return 2 }
func (x AuthenticationControllerOriginIndexKey) values() []interface{}   { return x.vs }
func (x AuthenticationControllerOriginIndexKey) authenticationIndexKey() {}

func (this AuthenticationControllerOriginIndexKey) WithController(controller string) AuthenticationControllerOriginIndexKey {
	this.vs = []interface{}{controller}
	return this
}

func (this AuthenticationControllerOriginIndexKey) WithControllerOrigin(controller string, origin string) AuthenticationControllerOriginIndexKey {
	this.vs = []interface{}{controller, origin}
	return this
}

type AuthenticationControllerCredentialLabelIndexKey struct {
	vs []interface{}
}

func (x AuthenticationControllerCredentialLabelIndexKey) id() uint32              { return 3 }
func (x AuthenticationControllerCredentialLabelIndexKey) values() []interface{}   { return x.vs }
func (x AuthenticationControllerCredentialLabelIndexKey) authenticationIndexKey() {}

func (this AuthenticationControllerCredentialLabelIndexKey) WithController(controller string) AuthenticationControllerCredentialLabelIndexKey {
	this.vs = []interface{}{controller}
	return this
}

func (this AuthenticationControllerCredentialLabelIndexKey) WithControllerCredentialLabel(controller string, credential_label string) AuthenticationControllerCredentialLabelIndexKey {
	this.vs = []interface{}{controller, credential_label}
	return this
}

type authenticationTable struct {
	table ormtable.Table
}

func (this authenticationTable) Insert(ctx context.Context, authentication *Authentication) error {
	return this.table.Insert(ctx, authentication)
}

func (this authenticationTable) Update(ctx context.Context, authentication *Authentication) error {
	return this.table.Update(ctx, authentication)
}

func (this authenticationTable) Save(ctx context.Context, authentication *Authentication) error {
	return this.table.Save(ctx, authentication)
}

func (this authenticationTable) Delete(ctx context.Context, authentication *Authentication) error {
	return this.table.Delete(ctx, authentication)
}

func (this authenticationTable) Has(ctx context.Context, id string) (found bool, err error) {
	return this.table.PrimaryKey().Has(ctx, id)
}

func (this authenticationTable) Get(ctx context.Context, id string) (*Authentication, error) {
	var authentication Authentication
	found, err := this.table.PrimaryKey().Get(ctx, &authentication, id)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &authentication, nil
}

func (this authenticationTable) HasBySubjectOrigin(ctx context.Context, subject string, origin string) (found bool, err error) {
	return this.table.GetIndexByID(1).(ormtable.UniqueIndex).Has(ctx,
		subject,
		origin,
	)
}

func (this authenticationTable) GetBySubjectOrigin(ctx context.Context, subject string, origin string) (*Authentication, error) {
	var authentication Authentication
	found, err := this.table.GetIndexByID(1).(ormtable.UniqueIndex).Get(ctx, &authentication,
		subject,
		origin,
	)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &authentication, nil
}

func (this authenticationTable) HasByControllerOrigin(ctx context.Context, controller string, origin string) (found bool, err error) {
	return this.table.GetIndexByID(2).(ormtable.UniqueIndex).Has(ctx,
		controller,
		origin,
	)
}

func (this authenticationTable) GetByControllerOrigin(ctx context.Context, controller string, origin string) (*Authentication, error) {
	var authentication Authentication
	found, err := this.table.GetIndexByID(2).(ormtable.UniqueIndex).Get(ctx, &authentication,
		controller,
		origin,
	)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &authentication, nil
}

func (this authenticationTable) HasByControllerCredentialLabel(ctx context.Context, controller string, credential_label string) (found bool, err error) {
	return this.table.GetIndexByID(3).(ormtable.UniqueIndex).Has(ctx,
		controller,
		credential_label,
	)
}

func (this authenticationTable) GetByControllerCredentialLabel(ctx context.Context, controller string, credential_label string) (*Authentication, error) {
	var authentication Authentication
	found, err := this.table.GetIndexByID(3).(ormtable.UniqueIndex).Get(ctx, &authentication,
		controller,
		credential_label,
	)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &authentication, nil
}

func (this authenticationTable) List(ctx context.Context, prefixKey AuthenticationIndexKey, opts ...ormlist.Option) (AuthenticationIterator, error) {
	it, err := this.table.GetIndexByID(prefixKey.id()).List(ctx, prefixKey.values(), opts...)
	return AuthenticationIterator{it}, err
}

func (this authenticationTable) ListRange(ctx context.Context, from, to AuthenticationIndexKey, opts ...ormlist.Option) (AuthenticationIterator, error) {
	it, err := this.table.GetIndexByID(from.id()).ListRange(ctx, from.values(), to.values(), opts...)
	return AuthenticationIterator{it}, err
}

func (this authenticationTable) DeleteBy(ctx context.Context, prefixKey AuthenticationIndexKey) error {
	return this.table.GetIndexByID(prefixKey.id()).DeleteBy(ctx, prefixKey.values()...)
}

func (this authenticationTable) DeleteRange(ctx context.Context, from, to AuthenticationIndexKey) error {
	return this.table.GetIndexByID(from.id()).DeleteRange(ctx, from.values(), to.values())
}

func (this authenticationTable) doNotImplement() {}

var _ AuthenticationTable = authenticationTable{}

func NewAuthenticationTable(db ormtable.Schema) (AuthenticationTable, error) {
	table := db.GetTable(&Authentication{})
	if table == nil {
		return nil, ormerrors.TableNotFound.Wrap(string((&Authentication{}).ProtoReflect().Descriptor().FullName()))
	}
	return authenticationTable{table}, nil
}

type AssertionTable interface {
	Insert(ctx context.Context, assertion *Assertion) error
	Update(ctx context.Context, assertion *Assertion) error
	Save(ctx context.Context, assertion *Assertion) error
	Delete(ctx context.Context, assertion *Assertion) error
	Has(ctx context.Context, id string) (found bool, err error)
	// Get returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	Get(ctx context.Context, id string) (*Assertion, error)
	HasBySubjectOrigin(ctx context.Context, subject string, origin string) (found bool, err error)
	// GetBySubjectOrigin returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	GetBySubjectOrigin(ctx context.Context, subject string, origin string) (*Assertion, error)
	HasByControllerOrigin(ctx context.Context, controller string, origin string) (found bool, err error)
	// GetByControllerOrigin returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	GetByControllerOrigin(ctx context.Context, controller string, origin string) (*Assertion, error)
	List(ctx context.Context, prefixKey AssertionIndexKey, opts ...ormlist.Option) (AssertionIterator, error)
	ListRange(ctx context.Context, from, to AssertionIndexKey, opts ...ormlist.Option) (AssertionIterator, error)
	DeleteBy(ctx context.Context, prefixKey AssertionIndexKey) error
	DeleteRange(ctx context.Context, from, to AssertionIndexKey) error

	doNotImplement()
}

type AssertionIterator struct {
	ormtable.Iterator
}

func (i AssertionIterator) Value() (*Assertion, error) {
	var assertion Assertion
	err := i.UnmarshalMessage(&assertion)
	return &assertion, err
}

type AssertionIndexKey interface {
	id() uint32
	values() []interface{}
	assertionIndexKey()
}

// primary key starting index..
type AssertionPrimaryKey = AssertionIdIndexKey

type AssertionIdIndexKey struct {
	vs []interface{}
}

func (x AssertionIdIndexKey) id() uint32            { return 0 }
func (x AssertionIdIndexKey) values() []interface{} { return x.vs }
func (x AssertionIdIndexKey) assertionIndexKey()    {}

func (this AssertionIdIndexKey) WithId(id string) AssertionIdIndexKey {
	this.vs = []interface{}{id}
	return this
}

type AssertionSubjectOriginIndexKey struct {
	vs []interface{}
}

func (x AssertionSubjectOriginIndexKey) id() uint32            { return 1 }
func (x AssertionSubjectOriginIndexKey) values() []interface{} { return x.vs }
func (x AssertionSubjectOriginIndexKey) assertionIndexKey()    {}

func (this AssertionSubjectOriginIndexKey) WithSubject(subject string) AssertionSubjectOriginIndexKey {
	this.vs = []interface{}{subject}
	return this
}

func (this AssertionSubjectOriginIndexKey) WithSubjectOrigin(subject string, origin string) AssertionSubjectOriginIndexKey {
	this.vs = []interface{}{subject, origin}
	return this
}

type AssertionControllerOriginIndexKey struct {
	vs []interface{}
}

func (x AssertionControllerOriginIndexKey) id() uint32            { return 2 }
func (x AssertionControllerOriginIndexKey) values() []interface{} { return x.vs }
func (x AssertionControllerOriginIndexKey) assertionIndexKey()    {}

func (this AssertionControllerOriginIndexKey) WithController(controller string) AssertionControllerOriginIndexKey {
	this.vs = []interface{}{controller}
	return this
}

func (this AssertionControllerOriginIndexKey) WithControllerOrigin(controller string, origin string) AssertionControllerOriginIndexKey {
	this.vs = []interface{}{controller, origin}
	return this
}

type assertionTable struct {
	table ormtable.Table
}

func (this assertionTable) Insert(ctx context.Context, assertion *Assertion) error {
	return this.table.Insert(ctx, assertion)
}

func (this assertionTable) Update(ctx context.Context, assertion *Assertion) error {
	return this.table.Update(ctx, assertion)
}

func (this assertionTable) Save(ctx context.Context, assertion *Assertion) error {
	return this.table.Save(ctx, assertion)
}

func (this assertionTable) Delete(ctx context.Context, assertion *Assertion) error {
	return this.table.Delete(ctx, assertion)
}

func (this assertionTable) Has(ctx context.Context, id string) (found bool, err error) {
	return this.table.PrimaryKey().Has(ctx, id)
}

func (this assertionTable) Get(ctx context.Context, id string) (*Assertion, error) {
	var assertion Assertion
	found, err := this.table.PrimaryKey().Get(ctx, &assertion, id)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &assertion, nil
}

func (this assertionTable) HasBySubjectOrigin(ctx context.Context, subject string, origin string) (found bool, err error) {
	return this.table.GetIndexByID(1).(ormtable.UniqueIndex).Has(ctx,
		subject,
		origin,
	)
}

func (this assertionTable) GetBySubjectOrigin(ctx context.Context, subject string, origin string) (*Assertion, error) {
	var assertion Assertion
	found, err := this.table.GetIndexByID(1).(ormtable.UniqueIndex).Get(ctx, &assertion,
		subject,
		origin,
	)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &assertion, nil
}

func (this assertionTable) HasByControllerOrigin(ctx context.Context, controller string, origin string) (found bool, err error) {
	return this.table.GetIndexByID(2).(ormtable.UniqueIndex).Has(ctx,
		controller,
		origin,
	)
}

func (this assertionTable) GetByControllerOrigin(ctx context.Context, controller string, origin string) (*Assertion, error) {
	var assertion Assertion
	found, err := this.table.GetIndexByID(2).(ormtable.UniqueIndex).Get(ctx, &assertion,
		controller,
		origin,
	)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &assertion, nil
}

func (this assertionTable) List(ctx context.Context, prefixKey AssertionIndexKey, opts ...ormlist.Option) (AssertionIterator, error) {
	it, err := this.table.GetIndexByID(prefixKey.id()).List(ctx, prefixKey.values(), opts...)
	return AssertionIterator{it}, err
}

func (this assertionTable) ListRange(ctx context.Context, from, to AssertionIndexKey, opts ...ormlist.Option) (AssertionIterator, error) {
	it, err := this.table.GetIndexByID(from.id()).ListRange(ctx, from.values(), to.values(), opts...)
	return AssertionIterator{it}, err
}

func (this assertionTable) DeleteBy(ctx context.Context, prefixKey AssertionIndexKey) error {
	return this.table.GetIndexByID(prefixKey.id()).DeleteBy(ctx, prefixKey.values()...)
}

func (this assertionTable) DeleteRange(ctx context.Context, from, to AssertionIndexKey) error {
	return this.table.GetIndexByID(from.id()).DeleteRange(ctx, from.values(), to.values())
}

func (this assertionTable) doNotImplement() {}

var _ AssertionTable = assertionTable{}

func NewAssertionTable(db ormtable.Schema) (AssertionTable, error) {
	table := db.GetTable(&Assertion{})
	if table == nil {
		return nil, ormerrors.TableNotFound.Wrap(string((&Assertion{}).ProtoReflect().Descriptor().FullName()))
	}
	return assertionTable{table}, nil
}

type ControllerTable interface {
	Insert(ctx context.Context, controller *Controller) error
	Update(ctx context.Context, controller *Controller) error
	Save(ctx context.Context, controller *Controller) error
	Delete(ctx context.Context, controller *Controller) error
	Has(ctx context.Context, id string) (found bool, err error)
	// Get returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	Get(ctx context.Context, id string) (*Controller, error)
	HasByAddress(ctx context.Context, address string) (found bool, err error)
	// GetByAddress returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	GetByAddress(ctx context.Context, address string) (*Controller, error)
	HasByVaultCid(ctx context.Context, vault_cid string) (found bool, err error)
	// GetByVaultCid returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	GetByVaultCid(ctx context.Context, vault_cid string) (*Controller, error)
	List(ctx context.Context, prefixKey ControllerIndexKey, opts ...ormlist.Option) (ControllerIterator, error)
	ListRange(ctx context.Context, from, to ControllerIndexKey, opts ...ormlist.Option) (ControllerIterator, error)
	DeleteBy(ctx context.Context, prefixKey ControllerIndexKey) error
	DeleteRange(ctx context.Context, from, to ControllerIndexKey) error

	doNotImplement()
}

type ControllerIterator struct {
	ormtable.Iterator
}

func (i ControllerIterator) Value() (*Controller, error) {
	var controller Controller
	err := i.UnmarshalMessage(&controller)
	return &controller, err
}

type ControllerIndexKey interface {
	id() uint32
	values() []interface{}
	controllerIndexKey()
}

// primary key starting index..
type ControllerPrimaryKey = ControllerIdIndexKey

type ControllerIdIndexKey struct {
	vs []interface{}
}

func (x ControllerIdIndexKey) id() uint32            { return 0 }
func (x ControllerIdIndexKey) values() []interface{} { return x.vs }
func (x ControllerIdIndexKey) controllerIndexKey()   {}

func (this ControllerIdIndexKey) WithId(id string) ControllerIdIndexKey {
	this.vs = []interface{}{id}
	return this
}

type ControllerAddressIndexKey struct {
	vs []interface{}
}

func (x ControllerAddressIndexKey) id() uint32            { return 1 }
func (x ControllerAddressIndexKey) values() []interface{} { return x.vs }
func (x ControllerAddressIndexKey) controllerIndexKey()   {}

func (this ControllerAddressIndexKey) WithAddress(address string) ControllerAddressIndexKey {
	this.vs = []interface{}{address}
	return this
}

type ControllerVaultCidIndexKey struct {
	vs []interface{}
}

func (x ControllerVaultCidIndexKey) id() uint32            { return 2 }
func (x ControllerVaultCidIndexKey) values() []interface{} { return x.vs }
func (x ControllerVaultCidIndexKey) controllerIndexKey()   {}

func (this ControllerVaultCidIndexKey) WithVaultCid(vault_cid string) ControllerVaultCidIndexKey {
	this.vs = []interface{}{vault_cid}
	return this
}

type controllerTable struct {
	table ormtable.Table
}

func (this controllerTable) Insert(ctx context.Context, controller *Controller) error {
	return this.table.Insert(ctx, controller)
}

func (this controllerTable) Update(ctx context.Context, controller *Controller) error {
	return this.table.Update(ctx, controller)
}

func (this controllerTable) Save(ctx context.Context, controller *Controller) error {
	return this.table.Save(ctx, controller)
}

func (this controllerTable) Delete(ctx context.Context, controller *Controller) error {
	return this.table.Delete(ctx, controller)
}

func (this controllerTable) Has(ctx context.Context, id string) (found bool, err error) {
	return this.table.PrimaryKey().Has(ctx, id)
}

func (this controllerTable) Get(ctx context.Context, id string) (*Controller, error) {
	var controller Controller
	found, err := this.table.PrimaryKey().Get(ctx, &controller, id)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &controller, nil
}

func (this controllerTable) HasByAddress(ctx context.Context, address string) (found bool, err error) {
	return this.table.GetIndexByID(1).(ormtable.UniqueIndex).Has(ctx,
		address,
	)
}

func (this controllerTable) GetByAddress(ctx context.Context, address string) (*Controller, error) {
	var controller Controller
	found, err := this.table.GetIndexByID(1).(ormtable.UniqueIndex).Get(ctx, &controller,
		address,
	)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &controller, nil
}

func (this controllerTable) HasByVaultCid(ctx context.Context, vault_cid string) (found bool, err error) {
	return this.table.GetIndexByID(2).(ormtable.UniqueIndex).Has(ctx,
		vault_cid,
	)
}

func (this controllerTable) GetByVaultCid(ctx context.Context, vault_cid string) (*Controller, error) {
	var controller Controller
	found, err := this.table.GetIndexByID(2).(ormtable.UniqueIndex).Get(ctx, &controller,
		vault_cid,
	)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &controller, nil
}

func (this controllerTable) List(ctx context.Context, prefixKey ControllerIndexKey, opts ...ormlist.Option) (ControllerIterator, error) {
	it, err := this.table.GetIndexByID(prefixKey.id()).List(ctx, prefixKey.values(), opts...)
	return ControllerIterator{it}, err
}

func (this controllerTable) ListRange(ctx context.Context, from, to ControllerIndexKey, opts ...ormlist.Option) (ControllerIterator, error) {
	it, err := this.table.GetIndexByID(from.id()).ListRange(ctx, from.values(), to.values(), opts...)
	return ControllerIterator{it}, err
}

func (this controllerTable) DeleteBy(ctx context.Context, prefixKey ControllerIndexKey) error {
	return this.table.GetIndexByID(prefixKey.id()).DeleteBy(ctx, prefixKey.values()...)
}

func (this controllerTable) DeleteRange(ctx context.Context, from, to ControllerIndexKey) error {
	return this.table.GetIndexByID(from.id()).DeleteRange(ctx, from.values(), to.values())
}

func (this controllerTable) doNotImplement() {}

var _ ControllerTable = controllerTable{}

func NewControllerTable(db ormtable.Schema) (ControllerTable, error) {
	table := db.GetTable(&Controller{})
	if table == nil {
		return nil, ormerrors.TableNotFound.Wrap(string((&Controller{}).ProtoReflect().Descriptor().FullName()))
	}
	return controllerTable{table}, nil
}

type DelegationTable interface {
	Insert(ctx context.Context, delegation *Delegation) error
	Update(ctx context.Context, delegation *Delegation) error
	Save(ctx context.Context, delegation *Delegation) error
	Delete(ctx context.Context, delegation *Delegation) error
	Has(ctx context.Context, id string) (found bool, err error)
	// Get returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	Get(ctx context.Context, id string) (*Delegation, error)
	HasByAccountAddressChainId(ctx context.Context, account_address string, chain_id string) (found bool, err error)
	// GetByAccountAddressChainId returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	GetByAccountAddressChainId(ctx context.Context, account_address string, chain_id string) (*Delegation, error)
	HasByControllerAccountLabel(ctx context.Context, controller string, account_label string) (found bool, err error)
	// GetByControllerAccountLabel returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	GetByControllerAccountLabel(ctx context.Context, controller string, account_label string) (*Delegation, error)
	List(ctx context.Context, prefixKey DelegationIndexKey, opts ...ormlist.Option) (DelegationIterator, error)
	ListRange(ctx context.Context, from, to DelegationIndexKey, opts ...ormlist.Option) (DelegationIterator, error)
	DeleteBy(ctx context.Context, prefixKey DelegationIndexKey) error
	DeleteRange(ctx context.Context, from, to DelegationIndexKey) error

	doNotImplement()
}

type DelegationIterator struct {
	ormtable.Iterator
}

func (i DelegationIterator) Value() (*Delegation, error) {
	var delegation Delegation
	err := i.UnmarshalMessage(&delegation)
	return &delegation, err
}

type DelegationIndexKey interface {
	id() uint32
	values() []interface{}
	delegationIndexKey()
}

// primary key starting index..
type DelegationPrimaryKey = DelegationIdIndexKey

type DelegationIdIndexKey struct {
	vs []interface{}
}

func (x DelegationIdIndexKey) id() uint32            { return 0 }
func (x DelegationIdIndexKey) values() []interface{} { return x.vs }
func (x DelegationIdIndexKey) delegationIndexKey()   {}

func (this DelegationIdIndexKey) WithId(id string) DelegationIdIndexKey {
	this.vs = []interface{}{id}
	return this
}

type DelegationAccountAddressChainIdIndexKey struct {
	vs []interface{}
}

func (x DelegationAccountAddressChainIdIndexKey) id() uint32            { return 1 }
func (x DelegationAccountAddressChainIdIndexKey) values() []interface{} { return x.vs }
func (x DelegationAccountAddressChainIdIndexKey) delegationIndexKey()   {}

func (this DelegationAccountAddressChainIdIndexKey) WithAccountAddress(account_address string) DelegationAccountAddressChainIdIndexKey {
	this.vs = []interface{}{account_address}
	return this
}

func (this DelegationAccountAddressChainIdIndexKey) WithAccountAddressChainId(account_address string, chain_id string) DelegationAccountAddressChainIdIndexKey {
	this.vs = []interface{}{account_address, chain_id}
	return this
}

type DelegationControllerAccountLabelIndexKey struct {
	vs []interface{}
}

func (x DelegationControllerAccountLabelIndexKey) id() uint32            { return 2 }
func (x DelegationControllerAccountLabelIndexKey) values() []interface{} { return x.vs }
func (x DelegationControllerAccountLabelIndexKey) delegationIndexKey()   {}

func (this DelegationControllerAccountLabelIndexKey) WithController(controller string) DelegationControllerAccountLabelIndexKey {
	this.vs = []interface{}{controller}
	return this
}

func (this DelegationControllerAccountLabelIndexKey) WithControllerAccountLabel(controller string, account_label string) DelegationControllerAccountLabelIndexKey {
	this.vs = []interface{}{controller, account_label}
	return this
}

type DelegationControllerChainIdIndexKey struct {
	vs []interface{}
}

func (x DelegationControllerChainIdIndexKey) id() uint32            { return 3 }
func (x DelegationControllerChainIdIndexKey) values() []interface{} { return x.vs }
func (x DelegationControllerChainIdIndexKey) delegationIndexKey()   {}

func (this DelegationControllerChainIdIndexKey) WithController(controller string) DelegationControllerChainIdIndexKey {
	this.vs = []interface{}{controller}
	return this
}

func (this DelegationControllerChainIdIndexKey) WithControllerChainId(controller string, chain_id string) DelegationControllerChainIdIndexKey {
	this.vs = []interface{}{controller, chain_id}
	return this
}

type delegationTable struct {
	table ormtable.Table
}

func (this delegationTable) Insert(ctx context.Context, delegation *Delegation) error {
	return this.table.Insert(ctx, delegation)
}

func (this delegationTable) Update(ctx context.Context, delegation *Delegation) error {
	return this.table.Update(ctx, delegation)
}

func (this delegationTable) Save(ctx context.Context, delegation *Delegation) error {
	return this.table.Save(ctx, delegation)
}

func (this delegationTable) Delete(ctx context.Context, delegation *Delegation) error {
	return this.table.Delete(ctx, delegation)
}

func (this delegationTable) Has(ctx context.Context, id string) (found bool, err error) {
	return this.table.PrimaryKey().Has(ctx, id)
}

func (this delegationTable) Get(ctx context.Context, id string) (*Delegation, error) {
	var delegation Delegation
	found, err := this.table.PrimaryKey().Get(ctx, &delegation, id)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &delegation, nil
}

func (this delegationTable) HasByAccountAddressChainId(ctx context.Context, account_address string, chain_id string) (found bool, err error) {
	return this.table.GetIndexByID(1).(ormtable.UniqueIndex).Has(ctx,
		account_address,
		chain_id,
	)
}

func (this delegationTable) GetByAccountAddressChainId(ctx context.Context, account_address string, chain_id string) (*Delegation, error) {
	var delegation Delegation
	found, err := this.table.GetIndexByID(1).(ormtable.UniqueIndex).Get(ctx, &delegation,
		account_address,
		chain_id,
	)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &delegation, nil
}

func (this delegationTable) HasByControllerAccountLabel(ctx context.Context, controller string, account_label string) (found bool, err error) {
	return this.table.GetIndexByID(2).(ormtable.UniqueIndex).Has(ctx,
		controller,
		account_label,
	)
}

func (this delegationTable) GetByControllerAccountLabel(ctx context.Context, controller string, account_label string) (*Delegation, error) {
	var delegation Delegation
	found, err := this.table.GetIndexByID(2).(ormtable.UniqueIndex).Get(ctx, &delegation,
		controller,
		account_label,
	)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &delegation, nil
}

func (this delegationTable) List(ctx context.Context, prefixKey DelegationIndexKey, opts ...ormlist.Option) (DelegationIterator, error) {
	it, err := this.table.GetIndexByID(prefixKey.id()).List(ctx, prefixKey.values(), opts...)
	return DelegationIterator{it}, err
}

func (this delegationTable) ListRange(ctx context.Context, from, to DelegationIndexKey, opts ...ormlist.Option) (DelegationIterator, error) {
	it, err := this.table.GetIndexByID(from.id()).ListRange(ctx, from.values(), to.values(), opts...)
	return DelegationIterator{it}, err
}

func (this delegationTable) DeleteBy(ctx context.Context, prefixKey DelegationIndexKey) error {
	return this.table.GetIndexByID(prefixKey.id()).DeleteBy(ctx, prefixKey.values()...)
}

func (this delegationTable) DeleteRange(ctx context.Context, from, to DelegationIndexKey) error {
	return this.table.GetIndexByID(from.id()).DeleteRange(ctx, from.values(), to.values())
}

func (this delegationTable) doNotImplement() {}

var _ DelegationTable = delegationTable{}

func NewDelegationTable(db ormtable.Schema) (DelegationTable, error) {
	table := db.GetTable(&Delegation{})
	if table == nil {
		return nil, ormerrors.TableNotFound.Wrap(string((&Delegation{}).ProtoReflect().Descriptor().FullName()))
	}
	return delegationTable{table}, nil
}

type ServiceRecordTable interface {
	Insert(ctx context.Context, serviceRecord *ServiceRecord) error
	Update(ctx context.Context, serviceRecord *ServiceRecord) error
	Save(ctx context.Context, serviceRecord *ServiceRecord) error
	Delete(ctx context.Context, serviceRecord *ServiceRecord) error
	Has(ctx context.Context, id string) (found bool, err error)
	// Get returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	Get(ctx context.Context, id string) (*ServiceRecord, error)
	HasByOriginUri(ctx context.Context, origin_uri string) (found bool, err error)
	// GetByOriginUri returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	GetByOriginUri(ctx context.Context, origin_uri string) (*ServiceRecord, error)
	HasByControllerOriginUri(ctx context.Context, controller string, origin_uri string) (found bool, err error)
	// GetByControllerOriginUri returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	GetByControllerOriginUri(ctx context.Context, controller string, origin_uri string) (*ServiceRecord, error)
	List(ctx context.Context, prefixKey ServiceRecordIndexKey, opts ...ormlist.Option) (ServiceRecordIterator, error)
	ListRange(ctx context.Context, from, to ServiceRecordIndexKey, opts ...ormlist.Option) (ServiceRecordIterator, error)
	DeleteBy(ctx context.Context, prefixKey ServiceRecordIndexKey) error
	DeleteRange(ctx context.Context, from, to ServiceRecordIndexKey) error

	doNotImplement()
}

type ServiceRecordIterator struct {
	ormtable.Iterator
}

func (i ServiceRecordIterator) Value() (*ServiceRecord, error) {
	var serviceRecord ServiceRecord
	err := i.UnmarshalMessage(&serviceRecord)
	return &serviceRecord, err
}

type ServiceRecordIndexKey interface {
	id() uint32
	values() []interface{}
	serviceRecordIndexKey()
}

// primary key starting index..
type ServiceRecordPrimaryKey = ServiceRecordIdIndexKey

type ServiceRecordIdIndexKey struct {
	vs []interface{}
}

func (x ServiceRecordIdIndexKey) id() uint32             { return 0 }
func (x ServiceRecordIdIndexKey) values() []interface{}  { return x.vs }
func (x ServiceRecordIdIndexKey) serviceRecordIndexKey() {}

func (this ServiceRecordIdIndexKey) WithId(id string) ServiceRecordIdIndexKey {
	this.vs = []interface{}{id}
	return this
}

type ServiceRecordOriginUriIndexKey struct {
	vs []interface{}
}

func (x ServiceRecordOriginUriIndexKey) id() uint32             { return 1 }
func (x ServiceRecordOriginUriIndexKey) values() []interface{}  { return x.vs }
func (x ServiceRecordOriginUriIndexKey) serviceRecordIndexKey() {}

func (this ServiceRecordOriginUriIndexKey) WithOriginUri(origin_uri string) ServiceRecordOriginUriIndexKey {
	this.vs = []interface{}{origin_uri}
	return this
}

type ServiceRecordControllerOriginUriIndexKey struct {
	vs []interface{}
}

func (x ServiceRecordControllerOriginUriIndexKey) id() uint32             { return 2 }
func (x ServiceRecordControllerOriginUriIndexKey) values() []interface{}  { return x.vs }
func (x ServiceRecordControllerOriginUriIndexKey) serviceRecordIndexKey() {}

func (this ServiceRecordControllerOriginUriIndexKey) WithController(controller string) ServiceRecordControllerOriginUriIndexKey {
	this.vs = []interface{}{controller}
	return this
}

func (this ServiceRecordControllerOriginUriIndexKey) WithControllerOriginUri(controller string, origin_uri string) ServiceRecordControllerOriginUriIndexKey {
	this.vs = []interface{}{controller, origin_uri}
	return this
}

type serviceRecordTable struct {
	table ormtable.Table
}

func (this serviceRecordTable) Insert(ctx context.Context, serviceRecord *ServiceRecord) error {
	return this.table.Insert(ctx, serviceRecord)
}

func (this serviceRecordTable) Update(ctx context.Context, serviceRecord *ServiceRecord) error {
	return this.table.Update(ctx, serviceRecord)
}

func (this serviceRecordTable) Save(ctx context.Context, serviceRecord *ServiceRecord) error {
	return this.table.Save(ctx, serviceRecord)
}

func (this serviceRecordTable) Delete(ctx context.Context, serviceRecord *ServiceRecord) error {
	return this.table.Delete(ctx, serviceRecord)
}

func (this serviceRecordTable) Has(ctx context.Context, id string) (found bool, err error) {
	return this.table.PrimaryKey().Has(ctx, id)
}

func (this serviceRecordTable) Get(ctx context.Context, id string) (*ServiceRecord, error) {
	var serviceRecord ServiceRecord
	found, err := this.table.PrimaryKey().Get(ctx, &serviceRecord, id)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &serviceRecord, nil
}

func (this serviceRecordTable) HasByOriginUri(ctx context.Context, origin_uri string) (found bool, err error) {
	return this.table.GetIndexByID(1).(ormtable.UniqueIndex).Has(ctx,
		origin_uri,
	)
}

func (this serviceRecordTable) GetByOriginUri(ctx context.Context, origin_uri string) (*ServiceRecord, error) {
	var serviceRecord ServiceRecord
	found, err := this.table.GetIndexByID(1).(ormtable.UniqueIndex).Get(ctx, &serviceRecord,
		origin_uri,
	)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &serviceRecord, nil
}

func (this serviceRecordTable) HasByControllerOriginUri(ctx context.Context, controller string, origin_uri string) (found bool, err error) {
	return this.table.GetIndexByID(2).(ormtable.UniqueIndex).Has(ctx,
		controller,
		origin_uri,
	)
}

func (this serviceRecordTable) GetByControllerOriginUri(ctx context.Context, controller string, origin_uri string) (*ServiceRecord, error) {
	var serviceRecord ServiceRecord
	found, err := this.table.GetIndexByID(2).(ormtable.UniqueIndex).Get(ctx, &serviceRecord,
		controller,
		origin_uri,
	)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &serviceRecord, nil
}

func (this serviceRecordTable) List(ctx context.Context, prefixKey ServiceRecordIndexKey, opts ...ormlist.Option) (ServiceRecordIterator, error) {
	it, err := this.table.GetIndexByID(prefixKey.id()).List(ctx, prefixKey.values(), opts...)
	return ServiceRecordIterator{it}, err
}

func (this serviceRecordTable) ListRange(ctx context.Context, from, to ServiceRecordIndexKey, opts ...ormlist.Option) (ServiceRecordIterator, error) {
	it, err := this.table.GetIndexByID(from.id()).ListRange(ctx, from.values(), to.values(), opts...)
	return ServiceRecordIterator{it}, err
}

func (this serviceRecordTable) DeleteBy(ctx context.Context, prefixKey ServiceRecordIndexKey) error {
	return this.table.GetIndexByID(prefixKey.id()).DeleteBy(ctx, prefixKey.values()...)
}

func (this serviceRecordTable) DeleteRange(ctx context.Context, from, to ServiceRecordIndexKey) error {
	return this.table.GetIndexByID(from.id()).DeleteRange(ctx, from.values(), to.values())
}

func (this serviceRecordTable) doNotImplement() {}

var _ ServiceRecordTable = serviceRecordTable{}

func NewServiceRecordTable(db ormtable.Schema) (ServiceRecordTable, error) {
	table := db.GetTable(&ServiceRecord{})
	if table == nil {
		return nil, ormerrors.TableNotFound.Wrap(string((&ServiceRecord{}).ProtoReflect().Descriptor().FullName()))
	}
	return serviceRecordTable{table}, nil
}

type StateStore interface {
	AuthenticationTable() AuthenticationTable
	AssertionTable() AssertionTable
	ControllerTable() ControllerTable
	DelegationTable() DelegationTable
	ServiceRecordTable() ServiceRecordTable

	doNotImplement()
}

type stateStore struct {
	authentication AuthenticationTable
	assertion      AssertionTable
	controller     ControllerTable
	delegation     DelegationTable
	serviceRecord  ServiceRecordTable
}

func (x stateStore) AuthenticationTable() AuthenticationTable {
	return x.authentication
}

func (x stateStore) AssertionTable() AssertionTable {
	return x.assertion
}

func (x stateStore) ControllerTable() ControllerTable {
	return x.controller
}

func (x stateStore) DelegationTable() DelegationTable {
	return x.delegation
}

func (x stateStore) ServiceRecordTable() ServiceRecordTable {
	return x.serviceRecord
}

func (stateStore) doNotImplement() {}

var _ StateStore = stateStore{}

func NewStateStore(db ormtable.Schema) (StateStore, error) {
	authenticationTable, err := NewAuthenticationTable(db)
	if err != nil {
		return nil, err
	}

	assertionTable, err := NewAssertionTable(db)
	if err != nil {
		return nil, err
	}

	controllerTable, err := NewControllerTable(db)
	if err != nil {
		return nil, err
	}

	delegationTable, err := NewDelegationTable(db)
	if err != nil {
		return nil, err
	}

	serviceRecordTable, err := NewServiceRecordTable(db)
	if err != nil {
		return nil, err
	}

	return stateStore{
		authenticationTable,
		assertionTable,
		controllerTable,
		delegationTable,
		serviceRecordTable,
	}, nil
}