ls3

type Action string

type Authorization struct {
	Credentials   Credential
	SignedHeaders []string
	Signature     []byte // raw decoded hex
}

type BucketFilesystemProvider interface {
	// ListBuckets lists all available filesystemProvider in the provider.
	ListBuckets() ([]string, error)

	// Open returns a filesystem for a given bucket name.
	Open(bucket string) (fs.FS, error)
}

type BucketIterator struct {
	IsTruncated bool
	Continue    string
	// contains filtered or unexported fields
}

type CommonPrefixes struct {
	Prefix string
}

type ConditionOperator string

type Contents struct {
	ChecksumAlgorithm string
	ETag              string
	Key               string
	LastModified      time.Time
	Size              int
	StorageClass      string
}

type Credential struct {
	AccessKeyID string
	Date        time.Time
	Region      string
	Service     string
	Type        string
}

type Error struct {
	ErrorCode
	Message string `xml:"Message"`
}

type ErrorCode struct {
	Code       string `xml:"Code"`
	StatusCode int    `xml:"-"`
}

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

type Identity struct {
	Name            string
	AccessKeyId     string
	SecretAccessKey string
	Policy          []*PolicyStatement
}

type IdentityProvider interface {
	// Get returns the identity associated with the provided access key ID.
	// It should return ErrMissingAccessKeyId if the given access key does not exist.
	Get(keyId string) (*Identity, error)
}

type Keyring map[string]*Identity

type ListBucketResult struct {
	XMLName        xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ ListBucketResult"`
	IsTruncated    bool
	Marker         string
	NextMarker     string
	Name           string
	Prefix         string
	Delimiter      string
	MaxKeys        int
	EncodingType   string
	Contents       []Contents
	CommonPrefixes []CommonPrefixes
}

type ListBucketResultV2 struct {
	XMLName               xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ ListBucketResult"`
	Name                  string
	Prefix                string
	Delimiter             string
	MaxKeys               int
	IsTruncated           bool
	EncodingType          string
	ContinuationToken     string
	NextContinuationToken string
	StartAfter            string
	Contents              []Contents
	CommonPrefixes        []CommonPrefixes
}

type MapContext map[string]string

type Method func(ctx *RequestContext) *Error

type MultiIdentityProvider []IdentityProvider

type NullContext struct{}

type Object struct {
	io.ReadCloser

	Size         int64
	Range        *http_range.Range
	LastModified time.Time
	// ContentType contains the MIME type of the object data.
	// It is the best guess based on the filetype library.
	// This is always set, if unknown the MIME type becomes application/octet-stream
	ContentType string
	// ETag represents the ETag field of the Object.
	// It is always empty.
	ETag string
}

type OptionalList[T any] []T

type PolicyConditions map[ConditionOperator]map[string]OptionalList[string]

type PolicyContextVars interface {
	Get(k string) (string, bool)
}

type PolicyStatement struct {
	// Deny marks this policy as an explicit deny.
	Deny bool
	// Action one or more actions that this policy applies to.
	Action OptionalList[Action]
	// Resource is one or more resources that this policy applies to.
	Resource OptionalList[Resource]
	// Condition sets conditions on when this policy applies.
	Condition PolicyConditions `json:",omitempty"`
}

type RequestContext struct {
	*zap.Logger
	ID         uuid.UUID
	Bucket     string
	Filesystem fs.FS
	Request    *http.Request
	Identity   *Identity

	// The client IP address
	RemoteIP net.IP
	// Is this connection secure
	Secure bool
	// contains filtered or unexported fields
}

type Resource string

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

type ServerOptions struct {
	Log          *zap.Logger
	Signer       Signer
	Identity     IdentityProvider
	Filesystem   BucketFilesystemProvider
	Domain       string
	GlobalPolicy []*PolicyStatement
	ClientIP     security.ClientIP
	ClientTLS    security.ClientTLS
}

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

type Signer interface {
	// Sign computes and signs the given HTTP request using the given request payload and Identity.
	// payload should be the contents of r.Body.
	Sign(r *http.Request, identity *Identity, payload []byte) error

	// Verify verifies the authorization and request signature present in the HTTP request.
	// Verify should return a non-nil error on verification failure, ideally this should contain the underlying type *Error.
	// If Verify reads data from r.Body, it must ensure that the data can be re-read from r if Verify returns a nil error.
	// If the request is not signed using the Signer's algorithm then it shall return nil, nil.
	Verify(r *http.Request, provider IdentityProvider) (*Identity, error)
}

type SingleBucketFilesystem struct {
	fs.FS
}

type SubdirBucketFilesystem struct {
	fs.FS
}