store

type AssertionQuery interface {
	ToResolve() (map[asserts.Grouping][]*asserts.AtRevision, map[asserts.Grouping][]*asserts.AtSequence, error)

	AddError(e error, ref *asserts.Ref) error
	AddSequenceError(e error, atSeq *asserts.AtSequence) error
	AddGroupingError(e error, grouping asserts.Grouping) error
}

type AssertionResult struct {
	Grouping   asserts.Grouping
	StreamURLs []string
}

type AuthRefreshNeed struct {
	Device bool
	User   bool
}

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

type Authorizer interface {
	// Authorize authorizes the given request.
	// If implementing multiple kind of authorization at the same
	// time all they should be performed separately ignoring
	// errors, as the higher-level code might as well treat Authorize
	// as best-effort and only log any returned error.
	Authorize(r *http.Request, dauthCtx DeviceAndAuthContext, user *auth.UserState, opts *AuthorizeOptions) error

	// CanAuthorizeForUser should return true if the Authorizer
	// can authorize requests on behalf of a user, either
	// by the Authorizer using implicit data or by using auth data
	// carried by UserState, in which case the availability of
	// that explicit data in user should be checked.
	CanAuthorizeForUser(user *auth.UserState) bool
}

type CacheEntry struct {
	Info os.FileInfo
	// Candidate is true if the entry is a candidate for removal
	Candidate bool
	// Remove is true when entry would be removed according to the cache policy
	Remove bool
}

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

type CachePolicy struct {
	// MaxItems sets a target for maximum number of unique cache items.
	MaxItems int
	// MaxSizeBytes sets a target for maximum size of all unique items.
	MaxSizeBytes uint64
	// MaxAge sets a target for maximum age of unique cache items.
	MaxAge time.Duration
}

type CategoryDetails struct {
	Name string `json:"name"`
}

type Config struct {
	// Store API base URLs. The assertions url is only separate because it can
	// be overridden by its own env var.
	StoreBaseURL      *url.URL
	AssertionsBaseURL *url.URL

	// Authorizer used to authorize requests, can be nil and a default
	// will be used.
	Authorizer Authorizer

	// StoreID is the store id used if we can't get one through the DeviceAndAuthContext.
	StoreID string

	Architecture string
	Series       string

	DetailFields []string
	InfoFields   []string
	// search v2 fields
	FindFields  []string
	DeltaFormat string

	// CachePolicy defines the cache policy for downloaded snaps
	CachePolicy CachePolicy

	// Proxy returns the HTTP proxy to use when talking to the store
	Proxy func(*http.Request) (*url.URL, error)

	// AssertionMaxFormats if set provides a way to override
	// the assertion max formats sent to the store as supported.
	AssertionMaxFormats map[string]int
}

type CurrentSnap struct {
	InstanceName     string
	SnapID           string
	Revision         snap.Revision
	TrackingChannel  string
	RefreshedDate    time.Time
	IgnoreValidation bool
	Block            []snap.Revision
	Epoch            snap.Epoch
	CohortKey        string
	// ValidationSets is an optional array of validation set primary keys.
	ValidationSets []snapasserts.ValidationSetKey
	// HeldBy is an optional array of snaps with holds on the current snap's
	// refreshes. The "system" snap represents a hold placed by the user.
	HeldBy []string
	// Resources is a map of resource names to the resource revision that is
	// currently installed for the snap.
	Resources map[string]snap.Revision
}

type DeviceAndAuthContext interface {
	Device() (*auth.DeviceState, error)

	UpdateDeviceAuth(device *auth.DeviceState, sessionMacaroon string) (actual *auth.DeviceState, err error)

	UpdateUserAuth(user *auth.UserState, discharges []string) (actual *auth.UserState, err error)

	StoreID(fallback string) (string, error)

	DeviceSessionRequestParams(nonce string) (*DeviceSessionRequestParams, error)
	// ProxyStoreParams returns the parameters of a proxy store. If one is set
	// up in the system, the returned URL points to the proxy store and its ID
	// is non-empty. Otherwise returns the fallback defaultURL.
	ProxyStoreParams(defaultURL *url.URL) (proxyStoreID string, proxyStoreURL *url.URL, err error)

	// CloudInfo returns details about the cloud the current system is running
	// in. Returns nil if no evidence of cloud was found at runtime.
	CloudInfo() (*auth.CloudInfo, error)

	StoreOffline() (bool, error)
}

type DeviceSessionRequestParams struct {
	Request *asserts.DeviceSessionRequest
	Serial  *asserts.Serial
	Model   *asserts.Model
}

type DownloadError struct {
	Code int
	URL  *url.URL
}

type DownloadOptions struct {
	RateLimit           int64
	Scheduled           bool
	LeavePartialOnError bool
}

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

type InvalidAuthDataError map[string]stringList

type Message struct {
	Format string `json:"format"` // e.g. assertion
	Data   string `json:"data"`   // Encoded assertion
}

type MessageExchangeRequest struct {
	// Token of last successfully stored request message.
	// Acknowledges all messages up to and including the specified token.
	After string `json:"after,omitempty"`

	// Controls the operation mode:
	//   - limit > 0: Fetch up to limit messages (server may return fewer)
	//   - limit = 0: Don't return messages (useful for ack-only, response-only, or status checks)
	Limit int `json:"limit"`

	// The response messages to send to the Store.
	Messages []Message `json:"messages,omitempty"`
}

type MessageExchangeResponse struct {
	// Request messages with their acknowledgement tokens.
	Messages []MessageWithToken `json:"messages"`

	// Total unacknowledged messages in the device's queue.
	TotalPendingMessages int `json:"total-pending-messages"`
}

type MessageWithToken struct {
	Message
	Token string `json:"token"`
}

type PasswordPolicyError map[string]stringList

type ReadWriteSeekTruncater interface {
	io.Reader
	io.Writer
	io.Seeker

	Truncate(size int64) error
}

type RefreshOptions struct {
	// RefreshManaged indicates to the store that the refresh is
	// managed via snapd-control.
	RefreshManaged bool
	Scheduled      bool

	PrivacyKey string

	// IncludeResources indicates to the store that resources should be included
	// in the response.
	IncludeResources bool
}

type RefreshingAuthorizer interface {
	Authorizer

	// Refresh transient authorization data.
	RefreshAuth(need AuthRefreshNeed, dauthCtx DeviceAndAuthContext, user *auth.UserState, client *http.Client) error
}

type RevisionNotAvailableError struct {
	Action   string
	Channel  string
	Releases []channel.Channel
}

type Search struct {
	// Query is a term to search by or a prefix (if Prefix is true)
	Query  string
	Prefix bool

	CommonID string

	// category is "section" in search v1
	Category string
	Private  bool
	Scope    string
}

type SnapAction struct {
	Action       string
	InstanceName string
	SnapID       string
	Channel      string
	Revision     snap.Revision
	CohortKey    string
	Flags        SnapActionFlags
	Epoch        snap.Epoch
	// ResourceInstall is a flag that indicates that this action is being used
	// to fetch the list of resources that are available for a snap. This flag
	// impacts how we decide to report an error if the snap has no updates
	// available.
	ResourceInstall bool
	// ValidationSets is an optional array of validation set primary keys
	// (relevant for install and refresh actions).
	ValidationSets []snapasserts.ValidationSetKey
}

type SnapActionError struct {
	// NoResults is set if there were no results in the response
	NoResults bool
	// Refresh errors by snap name.
	Refresh map[string]error
	// Install errors by snap name.
	Install map[string]error
	// Download errors by snap name.
	Download map[string]error
	// Other errors.
	Other []error
}

type SnapActionFlags int

type SnapActionResult struct {
	*snap.Info
	Resources       []SnapResourceResult
	RedirectChannel string
}

type SnapAdder interface {
	AddSnap(snapName, version, summary string, commands []string) error
}

type SnapResourceResult struct {
	DownloadInfo snap.DownloadInfo
	Type         string
	Name         string
	Revision     int
	Version      string
	CreatedAt    string
}

type SnapSpec struct {
	Name string
}

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

type StoreCacheStats struct {
	// TotalSize is a sum of sizes of all entries in the cache.
	TotalSize uint64
	// Entries in the cache, sorted by their modification time, starting from
	// oldest.
	Entries []CacheEntry
}

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

type UnexpectedHTTPStatusError struct {
	OpSummary  string
	StatusCode int
	Method     string
	URL        *url.URL
	OopsID     string
}

type User struct {
	Username         string
	SSHKeys          []string
	OpenIDIdentifier string
}

type UserAuthUpdater interface {
	UpdateUserAuth(user *auth.UserState, discharges []string) (actual *auth.UserState, err error)
}

type UserAuthorizer struct{}