schema.graphql

# Auto-generated by scripts/fetch-schema.mjs via introspection
# Source: https://tst-notifications.dev.openframe.build/api/graphql
# Generated: 2026-09-14T16:34:07.687Z
#
# Do not edit manually. Re-run: npm run fetch-schema
directive @extends on OBJECT | INTERFACE

directive @external on FIELD_DEFINITION

directive @key(fields: _FieldSet!) on OBJECT | INTERFACE

directive @provides(fields: _FieldSet!) on FIELD_DEFINITION

directive @requires(fields: _FieldSet!) on FIELD_DEFINITION

"""AI provider that powers a given model in the rate table."""
enum AIProvider {
  OPENAI
  ANTHROPIC
  GOOGLE_GEMINI
}

type APIKey {
  key: String!
  type: APIKeyType!
  keyName: String
}

enum APIKeyType {
  HEADER
  BEARER_TOKEN
}

type Address {
  street1: String
  street2: String
  city: String
  state: String
  postalCode: String
  country: String
}

"""
Rate for converting provider tokens of a single model into OpenFrame tokens.
"""
type AiModelRate {
  modelName: String!

  """Human-readable model name for display, e.g. "Claude Sonnet 4.6"."""
  displayName: String!
  providerType: AIProvider!

  """OpenFrame tokens charged per 1 input token of this model."""
  inputTokenRate: Float!

  """OpenFrame tokens charged per 1 output token of this model."""
  outputTokenRate: Float!
}

interface AssignableTarget {
  id: ID!
}

type AssignedItemCount {
  targetType: AssignmentTargetType!
  count: Int!
}

enum AssignmentItemType {
  TICKET
  KNOWLEDGE_ARTICLE
}

enum AssignmentTargetType {
  ORGANIZATION
  DEVICE
  TICKET
  KNOWLEDGE_ARTICLE
}

"""
Relay connection for the schedule's "Available Devices" picker. Same shape as DeviceConnection,
but each edge additionally reports whether the device is already assigned to the schedule.
"""
type AvailableDeviceConnection {
  edges: [AvailableDeviceEdge!]!
  pageInfo: PageInfo!
  filteredCount: Int!
}

type AvailableDeviceEdge {
  node: Machine!
  cursor: String!

  """
  True if this device is already assigned to the schedule (pre-checked in the picker).
  """
  assigned: Boolean!
}

" One command fanned out to several machines under a single executionId.\n Unlike runCommand, the batch is persisted (status PENDING) before dispatch."
input BatchRunCommandInput {
  machineIds: [String!]!
  shell: ScriptShell!
  command: String!
  privilegeLevel: PrivilegeLevel!
  timeoutSeconds: Int
}

""" One saved script fanned out to several machines under a single executionId.
"""
input BatchRunScriptInput {
  machineIds: [String!]!
  scriptId: ID!
  privilegeLevel: PrivilegeLevel!

  """Optional override of the script's defaultArgs."""
  args: [String!]

  """Optional override of the script's defaultTimeoutSeconds."""
  timeoutSeconds: Int

  """
  Run-time env vars merged over the script's stored env vars (same name overrides; new names are added). Null/empty keeps the script's stored env vars.
  """
  envVars: [ScriptEnvVarInput!]
}

"""
AI_TOKENS adds tokens to the day's sum; MANAGED_DEVICES sets the day's device-count peak.
"""
enum BillingMetricType {
  AI_TOKENS
  MANAGED_DEVICES
}

enum BillingPeriod {
  MONTHLY
  YEARLY
}

""" --- Billing Plan (detailed) ---"""
type BillingPlanDetails {
  id: ID!
  name: String!
  description: String
  version: String
  status: BillingPlanStatus
  trialDurationDays: Int
  effectiveDate: Date
  endDate: Date
  products: [Product!]!

  """
  Free AI tokens granted per billing period, by subscription state. Additive with a purchased AI token package.
  """
  freeTokens: FreeTokenGrants
}

enum BillingPlanStatus {
  DRAFT
  ACTIVE
  ARCHIVED
}

"""Stripe Billing Portal session the client should be sent to."""
type BillingPortalResult {
  portalUrl: String!
}

enum BillingProvisioningPendingReason {
  """
  No subscription document yet — waiting for registration or the gap-fill scheduler.
  """
  NO_SUBSCRIPTION

  """Subscription exists but the tenant has no Stripe customer yet."""
  NO_STRIPE_CUSTOMER

  """
  Stripe customer exists but the paused Stripe subscription has not been created yet.
  """
  NO_STRIPE_SUBSCRIPTION

  """
  Everything exists in Stripe, but pending actions have not been pushed yet.
  """
  STRIPE_SYNC_PENDING
}

enum BillingProvisioningState {
  """
  Subscription, Stripe customer and Stripe subscription all exist and are in sync.
  """
  READY

  """Provisioning is still in progress; see reason."""
  PENDING
}

type BillingProvisioningStatus {
  state: BillingProvisioningState!

  """Why provisioning is still pending. Null when state is READY."""
  reason: BillingProvisioningPendingReason

  """Human-readable explanation, safe to show as-is."""
  message: String!
}

"""
BREW only — the same name can exist as both a formula and a cask; other managers ignore it.
"""
enum BrewPackageType {
  FORMULA
  CASK
}

input CancelExecutionInput {
  machineId: String!
  executionId: ID!
}

"""Optional metadata for tenant-initiated cancellations."""
input CancelSubscriptionInput {
  """
  Short category code (e.g. "TOO_EXPENSIVE", "MISSING_FEATURE", "OTHER").
  """
  reason: String

  """Free-form details from the user."""
  description: String
}

input CheckoutInput {
  products: [ProductCheckoutInput!]!
  discountCode: String
}

""" --- Subscription / Checkout ---"""
type CheckoutResult {
  checkoutUrl: String!
  subscription: SubscriptionDetail
}

enum ConnectionStatus {
  CONNECTED
  DISCONNECTED
  ERROR
}

type ContactInformation {
  contacts: [ContactPerson!]!
  physicalAddress: Address
  mailingAddress: Address
  mailingAddressSameAsPhysical: Boolean
}

type ContactPerson {
  contactName: String
  title: String
  phone: String
  email: String
}

input CreateArticleInput {
  name: String!
  parentId: ID
  content: String
  summary: String
  status: KnowledgeBaseArticleStatus
  tagIds: [ID!]
  assignedOrganizationIds: [ID!]
  assignedDeviceIds: [ID!]
  assignedTicketIds: [ID!]
  assignedKnowledgeArticleIds: [ID!]
}

input CreateKnowledgeBaseAttachmentInput {
  articleId: ID!
  fileName: String!
  contentType: String
  fileSize: Long
}

input CreateKnowledgeBaseTempAttachmentInput {
  fileName: String!
  contentType: String
  fileSize: Long
}

input CreateScriptInput {
  name: String!
  description: String
  shell: ScriptShell!
  privilegeLevel: PrivilegeLevel!
  scriptBody: String!
  supportedPlatforms: [OsType!]
  defaultTimeoutSeconds: Int
  defaultArgs: [String!]
  envVars: [ScriptEnvVarInput!]

  """Ids of existing Tag entities to assign to the script."""
  tagIds: [ID!]
}

input CreateScriptScheduleInput {
  name: String!
  description: String
  supportedPlatforms: [OsType!]

  """Ids of existing Scripts to run, in run order."""
  scriptIds: [ID!]

  """
  Optional per-script custom args / env overrides. Sparse; each scriptId must be in scriptIds.
  """
  scriptCustomParams: [ScheduledScriptCustomParamsInput!]
  trigger: ScriptScheduleTrigger!

  """
  How a DATE_TIME schedule reads its startAt: SERVER (an absolute instant) or DEVICE_LOCAL (a wall-clock re-based per device). Null defaults to SERVER.
  """
  timeReference: ScheduleTimeReference

  """
  What to do when a target device is offline at the scheduled time. Null defaults to SKIP (current behaviour).
  """
  offlineBehavior: ScheduleOfflineBehavior

  """
  Max seconds to wait for an offline device to reconnect. Set only when offlineBehavior is RETRY_ON_RECONNECT; null/ignored for SKIP.
  """
  reconnectWindowSeconds: Long

  """
  The scheduled run time. For SERVER: an absolute UTC instant. For DEVICE_LOCAL: the picked Date + Time with NO zone offset applied (local 09:00 → 2026-09-10T09:00:00Z), re-based into each device's own timezone. Required when trigger is DATE_TIME; must be null for DEVICE_ONLINE. Must fall on a 30-minute boundary (xx:00 or xx:30).
  """
  startAt: Instant

  """
  Recurrence interval in seconds. Must be a whole number of 30-minute slots (1800, 3600, 5400, …); the runner ticks on that grid. Null means run once at startAt. For DEVICE_LOCAL it advances the local wall-clock by this many seconds each occurrence (e.g. 86400 = daily at the same local time).
  """
  repeat: Long
}

input CreateSoftwareScheduleInput {
  name: String!
  description: String
  action: SoftwareAction!

  """Packages to install/update. At least one."""
  packages: [SoftwareSchedulePackageInput!]!

  """
  How the schedule reads its startAt: SERVER (an absolute instant) or DEVICE_LOCAL (a wall-clock re-based per device). Null defaults to SERVER.
  """
  timeReference: ScheduleTimeReference

  """
  What to do when a target device is offline at the scheduled time. Null defaults to SKIP.
  """
  offlineBehavior: ScheduleOfflineBehavior

  """
  Max seconds to wait for an offline device to reconnect. Set only when offlineBehavior is RETRY_ON_RECONNECT.
  """
  reconnectWindowSeconds: Long

  """
  The scheduled run time. For SERVER: an absolute UTC instant. For DEVICE_LOCAL: the picked Date + Time with NO zone offset applied, re-based per device. Required; must fall on a 30-minute boundary (xx:00 or xx:30).
  """
  startAt: Instant!

  """
  Recurrence interval in seconds — a whole number of 30-minute slots (1800, 3600, …). Null = run once.
  """
  repeat: Long

  """SPECIFIC target device ids (Machine global ids)."""
  machineIds: [ID!]
}

input CreateTimeEntryInput {
  userId: ID!
  ticketId: ID
  organizationId: ID
  notes: String
  startedAt: Instant!
  durationSeconds: Long!
}

input CursorPaginationInput {
  """Opaque cursor from a previous page's `pageInfo.endCursor`."""
  cursor: String

  """Defaults to 20; values above 100 are clamped, not rejected."""
  limit: Int
}

""""""
scalar Date

""" Half-open date range filter. Period covers [startDate, endDate) — endDate day itself is NOT included.
"""
input DateRangeInput {
  startDate: Date!
  endDate: Date!
}

input DeleteFolderInput {
  id: ID!
  childrenAction: FolderChildrenAction
  moveTargetFolderId: ID
}

type DeviceConnection {
  edges: [DeviceEdge!]!
  pageInfo: PageInfo!
  filteredCount: Int!
}

type DeviceEdge {
  node: Machine!
  cursor: String!
}

input DeviceFilterInput {
  statuses: [DeviceStatus!]
  deviceTypes: [DeviceType!]
  osTypes: [String!]
  organizationIds: [String!]
  tagKeys: [String!]
  tagValues: [String!]
}

type DeviceFilterOption {
  value: String!
  label: String!
  count: Int!
}

type DeviceFilters {
  statuses: [DeviceFilterOption!]!
  deviceTypes: [DeviceFilterOption!]!
  osTypes: [DeviceFilterOption!]!
  organizationIds: [DeviceFilterOption!]!
  tagKeys: [TagFilterOption!]!
  filteredCount: Int!
}

enum DeviceStatus {
  PENDING
  ACTIVE
  INACTIVE
  MAINTENANCE
  DECOMMISSIONED
  ONLINE
  OFFLINE
  PENDING_DELETION
  DELETED
  ARCHIVED
}

enum DeviceType {
  DESKTOP
  LAPTOP
  SERVER
  MOBILE_DEVICE
  TABLET
  NETWORK_DEVICE
  IOT_DEVICE
  VIRTUAL_MACHINE
  CONTAINER_HOST
  OTHER
}

enum DiscountType {
  FIXED
  PERCENT
}

""" --- Discount ---"""
type DiscountValidation {
  discountId: ID
  code: String!
  name: String
  type: DiscountType
  applicableProducts: [OpenframeProduct!]!
  value: Float
  durationInMonths: Int
  valid: Boolean!
  reason: String
}

type DispatchResponse {
  executionId: ID!
}

type EmployeeTimeStats {
  todayTotalSeconds: Long!
  todayEntryCount: Long!
  periodTotalSeconds: Long!
  periodEntryCount: Long!
  averagePerDaySeconds: Long!
}

enum ErrorDetail {
  """
  Unknown error.
  
  This error should only be returned when no other error detail applies.
  If a client sees an unknown errorDetail, it will be interpreted as UNKNOWN.
  
  HTTP Mapping: 500 Internal Server Error
  """
  UNKNOWN

  """
  The requested field is not found in the schema.
  
  This differs from `NOT_FOUND` in that `NOT_FOUND` should be used when a
  query is valid, but is unable to return a result (if, for example, a
  specific video id doesn't exist). `FIELD_NOT_FOUND` is intended to be
  returned by the server to signify that the requested field is not known to exist.
  This may be returned in lieu of failing the entire query.
  See also `PERMISSION_DENIED` for cases where the
  requested field is invalid only for the given user or class of users.
  
  HTTP Mapping: 404 Not Found
  Error Type: BAD_REQUEST
  """
  FIELD_NOT_FOUND

  """
  The provided cursor is not valid.
  
  The most common usage for this error is when a client is paginating
  through a list that uses stateful cursors. In that case, the provided
  cursor may be expired.
  
  HTTP Mapping: 404 Not Found
  Error Type: NOT_FOUND
  """
  INVALID_CURSOR

  """
  The operation is not implemented or is not currently supported/enabled.
  
  HTTP Mapping: 501 Not Implemented
  Error Type: BAD_REQUEST
  """
  UNIMPLEMENTED

  """
  The client specified an invalid argument.
  
  Note that this differs from `FAILED_PRECONDITION`.
  `INVALID_ARGUMENT` indicates arguments that are problematic
  regardless of the state of the system (e.g., a malformed file name).
  
  HTTP Mapping: 400 Bad Request
  Error Type: BAD_REQUEST
  """
  INVALID_ARGUMENT

  """
  The deadline expired before the operation could complete.
  
  For operations that change the state of the system, this error
  may be returned even if the operation has completed successfully.
  For example, a successful response from a server could have been
  delayed long enough for the deadline to expire.
  
  HTTP Mapping: 504 Gateway Timeout
  Error Type: UNAVAILABLE
  """
  DEADLINE_EXCEEDED

  """
  Service Error.
  
  There is a problem with an upstream service.
  
  This may be returned if a gateway receives an unknown error from a service
  or if a service is unreachable.
  If a request times out which waiting on a response from a service,
  `DEADLINE_EXCEEDED` may be returned instead.
  If a service returns a more specific error Type, the specific error Type may
  be returned instead.
  
  HTTP Mapping: 502 Bad Gateway
  Error Type: UNAVAILABLE
  """
  SERVICE_ERROR

  """
  Request throttled based on server CPU limits
  
  HTTP Mapping: 503 Unavailable.
  Error Type: UNAVAILABLE
  """
  THROTTLED_CPU

  """
  Request throttled based on server concurrency limits.
  
  HTTP Mapping: 503 Unavailable
  Error Type: UNAVAILABLE
  """
  THROTTLED_CONCURRENCY

  """
  The server detected that the client is exhibiting a behavior that
  might be generating excessive load.
  
  HTTP Mapping: 429 Too Many Requests or 420 Enhance Your Calm
  Error Type: UNAVAILABLE
  """
  ENHANCE_YOUR_CALM

  """
  Request failed due to network errors.
  
  HTTP Mapping: 503 Unavailable
  Error Type: UNAVAILABLE
  """
  TCP_FAILURE

  """
  Unable to perform operation because a required resource is missing.
  
  Example: Client is attempting to refresh a list, but the specified
  list is expired. This requires an action by the client to get a new list.
  
  If the user is simply trying GET a resource that is not found,
  use the NOT_FOUND error type. FAILED_PRECONDITION.MISSING_RESOURCE
  is to be used particularly when the user is performing an operation
  that requires a particular resource to exist.
  
  HTTP Mapping: 400 Bad Request or 500 Internal Server Error
  Error Type: FAILED_PRECONDITION
  """
  MISSING_RESOURCE
}

enum ErrorType {
  """
  Unknown error.
  
  For example, this error may be returned when
  an error code received from another address space belongs to
  an error space that is not known in this address space.  Also
  errors raised by APIs that do not return enough error information
  may be converted to this error.
  
  If a client sees an unknown errorType, it will be interpreted as UNKNOWN.
  Unknown errors MUST NOT trigger any special behavior. These MAY be treated
  by an implementation as being equivalent to INTERNAL.
  
  When possible, a more specific error should be provided.
  
  HTTP Mapping: 520 Unknown Error
  """
  UNKNOWN

  """
  Internal error.
  
  An unexpected internal error was encountered. This means that some
  invariants expected by the underlying system have been broken.
  This error code is reserved for serious errors.
  
  HTTP Mapping: 500 Internal Server Error
  """
  INTERNAL

  """
  The requested entity was not found.
  
  This could apply to a resource that has never existed (e.g. bad resource id),
  or a resource that no longer exists (e.g. cache expired.)
  
  Note to server developers: if a request is denied for an entire class
  of users, such as gradual feature rollout or undocumented allowlist,
  `NOT_FOUND` may be used. If a request is denied for some users within
  a class of users, such as user-based access control, `PERMISSION_DENIED`
  must be used.
  
  HTTP Mapping: 404 Not Found
  """
  NOT_FOUND

  """
  The request does not have valid authentication credentials.
  
  This is intended to be returned only for routes that require
  authentication.
  
  HTTP Mapping: 401 Unauthorized
  """
  UNAUTHENTICATED

  """
  The caller does not have permission to execute the specified
  operation.
  
  `PERMISSION_DENIED` must not be used for rejections
  caused by exhausting some resource or quota.
  `PERMISSION_DENIED` must not be used if the caller
  cannot be identified (use `UNAUTHENTICATED`
  instead for those errors).
  
  This error Type does not imply the
  request is valid or the requested entity exists or satisfies
  other pre-conditions.
  
  HTTP Mapping: 403 Forbidden
  """
  PERMISSION_DENIED

  """
  Bad Request.
  
  There is a problem with the request.
  Retrying the same request is not likely to succeed.
  An example would be a query or argument that cannot be deserialized.
  
  HTTP Mapping: 400 Bad Request
  """
  BAD_REQUEST

  """
  Currently Unavailable.
  
  The service is currently unavailable.  This is most likely a
  transient condition, which can be corrected by retrying with
  a backoff.
  
  HTTP Mapping: 503 Unavailable
  """
  UNAVAILABLE

  """
  The operation was rejected because the system is not in a state
  required for the operation's execution.  For example, the directory
  to be deleted is non-empty, an rmdir operation is applied to
  a non-directory, etc.
  
  Service implementers can use the following guidelines to decide
  between `FAILED_PRECONDITION` and `UNAVAILABLE`:
  
  - Use `UNAVAILABLE` if the client can retry just the failing call.
  - Use `FAILED_PRECONDITION` if the client should not retry until
  the system state has been explicitly fixed.  E.g., if an "rmdir"
       fails because the directory is non-empty, `FAILED_PRECONDITION`
  should be returned since the client should not retry unless
  the files are deleted from the directory.
  
  HTTP Mapping: 400 Bad Request or 500 Internal Server Error
  """
  FAILED_PRECONDITION
}

"""
Where the execution was triggered from. Stamped server-side at dispatch — the client can't
forge it via the API. Powers the "via Mingo" label in History for AI-initiated runs.
"""
enum ExecutionSource {
  """Technician clicked Run in the dashboard."""
  MANUAL

  """
  A schedule fire — time-driven, DEVICE_ONLINE trigger, or dashboard Run Now on a schedule.
  """
  SCHEDULED

  """The Mingo AI runner invoked the dispatch on the technician's behalf."""
  AI_ASSISTANT
}

type FeFeatureFlag {
  name: String!
  enabled: Boolean!
}

enum FolderChildrenAction {
  MOVE
  ARCHIVE
}

type FreeTokenGrants {
  """Free AI tokens for the whole trial."""
  trial: Long

  """Free AI tokens per paid period without a device package."""
  payg: Long

  """Free AI tokens per paid period with an active device package."""
  devicePackage: Long
}

"""
Image projection (metadata, not bytes) shared by image-bearing GraphQL types
(e.g. TenantInfo.image, the AI assistant avatar, User.image).
Maps to com.openframe.data.document.image.Image; resolved via ImageService.
Image bytes/upload are served over REST (ImageController), not GraphQL.
"""
type Image {
  imageUrl: String!
  presignedImageUrl: String
  sourceType: String!
  hash: String
}

type Insight {
  """Detector fingerprint — stable across repeats of the same finding."""
  id: ID!
  organizationId: String!

  """Resolved through the shared organizationDataLoader — batched, no N+1."""
  organization: Organization

  """One line, already rendered for display."""
  title: String!

  """What was detected."""
  kind: InsightKind!

  """
  The category `kind` belongs to. Derived from the kind, never stored separately.
  """
  type: InsightType!
  severity: InsightSeverity!
  status: InsightStatus!
  deviceIds: [String!]!

  """When the detector decided, not when the underlying event happened."""
  detectedAt: Instant!
}

type InsightConnection {
  edges: [InsightEdge!]!
  pageInfo: PageInfo!

  """Total number of insights matching the filter, ignoring pagination."""
  filteredCount: Int!
}

type InsightEdge {
  node: Insight!
  cursor: String!
}

input InsightFilter {
  organizationId: String
  type: InsightType
  severity: InsightSeverity
  status: InsightStatus
}

enum InsightKind {
  UNSIGNED_BINARY
}

enum InsightSeverity {
  CRITICAL
  HIGH
  MEDIUM
  LOW
  INFO
}

enum InsightStatus {
  NEW
  ACKNOWLEDGED
  IN_PROGRESS
  RESOLVED
}

enum InsightType {
  SECURITY
  RESOURCE
  COMPLIANCE
  AVAILABILITY
}

type InstalledAgent implements Node {
  id: ID!
  machineId: String!
  agentType: String!
  version: String!
  createdAt: String
  updatedAt: String
}

""""""
scalar Instant

type IntegratedTool implements Node {
  id: ID!
  name: String!
  description: String
  icon: String
  toolUrls: [ToolUrl!]!
  type: String
  toolType: String
  category: String
  platformCategory: String
  enabled: Boolean!
  credentials: ToolCredentials

  """ Layer information"""
  layer: String
  layerOrder: Int
  layerColor: String

  """ Monitoring configuration"""
  metricsPath: String
  healthCheckEndpoint: String
  healthCheckInterval: Int
  connectionTimeout: Int
  readTimeout: Int
  allowedEndpoints: [String]
}

"""Lifecycle status of an invoice, mirrored from Stripe."""
enum InvoiceStatus {
  """Not yet finalized in Stripe."""
  DRAFT

  """
  Finalized and awaiting payment — this is the invoice the tenant still has to pay.
  """
  OPEN

  """Fully paid."""
  PAID

  """
  Voided (e.g. superseded by a re-planned subscription update); no longer payable.
  """
  VOID

  """Written off as uncollectible."""
  UNCOLLECTIBLE
}

"""Forecast of the next Stripe invoice for the current subscription."""
type InvoiceSummary {
  """
  Subtotal in the smallest currency unit (cents). Includes recurring fees, excludes overage.
  """
  monthlyTotal: Long!

  """
  Estimated overage charges from metered usage in the current period (cents).
  """
  estimatedOverage: Long!

  """ISO 4217 currency code, lowercase as Stripe returns it."""
  currency: String!

  """End of the period the upcoming invoice will cover."""
  periodEnd: Date!
}

type ItemAssignment implements Node {
  id: ID!
  itemType: AssignmentItemType!
  targetType: AssignmentTargetType!
  displayName: String!
  createdAt: Instant
  target: AssignableTarget
}

type ItemAssignmentConnection {
  edges: [ItemAssignmentEdge!]!
  pageInfo: PageInfo!
  filteredCount: Int!
}

type ItemAssignmentEdge {
  node: ItemAssignment!
  cursor: String!
}

""""""
scalar JSON

enum KnowledgeBaseArticleStatus {
  DRAFT
  PUBLISHED
  ARCHIVED
}

type KnowledgeBaseAttachmentUpload {
  attachment: KnowledgeBaseItemAttachment!
  uploadUrl: String!
}

type KnowledgeBaseAttachmentUploadPayload {
  attachment: KnowledgeBaseItemAttachment
  uploadUrl: String
  userErrors: [MutationError!]!
}

input KnowledgeBaseFilterInput {
  parentId: ID
  type: KnowledgeBaseItemType
  tagIds: [ID]
}

type KnowledgeBaseItem implements AssignableTarget & Node {
  id: ID!
  type: KnowledgeBaseItemType!
  name: String!
  parentId: ID
  slug: String
  sortOrder: Int
  content: String
  summary: String
  status: KnowledgeBaseArticleStatus
  publishedAt: Instant
  createdBy: ID
  createdAt: Instant
  lastModifiedBy: ID
  updatedAt: Instant
  tags: [Tag!]!
  attachments: [KnowledgeBaseItemAttachment!]!
  author: User
}

type KnowledgeBaseItemAttachment {
  id: ID!
  fileName: String!
  fileSize: Long
  contentType: String
  createdAt: Instant
}

type KnowledgeBaseItemConnection {
  edges: [KnowledgeBaseItemEdge!]!
  pageInfo: PageInfo!
  filteredCount: Int!
}

type KnowledgeBaseItemEdge {
  node: KnowledgeBaseItem!
  cursor: String!
}

enum KnowledgeBaseItemType {
  FOLDER
  ARTICLE
}

type KnowledgeBaseTempAttachmentPayload {
  tempAttachment: TempAttachment
  userErrors: [MutationError!]!
}

input LinkKnowledgeBaseTempAttachmentsInput {
  articleId: ID!
  tempIds: [ID!]!
}

type LogConnection {
  edges: [LogEdge!]!
  pageInfo: PageInfo!
}

""" Full audit details from Cassandra"""
type LogDetails implements Node {
  id: ID!
  toolEventId: String!
  eventType: String!
  ingestDay: String!
  toolType: String!
  severity: String!
  userId: String
  deviceId: String
  hostname: String
  organizationId: String
  organizationName: String
  message: String
  timestamp: Instant!

  """ Details as JSON string"""
  details: String
}

type LogEdge {
  node: LogEvent!
  cursor: String!
}

type LogEvent implements Node {
  id: ID!
  toolEventId: String!
  eventType: String!
  ingestDay: String!
  toolType: String!
  severity: String!
  userId: String
  deviceId: String
  hostname: String
  organizationId: String
  organizationName: String
  summary: String
  timestamp: Instant!
}

input LogFilterInput {
  startDate: Date

  """ Date scalar - single select (day granularity)"""
  endDate: Date

  " Date scalar - single select (day granularity)\n Inclusive timestamp range (millisecond precision, UTC ISO-8601 Instant).\n Independent of startDate/endDate and of each other: only from, only to, or both."
  timestampFrom: Instant

  """ Inclusive lower bound on the log timestamp"""
  timestampTo: Instant

  """ Inclusive upper bound on the log timestamp"""
  eventTypes: [String!]

  """ Multiselect (not array)"""
  toolTypes: [String!]

  """ Multiselect (not array)"""
  severities: [String!]

  """ Multiselect (not array)"""
  organizationIds: [String!]

  """ Organization filter (multiselect)"""
  deviceId: String
}

type LogFilters {
  toolTypes: [String!]!
  eventTypes: [String!]!
  severities: [String!]!
  organizations: [OrganizationFilterOption!]!
}

""" Sortable fields for logs. Currently only the timestamp is sortable."""
enum LogSortField {
  TIMESTAMP
}

input LogSortInput {
  field: LogSortField!

  """ currently TIMESTAMP only"""
  direction: SortDirection!
}

""""""
scalar Long

type Machine implements Node & AssignableTarget {
  id: ID!
  machineId: String!
  ip: String
  macAddress: String
  osUuid: String
  agentVersion: String
  status: DeviceStatus
  lastSeen: Instant
  organizationId: String
  organization: Organization
  hostname: String
  displayName: String
  nickname: String
  serialNumber: String
  manufacturer: String
  model: String
  type: DeviceType
  osType: OsType!
  osVersion: String
  osBuild: String
  timezone: String
  registeredAt: Instant
  updatedAt: Instant
  tags: [Tag]
  toolConnections: [ToolConnection]
  installedAgents: [InstalledAgent]
}

type Mutation {
  """Mark one Initial Setup step done. Idempotent."""
  completeTenantOnboardingStep(step: TenantOnboardingStep!): TenantOnboardingProgress!

  """
  Explicit 'Complete' button. Sets completed = true (frontend only surfaces it once all steps are done).
  """
  completeTenantOnboarding: TenantOnboardingProgress!

  """Mark one Get Started step done. Idempotent."""
  completeUserOnboardingStep(step: UserOnboardingStep!): UserOnboardingProgress!

  """Explicit 'Finish' button. Sets completed = true."""
  completeUserOnboarding: UserOnboardingProgress!

  """'Skip Onboarding' — start or anytime. Sets skipped = true."""
  skipUserOnboarding: UserOnboardingProgress!

  """
  Reset personal onboarding to a clean state (no steps, not skipped, not completed).
  """
  resetUserOnboarding: UserOnboardingProgress!

  """
  Idempotent upsert by token; a token previously owned by another user is re-bound to the caller.
  True = new device row. Call on every app launch: appVersion (the reporting app's own version) is
  recorded verbatim each time and gates capability-dependent push payloads.
  """
  registerPushDevice(token: String!, platform: PushPlatform!, appVersion: String): Boolean!

  """
  Best-effort on logout. False (not an error) when the token was not registered.
  """
  unregisterPushDevice(token: String!): Boolean!

  """
  The caller is looking right at this notification — cancel its pending OS push. Safe to fire
  at any moment: a cancel that arrives before the push is even enqueued still wins (tombstone).
  True = suppression guaranteed; false = too late (sent) or already cancelled. Idempotent.
  """
  cancelPendingPush(notificationId: ObjectId!): Boolean!

  """Create a Stripe checkout session for subscribing to selected products."""
  createCheckoutSession(input: CheckoutInput!): CheckoutResult!

  """
  Create a Stripe Billing Portal session where the customer manages its own billing address, tax IDs,
  payment methods and invoice history. Cancelling or changing the subscription is not exposed there —
  use cancelSubscription / updateSubscription instead.
  """
  createBillingPortalSession: BillingPortalResult!

  """
  Cancel the current tenant's subscription.
  The optional input captures a reason/description for analytics.
  """
  cancelSubscription(input: CancelSubscriptionInput): Boolean!

  """
  Resume a subscription that is scheduled for cancellation (status PENDING_CANCELLATION), clearing the
  pending cancellation in Stripe so it renews again. Only valid while still inside the paid period; a
  fully canceled subscription must go through checkout again.
  """
  resumeSubscription: Boolean!

  """Update the current subscription (change packages, toggle PAYG)."""
  updateSubscription(input: UpdateSubscriptionInput!): UpdateSubscriptionResult!

  """
  Cancel a pending package downgrade, reverting to the current (higher) tier. Drops the deferred
  PENDING_ACTIVATION option and its queued Stripe schedule phase so the scheduled reduction never takes
  effect. Errors if there is no pending downgrade.
  """
  cancelPendingDowngrade: UpdateSubscriptionResult!

  """Detach all payment methods. Returns the count of detached methods."""
  detachPaymentMethods: Int!

  """
  Set the ceiling, in USD, on the AI overage this subscription may accrue in one billing period. AI stops
  as soon as the accrued AI spend reaches it; raising it takes effect immediately.
  Pass an empty value (null, or omit the argument) to remove the cap — that is how "unlimited" is
  expressed in both directions; `aiSpendCapUsd` then comes back empty too. 0 is a real cap, not unlimited.
  Available while blocked, so a tenant can always lift its own limit.
  """
  updateAiSpendCap(amountUsd: Float): SubscriptionDetail!

  """
  Update the current authenticated tenant's name and/or website. saas-api only.
  """
  updateTenantInfo(input: UpdateTenantInfoInput!): TenantInfoPayload!
  updateDeviceNickname(machineId: String!, nickname: String): Machine!

  """
  Heartbeat from an active human session: marks the caller present for the presence TTL.
  Sent by the frontend while the tab/app is visible, plus immediately on regaining focus.
  An optional context argument can be added later without breaking existing clients.
  """
  recordPresence: Boolean!

  """
  Create a new schedule. Returns the created schedule with its server-assigned id.
  """
  createScriptSchedule(input: CreateScriptScheduleInput!): ScriptSchedule!

  """
  Full replacement (PUT semantics) of an existing schedule: every writable field on the input overwrites the stored value, including nulls which clear optional fields. The target schedule id travels inside the input.
  """
  updateScriptSchedule(input: UpdateScriptScheduleInput!): ScriptSchedule!

  """
  Soft-delete a schedule (sets status to DELETED). Returns the id of the deleted schedule; idempotent on already-deleted schedules. Throws if the id is not found in the tenant.
  """
  deleteScriptSchedule(id: ID!): ID!

  """
  Archive a schedule (sets status to ARCHIVED). Idempotent. Returns the updated schedule. Throws if not found or soft-deleted.
  """
  archiveScriptSchedule(id: ID!): ScriptSchedule!

  """
  Restore an archived schedule back to ACTIVE. Idempotent. Returns the updated schedule. Throws if not found or soft-deleted.
  """
  unarchiveScriptSchedule(id: ID!): ScriptSchedule!

  """
  Replace the full set of devices assigned to a schedule (PUT semantics — backs "Edit Devices").
  machineIds are Machine global ids. Returns the updated schedule. Throws if the schedule is not found or soft-deleted.
  """
  setScriptScheduleDevices(scheduleId: ID!, machineIds: [ID!]!): ScriptSchedule!

  """
  Incrementally assign the given devices to a schedule (the "+" / "Add selected" actions).
  Idempotent — already-assigned devices are skipped. machineIds are Machine global ids.
  Rejects devices whose OS does not match the schedule's supportedPlatforms.
  """
  addDevicesToSchedule(scheduleId: ID!, machineIds: [ID!]!): ScriptSchedule!

  """
  Incrementally unassign the given devices (the trash / "Remove selected" actions).
  Missing ids are no-ops. machineIds are Machine global ids.
  """
  removeDevicesFromSchedule(scheduleId: ID!, machineIds: [ID!]!): ScriptSchedule!

  """
  Assign ALL devices matching the Available-Devices filter/search (the "Add N Devices" action),
  scoped to the schedule's platforms and resolved server-side. Already-assigned devices are skipped.
  """
  addAllDevicesToSchedule(scheduleId: ID!, filter: DeviceFilterInput, search: String): ScriptSchedule!

  """
  Unassign ALL currently-assigned devices matching the Selected-Devices filter/search (the
  "Remove N Devices" action). With no filter this clears the whole assignment.
  """
  removeAllDevicesFromSchedule(scheduleId: ID!, filter: DeviceFilterInput, search: String): ScriptSchedule!

  """
  Switch a schedule to CRITERIA device selection and store its rule (customer / type / OS) — backs
  "Select Devices by Criteria" → Save Devices. The target device set is then resolved live at
  dispatch and display time, so devices registered later that match the rule are included
  automatically (and DEVICE_ONLINE schedules fire on them when they come online). Returns the
  updated schedule. Throws if the schedule is not found or soft-deleted.
  """
  setScheduleDeviceCriteria(scheduleId: ID!, criteria: ScheduleDeviceCriteriaInput!): ScriptSchedule!

  """
  Run a schedule now: fan every script the schedule references out to all of its assigned
  devices over core NATS under a single run executionId (shared across all scripts and machines).
  Returns that one DispatchResponse.
  """
  runScheduleJobNow(scheduleId: ID!): DispatchResponse!

  """
  Install one or more catalog packages on the given devices, immediately. Each package is
  dispatched as its own RMM execution; returns one result (with its executionId) per package.
  """
  installSoftware(input: SoftwareManagementInput!): [SoftwareDispatchResult!]!

  """
  Update one or more catalog packages on the given devices, immediately. Each package is
  dispatched as its own RMM execution; returns one result (with its executionId) per package.
  """
  updateSoftware(input: SoftwareManagementInput!): [SoftwareDispatchResult!]!

  """
  Create a new script. Returns the created script with its server-assigned id.
  """
  createScript(input: CreateScriptInput!): Script!

  """
  Full replacement (PUT semantics) of an existing script: every writable field on the input overwrites the stored value, including nulls which clear optional fields. Required fields (name, shell, scriptBody) must be present. The target script id travels inside the input.
  """
  updateScript(input: UpdateScriptInput!): Script!

  """
  Soft-delete a script (sets status to DELETED). Returns the id of the deleted script; idempotent on already-deleted scripts. Throws if the script id is not found in the tenant.
  """
  deleteScript(id: ID!): ID!

  """
  Archive a script (sets status to ARCHIVED). Idempotent on already-archived scripts. Returns the updated script. Throws if the script id is not found or is soft-deleted in the tenant.
  """
  archiveScript(id: ID!): Script!

  """
  Restore an archived script back to ACTIVE. Idempotent on scripts that are not archived. Returns the updated script. Throws if the script id is not found or is soft-deleted in the tenant.
  """
  unarchiveScript(id: ID!): Script!

  """
  Dispatch a saved script to a target machine over NATS. Nothing is persisted;
  the script body / shell / env-vars are resolved server-side from the stored script.
  Returns an executionId for correlating the agent's asynchronous result.
  """
  runScript(input: RunScriptInput!): DispatchResponse!

  """
  Dispatch one saved script to several machines at once over NATS, under a single
  shared executionId. Nothing is persisted; the script body / shell / env-vars are
  resolved server-side. Returns the shared executionId.
  """
  batchRunScript(input: BatchRunScriptInput!): DispatchResponse!
  runCommand(input: RunCommandInput!): DispatchResponse!
  batchRunCommand(input: BatchRunCommandInput!): DispatchResponse!
  cancelExecution(input: CancelExecutionInput!): DispatchResponse!
  assignItem(itemId: ID!, itemType: AssignmentItemType!, targetType: AssignmentTargetType!, targetId: ID!): ItemAssignment!
  unassignItem(itemId: ID!, targetType: AssignmentTargetType!, targetId: ID!): Boolean!
  unassignAllByType(itemId: ID!, targetType: AssignmentTargetType!): Boolean!
  startTimer(input: StartTimerInput): TimeEntry!
  pauseTimer: TimeEntry!
  resumeTimer: TimeEntry!
  stopTimer(input: StopTimerInput): TimeEntry!
  cancelTimer: Boolean!
  createTimeEntry(input: CreateTimeEntryInput!): TimeEntry!
  updateTimeEntry(input: UpdateTimeEntryInput!): TimeEntry!
  unlinkTicketFromTimeEntry(id: ID!): TimeEntry!
  deleteTimeEntry(id: ID!): Boolean!
  createFolder(name: String!, parentId: ID): KnowledgeBaseItem!
  renameFolder(id: ID!, name: String!): KnowledgeBaseItem!
  createArticle(input: CreateArticleInput!): KnowledgeBaseItem!
  updateArticle(input: UpdateArticleInput!): KnowledgeBaseItem!
  publishArticle(id: ID!): KnowledgeBaseItem!
  unpublishArticle(id: ID!): KnowledgeBaseItem!
  moveToFolder(id: ID!, parentId: ID): KnowledgeBaseItem!
  archiveArticle(id: ID!): KnowledgeBaseItem!
  unarchiveArticle(id: ID!, parentId: ID): KnowledgeBaseItem!
  deleteFolder(input: DeleteFolderInput!): Boolean!
  addTagToKnowledgeBaseItem(itemId: ID!, tagId: ID!): KnowledgeBaseItem!
  removeTagFromKnowledgeBaseItem(itemId: ID!, tagId: ID!): KnowledgeBaseItem!
  createKnowledgeBaseTempAttachmentUploadUrl(input: CreateKnowledgeBaseTempAttachmentInput!): KnowledgeBaseTempAttachmentPayload!
  deleteKnowledgeBaseTempAttachment(input: MutationDeleteInput!): MutationDeletePayload!
  linkKnowledgeBaseTempAttachmentsToArticle(input: LinkKnowledgeBaseTempAttachmentsInput!): [KnowledgeBaseItemAttachment!]!
  createKnowledgeBaseAttachmentUploadUrl(input: CreateKnowledgeBaseAttachmentInput!): KnowledgeBaseAttachmentUploadPayload!
  deleteKnowledgeBaseAttachment(input: MutationDeleteInput!): MutationDeletePayload!
  markNotificationAsRead(notificationId: ID!): Boolean!
  markAllNotificationsAsRead: Int!
  deleteNotification(notificationId: ID!): Boolean!
  deleteAllReadNotifications: Int!

  """
  Cards stay in the list as read; only the counts drop. The returned number spans categories — refetch, do not subtract it.
  """
  markNotificationsReadForEntity(entityType: NotificationEntityType!, entityId: ID!): Int!

  """
  Create a new software schedule. Returns the created schedule with its server-assigned id.
  """
  createSoftwareSchedule(input: CreateSoftwareScheduleInput!): SoftwareSchedule!

  """
  Full replacement (PUT) of an existing software schedule. The target id travels inside the input.
  machineIds null leaves the device assignment untouched; a list (including empty) replaces it.
  """
  updateSoftwareSchedule(input: UpdateSoftwareScheduleInput!): SoftwareSchedule!

  """
  Soft-delete a software schedule (sets status to DELETED). Returns the id; idempotent.
  """
  deleteSoftwareSchedule(id: ID!): ID!

  """
  Archive a software schedule (sets status to ARCHIVED). Idempotent. Returns the updated schedule.
  """
  archiveSoftwareSchedule(id: ID!): SoftwareSchedule!

  """
  Restore an archived software schedule back to ACTIVE. Idempotent. Returns the updated schedule.
  """
  unarchiveSoftwareSchedule(id: ID!): SoftwareSchedule!

  """
  Replace the full set of devices assigned to a software schedule (PUT — backs "Edit Devices").
  machineIds are Machine global ids. Returns the updated schedule.
  """
  setSoftwareScheduleDevices(scheduleId: ID!, machineIds: [ID!]!): SoftwareSchedule!

  """
  Incrementally assign the given devices (the "+"/"Add selected" actions). Idempotent.
  """
  addDevicesToSoftwareSchedule(scheduleId: ID!, machineIds: [ID!]!): SoftwareSchedule!

  """
  Incrementally unassign the given devices (the trash / "Remove selected" actions). Missing ids are no-ops.
  """
  removeDevicesFromSoftwareSchedule(scheduleId: ID!, machineIds: [ID!]!): SoftwareSchedule!
  createTag(key: String!, entityType: String!, description: String, color: String): Tag!
  updateTag(id: ID!, key: String, description: String, color: String): Tag!
  deleteTag(id: ID!): Boolean!

  """
  The modal saves full state; omitting typeSettings keeps the stored group overrides.
  """
  updateNotificationSettings(enabled: Boolean!, typeSettings: [NotificationTypeSettingInput!]): NotificationSettings!

  """
  Advance this tenant's Stripe test clock by N days (dev/stage only). Attaches a clock to the customer on first call, flushes current metered usage to Stripe, then advances.
  """
  advanceTestClock(days: Int!): TestClockResult

  """
  Delete this tenant's Stripe test clock (dev/stage only). Cascades to delete the customer, resetting the tenant to trial.
  """
  resetTestClock: Boolean!

  """
  Seed synthetic billing usage for this tenant (dev/stage only). Writes the same Cassandra row the real trackers produce and pushes the day's value to the shared cluster immediately. Optional date (yyyy-MM-dd) backdates within the current billing period; the default is the tenant's (possibly test-clock-virtual) today.
  """
  seedTestUsage(metricType: BillingMetricType!, value: Int!, date: String): TestUsageResult!
}

input MutationDeleteInput {
  id: ID!
}

type MutationDeletePayload {
  deletedId: ID
  userErrors: [MutationError!]!
}

""" Generic mutation primitives"""
type MutationError {
  field: [String!]
  message: String!
}

" Shared GraphQL schema definitions\n This file contains common types and base types used across multiple schemas\n Base types that can be extended by other schemas"
interface Node {
  id: ID!
}

type Notification implements Node {
  id: ID!
  severity: NotificationSeverity!
  title: String!
  description: String
  createdAt: Instant!
  read: Boolean!
  category: NotificationCategory!

  """Spec-driven notification type."""
  type: String

  """Flat string map of the notification's facts, snapshotted at emission."""
  attributes: JSON
}

enum NotificationCategory {
  DASHBOARD
  CUSTOMERS
  DEVICES
  SCRIPTS
  MONITORING
  SOFTWARE
  LOGS
  TICKETS
  MINGO
  GENERIC
}

type NotificationConnection {
  edges: [NotificationEdge!]!
  pageInfo: PageInfo!
}

type NotificationEdge {
  node: Notification!
  cursor: String!
}

enum NotificationEntityType {
  TICKET
  DIALOG
}

input NotificationFilterInput {
  read: Boolean
}

"""
The 'Notify about' checkboxes. A notification type outside every group cannot be muted.
"""
enum NotificationSettingGroup {
  TICKET_ASSIGNED
  TICKET_CREATED
  TICKET_STATUS_CHANGED
  CUSTOMER_REPLIED
  ADMIN_REPLIED
  MINGO_MESSAGES
  APPROVAL_TICKET
  APPROVAL_MINGO
}

type NotificationSettings {
  """Master switch over ALL notifications — in-app and push alike."""
  enabled: Boolean!

  """Every group exactly once, defaults already resolved."""
  typeSettings: [NotificationTypeSetting!]!
}

enum NotificationSeverity {
  INFO
  SUCCESS
  WARNING
  DANGER
}

type NotificationTypeSetting {
  group: NotificationSettingGroup!

  """
  Ready-to-render checkbox caption — a new group ships its own label, the client never maps the enum.
  """
  label: String!
  enabled: Boolean!
}

input NotificationTypeSettingInput {
  group: NotificationSettingGroup!
  enabled: Boolean!
}

"""A Mongo ObjectId; malformed input is rejected at the schema boundary."""
scalar ObjectId

"""OpenframeProduct enum represents available product features."""
enum OpenframeProduct {
  AI_ASSISTANCE
  MANAGED_DEVICES
}

type Organization implements Node & AssignableTarget {
  id: ID!
  name: String!
  organizationId: String!

  """ Generated as UUID on creation"""
  category: String
  numberOfEmployees: Int
  websiteUrl: String
  notes: String
  contactInformation: ContactInformation
  monthlyRevenue: Float
  contractStartDate: Date
  contractEndDate: Date
  createdAt: Instant
  updatedAt: Instant

  " Canonical \"last activity\" timestamp. Currently backed by updatedAt\n (falls back to createdAt when updatedAt is absent). Filter and sort\n operate on this same value."
  lastActivityAt: Instant
  isDefault: Boolean!
  status: String
  statusChangedAt: Instant

  """ Logo for the organization"""
  image: OrganizationImage
}

type OrganizationConnection {
  edges: [OrganizationEdge!]!
  pageInfo: PageInfo!
  filteredCount: Int!
}

type OrganizationEdge {
  node: Organization!
  cursor: String!
}

input OrganizationFilterInput {
  category: String
  minEmployees: Int
  maxEmployees: Int
  hasActiveContract: Boolean

  """ Filter by organization status (ACTIVE or ARCHIVED). Defaults to ACTIVE.
  """
  status: String

  " Inclusive last-activity range (millisecond precision, UTC ISO-8601 Instant).\n Independent bounds: only from, only to, or both. Operates on lastActivityAt."
  lastActivityFrom: Instant
  lastActivityTo: Instant
}

type OrganizationFilterOption {
  id: String!

  """ organizationId (for filtering)"""
  name: String!
}

type OrganizationImage {
  """ URL to access the logo image (relative path via backend proxy)"""
  imageUrl: String!

  """ Direct presigned URL to the image in cloud storage"""
  presignedImageUrl: String
  hash: String
  sourceType: String!
}

""" Deprecated: Use OrganizationConnection instead"""
type OrganizationList {
  organizations: [Organization!]!
}

""" Sortable fields for organizations. Currently only last activity is sortable.
"""
enum OrganizationSortField {
  LAST_ACTIVITY
}

input OrganizationSortInput {
  field: OrganizationSortField!

  """ currently LAST_ACTIVITY only"""
  direction: SortDirection!
}

enum OsType {
  WINDOWS
  MAC_OS
}

type PackageDetails {
  id: ID!
  packageManager: PackageManagerType!
  name: String!
  description: String
  publisher: String
  homepage: String
  iconUrl: String
  license: String
  installCommand: String!
  packageType: BrewPackageType

  """BREW and CHOCO only."""
  popularity: Int
  tags: [String!]!

  """
  Available versions, newest first. Homebrew publishes only the current one; Chocolatey returns the newest 40.
  """
  versions: [PackageVersion!]!
}

enum PackageManagerType {
  BREW
  CHOCO
  WINGET
}

type PackageSearchConnection {
  edges: [PackageSearchEdge!]!
  pageInfo: PageInfo!

  """
  Total matches for the query (same field name as every other connection).
  """
  filteredCount: Int!
}

type PackageSearchEdge {
  node: PackageSearchItem!
  cursor: String!
}

type PackageSearchItem {
  """
  Identifier to pass to packageDetails: brew name/token, Chocolatey package id, winget PackageIdentifier.
  """
  id: ID!
  name: String!
  description: String

  """Latest available version."""
  version: String

  """WINGET only in search results."""
  publisher: String
  homepage: String

  """CHOCO only in search results; winget provides it in packageDetails."""
  iconUrl: String

  """Ready-to-run install command, e.g. `brew install --cask slack`."""
  installCommand: String!

  """
  BREW only — pass it back to packageDetails to open exactly this package, not its twin of the other type.
  """
  packageType: BrewPackageType

  """
  Install/download count where the source publishes one: brew 30-day installs, Chocolatey total downloads.
  """
  popularity: Int
  packageManager: PackageManagerType!
}

input PackageUpdateInput {
  productName: OpenframeProduct!
  packageOptionId: String!
  action: UpdateAction!
  quantity: Int
}

type PackageVersion {
  version: String!

  """Chocolatey only — the other sources do not publish release dates."""
  releasedAt: Instant
  prerelease: Boolean
}

" Opaque JSON value (maps/lists serialized as-is); not accepted as an argument literal\n Relay Connection Spec page info"
type PageInfo {
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
  endCursor: String
}

"""
A Stripe invoice for the current tenant. The list is a full history — entries are kept after they
settle, with `status` reflecting the outcome (OPEN invoices are the ones still awaiting payment).
"""
type PendingInvoice {
  """Stripe invoice id (e.g. "in_1Abc...")."""
  id: ID!

  """
  Lifecycle status mirrored from Stripe. Null only for legacy entries not yet reconciled.
  """
  status: InvoiceStatus

  """
  Outstanding amount in major currency units (e.g. 10.00 USD), converted from Stripe's cents.
  """
  amountDue: Float!

  """ISO 4217 currency code, lowercase as Stripe returns it."""
  currency: String!

  """Due date for send_invoice mode, null when Stripe auto-charges."""
  dueDate: Instant

  """Long-lived Stripe-hosted URL where the customer can pay."""
  hostedInvoiceUrl: String!

  """
  Human-readable Stripe invoice number (e.g. "ABCD-0001"). Null for legacy entries not yet reconciled.
  """
  invoiceNumber: String

  """When the invoice first appeared in our store."""
  createdAt: Instant!

  """When the invoice was last updated in our store."""
  updatedAt: Instant!
}

enum PriceModel {
  PACKAGE_PRICING
  USAGE_BASED
}

type PriceTier {
  from: Int!
  upTo: Int
  unitPrice: Float!
}

enum PrivilegeLevel {
  USER
  ADMIN
}

type Product {
  id: ID!
  name: OpenframeProduct!
  unitSize: Long
  packageOptions: [ProductOption!]!
  payAsYouGoOption: ProductOption
}

""" --- Inputs ---"""
input ProductCheckoutInput {
  productName: OpenframeProduct!
  packageOptionId: String
  quantity: Int
  payAsYouGoEnabled: Boolean = true
  enabled: Boolean = true
}

type ProductOption {
  id: ID!
  name: String!
  description: String
  billingPeriod: BillingPeriod
  priceModel: PriceModel
  price: Float
  priceTiers: [PriceTier!]
  quantity: Int
  status: SubscriptionProductStatus
}

enum PushPlatform {
  IOS
  ANDROID
}

type Query {
  """ Relay Node interface queries"""
  node(id: ID!): Node
  nodes(ids: [ID!]!): [Node]!

  """
  Cursor-paginated insights for the calling tenant, newest first (Relay Connection Spec).
  Tenant scoping is applied by the datastore — the filter narrows within the tenant,
  it can never widen beyond it.
  """
  insights(filter: InsightFilter, pagination: CursorPaginationInput): InsightConnection!

  """
  A single insight by its detector fingerprint. Errors when it does not exist.
  """
  insight(id: ID!): Insight!

  """Tenant-wide Initial Setup progress (shared across admins)."""
  tenantOnboardingProgress: TenantOnboardingProgress!

  """Current user's Get Started progress."""
  userOnboardingProgress: UserOnboardingProgress!

  """
  Get the current authenticated tenant.
  Requires authentication.
  """
  currentTenant: Tenant

  """Get the current tenant's billing plan with full details."""
  billingPlan: BillingPlanDetails

  """Validate a discount by its ID. Returns discount details and validity."""
  validateDiscount(code: String!): DiscountValidation!

  """
  Get the current tenant's subscription details.
  Reads directly from local database without external calls.
  """
  subscription: SubscriptionDetail

  """
  Preview the date the subscription would be cancelled at (its current period end), for the
  cancel-confirmation dialog. Read-only — does not cancel. Reads live from Stripe, so the value matches
  what cancelSubscription then persists. Null only when Stripe exposes no period end.
  """
  subscriptionCancellationPreview: Date

  """
  Currently active AI model rate version — how provider tokens convert to OpenFrame tokens.
  Empty list when no rate version has been published yet.
  """
  aiModelRates: [AiModelRate!]!

  """
  How far along the tenant's billing provisioning is. READY means subscription, Stripe customer and
  Stripe subscription all exist and are in sync — the tenant is safe to test against. PENDING means the
  schedulers are still rebuilding it (normal for the first minutes after registration, or after a
  dev/stage test-clock reset).
  """
  billingProvisioningStatus: BillingProvisioningStatus!
  deviceFilters(filter: DeviceFilterInput): DeviceFilters!
  devices(filter: DeviceFilterInput, first: Int, after: String, last: Int, before: String, search: String, sort: SortInput): DeviceConnection!

  """ Get single device by Relay global ID"""
  deviceById(id: ID!): Machine

  """ Get single device by machineId"""
  device(machineId: String!): Machine

  " Get all integrated tools with optional filtering\n Returns a simple list since tools are limited in number (configuration data)"
  integratedTools(filter: ToolFilterInput, search: String, sort: SortInput): ToolList!

  """ Get available tool filters"""
  toolFilters: ToolFilters!

  """
  A single execution by its Relay id. Typed refetch — the alternative to node(id).
  Throws (not null) if the id is absent or in another tenant.
  """
  scriptExecution(id: ID!): ScriptExecution!
  scriptExecutions(scriptId: ID!, filter: ScriptExecutionFilterInput, search: String, sort: SortInput, first: Int, after: String, last: Int, before: String): ScriptExecutionConnection!
  scriptExecutionFilters(scriptId: ID!, filter: ScriptExecutionFilterInput, search: String): ScriptExecutionFilters!

  """
  Execution History rows for one schedule — parallel to scriptExecutions but
  scoped by scheduleId. Same ScriptExecutionConnection shape (rows are the same
  ScriptExecution rows the schedule produced), same filter / search / sort options.
  """
  scheduleExecutions(scheduleId: ID!, filter: ScriptExecutionFilterInput, search: String, sort: SortInput, first: Int, after: String, last: Int, before: String): ScriptExecutionConnection!

  """
  Facet options for a schedule's Execution History — parallel to scriptExecutionFilters.
  """
  scheduleExecutionFilters(scheduleId: ID!, filter: ScriptExecutionFilterInput, search: String): ScriptExecutionFilters!

  """
  Execution History rows for one software package's install/update runs — parallel to
  scriptExecutions but scoped by (packageManager, packageName, action). All packages of a manager
  share one generic script, so the package identity (not scriptId) narrows the rows. Same
  ScriptExecutionConnection shape, same filter / search / sort options.
  """
  softwareExecutions(packageManager: PackageManagerType!, packageName: String!, action: SoftwareAction!, filter: ScriptExecutionFilterInput, search: String, sort: SortInput, first: Int, after: String, last: Int, before: String): ScriptExecutionConnection!

  """
  Facet options for a software package's Execution History — parallel to scriptExecutionFilters.
  """
  softwareExecutionFilters(packageManager: PackageManagerType!, packageName: String!, action: SoftwareAction!, filter: ScriptExecutionFilterInput, search: String): ScriptExecutionFilters!

  """ Get all organizations with optional filtering and pagination"""
  organizations(filter: OrganizationFilterInput, first: Int, after: String, last: Int, before: String, search: String, orderBy: OrganizationSortInput): OrganizationConnection!

  """ Get single organization by ID"""
  organization(id: ID!): Organization

  """ Get organization by organizationId"""
  organizationByOrganizationId(organizationId: String!): Organization

  """
  Get a single schedule by id within the current tenant. Throws (not null) if the id is absent, soft-deleted, or in another tenant.
  """
  scriptSchedule(id: ID!): ScriptSchedule!

  """
  Cursor-paginated list of schedules within the current tenant (Relay Connection Spec).
  Default order is newest-first by _id. Optional filter / search / sort.
  Sortable fields: _id (default), name, startAt, repeat, deviceCount.
  When sorting by startAt, DEVICE_ONLINE schedules are always ordered last
  (they are event-driven and have no startAt).
  Ties are broken by _id so the order is stable. Search is a
  case-insensitive substring match on name.
  """
  scriptSchedules(filter: ScriptScheduleFilterInput, search: String, sort: SortInput, first: Int, after: String, last: Int, before: String): ScriptScheduleConnection!
  scriptScheduleFilters(filter: ScriptScheduleFilterInput): ScriptScheduleFilters!

  """
  Get a single script by id within the current tenant. Throws (not null) if the id is absent, soft-deleted, or in another tenant.
  """
  script(id: ID!): Script!

  """
  Cursor-paginated list of scripts within the current tenant (Relay Connection Spec).
  Default order is newest-first by _id. Optional filter / search / sort.
  Sortable fields: _id (default), name, createdAt, updatedAt. Search is a
  case-insensitive substring match on name.
  """
  scripts(filter: ScriptFilterInput, search: String, sort: SortInput, first: Int, after: String, last: Int, before: String): ScriptConnection!
  scriptFilters(filter: ScriptFilterInput): ScriptFilters!
  assignedItemCounts(itemId: ID!): [AssignedItemCount!]!
  assignedItems(itemId: ID!, targetType: AssignmentTargetType!, search: String, sort: SortInput, first: Int, after: String): ItemAssignmentConnection!
  currentTimer: TimeEntry
  myTimeEntries(period: DateRangeInput, search: String, sort: SortInput, first: Int, after: String): TimeEntryConnection!

  " Tenant-wide time entries. Filter groups all criteria: employeeIds (all users if null/empty),\n organizationIds (customer filter), startedFrom/startedTo (period)."
  employeeTimeEntries(filter: TimeEntryFilterInput, search: String, sort: SortInput, first: Int, after: String): TimeEntryConnection!
  employeeTimeStats(filter: TimeEntryFilterInput): EmployeeTimeStats!
  timeEntry(id: ID!): TimeEntry

  """
  Search packages in a public package-manager repository (Homebrew, Chocolatey, winget).
  Homebrew and winget results are ranked by match quality with popularity/canonical-id
  tiebreaks; Chocolatey results come in the repository's own relevance order.
  Forward cursor pagination only: pass `pageInfo.endCursor` back as `after`.
  """
  searchPackages(packageManager: PackageManagerType!, search: String, first: Int, after: String, last: Int, before: String): PackageSearchConnection!

  """
  Package details by identifier, including available versions (newest first).
  Errors with NOT_FOUND when the id is unknown to the package manager.
  """
  packageDetails(packageManager: PackageManagerType!, packageId: ID!, packageType: BrewPackageType): PackageDetails!
  knowledgeBaseItems(filter: KnowledgeBaseFilterInput, search: String, first: Int, after: String): KnowledgeBaseItemConnection!
  knowledgeBaseItem(id: ID!): KnowledgeBaseItem
  knowledgeBaseTags(folderId: ID, archived: Boolean): [Tag!]!
  knowledgeBaseFolderTree: [KnowledgeBaseItem!]!
  knowledgeBaseArticleTree: [KnowledgeBaseItem!]!
  archivedArticles(search: String, tagIds: [ID], first: Int, after: String): KnowledgeBaseItemConnection!
  knowledgeBaseAttachmentDownloadUrl(attachmentId: ID!): String!
  notifications(filter: NotificationFilterInput, search: String, first: Int, after: String, last: Int, before: String, sort: SortInput): NotificationConnection!
  hasUnreadNotifications: Boolean!
  unreadCountsByCategory: [UnreadCategoryCount!]!

  """
  Get a single software schedule by id within the current tenant. Throws (not null) if the id is absent, soft-deleted, or in another tenant.
  """
  softwareSchedule(id: ID!): SoftwareSchedule!

  """
  All software schedules in the current tenant, newest-first (by _id). Soft-deleted schedules are excluded.
  """
  softwareSchedules: [SoftwareSchedule!]!

  """ Tag key queries (tenant-wide, scoped to DEVICE entity type)"""
  tags: [Tag!]!

  """ Tag value options for filter UI (returns distinct values for a tag key with device counts)
  """
  tagValueOptions(tagKey: String!): [DeviceFilterOption!]!

  """ Autocomplete queries for tag key and value search (tenant-wide, scoped to DEVICE entity type)
  """
  tagKeySuggestions(search: String, limit: Int): [Tag!]!
  tagValueSuggestions(tagKey: String!, search: String, limit: Int): [String!]!

  """ All tag keys defined for a given entity type (tenant-wide)"""
  tagsByEntityType(entityType: TagEntityType!): [Tag!]!

  " Tag keys assigned to scripts. When archived=true returns tags assigned to\n archived scripts; when false/null returns tags assigned to active scripts."
  scriptsTags(archived: Boolean): [Tag!]!
  notificationSettings: NotificationSettings!

  """
  A single schedule fire by its Relay id. Typed refetch — the alternative to node(id).
  Throws (not null) if the id is absent or in another tenant.
  """
  scheduleRun(id: ID!): ScheduleRun!

  """
  Cursor-paginated list of individual schedule fires (Schedule Runs tab).
  Each row is one dispatch of the schedule to its assigned devices. Newest first
  by dispatchedAt (default). Optional statuses filter + case-insensitive substring
  search on executionId.
  """
  scheduleRuns(scheduleId: ID!, filter: ScheduleRunFilterInput, search: String, sort: SortInput, first: Int, after: String, last: Int, before: String): ScheduleRunConnection!

  """
  Available filter options (with live counts) for the scheduleRuns list of one schedule — the
  facet panel paired with the scheduleRuns connection. statuses = run outcomes; initiators = users
  who triggered fires (value is a User global id). Same scheduleId/filter/search scope as scheduleRuns.
  """
  scheduleRunFilters(scheduleId: ID!, filter: ScheduleRunFilterInput, search: String): ScheduleRunFilters!
  logFilters(filter: LogFilterInput): LogFilters!
  logs(filter: LogFilterInput, first: Int, after: String, last: Int, before: String, search: String, sort: LogSortInput): LogConnection!

  " Get full audit details from Cassandra when user clicks on a audit\n Requires complete composite key for efficient Cassandra lookup"
  logDetails(
    ingestDay: String!

    """ YYYY-MM-DD format"""
    toolType: String!

    """ Tool type (meshcentral, fleet-mdm, etc.)"""
    eventType: String!

    """ Event type (login, logout, script, etc.)"""
    timestamp: Instant!

    """ Timestamp of the audit"""
    toolEventId: String!
  ): LogDetails

  """Current authenticated tenant's info (name, website, image)."""
  tenantInfo: TenantInfo

  """
  Get frontend feature flags by names.
  Returns the requested flags with their enabled status.
  Unknown flags default to false.
  """
  feFeatureFlags(names: [String!]): [FeFeatureFlag!]!

  """
  Current virtual (frozen) time of this tenant's Stripe test clock, or null when no test clock is active (dev/stage only).
  """
  testClockTime: TestClockResult
  _service: _Service!
}

input RunCommandInput {
  machineId: String!
  shell: ScriptShell!
  command: String!
  privilegeLevel: PrivilegeLevel!
  timeoutSeconds: Int
}

input RunScriptInput {
  machineId: String!
  scriptId: ID!
  privilegeLevel: PrivilegeLevel!

  """Optional override of the script's defaultArgs."""
  args: [String!]

  """Optional override of the script's defaultTimeoutSeconds."""
  timeoutSeconds: Int

  """
  Run-time env vars merged over the script's stored env vars (same name overrides; new names are added). Null/empty keeps the script's stored env vars.
  """
  envVars: [ScriptEnvVarInput!]
}

"""
The stored "Select Devices by Criteria" rule. Each list is a whitelist (empty/null = no constraint on that dimension); a device matches when it satisfies every non-empty dimension.
"""
type ScheduleDeviceCriteria {
  """Customer scope — raw organization ids (empty = all customers)."""
  organizationIds: [String!]

  """Device-type scope (empty = all types)."""
  deviceTypes: [DeviceType!]

  """
  OS scope, intersected with the schedule's supportedPlatforms (empty = all supported platforms).
  """
  osTypes: [String!]
}

"""
Input for setScheduleDeviceCriteria — mirrors the customer / type / OS filters of the picker.
"""
input ScheduleDeviceCriteriaInput {
  organizationIds: [String!]
  deviceTypes: [DeviceType!]
  osTypes: [String!]
}

enum ScheduleDeviceSelectionMode {
  SPECIFIC
  CRITERIA
}

enum ScheduleOfflineBehavior {
  SKIP
  RETRY_ON_RECONNECT
}

"""
One row on the "Schedule Runs" tab — a single fire of the schedule to its assigned
devices. {@code respondedMachineCount / totalMachineCount} backs the "80 / 150"
progress ratio (responded = devices from which we have processed ≥ 1 result via Kafka).
"""
type ScheduleRun implements Node {
  id: ID!
  executionId: String!
  scheduleId: ID!

  """
  Aggregate fire status: RUNNING while any leaf is running, then SUCCESS / FAILED.
  """
  status: ScriptExecutionStatus!

  """Devices the fire targeted (denominator of the progress ratio)."""
  totalMachineCount: Int!

  """
  Devices we have received & processed at least one result from (numerator).
  """
  respondedMachineCount: Int!
  dispatchedAt: Instant!
  finishedAt: Instant

  """
  User who triggered this fire (resolved via User DataLoader from the raw initiator id).
  """
  initiator: User
}

type ScheduleRunConnection {
  edges: [ScheduleRunEdge!]!
  pageInfo: PageInfo!

  """
  Total matching rows for the current filter/search — independent of pagination.
  """
  filteredCount: Int!
}

type ScheduleRunEdge {
  node: ScheduleRun!
  cursor: String!
}

"""
Filter for the scheduleRuns(...) query. All fields optional; null/empty = no constraint.
"""
input ScheduleRunFilterInput {
  statuses: [ScriptExecutionStatus!]

  """
  Inclusive lower bound on the fire's dispatchedAt (date-range picker start).
  """
  dispatchedAtFrom: Instant

  """
  Inclusive upper bound on the fire's dispatchedAt (date-range picker end).
  """
  dispatchedAtTo: Instant
}

"""
Faceted filter options (with live counts) for the "Schedule Runs" tab. Reuses ScriptFilterOption
(value / label / count). filteredCount = total rows matching all active filters.
"""
type ScheduleRunFilters {
  statuses: [ScriptFilterOption!]!
  initiators: [ScriptFilterOption!]!
  filteredCount: Int!
}

enum ScheduleTimeReference {
  SERVER
  DEVICE_LOCAL
}

type ScheduledScriptCustomParams {
  scriptId: ID!
  args: [String!]
  envVars: [ScriptEnvVar!]
}

input ScheduledScriptCustomParamsInput {
  scriptId: ID!

  """
  Full replacement for the script's defaultArgs; null/omitted inherits the default.
  """
  args: [String!]

  """
  Full replacement for the script's envVars; null/omitted inherits the default. NOT merged.
  """
  envVars: [ScriptEnvVarInput!]
}

type Script implements Node {
  id: ID!
  name: String!
  description: String
  shell: ScriptShell!
  privilegeLevel: PrivilegeLevel!
  scriptBody: String!
  supportedPlatforms: [OsType!]
  defaultTimeoutSeconds: Int
  defaultArgs: [String!]
  envVars: [ScriptEnvVar!]

  """
  Tags assigned to this script (real Tag entities, resolved via tag assignments).
  """
  tags: [Tag!]!

  """
  Lifecycle status: ACTIVE | ARCHIVED | DELETED. DELETED is a soft-delete and is hidden from default queries.
  """
  status: ScriptStatus!
  statusChangedAt: Instant
  createdAt: Instant
  updatedAt: Instant

  """
  The creating user (resolved from the internal createdBy id via the user DataLoader). The raw createdBy id is not exposed — filter by author via authorIds.
  """
  author: User
}

type ScriptConnection {
  edges: [ScriptEdge!]!
  pageInfo: PageInfo!

  """
  Total number of scripts matching the current filter/search for the tenant, independent of pagination. Lets the UI show the full count up front while items load page by page. (Same field name as every other connection in the schema.)
  """
  filteredCount: Int!
}

type ScriptEdge {
  node: Script!
  cursor: String!
}

type ScriptEnvVar {
  name: String!
  value: String
  secret: Boolean!
}

input ScriptEnvVarInput {
  name: String!
  value: String
  secret: Boolean!
}

type ScriptExecution implements Node {
  " Relay global id (opaque). The raw Mongo _id is not exposed; clients\n correlate executions by executionId and refetch nodes by this global id."
  id: ID!
  executionId: ID!
  scriptId: ID!

  """ Resolved at read time from scriptId"""
  scriptName: String

  " Software install/update identity — set only for software executions, null for ordinary\n script/command runs. Lets History label the row by its package instead of the shared script."
  packageManager: PackageManagerType
  packageName: String
  softwareAction: SoftwareAction

  " Schedule this execution originated from, stamped at dispatch.\n Null for ad-hoc runs (runScript / batchRunScript). Backs \"execution history per schedule job\"."
  scheduleId: ID
  machine: Machine
  privilegeLevel: PrivilegeLevel!
  initiator: User
  source: ExecutionSource!
  status: ScriptExecutionStatus!
  dispatchedAt: Instant!
  statusChangedAt: Instant
  finishedAt: Instant
  exitCode: Int
  executionTimeMs: Float
  timedOut: Boolean
  stdout: String
  stdoutTruncated: Boolean
  stderr: String
  stderrTruncated: Boolean
  error: String
}

type ScriptExecutionConnection {
  edges: [ScriptExecutionEdge!]!
  pageInfo: PageInfo!
  filteredCount: Int!
}

type ScriptExecutionEdge {
  node: ScriptExecution!
  cursor: String!
}

input ScriptExecutionFilterInput {
  statuses: [ScriptExecutionStatus!]
  initiatorIds: [ID!]
  machineIds: [String!]

  """
  Inclusive lower bound on dispatchedAt (date-range picker start). Null = no lower bound.
  """
  dispatchedAtFrom: Instant

  """
  Inclusive upper bound on dispatchedAt (date-range picker end). Null = no upper bound.
  """
  dispatchedAtTo: Instant
}

type ScriptExecutionFilters {
  initiators: [ScriptFilterOption!]!
  statuses: [ScriptFilterOption!]!
  machines: [ScriptFilterOption!]!
  filteredCount: Int!
}

enum ScriptExecutionStatus {
  QUEUED
  RUNNING
  SUCCESS
  FAILED
}

"""
Filter for the scripts(...) query. All fields are optional — null/empty means
no constraint. The statuses field has special default behaviour: when null/empty,
DELETED scripts are hidden; when supplied (e.g. [DELETED] for admin audit),
the list is used verbatim with no implicit exclusion.
"""
input ScriptFilterInput {
  shells: [ScriptShell!]
  statuses: [ScriptStatus!]
  supportedPlatforms: [OsType!]
  tagIds: [ID!]
  authorIds: [ID!]
}

type ScriptFilterOption {
  value: String!
  label: String!
  count: Int!
}

type ScriptFilters {
  shells: [ScriptFilterOption!]!
  platforms: [ScriptFilterOption!]!
  authors: [ScriptFilterOption!]!
  filteredCount: Int!
}

type ScriptSchedule implements Node {
  id: ID!
  name: String!
  description: String
  supportedPlatforms: [OsType!]

  """
  How this schedule targets devices: SPECIFIC (an explicit machine set, managed on the "Select Specific Devices" tab) or CRITERIA (a live rule; devices registered later that match are included automatically). Never null — legacy schedules read as SPECIFIC.
  """
  selectionMode: ScheduleDeviceSelectionMode!

  """
  The device-selection rule when selectionMode is CRITERIA (customer / type / OS). Null for SPECIFIC schedules.
  """
  deviceCriteria: ScheduleDeviceCriteria

  """
  What fires this schedule: DATE_TIME (time-driven, uses startAt/repeat) or DEVICE_ONLINE (event-driven, fires when an assigned device comes online). Never null.
  """
  trigger: ScriptScheduleTrigger!

  """
  How a DATE_TIME schedule reads its startAt: SERVER (an absolute instant) or DEVICE_LOCAL (a wall-clock re-based into each device's own timezone). Never null; defaults to SERVER.
  """
  timeReference: ScheduleTimeReference!

  """
  What to do when a target device is offline at the scheduled time: SKIP (log and move on) or RETRY_ON_RECONNECT (run on reconnect). Never null; defaults to SKIP.
  """
  offlineBehavior: ScheduleOfflineBehavior!

  """
  Max seconds to wait for an offline device to reconnect before abandoning the run. Set only when offlineBehavior is RETRY_ON_RECONNECT; null for SKIP.
  """
  reconnectWindowSeconds: Long

  """
  The scheduled run time. For SERVER timeReference: an absolute UTC instant (the dashboard's Date + Time). For DEVICE_LOCAL: the picked Date + Time with no zone offset applied, re-based into each device's own timezone at run time. Null for DEVICE_ONLINE.
  """
  startAt: Instant

  """
  Recurrence interval in seconds. Null for a one-shot schedule that fires once at startAt.
  """
  repeat: Long

  """
  Next instant the runner will fire this schedule. Null when not scheduled (no timing, archived, or a one-shot that already fired).
  """
  nextRunAt: Instant

  """
  Instant of the most recent run performed by the runner. Null until the first fire.
  """
  lastRunAt: Instant

  """
  The scripts this schedule runs, in run order (resolved from the stored script ids).
  """
  scripts: [Script!]!

  """
  Per-script custom args / env overrides for this schedule ("custom scripts"). Sparse — only the
  scripts the user customised; every other script in `scripts` runs on its stored defaults. `scriptId`
  is a Script global id (matches `scripts[].id`).
  """
  scriptCustomParams: [ScheduledScriptCustomParams!]!

  """
  Machines assigned to this schedule — a Relay connection with the same filter/search/sort/pagination
  as the top-level `devices` query, scoped to this schedule's assignments.
  """
  assignedDevices(filter: DeviceFilterInput, first: Int, after: String, last: Int, before: String, search: String, sort: SortInput): DeviceConnection!

  """
  Devices selectable for this schedule — the "Available Devices" picker. Scoped to this
  schedule's supportedPlatforms so platform-mismatched devices are never shown (a Windows device
  is not offered for a macOS schedule). Same filter/search/sort/pagination as the top-level
  `devices` query. Each edge carries `assigned` = whether that device is already assigned to this
  schedule, so the picker can pre-check it. No scheduleId argument — it is taken from the parent.
  """
  availableDevices(filter: DeviceFilterInput, first: Int, after: String, last: Int, before: String, search: String, sort: SortInput): AvailableDeviceConnection!

  """
  Faceted filter options (status / deviceType / osType / organization, each with counts) for the
  "Assigned Devices" picker — the values actually present among this schedule's assigned devices,
  narrowed by `filter`/`search`. Same shape as the top-level `deviceFilters` query so the same
  filter panel can drive the picker. `tagKeys` is currently always empty for the pickers.
  """
  assignedDeviceFilters(filter: DeviceFilterInput, search: String): DeviceFilters!

  """
  Faceted filter options for the "Available Devices" picker — like `assignedDeviceFilters` but
  over this schedule's platform-scoped selectable set (matching the `availableDevices` picker).
  """
  availableDeviceFilters(filter: DeviceFilterInput, search: String): DeviceFilters!

  """Number of machines assigned to this schedule (the DEVICES column)."""
  deviceCount: Int!

  """
  Lifecycle status: ACTIVE | ARCHIVED | DELETED. DELETED is a soft-delete and is hidden from default queries.
  """
  status: ScriptStatus!
  statusChangedAt: Instant
  createdAt: Instant
  updatedAt: Instant

  """
  The creating user (resolved from the internal createdBy id via the user DataLoader).
  """
  author: User
}

type ScriptScheduleConnection {
  edges: [ScriptScheduleEdge!]!
  pageInfo: PageInfo!

  """
  Total number of schedules matching the current filter/search for the tenant, independent of pagination.
  """
  filteredCount: Int!
}

type ScriptScheduleEdge {
  node: ScriptSchedule!
  cursor: String!
}

"""
Filter for the scriptSchedules(...) query. All fields optional — null/empty means
no constraint. The statuses field hides DELETED when null/empty; when supplied it
is used verbatim.
"""
input ScriptScheduleFilterInput {
  statuses: [ScriptStatus!]
  supportedPlatforms: [OsType!]
  authorIds: [ID!]

  """
  Filter by first-run instant (startAt). DEVICE_ONLINE schedules have no startAt, so a startAt range excludes them.
  """
  startAtFrom: Instant
  startAtTo: Instant
}

type ScriptScheduleFilters {
  platforms: [ScriptFilterOption!]!
  authors: [ScriptFilterOption!]!
  filteredCount: Int!
}

enum ScriptScheduleTrigger {
  DATE_TIME
  DEVICE_ONLINE
}

enum ScriptShell {
  POWERSHELL
  CMD
  BASH
  PYTHON
  NUSHELL
  SHELL
}

enum ScriptStatus {
  ACTIVE
  ARCHIVED
  DELETED
}

"""
Install vs update — the two software management actions. Also scopes a package's Execution
History (softwareExecutions).
"""
enum SoftwareAction {
  INSTALL
  UPDATE
}

"""
The dispatch outcome for one package: its shared executionId across the targeted devices.
"""
type SoftwareDispatchResult {
  packageManager: PackageManagerType!
  packageName: String!
  executionId: String!
}

"""A set of catalog packages to install/update on a set of devices."""
input SoftwareManagementInput {
  """Target device machineIds (subject-safe tokens). 1..100."""
  machineIds: [String!]!

  """Packages to act on. 1..50."""
  packages: [SoftwarePackageInput!]!
}

"""
One package chosen from the catalog, identified exactly as package search returns it.
"""
input SoftwarePackageInput {
  packageManager: PackageManagerType!
  packageName: String!

  """
  Brew-only sub-type (CASK/FORMULA). Required for brew (enforced server-side), ignored by managers that do not distinguish.
  """
  brewPackageType: BrewPackageType
}

type SoftwareSchedule implements Node {
  id: ID!
  name: String!
  description: String

  """Install vs update — applied to every package in this schedule."""
  action: SoftwareAction!

  """The packages this schedule installs/updates."""
  packages: [SoftwareSchedulePackage!]!

  """
  How this schedule targets devices. Always SPECIFIC for now (criteria out of scope).
  """
  selectionMode: ScheduleDeviceSelectionMode!

  """
  How a DATE_TIME schedule reads its startAt: SERVER (an absolute instant) or DEVICE_LOCAL (a wall-clock re-based into each device's own timezone). Never null; defaults to SERVER.
  """
  timeReference: ScheduleTimeReference!

  """
  What to do when a target device is offline at the scheduled time. Never null; defaults to SKIP.
  """
  offlineBehavior: ScheduleOfflineBehavior!

  """
  Max seconds to wait for an offline device to reconnect. Set only when offlineBehavior is RETRY_ON_RECONNECT.
  """
  reconnectWindowSeconds: Long

  """
  The scheduled run time. For SERVER: an absolute UTC instant. For DEVICE_LOCAL: the picked Date + Time with no zone offset, re-based into each device's own timezone at run time.
  """
  startAt: Instant

  """Recurrence interval in seconds. Null for a one-shot schedule."""
  repeat: Long

  """
  Next instant the runner will fire this schedule. Null when not scheduled (DEVICE_LOCAL, archived, or a one-shot that already fired).
  """
  nextRunAt: Instant

  """Instant of the most recent run. Null until the first fire."""
  lastRunAt: Instant

  """
  Machines assigned to this schedule — same filter/search/sort/pagination as the top-level `devices` query, scoped to this schedule's assignments.
  """
  assignedDevices(filter: DeviceFilterInput, first: Int, after: String, last: Int, before: String, search: String, sort: SortInput): DeviceConnection!

  """
  Devices selectable for this schedule — the "Available Devices" picker. Each edge carries `assigned`.
  """
  availableDevices(filter: DeviceFilterInput, first: Int, after: String, last: Int, before: String, search: String, sort: SortInput): AvailableDeviceConnection!

  """Faceted filter options over this schedule's assigned devices."""
  assignedDeviceFilters(filter: DeviceFilterInput, search: String): DeviceFilters!

  """Faceted filter options over this schedule's selectable device set."""
  availableDeviceFilters(filter: DeviceFilterInput, search: String): DeviceFilters!

  """Number of machines assigned to this schedule (the DEVICES column)."""
  deviceCount: Int!

  """
  Lifecycle status: ACTIVE | ARCHIVED | DELETED. DELETED is a soft-delete, hidden from default queries.
  """
  status: ScriptStatus!
  statusChangedAt: Instant
  createdAt: Instant
  updatedAt: Instant

  """
  The creating user (resolved from the internal createdBy id via the user DataLoader).
  """
  author: User
}

"""One package a software schedule installs/updates."""
type SoftwareSchedulePackage {
  packageManager: PackageManagerType!
  packageName: String!

  """
  Brew-only sub-type (CASK/FORMULA); null for managers that do not distinguish.
  """
  brewPackageType: BrewPackageType
}

input SoftwareSchedulePackageInput {
  packageManager: PackageManagerType!
  packageName: String!

  """
  Brew-only sub-type (CASK/FORMULA). Required for brew (enforced server-side), ignored by other managers.
  """
  brewPackageType: BrewPackageType
}

""" Sorting support"""
enum SortDirection {
  ASC
  DESC
}

input SortInput {
  field: String
  direction: SortDirection
}

input StartTimerInput {
  ticketId: ID
  organizationId: ID
  notes: String
}

input StopTimerInput {
  ticketId: ID
  organizationId: ID
  notes: String
}

""" --- Subscription (full, standalone) ---"""
type SubscriptionDetail {
  id: ID!
  status: SubscriptionStatus!
  startDate: Date

  """
  End of the currently paid billing period. For ACTIVE subscriptions this is the next renewal date.
  """
  currentPeriodEnd: Date

  """
  When the subscription will actually be terminated. Non-null only for PENDING_CANCELLATION / CANCELED.
  """
  cancellationEffectiveAt: Date
  trialExpirationDate: Date
  products: [SubscriptionProductDetail!]!
  discounts: [SubscriptionDiscount!]!

  """
  Full history of the tenant's Stripe invoices, newest first. Each carries a `status`; the ones still
  awaiting payment are those with status OPEN. Empty only when the tenant has no invoices at all.
  """
  pendingInvoices: [PendingInvoice!]!

  """Aggregated usage for the current billing period."""
  usage: SubscriptionUsage!

  """Forecast of the next invoice from Stripe."""
  currentInvoice: InvoiceSummary

  """
  Projected amount of the next invoice: PAYG overage accrued so far + package charges due next cycle. Computed on read.
  """
  nextPayment: Float

  """
  Customer-set ceiling, in USD, on the AI overage this subscription may accrue in one billing period.
  Once the free tokens are spent, AI is blocked as soon as the accrued AI spend reaches it.
  Empty (null) means no cap at all — AI keeps running and the overage keeps being billed. A cap of 0 is
  a real cap: nothing beyond the free tokens may be spent.
  """
  aiSpendCapUsd: Float
}

type SubscriptionDiscount {
  id: ID!
  code: String
  name: String
  type: DiscountType
  applicableProducts: [OpenframeProduct!]!
  value: Float
  durationInMonths: Int
}

type SubscriptionOptionDetail {
  """
  Stable unique identifier for Relay normalization. Composite of product id, catalog option id, and slot to disambiguate options that share a catalog id (e.g. ACTIVE + PENDING_ACTIVATION).
  """
  id: ID!

  """
  Catalog option id. Use this value for PackageUpdateInput.packageOptionId when issuing updateSubscription mutations.
  """
  packageOptionId: String!
  name: String
  description: String
  billingPeriod: BillingPeriod
  priceModel: PriceModel
  price: Float
  priceTiers: [PriceTier!]
  quantity: Int
  startDate: Date
  endDate: Date
  status: SubscriptionProductStatus
}

type SubscriptionProductDetail {
  name: OpenframeProduct!
  paygOnly: Boolean!
  packageOptions: [SubscriptionOptionDetail!]!
  payAsYouGoOption: SubscriptionOptionDetail
}

enum SubscriptionProductStatus {
  ACTIVE
  PENDING_ACTIVATION
  EXPIRED
}

enum SubscriptionStatus {
  ACTIVE
  TRIAL

  """
  Projection-only: returned by the BFF when status is TRIAL and trialExpirationDate is in the past. Never persisted.
  """
  TRIAL_EXPIRED
  PAST_DUE
  SUSPENDED
  PENDING_CANCELLATION
  CANCELED
}

"""Aggregated usage counters for the current billing period."""
type SubscriptionUsage {
  """Total managed devices (active + inactive)."""
  devicesUsed: Int!

  """Devices currently online."""
  activeDevices: Int!

  """Devices currently offline."""
  inactiveDevices: Int!

  """AI tokens consumed in the current billing period."""
  aiTokensUsed: Long!

  """
  Free AI tokens granted for this billing period: 5M during the trial, 10M on PAYG, 25M with an active
  device package. Re-granted every period — nothing carries over — and additive with a purchased AI package.
  """
  aiTokensFree: Long!

  """
  How many of the free tokens are already spent (never more than aiTokensFree).
  """
  aiTokensFreeUsed: Long!

  """
  Tokens consumed beyond the full allowance (free + package) — the part that gets billed.
  """
  aiTokensOverage: Long!

  """
  What the AI overage accrued so far costs, in USD. This is what aiSpendCapUsd is measured against.
  """
  aiSpendUsd: Float!
}

""" Tag key definition (shared across all entity types)"""
type Tag implements Node {
  id: ID!
  key: String!
  description: String
  color: String
  values: [String!]
  entityType: TagEntityType
  createdAt: Instant
}

enum TagEntityType {
  DEVICE
  TICKET
  KNOWLEDGE_ARTICLE
  SCRIPT
}

type TagFilterOption {
  key: String!
  value: String!
  count: Int!
}

type TempAttachment {
  id: ID!
  fileName: String!
  contentType: String
  fileSize: Long
  uploadUrl: String!
  createdAt: Instant
}

"""Tenant represents a customer organization in the SaaS platform."""
type Tenant {
  """Unique identifier of the tenant"""
  id: ID!

  """Display name of the tenant organization"""
  name: String!

  """Owner user ID"""
  ownerId: String

  """HubSpot contact ID"""
  hubspotContactId: String

  """HubSpot tenant record ID"""
  hubspotTenantId: String

  """Stripe customer ID"""
  stripeCustomerId: String

  """Whether the tenant is a test account"""
  isTest: Boolean!

  """
  Timestamp when the tenant was created (ISO-8601 local datetime, no timezone)
  """
  createdAt: String

  """
  Timestamp when the tenant was last updated (ISO-8601 local datetime, no timezone)
  """
  updatedAt: String
}

"""
Editable tenant profile (name, website, image). Shared read model served by both
saas-api and the AI agent. The `image` field reuses the `Image` type defined by the
consuming service (saas-api / ai-agent) and is resolved via ImageService for ImageEntityType.TENANT.
"""
type TenantInfo {
  id: ID!
  name: String
  website: String
  image: Image
}

type TenantInfoPayload {
  tenantInfo: TenantInfo
  userErrors: [UserError!]!
}

"""
Tenant-wide Initial Setup progress. Shared across all admins of the tenant.
"""
type TenantOnboardingProgress {
  """
  Steps explicitly marked done. Subset of TenantOnboardingStep, no order guarantee.
  """
  completedSteps: [TenantOnboardingStep!]!

  """
  Set true only by the explicit Complete action; the tenant's definitive "onboarded" marker.
  """
  completed: Boolean!

  """When completed was set; null while not completed."""
  completedAt: Instant
}

" Every mutation returns the full progress object (no userErrors wrapper) so the client refreshes in\n one round-trip. `Instant` is the shared date-time scalar (ISO-8601, declared in the OSS shared schema)."
enum TenantOnboardingStep {
  MSP_SETUP
  CUSTOMERS_SETUP
  DEVICE_MANAGEMENT
  MEET_MINGO
}

type TestClockResult {
  frozenTime: String!
}

type TestUsageResult {
  metricType: String!
  billingDate: String!

  """The day's total after seeding (sum for tokens, max for devices)."""
  dayValue: Float!
}

" Ticket fields exposed for AssignableTarget resolution. Full type in ai-agent (ticket.graphqls).\n All fields below come from the Ticket @Document entity (denormalized at write time).\n Fields requiring DataLoaders (assignee User, attachments, notes, dialog, labels) are\n only on the ai-agent side; query ticket(id) there for full detail.\n TODO: Remove after Apollo Federation migration — single shared Ticket type."
type Ticket implements AssignableTarget & Node {
  id: ID!
  ticketNumber: Int
  title: String
  description: String
  status: String
  creationSource: String
  deviceId: String
  deviceHostname: String
  organizationId: String
  organizationName: String
  reporterId: String
  reporterName: String
  assignedTo: String
  assignedName: String
  createdAt: Instant
  updatedAt: Instant
  resolvedAt: Instant
}

type TimeEntry implements Node {
  id: ID!
  userId: ID!
  user: User
  ticketId: ID
  ticketNumber: Int
  ticketTitle: String
  ticket: Ticket
  organizationId: ID
  organization: Organization
  notes: String
  startedAt: Instant!
  endedAt: Instant
  pausedAt: Instant
  durationSeconds: Long!
  breakSeconds: Long!
  state: TimerState!
  source: TimeEntrySource!
  createdAt: Instant
  updatedAt: Instant
}

type TimeEntryConnection {
  edges: [TimeEntryEdge!]!
  pageInfo: PageInfo!
  filteredCount: Int!
}

type TimeEntryEdge {
  node: TimeEntry!
  cursor: String!
}

input TimeEntryFilterInput {
  employeeIds: [ID!]
  organizationIds: [ID!]
  startedFrom: Instant
  startedTo: Instant
}

enum TimeEntrySource {
  TIMER
  MANUAL
}

enum TimerState {
  RUNNING
  PAUSED
  COMPLETED
}

type ToolConnection implements Node {
  id: ID!
  machineId: String!
  toolType: ToolType!
  agentToolId: String!
  status: ConnectionStatus!
  metadata: String
  connectedAt: Instant
  lastSyncAt: Instant
  vulnerabilitiesUpdatedAt: Instant
  disconnectedAt: Instant
}

type ToolCredentials {
  username: String
  password: String
  apiKey: APIKey
}

input ToolFilterInput {
  enabled: Boolean
  type: String
  category: String
  platformCategory: String
}

""" Available filter options for tools"""
type ToolFilters {
  types: [String!]!
  categories: [String!]!
  platformCategories: [String!]!
}

" Simple list type for tools query\n Tools are configuration data with limited quantity (10-50 items)\n No pagination or total count needed"
type ToolList {
  tools: [IntegratedTool!]!
}

enum ToolType {
  MESHCENTRAL
  FLEET_MDM
  OPENFRAME_RMM
}

type ToolUrl {
  url: String!
  port: String
  type: ToolUrlType!
}

enum ToolUrlType {
  DASHBOARD
  API
  WS
  DATABASE
  CACHE
  BROKER
  COORDINATOR
  CONTROLLER
  SERVER
  METRICS
  LOGS
  INTERNAL
  NATS
  MINION
}

type UnreadCategoryCount {
  category: NotificationCategory!
  count: Int!
}

enum UpdateAction {
  ADD
  CANCEL
}

input UpdateArticleInput {
  id: ID!
  name: String
  parentId: ID
  content: String
  summary: String
}

"""
Full-replacement (PUT) payload for an existing script. Optional fields accept
null to clear the stored value; required fields (name, shell, scriptBody)
mirror createScript constraints and cannot be null.
"""
input UpdateScriptInput {
  id: ID!
  name: String!
  description: String
  shell: ScriptShell!
  privilegeLevel: PrivilegeLevel!
  scriptBody: String!
  supportedPlatforms: [OsType!]
  defaultTimeoutSeconds: Int
  defaultArgs: [String!]
  envVars: [ScriptEnvVarInput!]

  """
  Ids of existing Tag entities to assign — replaces the current set (PUT semantics: null/empty clears all tags).
  """
  tagIds: [ID!]
}

"""
Full-replacement (PUT) payload for an existing schedule. Optional fields accept
null to clear the stored value; name cannot be null.
"""
input UpdateScriptScheduleInput {
  id: ID!
  name: String!
  description: String
  supportedPlatforms: [OsType!]
  scriptIds: [ID!]

  """
  Optional per-script custom args / env overrides. PUT semantics: fully replaces the stored custom params (null/empty clears them). Each scriptId must be in scriptIds.
  """
  scriptCustomParams: [ScheduledScriptCustomParamsInput!]
  trigger: ScriptScheduleTrigger!

  """
  How a DATE_TIME schedule reads its startAt: SERVER (an absolute instant) or DEVICE_LOCAL (a wall-clock re-based per device). Null defaults to SERVER.
  """
  timeReference: ScheduleTimeReference

  """
  What to do when a target device is offline at the scheduled time. Null defaults to SKIP (current behaviour).
  """
  offlineBehavior: ScheduleOfflineBehavior

  """
  Max seconds to wait for an offline device to reconnect. Set only when offlineBehavior is RETRY_ON_RECONNECT; null/ignored for SKIP.
  """
  reconnectWindowSeconds: Long

  """
  How this schedule targets devices — SPECIFIC (an explicit machine set) or CRITERIA (a live rule). Null defaults to SPECIFIC, matching legacy documents. Flipping between modes leaves the join rows/rule untouched; whichever mode is active is what the resolver reads.
  """
  selectionMode: ScheduleDeviceSelectionMode

  """
  The scheduled run time. For SERVER: an absolute UTC instant. For DEVICE_LOCAL: the picked Date + Time with NO zone offset applied, re-based per device. Required when trigger is DATE_TIME; must be null for DEVICE_ONLINE. Changing it reschedules the run. Must fall on a 30-minute boundary.
  """
  startAt: Instant

  """
  Recurrence interval in seconds. Must be a whole number of 30-minute slots (1800, 3600, 5400, …). Null clears recurrence (one-shot). For DEVICE_LOCAL it advances the local wall-clock each occurrence (e.g. 86400 = daily at the same local time).
  """
  repeat: Long
}

"""Full-replacement (PUT) payload for an existing software schedule."""
input UpdateSoftwareScheduleInput {
  id: ID!
  name: String!
  description: String
  action: SoftwareAction!
  packages: [SoftwareSchedulePackageInput!]!
  timeReference: ScheduleTimeReference
  offlineBehavior: ScheduleOfflineBehavior
  reconnectWindowSeconds: Long
  startAt: Instant!
  repeat: Long

  """
  Full replacement of the assigned device set (Machine global ids). Null leaves the assignment untouched.
  """
  machineIds: [ID!]
}

input UpdateSubscriptionInput {
  packageUpdates: [PackageUpdateInput!]
  discountCode: String
}

type UpdateSubscriptionResult {
  subscription: SubscriptionDetail!

  """Domain-level errors. Empty when the update succeeded."""
  errors: [UserError!]!
}

"""
Update the current tenant's editable profile fields. Only non-null fields are applied.
The tenant image is managed via the REST image endpoints (ImageController, ImageEntityType.TENANT),
not through this mutation.
"""
input UpdateTenantInfoInput {
  name: String
  website: String
}

input UpdateTimeEntryInput {
  id: ID!
  userId: ID
  ticketId: ID
  organizationId: ID
  notes: String
  startedAt: Instant
  durationSeconds: Long
}

" Minimal User type for KB author resolution.\n TODO: Extract to shared schema or replace after user management module."
type User implements Node {
  id: ID!
  firstName: String
  lastName: String
  email: String

  """ACTIVE, DELETED or SELF_DELETED"""
  status: String
  image: UserImage
}

"""
Recoverable, user-facing error returned in a mutation payload (vs system errors that surface via onError).
"""
type UserError {
  """Stable machine-readable code (e.g. QUANTITY_DOWNGRADE_NOT_ALLOWED)."""
  code: String!

  """Human-readable description; UI may localize by code."""
  message: String!

  """Optional input field this error refers to (e.g. "quantity")."""
  field: String
}

type UserImage {
  imageUrl: String
  hash: String
}

"""Current user's Get Started progress for the current tenant."""
type UserOnboardingProgress {
  """
  Steps explicitly marked done. Subset of UserOnboardingStep, no order guarantee.
  """
  completedSteps: [UserOnboardingStep!]!

  """Set true only by the explicit Finish action."""
  completed: Boolean!

  """When completed was set; null while not completed."""
  completedAt: Instant

  """Set true by "Skip Onboarding" (start or anytime); cleared by reset."""
  skipped: Boolean!

  """When skipped was set; null while not skipped."""
  skippedAt: Instant
}

enum UserOnboardingStep {
  MEET_MINGO
  TICKETS
  SCRIPTING
  MONITORING
  LOGGING
  KNOWLEDGE_MANAGEMENT
}

""""""
scalar _FieldSet

type _Service {
  sdl: String!
}