oapi

type AnalyticsServiceGetAgentAnalyticsParams struct {
	// RangeStartTime A Timestamp represents a point in time independent of any time zone or local
	//  calendar, encoded as a count of seconds and fractions of seconds at
	//  nanosecond resolution. The count is relative to an epoch at UTC midnight on
	//  January 1, 1970, in the proleptic Gregorian calendar which extends the
	//  Gregorian calendar backwards to year one.
	//
	//  All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
	//  second table is needed for interpretation, using a [24-hour linear
	//  smear](https://developers.google.com/time/smear).
	//
	//  The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
	//  restricting to that range, we ensure that we can convert to and from [RFC
	//  3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
	//
	//  # Examples
	//
	//  Example 1: Compute Timestamp from POSIX `time()`.
	//
	//      Timestamp timestamp;
	//      timestamp.set_seconds(time(NULL));
	//      timestamp.set_nanos(0);
	//
	//  Example 2: Compute Timestamp from POSIX `gettimeofday()`.
	//
	//      struct timeval tv;
	//      gettimeofday(&tv, NULL);
	//
	//      Timestamp timestamp;
	//      timestamp.set_seconds(tv.tv_sec);
	//      timestamp.set_nanos(tv.tv_usec * 1000);
	//
	//  Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
	//
	//      FILETIME ft;
	//      GetSystemTimeAsFileTime(&ft);
	//      UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
	//
	//      // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
	//      // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
	//      Timestamp timestamp;
	//      timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
	//      timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
	//
	//  Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
	//
	//      long millis = System.currentTimeMillis();
	//
	//      Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
	//          .setNanos((int) ((millis % 1000) * 1000000)).build();
	//
	//  Example 5: Compute Timestamp from Java `Instant.now()`.
	//
	//      Instant now = Instant.now();
	//
	//      Timestamp timestamp =
	//          Timestamp.newBuilder().setSeconds(now.getEpochSecond())
	//              .setNanos(now.getNano()).build();
	//
	//  Example 6: Compute Timestamp from current time in Python.
	//
	//      timestamp = Timestamp()
	//      timestamp.GetCurrentTime()
	//
	//  # JSON Mapping
	//
	//  In JSON format, the Timestamp type is encoded as a string in the
	//  [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
	//  format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
	//  where {year} is always expressed using four digits while {month}, {day},
	//  {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
	//  seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
	//  are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
	//  is required. A ProtoJSON serializer should always use UTC (as indicated by
	//  "Z") when printing the Timestamp type and a ProtoJSON parser should be
	//  able to accept both UTC and other timezones (as indicated by an offset).
	//
	//  For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
	//  01:30 UTC on January 15, 2017.
	//
	//  In JavaScript, one can convert a Date object to this format using the
	//  standard
	//  [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
	//  method. In Python, a standard `datetime.datetime` object can be converted
	//  to this format using
	//  [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
	//  the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
	//  the Joda Time's [`ISODateTimeFormat.dateTime()`](
	//  http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
	//  ) to obtain a formatter capable of generating timestamps in this format.
	RangeStartTime *time.Time `form:"range.startTime,omitempty" json:"range.startTime,omitempty"`

	// RangeEndTime A Timestamp represents a point in time independent of any time zone or local
	//  calendar, encoded as a count of seconds and fractions of seconds at
	//  nanosecond resolution. The count is relative to an epoch at UTC midnight on
	//  January 1, 1970, in the proleptic Gregorian calendar which extends the
	//  Gregorian calendar backwards to year one.
	//
	//  All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
	//  second table is needed for interpretation, using a [24-hour linear
	//  smear](https://developers.google.com/time/smear).
	//
	//  The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
	//  restricting to that range, we ensure that we can convert to and from [RFC
	//  3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
	//
	//  # Examples
	//
	//  Example 1: Compute Timestamp from POSIX `time()`.
	//
	//      Timestamp timestamp;
	//      timestamp.set_seconds(time(NULL));
	//      timestamp.set_nanos(0);
	//
	//  Example 2: Compute Timestamp from POSIX `gettimeofday()`.
	//
	//      struct timeval tv;
	//      gettimeofday(&tv, NULL);
	//
	//      Timestamp timestamp;
	//      timestamp.set_seconds(tv.tv_sec);
	//      timestamp.set_nanos(tv.tv_usec * 1000);
	//
	//  Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
	//
	//      FILETIME ft;
	//      GetSystemTimeAsFileTime(&ft);
	//      UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
	//
	//      // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
	//      // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
	//      Timestamp timestamp;
	//      timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
	//      timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
	//
	//  Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
	//
	//      long millis = System.currentTimeMillis();
	//
	//      Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
	//          .setNanos((int) ((millis % 1000) * 1000000)).build();
	//
	//  Example 5: Compute Timestamp from Java `Instant.now()`.
	//
	//      Instant now = Instant.now();
	//
	//      Timestamp timestamp =
	//          Timestamp.newBuilder().setSeconds(now.getEpochSecond())
	//              .setNanos(now.getNano()).build();
	//
	//  Example 6: Compute Timestamp from current time in Python.
	//
	//      timestamp = Timestamp()
	//      timestamp.GetCurrentTime()
	//
	//  # JSON Mapping
	//
	//  In JSON format, the Timestamp type is encoded as a string in the
	//  [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
	//  format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
	//  where {year} is always expressed using four digits while {month}, {day},
	//  {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
	//  seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
	//  are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
	//  is required. A ProtoJSON serializer should always use UTC (as indicated by
	//  "Z") when printing the Timestamp type and a ProtoJSON parser should be
	//  able to accept both UTC and other timezones (as indicated by an offset).
	//
	//  For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
	//  01:30 UTC on January 15, 2017.
	//
	//  In JavaScript, one can convert a Date object to this format using the
	//  standard
	//  [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
	//  method. In Python, a standard `datetime.datetime` object can be converted
	//  to this format using
	//  [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
	//  the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
	//  the Joda Time's [`ISODateTimeFormat.dateTime()`](
	//  http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
	//  ) to obtain a formatter capable of generating timestamps in this format.
	RangeEndTime *time.Time `form:"range.endTime,omitempty" json:"range.endTime,omitempty"`
}

type AnalyticsServiceGetAgentAnalyticsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *LivekitPublicapiAnalyticsV1AgentsGetResponse
}

type AnalyticsServiceGetProjectAnalyticsParams struct {
	// RangeStartTime A Timestamp represents a point in time independent of any time zone or local
	//  calendar, encoded as a count of seconds and fractions of seconds at
	//  nanosecond resolution. The count is relative to an epoch at UTC midnight on
	//  January 1, 1970, in the proleptic Gregorian calendar which extends the
	//  Gregorian calendar backwards to year one.
	//
	//  All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
	//  second table is needed for interpretation, using a [24-hour linear
	//  smear](https://developers.google.com/time/smear).
	//
	//  The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
	//  restricting to that range, we ensure that we can convert to and from [RFC
	//  3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
	//
	//  # Examples
	//
	//  Example 1: Compute Timestamp from POSIX `time()`.
	//
	//      Timestamp timestamp;
	//      timestamp.set_seconds(time(NULL));
	//      timestamp.set_nanos(0);
	//
	//  Example 2: Compute Timestamp from POSIX `gettimeofday()`.
	//
	//      struct timeval tv;
	//      gettimeofday(&tv, NULL);
	//
	//      Timestamp timestamp;
	//      timestamp.set_seconds(tv.tv_sec);
	//      timestamp.set_nanos(tv.tv_usec * 1000);
	//
	//  Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
	//
	//      FILETIME ft;
	//      GetSystemTimeAsFileTime(&ft);
	//      UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
	//
	//      // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
	//      // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
	//      Timestamp timestamp;
	//      timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
	//      timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
	//
	//  Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
	//
	//      long millis = System.currentTimeMillis();
	//
	//      Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
	//          .setNanos((int) ((millis % 1000) * 1000000)).build();
	//
	//  Example 5: Compute Timestamp from Java `Instant.now()`.
	//
	//      Instant now = Instant.now();
	//
	//      Timestamp timestamp =
	//          Timestamp.newBuilder().setSeconds(now.getEpochSecond())
	//              .setNanos(now.getNano()).build();
	//
	//  Example 6: Compute Timestamp from current time in Python.
	//
	//      timestamp = Timestamp()
	//      timestamp.GetCurrentTime()
	//
	//  # JSON Mapping
	//
	//  In JSON format, the Timestamp type is encoded as a string in the
	//  [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
	//  format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
	//  where {year} is always expressed using four digits while {month}, {day},
	//  {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
	//  seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
	//  are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
	//  is required. A ProtoJSON serializer should always use UTC (as indicated by
	//  "Z") when printing the Timestamp type and a ProtoJSON parser should be
	//  able to accept both UTC and other timezones (as indicated by an offset).
	//
	//  For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
	//  01:30 UTC on January 15, 2017.
	//
	//  In JavaScript, one can convert a Date object to this format using the
	//  standard
	//  [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
	//  method. In Python, a standard `datetime.datetime` object can be converted
	//  to this format using
	//  [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
	//  the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
	//  the Joda Time's [`ISODateTimeFormat.dateTime()`](
	//  http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
	//  ) to obtain a formatter capable of generating timestamps in this format.
	RangeStartTime *time.Time `form:"range.startTime,omitempty" json:"range.startTime,omitempty"`

	// RangeEndTime A Timestamp represents a point in time independent of any time zone or local
	//  calendar, encoded as a count of seconds and fractions of seconds at
	//  nanosecond resolution. The count is relative to an epoch at UTC midnight on
	//  January 1, 1970, in the proleptic Gregorian calendar which extends the
	//  Gregorian calendar backwards to year one.
	//
	//  All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
	//  second table is needed for interpretation, using a [24-hour linear
	//  smear](https://developers.google.com/time/smear).
	//
	//  The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
	//  restricting to that range, we ensure that we can convert to and from [RFC
	//  3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
	//
	//  # Examples
	//
	//  Example 1: Compute Timestamp from POSIX `time()`.
	//
	//      Timestamp timestamp;
	//      timestamp.set_seconds(time(NULL));
	//      timestamp.set_nanos(0);
	//
	//  Example 2: Compute Timestamp from POSIX `gettimeofday()`.
	//
	//      struct timeval tv;
	//      gettimeofday(&tv, NULL);
	//
	//      Timestamp timestamp;
	//      timestamp.set_seconds(tv.tv_sec);
	//      timestamp.set_nanos(tv.tv_usec * 1000);
	//
	//  Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
	//
	//      FILETIME ft;
	//      GetSystemTimeAsFileTime(&ft);
	//      UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
	//
	//      // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
	//      // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
	//      Timestamp timestamp;
	//      timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
	//      timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
	//
	//  Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
	//
	//      long millis = System.currentTimeMillis();
	//
	//      Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
	//          .setNanos((int) ((millis % 1000) * 1000000)).build();
	//
	//  Example 5: Compute Timestamp from Java `Instant.now()`.
	//
	//      Instant now = Instant.now();
	//
	//      Timestamp timestamp =
	//          Timestamp.newBuilder().setSeconds(now.getEpochSecond())
	//              .setNanos(now.getNano()).build();
	//
	//  Example 6: Compute Timestamp from current time in Python.
	//
	//      timestamp = Timestamp()
	//      timestamp.GetCurrentTime()
	//
	//  # JSON Mapping
	//
	//  In JSON format, the Timestamp type is encoded as a string in the
	//  [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
	//  format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
	//  where {year} is always expressed using four digits while {month}, {day},
	//  {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
	//  seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
	//  are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
	//  is required. A ProtoJSON serializer should always use UTC (as indicated by
	//  "Z") when printing the Timestamp type and a ProtoJSON parser should be
	//  able to accept both UTC and other timezones (as indicated by an offset).
	//
	//  For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
	//  01:30 UTC on January 15, 2017.
	//
	//  In JavaScript, one can convert a Date object to this format using the
	//  standard
	//  [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
	//  method. In Python, a standard `datetime.datetime` object can be converted
	//  to this format using
	//  [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
	//  the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
	//  the Joda Time's [`ISODateTimeFormat.dateTime()`](
	//  http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
	//  ) to obtain a formatter capable of generating timestamps in this format.
	RangeEndTime *time.Time `form:"range.endTime,omitempty" json:"range.endTime,omitempty"`
}

type AnalyticsServiceGetProjectAnalyticsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *LivekitPublicapiAnalyticsV1ProjectOverviewGetResponse
}

type AnalyticsServiceGetSessionResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *LivekitPublicapiAnalyticsV1SessionsGetResponse
}

type AnalyticsServiceListAgentAnalyticsParams struct {
	// RangeStartTime A Timestamp represents a point in time independent of any time zone or local
	//  calendar, encoded as a count of seconds and fractions of seconds at
	//  nanosecond resolution. The count is relative to an epoch at UTC midnight on
	//  January 1, 1970, in the proleptic Gregorian calendar which extends the
	//  Gregorian calendar backwards to year one.
	//
	//  All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
	//  second table is needed for interpretation, using a [24-hour linear
	//  smear](https://developers.google.com/time/smear).
	//
	//  The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
	//  restricting to that range, we ensure that we can convert to and from [RFC
	//  3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
	//
	//  # Examples
	//
	//  Example 1: Compute Timestamp from POSIX `time()`.
	//
	//      Timestamp timestamp;
	//      timestamp.set_seconds(time(NULL));
	//      timestamp.set_nanos(0);
	//
	//  Example 2: Compute Timestamp from POSIX `gettimeofday()`.
	//
	//      struct timeval tv;
	//      gettimeofday(&tv, NULL);
	//
	//      Timestamp timestamp;
	//      timestamp.set_seconds(tv.tv_sec);
	//      timestamp.set_nanos(tv.tv_usec * 1000);
	//
	//  Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
	//
	//      FILETIME ft;
	//      GetSystemTimeAsFileTime(&ft);
	//      UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
	//
	//      // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
	//      // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
	//      Timestamp timestamp;
	//      timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
	//      timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
	//
	//  Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
	//
	//      long millis = System.currentTimeMillis();
	//
	//      Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
	//          .setNanos((int) ((millis % 1000) * 1000000)).build();
	//
	//  Example 5: Compute Timestamp from Java `Instant.now()`.
	//
	//      Instant now = Instant.now();
	//
	//      Timestamp timestamp =
	//          Timestamp.newBuilder().setSeconds(now.getEpochSecond())
	//              .setNanos(now.getNano()).build();
	//
	//  Example 6: Compute Timestamp from current time in Python.
	//
	//      timestamp = Timestamp()
	//      timestamp.GetCurrentTime()
	//
	//  # JSON Mapping
	//
	//  In JSON format, the Timestamp type is encoded as a string in the
	//  [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
	//  format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
	//  where {year} is always expressed using four digits while {month}, {day},
	//  {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
	//  seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
	//  are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
	//  is required. A ProtoJSON serializer should always use UTC (as indicated by
	//  "Z") when printing the Timestamp type and a ProtoJSON parser should be
	//  able to accept both UTC and other timezones (as indicated by an offset).
	//
	//  For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
	//  01:30 UTC on January 15, 2017.
	//
	//  In JavaScript, one can convert a Date object to this format using the
	//  standard
	//  [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
	//  method. In Python, a standard `datetime.datetime` object can be converted
	//  to this format using
	//  [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
	//  the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
	//  the Joda Time's [`ISODateTimeFormat.dateTime()`](
	//  http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
	//  ) to obtain a formatter capable of generating timestamps in this format.
	RangeStartTime *time.Time `form:"range.startTime,omitempty" json:"range.startTime,omitempty"`

	// RangeEndTime A Timestamp represents a point in time independent of any time zone or local
	//  calendar, encoded as a count of seconds and fractions of seconds at
	//  nanosecond resolution. The count is relative to an epoch at UTC midnight on
	//  January 1, 1970, in the proleptic Gregorian calendar which extends the
	//  Gregorian calendar backwards to year one.
	//
	//  All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
	//  second table is needed for interpretation, using a [24-hour linear
	//  smear](https://developers.google.com/time/smear).
	//
	//  The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
	//  restricting to that range, we ensure that we can convert to and from [RFC
	//  3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
	//
	//  # Examples
	//
	//  Example 1: Compute Timestamp from POSIX `time()`.
	//
	//      Timestamp timestamp;
	//      timestamp.set_seconds(time(NULL));
	//      timestamp.set_nanos(0);
	//
	//  Example 2: Compute Timestamp from POSIX `gettimeofday()`.
	//
	//      struct timeval tv;
	//      gettimeofday(&tv, NULL);
	//
	//      Timestamp timestamp;
	//      timestamp.set_seconds(tv.tv_sec);
	//      timestamp.set_nanos(tv.tv_usec * 1000);
	//
	//  Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
	//
	//      FILETIME ft;
	//      GetSystemTimeAsFileTime(&ft);
	//      UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
	//
	//      // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
	//      // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
	//      Timestamp timestamp;
	//      timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
	//      timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
	//
	//  Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
	//
	//      long millis = System.currentTimeMillis();
	//
	//      Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
	//          .setNanos((int) ((millis % 1000) * 1000000)).build();
	//
	//  Example 5: Compute Timestamp from Java `Instant.now()`.
	//
	//      Instant now = Instant.now();
	//
	//      Timestamp timestamp =
	//          Timestamp.newBuilder().setSeconds(now.getEpochSecond())
	//              .setNanos(now.getNano()).build();
	//
	//  Example 6: Compute Timestamp from current time in Python.
	//
	//      timestamp = Timestamp()
	//      timestamp.GetCurrentTime()
	//
	//  # JSON Mapping
	//
	//  In JSON format, the Timestamp type is encoded as a string in the
	//  [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
	//  format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
	//  where {year} is always expressed using four digits while {month}, {day},
	//  {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
	//  seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
	//  are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
	//  is required. A ProtoJSON serializer should always use UTC (as indicated by
	//  "Z") when printing the Timestamp type and a ProtoJSON parser should be
	//  able to accept both UTC and other timezones (as indicated by an offset).
	//
	//  For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
	//  01:30 UTC on January 15, 2017.
	//
	//  In JavaScript, one can convert a Date object to this format using the
	//  standard
	//  [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
	//  method. In Python, a standard `datetime.datetime` object can be converted
	//  to this format using
	//  [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
	//  the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
	//  the Joda Time's [`ISODateTimeFormat.dateTime()`](
	//  http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
	//  ) to obtain a formatter capable of generating timestamps in this format.
	RangeEndTime *time.Time `form:"range.endTime,omitempty" json:"range.endTime,omitempty"`

	// PageCursor Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
	//  from the beginning.
	PageCursor *string `form:"page.cursor,omitempty" json:"page.cursor,omitempty"`

	// PagePageSize Maximum items to return; 0 lets the server pick a default.
	PagePageSize *int32 `form:"page.pageSize,omitempty" json:"page.pageSize,omitempty"`
}

type AnalyticsServiceListAgentAnalyticsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *LivekitPublicapiAnalyticsV1AgentsListResponse
}

type AnalyticsServiceListProjectSessionsParams struct {
	// PageCursor Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
	//  from the beginning.
	PageCursor *string `form:"page.cursor,omitempty" json:"page.cursor,omitempty"`

	// PagePageSize Maximum items to return; 0 lets the server pick a default.
	PagePageSize *int32 `form:"page.pageSize,omitempty" json:"page.pageSize,omitempty"`

	// FilterRangeStartTime A Timestamp represents a point in time independent of any time zone or local
	//  calendar, encoded as a count of seconds and fractions of seconds at
	//  nanosecond resolution. The count is relative to an epoch at UTC midnight on
	//  January 1, 1970, in the proleptic Gregorian calendar which extends the
	//  Gregorian calendar backwards to year one.
	//
	//  All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
	//  second table is needed for interpretation, using a [24-hour linear
	//  smear](https://developers.google.com/time/smear).
	//
	//  The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
	//  restricting to that range, we ensure that we can convert to and from [RFC
	//  3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
	//
	//  # Examples
	//
	//  Example 1: Compute Timestamp from POSIX `time()`.
	//
	//      Timestamp timestamp;
	//      timestamp.set_seconds(time(NULL));
	//      timestamp.set_nanos(0);
	//
	//  Example 2: Compute Timestamp from POSIX `gettimeofday()`.
	//
	//      struct timeval tv;
	//      gettimeofday(&tv, NULL);
	//
	//      Timestamp timestamp;
	//      timestamp.set_seconds(tv.tv_sec);
	//      timestamp.set_nanos(tv.tv_usec * 1000);
	//
	//  Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
	//
	//      FILETIME ft;
	//      GetSystemTimeAsFileTime(&ft);
	//      UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
	//
	//      // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
	//      // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
	//      Timestamp timestamp;
	//      timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
	//      timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
	//
	//  Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
	//
	//      long millis = System.currentTimeMillis();
	//
	//      Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
	//          .setNanos((int) ((millis % 1000) * 1000000)).build();
	//
	//  Example 5: Compute Timestamp from Java `Instant.now()`.
	//
	//      Instant now = Instant.now();
	//
	//      Timestamp timestamp =
	//          Timestamp.newBuilder().setSeconds(now.getEpochSecond())
	//              .setNanos(now.getNano()).build();
	//
	//  Example 6: Compute Timestamp from current time in Python.
	//
	//      timestamp = Timestamp()
	//      timestamp.GetCurrentTime()
	//
	//  # JSON Mapping
	//
	//  In JSON format, the Timestamp type is encoded as a string in the
	//  [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
	//  format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
	//  where {year} is always expressed using four digits while {month}, {day},
	//  {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
	//  seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
	//  are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
	//  is required. A ProtoJSON serializer should always use UTC (as indicated by
	//  "Z") when printing the Timestamp type and a ProtoJSON parser should be
	//  able to accept both UTC and other timezones (as indicated by an offset).
	//
	//  For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
	//  01:30 UTC on January 15, 2017.
	//
	//  In JavaScript, one can convert a Date object to this format using the
	//  standard
	//  [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
	//  method. In Python, a standard `datetime.datetime` object can be converted
	//  to this format using
	//  [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
	//  the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
	//  the Joda Time's [`ISODateTimeFormat.dateTime()`](
	//  http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
	//  ) to obtain a formatter capable of generating timestamps in this format.
	FilterRangeStartTime *time.Time `form:"filter.range.startTime,omitempty" json:"filter.range.startTime,omitempty"`

	// FilterRangeEndTime A Timestamp represents a point in time independent of any time zone or local
	//  calendar, encoded as a count of seconds and fractions of seconds at
	//  nanosecond resolution. The count is relative to an epoch at UTC midnight on
	//  January 1, 1970, in the proleptic Gregorian calendar which extends the
	//  Gregorian calendar backwards to year one.
	//
	//  All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
	//  second table is needed for interpretation, using a [24-hour linear
	//  smear](https://developers.google.com/time/smear).
	//
	//  The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
	//  restricting to that range, we ensure that we can convert to and from [RFC
	//  3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
	//
	//  # Examples
	//
	//  Example 1: Compute Timestamp from POSIX `time()`.
	//
	//      Timestamp timestamp;
	//      timestamp.set_seconds(time(NULL));
	//      timestamp.set_nanos(0);
	//
	//  Example 2: Compute Timestamp from POSIX `gettimeofday()`.
	//
	//      struct timeval tv;
	//      gettimeofday(&tv, NULL);
	//
	//      Timestamp timestamp;
	//      timestamp.set_seconds(tv.tv_sec);
	//      timestamp.set_nanos(tv.tv_usec * 1000);
	//
	//  Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
	//
	//      FILETIME ft;
	//      GetSystemTimeAsFileTime(&ft);
	//      UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
	//
	//      // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
	//      // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
	//      Timestamp timestamp;
	//      timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
	//      timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
	//
	//  Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
	//
	//      long millis = System.currentTimeMillis();
	//
	//      Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
	//          .setNanos((int) ((millis % 1000) * 1000000)).build();
	//
	//  Example 5: Compute Timestamp from Java `Instant.now()`.
	//
	//      Instant now = Instant.now();
	//
	//      Timestamp timestamp =
	//          Timestamp.newBuilder().setSeconds(now.getEpochSecond())
	//              .setNanos(now.getNano()).build();
	//
	//  Example 6: Compute Timestamp from current time in Python.
	//
	//      timestamp = Timestamp()
	//      timestamp.GetCurrentTime()
	//
	//  # JSON Mapping
	//
	//  In JSON format, the Timestamp type is encoded as a string in the
	//  [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
	//  format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
	//  where {year} is always expressed using four digits while {month}, {day},
	//  {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
	//  seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
	//  are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
	//  is required. A ProtoJSON serializer should always use UTC (as indicated by
	//  "Z") when printing the Timestamp type and a ProtoJSON parser should be
	//  able to accept both UTC and other timezones (as indicated by an offset).
	//
	//  For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
	//  01:30 UTC on January 15, 2017.
	//
	//  In JavaScript, one can convert a Date object to this format using the
	//  standard
	//  [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
	//  method. In Python, a standard `datetime.datetime` object can be converted
	//  to this format using
	//  [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
	//  the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
	//  the Joda Time's [`ISODateTimeFormat.dateTime()`](
	//  http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
	//  ) to obtain a formatter capable of generating timestamps in this format.
	FilterRangeEndTime *time.Time `form:"filter.range.endTime,omitempty" json:"filter.range.endTime,omitempty"`

	// FilterStatuses OR semantics; empty matches any status.
	FilterStatuses *[]LivekitPublicapiAnalyticsV1SessionStatus `form:"filter.statuses,omitempty" json:"filter.statuses,omitempty"`

	// FilterRoomName Room-name prefix match (case-sensitive): returns sessions whose room name
	//  starts with this value, e.g. `demo-` matches `demo-1` and `demo-lobby`.
	FilterRoomName *string `form:"filter.roomName,omitempty" json:"filter.roomName,omitempty"`

	// FilterSessionId Exact room-session id match (RM_...).
	FilterSessionId *string `form:"filter.sessionId,omitempty" json:"filter.sessionId,omitempty"`

	// FilterTags OR semantics.
	FilterTags *[]string `form:"filter.tags,omitempty" json:"filter.tags,omitempty"`

	// FilterAgentId Cloud agent id (CA_...) — return only sessions this agent served. Duration is not filterable in v1.
	FilterAgentId *string `form:"filter.agentId,omitempty" json:"filter.agentId,omitempty"`

	// SortOrder Direction of the started_at ordering, the only column sessions sort on.
	//  Defaults to descending (newest first) when unset.
	SortOrder *LivekitPublicapiCommonV1SortOrder `form:"sortOrder,omitempty" json:"sortOrder,omitempty"`
}

type AnalyticsServiceListProjectSessionsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *LivekitPublicapiAnalyticsV1SessionsListResponse
}

type AnalyticsServiceListSessionEventsParams struct {
	// PageCursor Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
	//  from the beginning.
	PageCursor *string `form:"page.cursor,omitempty" json:"page.cursor,omitempty"`

	// PagePageSize Maximum items to return; 0 lets the server pick a default.
	PagePageSize *int32 `form:"page.pageSize,omitempty" json:"page.pageSize,omitempty"`

	// Types Event types to return, by name, such as TRACK_PUBLISHED: the names of
	//  LiveKit's AnalyticsEventType. Each matches exactly. Empty returns the
	//  dashboard's seven defaults, or with participant_session_id its eleven
	//  participant defaults, track events included (see ListSessionEvents).
	//  An unknown name is InvalidArgument.
	Types *[]string `form:"types,omitempty" json:"types,omitempty"`

	// ParticipantSessionId Only the events of this participant session (PA_...), as the
	//  participants list's ParticipantSession.participant_session_id names
	//  it. Room events and API calls name no participant session, so they
	//  are left out. Anything but a PA_ id is InvalidArgument.
	ParticipantSessionId *string `form:"participantSessionId,omitempty" json:"participantSessionId,omitempty"`

	// SortOrder Direction of the timestamp ordering. Defaults to ascending (oldest
	//  first) when unset.
	SortOrder *LivekitPublicapiCommonV1SortOrder `form:"sortOrder,omitempty" json:"sortOrder,omitempty"`
}

type AnalyticsServiceListSessionEventsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *LivekitPublicapiAnalyticsV1SessionEventsListResponse
}

type AnalyticsServiceListSessionParticipantsParams struct {
	// PageCursor Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
	//  from the beginning.
	PageCursor *string `form:"page.cursor,omitempty" json:"page.cursor,omitempty"`

	// PagePageSize Maximum items to return; 0 lets the server pick a default.
	PagePageSize *int32 `form:"page.pageSize,omitempty" json:"page.pageSize,omitempty"`

	// SortBy Column to order by. Defaults to joined_at when unset.
	SortBy *LivekitPublicapiAnalyticsV1ParticipantSortField `form:"sortBy,omitempty" json:"sortBy,omitempty"`

	// SortOrder Direction of sort_by. Defaults to descending (newest first) when unset.
	SortOrder *LivekitPublicapiCommonV1SortOrder `form:"sortOrder,omitempty" json:"sortOrder,omitempty"`
}

type AnalyticsServiceListSessionParticipantsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *LivekitPublicapiAnalyticsV1SessionParticipantsListResponse
}

type Client struct {
	// The endpoint of the server conforming to this interface, with scheme,
	// https://api.deepmap.com for example. This can contain a path relative
	// to the server, such as https://api.deepmap.com/dev-test, and all the
	// paths in the swagger spec will be appended to the server.
	Server string

	// Doer for performing requests, typically a *http.Client with any
	// customized settings, such as certificate chains.
	Client HttpRequestDoer

	// A list of callbacks for modifying requests which are generated before sending over
	// the network.
	RequestEditors []RequestEditorFn
}