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
| 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) |