@miradorlabs/web-grpc 4.1.0 → 4.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
|
@@ -1824,6 +1824,261 @@ export function relayHeartbeatSortToJSON(object: RelayHeartbeatSort): string {
|
|
|
1824
1824
|
}
|
|
1825
1825
|
}
|
|
1826
1826
|
|
|
1827
|
+
/** Tracker mirrors ai.api.v1.Tracker. */
|
|
1828
|
+
export enum Tracker {
|
|
1829
|
+
TRACKER_UNSPECIFIED = 0,
|
|
1830
|
+
TRACKER_LINEAR = 1,
|
|
1831
|
+
UNRECOGNIZED = -1,
|
|
1832
|
+
}
|
|
1833
|
+
|
|
1834
|
+
export function trackerFromJSON(object: any): Tracker {
|
|
1835
|
+
switch (object) {
|
|
1836
|
+
case 0:
|
|
1837
|
+
case "TRACKER_UNSPECIFIED":
|
|
1838
|
+
return Tracker.TRACKER_UNSPECIFIED;
|
|
1839
|
+
case 1:
|
|
1840
|
+
case "TRACKER_LINEAR":
|
|
1841
|
+
return Tracker.TRACKER_LINEAR;
|
|
1842
|
+
case -1:
|
|
1843
|
+
case "UNRECOGNIZED":
|
|
1844
|
+
default:
|
|
1845
|
+
return Tracker.UNRECOGNIZED;
|
|
1846
|
+
}
|
|
1847
|
+
}
|
|
1848
|
+
|
|
1849
|
+
export function trackerToJSON(object: Tracker): string {
|
|
1850
|
+
switch (object) {
|
|
1851
|
+
case Tracker.TRACKER_UNSPECIFIED:
|
|
1852
|
+
return "TRACKER_UNSPECIFIED";
|
|
1853
|
+
case Tracker.TRACKER_LINEAR:
|
|
1854
|
+
return "TRACKER_LINEAR";
|
|
1855
|
+
case Tracker.UNRECOGNIZED:
|
|
1856
|
+
default:
|
|
1857
|
+
return "UNRECOGNIZED";
|
|
1858
|
+
}
|
|
1859
|
+
}
|
|
1860
|
+
|
|
1861
|
+
/** IssueCostGroupBy mirrors ai.api.v1.IssueCostGroupBy. */
|
|
1862
|
+
export enum IssueCostGroupBy {
|
|
1863
|
+
ISSUE_COST_GROUP_BY_UNSPECIFIED = 0,
|
|
1864
|
+
ISSUE_COST_GROUP_BY_ISSUE = 1,
|
|
1865
|
+
/** ISSUE_COST_GROUP_BY_PARENT - The issue's parent (a Linear project) as last synced, with a "none" group. */
|
|
1866
|
+
ISSUE_COST_GROUP_BY_PARENT = 2,
|
|
1867
|
+
/**
|
|
1868
|
+
* ISSUE_COST_GROUP_BY_ITERATION - The issue's iteration (a Linear cycle) as last synced, with a "none" group: an issue moved to the next cycle
|
|
1869
|
+
* takes its whole cost along.
|
|
1870
|
+
*/
|
|
1871
|
+
ISSUE_COST_GROUP_BY_ITERATION = 3,
|
|
1872
|
+
UNRECOGNIZED = -1,
|
|
1873
|
+
}
|
|
1874
|
+
|
|
1875
|
+
export function issueCostGroupByFromJSON(object: any): IssueCostGroupBy {
|
|
1876
|
+
switch (object) {
|
|
1877
|
+
case 0:
|
|
1878
|
+
case "ISSUE_COST_GROUP_BY_UNSPECIFIED":
|
|
1879
|
+
return IssueCostGroupBy.ISSUE_COST_GROUP_BY_UNSPECIFIED;
|
|
1880
|
+
case 1:
|
|
1881
|
+
case "ISSUE_COST_GROUP_BY_ISSUE":
|
|
1882
|
+
return IssueCostGroupBy.ISSUE_COST_GROUP_BY_ISSUE;
|
|
1883
|
+
case 2:
|
|
1884
|
+
case "ISSUE_COST_GROUP_BY_PARENT":
|
|
1885
|
+
return IssueCostGroupBy.ISSUE_COST_GROUP_BY_PARENT;
|
|
1886
|
+
case 3:
|
|
1887
|
+
case "ISSUE_COST_GROUP_BY_ITERATION":
|
|
1888
|
+
return IssueCostGroupBy.ISSUE_COST_GROUP_BY_ITERATION;
|
|
1889
|
+
case -1:
|
|
1890
|
+
case "UNRECOGNIZED":
|
|
1891
|
+
default:
|
|
1892
|
+
return IssueCostGroupBy.UNRECOGNIZED;
|
|
1893
|
+
}
|
|
1894
|
+
}
|
|
1895
|
+
|
|
1896
|
+
export function issueCostGroupByToJSON(object: IssueCostGroupBy): string {
|
|
1897
|
+
switch (object) {
|
|
1898
|
+
case IssueCostGroupBy.ISSUE_COST_GROUP_BY_UNSPECIFIED:
|
|
1899
|
+
return "ISSUE_COST_GROUP_BY_UNSPECIFIED";
|
|
1900
|
+
case IssueCostGroupBy.ISSUE_COST_GROUP_BY_ISSUE:
|
|
1901
|
+
return "ISSUE_COST_GROUP_BY_ISSUE";
|
|
1902
|
+
case IssueCostGroupBy.ISSUE_COST_GROUP_BY_PARENT:
|
|
1903
|
+
return "ISSUE_COST_GROUP_BY_PARENT";
|
|
1904
|
+
case IssueCostGroupBy.ISSUE_COST_GROUP_BY_ITERATION:
|
|
1905
|
+
return "ISSUE_COST_GROUP_BY_ITERATION";
|
|
1906
|
+
case IssueCostGroupBy.UNRECOGNIZED:
|
|
1907
|
+
default:
|
|
1908
|
+
return "UNRECOGNIZED";
|
|
1909
|
+
}
|
|
1910
|
+
}
|
|
1911
|
+
|
|
1912
|
+
/** IssueCostSort mirrors ai.api.v1.IssueCostSort. Unspecified is COST_DESC. */
|
|
1913
|
+
export enum IssueCostSort {
|
|
1914
|
+
ISSUE_COST_SORT_UNSPECIFIED = 0,
|
|
1915
|
+
/** ISSUE_COST_SORT_COST_DESC - Highest cost first, ties by id ascending. */
|
|
1916
|
+
ISSUE_COST_SORT_COST_DESC = 1,
|
|
1917
|
+
UNRECOGNIZED = -1,
|
|
1918
|
+
}
|
|
1919
|
+
|
|
1920
|
+
export function issueCostSortFromJSON(object: any): IssueCostSort {
|
|
1921
|
+
switch (object) {
|
|
1922
|
+
case 0:
|
|
1923
|
+
case "ISSUE_COST_SORT_UNSPECIFIED":
|
|
1924
|
+
return IssueCostSort.ISSUE_COST_SORT_UNSPECIFIED;
|
|
1925
|
+
case 1:
|
|
1926
|
+
case "ISSUE_COST_SORT_COST_DESC":
|
|
1927
|
+
return IssueCostSort.ISSUE_COST_SORT_COST_DESC;
|
|
1928
|
+
case -1:
|
|
1929
|
+
case "UNRECOGNIZED":
|
|
1930
|
+
default:
|
|
1931
|
+
return IssueCostSort.UNRECOGNIZED;
|
|
1932
|
+
}
|
|
1933
|
+
}
|
|
1934
|
+
|
|
1935
|
+
export function issueCostSortToJSON(object: IssueCostSort): string {
|
|
1936
|
+
switch (object) {
|
|
1937
|
+
case IssueCostSort.ISSUE_COST_SORT_UNSPECIFIED:
|
|
1938
|
+
return "ISSUE_COST_SORT_UNSPECIFIED";
|
|
1939
|
+
case IssueCostSort.ISSUE_COST_SORT_COST_DESC:
|
|
1940
|
+
return "ISSUE_COST_SORT_COST_DESC";
|
|
1941
|
+
case IssueCostSort.UNRECOGNIZED:
|
|
1942
|
+
default:
|
|
1943
|
+
return "UNRECOGNIZED";
|
|
1944
|
+
}
|
|
1945
|
+
}
|
|
1946
|
+
|
|
1947
|
+
/** TrackerSyncState mirrors ai.api.v1.TrackerSyncState. */
|
|
1948
|
+
export enum TrackerSyncState {
|
|
1949
|
+
TRACKER_SYNC_STATE_UNSPECIFIED = 0,
|
|
1950
|
+
/** TRACKER_SYNC_STATE_NOT_CONNECTED - The organization has not connected the tracker: nothing is served. */
|
|
1951
|
+
TRACKER_SYNC_STATE_NOT_CONNECTED = 1,
|
|
1952
|
+
/**
|
|
1953
|
+
* TRACKER_SYNC_STATE_PENDING - Connected, but the first full sync of the connected workspace has not completed (just connected, or reconnected
|
|
1954
|
+
* to another workspace): nothing is served, never an earlier workspace's issues.
|
|
1955
|
+
*/
|
|
1956
|
+
TRACKER_SYNC_STATE_PENDING = 2,
|
|
1957
|
+
/** TRACKER_SYNC_STATE_SYNCED - Served; a sync completed within the last 10 minutes. */
|
|
1958
|
+
TRACKER_SYNC_STATE_SYNCED = 3,
|
|
1959
|
+
/** TRACKER_SYNC_STATE_STALE - Served, but no sync has completed for 10 minutes (last_sync_error says why when the attempts fail). */
|
|
1960
|
+
TRACKER_SYNC_STATE_STALE = 4,
|
|
1961
|
+
UNRECOGNIZED = -1,
|
|
1962
|
+
}
|
|
1963
|
+
|
|
1964
|
+
export function trackerSyncStateFromJSON(object: any): TrackerSyncState {
|
|
1965
|
+
switch (object) {
|
|
1966
|
+
case 0:
|
|
1967
|
+
case "TRACKER_SYNC_STATE_UNSPECIFIED":
|
|
1968
|
+
return TrackerSyncState.TRACKER_SYNC_STATE_UNSPECIFIED;
|
|
1969
|
+
case 1:
|
|
1970
|
+
case "TRACKER_SYNC_STATE_NOT_CONNECTED":
|
|
1971
|
+
return TrackerSyncState.TRACKER_SYNC_STATE_NOT_CONNECTED;
|
|
1972
|
+
case 2:
|
|
1973
|
+
case "TRACKER_SYNC_STATE_PENDING":
|
|
1974
|
+
return TrackerSyncState.TRACKER_SYNC_STATE_PENDING;
|
|
1975
|
+
case 3:
|
|
1976
|
+
case "TRACKER_SYNC_STATE_SYNCED":
|
|
1977
|
+
return TrackerSyncState.TRACKER_SYNC_STATE_SYNCED;
|
|
1978
|
+
case 4:
|
|
1979
|
+
case "TRACKER_SYNC_STATE_STALE":
|
|
1980
|
+
return TrackerSyncState.TRACKER_SYNC_STATE_STALE;
|
|
1981
|
+
case -1:
|
|
1982
|
+
case "UNRECOGNIZED":
|
|
1983
|
+
default:
|
|
1984
|
+
return TrackerSyncState.UNRECOGNIZED;
|
|
1985
|
+
}
|
|
1986
|
+
}
|
|
1987
|
+
|
|
1988
|
+
export function trackerSyncStateToJSON(object: TrackerSyncState): string {
|
|
1989
|
+
switch (object) {
|
|
1990
|
+
case TrackerSyncState.TRACKER_SYNC_STATE_UNSPECIFIED:
|
|
1991
|
+
return "TRACKER_SYNC_STATE_UNSPECIFIED";
|
|
1992
|
+
case TrackerSyncState.TRACKER_SYNC_STATE_NOT_CONNECTED:
|
|
1993
|
+
return "TRACKER_SYNC_STATE_NOT_CONNECTED";
|
|
1994
|
+
case TrackerSyncState.TRACKER_SYNC_STATE_PENDING:
|
|
1995
|
+
return "TRACKER_SYNC_STATE_PENDING";
|
|
1996
|
+
case TrackerSyncState.TRACKER_SYNC_STATE_SYNCED:
|
|
1997
|
+
return "TRACKER_SYNC_STATE_SYNCED";
|
|
1998
|
+
case TrackerSyncState.TRACKER_SYNC_STATE_STALE:
|
|
1999
|
+
return "TRACKER_SYNC_STATE_STALE";
|
|
2000
|
+
case TrackerSyncState.UNRECOGNIZED:
|
|
2001
|
+
default:
|
|
2002
|
+
return "UNRECOGNIZED";
|
|
2003
|
+
}
|
|
2004
|
+
}
|
|
2005
|
+
|
|
2006
|
+
/** TrackerSyncError mirrors ai.api.v1.TrackerSyncError. */
|
|
2007
|
+
export enum TrackerSyncError {
|
|
2008
|
+
TRACKER_SYNC_ERROR_UNSPECIFIED = 0,
|
|
2009
|
+
/** TRACKER_SYNC_ERROR_UNAUTHORIZED - The tracker refused the token: revoked, or the app uninstalled. Reconnecting fixes it. */
|
|
2010
|
+
TRACKER_SYNC_ERROR_UNAUTHORIZED = 1,
|
|
2011
|
+
TRACKER_SYNC_ERROR_RATE_LIMITED = 2,
|
|
2012
|
+
/** TRACKER_SYNC_ERROR_UNAVAILABLE - The tracker was down or slow. */
|
|
2013
|
+
TRACKER_SYNC_ERROR_UNAVAILABLE = 3,
|
|
2014
|
+
/** TRACKER_SYNC_ERROR_REJECTED - The tracker refused a request. */
|
|
2015
|
+
TRACKER_SYNC_ERROR_REJECTED = 4,
|
|
2016
|
+
/** TRACKER_SYNC_ERROR_UNREADABLE - The tracker sent what Terma could not use. */
|
|
2017
|
+
TRACKER_SYNC_ERROR_UNREADABLE = 5,
|
|
2018
|
+
/** TRACKER_SYNC_ERROR_WORKSPACE_CHANGED - The token reads another workspace than the connection names: a reconnect is landing. */
|
|
2019
|
+
TRACKER_SYNC_ERROR_WORKSPACE_CHANGED = 6,
|
|
2020
|
+
/** TRACKER_SYNC_ERROR_INTERNAL - Terma's own failure. */
|
|
2021
|
+
TRACKER_SYNC_ERROR_INTERNAL = 7,
|
|
2022
|
+
UNRECOGNIZED = -1,
|
|
2023
|
+
}
|
|
2024
|
+
|
|
2025
|
+
export function trackerSyncErrorFromJSON(object: any): TrackerSyncError {
|
|
2026
|
+
switch (object) {
|
|
2027
|
+
case 0:
|
|
2028
|
+
case "TRACKER_SYNC_ERROR_UNSPECIFIED":
|
|
2029
|
+
return TrackerSyncError.TRACKER_SYNC_ERROR_UNSPECIFIED;
|
|
2030
|
+
case 1:
|
|
2031
|
+
case "TRACKER_SYNC_ERROR_UNAUTHORIZED":
|
|
2032
|
+
return TrackerSyncError.TRACKER_SYNC_ERROR_UNAUTHORIZED;
|
|
2033
|
+
case 2:
|
|
2034
|
+
case "TRACKER_SYNC_ERROR_RATE_LIMITED":
|
|
2035
|
+
return TrackerSyncError.TRACKER_SYNC_ERROR_RATE_LIMITED;
|
|
2036
|
+
case 3:
|
|
2037
|
+
case "TRACKER_SYNC_ERROR_UNAVAILABLE":
|
|
2038
|
+
return TrackerSyncError.TRACKER_SYNC_ERROR_UNAVAILABLE;
|
|
2039
|
+
case 4:
|
|
2040
|
+
case "TRACKER_SYNC_ERROR_REJECTED":
|
|
2041
|
+
return TrackerSyncError.TRACKER_SYNC_ERROR_REJECTED;
|
|
2042
|
+
case 5:
|
|
2043
|
+
case "TRACKER_SYNC_ERROR_UNREADABLE":
|
|
2044
|
+
return TrackerSyncError.TRACKER_SYNC_ERROR_UNREADABLE;
|
|
2045
|
+
case 6:
|
|
2046
|
+
case "TRACKER_SYNC_ERROR_WORKSPACE_CHANGED":
|
|
2047
|
+
return TrackerSyncError.TRACKER_SYNC_ERROR_WORKSPACE_CHANGED;
|
|
2048
|
+
case 7:
|
|
2049
|
+
case "TRACKER_SYNC_ERROR_INTERNAL":
|
|
2050
|
+
return TrackerSyncError.TRACKER_SYNC_ERROR_INTERNAL;
|
|
2051
|
+
case -1:
|
|
2052
|
+
case "UNRECOGNIZED":
|
|
2053
|
+
default:
|
|
2054
|
+
return TrackerSyncError.UNRECOGNIZED;
|
|
2055
|
+
}
|
|
2056
|
+
}
|
|
2057
|
+
|
|
2058
|
+
export function trackerSyncErrorToJSON(object: TrackerSyncError): string {
|
|
2059
|
+
switch (object) {
|
|
2060
|
+
case TrackerSyncError.TRACKER_SYNC_ERROR_UNSPECIFIED:
|
|
2061
|
+
return "TRACKER_SYNC_ERROR_UNSPECIFIED";
|
|
2062
|
+
case TrackerSyncError.TRACKER_SYNC_ERROR_UNAUTHORIZED:
|
|
2063
|
+
return "TRACKER_SYNC_ERROR_UNAUTHORIZED";
|
|
2064
|
+
case TrackerSyncError.TRACKER_SYNC_ERROR_RATE_LIMITED:
|
|
2065
|
+
return "TRACKER_SYNC_ERROR_RATE_LIMITED";
|
|
2066
|
+
case TrackerSyncError.TRACKER_SYNC_ERROR_UNAVAILABLE:
|
|
2067
|
+
return "TRACKER_SYNC_ERROR_UNAVAILABLE";
|
|
2068
|
+
case TrackerSyncError.TRACKER_SYNC_ERROR_REJECTED:
|
|
2069
|
+
return "TRACKER_SYNC_ERROR_REJECTED";
|
|
2070
|
+
case TrackerSyncError.TRACKER_SYNC_ERROR_UNREADABLE:
|
|
2071
|
+
return "TRACKER_SYNC_ERROR_UNREADABLE";
|
|
2072
|
+
case TrackerSyncError.TRACKER_SYNC_ERROR_WORKSPACE_CHANGED:
|
|
2073
|
+
return "TRACKER_SYNC_ERROR_WORKSPACE_CHANGED";
|
|
2074
|
+
case TrackerSyncError.TRACKER_SYNC_ERROR_INTERNAL:
|
|
2075
|
+
return "TRACKER_SYNC_ERROR_INTERNAL";
|
|
2076
|
+
case TrackerSyncError.UNRECOGNIZED:
|
|
2077
|
+
default:
|
|
2078
|
+
return "UNRECOGNIZED";
|
|
2079
|
+
}
|
|
2080
|
+
}
|
|
2081
|
+
|
|
1827
2082
|
export interface ListSessionsRequest {
|
|
1828
2083
|
organizationId: string;
|
|
1829
2084
|
projectId: string;
|
|
@@ -3822,6 +4077,137 @@ export interface RelayHeartbeatFilter {
|
|
|
3822
4077
|
lastSeenBefore: Date | undefined;
|
|
3823
4078
|
}
|
|
3824
4079
|
|
|
4080
|
+
export interface ListIssueCostsRequest {
|
|
4081
|
+
organizationId: string;
|
|
4082
|
+
/**
|
|
4083
|
+
* The tracker whose issues receive the cost; with organization_id, the connected tracker the collection belongs to.
|
|
4084
|
+
* UNSPECIFIED is a validation error.
|
|
4085
|
+
*/
|
|
4086
|
+
tracker: Tracker;
|
|
4087
|
+
/** What each row is; UNSPECIFIED is a validation error. */
|
|
4088
|
+
groupBy: IssueCostGroupBy;
|
|
4089
|
+
filter:
|
|
4090
|
+
| IssueCostFilter
|
|
4091
|
+
| undefined;
|
|
4092
|
+
/** Unspecified is ISSUE_COST_SORT_COST_DESC. */
|
|
4093
|
+
sort: IssueCostSort;
|
|
4094
|
+
/** 1-indexed page; 1 when 0. */
|
|
4095
|
+
page: number;
|
|
4096
|
+
/** 100 when 0, at most 1000. */
|
|
4097
|
+
perPage: number;
|
|
4098
|
+
}
|
|
4099
|
+
|
|
4100
|
+
/**
|
|
4101
|
+
* IssueCostFilter narrows ListIssueCosts. Fields AND; a repeated field matches any of its values; an unset or empty
|
|
4102
|
+
* field does not filter. The window picks the sessions whose cost is split, by each session's start; parent_ids and
|
|
4103
|
+
* iteration_ids pick the issues whose shares make the groups, by the issue's parent and iteration as last synced,
|
|
4104
|
+
* after the split, and change only filtered_cost_usd_nanos of the totals. More than 500 ids in either list is a
|
|
4105
|
+
* validation error.
|
|
4106
|
+
*/
|
|
4107
|
+
export interface IssueCostFilter {
|
|
4108
|
+
/**
|
|
4109
|
+
* [start_time, end_time); an unset bound leaves that side open. end_time at or before start_time is a validation
|
|
4110
|
+
* error.
|
|
4111
|
+
*/
|
|
4112
|
+
startTime: Date | undefined;
|
|
4113
|
+
endTime:
|
|
4114
|
+
| Date
|
|
4115
|
+
| undefined;
|
|
4116
|
+
/** The tracker's parent ids (Linear project ids); "" matches an issue with no parent. */
|
|
4117
|
+
parentIds: string[];
|
|
4118
|
+
/** The tracker's iteration ids (Linear cycle ids); "" matches an issue in no iteration. */
|
|
4119
|
+
iterationIds: string[];
|
|
4120
|
+
}
|
|
4121
|
+
|
|
4122
|
+
export interface ListIssueCostsResponse {
|
|
4123
|
+
status:
|
|
4124
|
+
| ResponseStatus
|
|
4125
|
+
| undefined;
|
|
4126
|
+
/** Whether the issues are served: groups are empty and pagination and totals absent unless it is SYNCED or STALE. */
|
|
4127
|
+
syncState: TrackerSyncState;
|
|
4128
|
+
/**
|
|
4129
|
+
* When a sync of the connected workspace last completed. Not a snapshot boundary: the issues served are the stored
|
|
4130
|
+
* ones, which can include pages a later sync wrote before failing, and deleted issues, detached pull requests and
|
|
4131
|
+
* teams made private leave only at the hourly full pass. Absent unless served.
|
|
4132
|
+
*/
|
|
4133
|
+
lastSyncedAt:
|
|
4134
|
+
| Date
|
|
4135
|
+
| undefined;
|
|
4136
|
+
/**
|
|
4137
|
+
* Why the latest sync attempt of the connected workspace failed; unspecified when it succeeded or none was made. Set
|
|
4138
|
+
* while PENDING when the first sync fails, which then does not complete until the cause is fixed.
|
|
4139
|
+
*/
|
|
4140
|
+
lastSyncError: TrackerSyncError;
|
|
4141
|
+
groups: IssueCostGroup[];
|
|
4142
|
+
pagination: IssueCostPagination | undefined;
|
|
4143
|
+
totals: IssueCostTotals | undefined;
|
|
4144
|
+
}
|
|
4145
|
+
|
|
4146
|
+
/**
|
|
4147
|
+
* IssueCostGroup is one issue, parent or iteration with the cost its issues received. A group appears once a session
|
|
4148
|
+
* in the window gave it a share, $0 shares included.
|
|
4149
|
+
*/
|
|
4150
|
+
export interface IssueCostGroup {
|
|
4151
|
+
/** The issue's, parent's or iteration's id; "" is the group of issues with no parent or in no iteration. */
|
|
4152
|
+
id: string;
|
|
4153
|
+
/**
|
|
4154
|
+
* The issue's title or the parent's or iteration's name, display only: of a parent or iteration, the name its most
|
|
4155
|
+
* recently synced issue carries. "" for the "none" group.
|
|
4156
|
+
*/
|
|
4157
|
+
name: string;
|
|
4158
|
+
/** Attributed recorded cost in nanodollars. */
|
|
4159
|
+
costUsdNanos: string;
|
|
4160
|
+
/** The distinct sessions that gave the group a share. */
|
|
4161
|
+
sessionCount: number;
|
|
4162
|
+
/** The distinct pull requests a share reached the group through. */
|
|
4163
|
+
pullRequestCount: number;
|
|
4164
|
+
/** On ISSUE, the issue as the last sync read it; absent otherwise. */
|
|
4165
|
+
issue: TrackerIssue | undefined;
|
|
4166
|
+
}
|
|
4167
|
+
|
|
4168
|
+
/** TrackerIssue is an issue as the tracker reported it, display only apart from its ids. */
|
|
4169
|
+
export interface TrackerIssue {
|
|
4170
|
+
/** The tracker's key (MIR-298), which changes when the issue moves team; IssueCostGroup.id is stable. */
|
|
4171
|
+
key: string;
|
|
4172
|
+
/** The workflow state's name (In Review). */
|
|
4173
|
+
state: string;
|
|
4174
|
+
url: string;
|
|
4175
|
+
/** "" when it has none. */
|
|
4176
|
+
parentId: string;
|
|
4177
|
+
parentName: string;
|
|
4178
|
+
/** "" when it is in none. */
|
|
4179
|
+
iterationId: string;
|
|
4180
|
+
iterationName: string;
|
|
4181
|
+
/** Absent unless the issue is archived. */
|
|
4182
|
+
archivedAt: Date | undefined;
|
|
4183
|
+
}
|
|
4184
|
+
|
|
4185
|
+
export interface IssueCostPagination {
|
|
4186
|
+
page: number;
|
|
4187
|
+
perPage: number;
|
|
4188
|
+
/** Every group the filter keeps, across pages, computed on every call. */
|
|
4189
|
+
totalCount: number;
|
|
4190
|
+
totalPages: number;
|
|
4191
|
+
}
|
|
4192
|
+
|
|
4193
|
+
/**
|
|
4194
|
+
* IssueCostTotals is the cost of the sessions that started in the window, over the whole organization, in nanodollars.
|
|
4195
|
+
* recorded is exactly attributed + no_pull_request + unlinked_pull_request, whatever parent_ids and iteration_ids say;
|
|
4196
|
+
* filtered is the part of attributed the groups the filter keeps received.
|
|
4197
|
+
*/
|
|
4198
|
+
export interface IssueCostTotals {
|
|
4199
|
+
/** The sessions' recorded cost. */
|
|
4200
|
+
recordedCostUsdNanos: string;
|
|
4201
|
+
/** The shares issues received. */
|
|
4202
|
+
attributedCostUsdNanos: string;
|
|
4203
|
+
/** Sessions that link to no pull request. */
|
|
4204
|
+
noPullRequestCostUsdNanos: string;
|
|
4205
|
+
/** Shares of pull requests the tracker attaches to no served issue (a private team's issues are never served). */
|
|
4206
|
+
unlinkedPullRequestCostUsdNanos: string;
|
|
4207
|
+
/** Every group the filter keeps, across pages: attributed when parent_ids and iteration_ids are unset. */
|
|
4208
|
+
filteredCostUsdNanos: string;
|
|
4209
|
+
}
|
|
4210
|
+
|
|
3825
4211
|
function createBaseListSessionsRequest(): ListSessionsRequest {
|
|
3826
4212
|
return { organizationId: "", projectId: "", filter: undefined, sort: 0, page: 0, perPage: 0 };
|
|
3827
4213
|
}
|
|
@@ -28118,108 +28504,1272 @@ export const RelayHeartbeatFilter: MessageFns<RelayHeartbeatFilter> = {
|
|
|
28118
28504
|
},
|
|
28119
28505
|
};
|
|
28120
28506
|
|
|
28121
|
-
|
|
28122
|
-
|
|
28123
|
-
|
|
28124
|
-
|
|
28125
|
-
export
|
|
28126
|
-
|
|
28127
|
-
|
|
28128
|
-
|
|
28129
|
-
|
|
28130
|
-
|
|
28131
|
-
|
|
28132
|
-
|
|
28133
|
-
|
|
28134
|
-
|
|
28135
|
-
|
|
28136
|
-
|
|
28137
|
-
|
|
28138
|
-
|
|
28139
|
-
|
|
28140
|
-
|
|
28141
|
-
|
|
28142
|
-
|
|
28143
|
-
|
|
28144
|
-
|
|
28145
|
-
|
|
28146
|
-
|
|
28147
|
-
|
|
28148
|
-
|
|
28149
|
-
|
|
28150
|
-
|
|
28151
|
-
|
|
28152
|
-
|
|
28153
|
-
|
|
28154
|
-
|
|
28155
|
-
|
|
28156
|
-
|
|
28157
|
-
|
|
28158
|
-
|
|
28159
|
-
|
|
28160
|
-
|
|
28161
|
-
|
|
28162
|
-
|
|
28163
|
-
|
|
28164
|
-
|
|
28165
|
-
|
|
28166
|
-
|
|
28167
|
-
|
|
28168
|
-
|
|
28169
|
-
|
|
28170
|
-
|
|
28171
|
-
|
|
28172
|
-
|
|
28173
|
-
|
|
28174
|
-
|
|
28175
|
-
|
|
28176
|
-
|
|
28177
|
-
|
|
28178
|
-
|
|
28179
|
-
|
|
28180
|
-
|
|
28181
|
-
|
|
28182
|
-
|
|
28183
|
-
|
|
28184
|
-
|
|
28185
|
-
|
|
28186
|
-
|
|
28187
|
-
|
|
28188
|
-
|
|
28189
|
-
|
|
28190
|
-
|
|
28191
|
-
|
|
28192
|
-
|
|
28193
|
-
|
|
28194
|
-
|
|
28195
|
-
|
|
28196
|
-
|
|
28197
|
-
|
|
28198
|
-
|
|
28199
|
-
|
|
28200
|
-
|
|
28201
|
-
|
|
28202
|
-
|
|
28203
|
-
|
|
28204
|
-
|
|
28205
|
-
|
|
28206
|
-
|
|
28207
|
-
|
|
28208
|
-
|
|
28209
|
-
|
|
28210
|
-
|
|
28211
|
-
|
|
28212
|
-
|
|
28213
|
-
|
|
28214
|
-
|
|
28215
|
-
|
|
28216
|
-
|
|
28217
|
-
|
|
28218
|
-
|
|
28219
|
-
|
|
28220
|
-
|
|
28221
|
-
|
|
28222
|
-
|
|
28507
|
+
function createBaseListIssueCostsRequest(): ListIssueCostsRequest {
|
|
28508
|
+
return { organizationId: "", tracker: 0, groupBy: 0, filter: undefined, sort: 0, page: 0, perPage: 0 };
|
|
28509
|
+
}
|
|
28510
|
+
|
|
28511
|
+
export const ListIssueCostsRequest: MessageFns<ListIssueCostsRequest> = {
|
|
28512
|
+
encode(message: ListIssueCostsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
|
|
28513
|
+
if (message.organizationId !== "") {
|
|
28514
|
+
writer.uint32(10).string(message.organizationId);
|
|
28515
|
+
}
|
|
28516
|
+
if (message.tracker !== 0) {
|
|
28517
|
+
writer.uint32(16).int32(message.tracker);
|
|
28518
|
+
}
|
|
28519
|
+
if (message.groupBy !== 0) {
|
|
28520
|
+
writer.uint32(24).int32(message.groupBy);
|
|
28521
|
+
}
|
|
28522
|
+
if (message.filter !== undefined) {
|
|
28523
|
+
IssueCostFilter.encode(message.filter, writer.uint32(34).fork()).join();
|
|
28524
|
+
}
|
|
28525
|
+
if (message.sort !== 0) {
|
|
28526
|
+
writer.uint32(40).int32(message.sort);
|
|
28527
|
+
}
|
|
28528
|
+
if (message.page !== 0) {
|
|
28529
|
+
writer.uint32(48).int32(message.page);
|
|
28530
|
+
}
|
|
28531
|
+
if (message.perPage !== 0) {
|
|
28532
|
+
writer.uint32(56).int32(message.perPage);
|
|
28533
|
+
}
|
|
28534
|
+
return writer;
|
|
28535
|
+
},
|
|
28536
|
+
|
|
28537
|
+
decode(input: BinaryReader | Uint8Array, length?: number): ListIssueCostsRequest {
|
|
28538
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
28539
|
+
const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
|
|
28540
|
+
if (previousRecursionDepth >= 100) {
|
|
28541
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
28542
|
+
}
|
|
28543
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
28544
|
+
try {
|
|
28545
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
28546
|
+
const message = createBaseListIssueCostsRequest();
|
|
28547
|
+
while (reader.pos < end) {
|
|
28548
|
+
const tag = reader.uint32();
|
|
28549
|
+
switch (tag >>> 3) {
|
|
28550
|
+
case 1: {
|
|
28551
|
+
if (tag !== 10) {
|
|
28552
|
+
break;
|
|
28553
|
+
}
|
|
28554
|
+
|
|
28555
|
+
message.organizationId = reader.string();
|
|
28556
|
+
continue;
|
|
28557
|
+
}
|
|
28558
|
+
case 2: {
|
|
28559
|
+
if (tag !== 16) {
|
|
28560
|
+
break;
|
|
28561
|
+
}
|
|
28562
|
+
|
|
28563
|
+
message.tracker = reader.int32() as any;
|
|
28564
|
+
continue;
|
|
28565
|
+
}
|
|
28566
|
+
case 3: {
|
|
28567
|
+
if (tag !== 24) {
|
|
28568
|
+
break;
|
|
28569
|
+
}
|
|
28570
|
+
|
|
28571
|
+
message.groupBy = reader.int32() as any;
|
|
28572
|
+
continue;
|
|
28573
|
+
}
|
|
28574
|
+
case 4: {
|
|
28575
|
+
if (tag !== 34) {
|
|
28576
|
+
break;
|
|
28577
|
+
}
|
|
28578
|
+
|
|
28579
|
+
message.filter = IssueCostFilter.decode(reader, reader.uint32());
|
|
28580
|
+
continue;
|
|
28581
|
+
}
|
|
28582
|
+
case 5: {
|
|
28583
|
+
if (tag !== 40) {
|
|
28584
|
+
break;
|
|
28585
|
+
}
|
|
28586
|
+
|
|
28587
|
+
message.sort = reader.int32() as any;
|
|
28588
|
+
continue;
|
|
28589
|
+
}
|
|
28590
|
+
case 6: {
|
|
28591
|
+
if (tag !== 48) {
|
|
28592
|
+
break;
|
|
28593
|
+
}
|
|
28594
|
+
|
|
28595
|
+
message.page = reader.int32();
|
|
28596
|
+
continue;
|
|
28597
|
+
}
|
|
28598
|
+
case 7: {
|
|
28599
|
+
if (tag !== 56) {
|
|
28600
|
+
break;
|
|
28601
|
+
}
|
|
28602
|
+
|
|
28603
|
+
message.perPage = reader.int32();
|
|
28604
|
+
continue;
|
|
28605
|
+
}
|
|
28606
|
+
}
|
|
28607
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
28608
|
+
break;
|
|
28609
|
+
}
|
|
28610
|
+
reader.skip(tag & 7);
|
|
28611
|
+
}
|
|
28612
|
+
return message;
|
|
28613
|
+
} finally {
|
|
28614
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
|
|
28615
|
+
}
|
|
28616
|
+
},
|
|
28617
|
+
|
|
28618
|
+
fromJSON(object: any): ListIssueCostsRequest {
|
|
28619
|
+
return {
|
|
28620
|
+
organizationId: isSet(object.organizationId)
|
|
28621
|
+
? globalThis.String(object.organizationId)
|
|
28622
|
+
: isSet(object.organization_id)
|
|
28623
|
+
? globalThis.String(object.organization_id)
|
|
28624
|
+
: "",
|
|
28625
|
+
tracker: isSet(object.tracker) ? trackerFromJSON(object.tracker) : 0,
|
|
28626
|
+
groupBy: isSet(object.groupBy)
|
|
28627
|
+
? issueCostGroupByFromJSON(object.groupBy)
|
|
28628
|
+
: isSet(object.group_by)
|
|
28629
|
+
? issueCostGroupByFromJSON(object.group_by)
|
|
28630
|
+
: 0,
|
|
28631
|
+
filter: isSet(object.filter) ? IssueCostFilter.fromJSON(object.filter) : undefined,
|
|
28632
|
+
sort: isSet(object.sort) ? issueCostSortFromJSON(object.sort) : 0,
|
|
28633
|
+
page: isSet(object.page) ? globalThis.Number(object.page) : 0,
|
|
28634
|
+
perPage: isSet(object.perPage)
|
|
28635
|
+
? globalThis.Number(object.perPage)
|
|
28636
|
+
: isSet(object.per_page)
|
|
28637
|
+
? globalThis.Number(object.per_page)
|
|
28638
|
+
: 0,
|
|
28639
|
+
};
|
|
28640
|
+
},
|
|
28641
|
+
|
|
28642
|
+
toJSON(message: ListIssueCostsRequest): unknown {
|
|
28643
|
+
const obj: any = {};
|
|
28644
|
+
if (message.organizationId !== "") {
|
|
28645
|
+
obj.organizationId = message.organizationId;
|
|
28646
|
+
}
|
|
28647
|
+
if (message.tracker !== 0) {
|
|
28648
|
+
obj.tracker = trackerToJSON(message.tracker);
|
|
28649
|
+
}
|
|
28650
|
+
if (message.groupBy !== 0) {
|
|
28651
|
+
obj.groupBy = issueCostGroupByToJSON(message.groupBy);
|
|
28652
|
+
}
|
|
28653
|
+
if (message.filter !== undefined) {
|
|
28654
|
+
obj.filter = IssueCostFilter.toJSON(message.filter);
|
|
28655
|
+
}
|
|
28656
|
+
if (message.sort !== 0) {
|
|
28657
|
+
obj.sort = issueCostSortToJSON(message.sort);
|
|
28658
|
+
}
|
|
28659
|
+
if (message.page !== 0) {
|
|
28660
|
+
obj.page = Math.round(message.page);
|
|
28661
|
+
}
|
|
28662
|
+
if (message.perPage !== 0) {
|
|
28663
|
+
obj.perPage = Math.round(message.perPage);
|
|
28664
|
+
}
|
|
28665
|
+
return obj;
|
|
28666
|
+
},
|
|
28667
|
+
|
|
28668
|
+
create<I extends Exact<DeepPartial<ListIssueCostsRequest>, I>>(base?: I): ListIssueCostsRequest {
|
|
28669
|
+
return ListIssueCostsRequest.fromPartial(base ?? ({} as any));
|
|
28670
|
+
},
|
|
28671
|
+
fromPartial<I extends Exact<DeepPartial<ListIssueCostsRequest>, I>>(object: I): ListIssueCostsRequest {
|
|
28672
|
+
const message = createBaseListIssueCostsRequest();
|
|
28673
|
+
message.organizationId = object.organizationId ?? "";
|
|
28674
|
+
message.tracker = object.tracker ?? 0;
|
|
28675
|
+
message.groupBy = object.groupBy ?? 0;
|
|
28676
|
+
message.filter = (object.filter !== undefined && object.filter !== null)
|
|
28677
|
+
? IssueCostFilter.fromPartial(object.filter)
|
|
28678
|
+
: undefined;
|
|
28679
|
+
message.sort = object.sort ?? 0;
|
|
28680
|
+
message.page = object.page ?? 0;
|
|
28681
|
+
message.perPage = object.perPage ?? 0;
|
|
28682
|
+
return message;
|
|
28683
|
+
},
|
|
28684
|
+
};
|
|
28685
|
+
|
|
28686
|
+
function createBaseIssueCostFilter(): IssueCostFilter {
|
|
28687
|
+
return { startTime: undefined, endTime: undefined, parentIds: [], iterationIds: [] };
|
|
28688
|
+
}
|
|
28689
|
+
|
|
28690
|
+
export const IssueCostFilter: MessageFns<IssueCostFilter> = {
|
|
28691
|
+
encode(message: IssueCostFilter, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
|
|
28692
|
+
if (message.startTime !== undefined) {
|
|
28693
|
+
Timestamp.encode(toTimestamp(message.startTime), writer.uint32(10).fork()).join();
|
|
28694
|
+
}
|
|
28695
|
+
if (message.endTime !== undefined) {
|
|
28696
|
+
Timestamp.encode(toTimestamp(message.endTime), writer.uint32(18).fork()).join();
|
|
28697
|
+
}
|
|
28698
|
+
for (const v of message.parentIds) {
|
|
28699
|
+
writer.uint32(26).string(v!);
|
|
28700
|
+
}
|
|
28701
|
+
for (const v of message.iterationIds) {
|
|
28702
|
+
writer.uint32(34).string(v!);
|
|
28703
|
+
}
|
|
28704
|
+
return writer;
|
|
28705
|
+
},
|
|
28706
|
+
|
|
28707
|
+
decode(input: BinaryReader | Uint8Array, length?: number): IssueCostFilter {
|
|
28708
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
28709
|
+
const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
|
|
28710
|
+
if (previousRecursionDepth >= 100) {
|
|
28711
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
28712
|
+
}
|
|
28713
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
28714
|
+
try {
|
|
28715
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
28716
|
+
const message = createBaseIssueCostFilter();
|
|
28717
|
+
while (reader.pos < end) {
|
|
28718
|
+
const tag = reader.uint32();
|
|
28719
|
+
switch (tag >>> 3) {
|
|
28720
|
+
case 1: {
|
|
28721
|
+
if (tag !== 10) {
|
|
28722
|
+
break;
|
|
28723
|
+
}
|
|
28724
|
+
|
|
28725
|
+
message.startTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
|
|
28726
|
+
continue;
|
|
28727
|
+
}
|
|
28728
|
+
case 2: {
|
|
28729
|
+
if (tag !== 18) {
|
|
28730
|
+
break;
|
|
28731
|
+
}
|
|
28732
|
+
|
|
28733
|
+
message.endTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
|
|
28734
|
+
continue;
|
|
28735
|
+
}
|
|
28736
|
+
case 3: {
|
|
28737
|
+
if (tag !== 26) {
|
|
28738
|
+
break;
|
|
28739
|
+
}
|
|
28740
|
+
|
|
28741
|
+
message.parentIds.push(reader.string());
|
|
28742
|
+
continue;
|
|
28743
|
+
}
|
|
28744
|
+
case 4: {
|
|
28745
|
+
if (tag !== 34) {
|
|
28746
|
+
break;
|
|
28747
|
+
}
|
|
28748
|
+
|
|
28749
|
+
message.iterationIds.push(reader.string());
|
|
28750
|
+
continue;
|
|
28751
|
+
}
|
|
28752
|
+
}
|
|
28753
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
28754
|
+
break;
|
|
28755
|
+
}
|
|
28756
|
+
reader.skip(tag & 7);
|
|
28757
|
+
}
|
|
28758
|
+
return message;
|
|
28759
|
+
} finally {
|
|
28760
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
|
|
28761
|
+
}
|
|
28762
|
+
},
|
|
28763
|
+
|
|
28764
|
+
fromJSON(object: any): IssueCostFilter {
|
|
28765
|
+
return {
|
|
28766
|
+
startTime: isSet(object.startTime)
|
|
28767
|
+
? fromJsonTimestamp(object.startTime)
|
|
28768
|
+
: isSet(object.start_time)
|
|
28769
|
+
? fromJsonTimestamp(object.start_time)
|
|
28770
|
+
: undefined,
|
|
28771
|
+
endTime: isSet(object.endTime)
|
|
28772
|
+
? fromJsonTimestamp(object.endTime)
|
|
28773
|
+
: isSet(object.end_time)
|
|
28774
|
+
? fromJsonTimestamp(object.end_time)
|
|
28775
|
+
: undefined,
|
|
28776
|
+
parentIds: globalThis.Array.isArray(object?.parentIds)
|
|
28777
|
+
? object.parentIds.map((e: any) => globalThis.String(e))
|
|
28778
|
+
: globalThis.Array.isArray(object?.parent_ids)
|
|
28779
|
+
? object.parent_ids.map((e: any) => globalThis.String(e))
|
|
28780
|
+
: [],
|
|
28781
|
+
iterationIds: globalThis.Array.isArray(object?.iterationIds)
|
|
28782
|
+
? object.iterationIds.map((e: any) => globalThis.String(e))
|
|
28783
|
+
: globalThis.Array.isArray(object?.iteration_ids)
|
|
28784
|
+
? object.iteration_ids.map((e: any) => globalThis.String(e))
|
|
28785
|
+
: [],
|
|
28786
|
+
};
|
|
28787
|
+
},
|
|
28788
|
+
|
|
28789
|
+
toJSON(message: IssueCostFilter): unknown {
|
|
28790
|
+
const obj: any = {};
|
|
28791
|
+
if (message.startTime !== undefined) {
|
|
28792
|
+
obj.startTime = message.startTime.toISOString();
|
|
28793
|
+
}
|
|
28794
|
+
if (message.endTime !== undefined) {
|
|
28795
|
+
obj.endTime = message.endTime.toISOString();
|
|
28796
|
+
}
|
|
28797
|
+
if (message.parentIds?.length) {
|
|
28798
|
+
obj.parentIds = message.parentIds;
|
|
28799
|
+
}
|
|
28800
|
+
if (message.iterationIds?.length) {
|
|
28801
|
+
obj.iterationIds = message.iterationIds;
|
|
28802
|
+
}
|
|
28803
|
+
return obj;
|
|
28804
|
+
},
|
|
28805
|
+
|
|
28806
|
+
create<I extends Exact<DeepPartial<IssueCostFilter>, I>>(base?: I): IssueCostFilter {
|
|
28807
|
+
return IssueCostFilter.fromPartial(base ?? ({} as any));
|
|
28808
|
+
},
|
|
28809
|
+
fromPartial<I extends Exact<DeepPartial<IssueCostFilter>, I>>(object: I): IssueCostFilter {
|
|
28810
|
+
const message = createBaseIssueCostFilter();
|
|
28811
|
+
message.startTime = object.startTime ?? undefined;
|
|
28812
|
+
message.endTime = object.endTime ?? undefined;
|
|
28813
|
+
message.parentIds = object.parentIds?.map((e) => e) || [];
|
|
28814
|
+
message.iterationIds = object.iterationIds?.map((e) => e) || [];
|
|
28815
|
+
return message;
|
|
28816
|
+
},
|
|
28817
|
+
};
|
|
28818
|
+
|
|
28819
|
+
function createBaseListIssueCostsResponse(): ListIssueCostsResponse {
|
|
28820
|
+
return {
|
|
28821
|
+
status: undefined,
|
|
28822
|
+
syncState: 0,
|
|
28823
|
+
lastSyncedAt: undefined,
|
|
28824
|
+
lastSyncError: 0,
|
|
28825
|
+
groups: [],
|
|
28826
|
+
pagination: undefined,
|
|
28827
|
+
totals: undefined,
|
|
28828
|
+
};
|
|
28829
|
+
}
|
|
28830
|
+
|
|
28831
|
+
export const ListIssueCostsResponse: MessageFns<ListIssueCostsResponse> = {
|
|
28832
|
+
encode(message: ListIssueCostsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
|
|
28833
|
+
if (message.status !== undefined) {
|
|
28834
|
+
ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
|
|
28835
|
+
}
|
|
28836
|
+
if (message.syncState !== 0) {
|
|
28837
|
+
writer.uint32(16).int32(message.syncState);
|
|
28838
|
+
}
|
|
28839
|
+
if (message.lastSyncedAt !== undefined) {
|
|
28840
|
+
Timestamp.encode(toTimestamp(message.lastSyncedAt), writer.uint32(26).fork()).join();
|
|
28841
|
+
}
|
|
28842
|
+
if (message.lastSyncError !== 0) {
|
|
28843
|
+
writer.uint32(32).int32(message.lastSyncError);
|
|
28844
|
+
}
|
|
28845
|
+
for (const v of message.groups) {
|
|
28846
|
+
IssueCostGroup.encode(v!, writer.uint32(42).fork()).join();
|
|
28847
|
+
}
|
|
28848
|
+
if (message.pagination !== undefined) {
|
|
28849
|
+
IssueCostPagination.encode(message.pagination, writer.uint32(50).fork()).join();
|
|
28850
|
+
}
|
|
28851
|
+
if (message.totals !== undefined) {
|
|
28852
|
+
IssueCostTotals.encode(message.totals, writer.uint32(58).fork()).join();
|
|
28853
|
+
}
|
|
28854
|
+
return writer;
|
|
28855
|
+
},
|
|
28856
|
+
|
|
28857
|
+
decode(input: BinaryReader | Uint8Array, length?: number): ListIssueCostsResponse {
|
|
28858
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
28859
|
+
const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
|
|
28860
|
+
if (previousRecursionDepth >= 100) {
|
|
28861
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
28862
|
+
}
|
|
28863
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
28864
|
+
try {
|
|
28865
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
28866
|
+
const message = createBaseListIssueCostsResponse();
|
|
28867
|
+
while (reader.pos < end) {
|
|
28868
|
+
const tag = reader.uint32();
|
|
28869
|
+
switch (tag >>> 3) {
|
|
28870
|
+
case 1: {
|
|
28871
|
+
if (tag !== 10) {
|
|
28872
|
+
break;
|
|
28873
|
+
}
|
|
28874
|
+
|
|
28875
|
+
message.status = ResponseStatus.decode(reader, reader.uint32());
|
|
28876
|
+
continue;
|
|
28877
|
+
}
|
|
28878
|
+
case 2: {
|
|
28879
|
+
if (tag !== 16) {
|
|
28880
|
+
break;
|
|
28881
|
+
}
|
|
28882
|
+
|
|
28883
|
+
message.syncState = reader.int32() as any;
|
|
28884
|
+
continue;
|
|
28885
|
+
}
|
|
28886
|
+
case 3: {
|
|
28887
|
+
if (tag !== 26) {
|
|
28888
|
+
break;
|
|
28889
|
+
}
|
|
28890
|
+
|
|
28891
|
+
message.lastSyncedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
|
|
28892
|
+
continue;
|
|
28893
|
+
}
|
|
28894
|
+
case 4: {
|
|
28895
|
+
if (tag !== 32) {
|
|
28896
|
+
break;
|
|
28897
|
+
}
|
|
28898
|
+
|
|
28899
|
+
message.lastSyncError = reader.int32() as any;
|
|
28900
|
+
continue;
|
|
28901
|
+
}
|
|
28902
|
+
case 5: {
|
|
28903
|
+
if (tag !== 42) {
|
|
28904
|
+
break;
|
|
28905
|
+
}
|
|
28906
|
+
|
|
28907
|
+
message.groups.push(IssueCostGroup.decode(reader, reader.uint32()));
|
|
28908
|
+
continue;
|
|
28909
|
+
}
|
|
28910
|
+
case 6: {
|
|
28911
|
+
if (tag !== 50) {
|
|
28912
|
+
break;
|
|
28913
|
+
}
|
|
28914
|
+
|
|
28915
|
+
message.pagination = IssueCostPagination.decode(reader, reader.uint32());
|
|
28916
|
+
continue;
|
|
28917
|
+
}
|
|
28918
|
+
case 7: {
|
|
28919
|
+
if (tag !== 58) {
|
|
28920
|
+
break;
|
|
28921
|
+
}
|
|
28922
|
+
|
|
28923
|
+
message.totals = IssueCostTotals.decode(reader, reader.uint32());
|
|
28924
|
+
continue;
|
|
28925
|
+
}
|
|
28926
|
+
}
|
|
28927
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
28928
|
+
break;
|
|
28929
|
+
}
|
|
28930
|
+
reader.skip(tag & 7);
|
|
28931
|
+
}
|
|
28932
|
+
return message;
|
|
28933
|
+
} finally {
|
|
28934
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
|
|
28935
|
+
}
|
|
28936
|
+
},
|
|
28937
|
+
|
|
28938
|
+
fromJSON(object: any): ListIssueCostsResponse {
|
|
28939
|
+
return {
|
|
28940
|
+
status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
|
|
28941
|
+
syncState: isSet(object.syncState)
|
|
28942
|
+
? trackerSyncStateFromJSON(object.syncState)
|
|
28943
|
+
: isSet(object.sync_state)
|
|
28944
|
+
? trackerSyncStateFromJSON(object.sync_state)
|
|
28945
|
+
: 0,
|
|
28946
|
+
lastSyncedAt: isSet(object.lastSyncedAt)
|
|
28947
|
+
? fromJsonTimestamp(object.lastSyncedAt)
|
|
28948
|
+
: isSet(object.last_synced_at)
|
|
28949
|
+
? fromJsonTimestamp(object.last_synced_at)
|
|
28950
|
+
: undefined,
|
|
28951
|
+
lastSyncError: isSet(object.lastSyncError)
|
|
28952
|
+
? trackerSyncErrorFromJSON(object.lastSyncError)
|
|
28953
|
+
: isSet(object.last_sync_error)
|
|
28954
|
+
? trackerSyncErrorFromJSON(object.last_sync_error)
|
|
28955
|
+
: 0,
|
|
28956
|
+
groups: globalThis.Array.isArray(object?.groups) ? object.groups.map((e: any) => IssueCostGroup.fromJSON(e)) : [],
|
|
28957
|
+
pagination: isSet(object.pagination) ? IssueCostPagination.fromJSON(object.pagination) : undefined,
|
|
28958
|
+
totals: isSet(object.totals) ? IssueCostTotals.fromJSON(object.totals) : undefined,
|
|
28959
|
+
};
|
|
28960
|
+
},
|
|
28961
|
+
|
|
28962
|
+
toJSON(message: ListIssueCostsResponse): unknown {
|
|
28963
|
+
const obj: any = {};
|
|
28964
|
+
if (message.status !== undefined) {
|
|
28965
|
+
obj.status = ResponseStatus.toJSON(message.status);
|
|
28966
|
+
}
|
|
28967
|
+
if (message.syncState !== 0) {
|
|
28968
|
+
obj.syncState = trackerSyncStateToJSON(message.syncState);
|
|
28969
|
+
}
|
|
28970
|
+
if (message.lastSyncedAt !== undefined) {
|
|
28971
|
+
obj.lastSyncedAt = message.lastSyncedAt.toISOString();
|
|
28972
|
+
}
|
|
28973
|
+
if (message.lastSyncError !== 0) {
|
|
28974
|
+
obj.lastSyncError = trackerSyncErrorToJSON(message.lastSyncError);
|
|
28975
|
+
}
|
|
28976
|
+
if (message.groups?.length) {
|
|
28977
|
+
obj.groups = message.groups.map((e) => IssueCostGroup.toJSON(e));
|
|
28978
|
+
}
|
|
28979
|
+
if (message.pagination !== undefined) {
|
|
28980
|
+
obj.pagination = IssueCostPagination.toJSON(message.pagination);
|
|
28981
|
+
}
|
|
28982
|
+
if (message.totals !== undefined) {
|
|
28983
|
+
obj.totals = IssueCostTotals.toJSON(message.totals);
|
|
28984
|
+
}
|
|
28985
|
+
return obj;
|
|
28986
|
+
},
|
|
28987
|
+
|
|
28988
|
+
create<I extends Exact<DeepPartial<ListIssueCostsResponse>, I>>(base?: I): ListIssueCostsResponse {
|
|
28989
|
+
return ListIssueCostsResponse.fromPartial(base ?? ({} as any));
|
|
28990
|
+
},
|
|
28991
|
+
fromPartial<I extends Exact<DeepPartial<ListIssueCostsResponse>, I>>(object: I): ListIssueCostsResponse {
|
|
28992
|
+
const message = createBaseListIssueCostsResponse();
|
|
28993
|
+
message.status = (object.status !== undefined && object.status !== null)
|
|
28994
|
+
? ResponseStatus.fromPartial(object.status)
|
|
28995
|
+
: undefined;
|
|
28996
|
+
message.syncState = object.syncState ?? 0;
|
|
28997
|
+
message.lastSyncedAt = object.lastSyncedAt ?? undefined;
|
|
28998
|
+
message.lastSyncError = object.lastSyncError ?? 0;
|
|
28999
|
+
message.groups = object.groups?.map((e) => IssueCostGroup.fromPartial(e)) || [];
|
|
29000
|
+
message.pagination = (object.pagination !== undefined && object.pagination !== null)
|
|
29001
|
+
? IssueCostPagination.fromPartial(object.pagination)
|
|
29002
|
+
: undefined;
|
|
29003
|
+
message.totals = (object.totals !== undefined && object.totals !== null)
|
|
29004
|
+
? IssueCostTotals.fromPartial(object.totals)
|
|
29005
|
+
: undefined;
|
|
29006
|
+
return message;
|
|
29007
|
+
},
|
|
29008
|
+
};
|
|
29009
|
+
|
|
29010
|
+
function createBaseIssueCostGroup(): IssueCostGroup {
|
|
29011
|
+
return { id: "", name: "", costUsdNanos: "0", sessionCount: 0, pullRequestCount: 0, issue: undefined };
|
|
29012
|
+
}
|
|
29013
|
+
|
|
29014
|
+
export const IssueCostGroup: MessageFns<IssueCostGroup> = {
|
|
29015
|
+
encode(message: IssueCostGroup, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
|
|
29016
|
+
if (message.id !== "") {
|
|
29017
|
+
writer.uint32(10).string(message.id);
|
|
29018
|
+
}
|
|
29019
|
+
if (message.name !== "") {
|
|
29020
|
+
writer.uint32(18).string(message.name);
|
|
29021
|
+
}
|
|
29022
|
+
if (message.costUsdNanos !== "0") {
|
|
29023
|
+
writer.uint32(24).int64(message.costUsdNanos);
|
|
29024
|
+
}
|
|
29025
|
+
if (message.sessionCount !== 0) {
|
|
29026
|
+
writer.uint32(32).int64(message.sessionCount);
|
|
29027
|
+
}
|
|
29028
|
+
if (message.pullRequestCount !== 0) {
|
|
29029
|
+
writer.uint32(40).int64(message.pullRequestCount);
|
|
29030
|
+
}
|
|
29031
|
+
if (message.issue !== undefined) {
|
|
29032
|
+
TrackerIssue.encode(message.issue, writer.uint32(50).fork()).join();
|
|
29033
|
+
}
|
|
29034
|
+
return writer;
|
|
29035
|
+
},
|
|
29036
|
+
|
|
29037
|
+
decode(input: BinaryReader | Uint8Array, length?: number): IssueCostGroup {
|
|
29038
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
29039
|
+
const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
|
|
29040
|
+
if (previousRecursionDepth >= 100) {
|
|
29041
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
29042
|
+
}
|
|
29043
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
29044
|
+
try {
|
|
29045
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
29046
|
+
const message = createBaseIssueCostGroup();
|
|
29047
|
+
while (reader.pos < end) {
|
|
29048
|
+
const tag = reader.uint32();
|
|
29049
|
+
switch (tag >>> 3) {
|
|
29050
|
+
case 1: {
|
|
29051
|
+
if (tag !== 10) {
|
|
29052
|
+
break;
|
|
29053
|
+
}
|
|
29054
|
+
|
|
29055
|
+
message.id = reader.string();
|
|
29056
|
+
continue;
|
|
29057
|
+
}
|
|
29058
|
+
case 2: {
|
|
29059
|
+
if (tag !== 18) {
|
|
29060
|
+
break;
|
|
29061
|
+
}
|
|
29062
|
+
|
|
29063
|
+
message.name = reader.string();
|
|
29064
|
+
continue;
|
|
29065
|
+
}
|
|
29066
|
+
case 3: {
|
|
29067
|
+
if (tag !== 24) {
|
|
29068
|
+
break;
|
|
29069
|
+
}
|
|
29070
|
+
|
|
29071
|
+
message.costUsdNanos = reader.int64().toString();
|
|
29072
|
+
continue;
|
|
29073
|
+
}
|
|
29074
|
+
case 4: {
|
|
29075
|
+
if (tag !== 32) {
|
|
29076
|
+
break;
|
|
29077
|
+
}
|
|
29078
|
+
|
|
29079
|
+
message.sessionCount = longToNumber(reader.int64());
|
|
29080
|
+
continue;
|
|
29081
|
+
}
|
|
29082
|
+
case 5: {
|
|
29083
|
+
if (tag !== 40) {
|
|
29084
|
+
break;
|
|
29085
|
+
}
|
|
29086
|
+
|
|
29087
|
+
message.pullRequestCount = longToNumber(reader.int64());
|
|
29088
|
+
continue;
|
|
29089
|
+
}
|
|
29090
|
+
case 6: {
|
|
29091
|
+
if (tag !== 50) {
|
|
29092
|
+
break;
|
|
29093
|
+
}
|
|
29094
|
+
|
|
29095
|
+
message.issue = TrackerIssue.decode(reader, reader.uint32());
|
|
29096
|
+
continue;
|
|
29097
|
+
}
|
|
29098
|
+
}
|
|
29099
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
29100
|
+
break;
|
|
29101
|
+
}
|
|
29102
|
+
reader.skip(tag & 7);
|
|
29103
|
+
}
|
|
29104
|
+
return message;
|
|
29105
|
+
} finally {
|
|
29106
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
|
|
29107
|
+
}
|
|
29108
|
+
},
|
|
29109
|
+
|
|
29110
|
+
fromJSON(object: any): IssueCostGroup {
|
|
29111
|
+
return {
|
|
29112
|
+
id: isSet(object.id) ? globalThis.String(object.id) : "",
|
|
29113
|
+
name: isSet(object.name) ? globalThis.String(object.name) : "",
|
|
29114
|
+
costUsdNanos: isSet(object.costUsdNanos)
|
|
29115
|
+
? globalThis.String(object.costUsdNanos)
|
|
29116
|
+
: isSet(object.cost_usd_nanos)
|
|
29117
|
+
? globalThis.String(object.cost_usd_nanos)
|
|
29118
|
+
: "0",
|
|
29119
|
+
sessionCount: isSet(object.sessionCount)
|
|
29120
|
+
? globalThis.Number(object.sessionCount)
|
|
29121
|
+
: isSet(object.session_count)
|
|
29122
|
+
? globalThis.Number(object.session_count)
|
|
29123
|
+
: 0,
|
|
29124
|
+
pullRequestCount: isSet(object.pullRequestCount)
|
|
29125
|
+
? globalThis.Number(object.pullRequestCount)
|
|
29126
|
+
: isSet(object.pull_request_count)
|
|
29127
|
+
? globalThis.Number(object.pull_request_count)
|
|
29128
|
+
: 0,
|
|
29129
|
+
issue: isSet(object.issue) ? TrackerIssue.fromJSON(object.issue) : undefined,
|
|
29130
|
+
};
|
|
29131
|
+
},
|
|
29132
|
+
|
|
29133
|
+
toJSON(message: IssueCostGroup): unknown {
|
|
29134
|
+
const obj: any = {};
|
|
29135
|
+
if (message.id !== "") {
|
|
29136
|
+
obj.id = message.id;
|
|
29137
|
+
}
|
|
29138
|
+
if (message.name !== "") {
|
|
29139
|
+
obj.name = message.name;
|
|
29140
|
+
}
|
|
29141
|
+
if (message.costUsdNanos !== "0") {
|
|
29142
|
+
obj.costUsdNanos = globalThis.String(message.costUsdNanos);
|
|
29143
|
+
}
|
|
29144
|
+
if (message.sessionCount !== 0) {
|
|
29145
|
+
obj.sessionCount = Math.round(message.sessionCount);
|
|
29146
|
+
}
|
|
29147
|
+
if (message.pullRequestCount !== 0) {
|
|
29148
|
+
obj.pullRequestCount = Math.round(message.pullRequestCount);
|
|
29149
|
+
}
|
|
29150
|
+
if (message.issue !== undefined) {
|
|
29151
|
+
obj.issue = TrackerIssue.toJSON(message.issue);
|
|
29152
|
+
}
|
|
29153
|
+
return obj;
|
|
29154
|
+
},
|
|
29155
|
+
|
|
29156
|
+
create<I extends Exact<DeepPartial<IssueCostGroup>, I>>(base?: I): IssueCostGroup {
|
|
29157
|
+
return IssueCostGroup.fromPartial(base ?? ({} as any));
|
|
29158
|
+
},
|
|
29159
|
+
fromPartial<I extends Exact<DeepPartial<IssueCostGroup>, I>>(object: I): IssueCostGroup {
|
|
29160
|
+
const message = createBaseIssueCostGroup();
|
|
29161
|
+
message.id = object.id ?? "";
|
|
29162
|
+
message.name = object.name ?? "";
|
|
29163
|
+
message.costUsdNanos = object.costUsdNanos ?? "0";
|
|
29164
|
+
message.sessionCount = object.sessionCount ?? 0;
|
|
29165
|
+
message.pullRequestCount = object.pullRequestCount ?? 0;
|
|
29166
|
+
message.issue = (object.issue !== undefined && object.issue !== null)
|
|
29167
|
+
? TrackerIssue.fromPartial(object.issue)
|
|
29168
|
+
: undefined;
|
|
29169
|
+
return message;
|
|
29170
|
+
},
|
|
29171
|
+
};
|
|
29172
|
+
|
|
29173
|
+
function createBaseTrackerIssue(): TrackerIssue {
|
|
29174
|
+
return {
|
|
29175
|
+
key: "",
|
|
29176
|
+
state: "",
|
|
29177
|
+
url: "",
|
|
29178
|
+
parentId: "",
|
|
29179
|
+
parentName: "",
|
|
29180
|
+
iterationId: "",
|
|
29181
|
+
iterationName: "",
|
|
29182
|
+
archivedAt: undefined,
|
|
29183
|
+
};
|
|
29184
|
+
}
|
|
29185
|
+
|
|
29186
|
+
export const TrackerIssue: MessageFns<TrackerIssue> = {
|
|
29187
|
+
encode(message: TrackerIssue, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
|
|
29188
|
+
if (message.key !== "") {
|
|
29189
|
+
writer.uint32(10).string(message.key);
|
|
29190
|
+
}
|
|
29191
|
+
if (message.state !== "") {
|
|
29192
|
+
writer.uint32(18).string(message.state);
|
|
29193
|
+
}
|
|
29194
|
+
if (message.url !== "") {
|
|
29195
|
+
writer.uint32(26).string(message.url);
|
|
29196
|
+
}
|
|
29197
|
+
if (message.parentId !== "") {
|
|
29198
|
+
writer.uint32(34).string(message.parentId);
|
|
29199
|
+
}
|
|
29200
|
+
if (message.parentName !== "") {
|
|
29201
|
+
writer.uint32(42).string(message.parentName);
|
|
29202
|
+
}
|
|
29203
|
+
if (message.iterationId !== "") {
|
|
29204
|
+
writer.uint32(50).string(message.iterationId);
|
|
29205
|
+
}
|
|
29206
|
+
if (message.iterationName !== "") {
|
|
29207
|
+
writer.uint32(58).string(message.iterationName);
|
|
29208
|
+
}
|
|
29209
|
+
if (message.archivedAt !== undefined) {
|
|
29210
|
+
Timestamp.encode(toTimestamp(message.archivedAt), writer.uint32(66).fork()).join();
|
|
29211
|
+
}
|
|
29212
|
+
return writer;
|
|
29213
|
+
},
|
|
29214
|
+
|
|
29215
|
+
decode(input: BinaryReader | Uint8Array, length?: number): TrackerIssue {
|
|
29216
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
29217
|
+
const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
|
|
29218
|
+
if (previousRecursionDepth >= 100) {
|
|
29219
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
29220
|
+
}
|
|
29221
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
29222
|
+
try {
|
|
29223
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
29224
|
+
const message = createBaseTrackerIssue();
|
|
29225
|
+
while (reader.pos < end) {
|
|
29226
|
+
const tag = reader.uint32();
|
|
29227
|
+
switch (tag >>> 3) {
|
|
29228
|
+
case 1: {
|
|
29229
|
+
if (tag !== 10) {
|
|
29230
|
+
break;
|
|
29231
|
+
}
|
|
29232
|
+
|
|
29233
|
+
message.key = reader.string();
|
|
29234
|
+
continue;
|
|
29235
|
+
}
|
|
29236
|
+
case 2: {
|
|
29237
|
+
if (tag !== 18) {
|
|
29238
|
+
break;
|
|
29239
|
+
}
|
|
29240
|
+
|
|
29241
|
+
message.state = reader.string();
|
|
29242
|
+
continue;
|
|
29243
|
+
}
|
|
29244
|
+
case 3: {
|
|
29245
|
+
if (tag !== 26) {
|
|
29246
|
+
break;
|
|
29247
|
+
}
|
|
29248
|
+
|
|
29249
|
+
message.url = reader.string();
|
|
29250
|
+
continue;
|
|
29251
|
+
}
|
|
29252
|
+
case 4: {
|
|
29253
|
+
if (tag !== 34) {
|
|
29254
|
+
break;
|
|
29255
|
+
}
|
|
29256
|
+
|
|
29257
|
+
message.parentId = reader.string();
|
|
29258
|
+
continue;
|
|
29259
|
+
}
|
|
29260
|
+
case 5: {
|
|
29261
|
+
if (tag !== 42) {
|
|
29262
|
+
break;
|
|
29263
|
+
}
|
|
29264
|
+
|
|
29265
|
+
message.parentName = reader.string();
|
|
29266
|
+
continue;
|
|
29267
|
+
}
|
|
29268
|
+
case 6: {
|
|
29269
|
+
if (tag !== 50) {
|
|
29270
|
+
break;
|
|
29271
|
+
}
|
|
29272
|
+
|
|
29273
|
+
message.iterationId = reader.string();
|
|
29274
|
+
continue;
|
|
29275
|
+
}
|
|
29276
|
+
case 7: {
|
|
29277
|
+
if (tag !== 58) {
|
|
29278
|
+
break;
|
|
29279
|
+
}
|
|
29280
|
+
|
|
29281
|
+
message.iterationName = reader.string();
|
|
29282
|
+
continue;
|
|
29283
|
+
}
|
|
29284
|
+
case 8: {
|
|
29285
|
+
if (tag !== 66) {
|
|
29286
|
+
break;
|
|
29287
|
+
}
|
|
29288
|
+
|
|
29289
|
+
message.archivedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
|
|
29290
|
+
continue;
|
|
29291
|
+
}
|
|
29292
|
+
}
|
|
29293
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
29294
|
+
break;
|
|
29295
|
+
}
|
|
29296
|
+
reader.skip(tag & 7);
|
|
29297
|
+
}
|
|
29298
|
+
return message;
|
|
29299
|
+
} finally {
|
|
29300
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
|
|
29301
|
+
}
|
|
29302
|
+
},
|
|
29303
|
+
|
|
29304
|
+
fromJSON(object: any): TrackerIssue {
|
|
29305
|
+
return {
|
|
29306
|
+
key: isSet(object.key) ? globalThis.String(object.key) : "",
|
|
29307
|
+
state: isSet(object.state) ? globalThis.String(object.state) : "",
|
|
29308
|
+
url: isSet(object.url) ? globalThis.String(object.url) : "",
|
|
29309
|
+
parentId: isSet(object.parentId)
|
|
29310
|
+
? globalThis.String(object.parentId)
|
|
29311
|
+
: isSet(object.parent_id)
|
|
29312
|
+
? globalThis.String(object.parent_id)
|
|
29313
|
+
: "",
|
|
29314
|
+
parentName: isSet(object.parentName)
|
|
29315
|
+
? globalThis.String(object.parentName)
|
|
29316
|
+
: isSet(object.parent_name)
|
|
29317
|
+
? globalThis.String(object.parent_name)
|
|
29318
|
+
: "",
|
|
29319
|
+
iterationId: isSet(object.iterationId)
|
|
29320
|
+
? globalThis.String(object.iterationId)
|
|
29321
|
+
: isSet(object.iteration_id)
|
|
29322
|
+
? globalThis.String(object.iteration_id)
|
|
29323
|
+
: "",
|
|
29324
|
+
iterationName: isSet(object.iterationName)
|
|
29325
|
+
? globalThis.String(object.iterationName)
|
|
29326
|
+
: isSet(object.iteration_name)
|
|
29327
|
+
? globalThis.String(object.iteration_name)
|
|
29328
|
+
: "",
|
|
29329
|
+
archivedAt: isSet(object.archivedAt)
|
|
29330
|
+
? fromJsonTimestamp(object.archivedAt)
|
|
29331
|
+
: isSet(object.archived_at)
|
|
29332
|
+
? fromJsonTimestamp(object.archived_at)
|
|
29333
|
+
: undefined,
|
|
29334
|
+
};
|
|
29335
|
+
},
|
|
29336
|
+
|
|
29337
|
+
toJSON(message: TrackerIssue): unknown {
|
|
29338
|
+
const obj: any = {};
|
|
29339
|
+
if (message.key !== "") {
|
|
29340
|
+
obj.key = message.key;
|
|
29341
|
+
}
|
|
29342
|
+
if (message.state !== "") {
|
|
29343
|
+
obj.state = message.state;
|
|
29344
|
+
}
|
|
29345
|
+
if (message.url !== "") {
|
|
29346
|
+
obj.url = message.url;
|
|
29347
|
+
}
|
|
29348
|
+
if (message.parentId !== "") {
|
|
29349
|
+
obj.parentId = message.parentId;
|
|
29350
|
+
}
|
|
29351
|
+
if (message.parentName !== "") {
|
|
29352
|
+
obj.parentName = message.parentName;
|
|
29353
|
+
}
|
|
29354
|
+
if (message.iterationId !== "") {
|
|
29355
|
+
obj.iterationId = message.iterationId;
|
|
29356
|
+
}
|
|
29357
|
+
if (message.iterationName !== "") {
|
|
29358
|
+
obj.iterationName = message.iterationName;
|
|
29359
|
+
}
|
|
29360
|
+
if (message.archivedAt !== undefined) {
|
|
29361
|
+
obj.archivedAt = message.archivedAt.toISOString();
|
|
29362
|
+
}
|
|
29363
|
+
return obj;
|
|
29364
|
+
},
|
|
29365
|
+
|
|
29366
|
+
create<I extends Exact<DeepPartial<TrackerIssue>, I>>(base?: I): TrackerIssue {
|
|
29367
|
+
return TrackerIssue.fromPartial(base ?? ({} as any));
|
|
29368
|
+
},
|
|
29369
|
+
fromPartial<I extends Exact<DeepPartial<TrackerIssue>, I>>(object: I): TrackerIssue {
|
|
29370
|
+
const message = createBaseTrackerIssue();
|
|
29371
|
+
message.key = object.key ?? "";
|
|
29372
|
+
message.state = object.state ?? "";
|
|
29373
|
+
message.url = object.url ?? "";
|
|
29374
|
+
message.parentId = object.parentId ?? "";
|
|
29375
|
+
message.parentName = object.parentName ?? "";
|
|
29376
|
+
message.iterationId = object.iterationId ?? "";
|
|
29377
|
+
message.iterationName = object.iterationName ?? "";
|
|
29378
|
+
message.archivedAt = object.archivedAt ?? undefined;
|
|
29379
|
+
return message;
|
|
29380
|
+
},
|
|
29381
|
+
};
|
|
29382
|
+
|
|
29383
|
+
function createBaseIssueCostPagination(): IssueCostPagination {
|
|
29384
|
+
return { page: 0, perPage: 0, totalCount: 0, totalPages: 0 };
|
|
29385
|
+
}
|
|
29386
|
+
|
|
29387
|
+
export const IssueCostPagination: MessageFns<IssueCostPagination> = {
|
|
29388
|
+
encode(message: IssueCostPagination, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
|
|
29389
|
+
if (message.page !== 0) {
|
|
29390
|
+
writer.uint32(8).int32(message.page);
|
|
29391
|
+
}
|
|
29392
|
+
if (message.perPage !== 0) {
|
|
29393
|
+
writer.uint32(16).int32(message.perPage);
|
|
29394
|
+
}
|
|
29395
|
+
if (message.totalCount !== 0) {
|
|
29396
|
+
writer.uint32(24).int64(message.totalCount);
|
|
29397
|
+
}
|
|
29398
|
+
if (message.totalPages !== 0) {
|
|
29399
|
+
writer.uint32(32).int32(message.totalPages);
|
|
29400
|
+
}
|
|
29401
|
+
return writer;
|
|
29402
|
+
},
|
|
29403
|
+
|
|
29404
|
+
decode(input: BinaryReader | Uint8Array, length?: number): IssueCostPagination {
|
|
29405
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
29406
|
+
const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
|
|
29407
|
+
if (previousRecursionDepth >= 100) {
|
|
29408
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
29409
|
+
}
|
|
29410
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
29411
|
+
try {
|
|
29412
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
29413
|
+
const message = createBaseIssueCostPagination();
|
|
29414
|
+
while (reader.pos < end) {
|
|
29415
|
+
const tag = reader.uint32();
|
|
29416
|
+
switch (tag >>> 3) {
|
|
29417
|
+
case 1: {
|
|
29418
|
+
if (tag !== 8) {
|
|
29419
|
+
break;
|
|
29420
|
+
}
|
|
29421
|
+
|
|
29422
|
+
message.page = reader.int32();
|
|
29423
|
+
continue;
|
|
29424
|
+
}
|
|
29425
|
+
case 2: {
|
|
29426
|
+
if (tag !== 16) {
|
|
29427
|
+
break;
|
|
29428
|
+
}
|
|
29429
|
+
|
|
29430
|
+
message.perPage = reader.int32();
|
|
29431
|
+
continue;
|
|
29432
|
+
}
|
|
29433
|
+
case 3: {
|
|
29434
|
+
if (tag !== 24) {
|
|
29435
|
+
break;
|
|
29436
|
+
}
|
|
29437
|
+
|
|
29438
|
+
message.totalCount = longToNumber(reader.int64());
|
|
29439
|
+
continue;
|
|
29440
|
+
}
|
|
29441
|
+
case 4: {
|
|
29442
|
+
if (tag !== 32) {
|
|
29443
|
+
break;
|
|
29444
|
+
}
|
|
29445
|
+
|
|
29446
|
+
message.totalPages = reader.int32();
|
|
29447
|
+
continue;
|
|
29448
|
+
}
|
|
29449
|
+
}
|
|
29450
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
29451
|
+
break;
|
|
29452
|
+
}
|
|
29453
|
+
reader.skip(tag & 7);
|
|
29454
|
+
}
|
|
29455
|
+
return message;
|
|
29456
|
+
} finally {
|
|
29457
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
|
|
29458
|
+
}
|
|
29459
|
+
},
|
|
29460
|
+
|
|
29461
|
+
fromJSON(object: any): IssueCostPagination {
|
|
29462
|
+
return {
|
|
29463
|
+
page: isSet(object.page) ? globalThis.Number(object.page) : 0,
|
|
29464
|
+
perPage: isSet(object.perPage)
|
|
29465
|
+
? globalThis.Number(object.perPage)
|
|
29466
|
+
: isSet(object.per_page)
|
|
29467
|
+
? globalThis.Number(object.per_page)
|
|
29468
|
+
: 0,
|
|
29469
|
+
totalCount: isSet(object.totalCount)
|
|
29470
|
+
? globalThis.Number(object.totalCount)
|
|
29471
|
+
: isSet(object.total_count)
|
|
29472
|
+
? globalThis.Number(object.total_count)
|
|
29473
|
+
: 0,
|
|
29474
|
+
totalPages: isSet(object.totalPages)
|
|
29475
|
+
? globalThis.Number(object.totalPages)
|
|
29476
|
+
: isSet(object.total_pages)
|
|
29477
|
+
? globalThis.Number(object.total_pages)
|
|
29478
|
+
: 0,
|
|
29479
|
+
};
|
|
29480
|
+
},
|
|
29481
|
+
|
|
29482
|
+
toJSON(message: IssueCostPagination): unknown {
|
|
29483
|
+
const obj: any = {};
|
|
29484
|
+
if (message.page !== 0) {
|
|
29485
|
+
obj.page = Math.round(message.page);
|
|
29486
|
+
}
|
|
29487
|
+
if (message.perPage !== 0) {
|
|
29488
|
+
obj.perPage = Math.round(message.perPage);
|
|
29489
|
+
}
|
|
29490
|
+
if (message.totalCount !== 0) {
|
|
29491
|
+
obj.totalCount = Math.round(message.totalCount);
|
|
29492
|
+
}
|
|
29493
|
+
if (message.totalPages !== 0) {
|
|
29494
|
+
obj.totalPages = Math.round(message.totalPages);
|
|
29495
|
+
}
|
|
29496
|
+
return obj;
|
|
29497
|
+
},
|
|
29498
|
+
|
|
29499
|
+
create<I extends Exact<DeepPartial<IssueCostPagination>, I>>(base?: I): IssueCostPagination {
|
|
29500
|
+
return IssueCostPagination.fromPartial(base ?? ({} as any));
|
|
29501
|
+
},
|
|
29502
|
+
fromPartial<I extends Exact<DeepPartial<IssueCostPagination>, I>>(object: I): IssueCostPagination {
|
|
29503
|
+
const message = createBaseIssueCostPagination();
|
|
29504
|
+
message.page = object.page ?? 0;
|
|
29505
|
+
message.perPage = object.perPage ?? 0;
|
|
29506
|
+
message.totalCount = object.totalCount ?? 0;
|
|
29507
|
+
message.totalPages = object.totalPages ?? 0;
|
|
29508
|
+
return message;
|
|
29509
|
+
},
|
|
29510
|
+
};
|
|
29511
|
+
|
|
29512
|
+
function createBaseIssueCostTotals(): IssueCostTotals {
|
|
29513
|
+
return {
|
|
29514
|
+
recordedCostUsdNanos: "0",
|
|
29515
|
+
attributedCostUsdNanos: "0",
|
|
29516
|
+
noPullRequestCostUsdNanos: "0",
|
|
29517
|
+
unlinkedPullRequestCostUsdNanos: "0",
|
|
29518
|
+
filteredCostUsdNanos: "0",
|
|
29519
|
+
};
|
|
29520
|
+
}
|
|
29521
|
+
|
|
29522
|
+
export const IssueCostTotals: MessageFns<IssueCostTotals> = {
|
|
29523
|
+
encode(message: IssueCostTotals, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
|
|
29524
|
+
if (message.recordedCostUsdNanos !== "0") {
|
|
29525
|
+
writer.uint32(8).int64(message.recordedCostUsdNanos);
|
|
29526
|
+
}
|
|
29527
|
+
if (message.attributedCostUsdNanos !== "0") {
|
|
29528
|
+
writer.uint32(16).int64(message.attributedCostUsdNanos);
|
|
29529
|
+
}
|
|
29530
|
+
if (message.noPullRequestCostUsdNanos !== "0") {
|
|
29531
|
+
writer.uint32(24).int64(message.noPullRequestCostUsdNanos);
|
|
29532
|
+
}
|
|
29533
|
+
if (message.unlinkedPullRequestCostUsdNanos !== "0") {
|
|
29534
|
+
writer.uint32(32).int64(message.unlinkedPullRequestCostUsdNanos);
|
|
29535
|
+
}
|
|
29536
|
+
if (message.filteredCostUsdNanos !== "0") {
|
|
29537
|
+
writer.uint32(40).int64(message.filteredCostUsdNanos);
|
|
29538
|
+
}
|
|
29539
|
+
return writer;
|
|
29540
|
+
},
|
|
29541
|
+
|
|
29542
|
+
decode(input: BinaryReader | Uint8Array, length?: number): IssueCostTotals {
|
|
29543
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
29544
|
+
const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
|
|
29545
|
+
if (previousRecursionDepth >= 100) {
|
|
29546
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
29547
|
+
}
|
|
29548
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
29549
|
+
try {
|
|
29550
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
29551
|
+
const message = createBaseIssueCostTotals();
|
|
29552
|
+
while (reader.pos < end) {
|
|
29553
|
+
const tag = reader.uint32();
|
|
29554
|
+
switch (tag >>> 3) {
|
|
29555
|
+
case 1: {
|
|
29556
|
+
if (tag !== 8) {
|
|
29557
|
+
break;
|
|
29558
|
+
}
|
|
29559
|
+
|
|
29560
|
+
message.recordedCostUsdNanos = reader.int64().toString();
|
|
29561
|
+
continue;
|
|
29562
|
+
}
|
|
29563
|
+
case 2: {
|
|
29564
|
+
if (tag !== 16) {
|
|
29565
|
+
break;
|
|
29566
|
+
}
|
|
29567
|
+
|
|
29568
|
+
message.attributedCostUsdNanos = reader.int64().toString();
|
|
29569
|
+
continue;
|
|
29570
|
+
}
|
|
29571
|
+
case 3: {
|
|
29572
|
+
if (tag !== 24) {
|
|
29573
|
+
break;
|
|
29574
|
+
}
|
|
29575
|
+
|
|
29576
|
+
message.noPullRequestCostUsdNanos = reader.int64().toString();
|
|
29577
|
+
continue;
|
|
29578
|
+
}
|
|
29579
|
+
case 4: {
|
|
29580
|
+
if (tag !== 32) {
|
|
29581
|
+
break;
|
|
29582
|
+
}
|
|
29583
|
+
|
|
29584
|
+
message.unlinkedPullRequestCostUsdNanos = reader.int64().toString();
|
|
29585
|
+
continue;
|
|
29586
|
+
}
|
|
29587
|
+
case 5: {
|
|
29588
|
+
if (tag !== 40) {
|
|
29589
|
+
break;
|
|
29590
|
+
}
|
|
29591
|
+
|
|
29592
|
+
message.filteredCostUsdNanos = reader.int64().toString();
|
|
29593
|
+
continue;
|
|
29594
|
+
}
|
|
29595
|
+
}
|
|
29596
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
29597
|
+
break;
|
|
29598
|
+
}
|
|
29599
|
+
reader.skip(tag & 7);
|
|
29600
|
+
}
|
|
29601
|
+
return message;
|
|
29602
|
+
} finally {
|
|
29603
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
|
|
29604
|
+
}
|
|
29605
|
+
},
|
|
29606
|
+
|
|
29607
|
+
fromJSON(object: any): IssueCostTotals {
|
|
29608
|
+
return {
|
|
29609
|
+
recordedCostUsdNanos: isSet(object.recordedCostUsdNanos)
|
|
29610
|
+
? globalThis.String(object.recordedCostUsdNanos)
|
|
29611
|
+
: isSet(object.recorded_cost_usd_nanos)
|
|
29612
|
+
? globalThis.String(object.recorded_cost_usd_nanos)
|
|
29613
|
+
: "0",
|
|
29614
|
+
attributedCostUsdNanos: isSet(object.attributedCostUsdNanos)
|
|
29615
|
+
? globalThis.String(object.attributedCostUsdNanos)
|
|
29616
|
+
: isSet(object.attributed_cost_usd_nanos)
|
|
29617
|
+
? globalThis.String(object.attributed_cost_usd_nanos)
|
|
29618
|
+
: "0",
|
|
29619
|
+
noPullRequestCostUsdNanos: isSet(object.noPullRequestCostUsdNanos)
|
|
29620
|
+
? globalThis.String(object.noPullRequestCostUsdNanos)
|
|
29621
|
+
: isSet(object.no_pull_request_cost_usd_nanos)
|
|
29622
|
+
? globalThis.String(object.no_pull_request_cost_usd_nanos)
|
|
29623
|
+
: "0",
|
|
29624
|
+
unlinkedPullRequestCostUsdNanos: isSet(object.unlinkedPullRequestCostUsdNanos)
|
|
29625
|
+
? globalThis.String(object.unlinkedPullRequestCostUsdNanos)
|
|
29626
|
+
: isSet(object.unlinked_pull_request_cost_usd_nanos)
|
|
29627
|
+
? globalThis.String(object.unlinked_pull_request_cost_usd_nanos)
|
|
29628
|
+
: "0",
|
|
29629
|
+
filteredCostUsdNanos: isSet(object.filteredCostUsdNanos)
|
|
29630
|
+
? globalThis.String(object.filteredCostUsdNanos)
|
|
29631
|
+
: isSet(object.filtered_cost_usd_nanos)
|
|
29632
|
+
? globalThis.String(object.filtered_cost_usd_nanos)
|
|
29633
|
+
: "0",
|
|
29634
|
+
};
|
|
29635
|
+
},
|
|
29636
|
+
|
|
29637
|
+
toJSON(message: IssueCostTotals): unknown {
|
|
29638
|
+
const obj: any = {};
|
|
29639
|
+
if (message.recordedCostUsdNanos !== "0") {
|
|
29640
|
+
obj.recordedCostUsdNanos = globalThis.String(message.recordedCostUsdNanos);
|
|
29641
|
+
}
|
|
29642
|
+
if (message.attributedCostUsdNanos !== "0") {
|
|
29643
|
+
obj.attributedCostUsdNanos = globalThis.String(message.attributedCostUsdNanos);
|
|
29644
|
+
}
|
|
29645
|
+
if (message.noPullRequestCostUsdNanos !== "0") {
|
|
29646
|
+
obj.noPullRequestCostUsdNanos = globalThis.String(message.noPullRequestCostUsdNanos);
|
|
29647
|
+
}
|
|
29648
|
+
if (message.unlinkedPullRequestCostUsdNanos !== "0") {
|
|
29649
|
+
obj.unlinkedPullRequestCostUsdNanos = globalThis.String(message.unlinkedPullRequestCostUsdNanos);
|
|
29650
|
+
}
|
|
29651
|
+
if (message.filteredCostUsdNanos !== "0") {
|
|
29652
|
+
obj.filteredCostUsdNanos = globalThis.String(message.filteredCostUsdNanos);
|
|
29653
|
+
}
|
|
29654
|
+
return obj;
|
|
29655
|
+
},
|
|
29656
|
+
|
|
29657
|
+
create<I extends Exact<DeepPartial<IssueCostTotals>, I>>(base?: I): IssueCostTotals {
|
|
29658
|
+
return IssueCostTotals.fromPartial(base ?? ({} as any));
|
|
29659
|
+
},
|
|
29660
|
+
fromPartial<I extends Exact<DeepPartial<IssueCostTotals>, I>>(object: I): IssueCostTotals {
|
|
29661
|
+
const message = createBaseIssueCostTotals();
|
|
29662
|
+
message.recordedCostUsdNanos = object.recordedCostUsdNanos ?? "0";
|
|
29663
|
+
message.attributedCostUsdNanos = object.attributedCostUsdNanos ?? "0";
|
|
29664
|
+
message.noPullRequestCostUsdNanos = object.noPullRequestCostUsdNanos ?? "0";
|
|
29665
|
+
message.unlinkedPullRequestCostUsdNanos = object.unlinkedPullRequestCostUsdNanos ?? "0";
|
|
29666
|
+
message.filteredCostUsdNanos = object.filteredCostUsdNanos ?? "0";
|
|
29667
|
+
return message;
|
|
29668
|
+
},
|
|
29669
|
+
};
|
|
29670
|
+
|
|
29671
|
+
/**
|
|
29672
|
+
* AIGatewayService is the frontend-facing proxy over telemetry.api.v1.AIService.
|
|
29673
|
+
* It stamps the authorized organization/project and forwards telemetry-api-shaped messages.
|
|
29674
|
+
*/
|
|
29675
|
+
export interface AIGatewayService {
|
|
29676
|
+
/**
|
|
29677
|
+
* One numbered page of the conversation catalog (sessions folded to
|
|
29678
|
+
* one rollup by source_system + session_id), ranked by sort. Weakly consistent
|
|
29679
|
+
* (latest-state, no frozen snapshot).
|
|
29680
|
+
*/
|
|
29681
|
+
ListSessions(request: ListSessionsRequest, metadata?: Metadata): Promise<ListSessionsResponse>;
|
|
29682
|
+
/**
|
|
29683
|
+
* Keeps the first conversation page live: the whole top-N page re-derived each tick
|
|
29684
|
+
* as one SessionsSnapshot, replacing client state wholesale (not a delta feed).
|
|
29685
|
+
*/
|
|
29686
|
+
StreamSessions(request: StreamSessionsRequest, metadata?: Metadata): Observable<SessionsSnapshot>;
|
|
29687
|
+
/** Live sidebar rollup (session_id + source_system): re-derived and re-emitted whole each tick. */
|
|
29688
|
+
StreamSessionSummary(request: GetSessionSummaryRequest, metadata?: Metadata): Observable<AISessionSummary>;
|
|
29689
|
+
ListSessionEvents(request: ListSessionEventsRequest, metadata?: Metadata): Promise<ListSessionEventsResponse>;
|
|
29690
|
+
StreamSessionEvents(request: StreamSessionEventsRequest, metadata?: Metadata): Observable<AISessionEventEnvelope>;
|
|
29691
|
+
/**
|
|
29692
|
+
* Live, backend-computed, per-event token series for one session (replacement snapshots):
|
|
29693
|
+
* one content-free point per logical event + whole-session totals; point count is capped.
|
|
29694
|
+
*/
|
|
29695
|
+
StreamSessionTokenTimeline(
|
|
29696
|
+
request: SessionTokenTimelineRequest,
|
|
29697
|
+
metadata?: Metadata,
|
|
29698
|
+
): Observable<SessionTokenTimeline>;
|
|
29699
|
+
/** Live "Files changed" card: per file the latest-observed git change-type + exact --numstat churn. */
|
|
29700
|
+
StreamSessionFileChanges(request: SessionFileChangesRequest, metadata?: Metadata): Observable<SessionFileChanges>;
|
|
29701
|
+
/** Filtered, keyset-paginated drill-down feed of git/GitHub actions (newest first). */
|
|
29702
|
+
ListGitActivities(request: ListGitActivitiesRequest, metadata?: Metadata): Promise<ListGitActivitiesResponse>;
|
|
29703
|
+
/**
|
|
29704
|
+
* Live stream of the filtered git/GitHub feed (UPSERT per activity keyed by
|
|
29705
|
+
* activity_id, a nonterminal GitActivitiesSnapshotCompleted, then open until cancel).
|
|
29706
|
+
*/
|
|
29707
|
+
StreamGitActivities(request: StreamGitActivitiesRequest, metadata?: Metadata): Observable<GitActivityFrame>;
|
|
29708
|
+
/**
|
|
29709
|
+
* Live stream of the git dashboard's overview: a full windowed, dimension-sliced rollup of the filtered
|
|
29710
|
+
* git activities (whole-window totals ride each frame), re-derived each tick.
|
|
29711
|
+
*/
|
|
29712
|
+
StreamGitActivitySummary(request: GitActivitySummaryRequest, metadata?: Metadata): Observable<GitActivitySummary>;
|
|
29713
|
+
/**
|
|
29714
|
+
* Live token burn calendar: a windowed, dimension-sliced token/cost trend series
|
|
29715
|
+
* plus whole-window totals.
|
|
29716
|
+
*/
|
|
29717
|
+
StreamTokenActivitySummary(
|
|
29718
|
+
request: TokenActivitySummaryRequest,
|
|
29719
|
+
metadata?: Metadata,
|
|
29720
|
+
): Observable<TokenActivitySummary>;
|
|
29721
|
+
/**
|
|
29722
|
+
* Live "burn rate now" gauge: the trailing-60s cost/hr + tokens/min (total plus a per-dimension
|
|
29723
|
+
* breakdown) and a fixed 60-minute one-minute rolling sparkline of that rate. Fixed horizon, fast
|
|
29724
|
+
* refresh; first frame is a full snapshot.
|
|
29725
|
+
*/
|
|
29726
|
+
StreamBurnRate(request: BurnRateRequest, metadata?: Metadata): Observable<BurnRate>;
|
|
29727
|
+
/**
|
|
29728
|
+
* Live token-burn calendar over an inclusive UTC [start_date, end_date] range: one complete row per
|
|
29729
|
+
* covered day off the precomputed daily rollup. Covered empty days are zero; uncomputed history is
|
|
29730
|
+
* omitted; today is provisional.
|
|
29731
|
+
*/
|
|
29732
|
+
StreamDailyActivity(request: DailyActivityRequest, metadata?: Metadata): Observable<DailyActivity>;
|
|
29733
|
+
/**
|
|
29734
|
+
* Live current-UTC-month spend forecast: month-to-date cost and the projected month-end total (a band from
|
|
29735
|
+
* replaying recent weeks), for the project, per model, provider and source system, and per principal, off the
|
|
29736
|
+
* same daily rollup as StreamDailyActivity; the filter narrows it by funding mode, source system and principal.
|
|
29737
|
+
* Mirrors telemetry.api.v1.
|
|
29738
|
+
*/
|
|
29739
|
+
StreamSpendForecast(request: SpendForecastRequest, metadata?: Metadata): Observable<SpendForecast>;
|
|
29740
|
+
/**
|
|
29741
|
+
* Live weekly activity rhythm: a sparse (weekday, hour) heatmap over a bounded sliding window in an
|
|
29742
|
+
* explicit IANA time zone. Every latest logical event counts; settled model calls add token/cost.
|
|
29743
|
+
*/
|
|
29744
|
+
StreamActivityRhythm(request: ActivityRhythmRequest, metadata?: Metadata): Observable<ActivityRhythm>;
|
|
29745
|
+
/**
|
|
29746
|
+
* Live stream of one project's dashboard bundle: headline totals, model/provider/source mix,
|
|
29747
|
+
* and top sessions by cost.
|
|
29748
|
+
*/
|
|
29749
|
+
StreamProjectOverview(request: ProjectOverviewRequest, metadata?: Metadata): Observable<ProjectOverview>;
|
|
29750
|
+
/**
|
|
29751
|
+
* Live organization home cards: one summary per requested project (zeros when it has no AI activity) —
|
|
29752
|
+
* conversations last active in the window, their principals and git counts, and the window's burn by model.
|
|
29753
|
+
*/
|
|
29754
|
+
StreamProjectSummaries(request: ProjectSummariesRequest, metadata?: Metadata): Observable<ProjectSummaries>;
|
|
29755
|
+
/**
|
|
29756
|
+
* Per-file working-state feed (keyset-paginated) behind the unlanded-work funnel: one row per
|
|
29757
|
+
* (repository_key, ref, path) the AI edited (with filter.sessions or filter.paths, one they name): its kept
|
|
29758
|
+
* checkout copies' edits, costs and tokens added up, its state from the most-edited copy. Mirrors telemetry.api.v1.
|
|
29759
|
+
*/
|
|
29760
|
+
ListFiles(request: ListFilesRequest, metadata?: Metadata): Promise<ListFilesResponse>;
|
|
29761
|
+
/**
|
|
29762
|
+
* ListFiles' files rolled up by directory, one row per (repository_key, directory), every matching directory in
|
|
29763
|
+
* one response (unpaged). Mirrors telemetry.api.v1.
|
|
29764
|
+
*/
|
|
29765
|
+
ListFileDirectories(request: ListFileDirectoriesRequest, metadata?: Metadata): Promise<ListFileDirectoriesResponse>;
|
|
29766
|
+
/**
|
|
29767
|
+
* Live stream of the unlanded-work funnel: aging tiers + discarded (git-invisible churn), a complete
|
|
29768
|
+
* snapshot re-derived each tick. Every checkout copy, edited or not, lands in its own bucket; files and
|
|
29769
|
+
* sessions are distinct counts, so they do not add up across buckets or groups. Mirrors telemetry.api.v1.
|
|
29770
|
+
*/
|
|
29771
|
+
StreamFilesSummary(request: FilesSummaryRequest, metadata?: Metadata): Observable<FilesSummary>;
|
|
29772
|
+
/** Latest observed list price per catalog listing from the global catalog, under stored names. */
|
|
28223
29773
|
ListModelPrices(request: ListModelPricesRequest, metadata?: Metadata): Promise<ListModelPricesResponse>;
|
|
28224
29774
|
/**
|
|
28225
29775
|
* Every stored observation for the filtered models over a time range, oldest first —
|
|
@@ -28282,6 +29832,18 @@ export interface AIGatewayService {
|
|
|
28282
29832
|
* Mirrors telemetry.api.v1.
|
|
28283
29833
|
*/
|
|
28284
29834
|
ListRelayHeartbeats(request: ListRelayHeartbeatsRequest, metadata?: Metadata): Promise<ListRelayHeartbeatsResponse>;
|
|
29835
|
+
/**
|
|
29836
|
+
* The organization's recorded AI cost (provider cost, gross of any subscription) attributed to its tracker's issues,
|
|
29837
|
+
* per pull request: each session that started in the window splits its cost evenly across the pull requests it
|
|
29838
|
+
* links to, then each pull request's share evenly across the issues the tracker attaches it to, in integer
|
|
29839
|
+
* nanodollars, over the whole organization before parent_ids and iteration_ids narrow the groups, so a shared
|
|
29840
|
+
* session never counts twice. An issue counts under its parent and iteration as last synced. One row per issue,
|
|
29841
|
+
* parent or iteration, highest cost first, numbered pages; totals add up to the window's recorded cost to the
|
|
29842
|
+
* nanodollar. Organization-level, for every member. Weakly consistent across pages. Nothing is served until the
|
|
29843
|
+
* tracker is connected and its first full sync has completed (sync_state); STATUS_CODE_UNAVAILABLE when Terma cannot
|
|
29844
|
+
* tell whether it is connected. Mirrors ai.api.v1.
|
|
29845
|
+
*/
|
|
29846
|
+
ListIssueCosts(request: ListIssueCostsRequest, metadata?: Metadata): Promise<ListIssueCostsResponse>;
|
|
28285
29847
|
}
|
|
28286
29848
|
|
|
28287
29849
|
export const AIGatewayServiceServiceName = "gateway.web.v1.AIGatewayService";
|
|
@@ -28322,6 +29884,7 @@ export class AIGatewayServiceClientImpl implements AIGatewayService {
|
|
|
28322
29884
|
this.GetPromptLabelTrend = this.GetPromptLabelTrend.bind(this);
|
|
28323
29885
|
this.StreamEntitlements = this.StreamEntitlements.bind(this);
|
|
28324
29886
|
this.ListRelayHeartbeats = this.ListRelayHeartbeats.bind(this);
|
|
29887
|
+
this.ListIssueCosts = this.ListIssueCosts.bind(this);
|
|
28325
29888
|
}
|
|
28326
29889
|
ListSessions(request: ListSessionsRequest, metadata?: Metadata): Promise<ListSessionsResponse> {
|
|
28327
29890
|
const data = ListSessionsRequest.encode(request).finish();
|
|
@@ -28520,6 +30083,12 @@ export class AIGatewayServiceClientImpl implements AIGatewayService {
|
|
|
28520
30083
|
const promise = this.rpc.request(this.service, "ListRelayHeartbeats", data, metadata);
|
|
28521
30084
|
return promise.then((data) => ListRelayHeartbeatsResponse.decode(new BinaryReader(data)));
|
|
28522
30085
|
}
|
|
30086
|
+
|
|
30087
|
+
ListIssueCosts(request: ListIssueCostsRequest, metadata?: Metadata): Promise<ListIssueCostsResponse> {
|
|
30088
|
+
const data = ListIssueCostsRequest.encode(request).finish();
|
|
30089
|
+
const promise = this.rpc.request(this.service, "ListIssueCosts", data, metadata);
|
|
30090
|
+
return promise.then((data) => ListIssueCostsResponse.decode(new BinaryReader(data)));
|
|
30091
|
+
}
|
|
28523
30092
|
}
|
|
28524
30093
|
|
|
28525
30094
|
interface Rpc {
|