@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 819 lines 41.5 KB
Raw
1 // Generated by @effect/graphql-generator from LinearApi.graphql. Do not edit.
2 import { GraphQL, GraphQLGroup } from "effect/graphql"
3 import * as Schema from "effect/Schema"
4 import * as Shared from "../../schema/linear.graphql.ts"
5
6 /**
7 * `fragment LinearUser on User`
8 *
9 * A user that belongs to a workspace. Users can have different roles (admin, member, guest, or app) that determine their level of access. Users can be members of multiple teams, and can be active or deactivated. Guest users have limited access scoped to specific teams they are invited to.
10 */
11 export const LinearUser = Schema.Struct({
12 /** The unique identifier of the entity. */
13 id: Shared.ID,
14 /** The user's full name. */
15 name: Schema.String,
16 /** The user's display (nick) name. Must be unique within the workspace. */
17 displayName: Schema.String,
18 /** The user's email address. */
19 email: Schema.String,
20 /** An URL to the user's avatar image. */
21 avatarUrl: Schema.NullOr(Schema.String)
22 })
23 export interface LinearUser extends Schema.Struct.Type<typeof LinearUser.fields> {}
24
25 /**
26 * `fragment LinearBot on ActorBot`
27 *
28 * A bot actor representing a non-human entity that performed an action, such as an integration (GitHub, Slack, Zendesk), an AI assistant, or an automated workflow. Bot actors are displayed in activity feeds and history to indicate when changes were made by applications rather than users.
29 */
30 export const LinearBot = Schema.Struct({
31 /** The display name of the bot. */
32 name: Schema.NullOr(Schema.String),
33 /** The display name of the external user on behalf of whom the bot acted. Shown when an integration action was triggered by a specific person in the external system. */
34 userDisplayName: Schema.NullOr(Schema.String),
35 /** A URL pointing to the avatar image representing this bot, typically the integration's logo or icon. */
36 avatarUrl: Schema.NullOr(Schema.String)
37 })
38 export interface LinearBot extends Schema.Struct.Type<typeof LinearBot.fields> {}
39
40 /**
41 * `fragment LinearWorkflowState on WorkflowState`
42 *
43 * A state in a team's workflow, representing an issue status such as Triage, Backlog, Todo, In Progress, In Review, Done, or Canceled. Each team has its own set of workflow states that define the progression of issues through the team's process. Workflow states have a type that categorizes them (triage, backlog, unstarted, started, completed, canceled), a position that determines their display order, and a color for visual identification. States can be inherited from parent teams to sub-teams.
44 */
45 export const LinearWorkflowState = Schema.Struct({
46 /** The unique identifier of the entity. */
47 id: Shared.ID,
48 /** The state's human-readable name (e.g., 'In Progress', 'Done', 'Backlog'). */
49 name: Schema.String,
50 /** The type of the state. One of "triage", "backlog", "unstarted", "started", "completed", "canceled", "duplicate". */
51 type: Schema.String,
52 /** The position of the state in the team's workflow. States are displayed in ascending order of position within their type group. */
53 position: Shared.Float
54 })
55 export interface LinearWorkflowState extends Schema.Struct.Type<typeof LinearWorkflowState.fields> {}
56
57 /**
58 * `fragment LinearLabel on IssueLabel`
59 *
60 * Labels that can be associated with issues. Labels help categorize and filter issues across a workspace. They can be workspace-level (shared across all teams) or team-scoped. Labels have a color for visual identification and can be organized hierarchically into groups, where a parent label acts as a group containing child labels. Labels may also be inherited from parent teams to sub-teams.
61 */
62 export const LinearLabel = Schema.Struct({
63 /** The unique identifier of the entity. */
64 id: Shared.ID,
65 /** The label's name. */
66 name: Schema.String,
67 /** The label's color as a HEX string (e.g., '#EB5757'). Used for visual identification of the label in the UI. */
68 color: Schema.String
69 })
70 export interface LinearLabel extends Schema.Struct.Type<typeof LinearLabel.fields> {}
71
72 /**
73 * `fragment LinearTeamLabel on IssueLabel`
74 *
75 * Labels that can be associated with issues. Labels help categorize and filter issues across a workspace. They can be workspace-level (shared across all teams) or team-scoped. Labels have a color for visual identification and can be organized hierarchically into groups, where a parent label acts as a group containing child labels. Labels may also be inherited from parent teams to sub-teams.
76 */
77 export const LinearTeamLabel = Schema.Struct({
78 ...LinearLabel.fields,
79 /** The label's description. */
80 description: Schema.NullOr(Schema.String)
81 })
82 export interface LinearTeamLabel extends Schema.Struct.Type<typeof LinearTeamLabel.fields> {}
83
84 /**
85 * `fragment LinearReaction on Reaction`
86 *
87 * An emoji reaction on a comment, issue, project update, initiative update, post, pull request, or pull request comment. Each reaction is associated with exactly one parent entity and is created by either a workspace user or an external user. Reactions are persisted individually but surfaced on their parent entities as aggregated reactionData.
88 */
89 export const LinearReaction = Schema.Struct({
90 /** The unique identifier of the entity. */
91 id: Shared.ID,
92 /** The name of the emoji used for this reaction. For custom workspace emojis, this is the custom emoji name; for standard emojis, this is the normalized emoji name. */
93 emoji: Schema.String,
94 /** The workspace user that created the reaction. Null if the reaction was created by an external user through an integration. */
95 user: Schema.NullOr(LinearUser)
96 })
97 export interface LinearReaction extends Schema.Struct.Type<typeof LinearReaction.fields> {}
98
99 /**
100 * `fragment LinearComment on Comment`
101 *
102 * A comment associated with an issue, project update, initiative update, document content, post, project, or initiative. Comments support rich text (ProseMirror), emoji reactions, and threaded replies via parentId. Comments can be created by workspace users or by external users through integrations (e.g., Slack, Intercom). Each comment belongs to exactly one parent entity.
103 */
104 export const LinearComment = Schema.Struct({
105 /** The unique identifier of the entity. */
106 id: Shared.ID,
107 /** The comment content in markdown format. This is a derived representation of the canonical bodyData ProseMirror content. */
108 body: Schema.String,
109 /** The time at which the entity was created. */
110 createdAt: Shared.DateTime,
111 /** Comment's URL. */
112 url: Schema.String,
113 /** The user who wrote the comment. Null for comments created by integrations or bots without a user association. */
114 user: Schema.NullOr(LinearUser),
115 /** The bot that created the comment. */
116 botActor: Schema.NullOr(LinearBot),
117 /** Reactions associated with the comment. */
118 reactions: Schema.Array(LinearReaction)
119 })
120 export interface LinearComment extends Schema.Struct.Type<typeof LinearComment.fields> {}
121
122 /** A team is the primary organizational unit in Linear. Issues belong to teams, and each team has its own workflow states, cycles, labels, and settings. Teams can be public (visible to all workspace members), private (visible only to team members), or restricted (visible only within an enclosing private-team boundary). Teams can also have sub-teams that inherit settings from their parent. */
123 export const LinearIssueTeamTeam = Schema.Struct({
124 /** The team's unique key, used as a prefix in issue identifiers (e.g., 'ENG' in 'ENG-123') and in URLs. */
125 key: Schema.String
126 })
127 export interface LinearIssueTeamTeam extends Schema.Struct.Type<typeof LinearIssueTeamTeam.fields> {}
128
129 export const LinearIssueLabelsIssueLabelConnection = Schema.Struct({
130 nodes: Schema.Array(LinearLabel)
131 })
132 export interface LinearIssueLabelsIssueLabelConnection extends Schema.Struct.Type<typeof LinearIssueLabelsIssueLabelConnection.fields> {}
133
134 /**
135 * `fragment LinearIssue on Issue`
136 *
137 * An issue is the core work item in Linear. Issues belong to a team, have a workflow status, can be assigned to users, carry a priority level, and can be organized into projects and cycles. Issues support sub-issues (parent-child hierarchy up to 10 levels deep), labels, due dates, estimates, and SLA tracking. They can also be linked to other issues via relations, attached to releases, and tracked through their full history of changes.
138 */
139 export const LinearIssue = Schema.Struct({
140 /** The unique identifier of the entity. */
141 id: Shared.ID,
142 /** Issue's human readable identifier (e.g. ENG-123). */
143 identifier: Schema.String,
144 /** The issue's unique number, scoped to the issue's team. Together with the team key, this forms the issue's human-readable identifier (e.g., ENG-123). */
145 number: Shared.Float,
146 /** The issue's title. This is the primary human-readable summary of the work item. */
147 title: Schema.String,
148 /** Issue URL. */
149 url: Schema.String,
150 /** The time at which the entity was created. */
151 createdAt: Shared.DateTime,
152 /**
153 * The last time at which the entity was meaningfully updated. This is the same as the creation time if the entity hasn't
154 * been updated after creation.
155 */
156 updatedAt: Shared.DateTime,
157 /** The time at which the issue was moved into completed state. */
158 completedAt: Schema.NullOr(Shared.DateTime),
159 /** The time at which the issue was moved into canceled state. */
160 canceledAt: Schema.NullOr(Shared.DateTime),
161 /** The workflow state (issue status) that the issue is currently in. Workflow states represent the issue's progress through the team's workflow, such as Triage, Todo, In Progress, Done, or Canceled. */
162 state: LinearWorkflowState,
163 /** The team that the issue belongs to. Every issue must belong to exactly one team, which determines the available workflow states, labels, and other team-specific configuration. */
164 team: LinearIssueTeamTeam,
165 /** The user who created the issue. Null if the creator's account has been deleted or if the issue was created by an integration or system process. */
166 creator: Schema.NullOr(LinearUser),
167 /** The bot that created the issue, if applicable. */
168 botActor: Schema.NullOr(LinearBot),
169 /** The user to whom the issue is assigned. Null if the issue is unassigned. */
170 assignee: Schema.NullOr(LinearUser),
171 /** Labels associated with this issue. */
172 labels: LinearIssueLabelsIssueLabelConnection
173 })
174 export interface LinearIssue extends Schema.Struct.Type<typeof LinearIssue.fields> {}
175
176 /** `fragment LinearPageInfo on PageInfo` */
177 export const LinearPageInfo = Schema.Struct({
178 /** Indicates if there are more results when paginating forward. */
179 hasNextPage: Schema.Boolean,
180 /** Cursor representing the last result in the paginated results. */
181 endCursor: Schema.NullOr(Schema.String)
182 })
183 export interface LinearPageInfo extends Schema.Struct.Type<typeof LinearPageInfo.fields> {}
184
185 /** A workspace (referred to as Organization in the API). Workspaces are the root-level container for all teams, users, projects, issues, and settings. Every user belongs to at least one workspace, and all data is scoped within a workspace boundary. */
186 export const Organization = Schema.Struct({
187 /** The workspace's unique URL key, used in URLs to identify the workspace. */
188 urlKey: Schema.String
189 })
190 export interface Organization extends Schema.Struct.Type<typeof Organization.fields> {}
191
192 /** A team is the primary organizational unit in Linear. Issues belong to teams, and each team has its own workflow states, cycles, labels, and settings. Teams can be public (visible to all workspace members), private (visible only to team members), or restricted (visible only within an enclosing private-team boundary). Teams can also have sub-teams that inherit settings from their parent. */
193 export const T3ViewerTeamsNodesTeam = Schema.Struct({
194 /** The unique identifier of the entity. */
195 id: Shared.ID,
196 /** The team's unique key, used as a prefix in issue identifiers (e.g., 'ENG' in 'ENG-123') and in URLs. */
197 key: Schema.String,
198 /** The team's name. */
199 name: Schema.String
200 })
201 export interface T3ViewerTeamsNodesTeam extends Schema.Struct.Type<typeof T3ViewerTeamsNodesTeam.fields> {}
202
203 export const T3ViewerTeamsTeamConnection = Schema.Struct({
204 nodes: Schema.Array(T3ViewerTeamsNodesTeam)
205 })
206 export interface T3ViewerTeamsTeamConnection extends Schema.Struct.Type<typeof T3ViewerTeamsTeamConnection.fields> {}
207
208 /** `query T3Viewer` */
209 export const T3Viewer = GraphQL.query("T3Viewer", {
210 document: {
211 variables: [],
212 selections: [
213 { name: "viewer", body: ["{...LinearUser}"] },
214 { name: "organization", body: ["{urlKey}"] },
215 { name: "teams", body: ["(first:250){nodes{id key name}}"] }
216 ],
217 fragments: [
218 { name: "LinearUser", body: ["on User{id name displayName email avatarUrl}"] }
219 ]
220 },
221 result: Schema.Struct({
222 /** The currently authenticated user making the API request. */
223 viewer: LinearUser,
224 /** The authenticated user's workspace. */
225 organization: Organization,
226 /** All teams whose issues the user can access. This includes public teams and private teams the user is a member of. This may differ from `administrableTeams`, which returns teams whose settings the user can change but whose issues they don't necessarily have access to. */
227 teams: T3ViewerTeamsTeamConnection
228 })
229 })
230 export declare namespace T3Viewer {
231 export type Variables = typeof T3Viewer.variables.Type
232 export type Result = typeof T3Viewer.result.Type
233 }
234
235 export const IssueConnection = Schema.Struct({
236 nodes: Schema.Array(LinearIssue),
237 pageInfo: LinearPageInfo
238 })
239 export interface IssueConnection extends Schema.Struct.Type<typeof IssueConnection.fields> {}
240
241 /** `query T3Issues` */
242 export const T3Issues = GraphQL.query("T3Issues", {
243 document: {
244 variables: [
245 { name: "first", body: "Int!" },
246 { name: "after", body: "String" },
247 { name: "filter", body: "IssueFilter!" },
248 { name: "orderBy", body: "PaginationOrderBy!" }
249 ],
250 selections: [
251 { name: "issues", body: ["(first:$", "first", " after:$", "after", " filter:$", "filter", " orderBy:$", "orderBy", "){nodes{...LinearIssue}pageInfo{...LinearPageInfo}}"] }
252 ],
253 fragments: [
254 { name: "LinearIssue", body: ["on Issue{id identifier number title url createdAt updatedAt completedAt canceledAt state{...LinearWorkflowState}team{key}creator{...LinearUser}botActor{...LinearBot}assignee{...LinearUser}labels{nodes{...LinearLabel}}}"] },
255 { name: "LinearPageInfo", body: ["on PageInfo{hasNextPage endCursor}"] },
256 { name: "LinearWorkflowState", body: ["on WorkflowState{id name type position}"] },
257 { name: "LinearUser", body: ["on User{id name displayName email avatarUrl}"] },
258 { name: "LinearBot", body: ["on ActorBot{name userDisplayName avatarUrl}"] },
259 { name: "LinearLabel", body: ["on IssueLabel{id name color}"] }
260 ]
261 },
262 variables: {
263 first: Shared.Int,
264 after: Schema.optional(Schema.NullOr(Schema.String)),
265 filter: Shared.IssueFilter,
266 orderBy: Shared.PaginationOrderBy
267 },
268 result: Schema.Struct({
269 /** All issues. Returns a paginated list of issues visible to the authenticated user. Can be filtered by various criteria including team, assignee, state, labels, project, and cycle. */
270 issues: IssueConnection
271 })
272 })
273 export declare namespace T3Issues {
274 export type Variables = typeof T3Issues.variables.Type
275 export type Result = typeof T3Issues.result.Type
276 }
277
278 export const TeamStatesWorkflowStateConnection = Schema.Struct({
279 nodes: Schema.Array(LinearWorkflowState)
280 })
281 export interface TeamStatesWorkflowStateConnection extends Schema.Struct.Type<typeof TeamStatesWorkflowStateConnection.fields> {}
282
283 /** A team is the primary organizational unit in Linear. Issues belong to teams, and each team has its own workflow states, cycles, labels, and settings. Teams can be public (visible to all workspace members), private (visible only to team members), or restricted (visible only within an enclosing private-team boundary). Teams can also have sub-teams that inherit settings from their parent. */
284 export const IssueTeamTeam = Schema.Struct({
285 /** The team's unique key, used as a prefix in issue identifiers (e.g., 'ENG' in 'ENG-123') and in URLs. */
286 key: Schema.String,
287 /** The states that define the workflow associated with the team. */
288 states: TeamStatesWorkflowStateConnection
289 })
290 export interface IssueTeamTeam extends Schema.Struct.Type<typeof IssueTeamTeam.fields> {}
291
292 export const CommentConnection = Schema.Struct({
293 nodes: Schema.Array(LinearComment),
294 pageInfo: LinearPageInfo
295 })
296 export interface CommentConnection extends Schema.Struct.Type<typeof CommentConnection.fields> {}
297
298 /** An attachment linking external content to an issue. Attachments represent connections to external resources such as GitHub pull requests, Slack messages, Zendesk tickets, Figma files, Sentry issues, Intercom conversations, and plain URLs. Each attachment has a title and subtitle displayed in the Linear UI, a URL serving as both the link destination and unique identifier per issue, and optional metadata specific to the source integration. */
299 export const Attachment = Schema.Struct({
300 /** The URL of the external resource this attachment links to. Also serves as a unique identifier for the attachment within an issue; no two attachments on the same issue can share the same URL. */
301 url: Schema.String,
302 /** Content for the title line in the Linear attachment widget. */
303 title: Schema.String,
304 /** The source type of the attachment, derived from the source metadata. Returns the integration type (e.g., 'github', 'slack', 'zendesk') or 'unknown' if no source is set. */
305 sourceType: Schema.NullOr(Schema.String),
306 /** Integration-specific metadata for this attachment. The schema varies by source type and may include fields such as pull request status, review counts, commit information, ticket status, or other data from the external system. */
307 metadata: Shared.JSONObject
308 })
309 export interface Attachment extends Schema.Struct.Type<typeof Attachment.fields> {}
310
311 export const AttachmentConnection = Schema.Struct({
312 nodes: Schema.Array(Attachment)
313 })
314 export interface AttachmentConnection extends Schema.Struct.Type<typeof AttachmentConnection.fields> {}
315
316 /** A record of changes to an issue. Each history entry captures one or more property changes made to an issue within a short grouping window by the same actor. History entries track changes to fields such as title, assignee, status, priority, project, cycle, labels, due date, estimate, parent issue, and more. They also record metadata about what triggered the change (e.g., a user action, workflow automation, triage rule, or integration). */
317 export const IssueHistory = Schema.Struct({
318 /** The unique identifier of the entity. */
319 id: Shared.ID,
320 /** The time at which the entity was created. */
321 createdAt: Shared.DateTime,
322 /** The actor that performed the actions. This field may be empty in the case of integrations or automations. */
323 actor: Schema.NullOr(LinearUser),
324 /** The bot that performed the action. */
325 botActor: Schema.NullOr(LinearBot),
326 /** The state that the issue was moved from. */
327 fromState: Schema.NullOr(LinearWorkflowState),
328 /** The state that the issue was moved to. */
329 toState: Schema.NullOr(LinearWorkflowState),
330 /** The user that was unassigned from the issue. */
331 fromAssignee: Schema.NullOr(LinearUser),
332 /** The user that was assigned to the issue. */
333 toAssignee: Schema.NullOr(LinearUser),
334 /** The labels that were added to the issue. */
335 addedLabels: Schema.NullOr(Schema.Array(LinearLabel)),
336 /** The labels that were removed from the issue. */
337 removedLabels: Schema.NullOr(Schema.Array(LinearLabel)),
338 /** What the title was changed from. */
339 fromTitle: Schema.NullOr(Schema.String),
340 /** What the title was changed to. */
341 toTitle: Schema.NullOr(Schema.String)
342 })
343 export interface IssueHistory extends Schema.Struct.Type<typeof IssueHistory.fields> {}
344
345 export const IssueHistoryConnection = Schema.Struct({
346 nodes: Schema.Array(IssueHistory)
347 })
348 export interface IssueHistoryConnection extends Schema.Struct.Type<typeof IssueHistoryConnection.fields> {}
349
350 /** An issue is the core work item in Linear. Issues belong to a team, have a workflow status, can be assigned to users, carry a priority level, and can be organized into projects and cycles. Issues support sub-issues (parent-child hierarchy up to 10 levels deep), labels, due dates, estimates, and SLA tracking. They can also be linked to other issues via relations, attached to releases, and tracked through their full history of changes. */
351 export const T3IssueIssueIssue = Schema.Struct({
352 /** The unique identifier of the entity. */
353 id: Shared.ID,
354 /** Issue's human readable identifier (e.g. ENG-123). */
355 identifier: Schema.String,
356 /** The issue's unique number, scoped to the issue's team. Together with the team key, this forms the issue's human-readable identifier (e.g., ENG-123). */
357 number: Shared.Float,
358 /** The issue's title. This is the primary human-readable summary of the work item. */
359 title: Schema.String,
360 /** Issue URL. */
361 url: Schema.String,
362 /** The time at which the entity was created. */
363 createdAt: Shared.DateTime,
364 /**
365 * The last time at which the entity was meaningfully updated. This is the same as the creation time if the entity hasn't
366 * been updated after creation.
367 */
368 updatedAt: Shared.DateTime,
369 /** The time at which the issue was moved into completed state. */
370 completedAt: Schema.NullOr(Shared.DateTime),
371 /** The time at which the issue was moved into canceled state. */
372 canceledAt: Schema.NullOr(Shared.DateTime),
373 /** The workflow state (issue status) that the issue is currently in. Workflow states represent the issue's progress through the team's workflow, such as Triage, Todo, In Progress, Done, or Canceled. */
374 state: LinearWorkflowState,
375 /** The team that the issue belongs to. Every issue must belong to exactly one team, which determines the available workflow states, labels, and other team-specific configuration. */
376 team: IssueTeamTeam,
377 /** The user who created the issue. Null if the creator's account has been deleted or if the issue was created by an integration or system process. */
378 creator: Schema.NullOr(LinearUser),
379 /** The bot that created the issue, if applicable. */
380 botActor: Schema.NullOr(LinearBot),
381 /** The user to whom the issue is assigned. Null if the issue is unassigned. */
382 assignee: Schema.NullOr(LinearUser),
383 /** Labels associated with this issue. */
384 labels: LinearIssueLabelsIssueLabelConnection,
385 /** The issue's description in markdown format. */
386 description: Schema.NullOr(Schema.String),
387 /** Comments associated with the issue, including inline comments on the issue's description. */
388 comments: CommentConnection,
389 /** Reactions associated with the issue. */
390 reactions: Schema.Array(LinearReaction),
391 /** Attachments associated with the issue. */
392 attachments: AttachmentConnection,
393 /** History entries associated with the issue. */
394 history: IssueHistoryConnection
395 })
396 export interface T3IssueIssueIssue extends Schema.Struct.Type<typeof T3IssueIssueIssue.fields> {}
397
398 /** `query T3Issue` */
399 export const T3Issue = GraphQL.query("T3Issue", {
400 document: {
401 variables: [
402 { name: "id", body: "String!" },
403 { name: "comments", body: "Int!" }
404 ],
405 selections: [
406 { name: "issue", body: ["(id:$", "id", "){...LinearIssue description team{states(first:100){nodes{...LinearWorkflowState}}}comments(first:$", "comments", " orderBy:createdAt){nodes{...LinearComment}pageInfo{...LinearPageInfo}}reactions{...LinearReaction}attachments(first:50){nodes{url title sourceType metadata}}history(first:100 orderBy:createdAt){nodes{id createdAt actor{...LinearUser}botActor{...LinearBot}fromState{...LinearWorkflowState}toState{...LinearWorkflowState}fromAssignee{...LinearUser}toAssignee{...LinearUser}addedLabels{...LinearLabel}removedLabels{...LinearLabel}fromTitle toTitle}}}"] }
407 ],
408 fragments: [
409 { name: "LinearIssue", body: ["on Issue{id identifier number title url createdAt updatedAt completedAt canceledAt state{...LinearWorkflowState}team{key}creator{...LinearUser}botActor{...LinearBot}assignee{...LinearUser}labels{nodes{...LinearLabel}}}"] },
410 { name: "LinearWorkflowState", body: ["on WorkflowState{id name type position}"] },
411 { name: "LinearComment", body: ["on Comment{id body createdAt url user{...LinearUser}botActor{...LinearBot}reactions{...LinearReaction}}"] },
412 { name: "LinearPageInfo", body: ["on PageInfo{hasNextPage endCursor}"] },
413 { name: "LinearReaction", body: ["on Reaction{id emoji user{...LinearUser}}"] },
414 { name: "LinearUser", body: ["on User{id name displayName email avatarUrl}"] },
415 { name: "LinearBot", body: ["on ActorBot{name userDisplayName avatarUrl}"] },
416 { name: "LinearLabel", body: ["on IssueLabel{id name color}"] }
417 ]
418 },
419 variables: {
420 id: Schema.String,
421 comments: Shared.Int
422 },
423 result: Schema.Struct({
424 /** One specific issue, looked up by its unique identifier. */
425 issue: T3IssueIssueIssue
426 })
427 })
428 export declare namespace T3Issue {
429 export type Variables = typeof T3Issue.variables.Type
430 export type Result = typeof T3Issue.result.Type
431 }
432
433 /** An issue is the core work item in Linear. Issues belong to a team, have a workflow status, can be assigned to users, carry a priority level, and can be organized into projects and cycles. Issues support sub-issues (parent-child hierarchy up to 10 levels deep), labels, due dates, estimates, and SLA tracking. They can also be linked to other issues via relations, attached to releases, and tracked through their full history of changes. */
434 export const T3CommentsIssueIssue = Schema.Struct({
435 /** Comments associated with the issue, including inline comments on the issue's description. */
436 comments: CommentConnection
437 })
438 export interface T3CommentsIssueIssue extends Schema.Struct.Type<typeof T3CommentsIssueIssue.fields> {}
439
440 /** `query T3Comments` */
441 export const T3Comments = GraphQL.query("T3Comments", {
442 document: {
443 variables: [
444 { name: "id", body: "String!" },
445 { name: "first", body: "Int!" },
446 { name: "after", body: "String" }
447 ],
448 selections: [
449 { name: "issue", body: ["(id:$", "id", "){comments(first:$", "first", " after:$", "after", " orderBy:createdAt){nodes{...LinearComment}pageInfo{...LinearPageInfo}}}"] }
450 ],
451 fragments: [
452 { name: "LinearComment", body: ["on Comment{id body createdAt url user{...LinearUser}botActor{...LinearBot}reactions{...LinearReaction}}"] },
453 { name: "LinearPageInfo", body: ["on PageInfo{hasNextPage endCursor}"] },
454 { name: "LinearUser", body: ["on User{id name displayName email avatarUrl}"] },
455 { name: "LinearBot", body: ["on ActorBot{name userDisplayName avatarUrl}"] },
456 { name: "LinearReaction", body: ["on Reaction{id emoji user{...LinearUser}}"] }
457 ]
458 },
459 variables: {
460 id: Schema.String,
461 first: Shared.Int,
462 after: Schema.optional(Schema.NullOr(Schema.String))
463 },
464 result: Schema.Struct({
465 /** One specific issue, looked up by its unique identifier. */
466 issue: T3CommentsIssueIssue
467 })
468 })
469 export declare namespace T3Comments {
470 export type Variables = typeof T3Comments.variables.Type
471 export type Result = typeof T3Comments.result.Type
472 }
473
474 export const NodesStatesWorkflowStateConnection = Schema.Struct({
475 nodes: Schema.Array(LinearWorkflowState),
476 pageInfo: LinearPageInfo
477 })
478 export interface NodesStatesWorkflowStateConnection extends Schema.Struct.Type<typeof NodesStatesWorkflowStateConnection.fields> {}
479
480 export const NodesLabelsIssueLabelConnection = Schema.Struct({
481 nodes: Schema.Array(LinearTeamLabel),
482 pageInfo: LinearPageInfo
483 })
484 export interface NodesLabelsIssueLabelConnection extends Schema.Struct.Type<typeof NodesLabelsIssueLabelConnection.fields> {}
485
486 export const UserConnection = Schema.Struct({
487 nodes: Schema.Array(LinearUser),
488 pageInfo: LinearPageInfo
489 })
490 export interface UserConnection extends Schema.Struct.Type<typeof UserConnection.fields> {}
491
492 /** A reusable template for creating issues, projects, or documents. Templates store pre-filled field values and content as JSON data. They can be scoped to a specific team or shared across the entire workspace. Team-scoped templates may be inherited from parent teams. */
493 export const Template = Schema.Struct({
494 /** The unique identifier of the entity. */
495 id: Shared.ID,
496 /** The name of the template. */
497 name: Schema.String,
498 /** A description of what the template is used for. */
499 description: Schema.NullOr(Schema.String),
500 /** The template's content in markdown format: the body it pre-fills on the entity it creates. Distinct from `description`, which says what the template is for. Form templates serialize their form fields as markdown placeholders instead. Null when the template has no content. */
501 content: Schema.NullOr(Schema.String),
502 /** The entity type this template is for, such as 'issue', 'project', or 'document'. */
503 type: Schema.String,
504 /** [Internal] Whether the template has form fields */
505 hasFormFields: Schema.Boolean,
506 /** The template data as a JSON-encoded string containing the pre-filled attributes for the entity type (e.g., issue fields, project configuration, or document content). */
507 templateData: Shared.JSON
508 })
509 export interface Template extends Schema.Struct.Type<typeof Template.fields> {}
510
511 export const TemplateConnection = Schema.Struct({
512 nodes: Schema.Array(Template)
513 })
514 export interface TemplateConnection extends Schema.Struct.Type<typeof TemplateConnection.fields> {}
515
516 /** A team is the primary organizational unit in Linear. Issues belong to teams, and each team has its own workflow states, cycles, labels, and settings. Teams can be public (visible to all workspace members), private (visible only to team members), or restricted (visible only within an enclosing private-team boundary). Teams can also have sub-teams that inherit settings from their parent. */
517 export const T3TeamTeamsNodesTeam = Schema.Struct({
518 /** The unique identifier of the entity. */
519 id: Shared.ID,
520 /** The team's unique key, used as a prefix in issue identifiers (e.g., 'ENG' in 'ENG-123') and in URLs. */
521 key: Schema.String,
522 /** The team's name. */
523 name: Schema.String,
524 /** The states that define the workflow associated with the team. */
525 states: NodesStatesWorkflowStateConnection,
526 /** Labels associated with the team. */
527 labels: NodesLabelsIssueLabelConnection,
528 /** Users who are members of this team. Supports filtering and pagination. */
529 members: UserConnection,
530 /** Templates associated with the team. */
531 templates: TemplateConnection
532 })
533 export interface T3TeamTeamsNodesTeam extends Schema.Struct.Type<typeof T3TeamTeamsNodesTeam.fields> {}
534
535 export const T3TeamTeamsTeamConnection = Schema.Struct({
536 nodes: Schema.Array(T3TeamTeamsNodesTeam)
537 })
538 export interface T3TeamTeamsTeamConnection extends Schema.Struct.Type<typeof T3TeamTeamsTeamConnection.fields> {}
539
540 /** `query T3Team` */
541 export const T3Team = GraphQL.query("T3Team", {
542 document: {
543 variables: [
544 { name: "key", body: "String!" }
545 ],
546 selections: [
547 { name: "teams", body: ["(first:1 filter:{key:{eq:$", "key", "}}){nodes{id key name states(first:100){nodes{...LinearWorkflowState}pageInfo{...LinearPageInfo}}labels(first:250){nodes{...LinearTeamLabel}pageInfo{...LinearPageInfo}}members(first:250){nodes{...LinearUser}pageInfo{...LinearPageInfo}}templates{nodes{id name description content type hasFormFields templateData}}}}"] },
548 { name: "issueLabels", body: ["(first:250 filter:{team:{null:true}}){nodes{...LinearTeamLabel}pageInfo{...LinearPageInfo}}"] }
549 ],
550 fragments: [
551 { name: "LinearWorkflowState", body: ["on WorkflowState{id name type position}"] },
552 { name: "LinearPageInfo", body: ["on PageInfo{hasNextPage endCursor}"] },
553 { name: "LinearTeamLabel", body: ["on IssueLabel{...LinearLabel description}"] },
554 { name: "LinearUser", body: ["on User{id name displayName email avatarUrl}"] },
555 { name: "LinearLabel", body: ["on IssueLabel{id name color}"] }
556 ]
557 },
558 variables: {
559 key: Schema.String
560 },
561 result: Schema.Struct({
562 /** All teams whose issues the user can access. This includes public teams and private teams the user is a member of. This may differ from `administrableTeams`, which returns teams whose settings the user can change but whose issues they don't necessarily have access to. */
563 teams: T3TeamTeamsTeamConnection,
564 /** All issue labels. Returns a paginated list of labels visible to the authenticated user, including both workspace-level and team-scoped labels. */
565 issueLabels: NodesLabelsIssueLabelConnection
566 })
567 })
568 export declare namespace T3Team {
569 export type Variables = typeof T3Team.variables.Type
570 export type Result = typeof T3Team.result.Type
571 }
572
573 /** An issue is the core work item in Linear. Issues belong to a team, have a workflow status, can be assigned to users, carry a priority level, and can be organized into projects and cycles. Issues support sub-issues (parent-child hierarchy up to 10 levels deep), labels, due dates, estimates, and SLA tracking. They can also be linked to other issues via relations, attached to releases, and tracked through their full history of changes. */
574 export const IssueCreateIssueIssue = Schema.Struct({
575 /** Issue's human readable identifier (e.g. ENG-123). */
576 identifier: Schema.String,
577 /** Issue URL. */
578 url: Schema.String
579 })
580 export interface IssueCreateIssueIssue extends Schema.Struct.Type<typeof IssueCreateIssueIssue.fields> {}
581
582 /** The result of an issue mutation, containing the created or updated issue and a success indicator. */
583 export const IssueCreateIssuePayload = Schema.Struct({
584 /** Whether the operation was successful. */
585 success: Schema.Boolean,
586 /** The issue that was created or updated. */
587 issue: Schema.NullOr(IssueCreateIssueIssue)
588 })
589 export interface IssueCreateIssuePayload extends Schema.Struct.Type<typeof IssueCreateIssuePayload.fields> {}
590
591 /** `mutation T3IssueCreate` */
592 export const T3IssueCreate = GraphQL.mutation("T3IssueCreate", {
593 document: {
594 variables: [
595 { name: "input", body: "IssueCreateInput!" }
596 ],
597 selections: [
598 { name: "issueCreate", body: ["(input:$", "input", "){success issue{identifier url}}"] }
599 ],
600 fragments: []
601 },
602 variables: {
603 input: Shared.IssueCreateInput
604 },
605 result: Schema.Struct({
606 /** Creates a new issue. */
607 issueCreate: IssueCreateIssuePayload
608 })
609 })
610 export declare namespace T3IssueCreate {
611 export type Variables = typeof T3IssueCreate.variables.Type
612 export type Result = typeof T3IssueCreate.result.Type
613 }
614
615 /** The result of an issue mutation, containing the created or updated issue and a success indicator. */
616 export const IssueUpdateIssuePayload = Schema.Struct({
617 /** Whether the operation was successful. */
618 success: Schema.Boolean
619 })
620 export interface IssueUpdateIssuePayload extends Schema.Struct.Type<typeof IssueUpdateIssuePayload.fields> {}
621
622 /** `mutation T3IssueUpdate` */
623 export const T3IssueUpdate = GraphQL.mutation("T3IssueUpdate", {
624 document: {
625 variables: [
626 { name: "id", body: "String!" },
627 { name: "input", body: "IssueUpdateInput!" }
628 ],
629 selections: [
630 { name: "issueUpdate", body: ["(id:$", "id", " input:$", "input", "){success}"] }
631 ],
632 fragments: []
633 },
634 variables: {
635 id: Schema.String,
636 input: Shared.IssueUpdateInput
637 },
638 result: Schema.Struct({
639 /** Updates an issue. */
640 issueUpdate: IssueUpdateIssuePayload
641 })
642 })
643 export declare namespace T3IssueUpdate {
644 export type Variables = typeof T3IssueUpdate.variables.Type
645 export type Result = typeof T3IssueUpdate.result.Type
646 }
647
648 /** The result of a comment mutation. */
649 export const CommentPayload = Schema.Struct({
650 /** Whether the operation was successful. */
651 success: Schema.Boolean
652 })
653 export interface CommentPayload extends Schema.Struct.Type<typeof CommentPayload.fields> {}
654
655 /** `mutation T3CommentCreate` */
656 export const T3CommentCreate = GraphQL.mutation("T3CommentCreate", {
657 document: {
658 variables: [
659 { name: "input", body: "CommentCreateInput!" }
660 ],
661 selections: [
662 { name: "commentCreate", body: ["(input:$", "input", "){success}"] }
663 ],
664 fragments: []
665 },
666 variables: {
667 input: Shared.CommentCreateInput
668 },
669 result: Schema.Struct({
670 /** Creates a new comment. */
671 commentCreate: CommentPayload
672 })
673 })
674 export declare namespace T3CommentCreate {
675 export type Variables = typeof T3CommentCreate.variables.Type
676 export type Result = typeof T3CommentCreate.result.Type
677 }
678
679 /** The result of a reaction mutation. */
680 export const ReactionPayload = Schema.Struct({
681 /** Whether the operation was successful. */
682 success: Schema.Boolean
683 })
684 export interface ReactionPayload extends Schema.Struct.Type<typeof ReactionPayload.fields> {}
685
686 /** `mutation T3ReactionCreate` */
687 export const T3ReactionCreate = GraphQL.mutation("T3ReactionCreate", {
688 document: {
689 variables: [
690 { name: "input", body: "ReactionCreateInput!" }
691 ],
692 selections: [
693 { name: "reactionCreate", body: ["(input:$", "input", "){success}"] }
694 ],
695 fragments: []
696 },
697 variables: {
698 input: Shared.ReactionCreateInput
699 },
700 result: Schema.Struct({
701 /** Creates a new reaction. */
702 reactionCreate: ReactionPayload
703 })
704 })
705 export declare namespace T3ReactionCreate {
706 export type Variables = typeof T3ReactionCreate.variables.Type
707 export type Result = typeof T3ReactionCreate.result.Type
708 }
709
710 /** A generic payload return from entity deletion mutations. */
711 export const DeletePayload = Schema.Struct({
712 /** Whether the operation was successful. */
713 success: Schema.Boolean
714 })
715 export interface DeletePayload extends Schema.Struct.Type<typeof DeletePayload.fields> {}
716
717 /** `mutation T3ReactionDelete` */
718 export const T3ReactionDelete = GraphQL.mutation("T3ReactionDelete", {
719 document: {
720 variables: [
721 { name: "id", body: "String!" }
722 ],
723 selections: [
724 { name: "reactionDelete", body: ["(id:$", "id", "){success}"] }
725 ],
726 fragments: []
727 },
728 variables: {
729 id: Schema.String
730 },
731 result: Schema.Struct({
732 /** Deletes a reaction. */
733 reactionDelete: DeletePayload
734 })
735 })
736 export declare namespace T3ReactionDelete {
737 export type Variables = typeof T3ReactionDelete.variables.Type
738 export type Result = typeof T3ReactionDelete.result.Type
739 }
740
741 /** An issue is the core work item in Linear. Issues belong to a team, have a workflow status, can be assigned to users, carry a priority level, and can be organized into projects and cycles. Issues support sub-issues (parent-child hierarchy up to 10 levels deep), labels, due dates, estimates, and SLA tracking. They can also be linked to other issues via relations, attached to releases, and tracked through their full history of changes. */
742 export const T3IssueReactionsIssueIssue = Schema.Struct({
743 /** Reactions associated with the issue. */
744 reactions: Schema.Array(LinearReaction)
745 })
746 export interface T3IssueReactionsIssueIssue extends Schema.Struct.Type<typeof T3IssueReactionsIssueIssue.fields> {}
747
748 /** `query T3IssueReactions` */
749 export const T3IssueReactions = GraphQL.query("T3IssueReactions", {
750 document: {
751 variables: [
752 { name: "id", body: "String!" }
753 ],
754 selections: [
755 { name: "issue", body: ["(id:$", "id", "){reactions{...LinearReaction}}"] }
756 ],
757 fragments: [
758 { name: "LinearReaction", body: ["on Reaction{id emoji user{...LinearUser}}"] },
759 { name: "LinearUser", body: ["on User{id name displayName email avatarUrl}"] }
760 ]
761 },
762 variables: {
763 id: Schema.String
764 },
765 result: Schema.Struct({
766 /** One specific issue, looked up by its unique identifier. */
767 issue: T3IssueReactionsIssueIssue
768 })
769 })
770 export declare namespace T3IssueReactions {
771 export type Variables = typeof T3IssueReactions.variables.Type
772 export type Result = typeof T3IssueReactions.result.Type
773 }
774
775 /** An issue is the core work item in Linear. Issues belong to a team, have a workflow status, can be assigned to users, carry a priority level, and can be organized into projects and cycles. Issues support sub-issues (parent-child hierarchy up to 10 levels deep), labels, due dates, estimates, and SLA tracking. They can also be linked to other issues via relations, attached to releases, and tracked through their full history of changes. */
776 export const CommentIssueIssue = Schema.Struct({
777 /** The unique identifier of the entity. */
778 id: Shared.ID
779 })
780 export interface CommentIssueIssue extends Schema.Struct.Type<typeof CommentIssueIssue.fields> {}
781
782 /** A comment associated with an issue, project update, initiative update, document content, post, project, or initiative. Comments support rich text (ProseMirror), emoji reactions, and threaded replies via parentId. Comments can be created by workspace users or by external users through integrations (e.g., Slack, Intercom). Each comment belongs to exactly one parent entity. */
783 export const Comment = Schema.Struct({
784 /** The issue that the comment is associated with. Null if the comment belongs to a different parent entity type. */
785 issue: Schema.NullOr(CommentIssueIssue),
786 /** Reactions associated with the comment. */
787 reactions: Schema.Array(LinearReaction)
788 })
789 export interface Comment extends Schema.Struct.Type<typeof Comment.fields> {}
790
791 /** `query T3CommentReactions` */
792 export const T3CommentReactions = GraphQL.query("T3CommentReactions", {
793 document: {
794 variables: [
795 { name: "id", body: "String!" }
796 ],
797 selections: [
798 { name: "comment", body: ["(id:$", "id", "){issue{id}reactions{...LinearReaction}}"] }
799 ],
800 fragments: [
801 { name: "LinearReaction", body: ["on Reaction{id emoji user{...LinearUser}}"] },
802 { name: "LinearUser", body: ["on User{id name displayName email avatarUrl}"] }
803 ]
804 },
805 variables: {
806 id: Schema.String
807 },
808 result: Schema.Struct({
809 /** A specific comment. */
810 comment: Comment
811 })
812 })
813 export declare namespace T3CommentReactions {
814 export type Variables = typeof T3CommentReactions.variables.Type
815 export type Result = typeof T3CommentReactions.result.Type
816 }
817
818 /** Every operation in LinearApi.graphql. */
819 export const LinearApiGraphQLGroup = GraphQLGroup.make(T3Viewer, T3Issues, T3Issue, T3Comments, T3Team, T3IssueCreate, T3IssueUpdate, T3CommentCreate, T3ReactionCreate, T3ReactionDelete, T3IssueReactions, T3CommentReactions)