import { DeviceCommunicationType } from '../../model/model_enum_values.js'; import { StorageItemType } from '../../model/model_enum_values.js'; import { DeviceStatus } from '../../model/model_enum_values.js'; import { Permission } from '../../model/model_enum_values.js'; import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql'; export type Maybe = T | null; export type InputMaybe = Maybe; export type Exact = { [K in keyof T]: T[K] }; export type MakeOptional = Omit & { [SubKey in K]?: Maybe }; export type MakeMaybe = Omit & { [SubKey in K]: Maybe }; export type MakeEmpty = { [_ in K]?: never }; export type Incremental = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never }; export type Omit = Pick>; export type EnumResolverSignature = { [key in keyof T]?: AllowedValues }; export type RequireFields = Omit & { [P in K]-?: NonNullable }; /** All built-in and custom scalars, mapped to their actual values */ export interface Scalars { ID: { input: string; output: string; } String: { input: string; output: string; } Boolean: { input: boolean; output: boolean; } Int: { input: number; output: number; } Float: { input: number; output: number; } DateTime: { input: any; output: any; } JSONObject: { input: any; output: any; } Time: { input: any; output: any; } } /** Detailed error information returned by the API. */ export interface ApiError extends Error { __typename?: 'ApiError'; /** Arguments passed to the operation that failed. */ args?: Maybe; /** Error code. */ code?: Maybe; /** Additional error data. */ data?: Maybe; /** Error message. */ message?: Maybe; /** Path to the field that caused the error. */ path?: Maybe; } /** Input for creating a new host. */ export interface CreateHost { /** Technical name of the host/device. */ deviceKey: Scalars['String']['input']; /** Classification or category of the device. */ deviceType: Scalars['String']['input']; /** List of host group names to assign the host to. */ groupNames: Array; /** Optionally, internal group IDs can be provided instead of group names. */ groupids?: InputMaybe>>; /** Location information for the host. */ location?: InputMaybe; /** User macros to assign to the host. */ macros?: InputMaybe>; /** Optional display name of the device (must be unique if provided - default is to set display name to deviceKey). */ name?: InputMaybe; /** List of template names to link to the host. */ templateNames?: InputMaybe>>; /** List of template IDs to link to the host. */ templateids?: InputMaybe>>; } /** Input for creating or identifying a host group. */ export interface CreateHostGroup { /** Name of the host group. */ groupName: Scalars['String']['input']; /** Internally used unique id (will be assigned by Zabbix if empty). */ uuid?: InputMaybe; } /** Response for a host group import operation. */ export interface CreateHostGroupResponse { __typename?: 'CreateHostGroupResponse'; /** Error information if the import failed. */ error?: Maybe; /** Name of the imported host group. */ groupName: Scalars['String']['output']; /** The Zabbix group ID assigned to the group. */ groupid?: Maybe; /** Status message for the import. */ message?: Maybe; } /** Response for a single host creation operation. */ export interface CreateHostResponse { __typename?: 'CreateHostResponse'; /** Error information if the creation failed. */ error?: Maybe; /** List of created host IDs. */ hostids?: Maybe>>; /** List of created item IDs. */ itemids?: Maybe>>; } /** Input for an item preprocessing step. */ export interface CreateItemPreprocessing { /** Error handling behavior. */ error_handler?: InputMaybe; /** Error handling parameters. */ error_handler_params?: InputMaybe; /** Parameters for the preprocessing step. */ params: Array; /** Type of preprocessing step (e.g. 12 for JSONPath, 21 for JavaScript). */ type: Scalars['Int']['input']; } /** Reference to a template to be linked. */ export interface CreateLinkedTemplate { /** The technical name of the template to link. */ name: Scalars['String']['input']; } /** Input for creating a user macro. */ export interface CreateMacro { /** Macro name (e.g. '{$LAT}'). */ macro: Scalars['String']['input']; /** Macro value. */ value: Scalars['String']['input']; } /** Reference to a master item for dependent items. */ export interface CreateMasterItem { /** The technical key of the master item. */ key: Scalars['String']['input']; } /** Input for a tag. */ export interface CreateTag { /** Tag name. */ tag: Scalars['String']['input']; /** Tag value. */ value?: InputMaybe; } /** Input for creating or updating a template. */ export interface CreateTemplate { /** List of template group names to assign the template to. */ groupNames: Array; /** Optionally, internal group IDs can be provided instead of group names. */ groupids?: InputMaybe>>; /** Technical name of the template. */ host: Scalars['String']['input']; /** List of items to create within the template. */ items?: InputMaybe>; /** User macros to assign to the template. */ macros?: InputMaybe>; /** Visible name of the template. */ name?: InputMaybe; /** Tags to assign to the template. */ tags?: InputMaybe>; /** List of other templates to link to this template. */ templates?: InputMaybe>; /** Internally used unique id (will be assigned by Zabbix if empty). */ uuid?: InputMaybe; } /** Input for creating or identifying a template group. */ export interface CreateTemplateGroup { /** Name of the template group. */ groupName: Scalars['String']['input']; /** Internally used unique id (will be assigned by Zabbix if empty). */ uuid?: InputMaybe; } /** Response for a template group import operation. */ export interface CreateTemplateGroupResponse { __typename?: 'CreateTemplateGroupResponse'; /** Error information if the import failed. */ error?: Maybe; /** Name of the imported template group. */ groupName: Scalars['String']['output']; /** The Zabbix group ID assigned to the group. */ groupid?: Maybe; /** Status message for the import. */ message?: Maybe; } /** Input for creating an item within a template. */ export interface CreateTemplateItem { /** Update interval. */ delay?: InputMaybe; /** Description of the item. */ description?: InputMaybe; /** History storage period (e.g. '2d', '90d'). */ history?: InputMaybe; /** Technical key of the item. */ key: Scalars['String']['input']; /** Reference to a master item if this is a dependent item. */ master_item?: InputMaybe; /** Name of the item. */ name: Scalars['String']['input']; /** JavaScript code for Script items or other parameters. */ params?: InputMaybe; /** Preprocessing steps for the item values. */ preprocessing?: InputMaybe>; /** Zabbix item status (0 for Enabled, 1 for Disabled). */ status?: InputMaybe; /** Tags to assign to the item. */ tags?: InputMaybe>; /** Timeout for item data collection. */ timeout?: InputMaybe; /** Zabbix item type (e.g. 0 for Zabbix Agent, 18 for Dependent). */ type?: InputMaybe; /** Units of the value. */ units?: InputMaybe; /** URL for HTTP Agent items. */ url?: InputMaybe; /** Internally used unique id. */ uuid?: InputMaybe; /** Type of information (e.g. 0 for Float, 3 for Int, 4 for Text). */ value_type?: InputMaybe; } /** Response object for delete operations. */ export interface DeleteResponse { __typename?: 'DeleteResponse'; /** Error information if the deletion failed. */ error?: Maybe; /** ID of the deleted entity. */ id: Scalars['Int']['output']; /** Status message for the delete operation. */ message?: Maybe; } /** * (IoT / Edge - ) Devices are hosts having a state containing the "output" / the business data which is exposed * besides monitoring information. */ export interface Device { /** Classification of the device. */ deviceType?: Maybe; /** Per convention a uuid is used as hostname to identify devices if they do not have a unique hostname. */ host: Scalars['String']['output']; /** List of host groups this device belongs to. */ hostgroups?: Maybe>; /** Internal Zabbix ID of the device. */ hostid: Scalars['ID']['output']; /** Host inventory data. */ inventory?: Maybe; /** List of monitored items for this host. */ items?: Maybe>; /** Visible name of the device. */ name?: Maybe; /** State of the device. */ state?: Maybe; /** Device configuration tags. */ tags?: Maybe; } export { DeviceCommunicationType }; /** Configuration settings for a device. */ export interface DeviceConfig { __typename?: 'DeviceConfig'; /** Configuration for the device widget preview in the cockpit. */ deviceWidgetPreview?: Maybe; } /** Common interface for device state. */ export interface DeviceState { /** Operational data (telemetry). */ operational?: Maybe; } export { DeviceStatus }; /** Marker-interface for device-related data values. */ export interface DeviceValue { /** Dummy field to allow for empty interfaces. */ _empty?: Maybe; } /** * Represents a message containing information about a specific device and its associated data value. * The interface is designed to be extended by other types that define more structured or specialized types * of device value messages. */ export interface DeviceValueMessage { /** * Represents the name assigned to a set of values that are submitted together with a single timestamp. * This name is associated with a well-defined data structure. */ attributeName?: Maybe; /** * A unique identifier used to distinguish a specific device within the system. * This field is commonly used to associate messages, configurations, or data values * with a particular device. */ deviceKey?: Maybe; /** * Specifies the type or category of the device. Used to define the classification * of a device in the system (capabilities, functionalities, or purpose). */ deviceType?: Maybe; /** * Represents the timestamp at which a specific event, message, or data point was created or recorded. * The format should align with standard expectations (e.g. ISO 8601). */ timestamp?: Maybe; /** * Represents the name of the sub-topic to which the attribute is submitted. * Classification or grouping of data within a broader topic structure. */ topicName?: Maybe; /** Retrieves the value associated with the current instance of the object. */ value?: Maybe; } /** Specification for a display field in a widget. */ export interface DisplayFieldSpec { __typename?: 'DisplayFieldSpec'; /** Value to display if the data is missing. */ emptyValue?: Maybe; /** Optional transformation for the unit. */ g_unit_transform?: Maybe; /** Optional transformation for the value. */ g_value_transform?: Maybe; /** Key of the data to display. */ key?: Maybe; /** Unit string to append to the value. */ unit?: Maybe; /** Font size for the unit. */ unit_font_size?: Maybe; /** Font size for the value. */ value_font_size?: Maybe; } /** Common error interface. */ export interface Error { /** Error code. */ code?: Maybe; /** Additional error data. */ data?: Maybe; /** Error message. */ message?: Maybe; } /** Payload for a single error or status message. */ export interface ErrorPayload { __typename?: 'ErrorPayload'; /** Additional contextual information about the error. */ additionalInfo?: Maybe; /** Error code. */ code: Scalars['Int']['output']; /** Human-readable error message. */ message?: Maybe; } /** Device represents generic IoT / Edge - devices providing their state as generic "state.current" - JSON Object. */ export interface GenericDevice extends Device, Host { __typename?: 'GenericDevice'; /** Classification of the device. */ deviceType?: Maybe; /** Per convention a uuid is used as hostname to identify devices if they do not have a unique hostname. */ host: Scalars['String']['output']; /** List of host groups this device belongs to. */ hostgroups?: Maybe>; /** Internal Zabbix ID of the device. */ hostid: Scalars['ID']['output']; /** Host inventory data. */ inventory?: Maybe; /** List of monitored items for this host. */ items?: Maybe>; /** Visible name of the device. */ name?: Maybe; /** State of the generic device. */ state?: Maybe; /** Device configuration tags. */ tags?: Maybe; } /** Generic implementation of device state using a JSON object for current values. */ export interface GenericDeviceState extends DeviceState { __typename?: 'GenericDeviceState'; /** Current business data as a generic JSON object. */ current?: Maybe; /** Operational data (telemetry). */ operational?: Maybe; } /** Generic response wrapper containing either the result data or an error. */ export interface GenericResponse { __typename?: 'GenericResponse'; /** Error information if the operation failed. */ error?: Maybe; /** The result data, typically a list of JSON objects. */ result?: Maybe>; } /** * Interface for entities that have GPS coordinates. * Hint: WGS84[dd.ddddd] coordinates are used. */ export interface GpsPosition { /** Latitude coordinate. */ latitude?: Maybe; /** Longitude coordinate. */ longitude?: Maybe; } /** Common interface for all host-like entities in Zabbix. */ export interface Host { /** * Specifies the type or category of the device. Used to define the classification * of a device in the system (capabilities, functionalities, or purpose). */ deviceType?: Maybe; /** Technical name of the host (the 'hostname' in Zabbix). */ host: Scalars['String']['output']; /** List of host groups this host belongs to. */ hostgroups?: Maybe>; /** Internal Zabbix ID of the host. */ hostid: Scalars['ID']['output']; /** Host inventory data. */ inventory?: Maybe; /** List of monitored items for this host. */ items?: Maybe>; /** Visible name of the host. */ name?: Maybe; } /** Represents a host group in Zabbix. */ export interface HostGroup { __typename?: 'HostGroup'; /** Internal Zabbix ID of the host group. */ groupid: Scalars['ID']['output']; /** Name of the host group. */ name?: Maybe; } /** Response for a host import operation. */ export interface ImportHostResponse { __typename?: 'ImportHostResponse'; /** The device key (technical name) of the imported host. */ deviceKey: Scalars['String']['output']; /** Error information if the import failed. */ error?: Maybe; /** The Zabbix host ID assigned to the host. */ hostid?: Maybe; /** Status message for the import. */ message?: Maybe; } /** Response for a template import operation. */ export interface ImportTemplateResponse { __typename?: 'ImportTemplateResponse'; /** Error information if the import failed. */ error?: Maybe; /** The technical name of the imported template. */ host: Scalars['String']['output']; /** Status message for the import. */ message?: Maybe; /** The Zabbix template ID assigned to the template. */ templateid?: Maybe; } /** Result of a single user right (role or group) import. */ export interface ImportUserRightResult { __typename?: 'ImportUserRightResult'; /** List of errors encountered during import. */ errors?: Maybe>; /** The ID of the imported/updated entity. */ id?: Maybe; /** Status message for the import. */ message?: Maybe; /** The name of the entity. */ name?: Maybe; } /** Result of a user rights import operation. */ export interface ImportUserRightsResult { __typename?: 'ImportUserRightsResult'; /** Results for the imported user groups. */ userGroups?: Maybe>; /** Results for the imported user roles. */ userRoles?: Maybe>; } /** Represents host inventory information. */ export interface Inventory { __typename?: 'Inventory'; /** Location data for the host. */ location?: Maybe; } /** Represents a geographical location. */ export interface Location extends GpsPosition { __typename?: 'Location'; /** Latitude coordinate. */ latitude?: Maybe; /** Longitude coordinate. */ longitude?: Maybe; /** Name of the location. */ name?: Maybe; } /** Input for host location information. */ export interface LocationInput { /** Latitude coordinate. */ location_lat?: InputMaybe; /** Longitude coordinate. */ location_lon?: InputMaybe; /** Name of the location. */ name?: InputMaybe; } export interface Mutation { __typename?: 'Mutation'; /** * Creates a single host in Zabbix. * * Authentication: Requires `zbx_session` cookie or `zabbix-auth-token` header. */ createHost?: Maybe; /** * Delete host groups by their IDs or by a name pattern. * * Authentication: Requires `zbx_session` cookie or `zabbix-auth-token` header. */ deleteHostGroups?: Maybe>; /** * Delete hosts by their IDs or by a name pattern. * * Authentication: Requires `zbx_session` cookie or `zabbix-auth-token` header. */ deleteHosts?: Maybe>; /** * Delete template groups by their IDs or by a name pattern. * * Authentication: Requires `zbx_session` cookie or `zabbix-auth-token` header. */ deleteTemplateGroups?: Maybe>; /** * Delete templates by their IDs or by a name pattern. * * Authentication: Requires `zbx_session` cookie or `zabbix-auth-token` header. */ deleteTemplates?: Maybe>; /** * (Mass) Import Zabbix host groups and assign them to the corresponding hosts by groupid or groupName. * * Return value: If no error occurs, a groupid is returned for each created group; otherwise, the return object contains an error message. * * Authentication: Requires `zbx_session` cookie or `zabbix-auth-token` header. */ importHostGroups?: Maybe>; /** * (Mass) Import hosts and assign them to host groups by groupid or groupName. * * Return value: If no error occurs, a hostid is returned for each created host; otherwise, the return object contains an error message. * * Authentication: Requires `zbx_session` cookie or `zabbix-auth-token` header. */ importHosts?: Maybe>; /** * (Mass) Import template groups and assign them by groupid or name. * * Return value: If no error occurs, a groupid is returned for each created group; otherwise, the return object contains an error message. * * Authentication: Requires `zbx_session` cookie or `zabbix-auth-token` header. */ importTemplateGroups?: Maybe>; /** * (Mass) Import templates. * * Return value: If no error occurs, a templateid is returned for each created template; otherwise, the return object contains an error message. * * Authentication: Requires `zbx_session` cookie or `zabbix-auth-token` header. */ importTemplates?: Maybe>; /** * Import user rights (roles and groups) into Zabbix. * * Authentication: Requires `zbx_session` cookie or `zabbix-auth-token` header. */ importUserRights?: Maybe; /** Runs all regression tests. */ runAllRegressionTests: SmoketestResponse; /** Runs a smoketest: creates a template, links a host, verifies it, and cleans up. */ runSmoketest: SmoketestResponse; } export interface MutationCreateHostArgs { host: Scalars['String']['input']; hostgroupids: Array; location?: InputMaybe; templateNames?: InputMaybe>>; templateids?: InputMaybe>>; } export interface MutationDeleteHostGroupsArgs { groupids?: InputMaybe>; name_pattern?: InputMaybe; } export interface MutationDeleteHostsArgs { hostids?: InputMaybe>; name_pattern?: InputMaybe; } export interface MutationDeleteTemplateGroupsArgs { groupids?: InputMaybe>; name_pattern?: InputMaybe; } export interface MutationDeleteTemplatesArgs { name_pattern?: InputMaybe; templateids?: InputMaybe>; } export interface MutationImportHostGroupsArgs { hostGroups: Array; } export interface MutationImportHostsArgs { hosts: Array; } export interface MutationImportTemplateGroupsArgs { templateGroups: Array; } export interface MutationImportTemplatesArgs { templates: Array; } export interface MutationImportUserRightsArgs { dryRun?: Scalars['Boolean']['input']; input: UserRightsInput; } export interface MutationRunSmoketestArgs { groupName: Scalars['String']['input']; hostName: Scalars['String']['input']; templateName: Scalars['String']['input']; } /** Operational data common to most devices. */ export interface OperationalDeviceData { __typename?: 'OperationalDeviceData'; /** List of active errors or status messages. */ error?: Maybe>; /** Current location of the device. */ location?: Maybe; /** Signal strength (e.g. WiFi or GSM). */ signalstrength?: Maybe; /** Device temperature. */ temperature?: Maybe; /** Timestamp of the operational data. */ timestamp?: Maybe; /** Device voltage. */ voltage?: Maybe; } export { Permission }; /** Request for checking specific user permissions. */ export interface PermissionRequest { /** * objectName maps to name / path suffix of the template group representing the permission in Zabbix: * Permissions/{objectName} */ objectName: Scalars['String']['input']; /** The required permission level (DENY, READ, or READ_WRITE). */ permission: Permission; } export interface Query { __typename?: 'Query'; /** * Returns all devices and their items. Devices are hosts with a `deviceType` and a state. * * Authentication: Requires `zbx_session` cookie or `zabbix-auth-token` header. */ allDevices?: Maybe>>; /** * Returns all host groups. * * Authentication: Requires `zbx_session` cookie or `zabbix-auth-token` header. */ allHostGroups?: Maybe>>; /** * Returns all hosts and their items. * * Authentication: Requires `zbx_session` cookie or `zabbix-auth-token` header. */ allHosts?: Maybe>>; /** Returns all template groups. */ allTemplateGroups?: Maybe>>; /** Returns the API build version. */ apiVersion: Scalars['String']['output']; /** * Exports value history for Zabbix items. * * Authentication: Requires `zbx_session` cookie or `zabbix-auth-token` header. */ exportHostValueHistory?: Maybe; /** Exports user rights (roles and groups). */ exportUserRights?: Maybe; /** Checks if the current user has the requested permissions. */ hasPermissions?: Maybe; /** * Returns all locations used by hosts. * * Authentication: Requires `zbx_session` cookie or `zabbix-auth-token` header. */ locations?: Maybe>>; /** * Logs in to Zabbix. This is primarily for debugging and testing. * The returned authentication token can be passed in the `zabbix-auth-token` header for future requests. * Alternatively, the `zbx_session` cookie can be used for authentication. */ login?: Maybe; /** Logs out from Zabbix, invalidating the current session/token. */ logout?: Maybe; /** Returns templates. */ templates?: Maybe>>; /** * Returns all user permissions. * If `objectNames` is provided, returns only the permissions related to those objects. */ userPermissions?: Maybe>; /** Returns the version of the connected Zabbix instance. */ zabbixVersion?: Maybe; } export interface QueryAllDevicesArgs { filter_host?: InputMaybe; groupids?: InputMaybe>; hostids?: InputMaybe; name_pattern?: InputMaybe; tag_deviceType?: InputMaybe>>; tag_hostType?: InputMaybe>; with_items?: InputMaybe; } export interface QueryAllHostGroupsArgs { search_name?: InputMaybe; with_hosts?: InputMaybe; } export interface QueryAllHostsArgs { filter_host?: InputMaybe; groupids?: InputMaybe>; hostids?: InputMaybe; name_pattern?: InputMaybe; tag_deviceType?: InputMaybe>>; tag_hostType?: InputMaybe>; with_items?: InputMaybe; } export interface QueryAllTemplateGroupsArgs { name_pattern?: InputMaybe; } export interface QueryExportHostValueHistoryArgs { host_filter?: InputMaybe>; itemKey_filter?: InputMaybe>; limit?: InputMaybe; sortOrder?: InputMaybe; time_from?: InputMaybe; time_until?: InputMaybe; type?: InputMaybe; } export interface QueryExportUserRightsArgs { exclude_hostgroups_pattern?: InputMaybe; name_pattern?: InputMaybe; } export interface QueryHasPermissionsArgs { permissions: Array; } export interface QueryLocationsArgs { distinct_by_name?: InputMaybe; name_pattern?: InputMaybe; templateids?: InputMaybe>>; } export interface QueryLoginArgs { password: Scalars['String']['input']; username: Scalars['String']['input']; } export interface QueryTemplatesArgs { hostids?: InputMaybe>>; name_pattern?: InputMaybe; } export interface QueryUserPermissionsArgs { objectNames?: InputMaybe>; } /** Response object for the smoketest operation. */ export interface SmoketestResponse { __typename?: 'SmoketestResponse'; /** Overall status message. */ message?: Maybe; /** Detailed results for each step. */ steps: Array; /** True if all steps of the smoketest succeeded. */ success: Scalars['Boolean']['output']; } /** Results for a single step in the smoketest. */ export interface SmoketestStep { __typename?: 'SmoketestStep'; /** Status message or error message for the step. */ message?: Maybe; /** Name of the step (e.g. 'Create Template'). */ name: Scalars['String']['output']; /** True if the step succeeded. */ success: Scalars['Boolean']['output']; } export enum SortOrder { /** Deliver values in ascending order */ Asc = 'asc', /** Deliver values in descending order */ Desc = 'desc' } export { StorageItemType }; /** Represents a Zabbix template. */ export interface Template { __typename?: 'Template'; /** Technical name of the template. */ host: Scalars['String']['output']; /** List of items for this template. */ items?: Maybe>; /** Name of the template. */ name?: Maybe; /** Internal Zabbix ID of the template. */ templateid: Scalars['String']['output']; } /** Represents a Zabbix user group. */ export interface UserGroup { __typename?: 'UserGroup'; /** Frontend access level. */ gui_access?: Maybe; /** Permissions for host groups. */ hostgroup_rights?: Maybe>; /** Name of the user group. */ name: Scalars['String']['output']; /** Permissions for template groups. */ templategroup_rights?: Maybe>; /** Status of users in the group. */ users_status?: Maybe; /** Internal Zabbix ID of the user group. */ usrgrpid: Scalars['Int']['output']; } /** Input for a user group. */ export interface UserGroupInput { /** Frontend access level. */ gui_access?: InputMaybe; /** Permissions for host groups. */ hostgroup_rights?: InputMaybe>; /** Name of the user group. */ name: Scalars['String']['input']; /** Permissions for template groups. */ templategroup_rights?: InputMaybe>; /** Status of the users in the group. */ users_status?: InputMaybe; } /** Represents a permission assigned to a user for a specific object. */ export interface UserPermission { __typename?: 'UserPermission'; /** * objectName maps to name / path suffix of the template group representing the permission in Zabbix: * Permissions/{objectName} */ objectName: Scalars['String']['output']; /** The assigned permission level. */ permission: Permission; } /** Represents the combined user rights (groups and roles). */ export interface UserRights { __typename?: 'UserRights'; /** List of user groups. */ userGroups?: Maybe>; /** List of user roles. */ userRoles?: Maybe>; } /** Input for importing user rights. */ export interface UserRightsInput { /** List of user groups to import. */ userGroups?: InputMaybe>; /** List of user roles to import. */ userRoles?: InputMaybe>; } /** Represents a Zabbix user role. */ export interface UserRole { __typename?: 'UserRole'; /** Name of the role. */ name?: Maybe; /** Whether the role is read-only. */ readonly?: Maybe; /** Internal Zabbix ID of the role. */ roleid: Scalars['Int']['output']; /** Rules assigned to the role. */ rules?: Maybe; /** Type of the role. */ type?: Maybe; } /** Input for a user role. */ export interface UserRoleInput { /** Name of the role. */ name?: InputMaybe; /** Whether the role is read-only (1) or not (0). */ readonly?: InputMaybe; /** Specific rules for the role. */ rules?: InputMaybe; /** Type of role (e.g. 1 for User, 2 for Admin, 3 for Super Admin). */ type?: InputMaybe; } /** Represents a module assigned to a user role. */ export interface UserRoleModule { __typename?: 'UserRoleModule'; /** Technical ID of the module. */ id?: Maybe; /** Internal Zabbix module ID. */ moduleid?: Maybe; /** Relative path to the module. */ relative_path?: Maybe; /** Status of the module. */ status?: Maybe; } /** Input for user role module access. */ export interface UserRoleModuleInput { /** Technical ID of the module. */ id?: InputMaybe; /** The internal Zabbix module ID. */ moduleid?: InputMaybe; /** Status of the module. */ status?: InputMaybe; } /** Represents a single rule within a user role. */ export interface UserRoleRule { __typename?: 'UserRoleRule'; /** Name of the rule. */ name?: Maybe; /** Status of the rule. */ status?: Maybe; } /** Input for a single user role rule. */ export interface UserRoleRuleInput { /** Name of the rule/element. */ name?: InputMaybe; /** Status (e.g. 1 for enabled, 0 for disabled). */ status?: InputMaybe; } /** Represents the rules assigned to a user role. */ export interface UserRoleRules { __typename?: 'UserRoleRules'; /** Action rules. */ actions?: Maybe>; /** Default access for actions. */ actions_default_access?: Maybe; /** List of API methods allowed/denied. */ api?: Maybe>; /** Whether API access is enabled. */ api_access?: Maybe; /** API mode. */ api_mode?: Maybe; /** Module access rules. */ modules?: Maybe>; /** Default access for modules. */ modules_default_access?: Maybe; /** UI access rules. */ ui?: Maybe>; /** Default access for UI elements. */ ui_default_access?: Maybe; } /** Input for user role rules. */ export interface UserRoleRulesInput { /** Action rules. */ actions?: InputMaybe>; /** Default access for actions. */ actions_default_access?: InputMaybe; /** List of API methods allowed/denied. */ api?: InputMaybe>; /** Whether API access is enabled (1) or not (0). */ api_access?: InputMaybe; /** API mode (e.g. 0 for white-list, 1 for black-list). */ api_mode?: InputMaybe; /** Module access rules. */ modules?: InputMaybe>; /** Default access for modules. */ modules_default_access?: InputMaybe; /** UI access rules. */ ui?: InputMaybe>; /** Default access for UI elements. */ ui_default_access?: InputMaybe; } /** Represents the configuration for a 4-field widget preview. */ export interface WidgetPreview { __typename?: 'WidgetPreview'; /** Bottom-left field specification. */ BOTTOM_LEFT?: Maybe; /** Bottom-right field specification. */ BOTTOM_RIGHT?: Maybe; /** Top-left field specification. */ TOP_LEFT?: Maybe; /** Top-right field specification. */ TOP_RIGHT?: Maybe; } /** Represents a specific permission right for a group. */ export interface ZabbixGroupRight { __typename?: 'ZabbixGroupRight'; /** ID of the group the right applies to. */ id: Scalars['Int']['output']; /** Name of the group. */ name?: Maybe; /** Assigned permission level. */ permission?: Maybe; /** Unique ID of the group. */ uuid?: Maybe; } /** Input for a Zabbix group permission right. */ export interface ZabbixGroupRightInput { /** * Name may optionally be specified for documentation purpose, * but the master for setting the user right is the uuid. */ name?: InputMaybe; /** The permission level to assign. */ permission?: InputMaybe; /** The unique ID of the group. */ uuid?: InputMaybe; } /** Concrete implementation of a Zabbix host. */ export interface ZabbixHost extends Host { __typename?: 'ZabbixHost'; /** * Specifies the type or category of the device. Used to define the classification * of a device in the system (capabilities, functionalities, or purpose). */ deviceType?: Maybe; /** Technical name of the host. */ host: Scalars['String']['output']; /** List of host groups this host belongs to. */ hostgroups?: Maybe>; /** Internal Zabbix ID of the host. */ hostid: Scalars['ID']['output']; /** Host inventory data. */ inventory?: Maybe; /** List of monitored items for this host. */ items?: Maybe>; /** Visible name of the host. */ name?: Maybe; /** List of templates linked to this host. */ parentTemplates?: Maybe>; /** Tags assigned to the host as a JSON object. */ tags?: Maybe; } /** Represents a Zabbix item (a single data point being monitored). */ export interface ZabbixItem { __typename?: 'ZabbixItem'; /** Attribute name if this item is part of a hierarchical mapping. */ attributeName?: Maybe; /** Update interval. */ delay?: Maybe; /** Description of the item. */ description?: Maybe; /** Error message if the item is in an error state. */ error?: Maybe; /** History storage period (e.g. '2d', '90d'). */ history?: Maybe; /** Internal Zabbix ID of the host this item belongs to. */ hostid?: Maybe; /** Hosts that this item is linked to. */ hosts?: Maybe>; /** Internal Zabbix ID of the item. */ itemid: Scalars['Int']['output']; /** Technical key of the item. */ key_: Scalars['String']['output']; /** Unix timestamp of the last time the item value was updated. */ lastclock?: Maybe; /** Last value retrieved for this item. */ lastvalue?: Maybe; /** Master item for dependent items. */ master_item?: Maybe; /** Master item ID for dependent items. */ master_itemid?: Maybe; /** Visible name of the item. */ name: Scalars['String']['output']; /** Preprocessing steps for the item. */ preprocessing?: Maybe>; /** Status of the item (ENABLED or DISABLED). */ status?: Maybe; /** Raw Zabbix item status as integer. */ status_int?: Maybe; /** Tags assigned to the item. */ tags?: Maybe>; /** Communication type used by the item. */ type?: Maybe; /** Raw Zabbix item type as integer. */ type_int?: Maybe; /** Units of the value. */ units?: Maybe; /** Type of information (e.g. 0 for Float, 3 for Int, 4 for Text). */ value_type: Scalars['Int']['output']; } export type ResolverTypeWrapper = Promise | T; export type ResolverWithResolve = { resolve: ResolverFn; }; export type Resolver = ResolverFn | ResolverWithResolve; export type ResolverFn = ( parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo ) => Promise | TResult; export type SubscriptionSubscribeFn = ( parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo ) => AsyncIterable | Promise>; export type SubscriptionResolveFn = ( parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo ) => TResult | Promise; export interface SubscriptionSubscriberObject { subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>; resolve?: SubscriptionResolveFn; } export interface SubscriptionResolverObject { subscribe: SubscriptionSubscribeFn; resolve: SubscriptionResolveFn; } export type SubscriptionObject = | SubscriptionSubscriberObject | SubscriptionResolverObject; export type SubscriptionResolver = | ((...args: any[]) => SubscriptionObject) | SubscriptionObject; export type TypeResolveFn = ( parent: TParent, context: TContext, info: GraphQLResolveInfo ) => Maybe | Promise>; export type IsTypeOfResolverFn = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise; export type NextResolverFn = () => Promise; export type DirectiveResolverFn = ( next: NextResolverFn, parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo ) => TResult | Promise; /** Mapping of interface types */ export type ResolversInterfaceTypes<_RefType extends Record> = { Device: ( Omit & { items?: Maybe> } ); DeviceState: ( GenericDeviceState ); DeviceValue: never; DeviceValueMessage: never; Error: ( ApiError ); GpsPosition: ( Location ); Host: ( Omit & { items?: Maybe> } ) | ( Omit & { items?: Maybe>, parentTemplates?: Maybe> } ); }; /** Mapping between all available schema types and the resolvers types */ export type ResolversTypes = { ApiError: ResolverTypeWrapper; Boolean: ResolverTypeWrapper; CreateHost: CreateHost; CreateHostGroup: CreateHostGroup; CreateHostGroupResponse: ResolverTypeWrapper; CreateHostResponse: ResolverTypeWrapper; CreateItemPreprocessing: CreateItemPreprocessing; CreateLinkedTemplate: CreateLinkedTemplate; CreateMacro: CreateMacro; CreateMasterItem: CreateMasterItem; CreateTag: CreateTag; CreateTemplate: CreateTemplate; CreateTemplateGroup: CreateTemplateGroup; CreateTemplateGroupResponse: ResolverTypeWrapper; CreateTemplateItem: CreateTemplateItem; DateTime: ResolverTypeWrapper; DeleteResponse: ResolverTypeWrapper; Device: ResolverTypeWrapper['Device']>; DeviceCommunicationType: DeviceCommunicationType; DeviceConfig: ResolverTypeWrapper; DeviceState: ResolverTypeWrapper['DeviceState']>; DeviceStatus: DeviceStatus; DeviceValue: ResolverTypeWrapper['DeviceValue']>; DeviceValueMessage: ResolverTypeWrapper['DeviceValueMessage']>; DisplayFieldSpec: ResolverTypeWrapper; Error: ResolverTypeWrapper['Error']>; ErrorPayload: ResolverTypeWrapper; Float: ResolverTypeWrapper; GenericDevice: ResolverTypeWrapper & { items?: Maybe> }>; GenericDeviceState: ResolverTypeWrapper; GenericResponse: ResolverTypeWrapper; GpsPosition: ResolverTypeWrapper['GpsPosition']>; Host: ResolverTypeWrapper['Host']>; HostGroup: ResolverTypeWrapper; ID: ResolverTypeWrapper; ImportHostResponse: ResolverTypeWrapper; ImportTemplateResponse: ResolverTypeWrapper; ImportUserRightResult: ResolverTypeWrapper; ImportUserRightsResult: ResolverTypeWrapper; Int: ResolverTypeWrapper; Inventory: ResolverTypeWrapper; JSONObject: ResolverTypeWrapper; Location: ResolverTypeWrapper; LocationInput: LocationInput; Mutation: ResolverTypeWrapper<{}>; OperationalDeviceData: ResolverTypeWrapper; Permission: Permission; PermissionRequest: PermissionRequest; Query: ResolverTypeWrapper<{}>; SmoketestResponse: ResolverTypeWrapper; SmoketestStep: ResolverTypeWrapper; SortOrder: SortOrder; StorageItemType: StorageItemType; String: ResolverTypeWrapper; Template: ResolverTypeWrapper & { items?: Maybe> }>; Time: ResolverTypeWrapper; UserGroup: ResolverTypeWrapper; UserGroupInput: UserGroupInput; UserPermission: ResolverTypeWrapper; UserRights: ResolverTypeWrapper; UserRightsInput: UserRightsInput; UserRole: ResolverTypeWrapper; UserRoleInput: UserRoleInput; UserRoleModule: ResolverTypeWrapper; UserRoleModuleInput: UserRoleModuleInput; UserRoleRule: ResolverTypeWrapper; UserRoleRuleInput: UserRoleRuleInput; UserRoleRules: ResolverTypeWrapper; UserRoleRulesInput: UserRoleRulesInput; WidgetPreview: ResolverTypeWrapper; ZabbixGroupRight: ResolverTypeWrapper; ZabbixGroupRightInput: ZabbixGroupRightInput; ZabbixHost: ResolverTypeWrapper & { items?: Maybe>, parentTemplates?: Maybe> }>; ZabbixItem: ResolverTypeWrapper & { hosts?: Maybe>, master_item?: Maybe }>; }; /** Mapping between all available schema types and the resolvers parents */ export type ResolversParentTypes = { ApiError: ApiError; Boolean: Scalars['Boolean']['output']; CreateHost: CreateHost; CreateHostGroup: CreateHostGroup; CreateHostGroupResponse: CreateHostGroupResponse; CreateHostResponse: CreateHostResponse; CreateItemPreprocessing: CreateItemPreprocessing; CreateLinkedTemplate: CreateLinkedTemplate; CreateMacro: CreateMacro; CreateMasterItem: CreateMasterItem; CreateTag: CreateTag; CreateTemplate: CreateTemplate; CreateTemplateGroup: CreateTemplateGroup; CreateTemplateGroupResponse: CreateTemplateGroupResponse; CreateTemplateItem: CreateTemplateItem; DateTime: Scalars['DateTime']['output']; DeleteResponse: DeleteResponse; Device: ResolversInterfaceTypes['Device']; DeviceConfig: DeviceConfig; DeviceState: ResolversInterfaceTypes