// GENERATED CODE - DO NOT MODIFY BY HAND
declare var $app: c.Handler;type _TygojaDict = { [key:string | number | symbol]: any; }
type _TygojaAny = any

/**
 * package a docs
 * lorem ipsum dolor...
 */
namespace a {
  interface Empty {
    [key:string]: any;
  }
  /**
   * unexported interface
   */
  interface interfaceA<T> {
    [key:string]: any;
    /**
     * some comment
     */
    /**
     * some comment above the function
     */
    Method0(): void
    Method1(): string // inline comment
    /**
     * multi
     * line
     * comment
     */
    Method2(argA: string, argB: string): [T, number]
    Method3(argA: number, ...argB: string[]): [T, Array<string>]
  }
  /**
   * multi
   * line
   * comment
   */
  interface InterfaceB {
    [key:string]: any;
    /**
     * "replace" Method0 from interfaceA
     */
    Method0(): void
    CustomMethod(): time.Time
  }
  interface unexported {
    Field1: string
  }
  /**
   * structA comment
   */
  interface structA {
    Field1: string // after
    /**
     * multi
     * line
     * comment
     * with union type
     */
    Field2: string|Array<number>
  }
  interface structA {
    /**
     * method comment
     */
    Method1(arg1: number): void
  }
  interface structA {
    Method2(arg1: number, ...arg2: string[]): void
  }
  /**
   * structB comment
   */
  type _sqJYikd = unexported&structA
  interface StructB<T> extends _sqJYikd {
    Field3: T
  }
  /**
   * structC with multiple mixed generic types
   */
  interface StructC<A,B,C> {
    Field4: A
    Field5: B
    Field6: C
  }
  interface StructC<A, B, C> {
    /**
     * StructC.Method4 comment
     */
    Method4(arg1: A): [B, C]
  }
  /**
   * type comment
   */
  interface SliceAlias<T> extends Array<T>{} // after
  /**
   * multi
   * line
   * comment
   */
  interface Handler<T> {(): [T, number]  } // after
}

/**
 * package b
 */
namespace b {
  interface Func1 {
    /**
     * single comment
     */
    (): void
  }
  interface Func2<T> {
    /**
     * multi
     * line
     * comment
     */
    (arg1: number): T
  }
  interface Func3<A,B,C> {
    /**
     * function with multiple generic types
     */
    (arg1: A, arg2: B, arg3: number): [A, C]
  }
  interface Func4 {
    /**
     * function that returns a function
     */
    (arg1: number): () => number
  }
  interface Func5 {
    /**
     * function with ommited argument types
     */
    (arg0: string, arg1: number, arg2: number): void
  }
  interface Func6 {
    /**
     * function with reserved argument name and variadic type
     */
    (_arg00: string, ...optional: string[]): void
  }
  interface Func7 {
    /**
     * function with ommited argument names
     */
    (_arg0: string, _arg1: number, ..._arg2: boolean[]): void
  }
  interface Func8 {
    /**
     * function with named return values
     */
    (): [number, string]
  }
  interface Func9 {
    /**
     * function with shortened return values
     */
    (): [string, string]
  }
  interface Func10 {
    /**
     * function with named and shortened return values
     */
    (): [number, string, string]
  }
}

namespace c {
  /**
   * func type comment
   */
  interface Handler {(): string  } // after
  /**
   * Example:
   * 
   * ```
   * 	Some
   * 	code
   * 	sample
   * ```
   */
  interface Example2 {
    Title: string
    Json: Raw
    Bytes: string|Array<number> // should be union
  }
  interface Example2 {
    DemoEx2(): time.Time
  }
  interface Example2 {
    /**
     * Pointer as argument vs return type
     */
    DemoEx3(arg: Example1): (Example1)
  }
  interface Example2 {
    /**
     * ommited types
     */
    DemoEx4(n1: string, n2: string, n3: string): void
  }
  interface Example2 {
    /**
     * ommited names
     */
    DemoEx5(_arg0: string, _arg1: number): void
  }
  interface Example2 {
    /**
     * named return values
     */
    DemoEx6(): [number, string]
  }
  interface Example2 {
    /**
     * shortened return values
     */
    DemoEx7(): [string, string]
  }
  interface Example2 {
    /**
     * named and shortened return values
     */
    DemoEx8(): [number, string, string]
  }
}

/**
 * Package time provides functionality for measuring and displaying time.
 * 
 * The calendrical calculations always assume a Gregorian calendar, with
 * no leap seconds.
 * 
 * # Monotonic Clocks
 * 
 * Operating systems provide both a “wall clock,” which is subject to
 * changes for clock synchronization, and a “monotonic clock,” which is
 * not. The general rule is that the wall clock is for telling time and
 * the monotonic clock is for measuring time. Rather than split the API,
 * in this package the Time returned by [time.Now] contains both a wall
 * clock reading and a monotonic clock reading; later time-telling
 * operations use the wall clock reading, but later time-measuring
 * operations, specifically comparisons and subtractions, use the
 * monotonic clock reading.
 * 
 * For example, this code always computes a positive elapsed time of
 * approximately 20 milliseconds, even if the wall clock is changed during
 * the operation being timed:
 * 
 * ```
 * 	start := time.Now()
 * 	... operation that takes 20 milliseconds ...
 * 	t := time.Now()
 * 	elapsed := t.Sub(start)
 * ```
 * 
 * Other idioms, such as [time.Since](start), [time.Until](deadline), and
 * time.Now().Before(deadline), are similarly robust against wall clock
 * resets.
 * 
 * The rest of this section gives the precise details of how operations
 * use monotonic clocks, but understanding those details is not required
 * to use this package.
 * 
 * The Time returned by time.Now contains a monotonic clock reading.
 * If Time t has a monotonic clock reading, t.Add adds the same duration to
 * both the wall clock and monotonic clock readings to compute the result.
 * Because t.AddDate(y, m, d), t.Round(d), and t.Truncate(d) are wall time
 * computations, they always strip any monotonic clock reading from their results.
 * Because t.In, t.Local, and t.UTC are used for their effect on the interpretation
 * of the wall time, they also strip any monotonic clock reading from their results.
 * The canonical way to strip a monotonic clock reading is to use t = t.Round(0).
 * 
 * If Times t and u both contain monotonic clock readings, the operations
 * t.After(u), t.Before(u), t.Equal(u), t.Compare(u), and t.Sub(u) are carried out
 * using the monotonic clock readings alone, ignoring the wall clock
 * readings. If either t or u contains no monotonic clock reading, these
 * operations fall back to using the wall clock readings.
 * 
 * On some systems the monotonic clock will stop if the computer goes to sleep.
 * On such a system, t.Sub(u) may not accurately reflect the actual
 * time that passed between t and u. The same applies to other functions and
 * methods that subtract times, such as [Since], [Until], [Before], [After],
 * [Add], [Sub], [Equal] and [Compare]. In some cases, you may need to strip
 * the monotonic clock to get accurate results.
 * 
 * Because the monotonic clock reading has no meaning outside
 * the current process, the serialized forms generated by t.GobEncode,
 * t.MarshalBinary, t.MarshalJSON, and t.MarshalText omit the monotonic
 * clock reading, and t.Format provides no format for it. Similarly, the
 * constructors [time.Date], [time.Parse], [time.ParseInLocation], and [time.Unix],
 * as well as the unmarshalers t.GobDecode, t.UnmarshalBinary.
 * t.UnmarshalJSON, and t.UnmarshalText always create times with
 * no monotonic clock reading.
 * 
 * The monotonic clock reading exists only in [Time] values. It is not
 * a part of [Duration] values or the Unix times returned by t.Unix and
 * friends.
 * 
 * Note that the Go == operator compares not just the time instant but
 * also the [Location] and the monotonic clock reading. See the
 * documentation for the Time type for a discussion of equality
 * testing for Time values.
 * 
 * For debugging, the result of t.String does include the monotonic
 * clock reading if present. If t != u because of different monotonic clock readings,
 * that difference will be visible when printing t.String() and u.String().
 * 
 * # Timer Resolution
 * 
 * [Timer] resolution varies depending on the Go runtime, the operating system
 * and the underlying hardware.
 * On Unix, the resolution is ~1ms.
 * On Windows version 1803 and newer, the resolution is ~0.5ms.
 * On older Windows versions, the default resolution is ~16ms, but
 * a higher resolution may be requested using [golang.org/x/sys/windows.TimeBeginPeriod].
 */
namespace time {
  interface Time {
    /**
     * String returns the time formatted using the format string
     * 
     * ```
     * 	"2006-01-02 15:04:05.999999999 -0700 MST"
     * ```
     * 
     * If the time has a monotonic clock reading, the returned string
     * includes a final field "m=±<value>", where value is the monotonic
     * clock reading formatted as a decimal number of seconds.
     * 
     * The returned string is meant for debugging; for a stable serialized
     * representation, use t.MarshalText, t.MarshalBinary, or t.Format
     * with an explicit format string.
     */
    String(): string
  }
  interface Time {
    /**
     * GoString implements [fmt.GoStringer] and formats t to be printed in Go source
     * code.
     */
    GoString(): string
  }
  interface Time {
    /**
     * 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.
     */
    Format(layout: string): string
  }
  interface Time {
    /**
     * AppendFormat is like [Time.Format] but appends the textual
     * representation to b and returns the extended buffer.
     */
    AppendFormat(b: string|Array<number>, layout: string): string|Array<number>
  }
  /**
   * A Time represents an instant in time with nanosecond precision.
   * 
   * Programs using times should typically store and pass them as values,
   * not pointers. That is, time variables and struct fields should be of
   * type [time.Time], not *time.Time.
   * 
   * A Time value can be used by multiple goroutines simultaneously except
   * that the methods [Time.GobDecode], [Time.UnmarshalBinary], [Time.UnmarshalJSON] and
   * [Time.UnmarshalText] are not concurrency-safe.
   * 
   * Time instants can be compared using the [Time.Before], [Time.After], and [Time.Equal] methods.
   * The [Time.Sub] method subtracts two instants, producing a [Duration].
   * The [Time.Add] method adds a Time and a Duration, producing a Time.
   * 
   * The zero value of type Time is January 1, year 1, 00:00:00.000000000 UTC.
   * As this time is unlikely to come up in practice, the [Time.IsZero] method gives
   * a simple way of detecting a time that has not been initialized explicitly.
   * 
   * Each time has an associated [Location]. The methods [Time.Local], [Time.UTC], and Time.In return a
   * Time with a specific Location. Changing the Location of a Time value with
   * these methods does not change the actual instant it represents, only the time
   * zone in which to interpret it.
   * 
   * Representations of a Time value saved by the [Time.GobEncode], [Time.MarshalBinary],
   * [Time.MarshalJSON], and [Time.MarshalText] methods store the [Time.Location]'s offset, but not
   * the location name. They therefore lose information about Daylight Saving Time.
   * 
   * In addition to the required “wall clock” reading, a Time may contain an optional
   * reading of the current process's monotonic clock, to provide additional precision
   * for comparison or subtraction.
   * See the “Monotonic Clocks” section in the package documentation for details.
   * 
   * Note that the Go == operator compares not just the time instant but also the
   * Location and the monotonic clock reading. Therefore, Time values should not
   * be used as map or database keys without first guaranteeing that the
   * identical Location has been set for all values, which can be achieved
   * through use of the UTC or Local method, and that the monotonic clock reading
   * has been stripped by setting t = t.Round(0). In general, prefer t.Equal(u)
   * to t == u, since t.Equal uses the most accurate comparison available and
   * correctly handles the case when only one of its arguments has a monotonic
   * clock reading.
   */
  interface Time {
  }
  interface Time {
    /**
     * After reports whether the time instant t is after u.
     */
    After(u: Time): boolean
  }
  interface Time {
    /**
     * Before reports whether the time instant t is before u.
     */
    Before(u: Time): boolean
  }
  interface Time {
    /**
     * 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.
     */
    Compare(u: Time): number
  }
  interface Time {
    /**
     * 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.
     */
    Equal(u: Time): boolean
  }
  interface Time {
    /**
     * IsZero reports whether t represents the zero time instant,
     * January 1, year 1, 00:00:00 UTC.
     */
    IsZero(): boolean
  }
  interface Time {
    /**
     * Date returns the year, month, and day in which t occurs.
     */
    Date(): [number, Month, number]
  }
  interface Time {
    /**
     * Year returns the year in which t occurs.
     */
    Year(): number
  }
  interface Time {
    /**
     * Month returns the month of the year specified by t.
     */
    Month(): Month
  }
  interface Time {
    /**
     * Day returns the day of the month specified by t.
     */
    Day(): number
  }
  interface Time {
    /**
     * Weekday returns the day of the week specified by t.
     */
    Weekday(): Weekday
  }
  interface Time {
    /**
     * 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.
     */
    ISOWeek(): [number, number]
  }
  interface Time {
    /**
     * Clock returns the hour, minute, and second within the day specified by t.
     */
    Clock(): [number, number, number]
  }
  interface Time {
    /**
     * Hour returns the hour within the day specified by t, in the range [0, 23].
     */
    Hour(): number
  }
  interface Time {
    /**
     * Minute returns the minute offset within the hour specified by t, in the range [0, 59].
     */
    Minute(): number
  }
  interface Time {
    /**
     * Second returns the second offset within the minute specified by t, in the range [0, 59].
     */
    Second(): number
  }
  interface Time {
    /**
     * Nanosecond returns the nanosecond offset within the second specified by t,
     * in the range [0, 999999999].
     */
    Nanosecond(): number
  }
  interface Time {
    /**
     * 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.
     */
    YearDay(): number
  }
  interface Time {
    /**
     * Add returns the time t+d.
     */
    Add(d: Duration): Time
  }
  interface Time {
    /**
     * 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).
     */
    Sub(u: Time): Duration
  }
  interface 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.
     */
    AddDate(years: number, months: number, days: number): Time
  }
  interface Time {
    /**
     * UTC returns t with the location set to UTC.
     */
    UTC(): Time
  }
  interface Time {
    /**
     * Local returns t with the location set to local time.
     */
    Local(): Time
  }
  interface 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.
     */
    In(loc: Location): Time
  }
  interface Time {
    /**
     * Location returns the time zone information associated with t.
     */
    Location(): (Location)
  }
  interface Time {
    /**
     * 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.
     */
    Zone(): [string, number]
  }
  interface 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.
     */
    ZoneBounds(): [Time, Time]
  }
  interface Time {
    /**
     * 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.
     */
    Unix(): number
  }
  interface Time {
    /**
     * 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.
     */
    UnixMilli(): number
  }
  interface Time {
    /**
     * 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.
     */
    UnixMicro(): number
  }
  interface Time {
    /**
     * 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.
     */
    UnixNano(): number
  }
  interface Time {
    /**
     * MarshalBinary implements the encoding.BinaryMarshaler interface.
     */
    MarshalBinary(): string|Array<number>
  }
  interface Time {
    /**
     * UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.
     */
    UnmarshalBinary(data: string|Array<number>): void
  }
  interface Time {
    /**
     * GobEncode implements the gob.GobEncoder interface.
     */
    GobEncode(): string|Array<number>
  }
  interface Time {
    /**
     * GobDecode implements the gob.GobDecoder interface.
     */
    GobDecode(data: string|Array<number>): void
  }
  interface Time {
    /**
     * MarshalJSON implements the [json.Marshaler] interface.
     * The time is a quoted string in the 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.
     */
    MarshalJSON(): string|Array<number>
  }
  interface Time {
    /**
     * UnmarshalJSON implements the [json.Unmarshaler] interface.
     * The time must be a quoted string in the RFC 3339 format.
     */
    UnmarshalJSON(data: string|Array<number>): void
  }
  interface Time {
    /**
     * 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.
     */
    MarshalText(): string|Array<number>
  }
  interface Time {
    /**
     * UnmarshalText implements the [encoding.TextUnmarshaler] interface.
     * The time must be in the RFC 3339 format.
     */
    UnmarshalText(data: string|Array<number>): void
  }
  interface Time {
    /**
     * IsDST reports whether the time in the configured location is in Daylight Savings Time.
     */
    IsDST(): boolean
  }
  interface 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.
     */
    Truncate(d: Duration): Time
  }
  interface 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.
     */
    Round(d: Duration): Time
  }
}

namespace c {
  interface Raw extends Array<number>{}
  interface Example1 {
    Name: string
  }
  interface Example1 {
    DemoEx1(): string
  }
}

namespace time {
  /**
   * A Month specifies a month of the year (January = 1, ...).
   */
  interface Month extends Number{}
  interface Month {
    /**
     * String returns the English name of the month ("January", "February", ...).
     */
    String(): string
  }
  /**
   * A Weekday specifies a day of the week (Sunday = 0, ...).
   */
  interface Weekday extends Number{}
  interface Weekday {
    /**
     * String returns the English name of the day ("Sunday", "Monday", ...).
     */
    String(): string
  }
  /**
   * A Duration represents the elapsed time between two instants
   * as an int64 nanosecond count. The representation limits the
   * largest representable duration to approximately 290 years.
   */
  interface Duration extends Number{}
  interface Duration {
    /**
     * String returns a string representing the duration in the form "72h3m0.5s".
     * Leading zero units are omitted. As a special case, durations less than one
     * second format use a smaller unit (milli-, micro-, or nanoseconds) to ensure
     * that the leading digit is non-zero. The zero duration formats as 0s.
     */
    String(): string
  }
  interface Duration {
    /**
     * Nanoseconds returns the duration as an integer nanosecond count.
     */
    Nanoseconds(): number
  }
  interface Duration {
    /**
     * Microseconds returns the duration as an integer microsecond count.
     */
    Microseconds(): number
  }
  interface Duration {
    /**
     * Milliseconds returns the duration as an integer millisecond count.
     */
    Milliseconds(): number
  }
  interface Duration {
    /**
     * Seconds returns the duration as a floating point number of seconds.
     */
    Seconds(): number
  }
  interface Duration {
    /**
     * Minutes returns the duration as a floating point number of minutes.
     */
    Minutes(): number
  }
  interface Duration {
    /**
     * Hours returns the duration as a floating point number of hours.
     */
    Hours(): number
  }
  interface Duration {
    /**
     * Truncate returns the result of rounding d toward zero to a multiple of m.
     * If m <= 0, Truncate returns d unchanged.
     */
    Truncate(m: Duration): Duration
  }
  interface Duration {
    /**
     * Round returns the result of rounding d to the nearest multiple of m.
     * The rounding behavior for halfway values is to round away from zero.
     * If the result exceeds the maximum (or minimum)
     * value that can be stored in a [Duration],
     * Round returns the maximum (or minimum) duration.
     * If m <= 0, Round returns d unchanged.
     */
    Round(m: Duration): Duration
  }
  interface Duration {
    /**
     * Abs returns the absolute value of d.
     * As a special case, [math.MinInt64] is converted to [math.MaxInt64].
     */
    Abs(): Duration
  }
  /**
   * A Location maps time instants to the zone in use at that time.
   * Typically, the Location represents the collection of time offsets
   * in use in a geographical area. For many Locations the time offset varies
   * depending on whether daylight savings time is in use at the time instant.
   * 
   * Location is used to provide a time zone in a printed Time value and for
   * calculations involving intervals that may cross daylight savings time
   * boundaries.
   */
  interface Location {
  }
  interface Location {
    /**
     * String returns a descriptive name for the time zone information,
     * corresponding to the name argument to [LoadLocation] or [FixedZone].
     */
    String(): string
  }
}