1150 lines
52 KiB
TypeScript
1150 lines
52 KiB
TypeScript
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> = T | null;
|
|
export type InputMaybe<T> = Maybe<T>;
|
|
export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
|
|
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
|
|
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
|
|
export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
|
|
export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
|
|
export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
|
|
export type EnumResolverSignature<T, AllowedValues = any> = { [key in keyof T]?: AllowedValues };
|
|
export type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> };
|
|
/** 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; }
|
|
}
|
|
|
|
export interface ApiError extends Error {
|
|
__typename?: 'ApiError';
|
|
args?: Maybe<Scalars['JSONObject']['output']>;
|
|
code?: Maybe<Scalars['Int']['output']>;
|
|
data?: Maybe<Scalars['JSONObject']['output']>;
|
|
message?: Maybe<Scalars['String']['output']>;
|
|
path?: Maybe<Scalars['String']['output']>;
|
|
}
|
|
|
|
export interface CreateHost {
|
|
deviceKey: Scalars['String']['input'];
|
|
deviceType: Scalars['String']['input'];
|
|
/**
|
|
* groupNames is used to assign the created object
|
|
* to a host group. It is mandatory but
|
|
* can also be blank. This is usefull in case of
|
|
* passing a groupid instead which is
|
|
* the zabbix internal key for storing the group.
|
|
* If a groupid is provided the passed groupName is ignored
|
|
*/
|
|
groupNames: Array<Scalars['String']['input']>;
|
|
/**
|
|
* Optionally the internal groupids can be passed - in this case the
|
|
* groupName is ignored
|
|
*/
|
|
groupids?: InputMaybe<Array<InputMaybe<Scalars['Int']['input']>>>;
|
|
location?: InputMaybe<LocationInput>;
|
|
/** Optional display name of the device (must be unique if provided - default is to set display name to deviceKey) */
|
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
}
|
|
|
|
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<Scalars['String']['input']>;
|
|
}
|
|
|
|
export interface CreateHostGroupResponse {
|
|
__typename?: 'CreateHostGroupResponse';
|
|
error?: Maybe<ApiError>;
|
|
groupName: Scalars['String']['output'];
|
|
groupid?: Maybe<Scalars['Int']['output']>;
|
|
message?: Maybe<Scalars['String']['output']>;
|
|
}
|
|
|
|
export interface CreateHostResponse {
|
|
__typename?: 'CreateHostResponse';
|
|
deviceKey: Scalars['String']['output'];
|
|
error?: Maybe<ApiError>;
|
|
hostid?: Maybe<Scalars['String']['output']>;
|
|
message?: Maybe<Scalars['String']['output']>;
|
|
}
|
|
|
|
/**
|
|
* (IoT / Edge - ) Devices are hosts having a state containing the "output" / the business data which is exposed
|
|
* besides monitoring information.
|
|
*/
|
|
export interface Device {
|
|
deviceType?: Maybe<Scalars['String']['output']>;
|
|
/** Per convention a uuid is used as hostname to identify devices if they do not have a unique hostname */
|
|
host: Scalars['String']['output'];
|
|
hostgroups?: Maybe<Array<HostGroup>>;
|
|
hostid: Scalars['ID']['output'];
|
|
name?: Maybe<Scalars['String']['output']>;
|
|
state?: Maybe<DeviceState>;
|
|
tags?: Maybe<Scalars['JSONObject']['output']>;
|
|
}
|
|
|
|
export { DeviceCommunicationType };
|
|
|
|
export interface DeviceState {
|
|
operational?: Maybe<OperationalDeviceData>;
|
|
}
|
|
|
|
export { DeviceStatus };
|
|
|
|
export interface Error {
|
|
code?: Maybe<Scalars['Int']['output']>;
|
|
data?: Maybe<Scalars['JSONObject']['output']>;
|
|
message?: Maybe<Scalars['String']['output']>;
|
|
}
|
|
|
|
export interface ErrorPayload {
|
|
__typename?: 'ErrorPayload';
|
|
additionalInfo?: Maybe<Scalars['JSONObject']['output']>;
|
|
code: Scalars['Int']['output'];
|
|
message?: Maybe<Scalars['String']['output']>;
|
|
}
|
|
|
|
/** Device represents generic IoT / Edge - devices providing their state as generic "state.current" - JSON Object */
|
|
export interface GenericDevice extends Device, Host {
|
|
__typename?: 'GenericDevice';
|
|
deviceType?: Maybe<Scalars['String']['output']>;
|
|
/** Per convention a uuid is used as hostname to identify devices if they do not have a unique hostname */
|
|
host: Scalars['String']['output'];
|
|
hostgroups?: Maybe<Array<HostGroup>>;
|
|
hostid: Scalars['ID']['output'];
|
|
name?: Maybe<Scalars['String']['output']>;
|
|
state?: Maybe<GenericDeviceState>;
|
|
tags?: Maybe<Scalars['JSONObject']['output']>;
|
|
}
|
|
|
|
export interface GenericDeviceState extends DeviceState {
|
|
__typename?: 'GenericDeviceState';
|
|
current?: Maybe<Scalars['JSONObject']['output']>;
|
|
operational?: Maybe<OperationalDeviceData>;
|
|
}
|
|
|
|
/** Hint: WGS84[dd.ddddd] coordinates are used */
|
|
export interface GpsPosition {
|
|
latitude?: Maybe<Scalars['Float']['output']>;
|
|
longitude?: Maybe<Scalars['Float']['output']>;
|
|
}
|
|
|
|
export interface HistoryExportResponse {
|
|
__typename?: 'HistoryExportResponse';
|
|
error?: Maybe<ApiError>;
|
|
result?: Maybe<Array<Scalars['JSONObject']['output']>>;
|
|
}
|
|
|
|
export interface Host {
|
|
deviceType?: Maybe<Scalars['String']['output']>;
|
|
/** The host field contains the "hostname" in Zabbix */
|
|
host: Scalars['String']['output'];
|
|
hostgroups?: Maybe<Array<HostGroup>>;
|
|
hostid: Scalars['ID']['output'];
|
|
name?: Maybe<Scalars['String']['output']>;
|
|
tags?: Maybe<Scalars['JSONObject']['output']>;
|
|
}
|
|
|
|
export interface HostGroup {
|
|
__typename?: 'HostGroup';
|
|
groupid: Scalars['ID']['output'];
|
|
name?: Maybe<Scalars['String']['output']>;
|
|
}
|
|
|
|
export interface HostTypeMeta {
|
|
__typename?: 'HostTypeMeta';
|
|
deviceType?: Maybe<Scalars['String']['output']>;
|
|
deviceTypeDescription?: Maybe<Scalars['String']['output']>;
|
|
}
|
|
|
|
export interface ImportUserRightResult {
|
|
__typename?: 'ImportUserRightResult';
|
|
errors?: Maybe<Array<ApiError>>;
|
|
id?: Maybe<Scalars['String']['output']>;
|
|
message?: Maybe<Scalars['String']['output']>;
|
|
name?: Maybe<Scalars['String']['output']>;
|
|
}
|
|
|
|
export interface ImportUserRightsResult {
|
|
__typename?: 'ImportUserRightsResult';
|
|
userGroups?: Maybe<Array<ImportUserRightResult>>;
|
|
userRoles?: Maybe<Array<ImportUserRightResult>>;
|
|
}
|
|
|
|
export interface Inventory {
|
|
__typename?: 'Inventory';
|
|
location?: Maybe<Location>;
|
|
}
|
|
|
|
export interface Item {
|
|
__typename?: 'Item';
|
|
attributeName?: Maybe<Scalars['String']['output']>;
|
|
deviceType?: Maybe<Scalars['String']['output']>;
|
|
hostid?: Maybe<Scalars['Int']['output']>;
|
|
hosts?: Maybe<Array<Maybe<Host>>>;
|
|
itemid?: Maybe<Scalars['Int']['output']>;
|
|
key_?: Maybe<Scalars['String']['output']>;
|
|
name: Scalars['String']['output'];
|
|
status?: Maybe<DeviceStatus>;
|
|
topicType?: Maybe<Scalars['String']['output']>;
|
|
type?: Maybe<DeviceCommunicationType>;
|
|
}
|
|
|
|
export interface Location extends GpsPosition {
|
|
__typename?: 'Location';
|
|
latitude?: Maybe<Scalars['Float']['output']>;
|
|
longitude?: Maybe<Scalars['Float']['output']>;
|
|
name?: Maybe<Scalars['String']['output']>;
|
|
}
|
|
|
|
export interface LocationInput {
|
|
location_lat?: InputMaybe<Scalars['String']['input']>;
|
|
location_lon?: InputMaybe<Scalars['String']['input']>;
|
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
}
|
|
|
|
export interface Mutation {
|
|
__typename?: 'Mutation';
|
|
/** Authentication: By zbx_session - cookie or zabbix-auth-token - header */
|
|
createHost?: Maybe<ZabbixCreateResponse>;
|
|
/**
|
|
* (Mass) Import zabbix groups
|
|
* and assign them to the corresponding hosts by groupid or groupName.
|
|
*
|
|
* Return value: If no error occurs a groupid be returned for each created group,
|
|
* otherwise the return object will contain an error message
|
|
*
|
|
* Authentication: By zbx_session - cookie or zabbix-auth-token - header
|
|
*/
|
|
importHostGroups?: Maybe<Array<CreateHostGroupResponse>>;
|
|
/**
|
|
* (Mass) Import hosts and assign them to host groups by groupid or groupName.
|
|
*
|
|
* Return value: If no error occurs a hostid will be returned for each created host,
|
|
* otherwise the return object will contain an error message.
|
|
*
|
|
* Authentication: By zbx_session - cookie or zabbix-auth-token - header
|
|
*/
|
|
importHosts?: Maybe<Array<CreateHostResponse>>;
|
|
importUserRights?: Maybe<ImportUserRightsResult>;
|
|
}
|
|
|
|
|
|
export interface MutationCreateHostArgs {
|
|
host: Scalars['String']['input'];
|
|
hostgroupids: Array<Scalars['Int']['input']>;
|
|
location?: InputMaybe<LocationInput>;
|
|
templateids: Array<Scalars['Int']['input']>;
|
|
}
|
|
|
|
|
|
export interface MutationImportHostGroupsArgs {
|
|
hostGroups: Array<CreateHostGroup>;
|
|
}
|
|
|
|
|
|
export interface MutationImportHostsArgs {
|
|
hosts: Array<CreateHost>;
|
|
}
|
|
|
|
|
|
export interface MutationImportUserRightsArgs {
|
|
dryRun?: Scalars['Boolean']['input'];
|
|
input: UserRightsInput;
|
|
}
|
|
|
|
export interface OperationalDeviceData {
|
|
__typename?: 'OperationalDeviceData';
|
|
error?: Maybe<Array<ErrorPayload>>;
|
|
location?: Maybe<Location>;
|
|
signalstrength?: Maybe<Scalars['Float']['output']>;
|
|
temperature?: Maybe<Scalars['Float']['output']>;
|
|
timestamp?: Maybe<Scalars['DateTime']['output']>;
|
|
voltage?: Maybe<Scalars['Float']['output']>;
|
|
}
|
|
|
|
export { Permission };
|
|
|
|
export interface PermissionRequest {
|
|
/**
|
|
* objectName maps to name / path suffix of the template group representing the permission in Zabbix:
|
|
* Permissions/{objectName}
|
|
*/
|
|
objectName: Scalars['String']['input'];
|
|
permission: Permission;
|
|
}
|
|
|
|
export interface Query {
|
|
__typename?: 'Query';
|
|
/**
|
|
* Get all host groups.
|
|
* If with_hosts==true only groups with attached hosts are delivered.
|
|
*
|
|
* Authentication: By zbx_session - cookie or zabbix-auth-token - header
|
|
*/
|
|
allHostGroups?: Maybe<Array<Maybe<HostGroup>>>;
|
|
/**
|
|
* Get all hosts + corresponding items. If with_items==true only hosts with attached items are delivered
|
|
* name_pattern: If provided this will perform a LIKE "%…%" search on the name attribute within the database.
|
|
*
|
|
* Authentication: By zbx_session - cookie or zabbix-auth-token - header
|
|
*/
|
|
allHosts?: Maybe<Array<Maybe<Host>>>;
|
|
/** Get api (build) version */
|
|
apiVersion: Scalars['String']['output'];
|
|
/**
|
|
* Export history from Zabbix items
|
|
*
|
|
* Authentication: By zbx_session - cookie or zabbix-auth-token - header
|
|
*/
|
|
exportHostValueHistory?: Maybe<HistoryExportResponse>;
|
|
/**
|
|
* name_pattern: If provided this will perform a LIKE "%…%" search on the name attribute within the database.
|
|
* exclude_groups_pattern: Regex allowing to exclude all matching hostgroups from group permissions
|
|
*/
|
|
exportUserRights?: Maybe<UserRights>;
|
|
/**
|
|
* Return true if and only if the current user (identified by token / cookie)
|
|
* has all requested permissions (minimum - if READ is requested and the user has READ_WRITE
|
|
* the response will be true)
|
|
*/
|
|
hasPermissions?: Maybe<Scalars['Boolean']['output']>;
|
|
/**
|
|
* Get all locations used by hosts.
|
|
* distinct_by_name=true means that the result is filtered for distinct names (default)
|
|
* name_pattern: If provided this will perform a Regex search on the name attribute within the database.
|
|
*
|
|
* Authentication: By zbx_session - cookie or zabbix-auth-token - header
|
|
*/
|
|
locations?: Maybe<Array<Maybe<Location>>>;
|
|
/**
|
|
* Login to zabbix - provided for debugging and testing purpose. The result of the login operation is
|
|
* authentication token returned may be passed as
|
|
* header 'zabbix-auth-token' for authenticating future API requests.
|
|
* As an alternative to the cookie 'zbx_session' may be set which is automatically set after login to
|
|
* the cockpit - this is the standard way to authenticate api calls initiated by the cockpit frontend
|
|
* because the frontend is always embedded into the Zabbix portal which is only accessible after logging in and
|
|
* obtainind the zbx_session - cookie.
|
|
*/
|
|
login?: Maybe<Scalars['String']['output']>;
|
|
/**
|
|
* Logout from zabbix - provided for debugging and testing purpose. This invalidates the token received by the login
|
|
* operation. Returns true on success
|
|
*/
|
|
logout?: Maybe<Scalars['Boolean']['output']>;
|
|
/**
|
|
* Return all user permissions. If objectNames is provided return only the permissions related to the objects within
|
|
* the objectNames - list
|
|
*/
|
|
userPermissions?: Maybe<Array<UserPermission>>;
|
|
/** Get zabbix version */
|
|
zabbixVersion?: Maybe<Scalars['String']['output']>;
|
|
}
|
|
|
|
|
|
export interface QueryAllHostGroupsArgs {
|
|
search_name?: InputMaybe<Scalars['String']['input']>;
|
|
with_hosts?: InputMaybe<Scalars['Boolean']['input']>;
|
|
}
|
|
|
|
|
|
export interface QueryAllHostsArgs {
|
|
filter_host?: InputMaybe<Scalars['String']['input']>;
|
|
groupids?: InputMaybe<Array<Scalars['Int']['input']>>;
|
|
hostids?: InputMaybe<Scalars['Int']['input']>;
|
|
name_pattern?: InputMaybe<Scalars['String']['input']>;
|
|
tag_deviceType?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
|
|
tag_hostType?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
with_items?: InputMaybe<Scalars['Boolean']['input']>;
|
|
}
|
|
|
|
|
|
export interface QueryExportHostValueHistoryArgs {
|
|
host_filter?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
itemKey_filter?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
sortOrder?: InputMaybe<SortOrder>;
|
|
time_from?: InputMaybe<Scalars['DateTime']['input']>;
|
|
time_until?: InputMaybe<Scalars['DateTime']['input']>;
|
|
type?: InputMaybe<StorageItemType>;
|
|
}
|
|
|
|
|
|
export interface QueryExportUserRightsArgs {
|
|
exclude_hostgroups_pattern?: InputMaybe<Scalars['String']['input']>;
|
|
name_pattern?: InputMaybe<Scalars['String']['input']>;
|
|
}
|
|
|
|
|
|
export interface QueryHasPermissionsArgs {
|
|
permissions: Array<PermissionRequest>;
|
|
}
|
|
|
|
|
|
export interface QueryLocationsArgs {
|
|
distinct_by_name?: InputMaybe<Scalars['Boolean']['input']>;
|
|
name_pattern?: InputMaybe<Scalars['String']['input']>;
|
|
templateids?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
|
|
}
|
|
|
|
|
|
export interface QueryLoginArgs {
|
|
password: Scalars['String']['input'];
|
|
username: Scalars['String']['input'];
|
|
}
|
|
|
|
|
|
export interface QueryUserPermissionsArgs {
|
|
objectNames?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
}
|
|
|
|
export enum SensorValueType {
|
|
Character = 'CHARACTER',
|
|
Log = 'LOG',
|
|
Numeric = 'NUMERIC',
|
|
NumericUnsigned = 'NUMERIC_UNSIGNED',
|
|
Text = 'TEXT'
|
|
}
|
|
|
|
export enum SortOrder {
|
|
/** Deliver values in ascending order */
|
|
Asc = 'asc',
|
|
/** Deliver values in descending order */
|
|
Desc = 'desc'
|
|
}
|
|
|
|
export { StorageItemType };
|
|
|
|
export interface Template {
|
|
__typename?: 'Template';
|
|
name?: Maybe<Scalars['String']['output']>;
|
|
templateid: Scalars['String']['output'];
|
|
}
|
|
|
|
export interface UserGroup {
|
|
__typename?: 'UserGroup';
|
|
gui_access?: Maybe<Scalars['Int']['output']>;
|
|
hostgroup_rights?: Maybe<Array<ZabbixGroupRight>>;
|
|
name: Scalars['String']['output'];
|
|
templategroup_rights?: Maybe<Array<ZabbixGroupRight>>;
|
|
users_status?: Maybe<Scalars['Int']['output']>;
|
|
usrgrpid: Scalars['Int']['output'];
|
|
}
|
|
|
|
export interface UserGroupInput {
|
|
gui_access?: InputMaybe<Scalars['Int']['input']>;
|
|
hostgroup_rights?: InputMaybe<Array<ZabbixGroupRightInput>>;
|
|
name: Scalars['String']['input'];
|
|
templategroup_rights?: InputMaybe<Array<ZabbixGroupRightInput>>;
|
|
users_status?: InputMaybe<Scalars['Int']['input']>;
|
|
}
|
|
|
|
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'];
|
|
permission: Permission;
|
|
}
|
|
|
|
export interface UserRights {
|
|
__typename?: 'UserRights';
|
|
userGroups?: Maybe<Array<UserGroup>>;
|
|
userRoles?: Maybe<Array<UserRole>>;
|
|
}
|
|
|
|
export interface UserRightsInput {
|
|
userGroups?: InputMaybe<Array<UserGroupInput>>;
|
|
userRoles?: InputMaybe<Array<UserRoleInput>>;
|
|
}
|
|
|
|
export interface UserRole {
|
|
__typename?: 'UserRole';
|
|
name?: Maybe<Scalars['String']['output']>;
|
|
readonly?: Maybe<Scalars['Int']['output']>;
|
|
roleid: Scalars['Int']['output'];
|
|
rules?: Maybe<UserRoleRules>;
|
|
type?: Maybe<Scalars['Int']['output']>;
|
|
}
|
|
|
|
export interface UserRoleInput {
|
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
readonly?: InputMaybe<Scalars['Int']['input']>;
|
|
rules?: InputMaybe<UserRoleRulesInput>;
|
|
type?: InputMaybe<Scalars['Int']['input']>;
|
|
}
|
|
|
|
export interface UserRoleModule {
|
|
__typename?: 'UserRoleModule';
|
|
id?: Maybe<Scalars['String']['output']>;
|
|
moduleid?: Maybe<Scalars['String']['output']>;
|
|
relative_path?: Maybe<Scalars['String']['output']>;
|
|
status?: Maybe<Scalars['Int']['output']>;
|
|
}
|
|
|
|
export interface UserRoleModuleInput {
|
|
id?: InputMaybe<Scalars['String']['input']>;
|
|
moduleid?: InputMaybe<Scalars['String']['input']>;
|
|
status?: InputMaybe<Scalars['Int']['input']>;
|
|
}
|
|
|
|
export interface UserRoleRule {
|
|
__typename?: 'UserRoleRule';
|
|
name?: Maybe<Scalars['String']['output']>;
|
|
status?: Maybe<Scalars['Int']['output']>;
|
|
}
|
|
|
|
export interface UserRoleRuleInput {
|
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
status?: InputMaybe<Scalars['Int']['input']>;
|
|
}
|
|
|
|
export interface UserRoleRules {
|
|
__typename?: 'UserRoleRules';
|
|
actions?: Maybe<Array<UserRoleRule>>;
|
|
actions_default_access?: Maybe<Scalars['Int']['output']>;
|
|
api?: Maybe<Array<Scalars['String']['output']>>;
|
|
api_access?: Maybe<Scalars['Int']['output']>;
|
|
api_mode?: Maybe<Scalars['Int']['output']>;
|
|
modules?: Maybe<Array<UserRoleModule>>;
|
|
modules_default_access?: Maybe<Scalars['Int']['output']>;
|
|
ui?: Maybe<Array<UserRoleRule>>;
|
|
ui_default_access?: Maybe<Scalars['Int']['output']>;
|
|
}
|
|
|
|
export interface UserRoleRulesInput {
|
|
actions?: InputMaybe<Array<UserRoleRuleInput>>;
|
|
actions_default_access?: InputMaybe<Scalars['Int']['input']>;
|
|
api?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
api_access?: InputMaybe<Scalars['Int']['input']>;
|
|
api_mode?: InputMaybe<Scalars['Int']['input']>;
|
|
modules?: InputMaybe<Array<UserRoleModuleInput>>;
|
|
modules_default_access?: InputMaybe<Scalars['Int']['input']>;
|
|
ui?: InputMaybe<Array<UserRoleRuleInput>>;
|
|
ui_default_access?: InputMaybe<Scalars['Int']['input']>;
|
|
}
|
|
|
|
export interface ZabbixCreateResponse {
|
|
__typename?: 'ZabbixCreateResponse';
|
|
error?: Maybe<ApiError>;
|
|
hostids?: Maybe<Array<Maybe<Scalars['Int']['output']>>>;
|
|
itemids?: Maybe<Array<Maybe<Scalars['Int']['output']>>>;
|
|
}
|
|
|
|
export interface ZabbixGroupRight {
|
|
__typename?: 'ZabbixGroupRight';
|
|
id: Scalars['Int']['output'];
|
|
name?: Maybe<Scalars['String']['output']>;
|
|
permission?: Maybe<Permission>;
|
|
uuid?: Maybe<Scalars['String']['output']>;
|
|
}
|
|
|
|
export interface ZabbixGroupRightInput {
|
|
/**
|
|
* name may optionally be specified for documentation purpose,
|
|
* but the master for setting the user right is the uuid.
|
|
* If a uuid is found and the corresponding group
|
|
* has a deviating name this will be documented within a message
|
|
* with errorcode = 0 (OK) but the permission will be set (
|
|
* the reason is that names for groups may deviate between several
|
|
* instances of the control center although the semantic is the same -
|
|
* while the semantic is identified by uuid.
|
|
*/
|
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
permission?: InputMaybe<Permission>;
|
|
uuid?: InputMaybe<Scalars['String']['input']>;
|
|
}
|
|
|
|
export interface ZabbixHost extends Host {
|
|
__typename?: 'ZabbixHost';
|
|
deviceType?: Maybe<Scalars['String']['output']>;
|
|
host: Scalars['String']['output'];
|
|
hostgroups?: Maybe<Array<HostGroup>>;
|
|
hostid: Scalars['ID']['output'];
|
|
inventory?: Maybe<Inventory>;
|
|
items?: Maybe<Array<ZabbixItem>>;
|
|
name?: Maybe<Scalars['String']['output']>;
|
|
parentTemplates?: Maybe<Array<Template>>;
|
|
tags?: Maybe<Scalars['JSONObject']['output']>;
|
|
}
|
|
|
|
export interface ZabbixItem {
|
|
__typename?: 'ZabbixItem';
|
|
attributeName?: Maybe<Scalars['String']['output']>;
|
|
deviceType?: Maybe<Scalars['String']['output']>;
|
|
hostid?: Maybe<Scalars['Int']['output']>;
|
|
hosts?: Maybe<Array<Maybe<Host>>>;
|
|
itemid: Scalars['Int']['output'];
|
|
key_: Scalars['String']['output'];
|
|
lastclock?: Maybe<Scalars['Int']['output']>;
|
|
lastvalue?: Maybe<Scalars['String']['output']>;
|
|
name: Scalars['String']['output'];
|
|
status?: Maybe<DeviceStatus>;
|
|
topicType?: Maybe<Scalars['String']['output']>;
|
|
type?: Maybe<DeviceCommunicationType>;
|
|
value_type: Scalars['Int']['output'];
|
|
}
|
|
|
|
|
|
|
|
export type ResolverTypeWrapper<T> = Promise<T> | T;
|
|
|
|
|
|
export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
|
|
resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
|
|
};
|
|
export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs>;
|
|
|
|
export type ResolverFn<TResult, TParent, TContext, TArgs> = (
|
|
parent: TParent,
|
|
args: TArgs,
|
|
context: TContext,
|
|
info: GraphQLResolveInfo
|
|
) => Promise<TResult> | TResult;
|
|
|
|
export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
|
|
parent: TParent,
|
|
args: TArgs,
|
|
context: TContext,
|
|
info: GraphQLResolveInfo
|
|
) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;
|
|
|
|
export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
|
|
parent: TParent,
|
|
args: TArgs,
|
|
context: TContext,
|
|
info: GraphQLResolveInfo
|
|
) => TResult | Promise<TResult>;
|
|
|
|
export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
|
|
subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>;
|
|
resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>;
|
|
}
|
|
|
|
export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
|
|
subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
|
|
resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
|
|
}
|
|
|
|
export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> =
|
|
| SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
|
|
| SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
|
|
|
|
export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> =
|
|
| ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
|
|
| SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
|
|
|
|
export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
|
|
parent: TParent,
|
|
context: TContext,
|
|
info: GraphQLResolveInfo
|
|
) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
|
|
|
|
export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
|
|
|
|
export type NextResolverFn<T> = () => Promise<T>;
|
|
|
|
export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
|
|
next: NextResolverFn<TResult>,
|
|
parent: TParent,
|
|
args: TArgs,
|
|
context: TContext,
|
|
info: GraphQLResolveInfo
|
|
) => TResult | Promise<TResult>;
|
|
|
|
|
|
/** Mapping of interface types */
|
|
export type ResolversInterfaceTypes<_RefType extends Record<string, unknown>> = {
|
|
Device: ( GenericDevice );
|
|
DeviceState: ( GenericDeviceState );
|
|
Error: ( ApiError );
|
|
GpsPosition: ( Location );
|
|
Host: ( GenericDevice ) | ( Omit<ZabbixHost, 'items'> & { items?: Maybe<Array<_RefType['ZabbixItem']>> } );
|
|
};
|
|
|
|
/** Mapping between all available schema types and the resolvers types */
|
|
export type ResolversTypes = {
|
|
ApiError: ResolverTypeWrapper<ApiError>;
|
|
Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>;
|
|
CreateHost: CreateHost;
|
|
CreateHostGroup: CreateHostGroup;
|
|
CreateHostGroupResponse: ResolverTypeWrapper<CreateHostGroupResponse>;
|
|
CreateHostResponse: ResolverTypeWrapper<CreateHostResponse>;
|
|
DateTime: ResolverTypeWrapper<Scalars['DateTime']['output']>;
|
|
Device: ResolverTypeWrapper<ResolversInterfaceTypes<ResolversTypes>['Device']>;
|
|
DeviceCommunicationType: DeviceCommunicationType;
|
|
DeviceState: ResolverTypeWrapper<ResolversInterfaceTypes<ResolversTypes>['DeviceState']>;
|
|
DeviceStatus: DeviceStatus;
|
|
Error: ResolverTypeWrapper<ResolversInterfaceTypes<ResolversTypes>['Error']>;
|
|
ErrorPayload: ResolverTypeWrapper<ErrorPayload>;
|
|
Float: ResolverTypeWrapper<Scalars['Float']['output']>;
|
|
GenericDevice: ResolverTypeWrapper<GenericDevice>;
|
|
GenericDeviceState: ResolverTypeWrapper<GenericDeviceState>;
|
|
GpsPosition: ResolverTypeWrapper<ResolversInterfaceTypes<ResolversTypes>['GpsPosition']>;
|
|
HistoryExportResponse: ResolverTypeWrapper<HistoryExportResponse>;
|
|
Host: ResolverTypeWrapper<ResolversInterfaceTypes<ResolversTypes>['Host']>;
|
|
HostGroup: ResolverTypeWrapper<HostGroup>;
|
|
HostTypeMeta: ResolverTypeWrapper<HostTypeMeta>;
|
|
ID: ResolverTypeWrapper<Scalars['ID']['output']>;
|
|
ImportUserRightResult: ResolverTypeWrapper<ImportUserRightResult>;
|
|
ImportUserRightsResult: ResolverTypeWrapper<ImportUserRightsResult>;
|
|
Int: ResolverTypeWrapper<Scalars['Int']['output']>;
|
|
Inventory: ResolverTypeWrapper<Inventory>;
|
|
Item: ResolverTypeWrapper<Omit<Item, 'hosts'> & { hosts?: Maybe<Array<Maybe<ResolversTypes['Host']>>> }>;
|
|
JSONObject: ResolverTypeWrapper<Scalars['JSONObject']['output']>;
|
|
Location: ResolverTypeWrapper<Location>;
|
|
LocationInput: LocationInput;
|
|
Mutation: ResolverTypeWrapper<{}>;
|
|
OperationalDeviceData: ResolverTypeWrapper<OperationalDeviceData>;
|
|
Permission: Permission;
|
|
PermissionRequest: PermissionRequest;
|
|
Query: ResolverTypeWrapper<{}>;
|
|
SensorValueType: SensorValueType;
|
|
SortOrder: SortOrder;
|
|
StorageItemType: StorageItemType;
|
|
String: ResolverTypeWrapper<Scalars['String']['output']>;
|
|
Template: ResolverTypeWrapper<Template>;
|
|
Time: ResolverTypeWrapper<Scalars['Time']['output']>;
|
|
UserGroup: ResolverTypeWrapper<UserGroup>;
|
|
UserGroupInput: UserGroupInput;
|
|
UserPermission: ResolverTypeWrapper<UserPermission>;
|
|
UserRights: ResolverTypeWrapper<UserRights>;
|
|
UserRightsInput: UserRightsInput;
|
|
UserRole: ResolverTypeWrapper<UserRole>;
|
|
UserRoleInput: UserRoleInput;
|
|
UserRoleModule: ResolverTypeWrapper<UserRoleModule>;
|
|
UserRoleModuleInput: UserRoleModuleInput;
|
|
UserRoleRule: ResolverTypeWrapper<UserRoleRule>;
|
|
UserRoleRuleInput: UserRoleRuleInput;
|
|
UserRoleRules: ResolverTypeWrapper<UserRoleRules>;
|
|
UserRoleRulesInput: UserRoleRulesInput;
|
|
ZabbixCreateResponse: ResolverTypeWrapper<ZabbixCreateResponse>;
|
|
ZabbixGroupRight: ResolverTypeWrapper<ZabbixGroupRight>;
|
|
ZabbixGroupRightInput: ZabbixGroupRightInput;
|
|
ZabbixHost: ResolverTypeWrapper<Omit<ZabbixHost, 'items'> & { items?: Maybe<Array<ResolversTypes['ZabbixItem']>> }>;
|
|
ZabbixItem: ResolverTypeWrapper<Omit<ZabbixItem, 'hosts'> & { hosts?: Maybe<Array<Maybe<ResolversTypes['Host']>>> }>;
|
|
};
|
|
|
|
/** 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;
|
|
DateTime: Scalars['DateTime']['output'];
|
|
Device: ResolversInterfaceTypes<ResolversParentTypes>['Device'];
|
|
DeviceState: ResolversInterfaceTypes<ResolversParentTypes>['DeviceState'];
|
|
Error: ResolversInterfaceTypes<ResolversParentTypes>['Error'];
|
|
ErrorPayload: ErrorPayload;
|
|
Float: Scalars['Float']['output'];
|
|
GenericDevice: GenericDevice;
|
|
GenericDeviceState: GenericDeviceState;
|
|
GpsPosition: ResolversInterfaceTypes<ResolversParentTypes>['GpsPosition'];
|
|
HistoryExportResponse: HistoryExportResponse;
|
|
Host: ResolversInterfaceTypes<ResolversParentTypes>['Host'];
|
|
HostGroup: HostGroup;
|
|
HostTypeMeta: HostTypeMeta;
|
|
ID: Scalars['ID']['output'];
|
|
ImportUserRightResult: ImportUserRightResult;
|
|
ImportUserRightsResult: ImportUserRightsResult;
|
|
Int: Scalars['Int']['output'];
|
|
Inventory: Inventory;
|
|
Item: Omit<Item, 'hosts'> & { hosts?: Maybe<Array<Maybe<ResolversParentTypes['Host']>>> };
|
|
JSONObject: Scalars['JSONObject']['output'];
|
|
Location: Location;
|
|
LocationInput: LocationInput;
|
|
Mutation: {};
|
|
OperationalDeviceData: OperationalDeviceData;
|
|
PermissionRequest: PermissionRequest;
|
|
Query: {};
|
|
String: Scalars['String']['output'];
|
|
Template: Template;
|
|
Time: Scalars['Time']['output'];
|
|
UserGroup: UserGroup;
|
|
UserGroupInput: UserGroupInput;
|
|
UserPermission: UserPermission;
|
|
UserRights: UserRights;
|
|
UserRightsInput: UserRightsInput;
|
|
UserRole: UserRole;
|
|
UserRoleInput: UserRoleInput;
|
|
UserRoleModule: UserRoleModule;
|
|
UserRoleModuleInput: UserRoleModuleInput;
|
|
UserRoleRule: UserRoleRule;
|
|
UserRoleRuleInput: UserRoleRuleInput;
|
|
UserRoleRules: UserRoleRules;
|
|
UserRoleRulesInput: UserRoleRulesInput;
|
|
ZabbixCreateResponse: ZabbixCreateResponse;
|
|
ZabbixGroupRight: ZabbixGroupRight;
|
|
ZabbixGroupRightInput: ZabbixGroupRightInput;
|
|
ZabbixHost: Omit<ZabbixHost, 'items'> & { items?: Maybe<Array<ResolversParentTypes['ZabbixItem']>> };
|
|
ZabbixItem: Omit<ZabbixItem, 'hosts'> & { hosts?: Maybe<Array<Maybe<ResolversParentTypes['Host']>>> };
|
|
};
|
|
|
|
export type ApiErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['ApiError'] = ResolversParentTypes['ApiError']> = {
|
|
args?: Resolver<Maybe<ResolversTypes['JSONObject']>, ParentType, ContextType>;
|
|
code?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
|
|
data?: Resolver<Maybe<ResolversTypes['JSONObject']>, ParentType, ContextType>;
|
|
message?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
path?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type CreateHostGroupResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateHostGroupResponse'] = ResolversParentTypes['CreateHostGroupResponse']> = {
|
|
error?: Resolver<Maybe<ResolversTypes['ApiError']>, ParentType, ContextType>;
|
|
groupName?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
|
|
groupid?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
|
|
message?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type CreateHostResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateHostResponse'] = ResolversParentTypes['CreateHostResponse']> = {
|
|
deviceKey?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
|
|
error?: Resolver<Maybe<ResolversTypes['ApiError']>, ParentType, ContextType>;
|
|
hostid?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
message?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export interface DateTimeScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['DateTime'], any> {
|
|
name: 'DateTime';
|
|
}
|
|
|
|
export type DeviceResolvers<ContextType = any, ParentType extends ResolversParentTypes['Device'] = ResolversParentTypes['Device']> = {
|
|
__resolveType: TypeResolveFn<'GenericDevice', ParentType, ContextType>;
|
|
deviceType?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
host?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
|
|
hostgroups?: Resolver<Maybe<Array<ResolversTypes['HostGroup']>>, ParentType, ContextType>;
|
|
hostid?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
|
|
name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
state?: Resolver<Maybe<ResolversTypes['DeviceState']>, ParentType, ContextType>;
|
|
tags?: Resolver<Maybe<ResolversTypes['JSONObject']>, ParentType, ContextType>;
|
|
};
|
|
|
|
export type DeviceCommunicationTypeResolvers = EnumResolverSignature<{ DATABASE_MONITOR?: any, DEPENDANT_ITEM?: any, HTTP_AGENT?: any, IPMI_AGENT?: any, JMX_AGENT?: any, SIMPLE_CHECK?: any, SIMULATOR_CALCULATED?: any, SIMULATOR_JAVASCRIPT?: any, SNMP_AGENT?: any, SNMP_TRAP?: any, ZABBIX_AGENT?: any, ZABBIX_AGENT_ACTIVE?: any, ZABBIX_INTERNAL_ITEM?: any, ZABBIX_TRAP?: any }, ResolversTypes['DeviceCommunicationType']>;
|
|
|
|
export type DeviceStateResolvers<ContextType = any, ParentType extends ResolversParentTypes['DeviceState'] = ResolversParentTypes['DeviceState']> = {
|
|
__resolveType: TypeResolveFn<'GenericDeviceState', ParentType, ContextType>;
|
|
operational?: Resolver<Maybe<ResolversTypes['OperationalDeviceData']>, ParentType, ContextType>;
|
|
};
|
|
|
|
export type DeviceStatusResolvers = EnumResolverSignature<{ DISABLED?: any, ENABLED?: any }, ResolversTypes['DeviceStatus']>;
|
|
|
|
export type ErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['Error'] = ResolversParentTypes['Error']> = {
|
|
__resolveType: TypeResolveFn<'ApiError', ParentType, ContextType>;
|
|
code?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
|
|
data?: Resolver<Maybe<ResolversTypes['JSONObject']>, ParentType, ContextType>;
|
|
message?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
};
|
|
|
|
export type ErrorPayloadResolvers<ContextType = any, ParentType extends ResolversParentTypes['ErrorPayload'] = ResolversParentTypes['ErrorPayload']> = {
|
|
additionalInfo?: Resolver<Maybe<ResolversTypes['JSONObject']>, ParentType, ContextType>;
|
|
code?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
|
|
message?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type GenericDeviceResolvers<ContextType = any, ParentType extends ResolversParentTypes['GenericDevice'] = ResolversParentTypes['GenericDevice']> = {
|
|
deviceType?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
host?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
|
|
hostgroups?: Resolver<Maybe<Array<ResolversTypes['HostGroup']>>, ParentType, ContextType>;
|
|
hostid?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
|
|
name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
state?: Resolver<Maybe<ResolversTypes['GenericDeviceState']>, ParentType, ContextType>;
|
|
tags?: Resolver<Maybe<ResolversTypes['JSONObject']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type GenericDeviceStateResolvers<ContextType = any, ParentType extends ResolversParentTypes['GenericDeviceState'] = ResolversParentTypes['GenericDeviceState']> = {
|
|
current?: Resolver<Maybe<ResolversTypes['JSONObject']>, ParentType, ContextType>;
|
|
operational?: Resolver<Maybe<ResolversTypes['OperationalDeviceData']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type GpsPositionResolvers<ContextType = any, ParentType extends ResolversParentTypes['GpsPosition'] = ResolversParentTypes['GpsPosition']> = {
|
|
__resolveType: TypeResolveFn<'Location', ParentType, ContextType>;
|
|
latitude?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
|
|
longitude?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
|
|
};
|
|
|
|
export type HistoryExportResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['HistoryExportResponse'] = ResolversParentTypes['HistoryExportResponse']> = {
|
|
error?: Resolver<Maybe<ResolversTypes['ApiError']>, ParentType, ContextType>;
|
|
result?: Resolver<Maybe<Array<ResolversTypes['JSONObject']>>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type HostResolvers<ContextType = any, ParentType extends ResolversParentTypes['Host'] = ResolversParentTypes['Host']> = {
|
|
__resolveType: TypeResolveFn<'GenericDevice' | 'ZabbixHost', ParentType, ContextType>;
|
|
deviceType?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
host?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
|
|
hostgroups?: Resolver<Maybe<Array<ResolversTypes['HostGroup']>>, ParentType, ContextType>;
|
|
hostid?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
|
|
name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
tags?: Resolver<Maybe<ResolversTypes['JSONObject']>, ParentType, ContextType>;
|
|
};
|
|
|
|
export type HostGroupResolvers<ContextType = any, ParentType extends ResolversParentTypes['HostGroup'] = ResolversParentTypes['HostGroup']> = {
|
|
groupid?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
|
|
name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type HostTypeMetaResolvers<ContextType = any, ParentType extends ResolversParentTypes['HostTypeMeta'] = ResolversParentTypes['HostTypeMeta']> = {
|
|
deviceType?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
deviceTypeDescription?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type ImportUserRightResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['ImportUserRightResult'] = ResolversParentTypes['ImportUserRightResult']> = {
|
|
errors?: Resolver<Maybe<Array<ResolversTypes['ApiError']>>, ParentType, ContextType>;
|
|
id?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
message?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type ImportUserRightsResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['ImportUserRightsResult'] = ResolversParentTypes['ImportUserRightsResult']> = {
|
|
userGroups?: Resolver<Maybe<Array<ResolversTypes['ImportUserRightResult']>>, ParentType, ContextType>;
|
|
userRoles?: Resolver<Maybe<Array<ResolversTypes['ImportUserRightResult']>>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type InventoryResolvers<ContextType = any, ParentType extends ResolversParentTypes['Inventory'] = ResolversParentTypes['Inventory']> = {
|
|
location?: Resolver<Maybe<ResolversTypes['Location']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type ItemResolvers<ContextType = any, ParentType extends ResolversParentTypes['Item'] = ResolversParentTypes['Item']> = {
|
|
attributeName?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
deviceType?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
hostid?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
|
|
hosts?: Resolver<Maybe<Array<Maybe<ResolversTypes['Host']>>>, ParentType, ContextType>;
|
|
itemid?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
|
|
key_?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
|
|
status?: Resolver<Maybe<ResolversTypes['DeviceStatus']>, ParentType, ContextType>;
|
|
topicType?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
type?: Resolver<Maybe<ResolversTypes['DeviceCommunicationType']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export interface JsonObjectScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['JSONObject'], any> {
|
|
name: 'JSONObject';
|
|
}
|
|
|
|
export type LocationResolvers<ContextType = any, ParentType extends ResolversParentTypes['Location'] = ResolversParentTypes['Location']> = {
|
|
latitude?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
|
|
longitude?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
|
|
name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type MutationResolvers<ContextType = any, ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']> = {
|
|
createHost?: Resolver<Maybe<ResolversTypes['ZabbixCreateResponse']>, ParentType, ContextType, RequireFields<MutationCreateHostArgs, 'host' | 'hostgroupids' | 'templateids'>>;
|
|
importHostGroups?: Resolver<Maybe<Array<ResolversTypes['CreateHostGroupResponse']>>, ParentType, ContextType, RequireFields<MutationImportHostGroupsArgs, 'hostGroups'>>;
|
|
importHosts?: Resolver<Maybe<Array<ResolversTypes['CreateHostResponse']>>, ParentType, ContextType, RequireFields<MutationImportHostsArgs, 'hosts'>>;
|
|
importUserRights?: Resolver<Maybe<ResolversTypes['ImportUserRightsResult']>, ParentType, ContextType, RequireFields<MutationImportUserRightsArgs, 'dryRun' | 'input'>>;
|
|
};
|
|
|
|
export type OperationalDeviceDataResolvers<ContextType = any, ParentType extends ResolversParentTypes['OperationalDeviceData'] = ResolversParentTypes['OperationalDeviceData']> = {
|
|
error?: Resolver<Maybe<Array<ResolversTypes['ErrorPayload']>>, ParentType, ContextType>;
|
|
location?: Resolver<Maybe<ResolversTypes['Location']>, ParentType, ContextType>;
|
|
signalstrength?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
|
|
temperature?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
|
|
timestamp?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
|
|
voltage?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type PermissionResolvers = EnumResolverSignature<{ DENY?: any, READ?: any, READ_WRITE?: any }, ResolversTypes['Permission']>;
|
|
|
|
export type QueryResolvers<ContextType = any, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = {
|
|
allHostGroups?: Resolver<Maybe<Array<Maybe<ResolversTypes['HostGroup']>>>, ParentType, ContextType, RequireFields<QueryAllHostGroupsArgs, 'with_hosts'>>;
|
|
allHosts?: Resolver<Maybe<Array<Maybe<ResolversTypes['Host']>>>, ParentType, ContextType, RequireFields<QueryAllHostsArgs, 'filter_host' | 'groupids' | 'name_pattern' | 'tag_deviceType' | 'with_items'>>;
|
|
apiVersion?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
|
|
exportHostValueHistory?: Resolver<Maybe<ResolversTypes['HistoryExportResponse']>, ParentType, ContextType, RequireFields<QueryExportHostValueHistoryArgs, 'sortOrder' | 'type'>>;
|
|
exportUserRights?: Resolver<Maybe<ResolversTypes['UserRights']>, ParentType, ContextType, RequireFields<QueryExportUserRightsArgs, 'exclude_hostgroups_pattern' | 'name_pattern'>>;
|
|
hasPermissions?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<QueryHasPermissionsArgs, 'permissions'>>;
|
|
locations?: Resolver<Maybe<Array<Maybe<ResolversTypes['Location']>>>, ParentType, ContextType, RequireFields<QueryLocationsArgs, 'distinct_by_name' | 'name_pattern' | 'templateids'>>;
|
|
login?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType, RequireFields<QueryLoginArgs, 'password' | 'username'>>;
|
|
logout?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
|
|
userPermissions?: Resolver<Maybe<Array<ResolversTypes['UserPermission']>>, ParentType, ContextType, Partial<QueryUserPermissionsArgs>>;
|
|
zabbixVersion?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
};
|
|
|
|
export type StorageItemTypeResolvers = EnumResolverSignature<{ FLOAT?: any, INT?: any, TEXT?: any }, ResolversTypes['StorageItemType']>;
|
|
|
|
export type TemplateResolvers<ContextType = any, ParentType extends ResolversParentTypes['Template'] = ResolversParentTypes['Template']> = {
|
|
name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
templateid?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export interface TimeScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Time'], any> {
|
|
name: 'Time';
|
|
}
|
|
|
|
export type UserGroupResolvers<ContextType = any, ParentType extends ResolversParentTypes['UserGroup'] = ResolversParentTypes['UserGroup']> = {
|
|
gui_access?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
|
|
hostgroup_rights?: Resolver<Maybe<Array<ResolversTypes['ZabbixGroupRight']>>, ParentType, ContextType>;
|
|
name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
|
|
templategroup_rights?: Resolver<Maybe<Array<ResolversTypes['ZabbixGroupRight']>>, ParentType, ContextType>;
|
|
users_status?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
|
|
usrgrpid?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type UserPermissionResolvers<ContextType = any, ParentType extends ResolversParentTypes['UserPermission'] = ResolversParentTypes['UserPermission']> = {
|
|
objectName?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
|
|
permission?: Resolver<ResolversTypes['Permission'], ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type UserRightsResolvers<ContextType = any, ParentType extends ResolversParentTypes['UserRights'] = ResolversParentTypes['UserRights']> = {
|
|
userGroups?: Resolver<Maybe<Array<ResolversTypes['UserGroup']>>, ParentType, ContextType>;
|
|
userRoles?: Resolver<Maybe<Array<ResolversTypes['UserRole']>>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type UserRoleResolvers<ContextType = any, ParentType extends ResolversParentTypes['UserRole'] = ResolversParentTypes['UserRole']> = {
|
|
name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
readonly?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
|
|
roleid?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
|
|
rules?: Resolver<Maybe<ResolversTypes['UserRoleRules']>, ParentType, ContextType>;
|
|
type?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type UserRoleModuleResolvers<ContextType = any, ParentType extends ResolversParentTypes['UserRoleModule'] = ResolversParentTypes['UserRoleModule']> = {
|
|
id?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
moduleid?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
relative_path?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
status?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type UserRoleRuleResolvers<ContextType = any, ParentType extends ResolversParentTypes['UserRoleRule'] = ResolversParentTypes['UserRoleRule']> = {
|
|
name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
status?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type UserRoleRulesResolvers<ContextType = any, ParentType extends ResolversParentTypes['UserRoleRules'] = ResolversParentTypes['UserRoleRules']> = {
|
|
actions?: Resolver<Maybe<Array<ResolversTypes['UserRoleRule']>>, ParentType, ContextType>;
|
|
actions_default_access?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
|
|
api?: Resolver<Maybe<Array<ResolversTypes['String']>>, ParentType, ContextType>;
|
|
api_access?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
|
|
api_mode?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
|
|
modules?: Resolver<Maybe<Array<ResolversTypes['UserRoleModule']>>, ParentType, ContextType>;
|
|
modules_default_access?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
|
|
ui?: Resolver<Maybe<Array<ResolversTypes['UserRoleRule']>>, ParentType, ContextType>;
|
|
ui_default_access?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type ZabbixCreateResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['ZabbixCreateResponse'] = ResolversParentTypes['ZabbixCreateResponse']> = {
|
|
error?: Resolver<Maybe<ResolversTypes['ApiError']>, ParentType, ContextType>;
|
|
hostids?: Resolver<Maybe<Array<Maybe<ResolversTypes['Int']>>>, ParentType, ContextType>;
|
|
itemids?: Resolver<Maybe<Array<Maybe<ResolversTypes['Int']>>>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type ZabbixGroupRightResolvers<ContextType = any, ParentType extends ResolversParentTypes['ZabbixGroupRight'] = ResolversParentTypes['ZabbixGroupRight']> = {
|
|
id?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
|
|
name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
permission?: Resolver<Maybe<ResolversTypes['Permission']>, ParentType, ContextType>;
|
|
uuid?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type ZabbixHostResolvers<ContextType = any, ParentType extends ResolversParentTypes['ZabbixHost'] = ResolversParentTypes['ZabbixHost']> = {
|
|
deviceType?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
host?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
|
|
hostgroups?: Resolver<Maybe<Array<ResolversTypes['HostGroup']>>, ParentType, ContextType>;
|
|
hostid?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
|
|
inventory?: Resolver<Maybe<ResolversTypes['Inventory']>, ParentType, ContextType>;
|
|
items?: Resolver<Maybe<Array<ResolversTypes['ZabbixItem']>>, ParentType, ContextType>;
|
|
name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
parentTemplates?: Resolver<Maybe<Array<ResolversTypes['Template']>>, ParentType, ContextType>;
|
|
tags?: Resolver<Maybe<ResolversTypes['JSONObject']>, ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type ZabbixItemResolvers<ContextType = any, ParentType extends ResolversParentTypes['ZabbixItem'] = ResolversParentTypes['ZabbixItem']> = {
|
|
attributeName?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
deviceType?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
hostid?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
|
|
hosts?: Resolver<Maybe<Array<Maybe<ResolversTypes['Host']>>>, ParentType, ContextType>;
|
|
itemid?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
|
|
key_?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
|
|
lastclock?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
|
|
lastvalue?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
|
|
status?: Resolver<Maybe<ResolversTypes['DeviceStatus']>, ParentType, ContextType>;
|
|
topicType?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
|
|
type?: Resolver<Maybe<ResolversTypes['DeviceCommunicationType']>, ParentType, ContextType>;
|
|
value_type?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
|
|
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
|
|
};
|
|
|
|
export type Resolvers<ContextType = any> = {
|
|
ApiError?: ApiErrorResolvers<ContextType>;
|
|
CreateHostGroupResponse?: CreateHostGroupResponseResolvers<ContextType>;
|
|
CreateHostResponse?: CreateHostResponseResolvers<ContextType>;
|
|
DateTime?: GraphQLScalarType;
|
|
Device?: DeviceResolvers<ContextType>;
|
|
DeviceCommunicationType?: DeviceCommunicationTypeResolvers;
|
|
DeviceState?: DeviceStateResolvers<ContextType>;
|
|
DeviceStatus?: DeviceStatusResolvers;
|
|
Error?: ErrorResolvers<ContextType>;
|
|
ErrorPayload?: ErrorPayloadResolvers<ContextType>;
|
|
GenericDevice?: GenericDeviceResolvers<ContextType>;
|
|
GenericDeviceState?: GenericDeviceStateResolvers<ContextType>;
|
|
GpsPosition?: GpsPositionResolvers<ContextType>;
|
|
HistoryExportResponse?: HistoryExportResponseResolvers<ContextType>;
|
|
Host?: HostResolvers<ContextType>;
|
|
HostGroup?: HostGroupResolvers<ContextType>;
|
|
HostTypeMeta?: HostTypeMetaResolvers<ContextType>;
|
|
ImportUserRightResult?: ImportUserRightResultResolvers<ContextType>;
|
|
ImportUserRightsResult?: ImportUserRightsResultResolvers<ContextType>;
|
|
Inventory?: InventoryResolvers<ContextType>;
|
|
Item?: ItemResolvers<ContextType>;
|
|
JSONObject?: GraphQLScalarType;
|
|
Location?: LocationResolvers<ContextType>;
|
|
Mutation?: MutationResolvers<ContextType>;
|
|
OperationalDeviceData?: OperationalDeviceDataResolvers<ContextType>;
|
|
Permission?: PermissionResolvers;
|
|
Query?: QueryResolvers<ContextType>;
|
|
StorageItemType?: StorageItemTypeResolvers;
|
|
Template?: TemplateResolvers<ContextType>;
|
|
Time?: GraphQLScalarType;
|
|
UserGroup?: UserGroupResolvers<ContextType>;
|
|
UserPermission?: UserPermissionResolvers<ContextType>;
|
|
UserRights?: UserRightsResolvers<ContextType>;
|
|
UserRole?: UserRoleResolvers<ContextType>;
|
|
UserRoleModule?: UserRoleModuleResolvers<ContextType>;
|
|
UserRoleRule?: UserRoleRuleResolvers<ContextType>;
|
|
UserRoleRules?: UserRoleRulesResolvers<ContextType>;
|
|
ZabbixCreateResponse?: ZabbixCreateResponseResolvers<ContextType>;
|
|
ZabbixGroupRight?: ZabbixGroupRightResolvers<ContextType>;
|
|
ZabbixHost?: ZabbixHostResolvers<ContextType>;
|
|
ZabbixItem?: ZabbixItemResolvers<ContextType>;
|
|
};
|
|
|