package gensupport

Import Path
	google.golang.org/api/internal/gensupport (on go.dev)

Dependency Relation
	imports 21 packages, and imported by one package

Involved Source Files

	      buffer.go
	   d➜ doc.go
		Package gensupport is an internal implementation detail used by code
		generated by the google-api-go-generator tool.

		This package may be modified at any time without regard for backwards
		compatibility. It should not be used directly by API users.

	      json.go
	      jsonfloat.go
	      media.go
	      params.go
	      resumable.go
	      send.go
	      version.go
Package-Level Type Names (total 12, in which 7 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Backoff (interface)
		Backoff is an interface around gax.Backoff's Pause method, allowing tests to provide their
		own implementation.

		Methods (only one, which is exported)
			( T) Pause() time.Duration
		Implemented By (at least one exported)
			*github.com/googleapis/gax-go/v2.Backoff

	 type Hook (func)
		Hook is the type of a function that is called once before each HTTP request
		that is sent by a generated API.  It returns a function that is called after
		the request returns.
		Hooks are not called if the context is nil.

		As Inputs Of (at least one exported)
			func RegisterHook(h Hook)

	 type JSONFloat64 float64 (basic type)
		JSONFloat64 is a float64 that supports proper unmarshaling of special float
		values in JSON, according to
		https://developers.google.com/protocol-buffers/docs/proto3#json. Although
		that is a proto-to-JSON spec, it applies to all Google APIs.

		The jsonpb package
		(https://github.com/golang/protobuf/blob/master/jsonpb/jsonpb.go) has
		similar functionality, but only for direct translation from proto messages
		to JSON.

		Methods (only one, which is exported)
			(*T) UnmarshalJSON(data []byte) error
		Implements (at least one exported)
			*T : encoding/json.Unmarshaler

	 type MediaBuffer (struct)
		MediaBuffer buffers data from an io.Reader to support uploading media in
		retryable chunks. It should be created with NewMediaBuffer.

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			chunk []byte
				// The current chunk which is pending upload.  The capacity is the chunk size.

			err error
				// Any error generated when populating chunk by reading media.

			media io.Reader
			off int64
				The absolute position of chunk in the underlying media.

		Methods (total 3, in which 2 are exported)
			(*T) Chunk() (chunk io.Reader, off int64, size int, err error)
				Chunk returns the current buffered chunk, the offset in the underlying media
				from which the chunk is drawn, and the size of the chunk.
				Successive calls to Chunk return the same chunk between calls to Next.

			(*T) Next()
				Next advances to the next chunk, which will be returned by the next call to Chunk.
				Calls to Next without a corresponding prior call to Chunk will have no effect.

			/* one unexported ... *//* one unexported: */
			(*T) loadChunk() error
				loadChunk will read from media into chunk, up to the capacity of chunk.

		As Outputs Of (at least 2, both are exported)
			func NewMediaBuffer(media io.Reader, chunkSize int) *MediaBuffer
			func PrepareUpload(media io.Reader, chunkSize int) (r io.Reader, mb *MediaBuffer, singleChunk bool)

	 type MediaInfo (struct)
		MediaInfo holds information for media uploads. It is intended for use by generated
		code only.

		Fields (total 6, none are exported)
			/* 6 unexporteds ... *//* 6 unexporteds: */
			buffer *MediaBuffer
			mType string
			media io.Reader
				At most one of Media and MediaBuffer will be set.

			progressUpdater googleapi.ProgressUpdater
			singleChunk bool
			size int64
				// mediaSize, if known.  Used only for calls to progressUpdater_.

		Methods (total 4, all are exported)
			(*T) ResumableUpload(locURI string) *ResumableUpload
				ResumableUpload returns an appropriately configured ResumableUpload value if the
				upload is resumable, or nil otherwise.

			(*T) SetProgressUpdater(pu googleapi.ProgressUpdater)
				SetProgressUpdater sets the progress updater for the media info.

			(*T) UploadRequest(reqHeaders http.Header, body io.Reader) (newBody io.Reader, getBody func() (io.ReadCloser, error), cleanup func())
				UploadRequest sets up an HTTP request for media upload. It adds headers
				as necessary, and returns a replacement for the body and a function for http.Request.GetBody.

			(*T) UploadType() string
				UploadType determines the type of upload: a single request, or a resumable
				series of requests.

		As Outputs Of (at least 2, both are exported)
			func NewInfoFromMedia(r io.Reader, options []googleapi.MediaOption) *MediaInfo
			func NewInfoFromResumableMedia(r io.ReaderAt, size int64, mediaType string) *MediaInfo

	 type ResumableUpload (struct)
		ResumableUpload is used by the generated APIs to provide resumable uploads.
		It is not used by developers directly.

		Fields (total 8, in which 6 are exported)
			Callback func(int64)
				Callback is an optional function that will be periodically called with the cumulative number of bytes uploaded.

			Client *http.Client
			Media *MediaBuffer
				Media is the object being uploaded.

			MediaType string
				MediaType defines the media type, e.g. "image/jpeg".

			URI string
				URI is the resumable resource destination provided by the server after specifying "&uploadType=resumable".

			UserAgent string
				// User-Agent for header of the request

			/* 2 unexporteds ... *//* 2 unexporteds: */
			mu sync.Mutex
				// guards progress

			progress int64
				// number of bytes uploaded so far

		Methods (total 5, in which 2 are exported)
			(*T) Progress() int64
				Progress returns the number of bytes uploaded at this point.

			(*T) Upload(ctx context.Context) (resp *http.Response, err error)
				Upload starts the process of a resumable upload with a cancellable context.
				It retries using the provided back off strategy until cancelled or the
				strategy indicates to stop retrying.
				It is called from the auto-generated API code and is not visible to the user.
				Before sending an HTTP request, Upload calls any registered hook functions,
				and calls the returned functions after the request returns (see send.go).
				rx is private to the auto-generated API code.
				Exactly one of resp or err will be nil.  If resp is non-nil, the caller must call resp.Body.Close.

			/* 3 unexporteds ... *//* 3 unexporteds: */
			(*T) doUploadRequest(ctx context.Context, data io.Reader, off, size int64, final bool) (*http.Response, error)
				doUploadRequest performs a single HTTP request to upload data.
				off specifies the offset in rx.Media from which data is drawn.
				size is the number of bytes in data.
				final specifies whether data is the final chunk to be uploaded.

			(*T) reportProgress(old, updated int64)
				reportProgress calls a user-supplied callback to report upload progress.
				If old==updated, the callback is not called.

			(*T) transferChunk(ctx context.Context) (*http.Response, error)
				transferChunk performs a single HTTP request to upload a single chunk from rx.Media.

		As Outputs Of (at least one exported)
			func (*MediaInfo).ResumableUpload(locURI string) *ResumableUpload

	 type URLParams (map)
		URLParams is a simplified replacement for url.Values
		that safely builds up URL parameters for encoding.

		Methods (total 4, all are exported)
			( T) Encode() string
				Encode encodes the values into ``URL encoded'' form
				("bar=baz&foo=quux") sorted by key.

			( T) Get(key string) string
				Get returns the first value for the given key, or "".

			( T) Set(key, value string)
				Set sets the key to value.
				It replaces any existing values.

			( T) SetMulti(key string, values []string)
				SetMulti sets the key to an array of values.
				It replaces any existing values.
				Note that values must not be modified after calling SetMulti
				so the caller is responsible for making a copy if necessary.

		Implements (at least 2, both are exported)
			 T : github.com/go-redis/redis/v8.ConsistentHash
			 T : go.opentelemetry.io/otel/api/propagation.HTTPSupplier
		As Inputs Of (at least one exported)
			func SetOptions(u URLParams, opts ...googleapi.CallOption)

	/* 5 unexporteds ... *//* 5 unexporteds: */
	 type contentSniffer (struct)
		contentSniffer wraps a Reader, and reports the content type determined by sniffing up to 512 bytes from the Reader.

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			ctype string
				// set on first sniff.

			err error
				// set to any error encountered while reading bytes to be sniffed.

			r io.Reader
			sniffed bool
				// set to true on first sniff.

			start []byte
				// buffer for the sniffed bytes.

		Methods (total 2, both are exported)
			(*T) ContentType() (string, bool)
				ContentType returns the sniffed content type, and whether the content type was successfully sniffed.

			(*T) Read(p []byte) (n int, err error)
		Implements (at least 2, both are exported)
			*T : github.com/jbenet/go-context/io.Reader
			*T : io.Reader
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newContentSniffer(r io.Reader) *contentSniffer

	 type jsonTag (struct)
		jsonTag represents a restricted version of the struct tag format used by encoding/json.
		It is used to describe the JSON encoding of fields in a Schema struct.

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			apiName string
			ignore bool
			stringFormat bool
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func parseJSONTag(val string) (jsonTag, error)

	 type multipartReader (struct)
		multipartReader combines the contents of multiple readers to create a multipart/related HTTP body.
		Close must be called if reads from the multipartReader are abandoned before reaching EOF.

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			ctype string
			mu sync.Mutex
			pipeOpen bool
			pr *io.PipeReader
		Methods (total 2, both are exported)
			(*T) Close() error
			(*T) Read(data []byte) (n int, err error)
		Implements (at least 4, all are exported)
			*T : github.com/jbenet/go-context/io.Reader
			*T : io.Closer
			*T : io.ReadCloser
			*T : io.Reader
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newMultipartReader(parts []typeReader, boundary string) *multipartReader

	 type readerTyper (struct)

		Fields (total 2, both are exported)
			ContentTyper googleapi.ContentTyper
			Reader io.Reader
		Methods (total 2, both are exported)
			( T) ContentType() string
			( T) Read(p []byte) (n int, err error)
		Implements (at least 3, all are exported)
			 T : google.golang.org/api/googleapi.ContentTyper
			 T : github.com/jbenet/go-context/io.Reader
			 T : io.Reader

	 type typeReader (struct)

		Fields (total 2, in which 1 are exported)
			Reader io.Reader
			/* one unexported ... *//* one unexported: */
			typ string
		Methods (only one, which is exported)
			( T) Read(p []byte) (n int, err error)
		Implements (at least 2, both are exported)
			 T : github.com/jbenet/go-context/io.Reader
			 T : io.Reader
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newMultipartReader(parts []typeReader, boundary string) *multipartReader


Package-Level Functions (total 31, in which 15 are exported)

	 func CombineBodyMedia(body io.Reader, bodyContentType string, media io.Reader, mediaContentType string) (io.ReadCloser, string)
		CombineBodyMedia combines a json body with media content to create a multipart/related HTTP body.
		It returns a ReadCloser containing the combined body, and the overall "multipart/related" content type, with random boundary.

		The caller must call Close on the returned ReadCloser if reads are abandoned before reaching EOF.

	 func DecodeResponse(target interface{}, res *http.Response) error
		DecodeResponse decodes the body of res into target. If there is no body,
		target is unchanged.

	 func DetermineContentType(media io.Reader, ctype string) (io.Reader, string)
		DetermineContentType determines the content type of the supplied reader.
		If the content type is already known, it can be specified via ctype.
		Otherwise, the content of media will be sniffed to determine the content type.
		If media implements googleapi.ContentTyper (deprecated), this will be used
		instead of sniffing the content.
		After calling DetectContentType the caller must not perform further reads on
		media, but rather read from the Reader that is returned.

	 func GoVersion() string
		GoVersion returns the Go runtime version. The returned string
		has no whitespace.

	 func MarshalJSON(schema interface{}, forceSendFields, nullFields []string) ([]byte, error)
		MarshalJSON returns a JSON encoding of schema containing only selected fields.
		A field is selected if any of the following is true:
		  * it has a non-empty value
		  * its field name is present in forceSendFields and it is not a nil pointer or nil interface
		  * its field name is present in nullFields.
		The JSON key for each selected field is taken from the field's json: struct tag.

	 func NewInfoFromMedia(r io.Reader, options []googleapi.MediaOption) *MediaInfo
		NewInfoFromMedia should be invoked from the Media method of a call. It returns a
		MediaInfo populated with chunk size and content type, and a reader or MediaBuffer
		if needed.

	 func NewInfoFromResumableMedia(r io.ReaderAt, size int64, mediaType string) *MediaInfo
		NewInfoFromResumableMedia should be invoked from the ResumableMedia method of a
		call. It returns a MediaInfo using the given reader, size and media type.

	 func NewMediaBuffer(media io.Reader, chunkSize int) *MediaBuffer
		NewMediaBuffer initializes a MediaBuffer.

	 func PrepareUpload(media io.Reader, chunkSize int) (r io.Reader, mb *MediaBuffer, singleChunk bool)
		PrepareUpload determines whether the data in the supplied reader should be
		uploaded in a single request, or in sequential chunks.
		chunkSize is the size of the chunk that media should be split into.

		If chunkSize is zero, media is returned as the first value, and the other
		two return values are nil, true.

		Otherwise, a MediaBuffer is returned, along with a bool indicating whether the
		contents of media fit in a single chunk.

		After PrepareUpload has been called, media should no longer be used: the
		media content should be accessed via one of the return values.

	 func ReaderAtToReader(ra io.ReaderAt, size int64) io.Reader
		ReaderAtToReader adapts a ReaderAt to be used as a Reader.
		If ra implements googleapi.ContentTyper, then the returned reader
		will also implement googleapi.ContentTyper, delegating to ra.

	 func RegisterHook(h Hook)
		RegisterHook registers a Hook to be called before each HTTP request by a
		generated API.  Hooks are called in the order they are registered.  Each
		hook can return a function; if it is non-nil, it is called after the HTTP
		request returns.  These functions are called in the reverse order.
		RegisterHook should not be called concurrently with itself or SendRequest.

	 func SendRequest(ctx context.Context, client *http.Client, req *http.Request) (*http.Response, error)
		SendRequest sends a single HTTP request using the given client.
		If ctx is non-nil, it calls all hooks, then sends the request with
		req.WithContext, then calls any functions returned by the hooks in
		reverse order.

	 func SendRequestWithRetry(ctx context.Context, client *http.Client, req *http.Request) (*http.Response, error)
		SendRequestWithRetry sends a single HTTP request using the given client,
		with retries if a retryable error is returned.
		If ctx is non-nil, it calls all hooks, then sends the request with
		req.WithContext, then calls any functions returned by the hooks in
		reverse order.

	 func SetGetBody(req *http.Request, f func() (io.ReadCloser, error))
		SetGetBody sets the GetBody field of req to f. This was once needed
		to gracefully support Go 1.7 and earlier which didn't have that
		field.

		Deprecated: the code generator no longer uses this as of
		2019-02-19. Nothing else should be calling this anyway, but we
		won't delete this immediately; it will be deleted in as early as 6
		months.

	 func SetOptions(u URLParams, opts ...googleapi.CallOption)
		SetOptions sets the URL params and any additional call options.

	/* 16 unexporteds ... *//* 16 unexporteds: */
	 func combineBodyMedia(body io.Reader, bodyContentType string, media io.Reader, mediaContentType, mimeBoundary string) (io.ReadCloser, string)
		combineBodyMedia is CombineBodyMedia but with an optional mimeBoundary field.

	 func formatAsString(v reflect.Value, kind reflect.Kind) string
		formatAsString returns a string representation of v, dereferencing it first if possible.

	 func goVer(s string) string
	 func includeField(v reflect.Value, f reflect.StructField, mustInclude map[string]bool) bool
		Reports whether the struct field "f" with value "v" should be included in JSON output.

	 func isEmptyValue(v reflect.Value) bool
		isEmptyValue reports whether v is the empty value for its type.  This
		implementation is based on that of the encoding/json package, but its
		correctness does not depend on it being identical. What's important is that
		this function return false in situations where v should not be sent as part
		of a PATCH operation.

	 func newContentSniffer(r io.Reader) *contentSniffer
	 func newMultipartReader(parts []typeReader, boundary string) *multipartReader
		boundary optionally specifies the MIME boundary

	 func notSemverRune(r rune) bool
	 func parseJSONTag(val string) (jsonTag, error)
		parseJSONTag parses a restricted version of the struct tag format used by encoding/json.
		The format of the tag must match that generated by the Schema.writeSchemaStruct method
		in the api generator.

	 func readerFunc(r io.Reader) func() io.Reader
		readerFunc returns a function that always returns an io.Reader that has the same
		contents as r, provided that can be done without consuming r. Otherwise, it
		returns nil.
		See http.NewRequest (in net/http/request.go).

	 func schemaToMap(schema interface{}, mustInclude, useNull map[string]bool, useNullMaps map[string]map[string]bool) (map[string]interface{}, error)
	 func send(ctx context.Context, client *http.Client, req *http.Request) (*http.Response, error)
	 func sendAndRetry(ctx context.Context, client *http.Client, req *http.Request) (*http.Response, error)
	 func shouldRetry(status int, err error) bool
		shouldRetry indicates whether an error is retryable for the purposes of this
		package, following guidance from
		https://cloud.google.com/storage/docs/exponential-backoff .

	 func statusResumeIncomplete(resp *http.Response) bool
	 func typeHeader(contentType string) textproto.MIMEHeader
Package-Level Variables (total 5, none are exported)

	/* 5 unexporteds ... *//* 5 unexporteds: */
	  var backoff func() Backoff
		These are declared as global variables so that tests can overwrite them.

	  var goVersion string
	  var hooks []Hook
	  var retryDeadline time.Duration
		These are declared as global variables so that tests can overwrite them.

	  var syscallRetryable (error) bool
		isRetryable is a platform-specific hook, specified in retryable_linux.go


Package-Level Constants (total 3, none are exported)

	/* 3 unexporteds ... *//* 3 unexporteds: */
	const develPrefix = "devel +"
	const sniffBuffSize = 512
	const statusTooManyRequests = 429
		statusTooManyRequests is returned by the storage API if the
		per-project limits have been temporarily exceeded. The request
		should be retried.
		https://cloud.google.com/storage/docs/json_api/v1/status-codes#standardcodes

The pages are generated with Golds v0.3.2-preview. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.