package types

Import Path
	github.com/oapi-codegen/runtime/types (on go.dev)

Dependency Relation
	imports 8 packages, and imported by one package

Involved Source Files

	    date.go
	    email.go
	    file.go
	    regexes.go
	    uuid.go
Package-Level Type Names (total 4, all are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Date (struct)

		Fields (total 4, in which 1 is exported)
			Time time.Time
			/* 3 unexporteds ... *//* 3 unexporteds: */
			Time.ext int64
			Time.loc *time.Location
				loc specifies the Location that should be used to
				determine the minute, hour, month, day, and year
				that correspond to this Time.
				The nil location means UTC.
				All UTC times are represented with loc==nil, never loc==&utcLoc.

			Time.wall uint64
				wall and ext encode the wall time seconds, wall time nanoseconds,
				and optional monotonic clock reading in nanoseconds.
				
				From high to low bit position, wall encodes a 1-bit flag (hasMonotonic),
				a 33-bit seconds field, and a 30-bit wall time nanoseconds field.
				The nanoseconds field is in the range [0, 999999999].
				If the hasMonotonic bit is 0, then the 33-bit field must be zero
				and the full signed 64-bit wall seconds since Jan 1 year 1 is stored in ext.
				If the hasMonotonic bit is 1, then the 33-bit field holds a 33-bit
				unsigned wall seconds since Jan 1 year 1885, and ext holds a
				signed 64-bit monotonic clock reading, nanoseconds since process start.

		Methods (total 59, in which 45 are exported)
			( Date) Add(d time.Duration) time.Time
				Add returns the time t+d.

			( Date) AddDate(years int, months int, days int) time.Time
				AddDate returns the time corresponding to adding the
				given number of years, months, and days to t.
				For example, AddDate(-1, 2, 3) applied to January 1, 2011
				returns March 4, 2010.
				
				Note that dates are fundamentally coupled to timezones, and calendrical
				periods like days don't have fixed durations. AddDate uses the Location of
				the Time value to determine these durations. That means that the same
				AddDate arguments can produce a different shift in absolute time depending on
				the base Time value and its Location. For example, AddDate(0, 0, 1) applied
				to 12:00 on March 27 always returns 12:00 on March 28. At some locations and
				in some years this is a 24 hour shift. In others it's a 23 hour shift due to
				daylight savings time transitions.
				
				AddDate normalizes its result in the same way that Date does,
				so, for example, adding one month to October 31 yields
				December 1, the normalized form for November 31.

			( Date) After(u time.Time) bool
				After reports whether the time instant t is after u.

			( Date) AppendFormat(b []byte, layout string) []byte
				AppendFormat is like [Time.Format] but appends the textual
				representation to b and returns the extended buffer.

			( Date) Before(u time.Time) bool
				Before reports whether the time instant t is before u.

			( Date) Clock() (hour, min, sec int)
				Clock returns the hour, minute, and second within the day specified by t.

			( Date) Compare(u time.Time) int
				Compare compares the time instant t with u. If t is before u, it returns -1;
				if t is after u, it returns +1; if they're the same, it returns 0.

			( Date) Date() (year int, month time.Month, day int)
				Date returns the year, month, and day in which t occurs.

			( Date) Day() int
				Day returns the day of the month specified by t.

			( Date) Equal(u time.Time) bool
				Equal reports whether t and u represent the same time instant.
				Two times can be equal even if they are in different locations.
				For example, 6:00 +0200 and 4:00 UTC are Equal.
				See the documentation on the Time type for the pitfalls of using == with
				Time values; most code should use Equal instead.

			( Date) Format(layout string) string
				Format returns a textual representation of the time value formatted according
				to the layout defined by the argument. See the documentation for the
				constant called [Layout] to see how to represent the layout format.
				
				The executable example for [Time.Format] demonstrates the working
				of the layout string in detail and is a good reference.

			( Date) GoString() string
				GoString implements [fmt.GoStringer] and formats t to be printed in Go source
				code.

			(*Date) GobDecode(data []byte) error
				GobDecode implements the gob.GobDecoder interface.

			( Date) GobEncode() ([]byte, error)
				GobEncode implements the gob.GobEncoder interface.

			( Date) Hour() int
				Hour returns the hour within the day specified by t, in the range [0, 23].

			( Date) ISOWeek() (year, week int)
				ISOWeek returns the ISO 8601 year and week number in which t occurs.
				Week ranges from 1 to 53. Jan 01 to Jan 03 of year n might belong to
				week 52 or 53 of year n-1, and Dec 29 to Dec 31 might belong to week 1
				of year n+1.

			( Date) In(loc *time.Location) time.Time
				In returns a copy of t representing the same time instant, but
				with the copy's location information set to loc for display
				purposes.
				
				In panics if loc is nil.

			( Date) IsDST() bool
				IsDST reports whether the time in the configured location is in Daylight Savings Time.

			( Date) IsZero() bool
				IsZero reports whether t represents the zero time instant,
				January 1, year 1, 00:00:00 UTC.

			( Date) Local() time.Time
				Local returns t with the location set to local time.

			( Date) Location() *time.Location
				Location returns the time zone information associated with t.

			( Date) MarshalBinary() ([]byte, error)
				MarshalBinary implements the encoding.BinaryMarshaler interface.

			( Date) MarshalJSON() ([]byte, error)
			( Date) MarshalText() ([]byte, error)
				MarshalText implements the [encoding.TextMarshaler] interface.
				The time is formatted in RFC 3339 format with sub-second precision.
				If the timestamp cannot be represented as valid RFC 3339
				(e.g., the year is out of range), then an error is reported.

			( Date) Minute() int
				Minute returns the minute offset within the hour specified by t, in the range [0, 59].

			( Date) Month() time.Month
				Month returns the month of the year specified by t.

			( Date) Nanosecond() int
				Nanosecond returns the nanosecond offset within the second specified by t,
				in the range [0, 999999999].

			( Date) Round(d time.Duration) time.Time
				Round returns the result of rounding t to the nearest multiple of d (since the zero time).
				The rounding behavior for halfway values is to round up.
				If d <= 0, Round returns t stripped of any monotonic clock reading but otherwise unchanged.
				
				Round operates on the time as an absolute duration since the
				zero time; it does not operate on the presentation form of the
				time. Thus, Round(Hour) may return a time with a non-zero
				minute, depending on the time's Location.

			( Date) Second() int
				Second returns the second offset within the minute specified by t, in the range [0, 59].

			( Date) String() string
			( Date) Sub(u time.Time) time.Duration
				Sub returns the duration t-u. If the result exceeds the maximum (or minimum)
				value that can be stored in a [Duration], the maximum (or minimum) duration
				will be returned.
				To compute t-d for a duration d, use t.Add(-d).

			( Date) Truncate(d time.Duration) time.Time
				Truncate returns the result of rounding t down to a multiple of d (since the zero time).
				If d <= 0, Truncate returns t stripped of any monotonic clock reading but otherwise unchanged.
				
				Truncate operates on the time as an absolute duration since the
				zero time; it does not operate on the presentation form of the
				time. Thus, Truncate(Hour) may return a time with a non-zero
				minute, depending on the time's Location.

			( Date) UTC() time.Time
				UTC returns t with the location set to UTC.

			( Date) Unix() int64
				Unix returns t as a Unix time, the number of seconds elapsed
				since January 1, 1970 UTC. The result does not depend on the
				location associated with t.
				Unix-like operating systems often record time as a 32-bit
				count of seconds, but since the method here returns a 64-bit
				value it is valid for billions of years into the past or future.

			( Date) UnixMicro() int64
				UnixMicro returns t as a Unix time, the number of microseconds elapsed since
				January 1, 1970 UTC. The result is undefined if the Unix time in
				microseconds cannot be represented by an int64 (a date before year -290307 or
				after year 294246). The result does not depend on the location associated
				with t.

			( Date) UnixMilli() int64
				UnixMilli returns t as a Unix time, the number of milliseconds elapsed since
				January 1, 1970 UTC. The result is undefined if the Unix time in
				milliseconds cannot be represented by an int64 (a date more than 292 million
				years before or after 1970). The result does not depend on the
				location associated with t.

			( Date) UnixNano() int64
				UnixNano returns t as a Unix time, the number of nanoseconds elapsed
				since January 1, 1970 UTC. The result is undefined if the Unix time
				in nanoseconds cannot be represented by an int64 (a date before the year
				1678 or after 2262). Note that this means the result of calling UnixNano
				on the zero Time is undefined. The result does not depend on the
				location associated with t.

			(*Date) UnmarshalBinary(data []byte) error
				UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.

			(*Date) UnmarshalJSON(data []byte) error
			(*Date) UnmarshalText(data []byte) error
			( Date) Weekday() time.Weekday
				Weekday returns the day of the week specified by t.

			( Date) Year() int
				Year returns the year in which t occurs.

			( Date) YearDay() int
				YearDay returns the day of the year specified by t, in the range [1,365] for non-leap years,
				and [1,366] in leap years.

			( Date) Zone() (name string, offset int)
				Zone computes the time zone in effect at time t, returning the abbreviated
				name of the zone (such as "CET") and its offset in seconds east of UTC.

			( Date) ZoneBounds() (start, end time.Time)
				ZoneBounds returns the bounds of the time zone in effect at time t.
				The zone begins at start and the next zone begins at end.
				If the zone begins at the beginning of time, start will be returned as a zero Time.
				If the zone goes on forever, end will be returned as a zero Time.
				The Location of the returned times will be the same as t.

			/* 14 unexporteds ... *//* 14 unexporteds: */
			( Date) abs() uint64
				abs returns the time t as an absolute time, adjusted by the zone offset.
				It is called when computing a presentation property like Month or Hour.

			(*Date) addSec(d int64)
				addSec adds d seconds to the time.

			( Date) appendFormat(b []byte, layout string) []byte
			( Date) appendFormatRFC3339(b []byte, nanos bool) []byte
			( Date) appendStrictRFC3339(b []byte) ([]byte, error)
			( Date) date(full bool) (year int, month time.Month, day int, yday int)
				date computes the year, day of year, and when full=true,
				the month and day in which t occurs.

			( Date) locabs() (name string, offset int, abs uint64)
				locabs is a combination of the Zone and abs methods,
				extracting both return values from a single zone lookup.

			(*Date) mono() int64
				mono returns t's monotonic clock reading.
				It returns 0 for a missing reading.
				This function is used only for testing,
				so it's OK that technically 0 is a valid
				monotonic clock reading as well.

			(*Date) nsec() int32
				nsec returns the time's nanoseconds.

			(*Date) sec() int64
				sec returns the time's seconds since Jan 1 year 1.

			(*Date) setLoc(loc *time.Location)
				setLoc sets the location associated with the time.

			(*Date) setMono(m int64)
				setMono sets the monotonic clock reading in t.
				If t cannot hold a monotonic clock reading,
				because its wall time is too large,
				setMono is a no-op.

			(*Date) stripMono()
				stripMono strips the monotonic clock reading in t.

			(*Date) unixSec() int64
				unixSec returns the time's seconds since Jan 1 1970 (Unix time).

		Implements (at least 11, in which 8 are exported)
			 Date : encoding.BinaryMarshaler
			*Date : encoding.BinaryUnmarshaler
			 Date : encoding.TextMarshaler
			*Date : encoding.TextUnmarshaler
			 Date : encoding/json.Marshaler
			*Date : encoding/json.Unmarshaler
			 Date : fmt.GoStringer
			 Date : fmt.Stringer
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			 Date : context.stringer
			*Date : crypto/hmac.marshalable
			 Date : runtime.stringer

	 type Email string (basic type)
		Email represents an email address.
		It is a string type that must pass regex validation before being marshalled
		to JSON or unmarshalled from JSON.

		Methods (total 2, both are exported)
			( Email) MarshalJSON() ([]byte, error)
			(*Email) UnmarshalJSON(data []byte) error
		Implements (at least 2, both are exported)
			 Email : encoding/json.Marshaler
			*Email : encoding/json.Unmarshaler

	 type File (struct)

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			data []byte
			filename string
			multipart *multipart.FileHeader
		Methods (total 8, all are exported)
			( File) Bytes() ([]byte, error)
			( File) FileSize() int64
			( File) Filename() string
			(*File) InitFromBytes(data []byte, filename string)
			(*File) InitFromMultipart(header *multipart.FileHeader)
			( File) MarshalJSON() ([]byte, error)
			( File) Reader() (io.ReadCloser, error)
			(*File) UnmarshalJSON(data []byte) error
		Implements (at least 2, both are exported)
			 File : encoding/json.Marshaler
			*File : encoding/json.Unmarshaler

	 type UUID = uuid.UUID ([...])
Package-Level Variables (total 2, in which 1 is exported)

	  var ErrValidationEmail error
		ErrValidationEmail is the sentinel error returned when an email fails validation

	/* one unexported ... *//* one unexported: */
	  var emailRegex *regexp.Regexp
Package-Level Constants (total 2, in which 1 is exported)

	const DateFormat = "2006-01-02"
	/* one unexported ... *//* one unexported: */
	const emailRegexString = "^(?:(?:(?:(?:[a-zA-Z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\x...

The pages are generated with Golds v0.7.6. (GOOS=linux 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 @zigo_101 (reachable from the left QR code) to get the latest news of Golds.