bulkfhir

type Authenticator interface {

	// Authenticate unconditionally performs any credential exchange required to
	// make requests. It is generally not necessary to call this method, as it
	// will be called automatically by AddAuthenticationToRequest if credentials
	// have not yet been exchanged or have expired.
	Authenticate(hc *http.Client) error

	// AuthenticateIfNecessary performs any credential exchange required to make
	// requests, if the credentials have expired or have not yet been exchanged.
	// This can be used if you need to track authentication errors, but does not
	// need to be called otherwise; authentication will be done automatically when
	// requests are made using AddAuthenticationToRequest.
	AuthenticateIfNecessary(hc *http.Client) error

	// Add authentication credentials to an outbound request. This may perform
	// additional requests to perform credential exchange if required by the
	// authentication mechanism, both before any initial request, and on
	// subsequent requests if any acquired credentials have expired.
	//
	// Implementations should call their own AuthenticateIfNecessary method if
	// credential exchange is necessary.
	AddAuthenticationToRequest(hc *http.Client, req *http.Request) error
}

type BearerToken struct {
	Token                        string
	Expiry                       time.Time
	AlwaysAuthenticateIfNoExpiry bool
}

type BearerTokenAuthenticator struct {
	Exchanger CredentialExchanger
	// contains filtered or unexported fields
}

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

type CredentialExchanger interface {
	Authenticate(hc *http.Client) (*BearerToken, error)
}

type HTTPBasicOAuthOptions struct {
	// OAuth scopes used when authenticating.
	Scopes []string

	// Whether the authenticator should always refresh if the authentication
	// server does not provide an "expires_in" duration in the response. The
	// default behaviour is to automatically authenticate upon first use (when
	// AuthenticateIfNecessary or AddAuthenticationToRequest is called), and then
	// to not authenticate again if no expiry time can be determined.
	//
	// Consider using DefaultExpiry instead to provide an expiry duration that is
	// used for determining the expiry time after each credential exchange.
	AlwaysAuthenticateIfNoExpiresIn bool

	// A default expiry duration to use if the authentication server does not
	// provide an "expires_in" duration in the response.
	DefaultExpiry time.Duration
}

type JWTKeyProvider interface {
	Key() (*rsa.PrivateKey, error)
	KeyID() string
}

type JWTOAuthOptions struct {
	// How long the generated JWT is valid for (according to its "exp" claim).
	// Defaults to 5 minutes if unset.
	JWTLifetime time.Duration

	// OAuth scopes used when authenticating.
	Scopes []string

	// Whether the authenticator should always refresh if the authentication
	// server does not provide an "expires_in" duration in the response. The
	// default behaviour is to automatically authenticate upon first use (when
	// AuthenticateIfNecessary or AddAuthenticationToRequest is called), and then
	// to not authenticate again if no expiry time can be determined.
	//
	// Consider using DefaultExpiry instead to provide an expiry duration that is
	// used for determining the expiry time after each credential exchange.
	AlwaysAuthenticateIfNoExpiresIn bool

	// A default expiry duration to use if the authentication server does not
	// provide an "expires_in" duration in the response.
	DefaultExpiry time.Duration
}

type JobStatus struct {
	IsComplete      bool
	PercentComplete int
	RetryAfter      time.Duration
	// ResultURLs holds the final NDJSON URLs for the job by resource type (if the job is complete).
	ResultURLs map[cpb.ResourceTypeCode_Value][]string
	// Indicates the FHIR server time when the bulk data export was processed.
	TransactionTime time.Time
}

type MonitorResult struct {
	// Status holdes the JobStatus
	Status JobStatus
	// Error holds an error associated with this entry (if any)
	Error error
}

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

type TransactionTimeStore interface {
	// Load a previously stored transaction time. If no transaction time has
	// previously been stored (i.e. if the program has never been successfully run
	// with the current configuration), this should return a zero time with no
	// error.
	Load(ctx context.Context) (time.Time, error)
	// Store() saves the given timestamp to persistent storage so that it can be
	// retrieved by Load() the next time the program is run.
	Store(ctx context.Context, ts time.Time) error
}