@task-shepherd/agent 1.0.6 → 1.0.7

package/shared/graphql/generated.ts.working

@@ -0,0 +1,4828 @@
+import { DocumentNode } from "graphql";
+import * as Apollo from "@apollo/client";
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends { [key: string]: unknown }> = {
+  [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+  [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+  [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<
+  T extends { [key: string]: unknown },
+  K extends keyof T,
+> = { [_ in K]?: never };
+export type Incremental<T> =
+  | T
+  | {
+      [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never;
+    };
+const defaultOptions = {} as const;
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: { input: string; output: string };
+  String: { input: string; output: string };
+  Boolean: { input: boolean; output: boolean };
+  Int: { input: number; output: number };
+  Float: { input: number; output: number };
+  /** Date custom scalar type that accepts both date-only (YYYY-MM-DD) and full DateTime (ISO 8601) strings */
+  Date: { input: string; output: string };
+  /** The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
+  JSON: { input: any; output: any };
+  /** The `JSONObject` scalar type represents JSON objects as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
+  JSONObject: { input: any; output: any };
+};
+
+export type AiServiceSession = {
+  __typename: "AIServiceSession";
+  capabilitiesJson: Scalars["String"]["output"];
+  completedAt: Maybe<Scalars["Date"]["output"]>;
+  createdAt: Scalars["Date"]["output"];
+  hasCodeReviewCapability: Scalars["Boolean"]["output"];
+  hasDevelopmentPlanningCapability: Scalars["Boolean"]["output"];
+  hasProjectReviewCapability: Scalars["Boolean"]["output"];
+  hasStoryImplementationCapability: Scalars["Boolean"]["output"];
+  id: Scalars["ID"]["output"];
+  isConnected: Scalars["Boolean"]["output"];
+  lastHeartbeat: Maybe<Scalars["Date"]["output"]>;
+  metadata: Maybe<Scalars["String"]["output"]>;
+  serviceEndpoint: Scalars["String"]["output"];
+  sessionToken: Scalars["String"]["output"];
+  startedAt: Maybe<Scalars["Date"]["output"]>;
+  status: AiServiceStatus;
+  updatedAt: Scalars["Date"]["output"];
+  user: User;
+  workType: Maybe<Scalars["String"]["output"]>;
+};
+
+/** Status of AI service connection */
+export enum AiServiceStatus {
+  ACTIVE = "ACTIVE",
+  DISCONNECTED = "DISCONNECTED",
+  ERROR = "ERROR",
+  INACTIVE = "INACTIVE",
+}
+
+export type AiWorkAssignment = {
+  __typename: "AIWorkAssignment";
+  assignedAt: Scalars["Date"]["output"];
+  assignmentId: Scalars["String"]["output"];
+  deadline: Maybe<Scalars["Date"]["output"]>;
+  priority: Scalars["Float"]["output"];
+  workData: Maybe<Scalars["JSONObject"]["output"]>;
+  workItemId: Scalars["String"]["output"];
+  workItemType: Scalars["String"]["output"];
+  workerId: Scalars["String"]["output"];
+};
+
+export type AiWorkAudit = {
+  __typename: "AIWorkAudit";
+  actionType: AuditActionType;
+  actorId: Maybe<Scalars["String"]["output"]>;
+  actorName: Scalars["String"]["output"];
+  actorType: AuditActorType;
+  createdAt: Scalars["Date"]["output"];
+  details: Maybe<Scalars["String"]["output"]>;
+  duration: Scalars["Float"]["output"];
+  errorMessage: Maybe<Scalars["String"]["output"]>;
+  hasError: Scalars["Boolean"]["output"];
+  id: Scalars["ID"]["output"];
+  isStatusChange: Scalars["Boolean"]["output"];
+  isWorkerChange: Scalars["Boolean"]["output"];
+  metadata: Scalars["JSONObject"]["output"];
+  newStatus: Maybe<AiWorkStatus>;
+  newWorkerId: Maybe<Scalars["String"]["output"]>;
+  previousStatus: Maybe<AiWorkStatus>;
+  previousWorkerId: Maybe<Scalars["String"]["output"]>;
+  reason: Scalars["String"]["output"];
+  source: Scalars["String"]["output"];
+  summaryText: Scalars["String"]["output"];
+  updatedAt: Scalars["Date"]["output"];
+  user: Maybe<User>;
+  workItem: AiWorkQueue;
+};
+
+export type AiWorkBulkOperationResult = {
+  __typename: "AIWorkBulkOperationResult";
+  deletedCount: Maybe<Scalars["Float"]["output"]>;
+  errors: Maybe<Array<Scalars["String"]["output"]>>;
+  message: Maybe<Scalars["String"]["output"]>;
+  success: Scalars["Boolean"]["output"];
+  updatedCount: Scalars["Float"]["output"];
+};
+
+export type AiWorkCompletion = {
+  __typename: "AIWorkCompletion";
+  assignmentId: Scalars["String"]["output"];
+  completedAt: Scalars["Date"]["output"];
+  errors: Array<Scalars["String"]["output"]>;
+  result: Maybe<Scalars["String"]["output"]>;
+  success: Scalars["Boolean"]["output"];
+  workerId: Scalars["String"]["output"];
+};
+
+export type AiWorkProgress = {
+  __typename: "AIWorkProgress";
+  assignmentId: Scalars["String"]["output"];
+  currentStep: Scalars["String"]["output"];
+  estimatedCompletion: Maybe<Scalars["Date"]["output"]>;
+  message: Scalars["String"]["output"];
+  metadata: Maybe<Scalars["JSONObject"]["output"]>;
+  progressPercentage: Scalars["Float"]["output"];
+  stage: Scalars["String"]["output"];
+  updatedAt: Scalars["Date"]["output"];
+  workerId: Scalars["String"]["output"];
+};
+
+export type AiWorkQueue = {
+  __typename: "AIWorkQueue";
+  activeCompatibleAgentCount: Maybe<Scalars["Int"]["output"]>;
+  actualDuration: Maybe<Scalars["Int"]["output"]>;
+  agentAvailabilityReason: Maybe<Scalars["String"]["output"]>;
+  agentAvailabilityStatus: Maybe<Scalars["String"]["output"]>;
+  aiWorkerId: Maybe<Scalars["String"]["output"]>;
+  assignedWorker: Maybe<Scalars["String"]["output"]>;
+  attemptCount: Scalars["Float"]["output"];
+  canRetry: Scalars["Boolean"]["output"];
+  claimedAt: Maybe<Scalars["Date"]["output"]>;
+  compatibleAgentCount: Maybe<Scalars["Int"]["output"]>;
+  completedAt: Maybe<Scalars["Date"]["output"]>;
+  createdAt: Scalars["Date"]["output"];
+  currentStep: Scalars["String"]["output"];
+  elapsedDuration: Maybe<Scalars["Int"]["output"]>;
+  error: Maybe<Scalars["String"]["output"]>;
+  estimatedDuration: Maybe<Scalars["Int"]["output"]>;
+  failureClassification: Maybe<Scalars["String"]["output"]>;
+  hasError: Scalars["Boolean"]["output"];
+  id: Scalars["ID"]["output"];
+  isClaimed: Scalars["Boolean"]["output"];
+  isCompleted: Scalars["Boolean"]["output"];
+  isFailed: Scalars["Boolean"]["output"];
+  isFailedButRetrying: Scalars["Boolean"]["output"];
+  isFailedPermanently: Scalars["Boolean"]["output"];
+  isInProgress: Scalars["Boolean"]["output"];
+  isQueued: Scalars["Boolean"]["output"];
+  lastError: Maybe<Scalars["String"]["output"]>;
+  lastRetryAt: Maybe<Scalars["Date"]["output"]>;
+  maxRetryAttempts: Scalars["Float"]["output"];
+  metadataJson: Scalars["String"]["output"];
+  nextRetryAt: Maybe<Scalars["Date"]["output"]>;
+  priority: Scalars["Int"]["output"];
+  progressPercentage: Scalars["Float"]["output"];
+  project: Maybe<Project>;
+  queuePosition: Maybe<Scalars["Int"]["output"]>;
+  queuedByUser: Maybe<User>;
+  requiredWorkspaces: Maybe<Array<Scalars["String"]["output"]>>;
+  retryCount: Maybe<Scalars["Int"]["output"]>;
+  retryDelay: Maybe<Scalars["Int"]["output"]>;
+  startedAt: Maybe<Scalars["Date"]["output"]>;
+  status: AiWorkStatus;
+  story: Maybe<Story>;
+  updatedAt: Scalars["Date"]["output"];
+  workType: Scalars["String"]["output"];
+};
+
+export type AiWorkQueueSearchInput = {
+  aiWorkerId?: InputMaybe<Scalars["String"]["input"]>;
+  createdAfter?: InputMaybe<Scalars["String"]["input"]>;
+  createdBefore?: InputMaybe<Scalars["String"]["input"]>;
+  hasErrors?: InputMaybe<Scalars["Boolean"]["input"]>;
+  ids?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  maxPriority?: InputMaybe<Scalars["Float"]["input"]>;
+  minPriority?: InputMaybe<Scalars["Float"]["input"]>;
+  priorities?: InputMaybe<Array<Scalars["Float"]["input"]>>;
+  projectId?: InputMaybe<Scalars["String"]["input"]>;
+  projectIds?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  search?: InputMaybe<Scalars["String"]["input"]>;
+  status?: InputMaybe<Array<AiWorkStatus>>;
+  storyId?: InputMaybe<Scalars["String"]["input"]>;
+  workTypes?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  workerIds?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  workerType?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+/** Status of AI work item */
+export enum AiWorkStatus {
+  ASSIGNED = "ASSIGNED",
+  CLAIMED = "CLAIMED",
+  COMPLETED = "COMPLETED",
+  FAILED = "FAILED",
+  FAILED_PERMANENT = "FAILED_PERMANENT",
+  FAILED_RETRYING = "FAILED_RETRYING",
+  IN_PROGRESS = "IN_PROGRESS",
+  PENDING = "PENDING",
+  QUEUED = "QUEUED",
+}
+
+export type AiWorker = {
+  __typename: "AIWorker";
+  accessibleServices: Array<Scalars["String"]["output"]>;
+  accessibleWorkspaces: Array<Scalars["String"]["output"]>;
+  canAcceptWork: Scalars["Boolean"]["output"];
+  canGuideMore: Scalars["Boolean"]["output"];
+  capabilities: Array<WorkerCapability>;
+  createdAt: Scalars["Date"]["output"];
+  currentActivity: ShepherdActivity;
+  currentTaskCount: Scalars["Float"]["output"];
+  flockEntities: Array<Scalars["String"]["output"]>;
+  flockHealthStatus: FlockHealthStatus;
+  flockMetrics: Maybe<Scalars["JSONObject"]["output"]>;
+  flockSize: Scalars["Float"]["output"];
+  healthMetrics: Maybe<Scalars["JSONObject"]["output"]>;
+  id: Scalars["ID"]["output"];
+  isAvailable: Scalars["Boolean"]["output"];
+  isHealthy: Scalars["Boolean"]["output"];
+  lastActivity: Maybe<Scalars["Date"]["output"]>;
+  lastFlockAssessment: Maybe<Scalars["Date"]["output"]>;
+  lastHeartbeat: Maybe<Scalars["Date"]["output"]>;
+  lastRestPeriod: Maybe<Scalars["Date"]["output"]>;
+  maxConcurrentTasks: Scalars["Float"]["output"];
+  metadata: Maybe<Scalars["JSONObject"]["output"]>;
+  needsRest: Scalars["Boolean"]["output"];
+  project: Maybe<Project>;
+  resourceLimits: Maybe<Scalars["JSONObject"]["output"]>;
+  scope: WorkerScope;
+  scopeId: Scalars["String"]["output"];
+  shepherdCapabilities: Maybe<Scalars["JSONObject"]["output"]>;
+  shepherdEffectiveness: Scalars["Float"]["output"];
+  shepherdExperience: Scalars["Float"]["output"];
+  shepherdPreferences: Maybe<Scalars["JSONObject"]["output"]>;
+  shepherdRole: ShepherdRole;
+  shepherdStamina: Scalars["Float"]["output"];
+  shepherdStatusDescription: Scalars["String"]["output"];
+  status: AiWorkerStatus;
+  team: Maybe<Team>;
+  updatedAt: Scalars["Date"]["output"];
+  uptimeSeconds: Scalars["Float"]["output"];
+  user: Maybe<User>;
+  utilizationPercentage: Scalars["Float"]["output"];
+  workerId: Scalars["String"]["output"];
+  workerName: Scalars["String"]["output"];
+};
+
+export type AiWorkerDisconnectionInfo = {
+  __typename: "AIWorkerDisconnectionInfo";
+  disconnectedAt: Scalars["Date"]["output"];
+  reason: Scalars["String"]["output"];
+  workerId: Scalars["String"]["output"];
+};
+
+export type AiWorkerDiscoveryFilter = {
+  availableOnly?: InputMaybe<Scalars["Boolean"]["input"]>;
+  capabilities?: InputMaybe<Array<WorkerCapability>>;
+  scope?: InputMaybe<WorkerScope>;
+  scopeId?: InputMaybe<Scalars["String"]["input"]>;
+  status?: InputMaybe<Array<AiWorkerStatus>>;
+};
+
+export type AiWorkerDiscoveryUpdate = {
+  __typename: "AIWorkerDiscoveryUpdate";
+  activeWorkers: Scalars["Float"]["output"];
+  availableCapabilities: Array<Scalars["String"]["output"]>;
+  totalWorkers: Scalars["Float"]["output"];
+};
+
+export type AiWorkerHealthCheckInput = {
+  cpuUsage?: InputMaybe<Scalars["Float"]["input"]>;
+  errorRate?: InputMaybe<Scalars["Float"]["input"]>;
+  isHealthy: Scalars["Boolean"]["input"];
+  localWorkState?: InputMaybe<Array<WorkStateItem>>;
+  memoryUsage?: InputMaybe<Scalars["Float"]["input"]>;
+  responseTime?: InputMaybe<Scalars["Float"]["input"]>;
+  workerId: Scalars["String"]["input"];
+};
+
+export type AiWorkerHealthStatus = {
+  __typename: "AIWorkerHealthStatus";
+  cpuUsage: Scalars["Float"]["output"];
+  errorRate: Scalars["Float"]["output"];
+  healthIssues: Array<Scalars["String"]["output"]>;
+  isHealthy: Scalars["Boolean"]["output"];
+  lastHealthCheck: Scalars["Date"]["output"];
+  memoryUsage: Scalars["Float"]["output"];
+  responseTime: Scalars["Float"]["output"];
+  workerId: Scalars["String"]["output"];
+};
+
+export type AiWorkerHeartbeatInput = {
+  cpuUsage?: InputMaybe<Scalars["Float"]["input"]>;
+  errorRate?: InputMaybe<Scalars["Float"]["input"]>;
+  isHealthy: Scalars["Boolean"]["input"];
+  memoryUsage?: InputMaybe<Scalars["Float"]["input"]>;
+  responseTime?: InputMaybe<Scalars["Float"]["input"]>;
+  workProgress?: InputMaybe<Array<WorkProgressUpdateInput>>;
+  workerId: Scalars["String"]["input"];
+};
+
+export type AiWorkerOperationResult = {
+  __typename: "AIWorkerOperationResult";
+  message: Maybe<Scalars["String"]["output"]>;
+  success: Scalars["Boolean"]["output"];
+  worker: Maybe<AiWorker>;
+};
+
+export type AiWorkerRegistration = {
+  __typename: "AIWorkerRegistration";
+  approvedBy: Maybe<User>;
+  createdAt: Scalars["Date"]["output"];
+  expiresAt: Maybe<Scalars["Date"]["output"]>;
+  id: Scalars["ID"]["output"];
+  isExpired: Scalars["Boolean"]["output"];
+  isProcessed: Scalars["Boolean"]["output"];
+  metadata: Maybe<Scalars["JSONObject"]["output"]>;
+  notes: Maybe<Scalars["String"]["output"]>;
+  processedAt: Maybe<Scalars["Date"]["output"]>;
+  processingTimeMs: Maybe<Scalars["Float"]["output"]>;
+  requestedBy: Maybe<User>;
+  status: RegistrationStatus;
+  updatedAt: Scalars["Date"]["output"];
+  worker: Maybe<AiWorker>;
+  workerId: Scalars["String"]["output"];
+};
+
+export type AiWorkerRegistrationInput = {
+  accessibleServices?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  accessibleWorkspaces?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  capabilities: Array<WorkerCapability>;
+  maxConcurrentTasks?: InputMaybe<Scalars["Float"]["input"]>;
+  metadata?: InputMaybe<Scalars["JSONObject"]["input"]>;
+  scope: WorkerScope;
+  scopeId: Scalars["String"]["input"];
+  workerId: Scalars["String"]["input"];
+  workerName: Scalars["String"]["input"];
+};
+
+export type AiWorkerStatistics = {
+  __typename: "AIWorkerStatistics";
+  activeWorkers: Scalars["Float"]["output"];
+  availableCapabilities: Array<WorkerCapability>;
+  availableWorkers: Scalars["Float"]["output"];
+  busyWorkers: Scalars["Float"]["output"];
+  disconnectedWorkers: Scalars["Float"]["output"];
+  totalCapacity: Scalars["Float"]["output"];
+  totalWorkers: Scalars["Float"]["output"];
+  usedCapacity: Scalars["Float"]["output"];
+  utilizationPercentage: Scalars["Float"]["output"];
+};
+
+export enum AiWorkerStatus {
+  ACTIVE = "ACTIVE",
+  BUSY = "BUSY",
+  COORDINATING = "COORDINATING",
+  DEGRADED = "DEGRADED",
+  DISCONNECTED = "DISCONNECTED",
+  ERROR = "ERROR",
+  GUIDING_TASKS = "GUIDING_TASKS",
+  IDLE = "IDLE",
+  ON_PATROL = "ON_PATROL",
+  REGISTERING = "REGISTERING",
+  RESTING = "RESTING",
+  TRAINING = "TRAINING",
+  WATCHING_FLOCK = "WATCHING_FLOCK",
+}
+
+export type ApiVersionInfo = {
+  __typename: "APIVersionInfo";
+  buildTimestamp: Scalars["String"]["output"];
+  commitHash: Maybe<Scalars["String"]["output"]>;
+  deprecationWarnings: Array<DeprecationWarning>;
+  minSupportedAgentVersion: Scalars["String"]["output"];
+  supportedFeatures: Array<Scalars["String"]["output"]>;
+  version: Scalars["String"]["output"];
+};
+
+export type AcceptOrganizationInviteInput = {
+  acceptedTerms?: InputMaybe<Scalars["Boolean"]["input"]>;
+  ageVerified: Scalars["Boolean"]["input"];
+  firstName: Scalars["String"]["input"];
+  inviteToken: Scalars["String"]["input"];
+  lastName: Scalars["String"]["input"];
+  organizationName: Scalars["String"]["input"];
+  organizationSubdomain: Scalars["String"]["input"];
+  password: Scalars["String"]["input"];
+};
+
+export type ActivityMetric = {
+  __typename: "ActivityMetric";
+  activeUsers: Scalars["Int"]["output"];
+  attachmentsUploaded: Scalars["Int"]["output"];
+  commentsAdded: Scalars["Int"]["output"];
+  date: Scalars["Date"]["output"];
+  storiesCompleted: Scalars["Int"]["output"];
+  storiesCreated: Scalars["Int"]["output"];
+  tasksCompleted: Scalars["Int"]["output"];
+  tasksCreated: Scalars["Int"]["output"];
+};
+
+export type AddTeamMemberInput = {
+  roleId: Scalars["String"]["input"];
+  teamId: Scalars["String"]["input"];
+  userId: Scalars["String"]["input"];
+};
+
+export type AgentConfiguration = {
+  __typename: "AgentConfiguration";
+  priorityFilters: Maybe<PriorityFilters>;
+};
+
+export type AgentConfigurationInput = {
+  priorityFilters?: InputMaybe<PriorityFiltersInput>;
+};
+
+export type AnalysisInput = {
+  opportunities: Array<OpportunityInput>;
+  risks: Array<RiskInput>;
+  strengths: Array<StrengthInput>;
+  weaknesses: Array<WeaknessInput>;
+};
+
+export type AnalyticsFilter = {
+  endDate?: InputMaybe<Scalars["Date"]["input"]>;
+  includeInactive?: InputMaybe<Scalars["Boolean"]["input"]>;
+  projectId?: InputMaybe<Scalars["String"]["input"]>;
+  startDate?: InputMaybe<Scalars["Date"]["input"]>;
+  teamId?: InputMaybe<Scalars["String"]["input"]>;
+  userId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export enum ApiKeyScope {
+  ORGANIZATION = "ORGANIZATION",
+  USER = "USER",
+}
+
+export enum ApiKeyType {
+  AGENT = "AGENT",
+  INTEGRATION = "INTEGRATION",
+  SERVICE = "SERVICE",
+  USER = "USER",
+  WEBHOOK = "WEBHOOK",
+}
+
+export type ApiKeyWithSecret = {
+  __typename: "ApiKeyWithSecret";
+  agentConfiguration: Maybe<AgentConfiguration>;
+  createdAt: Scalars["Date"]["output"];
+  createdBy: Maybe<User>;
+  id: Scalars["String"]["output"];
+  key: Scalars["String"]["output"];
+  keyType: ApiKeyType;
+  lastUsed: Maybe<Scalars["Date"]["output"]>;
+  name: Scalars["String"]["output"];
+  scope: ApiKeyScope;
+  userId: Scalars["String"]["output"];
+};
+
+export type ApplicationProgress = {
+  __typename: "ApplicationProgress";
+  currentStep: Scalars["String"]["output"];
+  estimatedCompletion: Maybe<Scalars["Date"]["output"]>;
+  filesModified: Array<Scalars["String"]["output"]>;
+  percentage: Scalars["Float"]["output"];
+  requirementsProgressJson: Maybe<Scalars["String"]["output"]>;
+  stage: Scalars["String"]["output"];
+};
+
+export type ApplicationQueueItem = {
+  __typename: "ApplicationQueueItem";
+  completedAt: Maybe<Scalars["Date"]["output"]>;
+  createdAt: Scalars["Date"]["output"];
+  estimatedDuration: Maybe<Scalars["Float"]["output"]>;
+  id: Scalars["String"]["output"];
+  priority: Scalars["Float"]["output"];
+  progress: Maybe<ApplicationProgress>;
+  projectId: Scalars["String"]["output"];
+  projectName: Scalars["String"]["output"];
+  queuePosition: Scalars["Float"]["output"];
+  reviewId: Scalars["String"]["output"];
+  startedAt: Maybe<Scalars["Date"]["output"]>;
+  status: ApplicationStatus;
+};
+
+/** Status of a review application */
+export enum ApplicationStatus {
+  CANCELLED = "CANCELLED",
+  COMPLETED = "COMPLETED",
+  FAILED = "FAILED",
+  IN_PROGRESS = "IN_PROGRESS",
+  NOT_APPLICABLE = "NOT_APPLICABLE",
+  PENDING = "PENDING",
+  QUEUED = "QUEUED",
+}
+
+export type ApplyReviewInput = {
+  applicationPrompt?: InputMaybe<Scalars["String"]["input"]>;
+  customInstructions?: InputMaybe<Scalars["String"]["input"]>;
+  focusAreas?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  reviewId: Scalars["String"]["input"];
+  validatedRequirementsJson?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type ApproveProjectReviewInput = {
+  approvalNotes?: InputMaybe<Scalars["String"]["input"]>;
+  approved: Scalars["Boolean"]["input"];
+  reviewId: Scalars["String"]["input"];
+};
+
+export type Attachment = {
+  __typename: "Attachment";
+  createdAt: Scalars["Date"]["output"];
+  createdByUser: Maybe<User>;
+  duration: Maybe<Scalars["Int"]["output"]>;
+  fileExtension: Scalars["String"]["output"];
+  fileSize: Scalars["Int"]["output"];
+  fileSizeFormatted: Scalars["String"]["output"];
+  filename: Scalars["String"]["output"];
+  height: Maybe<Scalars["Int"]["output"]>;
+  id: Scalars["ID"]["output"];
+  isAudio: Scalars["Boolean"]["output"];
+  isDocument: Scalars["Boolean"]["output"];
+  isImage: Scalars["Boolean"]["output"];
+  isPublic: Scalars["Boolean"]["output"];
+  isVideo: Scalars["Boolean"]["output"];
+  mimeType: Scalars["String"]["output"];
+  originalFilename: Scalars["String"]["output"];
+  storageProvider: Scalars["String"]["output"];
+  story: Maybe<Story>;
+  task: Maybe<Task>;
+  updatedAt: Scalars["Date"]["output"];
+  updatedByUser: Maybe<User>;
+  width: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type AttachmentSearchInput = {
+  createdBy?: InputMaybe<Scalars["String"]["input"]>;
+  isDocument?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isImage?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isVideo?: InputMaybe<Scalars["Boolean"]["input"]>;
+  mimeType?: InputMaybe<Scalars["String"]["input"]>;
+  storyId?: InputMaybe<Scalars["String"]["input"]>;
+  taskId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export enum AuditAction {
+  ASSIGNED = "ASSIGNED",
+  CREATED = "CREATED",
+  DELETED = "DELETED",
+  STATE_CHANGED = "STATE_CHANGED",
+  UNASSIGNED = "UNASSIGNED",
+  UPDATED = "UPDATED",
+}
+
+/** Type of audit action performed on work item */
+export enum AuditActionType {
+  CANCELLED = "CANCELLED",
+  CLAIMED = "CLAIMED",
+  COMPLETED = "COMPLETED",
+  CREATED = "CREATED",
+  FAILED = "FAILED",
+  PROGRESS_UPDATED = "PROGRESS_UPDATED",
+  REASSIGNED = "REASSIGNED",
+  RECLAIMED = "RECLAIMED",
+  RELEASED = "RELEASED",
+  RETRY = "RETRY",
+  STARTED = "STARTED",
+  TIMEOUT = "TIMEOUT",
+}
+
+export type AuditActionTypeCount = {
+  __typename: "AuditActionTypeCount";
+  actionType: AuditActionType;
+  count: Scalars["Int"]["output"];
+};
+
+export type AuditActorCount = {
+  __typename: "AuditActorCount";
+  actorId: Scalars["String"]["output"];
+  count: Scalars["Int"]["output"];
+};
+
+/** Type of actor that performed the audit action */
+export enum AuditActorType {
+  ADMIN = "ADMIN",
+  AI_WORKER = "AI_WORKER",
+  SYSTEM = "SYSTEM",
+  USER = "USER",
+}
+
+export type AuditActorTypeCount = {
+  __typename: "AuditActorTypeCount";
+  actorType: AuditActorType;
+  count: Scalars["Int"]["output"];
+};
+
+export type AuditLogResult = {
+  __typename: "AuditLogResult";
+  audit: Maybe<AiWorkAudit>;
+  message: Maybe<Scalars["String"]["output"]>;
+  success: Scalars["Boolean"]["output"];
+};
+
+export type AuditSearchInput = {
+  actionType?: InputMaybe<AuditActionType>;
+  actorId?: InputMaybe<Scalars["String"]["input"]>;
+  actorType?: InputMaybe<AuditActorType>;
+  dateFrom?: InputMaybe<Scalars["Date"]["input"]>;
+  dateTo?: InputMaybe<Scalars["Date"]["input"]>;
+  hasErrors?: InputMaybe<Scalars["Boolean"]["input"]>;
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  source?: InputMaybe<Scalars["String"]["input"]>;
+  userId?: InputMaybe<Scalars["String"]["input"]>;
+  workItemId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type AuditSearchResult = {
+  __typename: "AuditSearchResult";
+  hasMore: Scalars["Boolean"]["output"];
+  items: Array<AiWorkAudit>;
+  limit: Scalars["Int"]["output"];
+  offset: Scalars["Int"]["output"];
+  total: Scalars["Int"]["output"];
+};
+
+export type AuditSourceCount = {
+  __typename: "AuditSourceCount";
+  count: Scalars["Int"]["output"];
+  source: Scalars["String"]["output"];
+};
+
+export type AuditStatsResult = {
+  __typename: "AuditStatsResult";
+  actionTypeCounts: Array<AuditActionTypeCount>;
+  actorTypeCounts: Array<AuditActorTypeCount>;
+  averageDuration: Scalars["Float"]["output"];
+  errorRate: Scalars["Float"]["output"];
+  topActors: Array<AuditActorCount>;
+  topSources: Array<AuditSourceCount>;
+  totalActions: Scalars["Int"]["output"];
+};
+
+export type AuditTrail = {
+  __typename: "AuditTrail";
+  action: AuditAction;
+  createdAt: Scalars["Date"]["output"];
+  createdByUser: Maybe<User>;
+  entityId: Scalars["String"]["output"];
+  entityType: Scalars["String"]["output"];
+  fieldName: Maybe<Scalars["String"]["output"]>;
+  id: Scalars["ID"]["output"];
+  isAssignment: Scalars["Boolean"]["output"];
+  isCreation: Scalars["Boolean"]["output"];
+  isDeletion: Scalars["Boolean"]["output"];
+  isStateChange: Scalars["Boolean"]["output"];
+  isUpdate: Scalars["Boolean"]["output"];
+  metadata: Maybe<Scalars["JSONObject"]["output"]>;
+  newValue: Maybe<Scalars["JSONObject"]["output"]>;
+  oldValue: Maybe<Scalars["JSONObject"]["output"]>;
+  updatedAt: Scalars["Date"]["output"];
+  user: Maybe<User>;
+};
+
+export type AuthPayload = {
+  __typename: "AuthPayload";
+  refreshToken: Maybe<Scalars["String"]["output"]>;
+  token: Scalars["String"]["output"];
+  user: User;
+};
+
+export type BulkInviteUsersInput = {
+  emails: Array<Scalars["String"]["input"]>;
+  expiresInDays?: InputMaybe<Scalars["Float"]["input"]>;
+  message?: InputMaybe<Scalars["String"]["input"]>;
+  roleId: Scalars["String"]["input"];
+  teamId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type BulkOperationResult = {
+  __typename: "BulkOperationResult";
+  errors: Array<Scalars["String"]["output"]>;
+  failedOperations: Scalars["Float"]["output"];
+  successfulOperations: Scalars["Float"]["output"];
+  totalOperations: Scalars["Float"]["output"];
+};
+
+export type ChangePasswordInput = {
+  currentPassword: Scalars["String"]["input"];
+  newPassword: Scalars["String"]["input"];
+};
+
+export type ClarificationQuestionType = {
+  __typename: "ClarificationQuestionType";
+  category: Scalars["String"]["output"];
+  impact_if_unclear: Scalars["String"]["output"];
+  question: Scalars["String"]["output"];
+  suggested_default: Scalars["String"]["output"];
+};
+
+export type Comment = {
+  __typename: "Comment";
+  canDelete: Scalars["Boolean"]["output"];
+  canEdit: Scalars["Boolean"]["output"];
+  canReply: Scalars["Boolean"]["output"];
+  content: Scalars["String"]["output"];
+  contentHtml: Maybe<Scalars["String"]["output"]>;
+  createdAt: Scalars["Date"]["output"];
+  createdByUser: Maybe<User>;
+  editedAt: Maybe<Scalars["Date"]["output"]>;
+  hasReplies: Scalars["Boolean"]["output"];
+  id: Scalars["ID"]["output"];
+  isEdited: Scalars["Boolean"]["output"];
+  isReply: Scalars["Boolean"]["output"];
+  isTopLevel: Scalars["Boolean"]["output"];
+  parentComment: Maybe<Comment>;
+  replies: Array<Comment>;
+  replyCount: Scalars["Float"]["output"];
+  story: Maybe<Story>;
+  task: Maybe<Task>;
+  threadDepth: Scalars["Int"]["output"];
+  updatedAt: Scalars["Date"]["output"];
+  updatedByUser: Maybe<User>;
+};
+
+export type CommentSearchInput = {
+  includeReplies?: InputMaybe<Scalars["Boolean"]["input"]>;
+  parentOnly?: InputMaybe<Scalars["Boolean"]["input"]>;
+  storyId?: InputMaybe<Scalars["String"]["input"]>;
+  taskId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type CommentThread = {
+  __typename: "CommentThread";
+  comments: Array<CommentWithThread>;
+  topLevelCount: Scalars["Int"]["output"];
+  totalCount: Scalars["Int"]["output"];
+};
+
+export type CommentWithThread = {
+  __typename: "CommentWithThread";
+  comment: Comment;
+  depth: Scalars["Int"]["output"];
+  replies: Array<Comment>;
+  totalReplies: Scalars["Int"]["output"];
+};
+
+export type CreateAiServiceSessionInput = {
+  capabilitiesJson: Scalars["String"]["input"];
+  serviceEndpoint: Scalars["String"]["input"];
+  sessionToken: Scalars["String"]["input"];
+};
+
+export type CreateApiKeyInput = {
+  agentConfiguration?: InputMaybe<AgentConfigurationInput>;
+  expiresAt?: InputMaybe<Scalars["Date"]["input"]>;
+  keyType: ApiKeyType;
+  name: Scalars["String"]["input"];
+  scope: ApiKeyScope;
+};
+
+export type CreateAttachmentInput = {
+  duration?: InputMaybe<Scalars["Float"]["input"]>;
+  fileSize: Scalars["Float"]["input"];
+  filename: Scalars["String"]["input"];
+  height?: InputMaybe<Scalars["Float"]["input"]>;
+  isPublic?: Scalars["Boolean"]["input"];
+  mimeType: Scalars["String"]["input"];
+  originalFilename: Scalars["String"]["input"];
+  storagePath: Scalars["String"]["input"];
+  storyId?: InputMaybe<Scalars["String"]["input"]>;
+  taskId?: InputMaybe<Scalars["String"]["input"]>;
+  width?: InputMaybe<Scalars["Float"]["input"]>;
+};
+
+export type CreateAuditLogInput = {
+  actionType: AuditActionType;
+  actorId?: InputMaybe<Scalars["String"]["input"]>;
+  actorType: AuditActorType;
+  details?: InputMaybe<Scalars["String"]["input"]>;
+  metadata?: InputMaybe<Scalars["JSONObject"]["input"]>;
+  reason: Scalars["String"]["input"];
+  source?: InputMaybe<Scalars["String"]["input"]>;
+  workItemId: Scalars["String"]["input"];
+};
+
+export type CreateCommentInput = {
+  content: Scalars["String"]["input"];
+  parentCommentId?: InputMaybe<Scalars["String"]["input"]>;
+  storyId: Scalars["String"]["input"];
+};
+
+export type CreateDevelopmentPlanInput = {
+  createdByUserId?: InputMaybe<Scalars["String"]["input"]>;
+  dependenciesJson: Scalars["String"]["input"];
+  estimatesJson: Scalars["String"]["input"];
+  planDataJson: Scalars["String"]["input"];
+  projectId: Scalars["String"]["input"];
+};
+
+export type CreateDevelopmentPlanVersionInput = {
+  createdByUserId?: InputMaybe<Scalars["String"]["input"]>;
+  dependenciesJson: Scalars["String"]["input"];
+  estimatesJson: Scalars["String"]["input"];
+  parentPlanId: Scalars["String"]["input"];
+  planDataJson: Scalars["String"]["input"];
+  repromptContext?: InputMaybe<Scalars["String"]["input"]>;
+  versionNotes?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type CreateInviteFromEarlyAccessInput = {
+  earlyAccessId: Scalars["String"]["input"];
+  expiresInDays?: InputMaybe<Scalars["Float"]["input"]>;
+  message?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type CreateOrganizationInviteInput = {
+  companySize?: InputMaybe<Scalars["String"]["input"]>;
+  email: Scalars["String"]["input"];
+  expiresInDays?: InputMaybe<Scalars["Float"]["input"]>;
+  features: Array<Scalars["String"]["input"]>;
+  message?: InputMaybe<Scalars["String"]["input"]>;
+  useCase?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type CreateProjectInput = {
+  affectedServiceIds?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  documentationUrl?: InputMaybe<Scalars["String"]["input"]>;
+  isPublic?: InputMaybe<Scalars["Boolean"]["input"]>;
+  name: Scalars["String"]["input"];
+  repositoryUrl?: InputMaybe<Scalars["String"]["input"]>;
+  stage?: InputMaybe<ProjectStage>;
+  startDate?: InputMaybe<Scalars["Date"]["input"]>;
+  targetCompletionDate?: InputMaybe<Scalars["Date"]["input"]>;
+  workspaceConfig?: InputMaybe<Scalars["JSONObject"]["input"]>;
+  workspaceIds?: InputMaybe<Array<Scalars["String"]["input"]>>;
+};
+
+export type CreateReplyInput = {
+  content: Scalars["String"]["input"];
+  parentCommentId: Scalars["String"]["input"];
+};
+
+export type CreateRoleInput = {
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  name: Scalars["String"]["input"];
+  permissions: Scalars["JSONObject"]["input"];
+};
+
+export type CreateStoryDependencyInput = {
+  dependsOnStoryId: Scalars["String"]["input"];
+  storyId: Scalars["String"]["input"];
+};
+
+export type CreateStoryInput = {
+  acceptanceCriteria?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  assignedTo?: InputMaybe<Scalars["String"]["input"]>;
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  estimate?: InputMaybe<Scalars["Int"]["input"]>;
+  orderIndex?: InputMaybe<Scalars["Int"]["input"]>;
+  priority?: InputMaybe<PriorityLevel>;
+  projectId: Scalars["String"]["input"];
+  storyLink?: InputMaybe<Scalars["String"]["input"]>;
+  tags?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  title: Scalars["String"]["input"];
+};
+
+export type CreateTaskInput = {
+  areas: Array<Scalars["String"]["input"]>;
+  assignedTo?: InputMaybe<Scalars["String"]["input"]>;
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  dueDate?: InputMaybe<Scalars["Date"]["input"]>;
+  estimate?: InputMaybe<Scalars["Int"]["input"]>;
+  estimatedHours?: InputMaybe<Scalars["Int"]["input"]>;
+  priority?: InputMaybe<PriorityLevel>;
+  status?: InputMaybe<TaskState>;
+  storyId: Scalars["String"]["input"];
+  title: Scalars["String"]["input"];
+  type?: InputMaybe<TaskType>;
+};
+
+export type CreateTeamInput = {
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  name: Scalars["String"]["input"];
+  settings?: InputMaybe<Scalars["JSONObject"]["input"]>;
+};
+
+export type CreateUserInput = {
+  email: Scalars["String"]["input"];
+  firstName?: InputMaybe<Scalars["String"]["input"]>;
+  lastName?: InputMaybe<Scalars["String"]["input"]>;
+  role?: InputMaybe<UserRole>;
+  status?: InputMaybe<UserStatus>;
+  timezone?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type DashboardData = {
+  __typename: "DashboardData";
+  projectProgress: Array<ProgressMetric>;
+  recentActivity: Array<ActivityMetric>;
+  teamPerformance: Array<TeamPerformance>;
+  topPerformers: Array<UserStats>;
+  topProjects: Array<ProjectStats>;
+  velocityTrend: Array<VelocityMetric>;
+  workspaceStats: WorkspaceStats;
+};
+
+export type DeprecationWarning = {
+  __typename: "DeprecationWarning";
+  deprecatedInVersion: Scalars["String"]["output"];
+  feature: Scalars["String"]["output"];
+  message: Scalars["String"]["output"];
+  removedInVersion: Scalars["String"]["output"];
+};
+
+export type DevelopmentPlan = {
+  __typename: "DevelopmentPlan";
+  activatedAt: Maybe<Scalars["Date"]["output"]>;
+  activatedByUser: Maybe<User>;
+  activationNotes: Maybe<Scalars["String"]["output"]>;
+  approvalNotes: Maybe<Scalars["String"]["output"]>;
+  approvedAt: Maybe<Scalars["Date"]["output"]>;
+  approvedByUser: Maybe<User>;
+  averageConfidence: Scalars["Float"]["output"];
+  childVersionCount: Scalars["Int"]["output"];
+  childVersions: Array<DevelopmentPlan>;
+  coordinatedServices: Array<Scalars["String"]["output"]>;
+  createdAt: Scalars["Date"]["output"];
+  createdByUser: Maybe<User>;
+  criticalPathLength: Scalars["Float"]["output"];
+  dependenciesJson: Scalars["String"]["output"];
+  estimatesJson: Scalars["String"]["output"];
+  generatedBy: PlanGeneratedBy;
+  hasChildVersions: Scalars["Boolean"]["output"];
+  id: Scalars["ID"]["output"];
+  isAIGenerated: Scalars["Boolean"]["output"];
+  isActive: Scalars["Boolean"]["output"];
+  isApproved: Scalars["Boolean"]["output"];
+  isDraft: Scalars["Boolean"]["output"];
+  isLatestVersion: Scalars["Boolean"]["output"];
+  isOriginalVersion: Scalars["Boolean"]["output"];
+  parentPlan: Maybe<DevelopmentPlan>;
+  phaseCount: Scalars["Float"]["output"];
+  planDataJson: Scalars["String"]["output"];
+  project: Project;
+  rejectedAt: Maybe<Scalars["Date"]["output"]>;
+  rejectedByUser: Maybe<User>;
+  rejectionReason: Maybe<Scalars["String"]["output"]>;
+  repromptContext: Maybe<Scalars["String"]["output"]>;
+  requestedByUser: Maybe<User>;
+  status: PlanStatus;
+  storyCount: Scalars["Float"]["output"];
+  targetWorkspaces: Array<Scalars["String"]["output"]>;
+  totalEstimatedDays: Scalars["Float"]["output"];
+  totalEstimatedHours: Scalars["Float"]["output"];
+  updatedAt: Scalars["Date"]["output"];
+  version: Scalars["Int"]["output"];
+  versionNotes: Maybe<Scalars["String"]["output"]>;
+};
+
+export type DevelopmentPlanAuditLog = {
+  __typename: "DevelopmentPlanAuditLog";
+  action: PlanAuditAction;
+  createdAt: Scalars["Date"]["output"];
+  description: Maybe<Scalars["String"]["output"]>;
+  id: Scalars["ID"]["output"];
+  metadataJson: Maybe<Scalars["String"]["output"]>;
+  notes: Maybe<Scalars["String"]["output"]>;
+  performedBy: Maybe<User>;
+  plan: DevelopmentPlan;
+  planVersion: Maybe<Scalars["Float"]["output"]>;
+  timestamp: Scalars["Date"]["output"];
+  updatedAt: Scalars["Date"]["output"];
+};
+
+export type DevelopmentPlanSearchInput = {
+  createdByUserId?: InputMaybe<Scalars["String"]["input"]>;
+  projectId?: InputMaybe<Scalars["String"]["input"]>;
+  status?: InputMaybe<PlanStatus>;
+};
+
+export type EarlyAccessRegistration = {
+  __typename: "EarlyAccessRegistration";
+  acceptedTerms: Scalars["Boolean"]["output"];
+  ageVerified: Scalars["Boolean"]["output"];
+  aiTools: Array<Scalars["String"]["output"]>;
+  comments: Maybe<Scalars["String"]["output"]>;
+  companyName: Maybe<Scalars["String"]["output"]>;
+  contactName: Maybe<Scalars["String"]["output"]>;
+  createdAt: Scalars["Date"]["output"];
+  currentTools: Array<Scalars["String"]["output"]>;
+  email: Scalars["String"]["output"];
+  id: Scalars["ID"]["output"];
+  inviteSentAt: Maybe<Scalars["Date"]["output"]>;
+  inviteToken: Maybe<Scalars["String"]["output"]>;
+  notes: Maybe<Scalars["String"]["output"]>;
+  organizationInviteId: Maybe<Scalars["String"]["output"]>;
+  painPoints: Array<Scalars["String"]["output"]>;
+  primaryLanguages: Array<Scalars["String"]["output"]>;
+  projectTypes: Array<Scalars["String"]["output"]>;
+  repoStructure: Maybe<Scalars["String"]["output"]>;
+  role: Maybe<Scalars["String"]["output"]>;
+  serviceCount: Maybe<Scalars["String"]["output"]>;
+  status: Scalars["String"]["output"];
+  subscribeToNewsletter: Maybe<Scalars["Boolean"]["output"]>;
+  teamSize: Maybe<Scalars["String"]["output"]>;
+  updatedAt: Scalars["Date"]["output"];
+};
+
+/** Error categories for analysis */
+export enum ErrorCategory {
+  CONFIGURATION = "CONFIGURATION",
+  PERMANENT = "PERMANENT",
+  SYSTEM = "SYSTEM",
+  TRANSIENT = "TRANSIENT",
+}
+
+/** Error severity levels */
+export enum ErrorSeverity {
+  CRITICAL = "CRITICAL",
+  HIGH = "HIGH",
+  LOW = "LOW",
+  MEDIUM = "MEDIUM",
+}
+
+export type ExplicitRequirementInput = {
+  confidence: Scalars["String"]["input"];
+  requirement: Scalars["String"]["input"];
+  source_text: Scalars["String"]["input"];
+};
+
+export type ExplicitRequirementType = {
+  __typename: "ExplicitRequirementType";
+  confidence: Scalars["String"]["output"];
+  requirement: Scalars["String"]["output"];
+  source_text: Scalars["String"]["output"];
+};
+
+export type FileDownloadResponse = {
+  __typename: "FileDownloadResponse";
+  fileSize: Scalars["Float"]["output"];
+  filename: Scalars["String"]["output"];
+  mimeType: Scalars["String"]["output"];
+  url: Scalars["String"]["output"];
+};
+
+export type FileModificationInput = {
+  change_type: Scalars["String"]["input"];
+  path: Scalars["String"]["input"];
+  summary: Scalars["String"]["input"];
+};
+
+export enum FlockHealthStatus {
+  CRITICAL = "CRITICAL",
+  HEALTHY = "HEALTHY",
+  STABLE = "STABLE",
+  STRESSED = "STRESSED",
+  STRUGGLING = "STRUGGLING",
+  THRIVING = "THRIVING",
+}
+
+export type GenerateStoriesFromPlanResult = {
+  __typename: "GenerateStoriesFromPlanResult";
+  message: Scalars["String"]["output"];
+  stories: Array<Story>;
+  storiesCreated: Scalars["Int"]["output"];
+  success: Scalars["Boolean"]["output"];
+  tasks: Array<Task>;
+  tasksCreated: Scalars["Int"]["output"];
+};
+
+export type ImplementationPlanInput = {
+  analysis: AnalysisInput;
+  analysis_type: Scalars["String"]["input"];
+  executive_summary: Scalars["String"]["input"];
+  metadata: MetadataInput;
+  project_id: Scalars["String"]["input"];
+  recommendations: Array<RecommendationInput>;
+  scores: ScoresInput;
+  suggested_product_requirements: ProductRequirementsInput;
+  timeline: TimelineInput;
+};
+
+export type InferredFunctionalRequirementInput = {
+  domain_pattern: Scalars["String"]["input"];
+  priority: Scalars["String"]["input"];
+  rationale: Scalars["String"]["input"];
+  requirement: Scalars["String"]["input"];
+};
+
+export type InferredRequirementType = {
+  __typename: "InferredRequirementType";
+  domain_pattern: Scalars["String"]["output"];
+  priority: Scalars["String"]["output"];
+  rationale: Scalars["String"]["output"];
+  requirement: Scalars["String"]["output"];
+};
+
+export type InvitationPayload = {
+  __typename: "InvitationPayload";
+  error: Maybe<Scalars["String"]["output"]>;
+  invitationId: Scalars["String"]["output"];
+  success: Scalars["Boolean"]["output"];
+};
+
+export enum InvitationStatus {
+  ACCEPTED = "ACCEPTED",
+  DECLINED = "DECLINED",
+  EXPIRED = "EXPIRED",
+  PENDING = "PENDING",
+}
+
+export type InviteResponse = {
+  __typename: "InviteResponse";
+  error: Maybe<Scalars["String"]["output"]>;
+  inviteToken: Maybe<Scalars["String"]["output"]>;
+  inviteUrl: Maybe<Scalars["String"]["output"]>;
+  success: Scalars["Boolean"]["output"];
+};
+
+export type InviteUserInput = {
+  email: Scalars["String"]["input"];
+  expiresInDays?: InputMaybe<Scalars["Float"]["input"]>;
+  message?: InputMaybe<Scalars["String"]["input"]>;
+  roleId: Scalars["String"]["input"];
+  teamId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type LoginInput = {
+  email: Scalars["String"]["input"];
+  password: Scalars["String"]["input"];
+};
+
+export type LoginPayload = {
+  __typename: "LoginPayload";
+  expiresIn: Scalars["String"]["output"];
+  refreshToken: Maybe<Scalars["String"]["output"]>;
+  token: Scalars["String"]["output"];
+  tokenType: Scalars["String"]["output"];
+  user: User;
+};
+
+export type LogoutPayload = {
+  __typename: "LogoutPayload";
+  message: Scalars["String"]["output"];
+  success: Scalars["Boolean"]["output"];
+};
+
+export type McpAgentOperationResult = {
+  __typename: "MCPAgentOperationResult";
+  analysisId: Maybe<Scalars["String"]["output"]>;
+  message: Scalars["String"]["output"];
+  planId: Maybe<Scalars["String"]["output"]>;
+  success: Scalars["Boolean"]["output"];
+  taskId: Maybe<Scalars["String"]["output"]>;
+};
+
+export type MetadataInput = {
+  analysis_duration_seconds: Scalars["Float"]["input"];
+  analysis_timestamp: Scalars["String"]["input"];
+  claude_model: Scalars["String"]["input"];
+  confidence_level: Scalars["Float"]["input"];
+  reviewer_notes?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type Mutation = {
+  __typename: "Mutation";
+  acceptOrganizationInvite: OrganizationRegistrationResponse;
+  activateDevelopmentPlan: DevelopmentPlan;
+  addTaskTimeEntry: Task;
+  addTeamMember: TeamMember;
+  allocateWork: Array<AiWorkQueue>;
+  applyProjectReview: ReviewApplicationResult;
+  approveDevelopmentPlan: DevelopmentPlan;
+  approveProjectReview: ProjectReview;
+  assignTask: Task;
+  bulkCancelAIWorkItems: AiWorkBulkOperationResult;
+  bulkDeleteAIWorkItems: AiWorkBulkOperationResult;
+  bulkInviteUsers: BulkOperationResult;
+  bulkRequeueAIWorkItems: AiWorkBulkOperationResult;
+  bulkUpdateUsers: BulkOperationResult;
+  cancelReviewApplication: Scalars["Boolean"]["output"];
+  changePassword: PasswordChangePayload;
+  claimAIWork: AiWorkQueue;
+  claimStory: Story;
+  claimTask: Task;
+  cleanupOrphanedWork: Scalars["Boolean"]["output"];
+  cleanupStaleAIWorkers: AiWorkerOperationResult;
+  cleanupStaleWorkTasks: Scalars["Boolean"]["output"];
+  clearTaskTimeEntries: Task;
+  completeAIWork: AiWorkQueue;
+  completeReviewApplication: Scalars["Boolean"]["output"];
+  completeStory: Story;
+  completeTask: Task;
+  createAIServiceSession: AiServiceSession;
+  createApiKey: ApiKeyWithSecret;
+  createAttachment: Attachment;
+  createAuditLog: AuditLogResult;
+  createComment: Comment;
+  createDevelopmentPlan: DevelopmentPlan;
+  createDevelopmentPlanVersion: DevelopmentPlan;
+  createEarlyAccessRegistration: EarlyAccessRegistration;
+  createInviteFromEarlyAccess: InviteResponse;
+  createOrganizationInvite: OrganizationInvite;
+  createProject: Project;
+  createProjectReview: ProjectReview;
+  createReply: Comment;
+  createRole: Role;
+  createStory: Story;
+  createStoryDependency: Story;
+  createTask: Task;
+  createTaskDependency: Task;
+  createTeam: Team;
+  createUser: User;
+  deactivateUser: Scalars["Boolean"]["output"];
+  deactivateWorkspace: Scalars["Boolean"]["output"];
+  deleteApiKey: Scalars["Boolean"]["output"];
+  deleteAttachment: Scalars["Boolean"]["output"];
+  deleteComment: Scalars["Boolean"]["output"];
+  deleteMultipleNotifications: Scalars["Boolean"]["output"];
+  deleteNotification: Scalars["Boolean"]["output"];
+  deleteProject: Scalars["Boolean"]["output"];
+  deleteStory: Scalars["Boolean"]["output"];
+  deleteTask: Scalars["Boolean"]["output"];
+  deleteTeam: Scalars["Boolean"]["output"];
+  deleteUser: Scalars["Boolean"]["output"];
+  deleteWorkspace: Scalars["Boolean"]["output"];
+  disableUser: User;
+  disconnectAIService: Scalars["Boolean"]["output"];
+  enableUser: User;
+  exchangeApiKeyForToken: LoginPayload;
+  generateInviteToken: InviteResponse;
+  generateStoriesFromPlan: GenerateStoriesFromPlanResult;
+  inviteUser: InvitationPayload;
+  logUserActivity: UserActivity;
+  logWorkItemError: WorkItemErrorResult;
+  logWorkItemEvent: WorkItemLogResult;
+  login: LoginPayload;
+  logout: LogoutPayload;
+  markAllNotificationsRead: Scalars["Boolean"]["output"];
+  markMultipleNotificationsRead: Scalars["Boolean"]["output"];
+  markNotificationRead: Notification;
+  optimizeWorkQueue: Scalars["String"]["output"];
+  queueAIWork: AiWorkQueue;
+  reactivateUser: Scalars["Boolean"]["output"];
+  reclaimWork: Array<AiWorkQueue>;
+  refreshToken: LoginPayload;
+  register: AuthPayload;
+  registerAIWorker: AiWorkerOperationResult;
+  registerWorker: Scalars["Boolean"]["output"];
+  registerWorkspace: Workspace;
+  rejectDevelopmentPlan: DevelopmentPlan;
+  releaseStory: Story;
+  releaseWorkItem: Scalars["Boolean"]["output"];
+  removeAIWork: Scalars["Boolean"]["output"];
+  removeStoryDependency: Story;
+  removeTaskDependency: Task;
+  removeTeamMember: Scalars["Boolean"]["output"];
+  repromptDevelopmentPlan: RepromptDevelopmentPlanResult;
+  repromptProjectReview: ProjectReview;
+  requestPasswordReset: PasswordResetRequestPayload;
+  requeueAIWorkItem: AiWorkQueue;
+  resendOrganizationInvite: Maybe<OrganizationInvite>;
+  resetPassword: PasswordResetPayload;
+  retryAIWork: AiWorkQueue;
+  reviewStory: Story;
+  revokeOrganizationInvite: Maybe<OrganizationInvite>;
+  sendAIServiceHeartbeat: Scalars["Boolean"]["output"];
+  startTask: Task;
+  startTaskTimer: Task;
+  stopTaskTimer: Task;
+  submitImplementationPlan: McpAgentOperationResult;
+  submitProjectAnalysis: McpAgentOperationResult;
+  submitStoryForReview: Story;
+  submitStoryProgress: McpAgentOperationResult;
+  submitTaskImplementation: McpAgentOperationResult;
+  unclaimTask: Task;
+  unregisterAIWorker: AiWorkerOperationResult;
+  updateAIServiceSession: AiServiceSession;
+  updateAIWork: AiWorkQueue;
+  updateAIWorkerHeartbeat: AiWorkerOperationResult;
+  updateAIWorkerHeartbeatWithProgress: AiWorkerOperationResult;
+  updateAIWorkerTaskCount: AiWorkerOperationResult;
+  updateApiKey: UserApiKey;
+  updateComment: Comment;
+  updateDevelopmentPlan: DevelopmentPlan;
+  updateEarlyAccessRegistration: Maybe<EarlyAccessRegistration>;
+  updateProject: Project;
+  updateProjectReview: ProjectReview;
+  updateRole: Role;
+  updateStory: Story;
+  updateStoryStatus: Story;
+  updateTask: Task;
+  updateTeam: Team;
+  updateTeamMember: TeamMember;
+  updateUser: User;
+  updateUserPreferences: UserPreferences;
+  updateUserRole: User;
+  updateWorkerHeartbeat: Scalars["Boolean"]["output"];
+};
+
+export type MutationAcceptOrganizationInviteArgs = {
+  input: AcceptOrganizationInviteInput;
+};
+
+export type MutationActivateDevelopmentPlanArgs = {
+  activationNotes?: InputMaybe<Scalars["String"]["input"]>;
+  id: Scalars["String"]["input"];
+};
+
+export type MutationAddTaskTimeEntryArgs = {
+  date?: InputMaybe<Scalars["Date"]["input"]>;
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  id: Scalars["String"]["input"];
+  minutes: Scalars["Int"]["input"];
+};
+
+export type MutationAddTeamMemberArgs = {
+  input: AddTeamMemberInput;
+};
+
+export type MutationAllocateWorkArgs = {
+  input: WorkAllocationInput;
+};
+
+export type MutationApplyProjectReviewArgs = {
+  input: ApplyReviewInput;
+};
+
+export type MutationApproveDevelopmentPlanArgs = {
+  approvalNotes?: InputMaybe<Scalars["String"]["input"]>;
+  id: Scalars["String"]["input"];
+};
+
+export type MutationApproveProjectReviewArgs = {
+  input: ApproveProjectReviewInput;
+};
+
+export type MutationAssignTaskArgs = {
+  taskId: Scalars["String"]["input"];
+  userId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type MutationBulkCancelAiWorkItemsArgs = {
+  ids: Array<Scalars["String"]["input"]>;
+};
+
+export type MutationBulkDeleteAiWorkItemsArgs = {
+  ids: Array<Scalars["String"]["input"]>;
+};
+
+export type MutationBulkInviteUsersArgs = {
+  input: BulkInviteUsersInput;
+};
+
+export type MutationBulkRequeueAiWorkItemsArgs = {
+  ids: Array<Scalars["String"]["input"]>;
+};
+
+export type MutationBulkUpdateUsersArgs = {
+  operations: Array<UserOperation>;
+};
+
+export type MutationCancelReviewApplicationArgs = {
+  reviewId: Scalars["String"]["input"];
+};
+
+export type MutationChangePasswordArgs = {
+  input: ChangePasswordInput;
+};
+
+export type MutationClaimAiWorkArgs = {
+  aiWorkerId: Scalars["String"]["input"];
+  id: Scalars["String"]["input"];
+};
+
+export type MutationClaimStoryArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationClaimTaskArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationClearTaskTimeEntriesArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationCompleteAiWorkArgs = {
+  artifacts?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id: Scalars["String"]["input"];
+  summary: Scalars["String"]["input"];
+};
+
+export type MutationCompleteReviewApplicationArgs = {
+  result: Scalars["JSONObject"]["input"];
+  reviewId: Scalars["String"]["input"];
+  workQueueId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type MutationCompleteStoryArgs = {
+  id: Scalars["String"]["input"];
+  implementationSummary?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type MutationCompleteTaskArgs = {
+  id: Scalars["String"]["input"];
+  implementationSummary?: InputMaybe<Scalars["String"]["input"]>;
+  keyFiles?: InputMaybe<Array<Scalars["String"]["input"]>>;
+};
+
+export type MutationCreateAiServiceSessionArgs = {
+  input: CreateAiServiceSessionInput;
+};
+
+export type MutationCreateApiKeyArgs = {
+  input: CreateApiKeyInput;
+};
+
+export type MutationCreateAttachmentArgs = {
+  input: CreateAttachmentInput;
+};
+
+export type MutationCreateAuditLogArgs = {
+  input: CreateAuditLogInput;
+};
+
+export type MutationCreateCommentArgs = {
+  input: CreateCommentInput;
+};
+
+export type MutationCreateDevelopmentPlanArgs = {
+  input: CreateDevelopmentPlanInput;
+};
+
+export type MutationCreateDevelopmentPlanVersionArgs = {
+  input: CreateDevelopmentPlanVersionInput;
+};
+
+export type MutationCreateEarlyAccessRegistrationArgs = {
+  input: PublicEarlyAccessRegistrationInput;
+};
+
+export type MutationCreateInviteFromEarlyAccessArgs = {
+  input: CreateInviteFromEarlyAccessInput;
+};
+
+export type MutationCreateOrganizationInviteArgs = {
+  input: CreateOrganizationInviteInput;
+};
+
+export type MutationCreateProjectArgs = {
+  input: CreateProjectInput;
+};
+
+export type MutationCreateProjectReviewArgs = {
+  input: ProjectReviewInput;
+};
+
+export type MutationCreateReplyArgs = {
+  input: CreateReplyInput;
+};
+
+export type MutationCreateRoleArgs = {
+  input: CreateRoleInput;
+};
+
+export type MutationCreateStoryArgs = {
+  input: CreateStoryInput;
+};
+
+export type MutationCreateStoryDependencyArgs = {
+  input: CreateStoryDependencyInput;
+};
+
+export type MutationCreateTaskArgs = {
+  input: CreateTaskInput;
+};
+
+export type MutationCreateTaskDependencyArgs = {
+  dependentId: Scalars["String"]["input"];
+  dependsOnId: Scalars["String"]["input"];
+};
+
+export type MutationCreateTeamArgs = {
+  input: CreateTeamInput;
+};
+
+export type MutationCreateUserArgs = {
+  input: CreateUserInput;
+};
+
+export type MutationDeactivateUserArgs = {
+  userId: Scalars["String"]["input"];
+};
+
+export type MutationDeactivateWorkspaceArgs = {
+  workspaceId: Scalars["String"]["input"];
+};
+
+export type MutationDeleteApiKeyArgs = {
+  id: Scalars["ID"]["input"];
+};
+
+export type MutationDeleteAttachmentArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationDeleteCommentArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationDeleteMultipleNotificationsArgs = {
+  notificationIds: Array<Scalars["String"]["input"]>;
+};
+
+export type MutationDeleteNotificationArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationDeleteProjectArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationDeleteStoryArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationDeleteTaskArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationDeleteTeamArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationDeleteUserArgs = {
+  userId: Scalars["String"]["input"];
+};
+
+export type MutationDeleteWorkspaceArgs = {
+  workspaceId: Scalars["String"]["input"];
+};
+
+export type MutationDisableUserArgs = {
+  userId: Scalars["String"]["input"];
+};
+
+export type MutationEnableUserArgs = {
+  userId: Scalars["String"]["input"];
+};
+
+export type MutationExchangeApiKeyForTokenArgs = {
+  apiKey: Scalars["String"]["input"];
+};
+
+export type MutationGenerateInviteTokenArgs = {
+  earlyAccessId: Scalars["String"]["input"];
+};
+
+export type MutationGenerateStoriesFromPlanArgs = {
+  planId: Scalars["String"]["input"];
+};
+
+export type MutationInviteUserArgs = {
+  input: InviteUserInput;
+};
+
+export type MutationLogUserActivityArgs = {
+  actionType: Scalars["String"]["input"];
+  metadata?: InputMaybe<Scalars["JSONObject"]["input"]>;
+  resourceId?: InputMaybe<Scalars["String"]["input"]>;
+  resourceType?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type MutationLogWorkItemErrorArgs = {
+  input: WorkItemErrorInput;
+};
+
+export type MutationLogWorkItemEventArgs = {
+  input: WorkItemLogInput;
+};
+
+export type MutationLoginArgs = {
+  input: LoginInput;
+};
+
+export type MutationMarkMultipleNotificationsReadArgs = {
+  notificationIds: Array<Scalars["String"]["input"]>;
+};
+
+export type MutationMarkNotificationReadArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationOptimizeWorkQueueArgs = {
+  input?: InputMaybe<QueueOptimizationInput>;
+};
+
+export type MutationQueueAiWorkArgs = {
+  input: QueueAiWorkInput;
+};
+
+export type MutationReactivateUserArgs = {
+  userId: Scalars["String"]["input"];
+};
+
+export type MutationReclaimWorkArgs = {
+  workItemIds?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  workerId: Scalars["String"]["input"];
+};
+
+export type MutationRefreshTokenArgs = {
+  input: RefreshTokenInput;
+};
+
+export type MutationRegisterArgs = {
+  input: RegisterInput;
+};
+
+export type MutationRegisterAiWorkerArgs = {
+  input: AiWorkerRegistrationInput;
+};
+
+export type MutationRegisterWorkerArgs = {
+  input: WorkerRegistrationInput;
+};
+
+export type MutationRegisterWorkspaceArgs = {
+  input: WorkspaceRegistrationInput;
+};
+
+export type MutationRejectDevelopmentPlanArgs = {
+  id: Scalars["String"]["input"];
+  rejectionReason: Scalars["String"]["input"];
+};
+
+export type MutationReleaseStoryArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationReleaseWorkItemArgs = {
+  input: WorkItemReleaseInput;
+};
+
+export type MutationRemoveAiWorkArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationRemoveStoryDependencyArgs = {
+  input: RemoveStoryDependencyInput;
+};
+
+export type MutationRemoveTaskDependencyArgs = {
+  dependentId: Scalars["String"]["input"];
+  dependsOnId: Scalars["String"]["input"];
+};
+
+export type MutationRemoveTeamMemberArgs = {
+  teamId: Scalars["String"]["input"];
+  userId: Scalars["String"]["input"];
+};
+
+export type MutationRepromptDevelopmentPlanArgs = {
+  input: RepromptDevelopmentPlanInput;
+};
+
+export type MutationRepromptProjectReviewArgs = {
+  input: RepromptReviewInput;
+};
+
+export type MutationRequestPasswordResetArgs = {
+  input: RequestPasswordResetInput;
+};
+
+export type MutationRequeueAiWorkItemArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationResendOrganizationInviteArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationResetPasswordArgs = {
+  input: ResetPasswordInput;
+};
+
+export type MutationRetryAiWorkArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationReviewStoryArgs = {
+  approved: Scalars["Boolean"]["input"];
+  id: Scalars["String"]["input"];
+  reviewNotes?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type MutationRevokeOrganizationInviteArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationStartTaskArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationStartTaskTimerArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationStopTaskTimerArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationSubmitImplementationPlanArgs = {
+  plan: ImplementationPlanInput;
+};
+
+export type MutationSubmitProjectAnalysisArgs = {
+  analysis: ProjectAnalysisInput;
+};
+
+export type MutationSubmitStoryForReviewArgs = {
+  id: Scalars["String"]["input"];
+  implementationSummary?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type MutationSubmitStoryProgressArgs = {
+  progress: StoryProgressInput;
+};
+
+export type MutationSubmitTaskImplementationArgs = {
+  implementation: TaskImplementationInput;
+};
+
+export type MutationUnclaimTaskArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type MutationUnregisterAiWorkerArgs = {
+  workerId: Scalars["String"]["input"];
+};
+
+export type MutationUpdateAiServiceSessionArgs = {
+  id: Scalars["String"]["input"];
+  input: UpdateAiServiceSessionInput;
+};
+
+export type MutationUpdateAiWorkArgs = {
+  input: UpdateAiWorkInput;
+};
+
+export type MutationUpdateAiWorkerHeartbeatArgs = {
+  input: AiWorkerHealthCheckInput;
+};
+
+export type MutationUpdateAiWorkerHeartbeatWithProgressArgs = {
+  input: AiWorkerHeartbeatInput;
+};
+
+export type MutationUpdateAiWorkerTaskCountArgs = {
+  taskCount: Scalars["Float"]["input"];
+  workerId: Scalars["String"]["input"];
+};
+
+export type MutationUpdateApiKeyArgs = {
+  id: Scalars["ID"]["input"];
+  input: UpdateApiKeyInput;
+};
+
+export type MutationUpdateCommentArgs = {
+  id: Scalars["String"]["input"];
+  input: UpdateCommentInput;
+};
+
+export type MutationUpdateDevelopmentPlanArgs = {
+  id: Scalars["String"]["input"];
+  input: UpdateDevelopmentPlanInput;
+};
+
+export type MutationUpdateEarlyAccessRegistrationArgs = {
+  id: Scalars["String"]["input"];
+  input: UpdateEarlyAccessRegistrationInput;
+};
+
+export type MutationUpdateProjectArgs = {
+  id: Scalars["String"]["input"];
+  input: UpdateProjectInput;
+};
+
+export type MutationUpdateProjectReviewArgs = {
+  input: ProjectReviewInput;
+  reviewId: Scalars["String"]["input"];
+};
+
+export type MutationUpdateRoleArgs = {
+  id: Scalars["String"]["input"];
+  input: UpdateRoleInput;
+};
+
+export type MutationUpdateStoryArgs = {
+  id: Scalars["String"]["input"];
+  input: UpdateStoryInput;
+};
+
+export type MutationUpdateStoryStatusArgs = {
+  id: Scalars["String"]["input"];
+  status: StoryState;
+};
+
+export type MutationUpdateTaskArgs = {
+  id: Scalars["String"]["input"];
+  input: UpdateTaskInput;
+};
+
+export type MutationUpdateTeamArgs = {
+  id: Scalars["String"]["input"];
+  input: UpdateTeamInput;
+};
+
+export type MutationUpdateTeamMemberArgs = {
+  input: UpdateTeamMemberInput;
+  teamId: Scalars["String"]["input"];
+  userId: Scalars["String"]["input"];
+};
+
+export type MutationUpdateUserArgs = {
+  id: Scalars["String"]["input"];
+  input: UpdateUserInput;
+};
+
+export type MutationUpdateUserPreferencesArgs = {
+  input: UpdateUserPreferencesInput;
+};
+
+export type MutationUpdateUserRoleArgs = {
+  roleId: Scalars["String"]["input"];
+  userId: Scalars["String"]["input"];
+};
+
+export type MutationUpdateWorkerHeartbeatArgs = {
+  input: WorkerHeartbeatInput;
+};
+
+export type NonFunctionalRequirementInput = {
+  category: Scalars["String"]["input"];
+  customization_needed: Scalars["Boolean"]["input"];
+  industry_standard: Scalars["Boolean"]["input"];
+  requirement: Scalars["String"]["input"];
+};
+
+export type NonFunctionalRequirementType = {
+  __typename: "NonFunctionalRequirementType";
+  category: Scalars["String"]["output"];
+  customization_needed: Scalars["Boolean"]["output"];
+  industry_standard: Scalars["Boolean"]["output"];
+  requirement: Scalars["String"]["output"];
+};
+
+export type Notification = {
+  __typename: "Notification";
+  createdAt: Scalars["Date"]["output"];
+  createdByUser: Maybe<User>;
+  emailSent: Scalars["Boolean"]["output"];
+  emailSentAt: Maybe<Scalars["Date"]["output"]>;
+  entityId: Maybe<Scalars["String"]["output"]>;
+  entityType: Maybe<Scalars["String"]["output"]>;
+  id: Scalars["ID"]["output"];
+  isRead: Scalars["Boolean"]["output"];
+  isRecent: Scalars["Boolean"]["output"];
+  isUnread: Scalars["Boolean"]["output"];
+  message: Scalars["String"]["output"];
+  readAt: Maybe<Scalars["Date"]["output"]>;
+  shouldSendEmail: Scalars["Boolean"]["output"];
+  targetUrl: Maybe<Scalars["String"]["output"]>;
+  title: Scalars["String"]["output"];
+  type: NotificationType;
+  updatedAt: Scalars["Date"]["output"];
+  user: User;
+};
+
+export enum NotificationType {
+  ASSIGNMENT = "ASSIGNMENT",
+  COMMENT = "COMMENT",
+  DEADLINE = "DEADLINE",
+  MENTION = "MENTION",
+  STATUS_CHANGE = "STATUS_CHANGE",
+}
+
+export type OpportunityInput = {
+  description: Scalars["String"]["input"];
+  implementation_complexity?: InputMaybe<Scalars["String"]["input"]>;
+  potential_value: Scalars["String"]["input"];
+  title: Scalars["String"]["input"];
+};
+
+export type Organization = {
+  __typename: "Organization";
+  createdAt: Scalars["Date"]["output"];
+  deletedAt: Maybe<Scalars["Date"]["output"]>;
+  description: Maybe<Scalars["String"]["output"]>;
+  fullDomain: Scalars["String"]["output"];
+  id: Scalars["ID"]["output"];
+  isActive: Scalars["Boolean"]["output"];
+  name: Scalars["String"]["output"];
+  settings: Maybe<Scalars["JSON"]["output"]>;
+  status: OrganizationStatus;
+  subdomain: Scalars["String"]["output"];
+  updatedAt: Scalars["Date"]["output"];
+};
+
+export type OrganizationInvite = {
+  __typename: "OrganizationInvite";
+  acceptedAt: Maybe<Scalars["Date"]["output"]>;
+  acceptedByUserId: Maybe<Scalars["String"]["output"]>;
+  companySize: Maybe<Scalars["String"]["output"]>;
+  createdAt: Scalars["Date"]["output"];
+  createdOrganizationId: Maybe<Scalars["String"]["output"]>;
+  email: Scalars["String"]["output"];
+  expiresAt: Maybe<Scalars["Date"]["output"]>;
+  features: Array<Scalars["String"]["output"]>;
+  id: Scalars["ID"]["output"];
+  inviteToken: Scalars["String"]["output"];
+  invitedBy: Maybe<User>;
+  message: Maybe<Scalars["String"]["output"]>;
+  status: Scalars["String"]["output"];
+  updatedAt: Scalars["Date"]["output"];
+  useCase: Maybe<Scalars["String"]["output"]>;
+};
+
+export type OrganizationRegistrationResponse = {
+  __typename: "OrganizationRegistrationResponse";
+  loginUrl: Maybe<Scalars["String"]["output"]>;
+  message: Scalars["String"]["output"];
+  organizationId: Maybe<Scalars["String"]["output"]>;
+  success: Scalars["Boolean"]["output"];
+  userId: Maybe<Scalars["String"]["output"]>;
+};
+
+export enum OrganizationRole {
+  ADMIN = "ADMIN",
+  MEMBER = "MEMBER",
+  OWNER = "OWNER",
+  VIEWER = "VIEWER",
+}
+
+export enum OrganizationStatus {
+  ACTIVE = "ACTIVE",
+  ARCHIVED = "ARCHIVED",
+  DELETED = "DELETED",
+  SUSPENDED = "SUSPENDED",
+}
+
+export type PaginationInput = {
+  limit?: InputMaybe<Scalars["Float"]["input"]>;
+  offset?: InputMaybe<Scalars["Float"]["input"]>;
+};
+
+export type PasswordChangePayload = {
+  __typename: "PasswordChangePayload";
+  message: Scalars["String"]["output"];
+  success: Scalars["Boolean"]["output"];
+};
+
+export type PasswordResetPayload = {
+  __typename: "PasswordResetPayload";
+  message: Scalars["String"]["output"];
+  success: Scalars["Boolean"]["output"];
+};
+
+export type PasswordResetRequestPayload = {
+  __typename: "PasswordResetRequestPayload";
+  message: Scalars["String"]["output"];
+};
+
+export type Phase = {
+  __typename: "Phase";
+  allStoriesComplete: Scalars["Boolean"]["output"];
+  completedAt: Maybe<Scalars["Date"]["output"]>;
+  completedStories: Scalars["Int"]["output"];
+  createdAt: Scalars["Date"]["output"];
+  createdByUser: Maybe<User>;
+  description: Maybe<Scalars["String"]["output"]>;
+  id: Scalars["ID"]["output"];
+  isCompleted: Scalars["Boolean"]["output"];
+  name: Scalars["String"]["output"];
+  orderIndex: Scalars["Int"]["output"];
+  progressPercentage: Scalars["Int"]["output"];
+  project: Project;
+  stories: Array<Story>;
+  totalStories: Scalars["Int"]["output"];
+  updatedAt: Scalars["Date"]["output"];
+  updatedByUser: Maybe<User>;
+};
+
+export type PhaseInput = {
+  deliverables?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  dependencies?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  description: Scalars["String"]["input"];
+  duration_weeks: Scalars["Int"]["input"];
+  id: Scalars["String"]["input"];
+  key_milestones?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  name: Scalars["String"]["input"];
+  resources_required?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  risks?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  start_week: Scalars["Int"]["input"];
+};
+
+/** Actions that can be performed on development plans */
+export enum PlanAuditAction {
+  ACTIVATED = "ACTIVATED",
+  APPROVED = "APPROVED",
+  COMMENTED = "COMMENTED",
+  COMPLETED = "COMPLETED",
+  CREATED = "CREATED",
+  REJECTED = "REJECTED",
+  SUBMITTED = "SUBMITTED",
+  UPDATED = "UPDATED",
+  VERSION_CREATED = "VERSION_CREATED",
+}
+
+/** Who generated the development plan */
+export enum PlanGeneratedBy {
+  AI = "AI",
+  HUMAN = "HUMAN",
+}
+
+/** Status of the development plan */
+export enum PlanStatus {
+  ACTIVE = "ACTIVE",
+  APPROVED = "APPROVED",
+  CANCELLED = "CANCELLED",
+  COMPLETED = "COMPLETED",
+  DRAFT = "DRAFT",
+  PENDING = "PENDING",
+  REJECTED = "REJECTED",
+}
+
+export enum PlatformRole {
+  AGENT_ADMIN = "AGENT_ADMIN",
+  AGENT_REVIEWER = "AGENT_REVIEWER",
+  AUDIT_VIEWER = "AUDIT_VIEWER",
+  BILLING_ADMIN = "BILLING_ADMIN",
+  SUPER_ADMIN = "SUPER_ADMIN",
+  SUPPORT = "SUPPORT",
+}
+
+export type PriorityFilters = {
+  __typename: "PriorityFilters";
+  priorities: Maybe<Array<Scalars["String"]["output"]>>;
+  projects: Maybe<Array<Scalars["String"]["output"]>>;
+  taskTypes: Maybe<Array<Scalars["String"]["output"]>>;
+  teams: Maybe<Array<Scalars["String"]["output"]>>;
+};
+
+export type PriorityFiltersInput = {
+  priorities?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  projects?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  taskTypes?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  teams?: InputMaybe<Array<Scalars["String"]["input"]>>;
+};
+
+export enum PriorityLevel {
+  CRITICAL = "CRITICAL",
+  HIGH = "HIGH",
+  LOW = "LOW",
+  MEDIUM = "MEDIUM",
+}
+
+export type ProductRequirementsInput = {
+  explicit_requirements: Array<ExplicitRequirementInput>;
+  inferred_functional_requirements: Array<InferredFunctionalRequirementInput>;
+  requirements_clarification_questions: Array<RequirementsClarificationQuestionInput>;
+  suggested_non_functional_requirements: Array<NonFunctionalRequirementInput>;
+};
+
+export type ProgressMetric = {
+  __typename: "ProgressMetric";
+  completedItems: Scalars["Int"]["output"];
+  completionPercentage: Scalars["Float"]["output"];
+  endDate: Maybe<Scalars["Date"]["output"]>;
+  entityId: Scalars["String"]["output"];
+  entityTitle: Scalars["String"]["output"];
+  entityType: Scalars["String"]["output"];
+  estimatedEndDate: Maybe<Scalars["Date"]["output"]>;
+  inProgressItems: Scalars["Int"]["output"];
+  overdueItems: Scalars["Int"]["output"];
+  startDate: Scalars["Date"]["output"];
+  totalItems: Scalars["Int"]["output"];
+};
+
+export type Project = {
+  __typename: "Project";
+  affectedServices: Array<WorkspaceService>;
+  blockedStoriesCount: Scalars["Int"]["output"];
+  completedStoriesCount: Scalars["Int"]["output"];
+  createdAt: Scalars["Date"]["output"];
+  createdByUser: Maybe<User>;
+  description: Maybe<Scalars["String"]["output"]>;
+  documentationUrl: Maybe<Scalars["String"]["output"]>;
+  healthScore: Scalars["Float"]["output"];
+  id: Scalars["ID"]["output"];
+  implementationStoriesCount: Scalars["Int"]["output"];
+  isActive: Scalars["Boolean"]["output"];
+  isArchived: Scalars["Boolean"]["output"];
+  isComplete: Scalars["Boolean"]["output"];
+  isPublic: Scalars["Boolean"]["output"];
+  links: Maybe<Scalars["JSONObject"]["output"]>;
+  name: Scalars["String"]["output"];
+  notes: Array<ProjectNote>;
+  organization: Organization;
+  pendingStoriesCount: Scalars["Int"]["output"];
+  phases: Array<Phase>;
+  progressPercentage: Scalars["Int"]["output"];
+  qualityMetrics: Scalars["JSONObject"]["output"];
+  repositoryUrl: Maybe<Scalars["String"]["output"]>;
+  requirements: Array<ProjectRequirement>;
+  reviewHistory: Scalars["JSONObject"]["output"];
+  reviewStoriesCount: Scalars["Int"]["output"];
+  riskProfile: Scalars["JSONObject"]["output"];
+  sprints: Array<Sprint>;
+  stage: ProjectStage;
+  startDate: Maybe<Scalars["Date"]["output"]>;
+  stories: Array<Story>;
+  storiesCount: Scalars["Int"]["output"];
+  targetCompletionDate: Maybe<Scalars["Date"]["output"]>;
+  tasksCount: Scalars["Int"]["output"];
+  team: Maybe<Team>;
+  updatedAt: Scalars["Date"]["output"];
+  updatedByUser: Maybe<User>;
+  workspaceConfig: Maybe<Scalars["JSONObject"]["output"]>;
+  workspaces: Array<Workspace>;
+};
+
+export type ProjectStoriesArgs = {
+  limit?: Scalars["Int"]["input"];
+  offset?: Scalars["Int"]["input"];
+};
+
+export type ProjectAnalysisInput = {
+  analysis: AnalysisInput;
+  analysis_type: Scalars["String"]["input"];
+  executive_summary: Scalars["String"]["input"];
+  metadata: MetadataInput;
+  project_id: Scalars["String"]["input"];
+  recommendations: Array<RecommendationInput>;
+  scores: ScoresInput;
+  suggested_product_requirements: ProductRequirementsInput;
+  timeline: TimelineInput;
+};
+
+export type ProjectNote = {
+  __typename: "ProjectNote";
+  content: Scalars["String"]["output"];
+  createdAt: Scalars["Date"]["output"];
+  createdByUser: Maybe<User>;
+  id: Scalars["ID"]["output"];
+  isPinned: Scalars["Boolean"]["output"];
+  project: Project;
+  title: Maybe<Scalars["String"]["output"]>;
+  updatedAt: Scalars["Date"]["output"];
+  updatedByUser: Maybe<User>;
+};
+
+export type ProjectRequirement = {
+  __typename: "ProjectRequirement";
+  acceptanceCriteria: Array<Scalars["String"]["output"]>;
+  applicationArea: Maybe<Scalars["String"]["output"]>;
+  createdAt: Scalars["Date"]["output"];
+  createdByUser: Maybe<User>;
+  description: Scalars["String"]["output"];
+  id: Scalars["ID"]["output"];
+  isCompleted: Scalars["Boolean"]["output"];
+  priority: PriorityLevel;
+  project: Project;
+  title: Scalars["String"]["output"];
+  updatedAt: Scalars["Date"]["output"];
+  updatedByUser: Maybe<User>;
+};
+
+export type ProjectReview = {
+  __typename: "ProjectReview";
+  analysisScope: Array<Scalars["String"]["output"]>;
+  applicationPrompt: Maybe<Scalars["String"]["output"]>;
+  applicationResultJson: Maybe<Scalars["String"]["output"]>;
+  appliedAt: Maybe<Scalars["Date"]["output"]>;
+  approvalCount: Scalars["Float"]["output"];
+  approvedAt: Maybe<Scalars["Date"]["output"]>;
+  approvedByUser: Maybe<User>;
+  canBeApplied: Scalars["Boolean"]["output"];
+  completedAt: Maybe<Scalars["Date"]["output"]>;
+  createdAt: Scalars["Date"]["output"];
+  hasApprovals: Scalars["Boolean"]["output"];
+  highPrioritySuggestionCount: Scalars["Float"]["output"];
+  id: Scalars["ID"]["output"];
+  isAIReview: Scalars["Boolean"]["output"];
+  isApplied: Scalars["Boolean"]["output"];
+  isApplying: Scalars["Boolean"]["output"];
+  isApproved: Scalars["Boolean"]["output"];
+  isCompleted: Scalars["Boolean"]["output"];
+  isCurrentVersion: Scalars["Boolean"]["output"];
+  isPending: Scalars["Boolean"]["output"];
+  originalReview: Maybe<ProjectReview>;
+  overallScore: Scalars["Float"]["output"];
+  previousVersion: Maybe<ProjectReview>;
+  project: Project;
+  rejectionCount: Scalars["Float"]["output"];
+  repromptContext: Maybe<Scalars["String"]["output"]>;
+  repromptedAt: Maybe<Scalars["Date"]["output"]>;
+  reviewDataJson: Scalars["String"]["output"];
+  reviewNotes: Maybe<Scalars["String"]["output"]>;
+  reviewedBy: Maybe<User>;
+  reviewerId: Scalars["String"]["output"];
+  reviewerType: ReviewerType;
+  reviewerUser: Maybe<User>;
+  status: ReviewStatus;
+  suggestedProductRequirements: Maybe<SuggestedProductRequirementsType>;
+  suggestionCount: Scalars["Float"]["output"];
+  suggestionsJson: Scalars["String"]["output"];
+  targetServices: Array<Scalars["String"]["output"]>;
+  updatedAt: Scalars["Date"]["output"];
+  version: Scalars["Float"]["output"];
+};
+
+export type ProjectReviewInput = {
+  projectId: Scalars["String"]["input"];
+  reviewDataJson?: InputMaybe<Scalars["String"]["input"]>;
+  reviewNotes?: InputMaybe<Scalars["String"]["input"]>;
+  reviewerId: Scalars["String"]["input"];
+  reviewerType: ReviewerType;
+  suggestionsJson?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type ProjectReviewSearchInput = {
+  projectId?: InputMaybe<Scalars["String"]["input"]>;
+  reviewerId?: InputMaybe<Scalars["String"]["input"]>;
+  reviewerType?: InputMaybe<ReviewerType>;
+  status?: InputMaybe<ReviewStatus>;
+};
+
+export type ProjectSearchInput = {
+  query?: InputMaybe<Scalars["String"]["input"]>;
+  stage?: InputMaybe<ProjectStage>;
+};
+
+export enum ProjectStage {
+  ARCHIVED = "ARCHIVED",
+  COMPLETE = "COMPLETE",
+  DESIGN = "DESIGN",
+  DEVELOPMENT = "DEVELOPMENT",
+  IMPLEMENTATION = "IMPLEMENTATION",
+  REQUIREMENTS = "REQUIREMENTS",
+}
+
+export type ProjectStats = {
+  __typename: "ProjectStats";
+  activeTeamMembers: Scalars["Int"]["output"];
+  averageStoryPoints: Scalars["Float"]["output"];
+  completedStories: Scalars["Int"]["output"];
+  completedStoryPoints: Scalars["Int"]["output"];
+  completedTasks: Scalars["Int"]["output"];
+  completionPercentage: Scalars["Float"]["output"];
+  inProgressStories: Scalars["Int"]["output"];
+  inProgressTasks: Scalars["Int"]["output"];
+  lastActivityAt: Scalars["Date"]["output"];
+  projectId: Scalars["String"]["output"];
+  projectName: Scalars["String"]["output"];
+  todoStories: Scalars["Int"]["output"];
+  todoTasks: Scalars["Int"]["output"];
+  totalAttachments: Scalars["Int"]["output"];
+  totalComments: Scalars["Int"]["output"];
+  totalStories: Scalars["Int"]["output"];
+  totalStoryPoints: Scalars["Int"]["output"];
+  totalTasks: Scalars["Int"]["output"];
+  velocityLastWeek: Scalars["Float"]["output"];
+  velocityThisWeek: Scalars["Float"]["output"];
+};
+
+export type ProjectStatsSummary = {
+  __typename: "ProjectStatsSummary";
+  completedStories: Scalars["Int"]["output"];
+  completedTasks: Scalars["Int"]["output"];
+  completionPercentage: Scalars["Int"]["output"];
+  totalComments: Scalars["Int"]["output"];
+  totalStories: Scalars["Int"]["output"];
+  totalTasks: Scalars["Int"]["output"];
+};
+
+export type ProjectWithStats = {
+  __typename: "ProjectWithStats";
+  affectedServices: Array<WorkspaceService>;
+  blockedStoriesCount: Scalars["Int"]["output"];
+  completedStoriesCount: Scalars["Int"]["output"];
+  createdAt: Scalars["Date"]["output"];
+  createdByUser: Maybe<User>;
+  description: Maybe<Scalars["String"]["output"]>;
+  documentationUrl: Maybe<Scalars["String"]["output"]>;
+  healthScore: Scalars["Float"]["output"];
+  id: Scalars["ID"]["output"];
+  implementationStoriesCount: Scalars["Int"]["output"];
+  isActive: Scalars["Boolean"]["output"];
+  isArchived: Scalars["Boolean"]["output"];
+  isComplete: Scalars["Boolean"]["output"];
+  isPublic: Scalars["Boolean"]["output"];
+  links: Maybe<Scalars["JSONObject"]["output"]>;
+  name: Scalars["String"]["output"];
+  notes: Array<ProjectNote>;
+  organization: Organization;
+  pendingStoriesCount: Scalars["Int"]["output"];
+  phases: Array<Phase>;
+  progressPercentage: Scalars["Int"]["output"];
+  qualityMetrics: Scalars["JSONObject"]["output"];
+  repositoryUrl: Maybe<Scalars["String"]["output"]>;
+  requirements: Array<ProjectRequirement>;
+  reviewHistory: Scalars["JSONObject"]["output"];
+  reviewStoriesCount: Scalars["Int"]["output"];
+  riskProfile: Scalars["JSONObject"]["output"];
+  sprints: Array<Sprint>;
+  stage: ProjectStage;
+  startDate: Maybe<Scalars["Date"]["output"]>;
+  stats: ProjectStatsSummary;
+  stories: Array<Story>;
+  storiesCount: Scalars["Int"]["output"];
+  targetCompletionDate: Maybe<Scalars["Date"]["output"]>;
+  tasksCount: Scalars["Int"]["output"];
+  team: Maybe<Team>;
+  updatedAt: Scalars["Date"]["output"];
+  updatedByUser: Maybe<User>;
+  workspaceConfig: Maybe<Scalars["JSONObject"]["output"]>;
+  workspaces: Array<Workspace>;
+};
+
+export type ProjectWithStatsStoriesArgs = {
+  limit?: Scalars["Int"]["input"];
+  offset?: Scalars["Int"]["input"];
+};
+
+export type PublicEarlyAccessRegistrationInput = {
+  acceptedTerms: Scalars["Boolean"]["input"];
+  ageVerified: Scalars["Boolean"]["input"];
+  aiTools: Array<Scalars["String"]["input"]>;
+  comments?: InputMaybe<Scalars["String"]["input"]>;
+  companyName?: InputMaybe<Scalars["String"]["input"]>;
+  contactName?: InputMaybe<Scalars["String"]["input"]>;
+  currentTools: Array<Scalars["String"]["input"]>;
+  email: Scalars["String"]["input"];
+  painPoints: Array<Scalars["String"]["input"]>;
+  primaryLanguages: Array<Scalars["String"]["input"]>;
+  projectTypes: Array<Scalars["String"]["input"]>;
+  repoStructure?: InputMaybe<Scalars["String"]["input"]>;
+  role?: InputMaybe<Scalars["String"]["input"]>;
+  serviceCount?: InputMaybe<Scalars["String"]["input"]>;
+  subscribeToNewsletter?: InputMaybe<Scalars["Boolean"]["input"]>;
+  teamSize?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type Query = {
+  __typename: "Query";
+  activeDevelopmentPlan: Maybe<DevelopmentPlan>;
+  activityMetrics: Array<ActivityMetric>;
+  aiServiceAnalytics: Scalars["String"]["output"];
+  aiServiceSessions: Array<AiServiceSession>;
+  aiWorkItem: Maybe<AiWorkQueue>;
+  aiWorkQueue: Array<AiWorkQueue>;
+  aiWorkTypeConfiguration: Scalars["JSONObject"]["output"];
+  aiWorker: Maybe<AiWorker>;
+  aiWorkerRegistrations: Array<AiWorkerRegistration>;
+  aiWorkerStatistics: AiWorkerStatistics;
+  aiWorkersByScope: Array<AiWorker>;
+  apiKey: Maybe<UserApiKey>;
+  apiKeys: Array<UserApiKey>;
+  apiVersion: ApiVersionInfo;
+  attachment: Maybe<Attachment>;
+  attachments: Array<Attachment>;
+  auditTrail: Array<AuditTrail>;
+  availableAIWork: Array<AiWorkQueue>;
+  availableWorkspaces: Array<Workspace>;
+  commentThread: CommentThread;
+  comments: Array<Comment>;
+  dashboardData: DashboardData;
+  developmentPlan: Maybe<DevelopmentPlan>;
+  developmentPlanAuditTrail: Array<DevelopmentPlanAuditLog>;
+  developmentPlanVersions: Array<DevelopmentPlan>;
+  developmentPlans: Array<DevelopmentPlan>;
+  discoverAIWorkers: Array<AiWorker>;
+  earlyAccessRegistration: Maybe<EarlyAccessRegistration>;
+  earlyAccessRegistrationCount: Scalars["Float"]["output"];
+  earlyAccessRegistrations: Array<EarlyAccessRegistration>;
+  entityAuditTrail: Array<AuditTrail>;
+  getApplicationQueue: Array<ApplicationQueueItem>;
+  getApplicationStatus: Maybe<ReviewApplicationStatus>;
+  getAttachmentDownloadUrl: FileDownloadResponse;
+  getAuditStats: AuditStatsResult;
+  getOptimizedWorkQueue: Array<AiWorkQueue>;
+  getOrganizationInviteByToken: Maybe<OrganizationInvite>;
+  getRecoverableWork: Array<AiWorkQueue>;
+  getWorkItemAuditHistory: Array<AiWorkAudit>;
+  getWorkItemAuditSummary: Maybe<WorkItemAuditSummary>;
+  getWorkerCurrentWork: Array<AiWorkQueue>;
+  me: Maybe<User>;
+  myActiveAISession: Maybe<AiServiceSession>;
+  myDashboard: UserStats;
+  myNotifications: Array<Notification>;
+  organizationInvite: Maybe<OrganizationInvite>;
+  organizationInvites: Array<OrganizationInvite>;
+  project: Maybe<Project>;
+  projectHealthMetrics: Scalars["JSON"]["output"];
+  projectHealthRankings: Array<Scalars["JSON"]["output"]>;
+  projectProgress: Array<ProgressMetric>;
+  projectReview: Maybe<ProjectReview>;
+  projectReviewVersions: Array<ProjectReview>;
+  projectReviews: Array<ProjectReview>;
+  projectStats: ProjectStats;
+  projectVelocity: Array<VelocityMetric>;
+  projectWithStats: Maybe<ProjectWithStats>;
+  projects: Array<Project>;
+  publicApiHealth: Scalars["String"]["output"];
+  recentActivity: Array<ActivityMetric>;
+  roleUsage: Array<RoleUsageStats>;
+  roles: Array<Role>;
+  searchAuditLogs: AuditSearchResult;
+  sessionInfo: SessionInfo;
+  stories: Array<Story>;
+  story: Maybe<Story>;
+  storyWithTasks: Maybe<StoryWithTasks>;
+  task: Maybe<Task>;
+  tasks: Array<Task>;
+  team: Maybe<Team>;
+  teamMembers: Array<TeamMember>;
+  teamPerformance: Array<TeamPerformance>;
+  teams: Array<Team>;
+  testAuth: Scalars["String"]["output"];
+  testClaudeConnection: Scalars["Boolean"]["output"];
+  topPerformers: Array<UserStats>;
+  topProjects: Array<ProjectStats>;
+  unreadNotificationsCount: Scalars["Int"]["output"];
+  user: Maybe<User>;
+  userActivities: Array<UserActivity>;
+  userComparison: Array<UserStats>;
+  userDetails: Maybe<User>;
+  userInvitations: Array<UserInvitation>;
+  userPreferences: Maybe<UserPreferences>;
+  userStats: UserStats;
+  users: UserConnection;
+  validateSubdomain: SubdomainValidationResponse;
+  velocityMetrics: Array<VelocityMetric>;
+  workQueueMetrics: Scalars["JSONObject"]["output"];
+  workQueueSystemHealth: Scalars["JSONObject"]["output"];
+  workspaceStats: WorkspaceStats;
+};
+
+export type QueryActiveDevelopmentPlanArgs = {
+  projectId: Scalars["String"]["input"];
+};
+
+export type QueryActivityMetricsArgs = {
+  filter?: InputMaybe<AnalyticsFilter>;
+  timeRange: TimeRange;
+};
+
+export type QueryAiWorkItemArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type QueryAiWorkQueueArgs = {
+  search?: InputMaybe<AiWorkQueueSearchInput>;
+};
+
+export type QueryAiWorkerArgs = {
+  workerId: Scalars["String"]["input"];
+};
+
+export type QueryAiWorkerRegistrationsArgs = {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
+export type QueryAiWorkersByScopeArgs = {
+  scope: WorkerScope;
+  scopeId: Scalars["String"]["input"];
+};
+
+export type QueryApiKeyArgs = {
+  id: Scalars["ID"]["input"];
+};
+
+export type QueryApiKeysArgs = {
+  scope?: InputMaybe<ApiKeyScope>;
+};
+
+export type QueryAttachmentArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type QueryAttachmentsArgs = {
+  limit?: Scalars["Int"]["input"];
+  offset?: Scalars["Int"]["input"];
+  search?: InputMaybe<AttachmentSearchInput>;
+};
+
+export type QueryAuditTrailArgs = {
+  entityId?: InputMaybe<Scalars["String"]["input"]>;
+  entityType?: InputMaybe<Scalars["String"]["input"]>;
+  limit?: Scalars["Int"]["input"];
+  offset?: Scalars["Int"]["input"];
+  userId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type QueryAvailableAiWorkArgs = {
+  aiWorkerId: Scalars["String"]["input"];
+  workerType?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type QueryCommentThreadArgs = {
+  limit?: Scalars["Int"]["input"];
+  offset?: Scalars["Int"]["input"];
+  storyId: Scalars["String"]["input"];
+};
+
+export type QueryCommentsArgs = {
+  limit?: Scalars["Int"]["input"];
+  offset?: Scalars["Int"]["input"];
+  search: CommentSearchInput;
+};
+
+export type QueryDashboardDataArgs = {
+  filter?: InputMaybe<AnalyticsFilter>;
+};
+
+export type QueryDevelopmentPlanArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type QueryDevelopmentPlanAuditTrailArgs = {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  planId: Scalars["String"]["input"];
+};
+
+export type QueryDevelopmentPlanVersionsArgs = {
+  planId: Scalars["String"]["input"];
+};
+
+export type QueryDevelopmentPlansArgs = {
+  search?: InputMaybe<DevelopmentPlanSearchInput>;
+};
+
+export type QueryDiscoverAiWorkersArgs = {
+  filter?: InputMaybe<AiWorkerDiscoveryFilter>;
+};
+
+export type QueryEarlyAccessRegistrationArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type QueryEarlyAccessRegistrationCountArgs = {
+  status?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type QueryEarlyAccessRegistrationsArgs = {
+  status?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type QueryEntityAuditTrailArgs = {
+  entityId: Scalars["String"]["input"];
+  entityType: Scalars["String"]["input"];
+  limit?: Scalars["Int"]["input"];
+  offset?: Scalars["Int"]["input"];
+};
+
+export type QueryGetApplicationQueueArgs = {
+  projectId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type QueryGetApplicationStatusArgs = {
+  reviewId: Scalars["String"]["input"];
+};
+
+export type QueryGetAttachmentDownloadUrlArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type QueryGetAuditStatsArgs = {
+  dateFrom?: InputMaybe<Scalars["Date"]["input"]>;
+  dateTo?: InputMaybe<Scalars["Date"]["input"]>;
+};
+
+export type QueryGetOptimizedWorkQueueArgs = {
+  workerId?: InputMaybe<Scalars["String"]["input"]>;
+  workerType?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type QueryGetOrganizationInviteByTokenArgs = {
+  token: Scalars["String"]["input"];
+};
+
+export type QueryGetRecoverableWorkArgs = {
+  workerId: Scalars["String"]["input"];
+};
+
+export type QueryGetWorkItemAuditHistoryArgs = {
+  limit?: Scalars["Float"]["input"];
+  workItemId: Scalars["String"]["input"];
+};
+
+export type QueryGetWorkItemAuditSummaryArgs = {
+  workItemId: Scalars["String"]["input"];
+};
+
+export type QueryGetWorkerCurrentWorkArgs = {
+  workerId: Scalars["String"]["input"];
+};
+
+export type QueryMyDashboardArgs = {
+  filter?: InputMaybe<AnalyticsFilter>;
+};
+
+export type QueryMyNotificationsArgs = {
+  limit?: Scalars["Int"]["input"];
+  offset?: Scalars["Int"]["input"];
+  unreadOnly?: Scalars["Boolean"]["input"];
+};
+
+export type QueryOrganizationInviteArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type QueryOrganizationInvitesArgs = {
+  status?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type QueryProjectArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type QueryProjectHealthMetricsArgs = {
+  projectId: Scalars["String"]["input"];
+};
+
+export type QueryProjectHealthRankingsArgs = {
+  limit?: Scalars["Int"]["input"];
+};
+
+export type QueryProjectProgressArgs = {
+  filter?: InputMaybe<AnalyticsFilter>;
+};
+
+export type QueryProjectReviewArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type QueryProjectReviewVersionsArgs = {
+  reviewId: Scalars["String"]["input"];
+};
+
+export type QueryProjectReviewsArgs = {
+  search?: InputMaybe<ProjectReviewSearchInput>;
+};
+
+export type QueryProjectStatsArgs = {
+  filter?: InputMaybe<AnalyticsFilter>;
+  projectId: Scalars["String"]["input"];
+};
+
+export type QueryProjectVelocityArgs = {
+  projectId: Scalars["String"]["input"];
+  weeks?: Scalars["Int"]["input"];
+};
+
+export type QueryProjectWithStatsArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type QueryProjectsArgs = {
+  limit?: Scalars["Int"]["input"];
+  offset?: Scalars["Int"]["input"];
+  search?: InputMaybe<ProjectSearchInput>;
+};
+
+export type QueryRecentActivityArgs = {
+  days?: Scalars["Int"]["input"];
+  filter?: InputMaybe<AnalyticsFilter>;
+};
+
+export type QuerySearchAuditLogsArgs = {
+  input: AuditSearchInput;
+};
+
+export type QueryStoriesArgs = {
+  limit?: Scalars["Int"]["input"];
+  offset?: Scalars["Int"]["input"];
+  projectId?: InputMaybe<Scalars["String"]["input"]>;
+  search?: InputMaybe<StorySearchInput>;
+};
+
+export type QueryStoryArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type QueryStoryWithTasksArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type QueryTaskArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type QueryTasksArgs = {
+  options?: InputMaybe<TasksOptionsInput>;
+};
+
+export type QueryTeamArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type QueryTeamMembersArgs = {
+  teamId: Scalars["String"]["input"];
+};
+
+export type QueryTeamPerformanceArgs = {
+  filter?: InputMaybe<AnalyticsFilter>;
+};
+
+export type QueryTeamsArgs = {
+  pagination?: InputMaybe<PaginationInput>;
+  search?: InputMaybe<TeamSearchInput>;
+};
+
+export type QueryTopPerformersArgs = {
+  filter?: InputMaybe<AnalyticsFilter>;
+  limit?: Scalars["Int"]["input"];
+};
+
+export type QueryTopProjectsArgs = {
+  filter?: InputMaybe<AnalyticsFilter>;
+  limit?: Scalars["Int"]["input"];
+};
+
+export type QueryUserArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type QueryUserActivitiesArgs = {
+  limit?: InputMaybe<Scalars["Float"]["input"]>;
+  userId: Scalars["String"]["input"];
+};
+
+export type QueryUserComparisonArgs = {
+  filter?: InputMaybe<AnalyticsFilter>;
+  userIds: Array<Scalars["String"]["input"]>;
+};
+
+export type QueryUserDetailsArgs = {
+  id: Scalars["String"]["input"];
+};
+
+export type QueryUserInvitationsArgs = {
+  status?: InputMaybe<InvitationStatus>;
+};
+
+export type QueryUserStatsArgs = {
+  filter?: InputMaybe<AnalyticsFilter>;
+  userId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type QueryUsersArgs = {
+  pagination?: InputMaybe<PaginationInput>;
+  search?: InputMaybe<TeamUserSearchInput>;
+};
+
+export type QueryValidateSubdomainArgs = {
+  subdomain: Scalars["String"]["input"];
+};
+
+export type QueryVelocityMetricsArgs = {
+  filter?: InputMaybe<AnalyticsFilter>;
+  timeRange: TimeRange;
+};
+
+export type QueryWorkspaceStatsArgs = {
+  filter?: InputMaybe<AnalyticsFilter>;
+};
+
+export type QueueAiWorkInput = {
+  aiWorkerId?: InputMaybe<Scalars["String"]["input"]>;
+  estimatedDuration?: InputMaybe<Scalars["Float"]["input"]>;
+  metadataJson?: InputMaybe<Scalars["String"]["input"]>;
+  priority?: InputMaybe<Scalars["Float"]["input"]>;
+  projectId?: InputMaybe<Scalars["String"]["input"]>;
+  storyId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type QueueOptimizationInput = {
+  forceOptimization?: InputMaybe<Scalars["Boolean"]["input"]>;
+  priorityThreshold?: InputMaybe<Scalars["Float"]["input"]>;
+  targetWorkerId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type RecommendationInput = {
+  business_impact?: InputMaybe<Scalars["String"]["input"]>;
+  category: Scalars["String"]["input"];
+  description: Scalars["String"]["input"];
+  estimated_effort?: InputMaybe<Scalars["String"]["input"]>;
+  id: Scalars["String"]["input"];
+  implementation_guide?: InputMaybe<Scalars["String"]["input"]>;
+  priority: Scalars["String"]["input"];
+  technical_complexity?: InputMaybe<Scalars["String"]["input"]>;
+  title: Scalars["String"]["input"];
+};
+
+export type RefreshTokenInput = {
+  refreshToken: Scalars["String"]["input"];
+};
+
+export type RegisterInput = {
+  email: Scalars["String"]["input"];
+  firstName?: InputMaybe<Scalars["String"]["input"]>;
+  lastName?: InputMaybe<Scalars["String"]["input"]>;
+  password: Scalars["String"]["input"];
+  role?: InputMaybe<UserRole>;
+};
+
+/** Status of AI agent registration request */
+export enum RegistrationStatus {
+  APPROVED = "APPROVED",
+  EXPIRED = "EXPIRED",
+  PENDING = "PENDING",
+  REJECTED = "REJECTED",
+}
+
+export type RemoveStoryDependencyInput = {
+  dependsOnStoryId: Scalars["String"]["input"];
+  storyId: Scalars["String"]["input"];
+};
+
+export type RepromptDevelopmentPlanInput = {
+  additionalContext?: InputMaybe<Scalars["String"]["input"]>;
+  changeRequest: Scalars["String"]["input"];
+  planId: Scalars["String"]["input"];
+  preserveContext?: Scalars["Boolean"]["input"];
+  repromptType: RepromptType;
+};
+
+export type RepromptDevelopmentPlanResult = {
+  __typename: "RepromptDevelopmentPlanResult";
+  estimatedCompletionTime: Maybe<Scalars["String"]["output"]>;
+  id: Scalars["String"]["output"];
+  message: Scalars["String"]["output"];
+  queuePosition: Scalars["Float"]["output"];
+  success: Scalars["Boolean"]["output"];
+  workQueueId: Scalars["String"]["output"];
+};
+
+export type RepromptReviewInput = {
+  focusAreas?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  repromptContext?: InputMaybe<Scalars["String"]["input"]>;
+  reviewId: Scalars["String"]["input"];
+};
+
+/** Type of reprompt request for development plans */
+export enum RepromptType {
+  REFINEMENT = "REFINEMENT",
+  RESOURCE_OPTIMIZATION = "RESOURCE_OPTIMIZATION",
+  RISK_MITIGATION = "RISK_MITIGATION",
+  SCOPE_CHANGE = "SCOPE_CHANGE",
+  TECHNOLOGY_CHANGE = "TECHNOLOGY_CHANGE",
+  TIMELINE_ADJUSTMENT = "TIMELINE_ADJUSTMENT",
+}
+
+export type RequestPasswordResetInput = {
+  email: Scalars["String"]["input"];
+};
+
+export type RequirementsClarificationQuestionInput = {
+  category: Scalars["String"]["input"];
+  impact_if_unclear: Scalars["String"]["input"];
+  question: Scalars["String"]["input"];
+  suggested_default: Scalars["String"]["input"];
+};
+
+export type ResetPasswordInput = {
+  newPassword: Scalars["String"]["input"];
+  token: Scalars["String"]["input"];
+};
+
+export type ReviewApplicationResult = {
+  __typename: "ReviewApplicationResult";
+  estimatedDuration: Maybe<Scalars["Float"]["output"]>;
+  id: Scalars["String"]["output"];
+  message: Scalars["String"]["output"];
+  status: ApplicationStatus;
+  workQueueId: Maybe<Scalars["String"]["output"]>;
+};
+
+export type ReviewApplicationStatus = {
+  __typename: "ReviewApplicationStatus";
+  errors: Array<Scalars["String"]["output"]>;
+  progress: Maybe<ApplicationProgress>;
+  reviewId: Scalars["String"]["output"];
+  status: ApplicationStatus;
+  workQueue: Maybe<ApplicationQueueItem>;
+};
+
+/** Completion status of the review generation */
+export enum ReviewStatus {
+  APPLIED = "APPLIED",
+  APPLYING = "APPLYING",
+  APPROVED = "APPROVED",
+  COMPLETED = "COMPLETED",
+  FAILED = "FAILED",
+  PENDING = "PENDING",
+}
+
+/** Type of reviewer (human or AI) */
+export enum ReviewerType {
+  AI = "AI",
+  HUMAN = "HUMAN",
+}
+
+export type RiskInput = {
+  description: Scalars["String"]["input"];
+  impact: Scalars["String"]["input"];
+  mitigation_strategy?: InputMaybe<Scalars["String"]["input"]>;
+  probability: Scalars["String"]["input"];
+  title: Scalars["String"]["input"];
+};
+
+export type Role = {
+  __typename: "Role";
+  createdAt: Scalars["Date"]["output"];
+  description: Maybe<Scalars["String"]["output"]>;
+  id: Scalars["ID"]["output"];
+  isSystemRole: Scalars["Boolean"]["output"];
+  name: Scalars["String"]["output"];
+  permissions: Scalars["JSONObject"]["output"];
+  updatedAt: Scalars["Date"]["output"];
+};
+
+export type RoleUsageStats = {
+  __typename: "RoleUsageStats";
+  activeUserCount: Scalars["Float"]["output"];
+  roleId: Scalars["String"]["output"];
+  roleName: Scalars["String"]["output"];
+  userCount: Scalars["Float"]["output"];
+};
+
+export type ScoreInput = {
+  reasoning: Scalars["String"]["input"];
+  score: Scalars["Int"]["input"];
+};
+
+export type ScoresInput = {
+  clarity: ScoreInput;
+  completeness: ScoreInput;
+  feasibility: ScoreInput;
+  overall: ScoreInput;
+};
+
+export type ServiceRegistrationInput = {
+  name: Scalars["String"]["input"];
+  port?: InputMaybe<Scalars["Float"]["input"]>;
+  serviceId: Scalars["String"]["input"];
+  technology?: Scalars["String"]["input"];
+};
+
+export type SessionInfo = {
+  __typename: "SessionInfo";
+  expiresAt: Maybe<Scalars["Date"]["output"]>;
+  isValid: Scalars["Boolean"]["output"];
+  issuedAt: Maybe<Scalars["Date"]["output"]>;
+  user: Maybe<User>;
+};
+
+export enum ShepherdActivity {
+  COORDINATING = "COORDINATING",
+  EMERGENCY_RESPONSE = "EMERGENCY_RESPONSE",
+  GUIDING = "GUIDING",
+  MONITORING = "MONITORING",
+  OPTIMIZING = "OPTIMIZING",
+  RESTING = "RESTING",
+  REVIEWING = "REVIEWING",
+  TRAINING = "TRAINING",
+}
+
+export enum ShepherdRole {
+  CODE_SHEPHERD = "CODE_SHEPHERD",
+  FLOCK_GUARDIAN = "FLOCK_GUARDIAN",
+  JUNIOR_SHEPHERD = "JUNIOR_SHEPHERD",
+  LEAD_SHEPHERD = "LEAD_SHEPHERD",
+  PERFORMANCE_SHEPHERD = "PERFORMANCE_SHEPHERD",
+  QUALITY_SHEPHERD = "QUALITY_SHEPHERD",
+  SPECIALIST_SHEPHERD = "SPECIALIST_SHEPHERD",
+  TASK_SHEPHERD = "TASK_SHEPHERD",
+}
+
+export type Sprint = {
+  __typename: "Sprint";
+  completedStories: Scalars["Float"]["output"];
+  createdAt: Scalars["Date"]["output"];
+  createdByUser: Maybe<User>;
+  duration: Scalars["Float"]["output"];
+  endDate: Scalars["Date"]["output"];
+  goal: Maybe<Scalars["String"]["output"]>;
+  id: Scalars["ID"]["output"];
+  isActive: Scalars["Boolean"]["output"];
+  isEnded: Scalars["Boolean"]["output"];
+  isInProgress: Scalars["Boolean"]["output"];
+  isStarted: Scalars["Boolean"]["output"];
+  name: Scalars["String"]["output"];
+  progressPercentage: Scalars["Float"]["output"];
+  project: Project;
+  startDate: Scalars["Date"]["output"];
+  stories: Array<Story>;
+  totalStories: Scalars["Float"]["output"];
+  updatedAt: Scalars["Date"]["output"];
+  updatedByUser: Maybe<User>;
+};
+
+export type Story = {
+  __typename: "Story";
+  acceptanceCriteria: Array<Scalars["String"]["output"]>;
+  affectedServices: Array<Scalars["String"]["output"]>;
+  assignedTo: Maybe<Scalars["String"]["output"]>;
+  assignedToUser: Maybe<User>;
+  attachments: Array<Attachment>;
+  canBeClaimed: Scalars["Boolean"]["output"];
+  claimedAt: Maybe<Scalars["Date"]["output"]>;
+  comments: Array<Comment>;
+  completedAt: Maybe<Scalars["Date"]["output"]>;
+  completedTasks: Scalars["Float"]["output"];
+  completedTasksCount: Scalars["Int"]["output"];
+  createdAt: Scalars["Date"]["output"];
+  createdByUser: Maybe<User>;
+  crossWorkspaceCoordination: Maybe<Scalars["String"]["output"]>;
+  dependencies: Maybe<Array<Story>>;
+  dependsOn: Maybe<Array<Story>>;
+  description: Maybe<Scalars["String"]["output"]>;
+  estimate: Maybe<Scalars["Int"]["output"]>;
+  hasBlockingDependencies: Scalars["Boolean"]["output"];
+  id: Scalars["ID"]["output"];
+  implementationDuration: Maybe<Scalars["Int"]["output"]>;
+  isAssigned: Scalars["Boolean"]["output"];
+  isBlocked: Scalars["Boolean"]["output"];
+  isComplete: Scalars["Boolean"]["output"];
+  isInProgress: Scalars["Boolean"]["output"];
+  isInReview: Scalars["Boolean"]["output"];
+  isPending: Scalars["Boolean"]["output"];
+  orderIndex: Maybe<Scalars["Int"]["output"]>;
+  organization: Organization;
+  phase: Maybe<Phase>;
+  priority: PriorityLevel;
+  progressPercentage: Scalars["Int"]["output"];
+  project: Project;
+  pullRequestLink: Maybe<Scalars["String"]["output"]>;
+  relatedWorkspaces: Array<Scalars["String"]["output"]>;
+  reviewNotes: Maybe<Scalars["String"]["output"]>;
+  reviewedAt: Maybe<Scalars["Date"]["output"]>;
+  reviewedBy: Maybe<User>;
+  sprint: Maybe<Sprint>;
+  startedAt: Maybe<Scalars["Date"]["output"]>;
+  status: StoryState;
+  storyLink: Maybe<Scalars["String"]["output"]>;
+  tags: Array<Scalars["String"]["output"]>;
+  taskProgressPercentage: Scalars["Float"]["output"];
+  tasks: Array<Task>;
+  tasksCount: Scalars["Int"]["output"];
+  title: Scalars["String"]["output"];
+  totalTasks: Scalars["Float"]["output"];
+  updatedAt: Scalars["Date"]["output"];
+  updatedByUser: Maybe<User>;
+  workspaceId: Maybe<Scalars["String"]["output"]>;
+};
+
+export type StoryTasksArgs = {
+  limit?: Scalars["Int"]["input"];
+  offset?: Scalars["Int"]["input"];
+};
+
+export type StoryProgressInput = {
+  next_steps?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  overall_progress: Scalars["Int"]["input"];
+  status_summary: Scalars["String"]["input"];
+  story_id: Scalars["String"]["input"];
+  tasks_completed?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tasks_remaining?: InputMaybe<Array<Scalars["String"]["input"]>>;
+};
+
+export type StorySearchInput = {
+  assignedTo?: InputMaybe<Scalars["String"]["input"]>;
+  projectId?: InputMaybe<Scalars["String"]["input"]>;
+  query?: InputMaybe<Scalars["String"]["input"]>;
+  state?: InputMaybe<StoryState>;
+  type?: InputMaybe<TaskType>;
+};
+
+export enum StoryState {
+  BLOCKED = "BLOCKED",
+  COMPLETE = "COMPLETE",
+  IMPLEMENTATION = "IMPLEMENTATION",
+  PENDING = "PENDING",
+  REVIEW = "REVIEW",
+}
+
+export type StoryWithTasks = {
+  __typename: "StoryWithTasks";
+  createdAt: Scalars["Date"]["output"];
+  createdBy: Scalars["String"]["output"];
+  description: Maybe<Scalars["String"]["output"]>;
+  id: Scalars["String"]["output"];
+  priority: Maybe<PriorityLevel>;
+  priorityLevel: PriorityLevel;
+  status: StoryState;
+  storyPoints: Maybe<Scalars["Int"]["output"]>;
+  tasks: Array<Task>;
+  title: Scalars["String"]["output"];
+  type: Maybe<TaskType>;
+  updatedAt: Scalars["Date"]["output"];
+  updatedBy: Maybe<Scalars["String"]["output"]>;
+};
+
+export type StrengthInput = {
+  description: Scalars["String"]["input"];
+  evidence?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  impact: Scalars["String"]["input"];
+  title: Scalars["String"]["input"];
+};
+
+export type SubdomainValidationResponse = {
+  __typename: "SubdomainValidationResponse";
+  error: Maybe<Scalars["String"]["output"]>;
+  isValid: Scalars["Boolean"]["output"];
+  suggestions: Array<Scalars["String"]["output"]>;
+};
+
+export type Subscription = {
+  __typename: "Subscription";
+  aiServiceStatusUpdated: AiServiceSession;
+  aiWorkAssigned: AiWorkAssignment;
+  aiWorkCompleted: AiWorkCompletion;
+  aiWorkProgressUpdated: AiWorkProgress;
+  aiWorkUpdated: AiWorkQueue;
+  aiWorkerDisconnected: AiWorkerDisconnectionInfo;
+  aiWorkerDiscoveryUpdated: AiWorkerDiscoveryUpdate;
+  aiWorkerHealthUpdated: AiWorkerHealthStatus;
+  aiWorkerRegistered: AiWorker;
+  aiWorkerStatusChanged: AiWorker;
+  applicationCompleted: ReviewApplicationResult;
+  applicationProgressUpdated: ApplicationProgress;
+  commentAdded: Comment;
+  developmentPlanUpdated: DevelopmentPlan;
+  notificationReceived: Notification;
+  projectReviewUpdated: ProjectReview;
+  projectUpdated: Project;
+  storyUpdated: Story;
+  taskUpdated: Task;
+  userPresence: UserPresence;
+};
+
+export type SubscriptionAiWorkAssignedArgs = {
+  projectId?: InputMaybe<Scalars["String"]["input"]>;
+  workerId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type SubscriptionAiWorkCompletedArgs = {
+  assignmentId?: InputMaybe<Scalars["String"]["input"]>;
+  projectId?: InputMaybe<Scalars["String"]["input"]>;
+  workerId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type SubscriptionAiWorkProgressUpdatedArgs = {
+  assignmentId?: InputMaybe<Scalars["String"]["input"]>;
+  projectId?: InputMaybe<Scalars["String"]["input"]>;
+  workerId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type SubscriptionAiWorkerDisconnectedArgs = {
+  projectId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type SubscriptionAiWorkerDiscoveryUpdatedArgs = {
+  projectId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type SubscriptionAiWorkerHealthUpdatedArgs = {
+  projectId?: InputMaybe<Scalars["String"]["input"]>;
+  workerId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type SubscriptionAiWorkerRegisteredArgs = {
+  capabilities?: InputMaybe<Array<WorkerCapability>>;
+  projectId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type SubscriptionAiWorkerStatusChangedArgs = {
+  projectId?: InputMaybe<Scalars["String"]["input"]>;
+  workerId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type SubscriptionApplicationCompletedArgs = {
+  reviewId: Scalars["String"]["input"];
+};
+
+export type SubscriptionApplicationProgressUpdatedArgs = {
+  reviewId: Scalars["String"]["input"];
+};
+
+export type SubscriptionCommentAddedArgs = {
+  storyId: Scalars["String"]["input"];
+};
+
+export type SubscriptionProjectUpdatedArgs = {
+  projectId: Scalars["String"]["input"];
+};
+
+export type SubscriptionStoryUpdatedArgs = {
+  projectId: Scalars["String"]["input"];
+};
+
+export type SubscriptionTaskUpdatedArgs = {
+  storyId: Scalars["String"]["input"];
+};
+
+export type SubscriptionUserPresenceArgs = {
+  projectId: Scalars["String"]["input"];
+};
+
+export type SuggestedProductRequirementsType = {
+  __typename: "SuggestedProductRequirementsType";
+  explicitRequirements: Array<ExplicitRequirementType>;
+  inferredFunctionalRequirements: Array<InferredRequirementType>;
+  requirementsClarificationQuestions: Array<ClarificationQuestionType>;
+  suggestedNonFunctionalRequirements: Array<NonFunctionalRequirementType>;
+};
+
+export type Task = {
+  __typename: "Task";
+  actualHours: Maybe<Scalars["Int"]["output"]>;
+  actualTime: Maybe<Scalars["Int"]["output"]>;
+  affectedWorkspaces: Array<Scalars["String"]["output"]>;
+  areas: Array<Scalars["String"]["output"]>;
+  assignedTo: Maybe<Scalars["String"]["output"]>;
+  assignedToUser: Maybe<User>;
+  attachments: Array<Attachment>;
+  canBeClaimed: Scalars["Boolean"]["output"];
+  claimedAt: Maybe<Scalars["Date"]["output"]>;
+  comments: Array<Comment>;
+  completedAt: Maybe<Scalars["Date"]["output"]>;
+  completionPercentage: Scalars["Int"]["output"];
+  createdAt: Scalars["Date"]["output"];
+  createdByUser: Maybe<User>;
+  currentSessionDuration: Scalars["Float"]["output"];
+  currentSessionStart: Maybe<Scalars["Date"]["output"]>;
+  deadline: Maybe<Scalars["Date"]["output"]>;
+  dependencies: Maybe<Array<Task>>;
+  dependsOn: Maybe<Array<Task>>;
+  description: Maybe<Scalars["String"]["output"]>;
+  dueDate: Maybe<Scalars["Date"]["output"]>;
+  estimate: Maybe<Scalars["Int"]["output"]>;
+  estimatedHours: Maybe<Scalars["Int"]["output"]>;
+  estimatedTime: Maybe<Scalars["Int"]["output"]>;
+  hasBlockingDependencies: Scalars["Boolean"]["output"];
+  id: Scalars["ID"]["output"];
+  implementationDuration: Maybe<Scalars["Int"]["output"]>;
+  implementationSummary: Maybe<Scalars["String"]["output"]>;
+  isAsk: Scalars["Boolean"]["output"];
+  isAssigned: Scalars["Boolean"]["output"];
+  isBlocked: Scalars["Boolean"]["output"];
+  isComplete: Scalars["Boolean"]["output"];
+  isFollowup: Scalars["Boolean"]["output"];
+  isInProgress: Scalars["Boolean"]["output"];
+  isOverdue: Scalars["Boolean"]["output"];
+  isPending: Scalars["Boolean"]["output"];
+  isPlanned: Scalars["Boolean"]["output"];
+  isTimerRunning: Scalars["Boolean"]["output"];
+  keyFiles: Maybe<Array<Scalars["String"]["output"]>>;
+  orderIndex: Maybe<Scalars["Int"]["output"]>;
+  organization: Organization;
+  priority: PriorityLevel;
+  startedAt: Maybe<Scalars["Date"]["output"]>;
+  state: TaskState;
+  status: TaskState;
+  story: Story;
+  targetFilePaths: Array<Scalars["String"]["output"]>;
+  targetService: Maybe<Scalars["String"]["output"]>;
+  title: Scalars["String"]["output"];
+  totalTimeIncludingCurrent: Scalars["Float"]["output"];
+  totalTrackedTime: Scalars["Int"]["output"];
+  type: TaskType;
+  updatedAt: Scalars["Date"]["output"];
+  updatedByUser: Maybe<User>;
+  workspaceId: Maybe<Scalars["String"]["output"]>;
+};
+
+export type TaskImplementationInput = {
+  blockers?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  completion_status: Scalars["String"]["input"];
+  files_modified: Array<FileModificationInput>;
+  implementation_summary: Scalars["String"]["input"];
+  task_id: Scalars["String"]["input"];
+  tests_added?: InputMaybe<Array<Scalars["String"]["input"]>>;
+};
+
+export type TaskSearchInput = {
+  areas?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  assignedTo?: InputMaybe<Scalars["String"]["input"]>;
+  priority?: InputMaybe<PriorityLevel>;
+  priorityLevel?: InputMaybe<PriorityLevel>;
+  query?: InputMaybe<Scalars["String"]["input"]>;
+  state?: InputMaybe<TaskState>;
+  status?: InputMaybe<TaskState>;
+  tags?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  type?: InputMaybe<TaskType>;
+};
+
+export enum TaskState {
+  BLOCKED = "BLOCKED",
+  COMPLETE = "COMPLETE",
+  IMPLEMENTATION = "IMPLEMENTATION",
+  PENDING = "PENDING",
+}
+
+export enum TaskType {
+  ASK = "ASK",
+  FOLLOWUP = "FOLLOWUP",
+  PLANNED = "PLANNED",
+}
+
+export type TasksOptionsInput = {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  search?: InputMaybe<TaskSearchInput>;
+  storyId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type Team = {
+  __typename: "Team";
+  createdAt: Scalars["Date"]["output"];
+  createdByUser: User;
+  description: Maybe<Scalars["String"]["output"]>;
+  id: Scalars["ID"]["output"];
+  isActive: Scalars["Boolean"]["output"];
+  memberCount: Scalars["Int"]["output"];
+  members: Array<TeamMember>;
+  name: Scalars["String"]["output"];
+  projectCount: Scalars["Int"]["output"];
+  settings: Maybe<Scalars["JSONObject"]["output"]>;
+  updatedAt: Scalars["Date"]["output"];
+};
+
+export type TeamMember = {
+  __typename: "TeamMember";
+  createdAt: Scalars["Date"]["output"];
+  id: Scalars["ID"]["output"];
+  joinedAt: Scalars["Date"]["output"];
+  role: Role;
+  status: Scalars["String"]["output"];
+  team: Team;
+  updatedAt: Scalars["Date"]["output"];
+  user: User;
+};
+
+export type TeamPerformance = {
+  __typename: "TeamPerformance";
+  averageCompletionTime: Scalars["Float"]["output"];
+  completedItems: Scalars["Int"]["output"];
+  completedStoryPoints: Scalars["Int"]["output"];
+  completionRate: Scalars["Float"]["output"];
+  inProgressItems: Scalars["Int"]["output"];
+  lastActivityAt: Scalars["Date"]["output"];
+  teamMemberAvatar: Maybe<Scalars["String"]["output"]>;
+  teamMemberId: Scalars["String"]["output"];
+  teamMemberName: Scalars["String"]["output"];
+  totalStoryPoints: Scalars["Int"]["output"];
+};
+
+export type TeamSearchInput = {
+  createdBy?: InputMaybe<Scalars["String"]["input"]>;
+  isActive?: InputMaybe<Scalars["Boolean"]["input"]>;
+  name?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type TeamUserSearchInput = {
+  email?: InputMaybe<Scalars["String"]["input"]>;
+  firstName?: InputMaybe<Scalars["String"]["input"]>;
+  isActive?: InputMaybe<Scalars["Boolean"]["input"]>;
+  lastName?: InputMaybe<Scalars["String"]["input"]>;
+  teamId?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type TimeRange = {
+  end: Scalars["Date"]["input"];
+  granularity?: Scalars["String"]["input"];
+  start: Scalars["Date"]["input"];
+};
+
+export type TimelineInput = {
+  phases: Array<PhaseInput>;
+  total_duration_weeks: Scalars["Int"]["input"];
+};
+
+export type UpdateAiServiceSessionInput = {
+  capabilitiesJson?: InputMaybe<Scalars["String"]["input"]>;
+  serviceEndpoint?: InputMaybe<Scalars["String"]["input"]>;
+  sessionToken?: InputMaybe<Scalars["String"]["input"]>;
+  status?: InputMaybe<AiServiceStatus>;
+};
+
+export type UpdateAiWorkInput = {
+  metadataJson?: InputMaybe<Scalars["String"]["input"]>;
+  priority?: InputMaybe<Scalars["Float"]["input"]>;
+  status?: InputMaybe<AiWorkStatus>;
+  workId: Scalars["String"]["input"];
+};
+
+export type UpdateApiKeyInput = {
+  agentConfiguration?: InputMaybe<AgentConfigurationInput>;
+  isActive?: InputMaybe<Scalars["Boolean"]["input"]>;
+  name?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type UpdateCommentInput = {
+  content: Scalars["String"]["input"];
+};
+
+export type UpdateDevelopmentPlanInput = {
+  approvalNotes?: InputMaybe<Scalars["String"]["input"]>;
+  dependenciesJson?: InputMaybe<Scalars["String"]["input"]>;
+  estimatesJson?: InputMaybe<Scalars["String"]["input"]>;
+  planDataJson?: InputMaybe<Scalars["String"]["input"]>;
+  status?: InputMaybe<PlanStatus>;
+};
+
+export type UpdateEarlyAccessRegistrationInput = {
+  companyName?: InputMaybe<Scalars["String"]["input"]>;
+  contactName?: InputMaybe<Scalars["String"]["input"]>;
+  notes?: InputMaybe<Scalars["String"]["input"]>;
+  status?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type UpdateProjectInput = {
+  affectedServiceIds?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  documentationUrl?: InputMaybe<Scalars["String"]["input"]>;
+  isPublic?: InputMaybe<Scalars["Boolean"]["input"]>;
+  name?: InputMaybe<Scalars["String"]["input"]>;
+  repositoryUrl?: InputMaybe<Scalars["String"]["input"]>;
+  stage?: InputMaybe<ProjectStage>;
+  startDate?: InputMaybe<Scalars["Date"]["input"]>;
+  targetCompletionDate?: InputMaybe<Scalars["Date"]["input"]>;
+  workspaceConfig?: InputMaybe<Scalars["JSONObject"]["input"]>;
+  workspaceIds?: InputMaybe<Array<Scalars["String"]["input"]>>;
+};
+
+export type UpdateRoleInput = {
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  name?: InputMaybe<Scalars["String"]["input"]>;
+  permissions?: InputMaybe<Scalars["JSONObject"]["input"]>;
+};
+
+export type UpdateStoryInput = {
+  acceptanceCriteria?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  assignedTo?: InputMaybe<Scalars["String"]["input"]>;
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  estimate?: InputMaybe<Scalars["Int"]["input"]>;
+  priority?: InputMaybe<PriorityLevel>;
+  storyLink?: InputMaybe<Scalars["String"]["input"]>;
+  tags?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  title?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type UpdateTaskInput = {
+  actualHours?: InputMaybe<Scalars["Int"]["input"]>;
+  actualTime?: InputMaybe<Scalars["Int"]["input"]>;
+  areas?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  assignedTo?: InputMaybe<Scalars["String"]["input"]>;
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  dueDate?: InputMaybe<Scalars["Date"]["input"]>;
+  estimatedHours?: InputMaybe<Scalars["Int"]["input"]>;
+  estimatedTime?: InputMaybe<Scalars["Int"]["input"]>;
+  priority?: InputMaybe<PriorityLevel>;
+  state?: InputMaybe<TaskState>;
+  status?: InputMaybe<TaskState>;
+  title?: InputMaybe<Scalars["String"]["input"]>;
+  type?: InputMaybe<TaskType>;
+};
+
+export type UpdateTeamInput = {
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  isActive?: InputMaybe<Scalars["Boolean"]["input"]>;
+  name?: InputMaybe<Scalars["String"]["input"]>;
+  settings?: InputMaybe<Scalars["JSONObject"]["input"]>;
+};
+
+export type UpdateTeamMemberInput = {
+  roleId?: InputMaybe<Scalars["String"]["input"]>;
+  status?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type UpdateUserInput = {
+  avatarUrl?: InputMaybe<Scalars["String"]["input"]>;
+  firstName?: InputMaybe<Scalars["String"]["input"]>;
+  lastName?: InputMaybe<Scalars["String"]["input"]>;
+  role?: InputMaybe<UserRole>;
+  status?: InputMaybe<UserStatus>;
+  timezone?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type UpdateUserPreferencesInput = {
+  dateFormat?: InputMaybe<Scalars["String"]["input"]>;
+  defaultProjectView?: InputMaybe<Scalars["String"]["input"]>;
+  emailDigestFrequency?: InputMaybe<Scalars["String"]["input"]>;
+  emailNotifications?: InputMaybe<Scalars["Boolean"]["input"]>;
+  itemsPerPage?: InputMaybe<Scalars["Int"]["input"]>;
+  notifyOnAssignment?: InputMaybe<Scalars["Boolean"]["input"]>;
+  notifyOnComment?: InputMaybe<Scalars["Boolean"]["input"]>;
+  notifyOnMention?: InputMaybe<Scalars["Boolean"]["input"]>;
+  notifyOnStatusChange?: InputMaybe<Scalars["Boolean"]["input"]>;
+  theme?: InputMaybe<Scalars["String"]["input"]>;
+  timeFormat?: InputMaybe<Scalars["String"]["input"]>;
+  timezone?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type User = {
+  __typename: "User";
+  activeApiKeysCount: Scalars["Int"]["output"];
+  assignedStoriesCount: Scalars["Int"]["output"];
+  assignedTasksCount: Scalars["Int"]["output"];
+  avatarUrl: Maybe<Scalars["String"]["output"]>;
+  canAccessAudits: Scalars["Boolean"]["output"];
+  canAccessInternal: Scalars["Boolean"]["output"];
+  canManageBilling: Scalars["Boolean"]["output"];
+  canSupportOrganizations: Scalars["Boolean"]["output"];
+  commentsCount: Scalars["Int"]["output"];
+  createdAt: Scalars["Date"]["output"];
+  createdProjectsCount: Scalars["Int"]["output"];
+  displayName: Scalars["String"]["output"];
+  email: Scalars["String"]["output"];
+  firstName: Maybe<Scalars["String"]["output"]>;
+  fullName: Scalars["String"]["output"];
+  id: Scalars["ID"]["output"];
+  isActive: Scalars["Boolean"]["output"];
+  isAdmin: Scalars["Boolean"]["output"];
+  lastLoginAt: Maybe<Scalars["Date"]["output"]>;
+  lastName: Maybe<Scalars["String"]["output"]>;
+  organizationMemberships: Array<UserOrganization>;
+  platformRoles: Array<UserPlatformRole>;
+  role: UserRole;
+  status: UserStatus;
+  storiesCount: Scalars["Int"]["output"];
+  tasksCount: Scalars["Int"]["output"];
+  teamMemberships: Array<TeamMember>;
+  timezone: Maybe<Scalars["String"]["output"]>;
+  updatedAt: Scalars["Date"]["output"];
+};
+
+export type UserActivity = {
+  __typename: "UserActivity";
+  actionType: Scalars["String"]["output"];
+  createdAt: Scalars["Date"]["output"];
+  id: Scalars["ID"]["output"];
+  metadata: Maybe<Scalars["JSONObject"]["output"]>;
+  resourceId: Maybe<Scalars["String"]["output"]>;
+  resourceType: Maybe<Scalars["String"]["output"]>;
+  updatedAt: Scalars["Date"]["output"];
+  user: User;
+};
+
+export type UserApiKey = {
+  __typename: "UserApiKey";
+  agentConfiguration: Maybe<AgentConfiguration>;
+  createdAt: Scalars["Date"]["output"];
+  createdByUser: Maybe<User>;
+  expiresAt: Maybe<Scalars["Date"]["output"]>;
+  id: Scalars["ID"]["output"];
+  isActive: Scalars["Boolean"]["output"];
+  isExpired: Scalars["Boolean"]["output"];
+  isValid: Scalars["Boolean"]["output"];
+  keyPrefix: Scalars["String"]["output"];
+  keyType: ApiKeyType;
+  lastUsedAt: Maybe<Scalars["Date"]["output"]>;
+  name: Scalars["String"]["output"];
+  scope: ApiKeyScope;
+  scopes: Array<Scalars["String"]["output"]>;
+  updatedAt: Scalars["Date"]["output"];
+  user: User;
+};
+
+export type UserConnection = {
+  __typename: "UserConnection";
+  hasNextPage: Scalars["Boolean"]["output"];
+  hasPreviousPage: Scalars["Boolean"]["output"];
+  nodes: Array<User>;
+  totalCount: Scalars["Float"]["output"];
+};
+
+export type UserInvitation = {
+  __typename: "UserInvitation";
+  acceptedAt: Maybe<Scalars["Date"]["output"]>;
+  createdAt: Scalars["Date"]["output"];
+  email: Scalars["String"]["output"];
+  expiresAt: Scalars["Date"]["output"];
+  id: Scalars["ID"]["output"];
+  invitedBy: User;
+  message: Maybe<Scalars["String"]["output"]>;
+  role: Role;
+  status: Scalars["String"]["output"];
+  updatedAt: Scalars["Date"]["output"];
+};
+
+export type UserOperation = {
+  operation: Scalars["String"]["input"];
+  userId: Scalars["String"]["input"];
+  value?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type UserOrganization = {
+  __typename: "UserOrganization";
+  createdAt: Scalars["Date"]["output"];
+  id: Scalars["ID"]["output"];
+  invitationToken: Maybe<Scalars["String"]["output"]>;
+  invitedAt: Maybe<Scalars["Date"]["output"]>;
+  invitedBy: Maybe<Scalars["String"]["output"]>;
+  joinedAt: Scalars["Date"]["output"];
+  lastAccessedAt: Maybe<Scalars["Date"]["output"]>;
+  organization: Organization;
+  role: OrganizationRole;
+  status: UserOrganizationStatus;
+  updatedAt: Scalars["Date"]["output"];
+  user: User;
+};
+
+/** Status of user membership in an organization */
+export enum UserOrganizationStatus {
+  ACTIVE = "ACTIVE",
+  INVITED = "INVITED",
+  LEFT = "LEFT",
+  SUSPENDED = "SUSPENDED",
+}
+
+export type UserPlatformRole = {
+  __typename: "UserPlatformRole";
+  createdAt: Scalars["Date"]["output"];
+  expiresAt: Maybe<Scalars["Date"]["output"]>;
+  grantedAt: Maybe<Scalars["Date"]["output"]>;
+  grantedBy: Maybe<User>;
+  id: Scalars["ID"]["output"];
+  reason: Maybe<Scalars["String"]["output"]>;
+  role: PlatformRole;
+  updatedAt: Scalars["Date"]["output"];
+  user: User;
+};
+
+export type UserPreferences = {
+  __typename: "UserPreferences";
+  createdAt: Scalars["Date"]["output"];
+  dateFormat: Scalars["String"]["output"];
+  defaultProjectView: Scalars["String"]["output"];
+  emailDigestFrequency: Scalars["String"]["output"];
+  emailNotifications: Scalars["Boolean"]["output"];
+  hasEmailNotificationsEnabled: Scalars["Boolean"]["output"];
+  id: Scalars["ID"]["output"];
+  isDarkMode: Scalars["Boolean"]["output"];
+  isLightMode: Scalars["Boolean"]["output"];
+  itemsPerPage: Scalars["Int"]["output"];
+  notifyOnAssignment: Scalars["Boolean"]["output"];
+  notifyOnComment: Scalars["Boolean"]["output"];
+  notifyOnMention: Scalars["Boolean"]["output"];
+  notifyOnStatusChange: Scalars["Boolean"]["output"];
+  prefersKanbanView: Scalars["Boolean"]["output"];
+  theme: Scalars["String"]["output"];
+  timeFormat: Scalars["String"]["output"];
+  timezone: Scalars["String"]["output"];
+  updatedAt: Scalars["Date"]["output"];
+  user: User;
+  uses24HourTime: Scalars["Boolean"]["output"];
+  usesSystemTheme: Scalars["Boolean"]["output"];
+};
+
+export type UserPresence = {
+  __typename: "UserPresence";
+  avatarUrl: Maybe<Scalars["String"]["output"]>;
+  currentPage: Maybe<Scalars["String"]["output"]>;
+  fullName: Scalars["String"]["output"];
+  lastSeen: Scalars["Date"]["output"];
+  status: Scalars["String"]["output"];
+  userId: Scalars["String"]["output"];
+};
+
+export enum UserRole {
+  ADMIN = "ADMIN",
+  PRODUCT = "PRODUCT",
+  VIEW = "VIEW",
+  WORKER = "WORKER",
+}
+
+export type UserStats = {
+  __typename: "UserStats";
+  assignedStories: Scalars["Int"]["output"];
+  assignedTasks: Scalars["Int"]["output"];
+  averageTaskCompletionTime: Scalars["Float"]["output"];
+  completedStories: Scalars["Int"]["output"];
+  completedTasks: Scalars["Int"]["output"];
+  completionRate: Scalars["Float"]["output"];
+  createdProjects: Scalars["Int"]["output"];
+  lastActiveAt: Scalars["Date"]["output"];
+  totalAttachments: Scalars["Int"]["output"];
+  totalComments: Scalars["Int"]["output"];
+  userAvatarUrl: Maybe<Scalars["String"]["output"]>;
+  userFullName: Scalars["String"]["output"];
+  userId: Scalars["String"]["output"];
+};
+
+export enum UserStatus {
+  ACTIVE = "ACTIVE",
+  DISABLED = "DISABLED",
+}
+
+export type VelocityMetric = {
+  __typename: "VelocityMetric";
+  averageCompletionTime: Scalars["Float"]["output"];
+  storiesCompleted: Scalars["Int"]["output"];
+  storyPointsCompleted: Scalars["Int"]["output"];
+  tasksCompleted: Scalars["Int"]["output"];
+  teamSize: Scalars["Int"]["output"];
+  week: Scalars["Date"]["output"];
+};
+
+export type WeaknessInput = {
+  affected_areas?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  description: Scalars["String"]["input"];
+  improvement_effort?: InputMaybe<Scalars["String"]["input"]>;
+  severity: Scalars["String"]["input"];
+  title: Scalars["String"]["input"];
+};
+
+export type WorkAllocationInput = {
+  forceRebalance?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxItems?: InputMaybe<Scalars["Float"]["input"]>;
+  workerId?: InputMaybe<Scalars["String"]["input"]>;
+  workerType?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type WorkItemAuditSummary = {
+  __typename: "WorkItemAuditSummary";
+  actionBreakdown: Array<AuditActionTypeCount>;
+  averageActionDuration: Scalars["Float"]["output"];
+  errors: Scalars["Int"]["output"];
+  firstAction: Scalars["Date"]["output"];
+  lastAction: Scalars["Date"]["output"];
+  statusChanges: Scalars["Int"]["output"];
+  totalActions: Scalars["Int"]["output"];
+  uniqueActors: Scalars["Int"]["output"];
+  workItemId: Scalars["String"]["output"];
+  workerChanges: Scalars["Int"]["output"];
+};
+
+export type WorkItemErrorInput = {
+  assignmentId: Scalars["String"]["input"];
+  category: ErrorCategory;
+  contextJson?: InputMaybe<Scalars["String"]["input"]>;
+  errorType: WorkItemErrorType;
+  message: Scalars["String"]["input"];
+  resolutionJson?: InputMaybe<Scalars["String"]["input"]>;
+  resolved?: Scalars["Boolean"]["input"];
+  retryable: Scalars["Boolean"]["input"];
+  severity: ErrorSeverity;
+  stack?: InputMaybe<Scalars["String"]["input"]>;
+  stage: Scalars["String"]["input"];
+  tags: Array<Scalars["String"]["input"]>;
+  workItemId: Scalars["String"]["input"];
+  workType: Scalars["String"]["input"];
+  workerId: Scalars["String"]["input"];
+};
+
+export type WorkItemErrorResult = {
+  __typename: "WorkItemErrorResult";
+  id: Scalars["String"]["output"];
+  logged: Scalars["Boolean"]["output"];
+  message: Maybe<Scalars["String"]["output"]>;
+};
+
+/** Types of work item errors */
+export enum WorkItemErrorType {
+  AI_RESPONSE_ERROR = "AI_RESPONSE_ERROR",
+  ANALYSIS_FAILED = "ANALYSIS_FAILED",
+  AUTHENTICATION_ERROR = "AUTHENTICATION_ERROR",
+  CLAUDE_API_ERROR = "CLAUDE_API_ERROR",
+  CLAUDE_CLI_ERROR = "CLAUDE_CLI_ERROR",
+  CONNECTION_ERROR = "CONNECTION_ERROR",
+  HANDLER_NOT_FOUND = "HANDLER_NOT_FOUND",
+  INTERNAL_ERROR = "INTERNAL_ERROR",
+  INVALID_PROJECT_ID = "INVALID_PROJECT_ID",
+  INVALID_WORK_DATA = "INVALID_WORK_DATA",
+  MISSING_PROJECT = "MISSING_PROJECT",
+  MISSING_REQUIRED_FIELD = "MISSING_REQUIRED_FIELD",
+  NETWORK_ERROR = "NETWORK_ERROR",
+  PLAN_GENERATION_FAILED = "PLAN_GENERATION_FAILED",
+  RECOVERY_FAILED = "RECOVERY_FAILED",
+  RESOURCE_EXHAUSTED = "RESOURCE_EXHAUSTED",
+  RETRY_LIMIT_EXCEEDED = "RETRY_LIMIT_EXCEEDED",
+  SAVE_FAILED = "SAVE_FAILED",
+  TIMEOUT_ERROR = "TIMEOUT_ERROR",
+  TOKEN_LIMIT_ERROR = "TOKEN_LIMIT_ERROR",
+  VALIDATION_FAILED = "VALIDATION_FAILED",
+  WORK_TYPE_MISMATCH = "WORK_TYPE_MISMATCH",
+}
+
+export type WorkItemLogInput = {
+  assignmentId: Scalars["String"]["input"];
+  duration?: InputMaybe<Scalars["Float"]["input"]>;
+  metadataJson?: InputMaybe<Scalars["String"]["input"]>;
+  progress?: InputMaybe<Scalars["Float"]["input"]>;
+  stage: Scalars["String"]["input"];
+  status: Scalars["String"]["input"];
+  timestamp: Scalars["Date"]["input"];
+  workItemId: Scalars["String"]["input"];
+  workType: Scalars["String"]["input"];
+};
+
+export type WorkItemLogResult = {
+  __typename: "WorkItemLogResult";
+  id: Scalars["String"]["output"];
+  logged: Scalars["Boolean"]["output"];
+  message: Maybe<Scalars["String"]["output"]>;
+};
+
+export type WorkItemReleaseInput = {
+  allowRetry?: InputMaybe<Scalars["Boolean"]["input"]>;
+  reason: Scalars["String"]["input"];
+  workItemId: Scalars["String"]["input"];
+};
+
+export type WorkProgressUpdateInput = {
+  completedSteps?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  currentStep: Scalars["String"]["input"];
+  estimatedTimeRemaining?: InputMaybe<Scalars["Float"]["input"]>;
+  lastError?: InputMaybe<Scalars["String"]["input"]>;
+  percentage: Scalars["Float"]["input"];
+  workItemId: Scalars["String"]["input"];
+};
+
+export type WorkStateItem = {
+  completedAt?: InputMaybe<Scalars["String"]["input"]>;
+  lastUpdate?: InputMaybe<Scalars["String"]["input"]>;
+  startedAt?: InputMaybe<Scalars["String"]["input"]>;
+  status: Scalars["String"]["input"];
+  workItemId: Scalars["String"]["input"];
+};
+
+export enum WorkerCapability {
+  CODE_REVIEW = "CODE_REVIEW",
+  CONFLICT_RESOLUTION = "CONFLICT_RESOLUTION",
+  DOCUMENTATION = "DOCUMENTATION",
+  FLOCK_MANAGEMENT = "FLOCK_MANAGEMENT",
+  IMPLEMENTATION_PLAN = "IMPLEMENTATION_PLAN",
+  PERFORMANCE_MONITORING = "PERFORMANCE_MONITORING",
+  PROJECT_REVIEW = "PROJECT_REVIEW",
+  QUALITY_SHEPHERDING = "QUALITY_SHEPHERDING",
+  RESOURCE_ALLOCATION = "RESOURCE_ALLOCATION",
+  STORY_IMPLEMENTATION = "STORY_IMPLEMENTATION",
+  TASK_HERDING = "TASK_HERDING",
+  TEAM_COORDINATION = "TEAM_COORDINATION",
+  TESTING = "TESTING",
+  WORKFLOW_GUIDANCE = "WORKFLOW_GUIDANCE",
+}
+
+export type WorkerHeartbeatInput = {
+  currentTaskCount?: InputMaybe<Scalars["Float"]["input"]>;
+  health: Scalars["String"]["input"];
+  workerId: Scalars["String"]["input"];
+};
+
+export type WorkerRegistrationInput = {
+  capabilities: Array<Scalars["String"]["input"]>;
+  maxConcurrentTasks: Scalars["Float"]["input"];
+  priority?: InputMaybe<Scalars["Float"]["input"]>;
+  workerId: Scalars["String"]["input"];
+  workerType: Scalars["String"]["input"];
+};
+
+export enum WorkerScope {
+  ORGANIZATION = "ORGANIZATION",
+  PROJECT = "PROJECT",
+  TEAM = "TEAM",
+  USER = "USER",
+}
+
+export type Workspace = {
+  __typename: "Workspace";
+  config: Maybe<Scalars["JSONObject"]["output"]>;
+  createdAt: Scalars["Date"]["output"];
+  description: Maybe<Scalars["String"]["output"]>;
+  errors: Array<Scalars["String"]["output"]>;
+  id: Scalars["ID"]["output"];
+  isActive: Scalars["Boolean"]["output"];
+  name: Scalars["String"]["output"];
+  path: Scalars["String"]["output"];
+  pattern: Scalars["String"]["output"];
+  projects: Array<Project>;
+  services: Array<WorkspaceService>;
+  updatedAt: Scalars["Date"]["output"];
+  workspaceId: Scalars["String"]["output"];
+};
+
+export type WorkspaceRegistrationInput = {
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  name: Scalars["String"]["input"];
+  path: Scalars["String"]["input"];
+  pattern?: Scalars["String"]["input"];
+  services: Array<ServiceRegistrationInput>;
+  workspaceId: Scalars["String"]["input"];
+};
+
+export type WorkspaceService = {
+  __typename: "WorkspaceService";
+  createdAt: Scalars["Date"]["output"];
+  id: Scalars["ID"]["output"];
+  isActive: Scalars["Boolean"]["output"];
+  name: Scalars["String"]["output"];
+  serviceId: Scalars["String"]["output"];
+  technology: Scalars["String"]["output"];
+  updatedAt: Scalars["Date"]["output"];
+  workspace: Workspace;
+};
+
+export type WorkspaceStats = {
+  __typename: "WorkspaceStats";
+  activeProjects: Scalars["Int"]["output"];
+  activeUsers: Scalars["Int"]["output"];
+  averageProjectVelocity: Scalars["Float"]["output"];
+  overallCompletionRate: Scalars["Float"]["output"];
+  totalAttachments: Scalars["Int"]["output"];
+  totalComments: Scalars["Int"]["output"];
+  totalProjects: Scalars["Int"]["output"];
+  totalStories: Scalars["Int"]["output"];
+  totalTasks: Scalars["Int"]["output"];
+  totalUsers: Scalars["Int"]["output"];
+};
+
+export type GetApiKeysQueryVariables = Exact<{
+  scope?: InputMaybe<ApiKeyScope>;
+}>;
+
+export type GetApiKeysQuery = {
+  __typename: "Query";
+  apiKeys: Array<{
+    __typename: "UserApiKey";
+    id: string;
+    name: string;
+    keyType: ApiKeyType;
+    scope: ApiKeyScope;
+    createdAt: string;
+    lastUsedAt: string | null;
+    user: { __typename: "User"; id: string; displayName: string };
+    createdByUser: {
+      __typename: "User";
+      id: string;
+      displayName: string;
+    } | null;
+    agentConfiguration: {
+      __typename: "AgentConfiguration";
+      priorityFilters: {
+        __typename: "PriorityFilters";
+        teams: Array<string> | null;
+        projects: Array<string> | null;
+        taskTypes: Array<string> | null;
+        priorities: Array<string> | null;
+      } | null;
+    } | null;
+  }>;
+};
+
+export type GetApiKeyQueryVariables = Exact<{
+  id: Scalars["ID"]["input"];
+}>;
+
+export type GetApiKeyQuery = {
+  __typename: "Query";
+  apiKey: {
+    __typename: "UserApiKey";
+    id: string;
+    name: string;
+    keyType: ApiKeyType;
+    scope: ApiKeyScope;
+    createdAt: string;
+    lastUsedAt: string | null;
+    user: { __typename: "User"; id: string; displayName: string };
+    createdByUser: {
+      __typename: "User";
+      id: string;
+      displayName: string;
+    } | null;
+    agentConfiguration: {
+      __typename: "AgentConfiguration";
+      priorityFilters: {
+        __typename: "PriorityFilters";
+        teams: Array<string> | null;
+        projects: Array<string> | null;
+        taskTypes: Array<string> | null;
+        priorities: Array<string> | null;
+      } | null;
+    } | null;
+  } | null;
+};
+
+export type CreateApiKeyMutationVariables = Exact<{
+  input: CreateApiKeyInput;
+}>;
+
+export type CreateApiKeyMutation = {
+  __typename: "Mutation";
+  createApiKey: {
+    __typename: "ApiKeyWithSecret";
+    id: string;
+    name: string;
+    keyType: ApiKeyType;
+    scope: ApiKeyScope;
+    key: string;
+    createdAt: string;
+    lastUsed: string | null;
+    userId: string;
+    createdBy: { __typename: "User"; id: string; displayName: string } | null;
+    agentConfiguration: {
+      __typename: "AgentConfiguration";
+      priorityFilters: {
+        __typename: "PriorityFilters";
+        teams: Array<string> | null;
+        projects: Array<string> | null;
+        taskTypes: Array<string> | null;
+        priorities: Array<string> | null;
+      } | null;
+    } | null;
+  };
+};
+
+export type DeleteApiKeyMutationVariables = Exact<{
+  id: Scalars["ID"]["input"];
+}>;
+
+export type DeleteApiKeyMutation = {
+  __typename: "Mutation";
+  deleteApiKey: boolean;
+};
+
+export type UpdateApiKeyMutationVariables = Exact<{
+  id: Scalars["ID"]["input"];
+  input: UpdateApiKeyInput;
+}>;
+
+export type UpdateApiKeyMutation = {
+  __typename: "Mutation";
+  updateApiKey: {
+    __typename: "UserApiKey";
+    id: string;
+    name: string;
+    agentConfiguration: {
+      __typename: "AgentConfiguration";
+      priorityFilters: {
+        __typename: "PriorityFilters";
+        teams: Array<string> | null;
+        projects: Array<string> | null;
+        taskTypes: Array<string> | null;
+        priorities: Array<string> | null;
+      } | null;
+    } | null;
+  };
+};
+
+export const GetApiKeysDocument = {
+  kind: "Document",
+  definitions: [
+    {
+      kind: "OperationDefinition",
+      operation: "query",
+      name: { kind: "Name", value: "GetApiKeys" },
+      variableDefinitions: [
+        {
+          kind: "VariableDefinition",
+          variable: {
+            kind: "Variable",
+            name: { kind: "Name", value: "scope" },
+          },
+          type: {
+            kind: "NamedType",
+            name: { kind: "Name", value: "ApiKeyScope" },
+          },
+        },
+      ],
+      selectionSet: {
+        kind: "SelectionSet",
+        selections: [
+          {
+            kind: "Field",
+            name: { kind: "Name", value: "apiKeys" },
+            arguments: [
+              {
+                kind: "Argument",
+                name: { kind: "Name", value: "scope" },
+                value: {
+                  kind: "Variable",
+                  name: { kind: "Name", value: "scope" },
+                },
+              },
+            ],
+            selectionSet: {
+              kind: "SelectionSet",
+              selections: [
+                { kind: "Field", name: { kind: "Name", value: "id" } },
+                { kind: "Field", name: { kind: "Name", value: "name" } },
+                { kind: "Field", name: { kind: "Name", value: "keyType" } },
+                { kind: "Field", name: { kind: "Name", value: "scope" } },
+                { kind: "Field", name: { kind: "Name", value: "createdAt" } },
+                { kind: "Field", name: { kind: "Name", value: "lastUsedAt" } },
+                {
+                  kind: "Field",
+                  name: { kind: "Name", value: "user" },
+                  selectionSet: {
+                    kind: "SelectionSet",
+                    selections: [
+                      { kind: "Field", name: { kind: "Name", value: "id" } },
+                      {
+                        kind: "Field",
+                        name: { kind: "Name", value: "displayName" },
+                      },
+                    ],
+                  },
+                },
+                {
+                  kind: "Field",
+                  name: { kind: "Name", value: "createdByUser" },
+                  selectionSet: {
+                    kind: "SelectionSet",
+                    selections: [
+                      { kind: "Field", name: { kind: "Name", value: "id" } },
+                      {
+                        kind: "Field",
+                        name: { kind: "Name", value: "displayName" },
+                      },
+                    ],
+                  },
+                },
+                {
+                  kind: "Field",
+                  name: { kind: "Name", value: "agentConfiguration" },
+                  selectionSet: {
+                    kind: "SelectionSet",
+                    selections: [
+                      {
+                        kind: "Field",
+                        name: { kind: "Name", value: "priorityFilters" },
+                        selectionSet: {
+                          kind: "SelectionSet",
+                          selections: [
+                            {
+                              kind: "Field",
+                              name: { kind: "Name", value: "teams" },
+                            },
+                            {
+                              kind: "Field",
+                              name: { kind: "Name", value: "projects" },
+                            },
+                            {
+                              kind: "Field",
+                              name: { kind: "Name", value: "taskTypes" },
+                            },
+                            {
+                              kind: "Field",
+                              name: { kind: "Name", value: "priorities" },
+                            },
+                          ],
+                        },
+                      },
+                    ],
+                  },
+                },
+              ],
+            },
+          },
+        ],
+      },
+    },
+  ],
+} as unknown as DocumentNode;
+
+/**
+ * __useGetApiKeysQuery__
+ *
+ * To run a query within a React component, call `useGetApiKeysQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetApiKeysQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetApiKeysQuery({
+ *   variables: {
+ *      scope: // value for 'scope'
+ *   },
+ * });
+ */
+export function useGetApiKeysQuery(
+  baseOptions?: Apollo.QueryHookOptions<
+    GetApiKeysQuery,
+    GetApiKeysQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useQuery<GetApiKeysQuery, GetApiKeysQueryVariables>(
+    GetApiKeysDocument,
+    options,
+  );
+}
+export function useGetApiKeysLazyQuery(
+  baseOptions?: Apollo.LazyQueryHookOptions<
+    GetApiKeysQuery,
+    GetApiKeysQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useLazyQuery<GetApiKeysQuery, GetApiKeysQueryVariables>(
+    GetApiKeysDocument,
+    options,
+  );
+}
+export function useGetApiKeysSuspenseQuery(
+  baseOptions?:
+    | Apollo.SkipToken
+    | Apollo.SuspenseQueryHookOptions<
+        GetApiKeysQuery,
+        GetApiKeysQueryVariables
+      >,
+) {
+  const options =
+    baseOptions === Apollo.skipToken
+      ? baseOptions
+      : { ...defaultOptions, ...baseOptions };
+  return Apollo.useSuspenseQuery<GetApiKeysQuery, GetApiKeysQueryVariables>(
+    GetApiKeysDocument,
+    options,
+  );
+}
+export type GetApiKeysQueryHookResult = ReturnType<typeof useGetApiKeysQuery>;
+export type GetApiKeysLazyQueryHookResult = ReturnType<
+  typeof useGetApiKeysLazyQuery
+>;
+export type GetApiKeysSuspenseQueryHookResult = ReturnType<
+  typeof useGetApiKeysSuspenseQuery
+>;
+export type GetApiKeysQueryResult = Apollo.QueryResult<
+  GetApiKeysQuery,
+  GetApiKeysQueryVariables
+>;
+export const GetApiKeyDocument = {
+  kind: "Document",
+  definitions: [
+    {
+      kind: "OperationDefinition",
+      operation: "query",
+      name: { kind: "Name", value: "GetApiKey" },
+      variableDefinitions: [
+        {
+          kind: "VariableDefinition",
+          variable: { kind: "Variable", name: { kind: "Name", value: "id" } },
+          type: {
+            kind: "NonNullType",
+            type: { kind: "NamedType", name: { kind: "Name", value: "ID" } },
+          },
+        },
+      ],
+      selectionSet: {
+        kind: "SelectionSet",
+        selections: [
+          {
+            kind: "Field",
+            name: { kind: "Name", value: "apiKey" },
+            arguments: [
+              {
+                kind: "Argument",
+                name: { kind: "Name", value: "id" },
+                value: {
+                  kind: "Variable",
+                  name: { kind: "Name", value: "id" },
+                },
+              },
+            ],
+            selectionSet: {
+              kind: "SelectionSet",
+              selections: [
+                { kind: "Field", name: { kind: "Name", value: "id" } },
+                { kind: "Field", name: { kind: "Name", value: "name" } },
+                { kind: "Field", name: { kind: "Name", value: "keyType" } },
+                { kind: "Field", name: { kind: "Name", value: "scope" } },
+                { kind: "Field", name: { kind: "Name", value: "createdAt" } },
+                { kind: "Field", name: { kind: "Name", value: "lastUsedAt" } },
+                {
+                  kind: "Field",
+                  name: { kind: "Name", value: "user" },
+                  selectionSet: {
+                    kind: "SelectionSet",
+                    selections: [
+                      { kind: "Field", name: { kind: "Name", value: "id" } },
+                      {
+                        kind: "Field",
+                        name: { kind: "Name", value: "displayName" },
+                      },
+                    ],
+                  },
+                },
+                {
+                  kind: "Field",
+                  name: { kind: "Name", value: "createdByUser" },
+                  selectionSet: {
+                    kind: "SelectionSet",
+                    selections: [
+                      { kind: "Field", name: { kind: "Name", value: "id" } },
+                      {
+                        kind: "Field",
+                        name: { kind: "Name", value: "displayName" },
+                      },
+                    ],
+                  },
+                },
+                {
+                  kind: "Field",
+                  name: { kind: "Name", value: "agentConfiguration" },
+                  selectionSet: {
+                    kind: "SelectionSet",
+                    selections: [
+                      {
+                        kind: "Field",
+                        name: { kind: "Name", value: "priorityFilters" },
+                        selectionSet: {
+                          kind: "SelectionSet",
+                          selections: [
+                            {
+                              kind: "Field",
+                              name: { kind: "Name", value: "teams" },
+                            },
+                            {
+                              kind: "Field",
+                              name: { kind: "Name", value: "projects" },
+                            },
+                            {
+                              kind: "Field",
+                              name: { kind: "Name", value: "taskTypes" },
+                            },
+                            {
+                              kind: "Field",
+                              name: { kind: "Name", value: "priorities" },
+                            },
+                          ],
+                        },
+                      },
+                    ],
+                  },
+                },
+              ],
+            },
+          },
+        ],
+      },
+    },
+  ],
+} as unknown as DocumentNode;
+
+/**
+ * __useGetApiKeyQuery__
+ *
+ * To run a query within a React component, call `useGetApiKeyQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetApiKeyQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetApiKeyQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useGetApiKeyQuery(
+  baseOptions: Apollo.QueryHookOptions<
+    GetApiKeyQuery,
+    GetApiKeyQueryVariables
+  > &
+    (
+      | { variables: GetApiKeyQueryVariables; skip?: boolean }
+      | { skip: boolean }
+    ),
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useQuery<GetApiKeyQuery, GetApiKeyQueryVariables>(
+    GetApiKeyDocument,
+    options,
+  );
+}
+export function useGetApiKeyLazyQuery(
+  baseOptions?: Apollo.LazyQueryHookOptions<
+    GetApiKeyQuery,
+    GetApiKeyQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useLazyQuery<GetApiKeyQuery, GetApiKeyQueryVariables>(
+    GetApiKeyDocument,
+    options,
+  );
+}
+export function useGetApiKeySuspenseQuery(
+  baseOptions?:
+    | Apollo.SkipToken
+    | Apollo.SuspenseQueryHookOptions<GetApiKeyQuery, GetApiKeyQueryVariables>,
+) {
+  const options =
+    baseOptions === Apollo.skipToken
+      ? baseOptions
+      : { ...defaultOptions, ...baseOptions };
+  return Apollo.useSuspenseQuery<GetApiKeyQuery, GetApiKeyQueryVariables>(
+    GetApiKeyDocument,
+    options,
+  );
+}
+export type GetApiKeyQueryHookResult = ReturnType<typeof useGetApiKeyQuery>;
+export type GetApiKeyLazyQueryHookResult = ReturnType<
+  typeof useGetApiKeyLazyQuery
+>;
+export type GetApiKeySuspenseQueryHookResult = ReturnType<
+  typeof useGetApiKeySuspenseQuery
+>;
+export type GetApiKeyQueryResult = Apollo.QueryResult<
+  GetApiKeyQuery,
+  GetApiKeyQueryVariables
+>;
+export const CreateApiKeyDocument = {
+  kind: "Document",
+  definitions: [
+    {
+      kind: "OperationDefinition",
+      operation: "mutation",
+      name: { kind: "Name", value: "CreateApiKey" },
+      variableDefinitions: [
+        {
+          kind: "VariableDefinition",
+          variable: {
+            kind: "Variable",
+            name: { kind: "Name", value: "input" },
+          },
+          type: {
+            kind: "NonNullType",
+            type: {
+              kind: "NamedType",
+              name: { kind: "Name", value: "CreateApiKeyInput" },
+            },
+          },
+        },
+      ],
+      selectionSet: {
+        kind: "SelectionSet",
+        selections: [
+          {
+            kind: "Field",
+            name: { kind: "Name", value: "createApiKey" },
+            arguments: [
+              {
+                kind: "Argument",
+                name: { kind: "Name", value: "input" },
+                value: {
+                  kind: "Variable",
+                  name: { kind: "Name", value: "input" },
+                },
+              },
+            ],
+            selectionSet: {
+              kind: "SelectionSet",
+              selections: [
+                { kind: "Field", name: { kind: "Name", value: "id" } },
+                { kind: "Field", name: { kind: "Name", value: "name" } },
+                { kind: "Field", name: { kind: "Name", value: "keyType" } },
+                { kind: "Field", name: { kind: "Name", value: "scope" } },
+                { kind: "Field", name: { kind: "Name", value: "key" } },
+                { kind: "Field", name: { kind: "Name", value: "createdAt" } },
+                { kind: "Field", name: { kind: "Name", value: "lastUsed" } },
+                { kind: "Field", name: { kind: "Name", value: "userId" } },
+                {
+                  kind: "Field",
+                  name: { kind: "Name", value: "createdBy" },
+                  selectionSet: {
+                    kind: "SelectionSet",
+                    selections: [
+                      { kind: "Field", name: { kind: "Name", value: "id" } },
+                      {
+                        kind: "Field",
+                        name: { kind: "Name", value: "displayName" },
+                      },
+                    ],
+                  },
+                },
+                {
+                  kind: "Field",
+                  name: { kind: "Name", value: "agentConfiguration" },
+                  selectionSet: {
+                    kind: "SelectionSet",
+                    selections: [
+                      {
+                        kind: "Field",
+                        name: { kind: "Name", value: "priorityFilters" },
+                        selectionSet: {
+                          kind: "SelectionSet",
+                          selections: [
+                            {
+                              kind: "Field",
+                              name: { kind: "Name", value: "teams" },
+                            },
+                            {
+                              kind: "Field",
+                              name: { kind: "Name", value: "projects" },
+                            },
+                            {
+                              kind: "Field",
+                              name: { kind: "Name", value: "taskTypes" },
+                            },
+                            {
+                              kind: "Field",
+                              name: { kind: "Name", value: "priorities" },
+                            },
+                          ],
+                        },
+                      },
+                    ],
+                  },
+                },
+              ],
+            },
+          },
+        ],
+      },
+    },
+  ],
+} as unknown as DocumentNode;
+export type CreateApiKeyMutationFn = Apollo.MutationFunction<
+  CreateApiKeyMutation,
+  CreateApiKeyMutationVariables
+>;
+
+/**
+ * __useCreateApiKeyMutation__
+ *
+ * To run a mutation, you first call `useCreateApiKeyMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateApiKeyMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createApiKeyMutation, { data, loading, error }] = useCreateApiKeyMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useCreateApiKeyMutation(
+  baseOptions?: Apollo.MutationHookOptions<
+    CreateApiKeyMutation,
+    CreateApiKeyMutationVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useMutation<
+    CreateApiKeyMutation,
+    CreateApiKeyMutationVariables
+  >(CreateApiKeyDocument, options);
+}
+export type CreateApiKeyMutationHookResult = ReturnType<
+  typeof useCreateApiKeyMutation
+>;
+export type CreateApiKeyMutationResult =
+  Apollo.MutationResult<CreateApiKeyMutation>;
+export type CreateApiKeyMutationOptions = Apollo.BaseMutationOptions<
+  CreateApiKeyMutation,
+  CreateApiKeyMutationVariables
+>;
+export const DeleteApiKeyDocument = {
+  kind: "Document",
+  definitions: [
+    {
+      kind: "OperationDefinition",
+      operation: "mutation",
+      name: { kind: "Name", value: "DeleteApiKey" },
+      variableDefinitions: [
+        {
+          kind: "VariableDefinition",
+          variable: { kind: "Variable", name: { kind: "Name", value: "id" } },
+          type: {
+            kind: "NonNullType",
+            type: { kind: "NamedType", name: { kind: "Name", value: "ID" } },
+          },
+        },
+      ],
+      selectionSet: {
+        kind: "SelectionSet",
+        selections: [
+          {
+            kind: "Field",
+            name: { kind: "Name", value: "deleteApiKey" },
+            arguments: [
+              {
+                kind: "Argument",
+                name: { kind: "Name", value: "id" },
+                value: {
+                  kind: "Variable",
+                  name: { kind: "Name", value: "id" },
+                },
+              },
+            ],
+          },
+        ],
+      },
+    },
+  ],
+} as unknown as DocumentNode;
+export type DeleteApiKeyMutationFn = Apollo.MutationFunction<
+  DeleteApiKeyMutation,
+  DeleteApiKeyMutationVariables
+>;
+
+/**
+ * __useDeleteApiKeyMutation__
+ *
+ * To run a mutation, you first call `useDeleteApiKeyMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteApiKeyMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deleteApiKeyMutation, { data, loading, error }] = useDeleteApiKeyMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useDeleteApiKeyMutation(
+  baseOptions?: Apollo.MutationHookOptions<
+    DeleteApiKeyMutation,
+    DeleteApiKeyMutationVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useMutation<
+    DeleteApiKeyMutation,
+    DeleteApiKeyMutationVariables
+  >(DeleteApiKeyDocument, options);
+}
+export type DeleteApiKeyMutationHookResult = ReturnType<
+  typeof useDeleteApiKeyMutation
+>;
+export type DeleteApiKeyMutationResult =
+  Apollo.MutationResult<DeleteApiKeyMutation>;
+export type DeleteApiKeyMutationOptions = Apollo.BaseMutationOptions<
+  DeleteApiKeyMutation,
+  DeleteApiKeyMutationVariables
+>;
+export const UpdateApiKeyDocument = {
+  kind: "Document",
+  definitions: [
+    {
+      kind: "OperationDefinition",
+      operation: "mutation",
+      name: { kind: "Name", value: "UpdateApiKey" },
+      variableDefinitions: [
+        {
+          kind: "VariableDefinition",
+          variable: { kind: "Variable", name: { kind: "Name", value: "id" } },
+          type: {
+            kind: "NonNullType",
+            type: { kind: "NamedType", name: { kind: "Name", value: "ID" } },
+          },
+        },
+        {
+          kind: "VariableDefinition",
+          variable: {
+            kind: "Variable",
+            name: { kind: "Name", value: "input" },
+          },
+          type: {
+            kind: "NonNullType",
+            type: {
+              kind: "NamedType",
+              name: { kind: "Name", value: "UpdateApiKeyInput" },
+            },
+          },
+        },
+      ],
+      selectionSet: {
+        kind: "SelectionSet",
+        selections: [
+          {
+            kind: "Field",
+            name: { kind: "Name", value: "updateApiKey" },
+            arguments: [
+              {
+                kind: "Argument",
+                name: { kind: "Name", value: "id" },
+                value: {
+                  kind: "Variable",
+                  name: { kind: "Name", value: "id" },
+                },
+              },
+              {
+                kind: "Argument",
+                name: { kind: "Name", value: "input" },
+                value: {
+                  kind: "Variable",
+                  name: { kind: "Name", value: "input" },
+                },
+              },
+            ],
+            selectionSet: {
+              kind: "SelectionSet",
+              selections: [
+                { kind: "Field", name: { kind: "Name", value: "id" } },
+                { kind: "Field", name: { kind: "Name", value: "name" } },
+                {
+                  kind: "Field",
+                  name: { kind: "Name", value: "agentConfiguration" },
+                  selectionSet: {
+                    kind: "SelectionSet",
+                    selections: [
+                      {
+                        kind: "Field",
+                        name: { kind: "Name", value: "priorityFilters" },
+                        selectionSet: {
+                          kind: "SelectionSet",
+                          selections: [
+                            {
+                              kind: "Field",
+                              name: { kind: "Name", value: "teams" },
+                            },
+                            {
+                              kind: "Field",
+                              name: { kind: "Name", value: "projects" },
+                            },
+                            {
+                              kind: "Field",
+                              name: { kind: "Name", value: "taskTypes" },
+                            },
+                            {
+                              kind: "Field",
+                              name: { kind: "Name", value: "priorities" },
+                            },
+                          ],
+                        },
+                      },
+                    ],
+                  },
+                },
+              ],
+            },
+          },
+        ],
+      },
+    },
+  ],
+} as unknown as DocumentNode;
+export type UpdateApiKeyMutationFn = Apollo.MutationFunction<
+  UpdateApiKeyMutation,
+  UpdateApiKeyMutationVariables
+>;
+
+/**
+ * __useUpdateApiKeyMutation__
+ *
+ * To run a mutation, you first call `useUpdateApiKeyMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateApiKeyMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateApiKeyMutation, { data, loading, error }] = useUpdateApiKeyMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useUpdateApiKeyMutation(
+  baseOptions?: Apollo.MutationHookOptions<
+    UpdateApiKeyMutation,
+    UpdateApiKeyMutationVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useMutation<
+    UpdateApiKeyMutation,
+    UpdateApiKeyMutationVariables
+  >(UpdateApiKeyDocument, options);
+}
+export type UpdateApiKeyMutationHookResult = ReturnType<
+  typeof useUpdateApiKeyMutation
+>;
+export type UpdateApiKeyMutationResult =
+  Apollo.MutationResult<UpdateApiKeyMutation>;
+export type UpdateApiKeyMutationOptions = Apollo.BaseMutationOptions<
+  UpdateApiKeyMutation,
+  UpdateApiKeyMutationVariables
+>;