authorization

type AccountReader interface {
	GetByID(context.Context, string) (account.Record, error)
}

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

type AuthorityStatus struct {
	Authority  string    `json:"authority"`
	Epoch      string    `json:"epoch"`
	Sequence   uint64    `json:"sequence"`
	CheckedAt  time.Time `json:"checked_at"`
	VerifiedAt time.Time `json:"verified_at"`
	Attempts   uint64    `json:"attempts"`
	Failure    string    `json:"failure"`
	Recovery   string    `json:"recovery"`
}

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

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

type CacheLimits struct {
	Entries            int
	Bytes              int
	BundleBytes        int
	ConcurrentLoads    int
	TenantLoads        int
	LoadTimeout        time.Duration
	PermissionLifetime time.Duration
	ClockUncertainty   time.Duration
}

type Candidate struct {
	Principal *identity.UserRecord
	Key       apikey.Record
	Account   account.Record
	Team      *identity.TeamRecord
	Evidence  []Evidence
}

type Clock func() (time.Time, bool)

type ElapsedClock func() (time.Duration, bool)

type Evidence struct {
	Authority  string
	Epoch      string
	Sequence   uint64
	VerifiedAt time.Time
	ValidUntil time.Time
}

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

type GrantReader interface {
	ResolveAccount(context.Context, string, string) (string, error)
}

type Identity struct {
	Tenant  string
	Subject string
}

type KeyReader interface {
	GetByHash(context.Context, string) (apikey.Record, error)
}

type LocalKeys struct {
	Keys      KeyReader
	Anonymous apikey.APIKey
}

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

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

type PolicyStatus struct {
	Authority string `json:"authority"`
	Sequence  uint64 `json:"sequence"`
	State     string `json:"state"`
	Recovery  string `json:"recovery"`
}

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

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

type RepositorySources struct {
	// PrepareBudget runs only during bounded source loads. It may establish
	// accounting history and change a revision, requiring a complete reread.
	PrepareBudget             func(context.Context, *limits.BudgetPolicy) error
	Users                     UserReader
	Grants                    GrantReader
	Keys                      KeyReader
	Accounts                  AccountReader
	Teams                     TeamReader
	KV, SQL                   RevisionReader
	KVAuthority, SQLAuthority string
}

type RevisionReader interface {
	Read(context.Context) (revision.Stamp, error)
}

type Source interface {
	Load(context.Context, Identity) (Candidate, error)
}

type Status struct {
	Ready              bool              `json:"ready"`
	PermissionLifetime time.Duration     `json:"permission_lifetime_ns"`
	ValidBundles       int               `json:"valid_bundles"`
	InvalidBundles     int               `json:"invalid_bundles"`
	LatestDeadline     time.Time         `json:"latest_deadline,omitempty"`
	Authorities        []PolicyStatus    `json:"authorities"`
	Observations       []AuthorityStatus `json:"observations"`
	Recovery           string            `json:"recovery"`
}

type TeamReader interface {
	GetByID(context.Context, string) (identity.TeamRecord, error)
}

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

type UserReader interface {
	GetBySubject(context.Context, string) (identity.UserRecord, error)
}

type WatchedAuthority struct {
	Authority string
	Reader    RevisionReader
}