@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
- * AIGatewayService is the frontend-facing proxy over telemetry.api.v1.AIService.
28123
- * It stamps the authorized organization/project and forwards telemetry-api-shaped messages.
28124
- */
28125
- export interface AIGatewayService {
28126
- /**
28127
- * One numbered page of the conversation catalog (sessions folded to
28128
- * one rollup by source_system + session_id), ranked by sort. Weakly consistent
28129
- * (latest-state, no frozen snapshot).
28130
- */
28131
- ListSessions(request: ListSessionsRequest, metadata?: Metadata): Promise<ListSessionsResponse>;
28132
- /**
28133
- * Keeps the first conversation page live: the whole top-N page re-derived each tick
28134
- * as one SessionsSnapshot, replacing client state wholesale (not a delta feed).
28135
- */
28136
- StreamSessions(request: StreamSessionsRequest, metadata?: Metadata): Observable<SessionsSnapshot>;
28137
- /** Live sidebar rollup (session_id + source_system): re-derived and re-emitted whole each tick. */
28138
- StreamSessionSummary(request: GetSessionSummaryRequest, metadata?: Metadata): Observable<AISessionSummary>;
28139
- ListSessionEvents(request: ListSessionEventsRequest, metadata?: Metadata): Promise<ListSessionEventsResponse>;
28140
- StreamSessionEvents(request: StreamSessionEventsRequest, metadata?: Metadata): Observable<AISessionEventEnvelope>;
28141
- /**
28142
- * Live, backend-computed, per-event token series for one session (replacement snapshots):
28143
- * one content-free point per logical event + whole-session totals; point count is capped.
28144
- */
28145
- StreamSessionTokenTimeline(
28146
- request: SessionTokenTimelineRequest,
28147
- metadata?: Metadata,
28148
- ): Observable<SessionTokenTimeline>;
28149
- /** Live "Files changed" card: per file the latest-observed git change-type + exact --numstat churn. */
28150
- StreamSessionFileChanges(request: SessionFileChangesRequest, metadata?: Metadata): Observable<SessionFileChanges>;
28151
- /** Filtered, keyset-paginated drill-down feed of git/GitHub actions (newest first). */
28152
- ListGitActivities(request: ListGitActivitiesRequest, metadata?: Metadata): Promise<ListGitActivitiesResponse>;
28153
- /**
28154
- * Live stream of the filtered git/GitHub feed (UPSERT per activity keyed by
28155
- * activity_id, a nonterminal GitActivitiesSnapshotCompleted, then open until cancel).
28156
- */
28157
- StreamGitActivities(request: StreamGitActivitiesRequest, metadata?: Metadata): Observable<GitActivityFrame>;
28158
- /**
28159
- * Live stream of the git dashboard's overview: a full windowed, dimension-sliced rollup of the filtered
28160
- * git activities (whole-window totals ride each frame), re-derived each tick.
28161
- */
28162
- StreamGitActivitySummary(request: GitActivitySummaryRequest, metadata?: Metadata): Observable<GitActivitySummary>;
28163
- /**
28164
- * Live token burn calendar: a windowed, dimension-sliced token/cost trend series
28165
- * plus whole-window totals.
28166
- */
28167
- StreamTokenActivitySummary(
28168
- request: TokenActivitySummaryRequest,
28169
- metadata?: Metadata,
28170
- ): Observable<TokenActivitySummary>;
28171
- /**
28172
- * Live "burn rate now" gauge: the trailing-60s cost/hr + tokens/min (total plus a per-dimension
28173
- * breakdown) and a fixed 60-minute one-minute rolling sparkline of that rate. Fixed horizon, fast
28174
- * refresh; first frame is a full snapshot.
28175
- */
28176
- StreamBurnRate(request: BurnRateRequest, metadata?: Metadata): Observable<BurnRate>;
28177
- /**
28178
- * Live token-burn calendar over an inclusive UTC [start_date, end_date] range: one complete row per
28179
- * covered day off the precomputed daily rollup. Covered empty days are zero; uncomputed history is
28180
- * omitted; today is provisional.
28181
- */
28182
- StreamDailyActivity(request: DailyActivityRequest, metadata?: Metadata): Observable<DailyActivity>;
28183
- /**
28184
- * Live current-UTC-month spend forecast: month-to-date cost and the projected month-end total (a band from
28185
- * replaying recent weeks), for the project, per model, provider and source system, and per principal, off the
28186
- * same daily rollup as StreamDailyActivity; the filter narrows it by funding mode, source system and principal.
28187
- * Mirrors telemetry.api.v1.
28188
- */
28189
- StreamSpendForecast(request: SpendForecastRequest, metadata?: Metadata): Observable<SpendForecast>;
28190
- /**
28191
- * Live weekly activity rhythm: a sparse (weekday, hour) heatmap over a bounded sliding window in an
28192
- * explicit IANA time zone. Every latest logical event counts; settled model calls add token/cost.
28193
- */
28194
- StreamActivityRhythm(request: ActivityRhythmRequest, metadata?: Metadata): Observable<ActivityRhythm>;
28195
- /**
28196
- * Live stream of one project's dashboard bundle: headline totals, model/provider/source mix,
28197
- * and top sessions by cost.
28198
- */
28199
- StreamProjectOverview(request: ProjectOverviewRequest, metadata?: Metadata): Observable<ProjectOverview>;
28200
- /**
28201
- * Live organization home cards: one summary per requested project (zeros when it has no AI activity) —
28202
- * conversations last active in the window, their principals and git counts, and the window's burn by model.
28203
- */
28204
- StreamProjectSummaries(request: ProjectSummariesRequest, metadata?: Metadata): Observable<ProjectSummaries>;
28205
- /**
28206
- * Per-file working-state feed (keyset-paginated) behind the unlanded-work funnel: one row per
28207
- * (repository_key, ref, path) the AI edited (with filter.sessions or filter.paths, one they name): its kept
28208
- * checkout copies' edits, costs and tokens added up, its state from the most-edited copy. Mirrors telemetry.api.v1.
28209
- */
28210
- ListFiles(request: ListFilesRequest, metadata?: Metadata): Promise<ListFilesResponse>;
28211
- /**
28212
- * ListFiles' files rolled up by directory, one row per (repository_key, directory), every matching directory in
28213
- * one response (unpaged). Mirrors telemetry.api.v1.
28214
- */
28215
- ListFileDirectories(request: ListFileDirectoriesRequest, metadata?: Metadata): Promise<ListFileDirectoriesResponse>;
28216
- /**
28217
- * Live stream of the unlanded-work funnel: aging tiers + discarded (git-invisible churn), a complete
28218
- * snapshot re-derived each tick. Every checkout copy, edited or not, lands in its own bucket; files and
28219
- * sessions are distinct counts, so they do not add up across buckets or groups. Mirrors telemetry.api.v1.
28220
- */
28221
- StreamFilesSummary(request: FilesSummaryRequest, metadata?: Metadata): Observable<FilesSummary>;
28222
- /** Latest observed list price per catalog listing from the global catalog, under stored names. */
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 {