persistence

type ApiSession struct {
	boltz.BaseExtEntity
	IdentityId     string
	Token          string
	IPAddress      string
	ConfigTypes    []string
	MfaComplete    bool
	MfaRequired    bool
	LastActivityAt time.Time
}

type ApiSessionCertificate struct {
	boltz.BaseExtEntity
	ApiSessionId string
	Subject      string
	Fingerprint  string
	ValidAfter   *time.Time
	ValidBefore  *time.Time
	PEM          string
}

type ApiSessionCertificateStore interface {
	Store
	LoadOneById(tx *bbolt.Tx, id string) (*ApiSessionCertificate, error)
	LoadOneByFingerprint(tx *bbolt.Tx, token string) (*ApiSessionCertificate, error)
	LoadOneByQuery(tx *bbolt.Tx, query string) (*ApiSessionCertificate, error)
	GetFingerprintIndex() boltz.ReadIndex
}

type ApiSessionCertificateStoreImpl struct {
	// contains filtered or unexported fields
}

type ApiSessionStore interface {
	Store
	LoadOneById(tx *bbolt.Tx, id string) (*ApiSession, error)
	LoadOneByToken(tx *bbolt.Tx, token string) (*ApiSession, error)
	LoadOneByQuery(tx *bbolt.Tx, query string) (*ApiSession, error)
	GetTokenIndex() boltz.ReadIndex
}

type Authenticator struct {
	boltz.BaseExtEntity
	Type       string
	IdentityId string
	SubType    AuthenticatorSubType
}

type AuthenticatorCert struct {
	Authenticator
	Fingerprint string
	Pem         string
}

type AuthenticatorStore interface {
	Store
	LoadOneById(tx *bbolt.Tx, id string) (*Authenticator, error)
	LoadOneByQuery(tx *bbolt.Tx, query string) (*Authenticator, error)
}

type AuthenticatorSubType interface {
	Fingerprints() []string
}

type AuthenticatorUpdb struct {
	Authenticator
	Username string
	Password string
	Salt     string
}

type Ca struct {
	boltz.BaseExtEntity
	Name                      string
	Fingerprint               string
	CertPem                   string
	IsVerified                bool
	VerificationToken         string
	IsAutoCaEnrollmentEnabled bool
	IsOttCaEnrollmentEnabled  bool
	IsAuthEnabled             bool
	IdentityRoles             []string
	IdentityNameFormat        string
}

type CaStore interface {
	Store
	LoadOneById(tx *bbolt.Tx, id string) (*Ca, error)
	LoadOneByName(tx *bbolt.Tx, id string) (*Ca, error)
	LoadOneByQuery(tx *bbolt.Tx, query string) (*Ca, error)
}

type Config struct {
	boltz.BaseExtEntity
	Name string
	Type string
	Data map[string]interface{}
}

type ConfigStore interface {
	NameIndexedStore
	LoadOneById(tx *bbolt.Tx, id string) (*Config, error)
	LoadOneByName(tx *bbolt.Tx, name string) (*Config, error)
}

type ConfigType struct {
	boltz.BaseExtEntity
	Name   string
	Schema map[string]interface{}
}

type ConfigTypeStore interface {
	NameIndexedStore
	LoadOneById(tx *bbolt.Tx, id string) (*ConfigType, error)
	LoadOneByName(tx *bbolt.Tx, name string) (*ConfigType, error)
	GetName(tx *bbolt.Tx, id string) *string
}

type DbProvider interface {
	GetDb() boltz.Db
	GetServiceCache() network.Cache
	NotifyRouterRenamed(id, name string)
	GetStores() *db.Stores
	GetControllers() *network.Controllers
}

type EdgeRouter struct {
	db.Router
	IsVerified            bool
	CertPem               *string
	UnverifiedCertPem     *string
	UnverifiedFingerprint *string
	Hostname              *string
	EdgeRouterProtocols   map[string]string
	RoleAttributes        []string
	Enrollments           []string
	IsTunnelerEnabled     bool
	AppData               map[string]interface{}
}

type EdgeRouterPolicy struct {
	boltz.BaseExtEntity
	Name            string
	Semantic        string
	IdentityRoles   []string
	EdgeRouterRoles []string
}

type EdgeRouterPolicyStore interface {
	NameIndexedStore
	LoadOneById(tx *bbolt.Tx, id string) (*EdgeRouterPolicy, error)
	LoadOneByName(tx *bbolt.Tx, id string) (*EdgeRouterPolicy, error)
}

type EdgeRouterStore interface {
	NameIndexedStore
	LoadOneById(tx *bbolt.Tx, id string) (*EdgeRouter, error)
	LoadOneByName(tx *bbolt.Tx, id string) (*EdgeRouter, error)
	GetRoleAttributesIndex() boltz.SetReadIndex
	GetRoleAttributesCursorProvider(values []string, semantic string) (ast.SetCursorProvider, error)
}

type EdgeService struct {
	db.Service
	RoleAttributes     []string
	Configs            []string
	EncryptionRequired bool
}

type EdgeServiceStore interface {
	NameIndexedStore

	LoadOneById(tx *bbolt.Tx, id string) (*EdgeService, error)
	LoadOneByName(tx *bbolt.Tx, id string) (*EdgeService, error)
	IsBindableByIdentity(tx *bbolt.Tx, id string, identityId string) bool
	IsDialableByIdentity(tx *bbolt.Tx, id string, identityId string) bool
	GetRoleAttributesIndex() boltz.SetReadIndex
	GetRoleAttributesCursorProvider(values []string, semantic string) (ast.SetCursorProvider, error)
}

type Enrollment struct {
	boltz.BaseExtEntity
	Token           string
	Method          string
	IdentityId      *string
	TransitRouterId *string
	EdgeRouterId    *string
	ExpiresAt       *time.Time
	IssuedAt        *time.Time
	CaId            *string
	Username        *string
	Jwt             string
}

type EnrollmentStore interface {
	Store
	LoadOneById(tx *bbolt.Tx, id string) (*Enrollment, error)
	LoadOneByToken(tx *bbolt.Tx, token string) (*Enrollment, error)
	LoadOneByQuery(tx *bbolt.Tx, query string) (*Enrollment, error)
}

type EnvInfo struct {
	Arch      string
	Os        string
	OsRelease string
	OsVersion string
}

type EventLog struct {
	boltz.BaseExtEntity
	Type             string
	ActorType        string
	ActorId          string
	EntityType       string
	EntityId         string
	FormattedMessage string
	FormatString     string
	FormatData       string
	Data             map[string]interface{}
}

type EventLogStore interface {
	Store
	LoadOneById(tx *bbolt.Tx, id string) (*EventLog, error)
	LoadOneByQuery(tx *bbolt.Tx, query string) (*EventLog, error)
}

type GeoRegion struct {
	boltz.BaseExtEntity
	Name string
}

type GeoRegionStore interface {
	NameIndexedStore
	LoadOneById(tx *bbolt.Tx, id string) (*GeoRegion, error)
	LoadOneByName(tx *bbolt.Tx, id string) (*GeoRegion, error)
}

type Identity struct {
	boltz.BaseExtEntity
	Name                      string
	IdentityTypeId            string
	IsDefaultAdmin            bool
	IsAdmin                   bool
	Enrollments               []string
	Authenticators            []string
	RoleAttributes            []string
	SdkInfo                   *SdkInfo
	EnvInfo                   *EnvInfo
	DefaultHostingPrecedence  ziti.Precedence
	DefaultHostingCost        uint16
	ServiceHostingPrecedences map[string]ziti.Precedence
	ServiceHostingCosts       map[string]uint16
	AppData                   map[string]interface{}
}

type IdentityStore interface {
	NameIndexedStore
	LoadOneById(tx *bbolt.Tx, id string) (*Identity, error)
	LoadOneByName(tx *bbolt.Tx, id string) (*Identity, error)

	GetRoleAttributesIndex() boltz.SetReadIndex
	GetRoleAttributesCursorProvider(values []string, semantic string) (ast.SetCursorProvider, error)

	AssignServiceConfigs(tx *bbolt.Tx, identityId string, serviceConfigs ...ServiceConfig) error
	RemoveServiceConfigs(tx *bbolt.Tx, identityId string, serviceConfigs ...ServiceConfig) error
	GetServiceConfigs(tx *bbolt.Tx, identityId string) ([]ServiceConfig, error)
	LoadServiceConfigsByServiceAndType(tx *bbolt.Tx, identityId string, configTypes map[string]struct{}) map[string]map[string]map[string]interface{}
}

type IdentityType struct {
	boltz.BaseExtEntity
	Name string
}

type IdentityTypeStore interface {
	NameIndexedStore
	LoadOneById(tx *bbolt.Tx, id string) (*IdentityType, error)
	LoadOneByName(tx *bbolt.Tx, id string) (*IdentityType, error)
}

type IdentityTypeStoreImpl struct {
	// contains filtered or unexported fields
}

type Mfa struct {
	boltz.BaseExtEntity
	IdentityId    string
	IsVerified    bool
	Secret        string
	Salt          string
	RecoveryCodes []string
}

type MfaStore interface {
	Store
	LoadOneById(tx *bbolt.Tx, id string) (*Mfa, error)
	LoadOneByQuery(tx *bbolt.Tx, query string) (*Mfa, error)
}

type MfaStoreImpl struct {
	// contains filtered or unexported fields
}

type Migrations struct {
	// contains filtered or unexported fields
}

type NameIndexedStore interface {
	Store
	GetNameIndex() boltz.ReadIndex
}

type OperatingSystem struct {
	OsType     string
	OsVersions []string
}

type Policy interface {
	boltz.NamedExtEntity
}

type PolicyType int32

type PostureCheck struct {
	boltz.BaseExtEntity
	Name           string
	TypeId         string
	Version        int64
	RoleAttributes []string
	SubType        PostureCheckSubType
}

type PostureCheckMacAddresses struct {
	MacAddresses []string
}

type PostureCheckMfa struct {
	TimeoutSeconds        int64
	PromptOnWake          bool
	PromptOnUnlock        bool
	IgnoreLegacyEndpoints bool
}

type PostureCheckOperatingSystem struct {
	OperatingSystems []OperatingSystem
}

type PostureCheckOs struct {
	boltz.BaseExtEntity
	Name             string
	OperatingSystems []OperatingSystem
}

type PostureCheckProcess struct {
	OperatingSystem string
	Path            string
	Hashes          []string
	Fingerprint     string
}

type PostureCheckProcessMulti struct {
	Semantic  string
	Processes []*ProcessMulti
}

type PostureCheckStore interface {
	Store
	LoadOneById(tx *bbolt.Tx, id string) (*PostureCheck, error)
	LoadOneByName(tx *bbolt.Tx, id string) (*PostureCheck, error)
	LoadOneByQuery(tx *bbolt.Tx, query string) (*PostureCheck, error)
	GetRoleAttributesIndex() boltz.SetReadIndex
	GetRoleAttributesCursorProvider(filters []string, semantic string) (ast.SetCursorProvider, error)
}

type PostureCheckSubType interface {
	LoadValues(store boltz.CrudStore, bucket *boltz.TypedBucket)
	SetValues(ctx *boltz.PersistContext, bucket *boltz.TypedBucket)
}

type PostureCheckTypeStore interface {
	NameIndexedStore
	LoadOneById(tx *bbolt.Tx, id string) (*PostureCheckOs, error)
	LoadOneByName(tx *bbolt.Tx, id string) (*PostureCheckOs, error)
}

type PostureCheckWindowsDomains struct {
	Domains []string
}

type ProcessMulti struct {
	OsType             string
	Path               string
	Hashes             []string
	SignerFingerprints []string
}

type SdkInfo struct {
	Branch     string
	Revision   string
	Type       string
	Version    string
	AppId      string
	AppVersion string
}

type SecretStore interface {
	GetSecret() []byte
}

type ServiceConfig struct {
	ServiceId string
	ConfigId  string
}

type ServiceEdgeRouterPolicy struct {
	boltz.BaseExtEntity
	Name            string
	Semantic        string
	ServiceRoles    []string
	EdgeRouterRoles []string
}

type ServiceEdgeRouterPolicyStore interface {
	NameIndexedStore
	LoadOneById(tx *bbolt.Tx, id string) (*ServiceEdgeRouterPolicy, error)
	LoadOneByName(tx *bbolt.Tx, id string) (*ServiceEdgeRouterPolicy, error)
}

type ServiceEvent struct {
	Type       ServiceEventType
	IdentityId string
	ServiceId  string
}

type ServiceEventHandler func(event *ServiceEvent)

type ServiceEventType byte

type ServiceEventsRegistry struct {
	// contains filtered or unexported fields
}

type ServicePolicy struct {
	boltz.BaseExtEntity
	PolicyType        PolicyType
	Name              string
	Semantic          string
	IdentityRoles     []string
	ServiceRoles      []string
	PostureCheckRoles []string
}

type ServicePolicyStore interface {
	NameIndexedStore
	LoadOneById(tx *bbolt.Tx, id string) (*ServicePolicy, error)
	LoadOneByName(tx *bbolt.Tx, id string) (*ServicePolicy, error)
}

type Session struct {
	boltz.BaseExtEntity
	Token           string
	IdentityId      string
	ApiSessionId    string
	ServiceId       string
	Type            string
	Certs           []*SessionCert
	ApiSession      *ApiSession
	ServicePolicies []string
}

type SessionCert struct {
	Id          string
	Cert        string
	Fingerprint string
	ValidFrom   time.Time
	ValidTo     time.Time
}

type SessionStore interface {
	Store
	LoadOneById(tx *bbolt.Tx, id string) (*Session, error)
	LoadOneByToken(tx *bbolt.Tx, token string) (*Session, error)
	LoadCerts(tx *bbolt.Tx, id string) ([]*SessionCert, error)
	GetTokenIndex() boltz.ReadIndex
}

type Store interface {
	boltz.CrudStore
	// contains filtered or unexported methods
}

type Stores struct {
	DbProvider DbProvider

	// fabric stores
	Router     db.RouterStore
	Service    db.ServiceStore
	Terminator db.TerminatorStore

	ApiSession              ApiSessionStore
	ApiSessionCertificate   ApiSessionCertificateStore
	Ca                      CaStore
	Config                  ConfigStore
	ConfigType              ConfigTypeStore
	EdgeRouter              EdgeRouterStore
	EdgeRouterPolicy        EdgeRouterPolicyStore
	EdgeService             EdgeServiceStore
	EventLog                EventLogStore
	GeoRegion               GeoRegionStore
	Identity                IdentityStore
	IdentityType            IdentityTypeStore
	Index                   boltz.ListStore
	Session                 SessionStore
	ServiceEdgeRouterPolicy ServiceEdgeRouterPolicyStore
	ServicePolicy           ServicePolicyStore
	TransitRouter           TransitRouterStore
	Enrollment              EnrollmentStore
	Authenticator           AuthenticatorStore
	PostureCheck            PostureCheckStore
	PostureCheckType        PostureCheckTypeStore
	Mfa                     MfaStore
	// contains filtered or unexported fields
}

type TestContext struct {
	boltz.BaseTestContext
	// contains filtered or unexported fields
}

type TransitRouter struct {
	db.Router
	IsVerified            bool
	Enrollments           []string
	IsBase                bool
	UnverifiedCertPem     *string
	UnverifiedFingerprint *string
}

type TransitRouterStore interface {
	NameIndexedStore
	LoadOneById(tx *bbolt.Tx, id string) (*TransitRouter, error)
	LoadOneByName(tx *bbolt.Tx, id string) (*TransitRouter, error)
}

type UpdateLastActivityAtChecker struct{}