@cesar-richard/git-connector-sdk 4.5.0 → 4.6.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.
- package/README.md +15 -0
- package/dist/schema.d.ts +846 -0
- package/package.json +1 -1
package/README.md
CHANGED
|
@@ -99,6 +99,21 @@ Two fields carry the kind, on `/v1/work-items`, `/v1/activities` and `/v1/delive
|
|
|
99
99
|
|
|
100
100
|
`other` is **not** a parse failure: it means the provider named a kind outside the normalised vocabulary. Read `originalType` then. This matters most on GitHub, whose issue types are defined per organisation — one org's `Epic` or `Spike` cannot be mapped onto a cross-provider taxonomy without inventing one, so it is deliberately left native. Branch on `source` if you need the raw values.
|
|
101
101
|
|
|
102
|
+
### Closure, hierarchy, time tracking
|
|
103
|
+
|
|
104
|
+
The same three shapes carry what the providers say about an item beyond its labels. Everything is nullable, and **null means the provider said nothing — never zero, never "no"**.
|
|
105
|
+
|
|
106
|
+
- **`closedAt` / `closedBy`** — when, and by whom. Distinct from `mergedAt`: a PR/MR can be closed without merging, and an issue is never merged. `closedBy` is a login, joinable against `?author`.
|
|
107
|
+
- **`stateReason`** (GitHub) — `completed`, `not_planned` or `reopened`. **`not_planned` means the issue was closed without being done.** A delivery report that ignores it counts abandoned work as delivered. GitLab has no equivalent, so it is always null there.
|
|
108
|
+
- **`parentEpic`** (GitLab) — `{ id, iid, title, url }`, read from the issue's own payload. Epics themselves are *not* ingested (they live at group level), but this is enough to walk PR → issue → epic.
|
|
109
|
+
- **`parentIssueUrl` / `subIssues`** (GitHub) — the same hierarchy on the other provider, plus sub-issue progress.
|
|
110
|
+
- **`blockingCount` / `blockedByCount`** — two directions, reported separately on purpose: GitLab only counts what an issue *blocks*, so `blockedByCount` is null there. Do not read one as the inverse of the other.
|
|
111
|
+
- **`timeStats`** (GitLab) — `{ estimateSeconds, spentSeconds }`, straight from the project's time tracking.
|
|
112
|
+
- **`taskCompletion`** — checklist progress in the description.
|
|
113
|
+
- **`weight`, `dueDate`, `startDate`, `healthStatus`, `severity`** (GitLab) — planning metadata, verbatim. No scale is imposed; `severity` is meaningful when `issueType === "incident"`.
|
|
114
|
+
|
|
115
|
+
On PR/MR shapes (`/v1/activities` and `linkedActivities[]`): **`mergedBy`** and **`targetBranch`**. `mergedBy` is GitLab-only — GitHub's list payload omits it, so null there means unknown.
|
|
116
|
+
|
|
102
117
|
### What did I do today?
|
|
103
118
|
|
|
104
119
|
```ts
|
package/dist/schema.d.ts
CHANGED
|
@@ -242,6 +242,52 @@ export interface components {
|
|
|
242
242
|
issueType: "issue" | "task" | "incident" | "test_case" | "other" | null;
|
|
243
243
|
/** @description The provider's own word for the kind, unmapped: `task` on GitLab, `Feature` on a GitHub org that defined it. `null` when the provider said nothing. GitHub issue types are org-defined, so this is deliberately NOT normalised across providers — branch on `source` if you need the raw taxonomy. */
|
|
244
244
|
originalType: string | null;
|
|
245
|
+
/** @description When the item was closed. Distinct from `mergedAt` — a PR/MR can be closed without merging, and an issue is never merged. */
|
|
246
|
+
closedAt: string | null;
|
|
247
|
+
/** @description Login of whoever closed it. A LOGIN, never a display name — same strict rule as `author`, so it can be joined against `?author`. */
|
|
248
|
+
closedBy: string | null;
|
|
249
|
+
/** @description GitHub only. `not_planned` means the issue was closed WITHOUT being done — a delivery report that ignores this counts abandoned work as delivered. Always null on GitLab, which has no equivalent. */
|
|
250
|
+
stateReason: "completed" | "not_planned" | "reopened" | null;
|
|
251
|
+
/** @description GitLab parent epic, read from the issue's own payload. Epics themselves are NOT ingested (they are group-level), but this is enough to walk PR → issue → epic. Always null on GitHub. */
|
|
252
|
+
parentEpic: {
|
|
253
|
+
id: (string | number) | null;
|
|
254
|
+
iid: (string | number) | null;
|
|
255
|
+
title: string | null;
|
|
256
|
+
url: string | null;
|
|
257
|
+
} | null;
|
|
258
|
+
/** @description GitHub parent issue, as an API url — the payload carries no id. Always null on GitLab, which expresses the same idea through `parentEpic`. */
|
|
259
|
+
parentIssueUrl: string | null;
|
|
260
|
+
/** @description GitHub sub-issue progress. Null when the issue has none. */
|
|
261
|
+
subIssues: {
|
|
262
|
+
total: string | number;
|
|
263
|
+
completed: string | number;
|
|
264
|
+
} | null;
|
|
265
|
+
/** @description How many items THIS one blocks. Not the inverse of `blockedByCount` — the two directions are reported separately because GitLab only counts this one. */
|
|
266
|
+
blockingCount: (string | number) | null;
|
|
267
|
+
/** @description How many items block THIS one. GitHub only; GitLab's payload does not say, so null there means unknown, not zero. */
|
|
268
|
+
blockedByCount: (string | number) | null;
|
|
269
|
+
/** @description GitLab time tracking, in seconds. Null when the project does not use it. */
|
|
270
|
+
timeStats: {
|
|
271
|
+
estimateSeconds: string | number;
|
|
272
|
+
spentSeconds: string | number;
|
|
273
|
+
} | null;
|
|
274
|
+
/** @description Checklist progress in the description ('3 of 5 tasks'). */
|
|
275
|
+
taskCompletion: {
|
|
276
|
+
total: string | number;
|
|
277
|
+
completed: string | number;
|
|
278
|
+
} | null;
|
|
279
|
+
/** @description GitLab issue weight, passed through unchanged — no scale is imposed here. */
|
|
280
|
+
weight: (string | number) | null;
|
|
281
|
+
dueDate: string | null;
|
|
282
|
+
startDate: string | null;
|
|
283
|
+
/** @description GitLab health status (`on_track`, `needs_attention`, `at_risk`), verbatim. */
|
|
284
|
+
healthStatus: string | null;
|
|
285
|
+
/** @description Incident severity. Meaningful when `issueType === 'incident'`. */
|
|
286
|
+
severity: string | null;
|
|
287
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
288
|
+
mergedBy: string | null;
|
|
289
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
290
|
+
targetBranch: string | null;
|
|
245
291
|
number: string | number;
|
|
246
292
|
title: string;
|
|
247
293
|
body: string | null;
|
|
@@ -301,6 +347,52 @@ export interface components {
|
|
|
301
347
|
issueType: "issue" | "task" | "incident" | "test_case" | "other" | null;
|
|
302
348
|
/** @description The provider's own word for the kind, unmapped: `task` on GitLab, `Feature` on a GitHub org that defined it. `null` when the provider said nothing. GitHub issue types are org-defined, so this is deliberately NOT normalised across providers — branch on `source` if you need the raw taxonomy. */
|
|
303
349
|
originalType: string | null;
|
|
350
|
+
/** @description When the item was closed. Distinct from `mergedAt` — a PR/MR can be closed without merging, and an issue is never merged. */
|
|
351
|
+
closedAt: string | null;
|
|
352
|
+
/** @description Login of whoever closed it. A LOGIN, never a display name — same strict rule as `author`, so it can be joined against `?author`. */
|
|
353
|
+
closedBy: string | null;
|
|
354
|
+
/** @description GitHub only. `not_planned` means the issue was closed WITHOUT being done — a delivery report that ignores this counts abandoned work as delivered. Always null on GitLab, which has no equivalent. */
|
|
355
|
+
stateReason: "completed" | "not_planned" | "reopened" | null;
|
|
356
|
+
/** @description GitLab parent epic, read from the issue's own payload. Epics themselves are NOT ingested (they are group-level), but this is enough to walk PR → issue → epic. Always null on GitHub. */
|
|
357
|
+
parentEpic: {
|
|
358
|
+
id: (string | number) | null;
|
|
359
|
+
iid: (string | number) | null;
|
|
360
|
+
title: string | null;
|
|
361
|
+
url: string | null;
|
|
362
|
+
} | null;
|
|
363
|
+
/** @description GitHub parent issue, as an API url — the payload carries no id. Always null on GitLab, which expresses the same idea through `parentEpic`. */
|
|
364
|
+
parentIssueUrl: string | null;
|
|
365
|
+
/** @description GitHub sub-issue progress. Null when the issue has none. */
|
|
366
|
+
subIssues: {
|
|
367
|
+
total: string | number;
|
|
368
|
+
completed: string | number;
|
|
369
|
+
} | null;
|
|
370
|
+
/** @description How many items THIS one blocks. Not the inverse of `blockedByCount` — the two directions are reported separately because GitLab only counts this one. */
|
|
371
|
+
blockingCount: (string | number) | null;
|
|
372
|
+
/** @description How many items block THIS one. GitHub only; GitLab's payload does not say, so null there means unknown, not zero. */
|
|
373
|
+
blockedByCount: (string | number) | null;
|
|
374
|
+
/** @description GitLab time tracking, in seconds. Null when the project does not use it. */
|
|
375
|
+
timeStats: {
|
|
376
|
+
estimateSeconds: string | number;
|
|
377
|
+
spentSeconds: string | number;
|
|
378
|
+
} | null;
|
|
379
|
+
/** @description Checklist progress in the description ('3 of 5 tasks'). */
|
|
380
|
+
taskCompletion: {
|
|
381
|
+
total: string | number;
|
|
382
|
+
completed: string | number;
|
|
383
|
+
} | null;
|
|
384
|
+
/** @description GitLab issue weight, passed through unchanged — no scale is imposed here. */
|
|
385
|
+
weight: (string | number) | null;
|
|
386
|
+
dueDate: string | null;
|
|
387
|
+
startDate: string | null;
|
|
388
|
+
/** @description GitLab health status (`on_track`, `needs_attention`, `at_risk`), verbatim. */
|
|
389
|
+
healthStatus: string | null;
|
|
390
|
+
/** @description Incident severity. Meaningful when `issueType === 'incident'`. */
|
|
391
|
+
severity: string | null;
|
|
392
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
393
|
+
mergedBy: string | null;
|
|
394
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
395
|
+
targetBranch: string | null;
|
|
304
396
|
number: string | number;
|
|
305
397
|
title: string;
|
|
306
398
|
body: string | null;
|
|
@@ -521,6 +613,10 @@ export interface components {
|
|
|
521
613
|
}[];
|
|
522
614
|
updatedAt: string;
|
|
523
615
|
mergedAt: string | null;
|
|
616
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
617
|
+
mergedBy: string | null;
|
|
618
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
619
|
+
targetBranch: string | null;
|
|
524
620
|
reviewRequestedAt: string | null;
|
|
525
621
|
volume: {
|
|
526
622
|
additions: string | number;
|
|
@@ -643,6 +739,48 @@ export interface components {
|
|
|
643
739
|
issueType: "issue" | "task" | "incident" | "test_case" | "other" | null;
|
|
644
740
|
/** @description The provider's own word for the kind, unmapped: `task` on GitLab, `Feature` on a GitHub org that defined it. `null` when the provider said nothing. GitHub issue types are org-defined, so this is deliberately NOT normalised across providers — branch on `source` if you need the raw taxonomy. */
|
|
645
741
|
originalType: string | null;
|
|
742
|
+
/** @description When the item was closed. Distinct from `mergedAt` — a PR/MR can be closed without merging, and an issue is never merged. */
|
|
743
|
+
closedAt: string | null;
|
|
744
|
+
/** @description Login of whoever closed it. A LOGIN, never a display name — same strict rule as `author`, so it can be joined against `?author`. */
|
|
745
|
+
closedBy: string | null;
|
|
746
|
+
/** @description GitHub only. `not_planned` means the issue was closed WITHOUT being done — a delivery report that ignores this counts abandoned work as delivered. Always null on GitLab, which has no equivalent. */
|
|
747
|
+
stateReason: "completed" | "not_planned" | "reopened" | null;
|
|
748
|
+
/** @description GitLab parent epic, read from the issue's own payload. Epics themselves are NOT ingested (they are group-level), but this is enough to walk PR → issue → epic. Always null on GitHub. */
|
|
749
|
+
parentEpic: {
|
|
750
|
+
id: (string | number) | null;
|
|
751
|
+
iid: (string | number) | null;
|
|
752
|
+
title: string | null;
|
|
753
|
+
url: string | null;
|
|
754
|
+
} | null;
|
|
755
|
+
/** @description GitHub parent issue, as an API url — the payload carries no id. Always null on GitLab, which expresses the same idea through `parentEpic`. */
|
|
756
|
+
parentIssueUrl: string | null;
|
|
757
|
+
/** @description GitHub sub-issue progress. Null when the issue has none. */
|
|
758
|
+
subIssues: {
|
|
759
|
+
total: string | number;
|
|
760
|
+
completed: string | number;
|
|
761
|
+
} | null;
|
|
762
|
+
/** @description How many items THIS one blocks. Not the inverse of `blockedByCount` — the two directions are reported separately because GitLab only counts this one. */
|
|
763
|
+
blockingCount: (string | number) | null;
|
|
764
|
+
/** @description How many items block THIS one. GitHub only; GitLab's payload does not say, so null there means unknown, not zero. */
|
|
765
|
+
blockedByCount: (string | number) | null;
|
|
766
|
+
/** @description GitLab time tracking, in seconds. Null when the project does not use it. */
|
|
767
|
+
timeStats: {
|
|
768
|
+
estimateSeconds: string | number;
|
|
769
|
+
spentSeconds: string | number;
|
|
770
|
+
} | null;
|
|
771
|
+
/** @description Checklist progress in the description ('3 of 5 tasks'). */
|
|
772
|
+
taskCompletion: {
|
|
773
|
+
total: string | number;
|
|
774
|
+
completed: string | number;
|
|
775
|
+
} | null;
|
|
776
|
+
/** @description GitLab issue weight, passed through unchanged — no scale is imposed here. */
|
|
777
|
+
weight: (string | number) | null;
|
|
778
|
+
dueDate: string | null;
|
|
779
|
+
startDate: string | null;
|
|
780
|
+
/** @description GitLab health status (`on_track`, `needs_attention`, `at_risk`), verbatim. */
|
|
781
|
+
healthStatus: string | null;
|
|
782
|
+
/** @description Incident severity. Meaningful when `issueType === 'incident'`. */
|
|
783
|
+
severity: string | null;
|
|
646
784
|
iteration: {
|
|
647
785
|
id: string | number;
|
|
648
786
|
title: string;
|
|
@@ -746,6 +884,10 @@ export interface components {
|
|
|
746
884
|
}[];
|
|
747
885
|
updatedAt: string;
|
|
748
886
|
mergedAt: string | null;
|
|
887
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
888
|
+
mergedBy: string | null;
|
|
889
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
890
|
+
targetBranch: string | null;
|
|
749
891
|
reviewRequestedAt: string | null;
|
|
750
892
|
volume: {
|
|
751
893
|
additions: string | number;
|
|
@@ -868,6 +1010,48 @@ export interface components {
|
|
|
868
1010
|
issueType: "issue" | "task" | "incident" | "test_case" | "other" | null;
|
|
869
1011
|
/** @description The provider's own word for the kind, unmapped: `task` on GitLab, `Feature` on a GitHub org that defined it. `null` when the provider said nothing. GitHub issue types are org-defined, so this is deliberately NOT normalised across providers — branch on `source` if you need the raw taxonomy. */
|
|
870
1012
|
originalType: string | null;
|
|
1013
|
+
/** @description When the item was closed. Distinct from `mergedAt` — a PR/MR can be closed without merging, and an issue is never merged. */
|
|
1014
|
+
closedAt: string | null;
|
|
1015
|
+
/** @description Login of whoever closed it. A LOGIN, never a display name — same strict rule as `author`, so it can be joined against `?author`. */
|
|
1016
|
+
closedBy: string | null;
|
|
1017
|
+
/** @description GitHub only. `not_planned` means the issue was closed WITHOUT being done — a delivery report that ignores this counts abandoned work as delivered. Always null on GitLab, which has no equivalent. */
|
|
1018
|
+
stateReason: "completed" | "not_planned" | "reopened" | null;
|
|
1019
|
+
/** @description GitLab parent epic, read from the issue's own payload. Epics themselves are NOT ingested (they are group-level), but this is enough to walk PR → issue → epic. Always null on GitHub. */
|
|
1020
|
+
parentEpic: {
|
|
1021
|
+
id: (string | number) | null;
|
|
1022
|
+
iid: (string | number) | null;
|
|
1023
|
+
title: string | null;
|
|
1024
|
+
url: string | null;
|
|
1025
|
+
} | null;
|
|
1026
|
+
/** @description GitHub parent issue, as an API url — the payload carries no id. Always null on GitLab, which expresses the same idea through `parentEpic`. */
|
|
1027
|
+
parentIssueUrl: string | null;
|
|
1028
|
+
/** @description GitHub sub-issue progress. Null when the issue has none. */
|
|
1029
|
+
subIssues: {
|
|
1030
|
+
total: string | number;
|
|
1031
|
+
completed: string | number;
|
|
1032
|
+
} | null;
|
|
1033
|
+
/** @description How many items THIS one blocks. Not the inverse of `blockedByCount` — the two directions are reported separately because GitLab only counts this one. */
|
|
1034
|
+
blockingCount: (string | number) | null;
|
|
1035
|
+
/** @description How many items block THIS one. GitHub only; GitLab's payload does not say, so null there means unknown, not zero. */
|
|
1036
|
+
blockedByCount: (string | number) | null;
|
|
1037
|
+
/** @description GitLab time tracking, in seconds. Null when the project does not use it. */
|
|
1038
|
+
timeStats: {
|
|
1039
|
+
estimateSeconds: string | number;
|
|
1040
|
+
spentSeconds: string | number;
|
|
1041
|
+
} | null;
|
|
1042
|
+
/** @description Checklist progress in the description ('3 of 5 tasks'). */
|
|
1043
|
+
taskCompletion: {
|
|
1044
|
+
total: string | number;
|
|
1045
|
+
completed: string | number;
|
|
1046
|
+
} | null;
|
|
1047
|
+
/** @description GitLab issue weight, passed through unchanged — no scale is imposed here. */
|
|
1048
|
+
weight: (string | number) | null;
|
|
1049
|
+
dueDate: string | null;
|
|
1050
|
+
startDate: string | null;
|
|
1051
|
+
/** @description GitLab health status (`on_track`, `needs_attention`, `at_risk`), verbatim. */
|
|
1052
|
+
healthStatus: string | null;
|
|
1053
|
+
/** @description Incident severity. Meaningful when `issueType === 'incident'`. */
|
|
1054
|
+
severity: string | null;
|
|
871
1055
|
iteration: {
|
|
872
1056
|
id: string | number;
|
|
873
1057
|
title: string;
|
|
@@ -1510,6 +1694,10 @@ export interface components {
|
|
|
1510
1694
|
}[];
|
|
1511
1695
|
updatedAt: string;
|
|
1512
1696
|
mergedAt: string | null;
|
|
1697
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
1698
|
+
mergedBy: string | null;
|
|
1699
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
1700
|
+
targetBranch: string | null;
|
|
1513
1701
|
reviewRequestedAt: string | null;
|
|
1514
1702
|
volume: {
|
|
1515
1703
|
additions: string | number;
|
|
@@ -1594,6 +1782,16 @@ export interface components {
|
|
|
1594
1782
|
number: string | number;
|
|
1595
1783
|
}[];
|
|
1596
1784
|
};
|
|
1785
|
+
ParentEpic: {
|
|
1786
|
+
id: (string | number) | null;
|
|
1787
|
+
iid: (string | number) | null;
|
|
1788
|
+
title: string | null;
|
|
1789
|
+
url: string | null;
|
|
1790
|
+
};
|
|
1791
|
+
Progress: {
|
|
1792
|
+
total: string | number;
|
|
1793
|
+
completed: string | number;
|
|
1794
|
+
};
|
|
1597
1795
|
ProjectLabel: {
|
|
1598
1796
|
name: string;
|
|
1599
1797
|
color: string;
|
|
@@ -1691,6 +1889,10 @@ export interface components {
|
|
|
1691
1889
|
firstNoteCreatedAt: string;
|
|
1692
1890
|
url: string | null;
|
|
1693
1891
|
};
|
|
1892
|
+
TimeStats: {
|
|
1893
|
+
estimateSeconds: string | number;
|
|
1894
|
+
spentSeconds: string | number;
|
|
1895
|
+
};
|
|
1694
1896
|
TrackedProject: {
|
|
1695
1897
|
source: "github" | "gitlab";
|
|
1696
1898
|
/** @description Provider-side project path, verbatim from the operator config (`owner/repo` on GitHub, `group/sub/project` on GitLab). Pair with `source` to call /v1/projects/{source}/{projectKey}/labels. */
|
|
@@ -1734,6 +1936,48 @@ export interface components {
|
|
|
1734
1936
|
issueType: "issue" | "task" | "incident" | "test_case" | "other" | null;
|
|
1735
1937
|
/** @description The provider's own word for the kind, unmapped: `task` on GitLab, `Feature` on a GitHub org that defined it. `null` when the provider said nothing. GitHub issue types are org-defined, so this is deliberately NOT normalised across providers — branch on `source` if you need the raw taxonomy. */
|
|
1736
1938
|
originalType: string | null;
|
|
1939
|
+
/** @description When the item was closed. Distinct from `mergedAt` — a PR/MR can be closed without merging, and an issue is never merged. */
|
|
1940
|
+
closedAt: string | null;
|
|
1941
|
+
/** @description Login of whoever closed it. A LOGIN, never a display name — same strict rule as `author`, so it can be joined against `?author`. */
|
|
1942
|
+
closedBy: string | null;
|
|
1943
|
+
/** @description GitHub only. `not_planned` means the issue was closed WITHOUT being done — a delivery report that ignores this counts abandoned work as delivered. Always null on GitLab, which has no equivalent. */
|
|
1944
|
+
stateReason: "completed" | "not_planned" | "reopened" | null;
|
|
1945
|
+
/** @description GitLab parent epic, read from the issue's own payload. Epics themselves are NOT ingested (they are group-level), but this is enough to walk PR → issue → epic. Always null on GitHub. */
|
|
1946
|
+
parentEpic: {
|
|
1947
|
+
id: (string | number) | null;
|
|
1948
|
+
iid: (string | number) | null;
|
|
1949
|
+
title: string | null;
|
|
1950
|
+
url: string | null;
|
|
1951
|
+
} | null;
|
|
1952
|
+
/** @description GitHub parent issue, as an API url — the payload carries no id. Always null on GitLab, which expresses the same idea through `parentEpic`. */
|
|
1953
|
+
parentIssueUrl: string | null;
|
|
1954
|
+
/** @description GitHub sub-issue progress. Null when the issue has none. */
|
|
1955
|
+
subIssues: {
|
|
1956
|
+
total: string | number;
|
|
1957
|
+
completed: string | number;
|
|
1958
|
+
} | null;
|
|
1959
|
+
/** @description How many items THIS one blocks. Not the inverse of `blockedByCount` — the two directions are reported separately because GitLab only counts this one. */
|
|
1960
|
+
blockingCount: (string | number) | null;
|
|
1961
|
+
/** @description How many items block THIS one. GitHub only; GitLab's payload does not say, so null there means unknown, not zero. */
|
|
1962
|
+
blockedByCount: (string | number) | null;
|
|
1963
|
+
/** @description GitLab time tracking, in seconds. Null when the project does not use it. */
|
|
1964
|
+
timeStats: {
|
|
1965
|
+
estimateSeconds: string | number;
|
|
1966
|
+
spentSeconds: string | number;
|
|
1967
|
+
} | null;
|
|
1968
|
+
/** @description Checklist progress in the description ('3 of 5 tasks'). */
|
|
1969
|
+
taskCompletion: {
|
|
1970
|
+
total: string | number;
|
|
1971
|
+
completed: string | number;
|
|
1972
|
+
} | null;
|
|
1973
|
+
/** @description GitLab issue weight, passed through unchanged — no scale is imposed here. */
|
|
1974
|
+
weight: (string | number) | null;
|
|
1975
|
+
dueDate: string | null;
|
|
1976
|
+
startDate: string | null;
|
|
1977
|
+
/** @description GitLab health status (`on_track`, `needs_attention`, `at_risk`), verbatim. */
|
|
1978
|
+
healthStatus: string | null;
|
|
1979
|
+
/** @description Incident severity. Meaningful when `issueType === 'incident'`. */
|
|
1980
|
+
severity: string | null;
|
|
1737
1981
|
iteration: {
|
|
1738
1982
|
id: string | number;
|
|
1739
1983
|
title: string;
|
|
@@ -1798,6 +2042,10 @@ export interface components {
|
|
|
1798
2042
|
}[];
|
|
1799
2043
|
updatedAt: string;
|
|
1800
2044
|
mergedAt: string | null;
|
|
2045
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
2046
|
+
mergedBy: string | null;
|
|
2047
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
2048
|
+
targetBranch: string | null;
|
|
1801
2049
|
reviewRequestedAt: string | null;
|
|
1802
2050
|
volume: {
|
|
1803
2051
|
additions: string | number;
|
|
@@ -1923,6 +2171,48 @@ export interface components {
|
|
|
1923
2171
|
issueType: "issue" | "task" | "incident" | "test_case" | "other" | null;
|
|
1924
2172
|
/** @description The provider's own word for the kind, unmapped: `task` on GitLab, `Feature` on a GitHub org that defined it. `null` when the provider said nothing. GitHub issue types are org-defined, so this is deliberately NOT normalised across providers — branch on `source` if you need the raw taxonomy. */
|
|
1925
2173
|
originalType: string | null;
|
|
2174
|
+
/** @description When the item was closed. Distinct from `mergedAt` — a PR/MR can be closed without merging, and an issue is never merged. */
|
|
2175
|
+
closedAt: string | null;
|
|
2176
|
+
/** @description Login of whoever closed it. A LOGIN, never a display name — same strict rule as `author`, so it can be joined against `?author`. */
|
|
2177
|
+
closedBy: string | null;
|
|
2178
|
+
/** @description GitHub only. `not_planned` means the issue was closed WITHOUT being done — a delivery report that ignores this counts abandoned work as delivered. Always null on GitLab, which has no equivalent. */
|
|
2179
|
+
stateReason: "completed" | "not_planned" | "reopened" | null;
|
|
2180
|
+
/** @description GitLab parent epic, read from the issue's own payload. Epics themselves are NOT ingested (they are group-level), but this is enough to walk PR → issue → epic. Always null on GitHub. */
|
|
2181
|
+
parentEpic: {
|
|
2182
|
+
id: (string | number) | null;
|
|
2183
|
+
iid: (string | number) | null;
|
|
2184
|
+
title: string | null;
|
|
2185
|
+
url: string | null;
|
|
2186
|
+
} | null;
|
|
2187
|
+
/** @description GitHub parent issue, as an API url — the payload carries no id. Always null on GitLab, which expresses the same idea through `parentEpic`. */
|
|
2188
|
+
parentIssueUrl: string | null;
|
|
2189
|
+
/** @description GitHub sub-issue progress. Null when the issue has none. */
|
|
2190
|
+
subIssues: {
|
|
2191
|
+
total: string | number;
|
|
2192
|
+
completed: string | number;
|
|
2193
|
+
} | null;
|
|
2194
|
+
/** @description How many items THIS one blocks. Not the inverse of `blockedByCount` — the two directions are reported separately because GitLab only counts this one. */
|
|
2195
|
+
blockingCount: (string | number) | null;
|
|
2196
|
+
/** @description How many items block THIS one. GitHub only; GitLab's payload does not say, so null there means unknown, not zero. */
|
|
2197
|
+
blockedByCount: (string | number) | null;
|
|
2198
|
+
/** @description GitLab time tracking, in seconds. Null when the project does not use it. */
|
|
2199
|
+
timeStats: {
|
|
2200
|
+
estimateSeconds: string | number;
|
|
2201
|
+
spentSeconds: string | number;
|
|
2202
|
+
} | null;
|
|
2203
|
+
/** @description Checklist progress in the description ('3 of 5 tasks'). */
|
|
2204
|
+
taskCompletion: {
|
|
2205
|
+
total: string | number;
|
|
2206
|
+
completed: string | number;
|
|
2207
|
+
} | null;
|
|
2208
|
+
/** @description GitLab issue weight, passed through unchanged — no scale is imposed here. */
|
|
2209
|
+
weight: (string | number) | null;
|
|
2210
|
+
dueDate: string | null;
|
|
2211
|
+
startDate: string | null;
|
|
2212
|
+
/** @description GitLab health status (`on_track`, `needs_attention`, `at_risk`), verbatim. */
|
|
2213
|
+
healthStatus: string | null;
|
|
2214
|
+
/** @description Incident severity. Meaningful when `issueType === 'incident'`. */
|
|
2215
|
+
severity: string | null;
|
|
1926
2216
|
iteration: {
|
|
1927
2217
|
id: string | number;
|
|
1928
2218
|
title: string;
|
|
@@ -1987,6 +2277,10 @@ export interface components {
|
|
|
1987
2277
|
}[];
|
|
1988
2278
|
updatedAt: string;
|
|
1989
2279
|
mergedAt: string | null;
|
|
2280
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
2281
|
+
mergedBy: string | null;
|
|
2282
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
2283
|
+
targetBranch: string | null;
|
|
1990
2284
|
reviewRequestedAt: string | null;
|
|
1991
2285
|
volume: {
|
|
1992
2286
|
additions: string | number;
|
|
@@ -2165,6 +2459,48 @@ export interface operations {
|
|
|
2165
2459
|
issueType: "issue" | "task" | "incident" | "test_case" | "other" | null;
|
|
2166
2460
|
/** @description The provider's own word for the kind, unmapped: `task` on GitLab, `Feature` on a GitHub org that defined it. `null` when the provider said nothing. GitHub issue types are org-defined, so this is deliberately NOT normalised across providers — branch on `source` if you need the raw taxonomy. */
|
|
2167
2461
|
originalType: string | null;
|
|
2462
|
+
/** @description When the item was closed. Distinct from `mergedAt` — a PR/MR can be closed without merging, and an issue is never merged. */
|
|
2463
|
+
closedAt: string | null;
|
|
2464
|
+
/** @description Login of whoever closed it. A LOGIN, never a display name — same strict rule as `author`, so it can be joined against `?author`. */
|
|
2465
|
+
closedBy: string | null;
|
|
2466
|
+
/** @description GitHub only. `not_planned` means the issue was closed WITHOUT being done — a delivery report that ignores this counts abandoned work as delivered. Always null on GitLab, which has no equivalent. */
|
|
2467
|
+
stateReason: "completed" | "not_planned" | "reopened" | null;
|
|
2468
|
+
/** @description GitLab parent epic, read from the issue's own payload. Epics themselves are NOT ingested (they are group-level), but this is enough to walk PR → issue → epic. Always null on GitHub. */
|
|
2469
|
+
parentEpic: {
|
|
2470
|
+
id: (string | number) | null;
|
|
2471
|
+
iid: (string | number) | null;
|
|
2472
|
+
title: string | null;
|
|
2473
|
+
url: string | null;
|
|
2474
|
+
} | null;
|
|
2475
|
+
/** @description GitHub parent issue, as an API url — the payload carries no id. Always null on GitLab, which expresses the same idea through `parentEpic`. */
|
|
2476
|
+
parentIssueUrl: string | null;
|
|
2477
|
+
/** @description GitHub sub-issue progress. Null when the issue has none. */
|
|
2478
|
+
subIssues: {
|
|
2479
|
+
total: string | number;
|
|
2480
|
+
completed: string | number;
|
|
2481
|
+
} | null;
|
|
2482
|
+
/** @description How many items THIS one blocks. Not the inverse of `blockedByCount` — the two directions are reported separately because GitLab only counts this one. */
|
|
2483
|
+
blockingCount: (string | number) | null;
|
|
2484
|
+
/** @description How many items block THIS one. GitHub only; GitLab's payload does not say, so null there means unknown, not zero. */
|
|
2485
|
+
blockedByCount: (string | number) | null;
|
|
2486
|
+
/** @description GitLab time tracking, in seconds. Null when the project does not use it. */
|
|
2487
|
+
timeStats: {
|
|
2488
|
+
estimateSeconds: string | number;
|
|
2489
|
+
spentSeconds: string | number;
|
|
2490
|
+
} | null;
|
|
2491
|
+
/** @description Checklist progress in the description ('3 of 5 tasks'). */
|
|
2492
|
+
taskCompletion: {
|
|
2493
|
+
total: string | number;
|
|
2494
|
+
completed: string | number;
|
|
2495
|
+
} | null;
|
|
2496
|
+
/** @description GitLab issue weight, passed through unchanged — no scale is imposed here. */
|
|
2497
|
+
weight: (string | number) | null;
|
|
2498
|
+
dueDate: string | null;
|
|
2499
|
+
startDate: string | null;
|
|
2500
|
+
/** @description GitLab health status (`on_track`, `needs_attention`, `at_risk`), verbatim. */
|
|
2501
|
+
healthStatus: string | null;
|
|
2502
|
+
/** @description Incident severity. Meaningful when `issueType === 'incident'`. */
|
|
2503
|
+
severity: string | null;
|
|
2168
2504
|
iteration: {
|
|
2169
2505
|
id: string | number;
|
|
2170
2506
|
title: string;
|
|
@@ -2229,6 +2565,10 @@ export interface operations {
|
|
|
2229
2565
|
}[];
|
|
2230
2566
|
updatedAt: string;
|
|
2231
2567
|
mergedAt: string | null;
|
|
2568
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
2569
|
+
mergedBy: string | null;
|
|
2570
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
2571
|
+
targetBranch: string | null;
|
|
2232
2572
|
reviewRequestedAt: string | null;
|
|
2233
2573
|
volume: {
|
|
2234
2574
|
additions: string | number;
|
|
@@ -2358,6 +2698,48 @@ export interface operations {
|
|
|
2358
2698
|
issueType: "issue" | "task" | "incident" | "test_case" | "other" | null;
|
|
2359
2699
|
/** @description The provider's own word for the kind, unmapped: `task` on GitLab, `Feature` on a GitHub org that defined it. `null` when the provider said nothing. GitHub issue types are org-defined, so this is deliberately NOT normalised across providers — branch on `source` if you need the raw taxonomy. */
|
|
2360
2700
|
originalType: string | null;
|
|
2701
|
+
/** @description When the item was closed. Distinct from `mergedAt` — a PR/MR can be closed without merging, and an issue is never merged. */
|
|
2702
|
+
closedAt: string | null;
|
|
2703
|
+
/** @description Login of whoever closed it. A LOGIN, never a display name — same strict rule as `author`, so it can be joined against `?author`. */
|
|
2704
|
+
closedBy: string | null;
|
|
2705
|
+
/** @description GitHub only. `not_planned` means the issue was closed WITHOUT being done — a delivery report that ignores this counts abandoned work as delivered. Always null on GitLab, which has no equivalent. */
|
|
2706
|
+
stateReason: "completed" | "not_planned" | "reopened" | null;
|
|
2707
|
+
/** @description GitLab parent epic, read from the issue's own payload. Epics themselves are NOT ingested (they are group-level), but this is enough to walk PR → issue → epic. Always null on GitHub. */
|
|
2708
|
+
parentEpic: {
|
|
2709
|
+
id: (string | number) | null;
|
|
2710
|
+
iid: (string | number) | null;
|
|
2711
|
+
title: string | null;
|
|
2712
|
+
url: string | null;
|
|
2713
|
+
} | null;
|
|
2714
|
+
/** @description GitHub parent issue, as an API url — the payload carries no id. Always null on GitLab, which expresses the same idea through `parentEpic`. */
|
|
2715
|
+
parentIssueUrl: string | null;
|
|
2716
|
+
/** @description GitHub sub-issue progress. Null when the issue has none. */
|
|
2717
|
+
subIssues: {
|
|
2718
|
+
total: string | number;
|
|
2719
|
+
completed: string | number;
|
|
2720
|
+
} | null;
|
|
2721
|
+
/** @description How many items THIS one blocks. Not the inverse of `blockedByCount` — the two directions are reported separately because GitLab only counts this one. */
|
|
2722
|
+
blockingCount: (string | number) | null;
|
|
2723
|
+
/** @description How many items block THIS one. GitHub only; GitLab's payload does not say, so null there means unknown, not zero. */
|
|
2724
|
+
blockedByCount: (string | number) | null;
|
|
2725
|
+
/** @description GitLab time tracking, in seconds. Null when the project does not use it. */
|
|
2726
|
+
timeStats: {
|
|
2727
|
+
estimateSeconds: string | number;
|
|
2728
|
+
spentSeconds: string | number;
|
|
2729
|
+
} | null;
|
|
2730
|
+
/** @description Checklist progress in the description ('3 of 5 tasks'). */
|
|
2731
|
+
taskCompletion: {
|
|
2732
|
+
total: string | number;
|
|
2733
|
+
completed: string | number;
|
|
2734
|
+
} | null;
|
|
2735
|
+
/** @description GitLab issue weight, passed through unchanged — no scale is imposed here. */
|
|
2736
|
+
weight: (string | number) | null;
|
|
2737
|
+
dueDate: string | null;
|
|
2738
|
+
startDate: string | null;
|
|
2739
|
+
/** @description GitLab health status (`on_track`, `needs_attention`, `at_risk`), verbatim. */
|
|
2740
|
+
healthStatus: string | null;
|
|
2741
|
+
/** @description Incident severity. Meaningful when `issueType === 'incident'`. */
|
|
2742
|
+
severity: string | null;
|
|
2361
2743
|
iteration: {
|
|
2362
2744
|
id: string | number;
|
|
2363
2745
|
title: string;
|
|
@@ -2422,6 +2804,10 @@ export interface operations {
|
|
|
2422
2804
|
}[];
|
|
2423
2805
|
updatedAt: string;
|
|
2424
2806
|
mergedAt: string | null;
|
|
2807
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
2808
|
+
mergedBy: string | null;
|
|
2809
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
2810
|
+
targetBranch: string | null;
|
|
2425
2811
|
reviewRequestedAt: string | null;
|
|
2426
2812
|
volume: {
|
|
2427
2813
|
additions: string | number;
|
|
@@ -2551,6 +2937,48 @@ export interface operations {
|
|
|
2551
2937
|
issueType: "issue" | "task" | "incident" | "test_case" | "other" | null;
|
|
2552
2938
|
/** @description The provider's own word for the kind, unmapped: `task` on GitLab, `Feature` on a GitHub org that defined it. `null` when the provider said nothing. GitHub issue types are org-defined, so this is deliberately NOT normalised across providers — branch on `source` if you need the raw taxonomy. */
|
|
2553
2939
|
originalType: string | null;
|
|
2940
|
+
/** @description When the item was closed. Distinct from `mergedAt` — a PR/MR can be closed without merging, and an issue is never merged. */
|
|
2941
|
+
closedAt: string | null;
|
|
2942
|
+
/** @description Login of whoever closed it. A LOGIN, never a display name — same strict rule as `author`, so it can be joined against `?author`. */
|
|
2943
|
+
closedBy: string | null;
|
|
2944
|
+
/** @description GitHub only. `not_planned` means the issue was closed WITHOUT being done — a delivery report that ignores this counts abandoned work as delivered. Always null on GitLab, which has no equivalent. */
|
|
2945
|
+
stateReason: "completed" | "not_planned" | "reopened" | null;
|
|
2946
|
+
/** @description GitLab parent epic, read from the issue's own payload. Epics themselves are NOT ingested (they are group-level), but this is enough to walk PR → issue → epic. Always null on GitHub. */
|
|
2947
|
+
parentEpic: {
|
|
2948
|
+
id: (string | number) | null;
|
|
2949
|
+
iid: (string | number) | null;
|
|
2950
|
+
title: string | null;
|
|
2951
|
+
url: string | null;
|
|
2952
|
+
} | null;
|
|
2953
|
+
/** @description GitHub parent issue, as an API url — the payload carries no id. Always null on GitLab, which expresses the same idea through `parentEpic`. */
|
|
2954
|
+
parentIssueUrl: string | null;
|
|
2955
|
+
/** @description GitHub sub-issue progress. Null when the issue has none. */
|
|
2956
|
+
subIssues: {
|
|
2957
|
+
total: string | number;
|
|
2958
|
+
completed: string | number;
|
|
2959
|
+
} | null;
|
|
2960
|
+
/** @description How many items THIS one blocks. Not the inverse of `blockedByCount` — the two directions are reported separately because GitLab only counts this one. */
|
|
2961
|
+
blockingCount: (string | number) | null;
|
|
2962
|
+
/** @description How many items block THIS one. GitHub only; GitLab's payload does not say, so null there means unknown, not zero. */
|
|
2963
|
+
blockedByCount: (string | number) | null;
|
|
2964
|
+
/** @description GitLab time tracking, in seconds. Null when the project does not use it. */
|
|
2965
|
+
timeStats: {
|
|
2966
|
+
estimateSeconds: string | number;
|
|
2967
|
+
spentSeconds: string | number;
|
|
2968
|
+
} | null;
|
|
2969
|
+
/** @description Checklist progress in the description ('3 of 5 tasks'). */
|
|
2970
|
+
taskCompletion: {
|
|
2971
|
+
total: string | number;
|
|
2972
|
+
completed: string | number;
|
|
2973
|
+
} | null;
|
|
2974
|
+
/** @description GitLab issue weight, passed through unchanged — no scale is imposed here. */
|
|
2975
|
+
weight: (string | number) | null;
|
|
2976
|
+
dueDate: string | null;
|
|
2977
|
+
startDate: string | null;
|
|
2978
|
+
/** @description GitLab health status (`on_track`, `needs_attention`, `at_risk`), verbatim. */
|
|
2979
|
+
healthStatus: string | null;
|
|
2980
|
+
/** @description Incident severity. Meaningful when `issueType === 'incident'`. */
|
|
2981
|
+
severity: string | null;
|
|
2554
2982
|
iteration: {
|
|
2555
2983
|
id: string | number;
|
|
2556
2984
|
title: string;
|
|
@@ -2615,6 +3043,10 @@ export interface operations {
|
|
|
2615
3043
|
}[];
|
|
2616
3044
|
updatedAt: string;
|
|
2617
3045
|
mergedAt: string | null;
|
|
3046
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
3047
|
+
mergedBy: string | null;
|
|
3048
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
3049
|
+
targetBranch: string | null;
|
|
2618
3050
|
reviewRequestedAt: string | null;
|
|
2619
3051
|
volume: {
|
|
2620
3052
|
additions: string | number;
|
|
@@ -2800,6 +3232,48 @@ export interface operations {
|
|
|
2800
3232
|
issueType: "issue" | "task" | "incident" | "test_case" | "other" | null;
|
|
2801
3233
|
/** @description The provider's own word for the kind, unmapped: `task` on GitLab, `Feature` on a GitHub org that defined it. `null` when the provider said nothing. GitHub issue types are org-defined, so this is deliberately NOT normalised across providers — branch on `source` if you need the raw taxonomy. */
|
|
2802
3234
|
originalType: string | null;
|
|
3235
|
+
/** @description When the item was closed. Distinct from `mergedAt` — a PR/MR can be closed without merging, and an issue is never merged. */
|
|
3236
|
+
closedAt: string | null;
|
|
3237
|
+
/** @description Login of whoever closed it. A LOGIN, never a display name — same strict rule as `author`, so it can be joined against `?author`. */
|
|
3238
|
+
closedBy: string | null;
|
|
3239
|
+
/** @description GitHub only. `not_planned` means the issue was closed WITHOUT being done — a delivery report that ignores this counts abandoned work as delivered. Always null on GitLab, which has no equivalent. */
|
|
3240
|
+
stateReason: "completed" | "not_planned" | "reopened" | null;
|
|
3241
|
+
/** @description GitLab parent epic, read from the issue's own payload. Epics themselves are NOT ingested (they are group-level), but this is enough to walk PR → issue → epic. Always null on GitHub. */
|
|
3242
|
+
parentEpic: {
|
|
3243
|
+
id: (string | number) | null;
|
|
3244
|
+
iid: (string | number) | null;
|
|
3245
|
+
title: string | null;
|
|
3246
|
+
url: string | null;
|
|
3247
|
+
} | null;
|
|
3248
|
+
/** @description GitHub parent issue, as an API url — the payload carries no id. Always null on GitLab, which expresses the same idea through `parentEpic`. */
|
|
3249
|
+
parentIssueUrl: string | null;
|
|
3250
|
+
/** @description GitHub sub-issue progress. Null when the issue has none. */
|
|
3251
|
+
subIssues: {
|
|
3252
|
+
total: string | number;
|
|
3253
|
+
completed: string | number;
|
|
3254
|
+
} | null;
|
|
3255
|
+
/** @description How many items THIS one blocks. Not the inverse of `blockedByCount` — the two directions are reported separately because GitLab only counts this one. */
|
|
3256
|
+
blockingCount: (string | number) | null;
|
|
3257
|
+
/** @description How many items block THIS one. GitHub only; GitLab's payload does not say, so null there means unknown, not zero. */
|
|
3258
|
+
blockedByCount: (string | number) | null;
|
|
3259
|
+
/** @description GitLab time tracking, in seconds. Null when the project does not use it. */
|
|
3260
|
+
timeStats: {
|
|
3261
|
+
estimateSeconds: string | number;
|
|
3262
|
+
spentSeconds: string | number;
|
|
3263
|
+
} | null;
|
|
3264
|
+
/** @description Checklist progress in the description ('3 of 5 tasks'). */
|
|
3265
|
+
taskCompletion: {
|
|
3266
|
+
total: string | number;
|
|
3267
|
+
completed: string | number;
|
|
3268
|
+
} | null;
|
|
3269
|
+
/** @description GitLab issue weight, passed through unchanged — no scale is imposed here. */
|
|
3270
|
+
weight: (string | number) | null;
|
|
3271
|
+
dueDate: string | null;
|
|
3272
|
+
startDate: string | null;
|
|
3273
|
+
/** @description GitLab health status (`on_track`, `needs_attention`, `at_risk`), verbatim. */
|
|
3274
|
+
healthStatus: string | null;
|
|
3275
|
+
/** @description Incident severity. Meaningful when `issueType === 'incident'`. */
|
|
3276
|
+
severity: string | null;
|
|
2803
3277
|
iteration: {
|
|
2804
3278
|
id: string | number;
|
|
2805
3279
|
title: string;
|
|
@@ -2864,6 +3338,10 @@ export interface operations {
|
|
|
2864
3338
|
}[];
|
|
2865
3339
|
updatedAt: string;
|
|
2866
3340
|
mergedAt: string | null;
|
|
3341
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
3342
|
+
mergedBy: string | null;
|
|
3343
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
3344
|
+
targetBranch: string | null;
|
|
2867
3345
|
reviewRequestedAt: string | null;
|
|
2868
3346
|
volume: {
|
|
2869
3347
|
additions: string | number;
|
|
@@ -2988,6 +3466,48 @@ export interface operations {
|
|
|
2988
3466
|
issueType: "issue" | "task" | "incident" | "test_case" | "other" | null;
|
|
2989
3467
|
/** @description The provider's own word for the kind, unmapped: `task` on GitLab, `Feature` on a GitHub org that defined it. `null` when the provider said nothing. GitHub issue types are org-defined, so this is deliberately NOT normalised across providers — branch on `source` if you need the raw taxonomy. */
|
|
2990
3468
|
originalType: string | null;
|
|
3469
|
+
/** @description When the item was closed. Distinct from `mergedAt` — a PR/MR can be closed without merging, and an issue is never merged. */
|
|
3470
|
+
closedAt: string | null;
|
|
3471
|
+
/** @description Login of whoever closed it. A LOGIN, never a display name — same strict rule as `author`, so it can be joined against `?author`. */
|
|
3472
|
+
closedBy: string | null;
|
|
3473
|
+
/** @description GitHub only. `not_planned` means the issue was closed WITHOUT being done — a delivery report that ignores this counts abandoned work as delivered. Always null on GitLab, which has no equivalent. */
|
|
3474
|
+
stateReason: "completed" | "not_planned" | "reopened" | null;
|
|
3475
|
+
/** @description GitLab parent epic, read from the issue's own payload. Epics themselves are NOT ingested (they are group-level), but this is enough to walk PR → issue → epic. Always null on GitHub. */
|
|
3476
|
+
parentEpic: {
|
|
3477
|
+
id: (string | number) | null;
|
|
3478
|
+
iid: (string | number) | null;
|
|
3479
|
+
title: string | null;
|
|
3480
|
+
url: string | null;
|
|
3481
|
+
} | null;
|
|
3482
|
+
/** @description GitHub parent issue, as an API url — the payload carries no id. Always null on GitLab, which expresses the same idea through `parentEpic`. */
|
|
3483
|
+
parentIssueUrl: string | null;
|
|
3484
|
+
/** @description GitHub sub-issue progress. Null when the issue has none. */
|
|
3485
|
+
subIssues: {
|
|
3486
|
+
total: string | number;
|
|
3487
|
+
completed: string | number;
|
|
3488
|
+
} | null;
|
|
3489
|
+
/** @description How many items THIS one blocks. Not the inverse of `blockedByCount` — the two directions are reported separately because GitLab only counts this one. */
|
|
3490
|
+
blockingCount: (string | number) | null;
|
|
3491
|
+
/** @description How many items block THIS one. GitHub only; GitLab's payload does not say, so null there means unknown, not zero. */
|
|
3492
|
+
blockedByCount: (string | number) | null;
|
|
3493
|
+
/** @description GitLab time tracking, in seconds. Null when the project does not use it. */
|
|
3494
|
+
timeStats: {
|
|
3495
|
+
estimateSeconds: string | number;
|
|
3496
|
+
spentSeconds: string | number;
|
|
3497
|
+
} | null;
|
|
3498
|
+
/** @description Checklist progress in the description ('3 of 5 tasks'). */
|
|
3499
|
+
taskCompletion: {
|
|
3500
|
+
total: string | number;
|
|
3501
|
+
completed: string | number;
|
|
3502
|
+
} | null;
|
|
3503
|
+
/** @description GitLab issue weight, passed through unchanged — no scale is imposed here. */
|
|
3504
|
+
weight: (string | number) | null;
|
|
3505
|
+
dueDate: string | null;
|
|
3506
|
+
startDate: string | null;
|
|
3507
|
+
/** @description GitLab health status (`on_track`, `needs_attention`, `at_risk`), verbatim. */
|
|
3508
|
+
healthStatus: string | null;
|
|
3509
|
+
/** @description Incident severity. Meaningful when `issueType === 'incident'`. */
|
|
3510
|
+
severity: string | null;
|
|
2991
3511
|
iteration: {
|
|
2992
3512
|
id: string | number;
|
|
2993
3513
|
title: string;
|
|
@@ -3052,6 +3572,10 @@ export interface operations {
|
|
|
3052
3572
|
}[];
|
|
3053
3573
|
updatedAt: string;
|
|
3054
3574
|
mergedAt: string | null;
|
|
3575
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
3576
|
+
mergedBy: string | null;
|
|
3577
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
3578
|
+
targetBranch: string | null;
|
|
3055
3579
|
reviewRequestedAt: string | null;
|
|
3056
3580
|
volume: {
|
|
3057
3581
|
additions: string | number;
|
|
@@ -3176,6 +3700,48 @@ export interface operations {
|
|
|
3176
3700
|
issueType: "issue" | "task" | "incident" | "test_case" | "other" | null;
|
|
3177
3701
|
/** @description The provider's own word for the kind, unmapped: `task` on GitLab, `Feature` on a GitHub org that defined it. `null` when the provider said nothing. GitHub issue types are org-defined, so this is deliberately NOT normalised across providers — branch on `source` if you need the raw taxonomy. */
|
|
3178
3702
|
originalType: string | null;
|
|
3703
|
+
/** @description When the item was closed. Distinct from `mergedAt` — a PR/MR can be closed without merging, and an issue is never merged. */
|
|
3704
|
+
closedAt: string | null;
|
|
3705
|
+
/** @description Login of whoever closed it. A LOGIN, never a display name — same strict rule as `author`, so it can be joined against `?author`. */
|
|
3706
|
+
closedBy: string | null;
|
|
3707
|
+
/** @description GitHub only. `not_planned` means the issue was closed WITHOUT being done — a delivery report that ignores this counts abandoned work as delivered. Always null on GitLab, which has no equivalent. */
|
|
3708
|
+
stateReason: "completed" | "not_planned" | "reopened" | null;
|
|
3709
|
+
/** @description GitLab parent epic, read from the issue's own payload. Epics themselves are NOT ingested (they are group-level), but this is enough to walk PR → issue → epic. Always null on GitHub. */
|
|
3710
|
+
parentEpic: {
|
|
3711
|
+
id: (string | number) | null;
|
|
3712
|
+
iid: (string | number) | null;
|
|
3713
|
+
title: string | null;
|
|
3714
|
+
url: string | null;
|
|
3715
|
+
} | null;
|
|
3716
|
+
/** @description GitHub parent issue, as an API url — the payload carries no id. Always null on GitLab, which expresses the same idea through `parentEpic`. */
|
|
3717
|
+
parentIssueUrl: string | null;
|
|
3718
|
+
/** @description GitHub sub-issue progress. Null when the issue has none. */
|
|
3719
|
+
subIssues: {
|
|
3720
|
+
total: string | number;
|
|
3721
|
+
completed: string | number;
|
|
3722
|
+
} | null;
|
|
3723
|
+
/** @description How many items THIS one blocks. Not the inverse of `blockedByCount` — the two directions are reported separately because GitLab only counts this one. */
|
|
3724
|
+
blockingCount: (string | number) | null;
|
|
3725
|
+
/** @description How many items block THIS one. GitHub only; GitLab's payload does not say, so null there means unknown, not zero. */
|
|
3726
|
+
blockedByCount: (string | number) | null;
|
|
3727
|
+
/** @description GitLab time tracking, in seconds. Null when the project does not use it. */
|
|
3728
|
+
timeStats: {
|
|
3729
|
+
estimateSeconds: string | number;
|
|
3730
|
+
spentSeconds: string | number;
|
|
3731
|
+
} | null;
|
|
3732
|
+
/** @description Checklist progress in the description ('3 of 5 tasks'). */
|
|
3733
|
+
taskCompletion: {
|
|
3734
|
+
total: string | number;
|
|
3735
|
+
completed: string | number;
|
|
3736
|
+
} | null;
|
|
3737
|
+
/** @description GitLab issue weight, passed through unchanged — no scale is imposed here. */
|
|
3738
|
+
weight: (string | number) | null;
|
|
3739
|
+
dueDate: string | null;
|
|
3740
|
+
startDate: string | null;
|
|
3741
|
+
/** @description GitLab health status (`on_track`, `needs_attention`, `at_risk`), verbatim. */
|
|
3742
|
+
healthStatus: string | null;
|
|
3743
|
+
/** @description Incident severity. Meaningful when `issueType === 'incident'`. */
|
|
3744
|
+
severity: string | null;
|
|
3179
3745
|
iteration: {
|
|
3180
3746
|
id: string | number;
|
|
3181
3747
|
title: string;
|
|
@@ -3240,6 +3806,10 @@ export interface operations {
|
|
|
3240
3806
|
}[];
|
|
3241
3807
|
updatedAt: string;
|
|
3242
3808
|
mergedAt: string | null;
|
|
3809
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
3810
|
+
mergedBy: string | null;
|
|
3811
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
3812
|
+
targetBranch: string | null;
|
|
3243
3813
|
reviewRequestedAt: string | null;
|
|
3244
3814
|
volume: {
|
|
3245
3815
|
additions: string | number;
|
|
@@ -4258,6 +4828,52 @@ export interface operations {
|
|
|
4258
4828
|
issueType: "issue" | "task" | "incident" | "test_case" | "other" | null;
|
|
4259
4829
|
/** @description The provider's own word for the kind, unmapped: `task` on GitLab, `Feature` on a GitHub org that defined it. `null` when the provider said nothing. GitHub issue types are org-defined, so this is deliberately NOT normalised across providers — branch on `source` if you need the raw taxonomy. */
|
|
4260
4830
|
originalType: string | null;
|
|
4831
|
+
/** @description When the item was closed. Distinct from `mergedAt` — a PR/MR can be closed without merging, and an issue is never merged. */
|
|
4832
|
+
closedAt: string | null;
|
|
4833
|
+
/** @description Login of whoever closed it. A LOGIN, never a display name — same strict rule as `author`, so it can be joined against `?author`. */
|
|
4834
|
+
closedBy: string | null;
|
|
4835
|
+
/** @description GitHub only. `not_planned` means the issue was closed WITHOUT being done — a delivery report that ignores this counts abandoned work as delivered. Always null on GitLab, which has no equivalent. */
|
|
4836
|
+
stateReason: "completed" | "not_planned" | "reopened" | null;
|
|
4837
|
+
/** @description GitLab parent epic, read from the issue's own payload. Epics themselves are NOT ingested (they are group-level), but this is enough to walk PR → issue → epic. Always null on GitHub. */
|
|
4838
|
+
parentEpic: {
|
|
4839
|
+
id: (string | number) | null;
|
|
4840
|
+
iid: (string | number) | null;
|
|
4841
|
+
title: string | null;
|
|
4842
|
+
url: string | null;
|
|
4843
|
+
} | null;
|
|
4844
|
+
/** @description GitHub parent issue, as an API url — the payload carries no id. Always null on GitLab, which expresses the same idea through `parentEpic`. */
|
|
4845
|
+
parentIssueUrl: string | null;
|
|
4846
|
+
/** @description GitHub sub-issue progress. Null when the issue has none. */
|
|
4847
|
+
subIssues: {
|
|
4848
|
+
total: string | number;
|
|
4849
|
+
completed: string | number;
|
|
4850
|
+
} | null;
|
|
4851
|
+
/** @description How many items THIS one blocks. Not the inverse of `blockedByCount` — the two directions are reported separately because GitLab only counts this one. */
|
|
4852
|
+
blockingCount: (string | number) | null;
|
|
4853
|
+
/** @description How many items block THIS one. GitHub only; GitLab's payload does not say, so null there means unknown, not zero. */
|
|
4854
|
+
blockedByCount: (string | number) | null;
|
|
4855
|
+
/** @description GitLab time tracking, in seconds. Null when the project does not use it. */
|
|
4856
|
+
timeStats: {
|
|
4857
|
+
estimateSeconds: string | number;
|
|
4858
|
+
spentSeconds: string | number;
|
|
4859
|
+
} | null;
|
|
4860
|
+
/** @description Checklist progress in the description ('3 of 5 tasks'). */
|
|
4861
|
+
taskCompletion: {
|
|
4862
|
+
total: string | number;
|
|
4863
|
+
completed: string | number;
|
|
4864
|
+
} | null;
|
|
4865
|
+
/** @description GitLab issue weight, passed through unchanged — no scale is imposed here. */
|
|
4866
|
+
weight: (string | number) | null;
|
|
4867
|
+
dueDate: string | null;
|
|
4868
|
+
startDate: string | null;
|
|
4869
|
+
/** @description GitLab health status (`on_track`, `needs_attention`, `at_risk`), verbatim. */
|
|
4870
|
+
healthStatus: string | null;
|
|
4871
|
+
/** @description Incident severity. Meaningful when `issueType === 'incident'`. */
|
|
4872
|
+
severity: string | null;
|
|
4873
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
4874
|
+
mergedBy: string | null;
|
|
4875
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
4876
|
+
targetBranch: string | null;
|
|
4261
4877
|
number: string | number;
|
|
4262
4878
|
title: string;
|
|
4263
4879
|
body: string | null;
|
|
@@ -4318,6 +4934,52 @@ export interface operations {
|
|
|
4318
4934
|
issueType: "issue" | "task" | "incident" | "test_case" | "other" | null;
|
|
4319
4935
|
/** @description The provider's own word for the kind, unmapped: `task` on GitLab, `Feature` on a GitHub org that defined it. `null` when the provider said nothing. GitHub issue types are org-defined, so this is deliberately NOT normalised across providers — branch on `source` if you need the raw taxonomy. */
|
|
4320
4936
|
originalType: string | null;
|
|
4937
|
+
/** @description When the item was closed. Distinct from `mergedAt` — a PR/MR can be closed without merging, and an issue is never merged. */
|
|
4938
|
+
closedAt: string | null;
|
|
4939
|
+
/** @description Login of whoever closed it. A LOGIN, never a display name — same strict rule as `author`, so it can be joined against `?author`. */
|
|
4940
|
+
closedBy: string | null;
|
|
4941
|
+
/** @description GitHub only. `not_planned` means the issue was closed WITHOUT being done — a delivery report that ignores this counts abandoned work as delivered. Always null on GitLab, which has no equivalent. */
|
|
4942
|
+
stateReason: "completed" | "not_planned" | "reopened" | null;
|
|
4943
|
+
/** @description GitLab parent epic, read from the issue's own payload. Epics themselves are NOT ingested (they are group-level), but this is enough to walk PR → issue → epic. Always null on GitHub. */
|
|
4944
|
+
parentEpic: {
|
|
4945
|
+
id: (string | number) | null;
|
|
4946
|
+
iid: (string | number) | null;
|
|
4947
|
+
title: string | null;
|
|
4948
|
+
url: string | null;
|
|
4949
|
+
} | null;
|
|
4950
|
+
/** @description GitHub parent issue, as an API url — the payload carries no id. Always null on GitLab, which expresses the same idea through `parentEpic`. */
|
|
4951
|
+
parentIssueUrl: string | null;
|
|
4952
|
+
/** @description GitHub sub-issue progress. Null when the issue has none. */
|
|
4953
|
+
subIssues: {
|
|
4954
|
+
total: string | number;
|
|
4955
|
+
completed: string | number;
|
|
4956
|
+
} | null;
|
|
4957
|
+
/** @description How many items THIS one blocks. Not the inverse of `blockedByCount` — the two directions are reported separately because GitLab only counts this one. */
|
|
4958
|
+
blockingCount: (string | number) | null;
|
|
4959
|
+
/** @description How many items block THIS one. GitHub only; GitLab's payload does not say, so null there means unknown, not zero. */
|
|
4960
|
+
blockedByCount: (string | number) | null;
|
|
4961
|
+
/** @description GitLab time tracking, in seconds. Null when the project does not use it. */
|
|
4962
|
+
timeStats: {
|
|
4963
|
+
estimateSeconds: string | number;
|
|
4964
|
+
spentSeconds: string | number;
|
|
4965
|
+
} | null;
|
|
4966
|
+
/** @description Checklist progress in the description ('3 of 5 tasks'). */
|
|
4967
|
+
taskCompletion: {
|
|
4968
|
+
total: string | number;
|
|
4969
|
+
completed: string | number;
|
|
4970
|
+
} | null;
|
|
4971
|
+
/** @description GitLab issue weight, passed through unchanged — no scale is imposed here. */
|
|
4972
|
+
weight: (string | number) | null;
|
|
4973
|
+
dueDate: string | null;
|
|
4974
|
+
startDate: string | null;
|
|
4975
|
+
/** @description GitLab health status (`on_track`, `needs_attention`, `at_risk`), verbatim. */
|
|
4976
|
+
healthStatus: string | null;
|
|
4977
|
+
/** @description Incident severity. Meaningful when `issueType === 'incident'`. */
|
|
4978
|
+
severity: string | null;
|
|
4979
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
4980
|
+
mergedBy: string | null;
|
|
4981
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
4982
|
+
targetBranch: string | null;
|
|
4321
4983
|
number: string | number;
|
|
4322
4984
|
title: string;
|
|
4323
4985
|
body: string | null;
|
|
@@ -4378,6 +5040,52 @@ export interface operations {
|
|
|
4378
5040
|
issueType: "issue" | "task" | "incident" | "test_case" | "other" | null;
|
|
4379
5041
|
/** @description The provider's own word for the kind, unmapped: `task` on GitLab, `Feature` on a GitHub org that defined it. `null` when the provider said nothing. GitHub issue types are org-defined, so this is deliberately NOT normalised across providers — branch on `source` if you need the raw taxonomy. */
|
|
4380
5042
|
originalType: string | null;
|
|
5043
|
+
/** @description When the item was closed. Distinct from `mergedAt` — a PR/MR can be closed without merging, and an issue is never merged. */
|
|
5044
|
+
closedAt: string | null;
|
|
5045
|
+
/** @description Login of whoever closed it. A LOGIN, never a display name — same strict rule as `author`, so it can be joined against `?author`. */
|
|
5046
|
+
closedBy: string | null;
|
|
5047
|
+
/** @description GitHub only. `not_planned` means the issue was closed WITHOUT being done — a delivery report that ignores this counts abandoned work as delivered. Always null on GitLab, which has no equivalent. */
|
|
5048
|
+
stateReason: "completed" | "not_planned" | "reopened" | null;
|
|
5049
|
+
/** @description GitLab parent epic, read from the issue's own payload. Epics themselves are NOT ingested (they are group-level), but this is enough to walk PR → issue → epic. Always null on GitHub. */
|
|
5050
|
+
parentEpic: {
|
|
5051
|
+
id: (string | number) | null;
|
|
5052
|
+
iid: (string | number) | null;
|
|
5053
|
+
title: string | null;
|
|
5054
|
+
url: string | null;
|
|
5055
|
+
} | null;
|
|
5056
|
+
/** @description GitHub parent issue, as an API url — the payload carries no id. Always null on GitLab, which expresses the same idea through `parentEpic`. */
|
|
5057
|
+
parentIssueUrl: string | null;
|
|
5058
|
+
/** @description GitHub sub-issue progress. Null when the issue has none. */
|
|
5059
|
+
subIssues: {
|
|
5060
|
+
total: string | number;
|
|
5061
|
+
completed: string | number;
|
|
5062
|
+
} | null;
|
|
5063
|
+
/** @description How many items THIS one blocks. Not the inverse of `blockedByCount` — the two directions are reported separately because GitLab only counts this one. */
|
|
5064
|
+
blockingCount: (string | number) | null;
|
|
5065
|
+
/** @description How many items block THIS one. GitHub only; GitLab's payload does not say, so null there means unknown, not zero. */
|
|
5066
|
+
blockedByCount: (string | number) | null;
|
|
5067
|
+
/** @description GitLab time tracking, in seconds. Null when the project does not use it. */
|
|
5068
|
+
timeStats: {
|
|
5069
|
+
estimateSeconds: string | number;
|
|
5070
|
+
spentSeconds: string | number;
|
|
5071
|
+
} | null;
|
|
5072
|
+
/** @description Checklist progress in the description ('3 of 5 tasks'). */
|
|
5073
|
+
taskCompletion: {
|
|
5074
|
+
total: string | number;
|
|
5075
|
+
completed: string | number;
|
|
5076
|
+
} | null;
|
|
5077
|
+
/** @description GitLab issue weight, passed through unchanged — no scale is imposed here. */
|
|
5078
|
+
weight: (string | number) | null;
|
|
5079
|
+
dueDate: string | null;
|
|
5080
|
+
startDate: string | null;
|
|
5081
|
+
/** @description GitLab health status (`on_track`, `needs_attention`, `at_risk`), verbatim. */
|
|
5082
|
+
healthStatus: string | null;
|
|
5083
|
+
/** @description Incident severity. Meaningful when `issueType === 'incident'`. */
|
|
5084
|
+
severity: string | null;
|
|
5085
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
5086
|
+
mergedBy: string | null;
|
|
5087
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
5088
|
+
targetBranch: string | null;
|
|
4381
5089
|
number: string | number;
|
|
4382
5090
|
title: string;
|
|
4383
5091
|
body: string | null;
|
|
@@ -4567,6 +5275,10 @@ export interface operations {
|
|
|
4567
5275
|
}[];
|
|
4568
5276
|
updatedAt: string;
|
|
4569
5277
|
mergedAt: string | null;
|
|
5278
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
5279
|
+
mergedBy: string | null;
|
|
5280
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
5281
|
+
targetBranch: string | null;
|
|
4570
5282
|
reviewRequestedAt: string | null;
|
|
4571
5283
|
volume: {
|
|
4572
5284
|
additions: string | number;
|
|
@@ -4689,6 +5401,48 @@ export interface operations {
|
|
|
4689
5401
|
issueType: "issue" | "task" | "incident" | "test_case" | "other" | null;
|
|
4690
5402
|
/** @description The provider's own word for the kind, unmapped: `task` on GitLab, `Feature` on a GitHub org that defined it. `null` when the provider said nothing. GitHub issue types are org-defined, so this is deliberately NOT normalised across providers — branch on `source` if you need the raw taxonomy. */
|
|
4691
5403
|
originalType: string | null;
|
|
5404
|
+
/** @description When the item was closed. Distinct from `mergedAt` — a PR/MR can be closed without merging, and an issue is never merged. */
|
|
5405
|
+
closedAt: string | null;
|
|
5406
|
+
/** @description Login of whoever closed it. A LOGIN, never a display name — same strict rule as `author`, so it can be joined against `?author`. */
|
|
5407
|
+
closedBy: string | null;
|
|
5408
|
+
/** @description GitHub only. `not_planned` means the issue was closed WITHOUT being done — a delivery report that ignores this counts abandoned work as delivered. Always null on GitLab, which has no equivalent. */
|
|
5409
|
+
stateReason: "completed" | "not_planned" | "reopened" | null;
|
|
5410
|
+
/** @description GitLab parent epic, read from the issue's own payload. Epics themselves are NOT ingested (they are group-level), but this is enough to walk PR → issue → epic. Always null on GitHub. */
|
|
5411
|
+
parentEpic: {
|
|
5412
|
+
id: (string | number) | null;
|
|
5413
|
+
iid: (string | number) | null;
|
|
5414
|
+
title: string | null;
|
|
5415
|
+
url: string | null;
|
|
5416
|
+
} | null;
|
|
5417
|
+
/** @description GitHub parent issue, as an API url — the payload carries no id. Always null on GitLab, which expresses the same idea through `parentEpic`. */
|
|
5418
|
+
parentIssueUrl: string | null;
|
|
5419
|
+
/** @description GitHub sub-issue progress. Null when the issue has none. */
|
|
5420
|
+
subIssues: {
|
|
5421
|
+
total: string | number;
|
|
5422
|
+
completed: string | number;
|
|
5423
|
+
} | null;
|
|
5424
|
+
/** @description How many items THIS one blocks. Not the inverse of `blockedByCount` — the two directions are reported separately because GitLab only counts this one. */
|
|
5425
|
+
blockingCount: (string | number) | null;
|
|
5426
|
+
/** @description How many items block THIS one. GitHub only; GitLab's payload does not say, so null there means unknown, not zero. */
|
|
5427
|
+
blockedByCount: (string | number) | null;
|
|
5428
|
+
/** @description GitLab time tracking, in seconds. Null when the project does not use it. */
|
|
5429
|
+
timeStats: {
|
|
5430
|
+
estimateSeconds: string | number;
|
|
5431
|
+
spentSeconds: string | number;
|
|
5432
|
+
} | null;
|
|
5433
|
+
/** @description Checklist progress in the description ('3 of 5 tasks'). */
|
|
5434
|
+
taskCompletion: {
|
|
5435
|
+
total: string | number;
|
|
5436
|
+
completed: string | number;
|
|
5437
|
+
} | null;
|
|
5438
|
+
/** @description GitLab issue weight, passed through unchanged — no scale is imposed here. */
|
|
5439
|
+
weight: (string | number) | null;
|
|
5440
|
+
dueDate: string | null;
|
|
5441
|
+
startDate: string | null;
|
|
5442
|
+
/** @description GitLab health status (`on_track`, `needs_attention`, `at_risk`), verbatim. */
|
|
5443
|
+
healthStatus: string | null;
|
|
5444
|
+
/** @description Incident severity. Meaningful when `issueType === 'incident'`. */
|
|
5445
|
+
severity: string | null;
|
|
4692
5446
|
iteration: {
|
|
4693
5447
|
id: string | number;
|
|
4694
5448
|
title: string;
|
|
@@ -4793,6 +5547,10 @@ export interface operations {
|
|
|
4793
5547
|
}[];
|
|
4794
5548
|
updatedAt: string;
|
|
4795
5549
|
mergedAt: string | null;
|
|
5550
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
5551
|
+
mergedBy: string | null;
|
|
5552
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
5553
|
+
targetBranch: string | null;
|
|
4796
5554
|
reviewRequestedAt: string | null;
|
|
4797
5555
|
volume: {
|
|
4798
5556
|
additions: string | number;
|
|
@@ -4915,6 +5673,48 @@ export interface operations {
|
|
|
4915
5673
|
issueType: "issue" | "task" | "incident" | "test_case" | "other" | null;
|
|
4916
5674
|
/** @description The provider's own word for the kind, unmapped: `task` on GitLab, `Feature` on a GitHub org that defined it. `null` when the provider said nothing. GitHub issue types are org-defined, so this is deliberately NOT normalised across providers — branch on `source` if you need the raw taxonomy. */
|
|
4917
5675
|
originalType: string | null;
|
|
5676
|
+
/** @description When the item was closed. Distinct from `mergedAt` — a PR/MR can be closed without merging, and an issue is never merged. */
|
|
5677
|
+
closedAt: string | null;
|
|
5678
|
+
/** @description Login of whoever closed it. A LOGIN, never a display name — same strict rule as `author`, so it can be joined against `?author`. */
|
|
5679
|
+
closedBy: string | null;
|
|
5680
|
+
/** @description GitHub only. `not_planned` means the issue was closed WITHOUT being done — a delivery report that ignores this counts abandoned work as delivered. Always null on GitLab, which has no equivalent. */
|
|
5681
|
+
stateReason: "completed" | "not_planned" | "reopened" | null;
|
|
5682
|
+
/** @description GitLab parent epic, read from the issue's own payload. Epics themselves are NOT ingested (they are group-level), but this is enough to walk PR → issue → epic. Always null on GitHub. */
|
|
5683
|
+
parentEpic: {
|
|
5684
|
+
id: (string | number) | null;
|
|
5685
|
+
iid: (string | number) | null;
|
|
5686
|
+
title: string | null;
|
|
5687
|
+
url: string | null;
|
|
5688
|
+
} | null;
|
|
5689
|
+
/** @description GitHub parent issue, as an API url — the payload carries no id. Always null on GitLab, which expresses the same idea through `parentEpic`. */
|
|
5690
|
+
parentIssueUrl: string | null;
|
|
5691
|
+
/** @description GitHub sub-issue progress. Null when the issue has none. */
|
|
5692
|
+
subIssues: {
|
|
5693
|
+
total: string | number;
|
|
5694
|
+
completed: string | number;
|
|
5695
|
+
} | null;
|
|
5696
|
+
/** @description How many items THIS one blocks. Not the inverse of `blockedByCount` — the two directions are reported separately because GitLab only counts this one. */
|
|
5697
|
+
blockingCount: (string | number) | null;
|
|
5698
|
+
/** @description How many items block THIS one. GitHub only; GitLab's payload does not say, so null there means unknown, not zero. */
|
|
5699
|
+
blockedByCount: (string | number) | null;
|
|
5700
|
+
/** @description GitLab time tracking, in seconds. Null when the project does not use it. */
|
|
5701
|
+
timeStats: {
|
|
5702
|
+
estimateSeconds: string | number;
|
|
5703
|
+
spentSeconds: string | number;
|
|
5704
|
+
} | null;
|
|
5705
|
+
/** @description Checklist progress in the description ('3 of 5 tasks'). */
|
|
5706
|
+
taskCompletion: {
|
|
5707
|
+
total: string | number;
|
|
5708
|
+
completed: string | number;
|
|
5709
|
+
} | null;
|
|
5710
|
+
/** @description GitLab issue weight, passed through unchanged — no scale is imposed here. */
|
|
5711
|
+
weight: (string | number) | null;
|
|
5712
|
+
dueDate: string | null;
|
|
5713
|
+
startDate: string | null;
|
|
5714
|
+
/** @description GitLab health status (`on_track`, `needs_attention`, `at_risk`), verbatim. */
|
|
5715
|
+
healthStatus: string | null;
|
|
5716
|
+
/** @description Incident severity. Meaningful when `issueType === 'incident'`. */
|
|
5717
|
+
severity: string | null;
|
|
4918
5718
|
iteration: {
|
|
4919
5719
|
id: string | number;
|
|
4920
5720
|
title: string;
|
|
@@ -5019,6 +5819,10 @@ export interface operations {
|
|
|
5019
5819
|
}[];
|
|
5020
5820
|
updatedAt: string;
|
|
5021
5821
|
mergedAt: string | null;
|
|
5822
|
+
/** @description Login of whoever merged. GitLab only — GitHub's list payload omits it, so null there means unknown, not 'nobody'. */
|
|
5823
|
+
mergedBy: string | null;
|
|
5824
|
+
/** @description Branch merged INTO. The source side is `branch`. */
|
|
5825
|
+
targetBranch: string | null;
|
|
5022
5826
|
reviewRequestedAt: string | null;
|
|
5023
5827
|
volume: {
|
|
5024
5828
|
additions: string | number;
|
|
@@ -5141,6 +5945,48 @@ export interface operations {
|
|
|
5141
5945
|
issueType: "issue" | "task" | "incident" | "test_case" | "other" | null;
|
|
5142
5946
|
/** @description The provider's own word for the kind, unmapped: `task` on GitLab, `Feature` on a GitHub org that defined it. `null` when the provider said nothing. GitHub issue types are org-defined, so this is deliberately NOT normalised across providers — branch on `source` if you need the raw taxonomy. */
|
|
5143
5947
|
originalType: string | null;
|
|
5948
|
+
/** @description When the item was closed. Distinct from `mergedAt` — a PR/MR can be closed without merging, and an issue is never merged. */
|
|
5949
|
+
closedAt: string | null;
|
|
5950
|
+
/** @description Login of whoever closed it. A LOGIN, never a display name — same strict rule as `author`, so it can be joined against `?author`. */
|
|
5951
|
+
closedBy: string | null;
|
|
5952
|
+
/** @description GitHub only. `not_planned` means the issue was closed WITHOUT being done — a delivery report that ignores this counts abandoned work as delivered. Always null on GitLab, which has no equivalent. */
|
|
5953
|
+
stateReason: "completed" | "not_planned" | "reopened" | null;
|
|
5954
|
+
/** @description GitLab parent epic, read from the issue's own payload. Epics themselves are NOT ingested (they are group-level), but this is enough to walk PR → issue → epic. Always null on GitHub. */
|
|
5955
|
+
parentEpic: {
|
|
5956
|
+
id: (string | number) | null;
|
|
5957
|
+
iid: (string | number) | null;
|
|
5958
|
+
title: string | null;
|
|
5959
|
+
url: string | null;
|
|
5960
|
+
} | null;
|
|
5961
|
+
/** @description GitHub parent issue, as an API url — the payload carries no id. Always null on GitLab, which expresses the same idea through `parentEpic`. */
|
|
5962
|
+
parentIssueUrl: string | null;
|
|
5963
|
+
/** @description GitHub sub-issue progress. Null when the issue has none. */
|
|
5964
|
+
subIssues: {
|
|
5965
|
+
total: string | number;
|
|
5966
|
+
completed: string | number;
|
|
5967
|
+
} | null;
|
|
5968
|
+
/** @description How many items THIS one blocks. Not the inverse of `blockedByCount` — the two directions are reported separately because GitLab only counts this one. */
|
|
5969
|
+
blockingCount: (string | number) | null;
|
|
5970
|
+
/** @description How many items block THIS one. GitHub only; GitLab's payload does not say, so null there means unknown, not zero. */
|
|
5971
|
+
blockedByCount: (string | number) | null;
|
|
5972
|
+
/** @description GitLab time tracking, in seconds. Null when the project does not use it. */
|
|
5973
|
+
timeStats: {
|
|
5974
|
+
estimateSeconds: string | number;
|
|
5975
|
+
spentSeconds: string | number;
|
|
5976
|
+
} | null;
|
|
5977
|
+
/** @description Checklist progress in the description ('3 of 5 tasks'). */
|
|
5978
|
+
taskCompletion: {
|
|
5979
|
+
total: string | number;
|
|
5980
|
+
completed: string | number;
|
|
5981
|
+
} | null;
|
|
5982
|
+
/** @description GitLab issue weight, passed through unchanged — no scale is imposed here. */
|
|
5983
|
+
weight: (string | number) | null;
|
|
5984
|
+
dueDate: string | null;
|
|
5985
|
+
startDate: string | null;
|
|
5986
|
+
/** @description GitLab health status (`on_track`, `needs_attention`, `at_risk`), verbatim. */
|
|
5987
|
+
healthStatus: string | null;
|
|
5988
|
+
/** @description Incident severity. Meaningful when `issueType === 'incident'`. */
|
|
5989
|
+
severity: string | null;
|
|
5144
5990
|
iteration: {
|
|
5145
5991
|
id: string | number;
|
|
5146
5992
|
title: string;
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@cesar-richard/git-connector-sdk",
|
|
3
|
-
"version": "4.
|
|
3
|
+
"version": "4.6.0",
|
|
4
4
|
"description": "TypeScript SDK for the git-connector v1 API (work items + iterations aggregated from GitHub/GitLab). Version published on npm tracks server releases.",
|
|
5
5
|
"license": "MIT",
|
|
6
6
|
"repository": {
|