provider

type AuthCodeExchangeOption interface {
	ApplyToAuthCodeExchangeOptions(target *AuthCodeExchangeOptions)
}

type AuthCodeExchangeOptions struct {
	RedirectURL     string
	AuthCodeOptions []oauth2.AuthCodeOption
	ProviderOptions map[string]string
}

type AuthCodeURLOption interface {
	ApplyToAuthCodeURLOptions(target *AuthCodeURLOptions)
}

type AuthCodeURLOptions struct {
	RedirectURL     string
	Scopes          []string
	AuthCodeOptions []oauth2.AuthCodeOption
	ProviderOptions map[string]string
}

type ClientCredentialsOption interface {
	ApplyToClientCredentialsOptions(target *ClientCredentialsOptions)
}

type ClientCredentialsOptions struct {
	Scopes          []string
	EndpointParams  url.Values
	ProviderOptions map[string]string
}

type DeviceCodeAuthOption interface {
	ApplyToDeviceCodeAuthOptions(target *DeviceCodeAuthOptions)
}

type DeviceCodeAuthOptions struct {
	Scopes          []string
	ProviderOptions map[string]string
}

type DeviceCodeExchangeOption interface {
	ApplyToDeviceCodeExchangeOptions(target *DeviceCodeExchangeOptions)
}

type DeviceCodeExchangeOptions struct {
	ProviderOptions map[string]string
}

type Endpoint struct {
	oauth2.Endpoint

	DeviceURL string
}

type EndpointFactoryFunc func(opts map[string]string) Endpoint

type FactoryFunc func(ctx context.Context, vsn int, opts map[string]string) (Provider, error)

type OptionError struct {
	Option string
	Cause  error
}

type PrivateOperations interface {
	PublicOperations

	// AuthCodeExchange performs an authorization code flow exchange request.
	AuthCodeExchange(ctx context.Context, code string, opts ...AuthCodeExchangeOption) (*Token, error)

	// ClientCredentials performs a client credentials flow request.
	ClientCredentials(ctx context.Context, opts ...ClientCredentialsOption) (*Token, error)
}

type Provider interface {
	// Version is the revision of this provider vis-a-vis the options it
	// supports.
	Version() int

	// Public returns a view of the operations for this provider for the given
	// client ID.
	Public(clientID string) PublicOperations

	// Private returns a complete set of the operations for this provider for
	// the given client ID and client secret.
	Private(clientID, clientSecret string) PrivateOperations
}

type PublicOperations interface {
	// AuthCodeURL returns a URL to send a user to for initial authentication.
	//
	// If this provider does not define an authorization code endpoint URL, this
	// method returns false.
	AuthCodeURL(state string, opts ...AuthCodeURLOption) (string, bool)

	// DeviceCodeAuth performs the RFC 8628 device code authorization operation.
	//
	// If this provider does not support device code authorization, this method
	// returns false.
	DeviceCodeAuth(ctx context.Context, opts ...DeviceCodeAuthOption) (*devicecode.Auth, bool, error)

	// DeviceCodeExchange performs the RFC 8628 device code exchange operation
	// once, without polling.
	DeviceCodeExchange(ctx context.Context, deviceCode string, opts ...DeviceCodeExchangeOption) (*Token, error)

	// RefreshToken performs a refresh token flow request.
	//
	// This method does not check the expiration of the token. It forces a
	// refresh when invoked.
	//
	// Depending on the source of the token, this method may require the client
	// secret. However, for implicit and device code grants, it only requires
	// the client ID.
	RefreshToken(ctx context.Context, t *Token, opts ...RefreshTokenOption) (*Token, error)
}

type RefreshTokenOption interface {
	ApplyToRefreshTokenOptions(target *RefreshTokenOptions)
}

type RefreshTokenOptions struct {
	ProviderOptions map[string]string
}

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

type Token struct {
	*oauth2.Token `json:",inline"`

	ExtraData map[string]interface{} `json:"extra_data,omitempty"`

	// ProviderVersion is the version of the provider that last updated this
	// token. It can be used to upgrade the provider options before handing off
	// to methods that expect versions to be synchronized with the plugin
	// provider version.
	//
	// May be unspecified. If not specified, provider options must be treated as
	// opaque data.
	ProviderVersion int `json:"provider_version,omitempty"`

	// ProviderOptions are the set of persistent options to use for this token
	// when configuring a provider.
	ProviderOptions map[string]string `json:"provider_options,omitempty"`
}

type WithProviderOptions map[string]string

type WithRedirectURL string

type WithScopes []string

type WithURLParams map[string]string