auth

type Application struct {
	Instance instance.Instance
	// ClientID is the application id GitLab shows. The application is
	// public, so there is no secret.
	ClientID string
	// HTTPClient carries the transport and its proxy. It is
	// copied; redirects are refused and Timeout applied.
	HTTPClient *http.Client
	// Timeout bounds one call. Zero means DefaultHTTPTimeout.
	Timeout time.Duration
	// Now is the clock; tests stub it.
	Now func() time.Time
}

type Grant struct {
	Token *oauth2.Token
	// Scopes is what GitLab granted, which can be less than was asked.
	Scopes []string
}

type LoginOptions struct {
	// OpenBrowser is called with the authorization URL. nil uses the
	// OS's default browser; a failure is not fatal, since the URL is
	// printed to Out as well.
	OpenBrowser func(url string) error
	// NoBrowser prints the URL and does not try to open anything. It is
	// what makes this flow usable over SSH, where the callback reaches
	// the remote host's loopback and the browser is local.
	NoBrowser bool
	// Out receives the URL and progress messages. nil discards them.
	Out io.Writer
	// Timeout bounds the person's trip through the browser. Default 5m.
	Timeout time.Duration
	// Listener overrides the loopback listener (tests).
	Listener net.Listener
}

type NoCredentials struct{ Reason error }

type OAuthError struct {
	Status      int
	Code        string
	Description string
}

type Store interface {
	Resolve() (*oauth2.Token, credentials.Source, error)
	Save(*oauth2.Token) (credentials.Source, error)
}

type TokenInfo struct {
	Scopes []string
	// ExpiresIn is the time left; zero for a token that does not expire.
	ExpiresIn time.Duration
	// ApplicationID is the id of the application the token was issued to.
	ApplicationID   string
	ResourceOwnerID int64
}

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

type TokenSourceOptions struct {
	// LockPath is the file the refresh locks: userconfig's LockPath for
	// the profile, shared by every process using it.
	LockPath string
	// LockTimeout bounds the wait for another process's refresh. Zero
	// means twice the application's timeout, so one slow refresh
	// elsewhere is waited out.
	LockTimeout time.Duration
	// Margin is how long before expiry to refresh. Zero means
	// DefaultRefreshMargin.
	Margin time.Duration
	// Warn receives what the person should hear about and no call
	// should fail over: a rotated pair that could not be stored.
	Warn func(string)
	// Now is the clock; tests stub it.
	Now func() time.Time
}

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