storage

type Info struct {
	Key         string
	Size        int64
	SHA256      string
	ContentType string
	// ETag is the quoted validator, derived from the SHA-256.
	ETag    string
	ModTime time.Time
}

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

type Object struct {
	// Key is the generated, opaque key. Keep it; it is the only handle.
	Key string
	// Size is the number of bytes stored.
	Size int64
	// SHA256 is the lowercase hex SHA-256 of the bytes.
	SHA256 string
	// ContentType is the type sniffed from the bytes, such as "image/png".
	ContentType string
}

type PutOptions struct {
	// MaxSize is the most bytes the object may hold. It must be positive.
	MaxSize int64
	// AllowedTypes, when not empty, lists the sniffed media types accepted:
	// "image/png", or "image/*" for any subtype. Parameters and case are
	// ignored. Nothing a client declares is consulted.
	AllowedTypes []string
}

type ServeOptions struct {
	// Filename is the name offered to the browser in Content-Disposition. It
	// comes from the host (its metadata), never from the stored object. It
	// is reduced to a base name, stripped of control characters, and encoded
	// per RFC 6266 and RFC 5987; if nothing usable is left no name is sent.
	Filename string
	// InlineTypes lists the stored media types the browser may show inline,
	// such as "image/png" or "image/*". Every other type is sent as an
	// attachment. Active content (HTML, XHTML, SVG, XML, JavaScript, CSS) is
	// always an attachment, even when listed, so a stored file cannot run
	// in the application's origin.
	InlineTypes []string
	// CacheControl replaces the default "private, no-store".
	CacheControl string
	// SkipSandboxPolicy omits the default Content-Security-Policy that sandboxes
	// a served object. Set it only when the object is trusted to run its own
	// active content, or when a browser must render it outside the sandbox.
	// Nothing else in the response changes.
	SkipSandboxPolicy bool
}

type Store interface {
	// Put streams r into a new object and returns its generated key. The
	// write is atomic (the object is fully visible or absent) and
	// create-only. It always sniffs the content type from the stream, and
	// fails with ErrTooLarge past opts.MaxSize or ErrTypeNotAllowed outside
	// opts.AllowedTypes, leaving nothing stored.
	Put(ctx context.Context, r io.Reader, opts PutOptions) (Object, error)
	// Stat describes the object at key, or fails with ErrNotFound.
	Stat(ctx context.Context, key string) (Info, error)
	// Open reads length bytes of the object at key from offset; a negative
	// length, or one that reaches or exceeds the remaining bytes (math.MaxInt64
	// included), reads to the end. An
	// offset beyond the end fails with ErrInvalidRange. The caller closes
	// the reader.
	Open(ctx context.Context, key string, offset, length int64) (io.ReadCloser, error)
	// Delete removes the object at key. Deleting a missing object is not an
	// error.
	Delete(ctx context.Context, key string) error
}

type TooLargeError struct{ Max int64 }

type TypeNotAllowedError struct{ Type string }

type UploadOptions struct {
	// Field is the form field holding the file. It defaults to "file".
	Field string
	// PutOptions are passed to Store.Put unchanged, so the size cap and the
	// allowed-types policy apply exactly as they do to a direct Put.
	PutOptions
}

type UploadedFile struct {
	Object
	// Filename is the client's filename reduced to a safe display name: no
	// directories, no control or format characters, valid UTF-8, at most 255 bytes.
	// It may be empty.
	Filename string
	// DeclaredType is the Content-Type the client sent for the part. It is
	// not the stored type; Object.ContentType is the sniffed one.
	DeclaredType string
}