schema.graphql

# This file was generated. Do not edit manually.

schema {
    query: Query
    mutation: Mutation
    subscription: Subscription
}

"Indicates an Input Object is a OneOf Input Object."
directive @oneOf on INPUT_OBJECT

"GraphQL representation of a JCR item definition"
interface JCRItemDefinition {
    "Reports whether the item is to be automatically created when its parent node is created."
    autoCreated: Boolean!
    "Gets the node type that contains the declaration of this definition."
    declaringNodeType: JCRNodeType!
    "Reports whether the child item is hidden from UI."
    hidden: Boolean!
    "Reports whether the item is mandatory. A mandatory item is one that, if its parent node exists, must also exist."
    mandatory: Boolean!
    "Gets the name of the child item."
    name: String!
    "Reports whether the child item is protected."
    protected: Boolean!
}

"GraphQL representation of a JCR node"
interface JCRNode {
    "Get ACL info for this node"
    acl: GqlAcl
    "Get the last modified date of this node and its descendants. The recursion in descendants can be controlled by recursionTypesFilter. If no filter is passed, recursion will stop by default on sub pages."
    aggregatedLastModifiedDate(
        "The language to use to get the last modified date, if not specified, returns last modification date in any language"
        language: String,
        "Stop recursion on nodes by their types; null to avoid such filtering"
        recursionTypesFilter: InputNodeTypesInput
    ): String
    "Aggregated publication info about the JCR node"
    aggregatedPublicationInfo(
        "Publication language"
        language: String!,
        "Whether to take references into account when calculating the aggregated publication status"
        references: Boolean = false,
        "Whether to take sub-nodes into account when calculating the aggregated publication status"
        subNodes: Boolean = false
    ): GqlPublicationInfo!
    "Render URL in ajax mode"
    ajaxRenderUrl: String
    "Returns a list of types allowed under the provided node"
    allowedChildNodeTypes(
        "Filter by GraphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Whether all sub-types of allowed child node types should be included"
        includeSubTypes: Boolean = true
    ): [JCRNodeType]
    "GraphQL representations of the ancestor nodes of the JCR node, top down direction"
    ancestors(
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "The path of the topmost ancestor node to include in the result; null or empty string to include all the ancestor nodes"
        upToPath: String
    ): [JCRNode]!
    "GraphQL representations of the child nodes, according to parameters passed"
    children(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Group fields according to specified criteria"
        fieldGrouping: InputFieldGroupingInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "Include the current node itself in results"
        includesSelf: Boolean = false,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "Filter of child nodes by their names; null to avoid such filtering"
        names: [String],
        "fetching only nodes after this node (inclusive)"
        offset: Int,
        "Filter of child nodes by their property values; null to avoid such filtering"
        propertiesFilter: InputNodePropertiesInput,
        "Filter of child nodes by their types; null to avoid such filtering"
        typesFilter: InputNodeTypesInput,
        "Language to use to get children"
        validInLanguage: String
    ): JCRNodeConnection
    "Read default Work in progress information. Set by \"wip.checkbox.checked\" system proprety"
    defaultWipInfo: wipInfo
    "Returns the node definition that applies to this node."
    definition: JCRNodeDefinition
    "GraphQL representation of a descendant node, based on its relative path"
    descendant(
        "Name or relative path of the sub node"
        relPath: String!
    ): JCRNode
    "GraphQL representations of the descendant nodes, according to parameters passed"
    descendants(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Group fields according to specified criteria"
        fieldGrouping: InputFieldGroupingInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int,
        "Filter of descendant nodes by their property values; null to avoid such filtering"
        propertiesFilter: InputNodePropertiesInput,
        "Filter out and stop recursion on nodes by their property values; null to avoid such filtering"
        recursionPropertiesFilter: InputNodePropertiesInput,
        "Filter out and stop recursion on nodes by their types; null to avoid such filtering"
        recursionTypesFilter: InputNodeTypesInput,
        "Filter of descendant nodes by their types; null to avoid such filtering"
        typesFilter: InputNodeTypesInput,
        "Language to use to get children"
        validInLanguage: String
    ): JCRNodeConnection
    "The display name of the JCR node this object represents in the requested language"
    displayName(
        "The language to obtain the display name in"
        language: String
    ): String
    "Returns the first parent of the current node that can be displayed in full page. If no matching node is found, null is returned."
    displayableNode: JCRNode
    "Returns the next available name for a node, appending if needed numbers."
    findAvailableNodeName(language: String, nodeType: String): String
    "Check if the current user has a specific permission"
    hasPermission(
        "The name of the permission"
        permissionName: String!
    ): Boolean
    "Check if the node as a renderable template associated with it (not a view a template)."
    isDisplayableNode: Boolean
    "true if node is under a mounted node"
    isExternal: Boolean!
    "Reports if the current node matches the nodetype(s) passed in parameter"
    isNodeType(
        "Node type name"
        type: InputNodeTypesInput!
    ): Boolean!
    "Check if the given locales need translation, by comparing last modifications dates with already existing translations"
    languagesToTranslate(
        "List of languages potentially to be translated"
        languagesToCheck: [String],
        "List of known translated languages, will be used to compare modifications dates"
        languagesTranslated: [String]
    ): [String]
    "Retrieve lock info of the current node"
    lockInfo: LockInfo
    "Returns edit lock status of the current node object"
    lockedAndCannotBeEdited: Boolean
    "Returns an array of <code>NodeType</code> objects representing the mixin node types in effect for this node."
    mixinTypes(
        "Filter by GraphQL fields values"
        fieldFilter: InputFieldFiltersInput
    ): [JCRNodeType]!
    "The name of the JCR node this object represents"
    name: String!
    "GraphQL representation of this node in certain workspace"
    nodeInWorkspace(
        "The target workspace"
        workspace: Workspace!
    ): JCRNode
    "Get information on the operations that can be done on this node"
    operationsSupport: GqlOperationsSupport
    "GraphQL representation of the parent JCR node"
    parent: JCRNode
    "The path of the JCR node this object represents"
    path: String!
    "Get the primary node type of this node"
    primaryNodeType: JCRNodeType!
    "GraphQL representations of the properties in the requested language"
    properties(
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "The language to obtain the properties in; must be a valid language code in case any internationalized properties are requested, does not matter for non-internationalized ones"
        language: String,
        "The names of the JCR properties; null to obtain all properties"
        names: [String],
        "When set to true, returns the node in the default language if there is no translation for the requested language. Returns null if the option \"Replace untranslated content with the default language content\" is not activated for the site of the requested node. Will also return null if there is no translation for the default language."
        useFallbackLanguage: Boolean = false
    ): [JCRProperty]!
    "The GraphQL representation of the property in the requested language; null if the property does not exist"
    property(
        "The language to obtain the property in; must be a valid language code for internationalized properties, does not matter for non-internationalized ones"
        language: String,
        "The name of the JCR property"
        name: String!,
        "When set to true, returns the node in the default language if there is no translation for the requested language. Returns null if the option \"Replace untranslated content with the default language content\" is not activated for the site of the requested node. Will also return null if there is no translation for the default language."
        useFallbackLanguage: Boolean = false
    ): JCRProperty
    "GraphQL representations of the reference properties that target the current JCR Node"
    references(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int
    ): JCRPropertyConnection!
    "Gets the fully rendered content for this node"
    renderedContent(
        "Rendering context configuration"
        contextConfiguration: String,
        "Is edit mode"
        isEditMode: Boolean,
        "Language"
        language: String,
        "Main resource path"
        mainResourcePath: String,
        "Additional request attributes"
        requestAttributes: [InputRenderRequestAttributeInput],
        "Template type"
        templateType: String,
        "Name of the view"
        view: String
    ): RenderedNode
    "GraphQL representation of the site the JCR node belongs to, or the system site in case the node does not belong to any site"
    site: JCRSite
    "Returns languages of available translations for this node"
    translationLanguages(
        "Optional: Return languages only if it is active for the site"
        isActiveOnly: Boolean
    ): [String]
    "GraphQL representations of the reference properties that target the current JCR Node"
    usages(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int
    ): UsageConnection!
    "The UUID of the JCR node this object represents"
    uuid: String!
    "Get vanity URLs from the current node filtered by the parameters"
    vanityUrls(
        "Filter results based on graphql field values"
        fieldFilter: InputFieldFiltersInput,
        "Languages"
        languages: [String]
    ): [VanityUrl]
    "Read work in progress information for a given node"
    wipInfo: wipInfo
    "Get the workspace of the query"
    workspace: Workspace!
}

"GraphQL representation of a principal"
interface Principal {
    "Full display name"
    displayName: String
    "List of groups this principal belongs to"
    groupMembership(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Group fields according to specified criteria"
        fieldGrouping: InputFieldGroupingInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int,
        "Return only groups which belong to this site"
        site: String
    ): GroupConnection!
    "Is this principal member of the specified group"
    memberOf(
        "Target group"
        group: String,
        "Site where the group is defined"
        site: String
    ): Boolean
    "Name"
    name: String!
    "Get the corresponding JCR node"
    node: JCRNode
    "Get principal type for this principal"
    principalType: PrincipalType
    "Site where the principal is defined"
    site: JCRSite
}

"Function score mutations"
type ASAdminFunctionScoreMutations {
    "Remove function score specification"
    removeFunction(
        "Function score id to be removed"
        id: String!
    ): Boolean
    "Upload function score specification"
    uploadFunction(
        "Describes what this function score does."
        description: String,
        "Function score file"
        file: String!,
        "Function score id, will be used as reference at query time."
        id: String!
    ): Boolean
}

"Function score admin entry point"
type ASAdminFunctionScoreQueries {
    "List available function score functions"
    functions(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int
    ): FunctionScoreConnection
}

"Generic object with admin mutation results"
type ASAdminMutations {
    "Add site to the list of indexed sites"
    addSite(
        "Site key"
        siteKey: String!
    ): String
    "Clear the database connection to use with Augmented Search (indexation and querying)"
    clearDbConnection: String
    "Function score mutations"
    functionScore: ASAdminFunctionScoreMutations
    "Remove site from the list of indexed sites"
    removeSite(
        "Site key"
        siteKey: String!
    ): String
    "Set the database connection to use with Augmented Search (indexation and querying)"
    setDbConnection(
        "DB connection id"
        connectionId: String!
    ): String
    "Given a list of sites, trigger bulk indexing. If no sites are provided, triggers a full reindex."
    startIndex(
        "Force start indexation for when job has already been started"
        force: Boolean = false,
        "List of siteKeys to index"
        siteKeys: [String],
        "Can be LIVE or EDIT or null for both"
        workspace: Workspace
    ): indexMutationResult
    "Given a list of nodes, trigger bulk indexing of those nodes and its descendants."
    startNodeIndex(
        "Re-index descendants (Optional; default=false)"
        inclDescendants: Boolean,
        "List of node paths to index"
        nodePaths: [String],
        "Can be LIVE or EDIT, or both if not specified"
        workspace: Workspace
    ): indexMutationResult
}

"List of indexed sites entry point"
type ASAdminQueries {
    "Current database connection ID used by Augmented Search"
    currentConnection: String
    "Get current shard configuration"
    currentShardConfiguration: GqlShardConfiguration
    "List of available database connections"
    dbConnections: [GqlAvailableConnection]
    "Function score queries"
    functionScore: ASAdminFunctionScoreQueries
    "Get index sizes"
    indexSizes: [GqlIndexSize]
    "List sites configured for Augmented Search"
    listSites: siteList
    "Get optimal shard configurations"
    optimalShardConfigurations(
        "Maximum average shard size allowed, in Gb"
        maxShardSizeInGb: Float,
        "Minimum amount of heap memory for each shard, in Mb"
        minHeapPerShardInMb: Float
    ): [GqlShardConfiguration]
}

"GraphQL representation of a Jahia ACL role"
type AclRole {
    "List of dependencies for a given role"
    dependencies: [AclRole]
    "Role description for a given locale"
    description(
        "locale"
        locale: String
    ): String
    "Role label for a given locale"
    label(
        "locale"
        locale: String
    ): String
    "Role name"
    name: String
    "Role group"
    roleGroup: String
}

"Admin mutations"
type AdminMutation {
    "Get Jahia admin mutation"
    jahia: JahiaAdminMutation!
    "Mount point mutation extension API"
    mountPoint: GqlMountPointMutation
    "Personal API tokens mutations"
    personalApiTokens: PersonalApiTokensMutation
    "Augmented Search administrative mutations"
    search: ASAdminMutations
    "Sitemap API mutations"
    sitemap: GqlSitemapMutation
}

"Admin queries root"
type AdminQuery {
    "Details about the Jahia cluster"
    cluster: Cluster
    "Current datetime"
    datetime: String
    "Get Jahia admin query"
    jahia: JahiaAdminQuery!
    "Mount point mutation extension API"
    mountPoint: GqlMountPointQuery
    "Personal API tokens queries"
    personalApiTokens: PersonalApiTokensQuery
    "Get available ACL roles; does not include any hidden or privileged roles"
    roles: [AclRole]
    "Augmented Search administrative queries"
    search: ASAdminQueries
    "Sitemap API queries"
    sitemap: GqlSitemapQueries
    "Get user administration endpoint"
    userAdmin: UserAdminQuery
    "Get user group endpoint"
    userGroup: UserGroupQuery
    "Version of the running Jahia instance"
    version: String! @deprecated(reason: "Deprecated")
}

"Details about the Jahia Cluster"
type Cluster {
    "Is the cluster mode activated on this Jahia instance"
    isActivated: Boolean
    "Query operation on Jahia's journal across all nodes of a cluster"
    journal: Journal
}

"Mutation for configuration value object"
type ConfigurationItemValuesMutation {
    "Modify a list of items"
    mutateList(
        "property name part"
        name: String
    ): ConfigurationItemsListMutation
    "Modify a structured object"
    mutateObject(
        "property name part"
        name: String
    ): ConfigurationItemValuesMutation
    "Remove the specified property and all sub/list properties"
    remove(
        "property name part"
        name: String
    ): Boolean
    "Set a property value"
    value(
        "property name part"
        name: String,
        value: String
    ): String
}

"Query for configuration value object"
type ConfigurationItemValuesQuery {
    "Get keys"
    keys: [String]
    "Get a list of items"
    list(
        "property name part"
        name: String
    ): ConfigurationItemsListQuery
    "Get a sub structured object value"
    object(
        "property name part"
        name: String
    ): ConfigurationItemValuesQuery
    "Get a property value"
    value(
        "property name part"
        name: String
    ): String
    "Get property values"
    values: [GqlConfigurationProperty]
}

"Mutation for configuration list of values"
type ConfigurationItemsListMutation {
    "Adds a new sub list to the list"
    addList: ConfigurationItemsListMutation
    "Adds a new structured object to the list"
    addObject: ConfigurationItemValuesMutation
    "Adds a property value to the list"
    addValue(value: String): String
}

"Query for configuration list of values"
type ConfigurationItemsListQuery {
    "Get sub lists of items"
    lists: [ConfigurationItemsListQuery]
    "Get sub structured object values"
    objects: [ConfigurationItemValuesQuery]
    "Adds a new structured object to the list"
    size: Int
    "Get property values"
    values: [String]
}

"Simple node count aggregation"
type CountAggregation {
    "Count all values"
    values(
        "The language to obtain the property in; must be a valid language code for internationalized properties, does not matter for non-internationalized ones"
        language: String,
        "The name of the JCR property"
        name: String!
    ): Int
}

"GraphQL representation of a Jahia current user"
type Current_32_user {
    "Full display name"
    displayName: String
    "Email of the user"
    email: String
    "First name of the user"
    firstname: String
    "Preferred language by the user"
    language: String
    "Last name of the user"
    lastname: String
    "Displays if user is locked"
    locked: Boolean
    "Is this principal member of the specified group"
    memberOf(
        "Target group"
        group: String,
        "Site where the group is defined"
        site: String
    ): Boolean
    "User name"
    name: String! @deprecated(reason: "Deprecated")
    "Get the corresponding JCR node"
    node: JCRNode
    "User organization"
    organization: String
    "User property"
    property(
        "The name of the property"
        name: String!
    ): String
    "Site where the user is defined"
    site: JCRSite
    "Username of the user"
    username: String!
}

"Functions score representation"
type FunctionScore {
    "Function score description"
    description: String
    "Function score id"
    id: String
    "JSON string "
    json: String
}

"A connection to a list of items."
type FunctionScoreConnection {
    "a list of edges"
    edges: [FunctionScoreEdge]
    "a list of nodes"
    nodes: [FunctionScore]
    "details about this specific page"
    pageInfo: PageInfo!
}

"An edge in a connection"
type FunctionScoreEdge {
    "cursor marks a unique position or index into the connection"
    cursor: String!
    "index in the connection"
    index: Int
    "The item at the end of the edge"
    node: FunctionScore
}

"GraphQL representation of a generic JCR node"
type GenericJCRNode implements JCRNode {
    "Get ACL info for this node"
    acl: GqlAcl
    "Get the last modified date of this node and its descendants. The recursion in descendants can be controlled by recursionTypesFilter. If no filter is passed, recursion will stop by default on sub pages."
    aggregatedLastModifiedDate(
        "The language"
        language: String,
        "Stop recursion on graphql field values"
        recursionTypesFilter: InputNodeTypesInput
    ): String
    "Aggregated publication info about the JCR node"
    aggregatedPublicationInfo(
        "Publication language"
        language: String!,
        "Whether to take references into account when calculating the aggregated publication status"
        references: Boolean = false,
        "Whether to take sub-nodes into account when calculating the aggregated publication status"
        subNodes: Boolean = false
    ): GqlPublicationInfo!
    "Render URL in ajax mode"
    ajaxRenderUrl: String
    "Returns a list of types allowed under the provided node"
    allowedChildNodeTypes(
        "Filter by GraphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Whether all sub-types of allowed child node types should be included"
        includeSubTypes: Boolean = true
    ): [JCRNodeType]
    "GraphQL representations of the ancestor nodes of the JCR node, top down direction"
    ancestors(
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "The path of the topmost ancestor node to include in the result; null or empty string to include all the ancestor nodes"
        upToPath: String
    ): [JCRNode]!
    "GraphQL representations of the child nodes, according to parameters passed"
    children(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Group fields according to specified criteria"
        fieldGrouping: InputFieldGroupingInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "Include the current node itself in results"
        includesSelf: Boolean = false,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "Filter of child nodes by their names; null to avoid such filtering"
        names: [String],
        "fetching only nodes after this node (inclusive)"
        offset: Int,
        "Filter of child nodes by their property values; null to avoid such filtering"
        propertiesFilter: InputNodePropertiesInput,
        "Filter of child nodes by their types; null to avoid such filtering"
        typesFilter: InputNodeTypesInput,
        "Language to use to get children"
        validInLanguage: String
    ): JCRNodeConnection
    "Read default Work in progress information. Set by \"wip.checkbox.checked\" system proprety"
    defaultWipInfo: wipInfo
    "Returns the node definition that applies to this node."
    definition: JCRNodeDefinition
    "GraphQL representation of a descendant node, based on its relative path"
    descendant(
        "Name or relative path of the sub node"
        relPath: String!
    ): JCRNode
    "GraphQL representations of the descendant nodes, according to parameters passed"
    descendants(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Group fields according to specified criteria"
        fieldGrouping: InputFieldGroupingInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int,
        "Filter of descendant nodes by their property values; null to avoid such filtering"
        propertiesFilter: InputNodePropertiesInput,
        "Filter out and stop recursion on nodes by their property values; null to avoid such filtering"
        recursionPropertiesFilter: InputNodePropertiesInput,
        "Filter out and stop recursion on nodes by their types; null to avoid such filtering"
        recursionTypesFilter: InputNodeTypesInput,
        "Filter of descendant nodes by their types; null to avoid such filtering"
        typesFilter: InputNodeTypesInput,
        "Language to use to get children"
        validInLanguage: String
    ): JCRNodeConnection
    "The displayable name of the JCR node"
    displayName(
        "Language"
        language: String
    ): String
    "Returns the first parent of the current node that can be displayed in full page. If no matching node is found, null is returned."
    displayableNode: JCRNode
    "Returns the next available name for a node, appending if needed numbers."
    findAvailableNodeName(language: String, nodeType: String): String
    "Check if the current user has a specific permission"
    hasPermission(
        "The name of the permission"
        permissionName: String!
    ): Boolean
    "Check if the node as a renderable template associated with it (not a view a template)."
    isDisplayableNode: Boolean
    "true if node is under a mounted node"
    isExternal: Boolean!
    "Reports if the current node matches the nodetype(s) passed in parameter"
    isNodeType(
        "Node type name"
        type: InputNodeTypesInput!
    ): Boolean!
    "Check if the given locales need translation, by comparing last modifications dates with already existing translations"
    languagesToTranslate(
        "The languages to check"
        languagesToCheck: [String],
        "The translated languages"
        languagesTranslated: [String]
    ): [String]
    "Retrieve lock info of the current node"
    lockInfo: LockInfo
    "Returns edit lock status of the current node object"
    lockedAndCannotBeEdited: Boolean
    "Returns an array of <code>NodeType</code> objects representing the mixin node types in effect for this node."
    mixinTypes(
        "Filter by GraphQL fields values"
        fieldFilter: InputFieldFiltersInput
    ): [JCRNodeType]!
    "The name of the JCR node this object represents"
    name: String!
    "GraphQL representation of this node in certain workspace"
    nodeInWorkspace(
        "The target workspace"
        workspace: Workspace!
    ): JCRNode
    "Get information on the operations that can be done on this node"
    operationsSupport: GqlOperationsSupport
    "GraphQL representation of the parent JCR node"
    parent: JCRNode
    "The path of the JCR node this object represents"
    path: String!
    "Get the primary node type of this node"
    primaryNodeType: JCRNodeType!
    "GraphQL representations of the properties in the requested language"
    properties(
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "The language to obtain the properties in; must be a valid language code in case any internationalized properties are requested, does not matter for non-internationalized ones"
        language: String,
        "The names of the JCR properties; null to obtain all properties"
        names: [String],
        "When set to true, returns the node in the default language if there is no translation for the requested language. Returns null if the option \"Replace untranslated content with the default language content\" is not activated for the site of the requested node. Will also return null if there is no translation for the default language."
        useFallbackLanguage: Boolean = false
    ): [JCRProperty]!
    "The GraphQL representation of the property in the requested language; null if the property does not exist"
    property(
        "The language to obtain the property in; must be a valid language code for internationalized properties, does not matter for non-internationalized ones"
        language: String,
        "The name of the JCR property"
        name: String!,
        "When set to true, returns the node in the default language if there is no translation for the requested language. Returns null if the option \"Replace untranslated content with the default language content\" is not activated for the site of the requested node. Will also return null if there is no translation for the default language."
        useFallbackLanguage: Boolean = false
    ): JCRProperty
    "GraphQL representations of the reference properties that target the current JCR Node"
    references(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int
    ): JCRPropertyConnection!
    "Gets the fully rendered content for this node"
    renderedContent(
        "Rendering context configuration"
        contextConfiguration: String,
        "Is edit mode"
        isEditMode: Boolean,
        "Language"
        language: String,
        "Main resource path"
        mainResourcePath: String,
        "Additional request attributes"
        requestAttributes: [InputRenderRequestAttributeInput],
        "Template type"
        templateType: String,
        "Name of the view"
        view: String
    ): RenderedNode
    "GraphQL representation of the site the JCR node belongs to, or the system site in case the node does not belong to any site"
    site: JCRSite
    "Returns languages of available translations for this node"
    translationLanguages(
        "Optional: Return languages only if it is active for the site"
        isActiveOnly: Boolean
    ): [String]
    "GraphQL representations of the reference properties that target the current JCR Node"
    usages(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int
    ): UsageConnection!
    "The UUID of the JCR node this object represents"
    uuid: String!
    "Get vanity URLs from the current node filtered by the parameters"
    vanityUrls(
        "Filter results based on graphql field values"
        fieldFilter: InputFieldFiltersInput,
        "Languages"
        languages: [String]
    ): [VanityUrl]
    "Read work in progress information for a given node"
    wipInfo: wipInfo
    "Get the workspace of the query"
    workspace: Workspace!
}

"ACL properties and list of access control entry"
type GqlAcl {
    "Get list of access control entries for this ACL"
    aclEntries(
        "The languages to check"
        inclInherited: Boolean,
        "Fetch ACL entry only for this principal"
        principalFilter: InputPrincipalInput
    ): [GqlAclEntry]
    "Get inheritance break attribute for this node"
    inheritanceBreak: Boolean
    "Get parent node for this ACL"
    parentNode: JCRNode
}

"ACL entry"
type GqlAclEntry {
    "Type of access for this ACL entry - one of GRANT, DENY or EXTERNAL"
    aclEntryType: String
    "External permissions name "
    externalPermissionsName: String
    "Return true if this ACL entry did not originate from this ACL's parent node"
    inherited: Boolean
    "Get node where this ACL entry originated from"
    inheritedFrom: JCRNode
    "Get principal for this entry"
    principal: Principal
    "Get role for this entry"
    role: AclRole
}

"Elasticsearch connection model"
type GqlAvailableConnection {
    "Id of the connection"
    connectionId: String
    "List of plugins if any"
    plugins: [GqlPlugin]
}

"Background job"
type GqlBackgroundJob {
    "The amount of time the job ran for (in milliseconds). The returned value will be -1 until the job has actually completed"
    duration: Long
    "The job group name"
    group: String
    "The job (Boolean) property that correspond to the given name. The returned value will be null in case the job doesn't have the property"
    jobBooleanProperty(
        "The job name"
        name: String
    ): Boolean
    "The job (Int) property that correspond to the given name. The returned value will be null in case the job doesn't have the property"
    jobIntegerProperty(
        "The job name"
        name: String
    ): Int
    "The job (Long) property that correspond to the given name. The returned value will be null in case the job doesn't have the property"
    jobLongProperty(
        "The job name"
        name: String
    ): Long
    "The job state is different from the status, it reflect the last action done on the job instance (Started, Vetoed, Finished)"
    jobState: GqlBackgroundJobState
    "The job status"
    jobStatus: GqlBackgroundJobStatus
    "The job (String) property that correspond to the given name. The returned value will be null in case the job doesn't have the property"
    jobStringProperty(
        "The job name"
        name: String
    ): String
    "The job name"
    name: String
    "GraphQL representation of publication job"
    publicationJob: GqlPublicationBackgroundJob
    "The site key. The returned value will be null in case the job doesn't have associated site key"
    siteKey: String
    "The user key. The returned value will be null in case the job doesn't have associated user key"
    userKey: String
}

"Condition for override item"
type GqlCondition {
    "Item will apply only on this nodetype"
    nodeType: String
    "Item will apply only if node has orderable children"
    orderable: Boolean
    "Item will apply only if user has permissions"
    withPermission: String
    "Item will apply only if user has not permissions"
    withoutPermission: String
}

"Mutation for OSGi configuration"
type GqlConfigurationMutation {
    "Modify a list of items"
    mutateList(
        "property name part"
        name: String
    ): ConfigurationItemsListMutation
    "Modify a structured object"
    mutateObject(
        "property name part"
        name: String
    ): ConfigurationItemValuesMutation
    "Remove the specified property and all sub/list properties"
    remove(
        "property name part"
        name: String
    ): Boolean
    "Set a property value"
    value(
        "property name part"
        name: String,
        value: String
    ): String
}

"OSGi configuration property"
type GqlConfigurationProperty {
    "The property key"
    key: String
    "The property value"
    value: String
}

"Query for OSGi configuration"
type GqlConfigurationQuery {
    "Get all properties of the configuration, as they are stored in OSGi"
    flatKeys: [String]
    "Get all properties of the configuration, as they are stored in OSGi"
    flatProperties: [GqlConfigurationProperty]
    "Get keys"
    keys: [String]
    "Get a list of items"
    list(
        "property name part"
        name: String
    ): ConfigurationItemsListQuery
    "Get a sub structured object value"
    object(
        "property name part"
        name: String
    ): ConfigurationItemValuesQuery
    "Get a property value"
    value(
        "property name part"
        name: String
    ): String
    "Get property values"
    values: [GqlConfigurationProperty]
}

type GqlDashboard {
    "Retrieves the list of modules currently available on the platform"
    modules: [GqlModule]
    "Whether the tools are accessible on the installation"
    toolsAccess: Boolean
}

type GqlEditorForm {
    "Retrieve a description text for the form, might contain explanations on how to use the form"
    description: String
    "Retrieve the displayable name of the form (in a specific language)"
    displayName: String
    "Returns the preview status of the form. If true, the form can display a preview."
    hasPreview: Boolean
    "Get list of merged forms."
    mergedItems(
        "Filter on field values"
        filter: InputFieldFiltersInput
    ): [GqlMergedItem]
    "Retrieve the name (aka identifier) of the form"
    name: String
    "Retrieve the sections that make up the form"
    sections: [GqlEditorFormSection]
    "Returns the advanced mode status of the form. If true advanced mode is available."
    showAdvancedMode: Boolean
}

type GqlEditorFormField {
    "The declaring node type for the field"
    declaringNodeType: String
    "This value contains the default values for the field."
    defaultValues: [GqlEditorFormValue]
    "The description of the field"
    description: String
    "The displayable name of the field"
    displayName: String
    "The error message of the field"
    errorMessage: String
    "This value is true if the field allows for internationalized values"
    i18n: Boolean
    "This value is true if the field is mandatory"
    mandatory: Boolean
    "This value is true if the field value is multi-valued."
    multiple: Boolean
    "The name of the field"
    name: String
    "This value is true if the field is readonly. This could be due to locks or permissions"
    readOnly: Boolean
    "The required type for the field"
    requiredType: JCRPropertyType
    "Options for the selector type. For JCR definitions, this will usually include choicelist initializer name and properties."
    selectorOptions: [GqlEditorFormProperty]
    "The selector type for the field. In the case of fields generated from node types, this is actually the SelectorType."
    selectorType: String
    "This array contains the list of possible values to choose from"
    valueConstraints: [GqlEditorFormValueConstraint]
    "This fields set is visible"
    visible: Boolean
}

type GqlEditorFormFieldSet {
    "Only used in the case of a dynamic field set. Set to true if it is activated"
    activated: Boolean
    "Get the internationalized description of the field set"
    description: String
    "Get the internationalized displayable name of the field set"
    displayName: String
    "True if this is dynamic field set (meaning it can be activated or not)"
    dynamic: Boolean
    "Get the fields contained in the target"
    fields: [GqlEditorFormField]
    "Only used in the case of a dynamic field set. Set to true if it is activated"
    hasEnableSwitch: Boolean
    "Get the name of the field set"
    name: String
    "This value is true if the fieldset is readonly. This could be due to locks or permissions"
    readOnly: Boolean
    visible: Boolean
}

type GqlEditorFormMutations {
    "Publish the edited node with the associated technical sub nodes (visibility conditions, vanity urls, ACLs)"
    publishForm(
        "A string representation of a locale, in IETF BCP 47 language tag format, ie en_US, en, fr, fr_CH, ..."
        locale: String!,
        "UUID or path of the edited node."
        uuidOrPath: String!
    ): Boolean
    "Unlock the given node for edition, if the node is locked."
    unlockEditor(
        "An ID generated client side used to identify the lock"
        editorID: String!
    ): Boolean
}

type GqlEditorFormProperty {
    "Property name"
    name: String
    "Property value"
    value: String
    "Property values"
    values: [String]
}

type GqlEditorFormSection {
    "Returns the description of the section"
    description: String
    "Retrieve the displayable name of the section"
    displayName: String
    "Is the section expanded"
    expanded: Boolean
    "Returns the field sets contained in this section"
    fieldSets: [GqlEditorFormFieldSet]
    "Retrieve the name (aka identifier) of the section"
    name: String
    "This section is visible"
    visible: Boolean
}

type GqlEditorFormValue {
    "This value's string representation"
    string: String
    "The type of this value"
    type: String
}

type GqlEditorFormValueConstraint {
    "The value as it is intended to be displayed in UIs"
    displayValue: String
    "The key of the value to get the translated value from the client side"
    displayValueKey: String
    "The properties for the value"
    properties: [GqlEditorFormProperty]
    "The actual value to be used in storage"
    value: GqlEditorFormValue
}

type GqlEditorForms {
    "Retrieve the custom configuration path for CKEditor"
    ckeditorConfigPath(
        "node path"
        nodePath: String
    ): String
    "Retrieve the toolbar type for CKEditor"
    ckeditorToolbar(
        "node path"
        nodePath: String
    ): String
    "Get a list of allowed child nodeTypes for a given nodeType and path. (Note that it returns nothing for type [jnt:page]. [jnt:contentFolder] is filterered by [jmix:editorialContent])"
    contentTypesAsTree(
        "the child node name, used to check the type allowed for this named child node, do not specify if you want to check for unnamed children"
        childNodeName: String,
        "List of types we want to exclude, null for all"
        excludedNodeTypes: [String],
        "if true, retrieves all the sub types of the given node types, if false, returns the type only. Default value is true"
        includeSubTypes: Boolean = true,
        "List of types we want to retrieve, null for all"
        nodeTypes: [String],
        "A string representation of a locale, in IETF BCP 47 language tag format, ie en_US, en, fr, fr_CH, ..."
        uiLocale: String!,
        "if true, check the contribute property of the node. Default value is true"
        useContribute: Boolean = true,
        "Path or id of an existing node under with the new content will be created."
        uuidOrPath: String!
    ): [NodeTypeTreeEntry]
    "Get a editor form to create a new content from its nodetype and parent"
    createForm(
        "A string representation of a locale, in IETF BCP 47 language tag format, ie en_US, en, fr, fr_CH, ..."
        locale: String!,
        "The primary node type name identifying the form we want to retrieve"
        primaryNodeType: String!,
        "A string representation of a locale, in IETF BCP 47 language tag format, ie en_US, en, fr, fr_CH, ..."
        uiLocale: String!,
        "uuid or path of an existing node under with the new content will be created."
        uuidOrPath: String!
    ): GqlEditorForm
    "Get a editor form from a locale and an existing node"
    editForm(
        "A string representation of a locale, in IETF BCP 47 language tag format, ie en_US, en, fr, fr_CH, ..."
        locale: String!,
        "A string representation of a locale, in IETF BCP 47 language tag format, ie en_US, en, fr, fr_CH, ..."
        uiLocale: String!,
        "UUID or path of an existing node under with the new content will be created."
        uuidOrPath: String!
    ): GqlEditorForm
    "Get field constraints"
    fieldConstraints(
        "Object contains additional information of the node"
        context: [InputContextEntryInput],
        "A string representation of field name"
        fieldName: String!,
        "A string representation of the field node type (the node type that contains the field, can be the node type of the node, a mixin or a super type)"
        fieldNodeType: String!,
        "A string representation of a locale, in IETF BCP 47 language tag format, ie en_US, en, fr, fr_CH, ..."
        locale: String!,
        "UUID or path of the node (optional in case you are creating it, and it doesnt exist yet)"
        nodeUuidOrPath: String,
        "UUID or path of the parent node"
        parentNodeUuidOrPath: String!,
        "A string representation of the primary node type of the node"
        primaryNodeType: String!,
        "A string representation of a locale, in IETF BCP 47 language tag format, ie en_US, en, fr, fr_CH, ..."
        uiLocale: String!
    ): [GqlEditorFormValueConstraint]
    "Retrieve the number of sub contents under the node for given types"
    subContentsCount(
        "List of node types to check for"
        includeTypes: [String],
        "Limit of sub contents count"
        limit: Int,
        "node path"
        nodePath: String
    ): Int
}

"Model for HTML filter settings of a site"
type GqlHTMLFiltering {
    "Indicates if html filtering is enabled or not"
    filteringEnabled: Boolean
    "Site key"
    siteKey: String
    "List of filter tags"
    tags: [String]
}

"Server healthCheck"
type GqlHealthCheck {
    probes: [GqlProbe]
    "Highest reported status across all probes"
    status: GqlProbeStatus
}

"Index size"
type GqlIndexSize {
    "Index name"
    name: String
    "Index size in bytes"
    size: Long
}

type GqlJcrImageTransformMutation {
    "Crop an image under the current node"
    cropImage(
        "new height"
        height: Int!,
        "left"
        left: Int!,
        "top"
        top: Int!,
        "new width"
        width: Int!
    ): Boolean
    "The transformed node"
    node: JCRNode
    "Resize an image under the current node"
    resizeImage(
        "new height"
        height: Int!,
        "new width"
        width: Int!
    ): Boolean
    "Rotate an image under the current node"
    rotateImage(
        "angle in degrees"
        angle: Float!
    ): Boolean
}

"Details on a lock"
type GqlLockDetail {
    "Language"
    language: String
    "Lock owner"
    owner: String
    "Lock type"
    type: String
}

"Override item"
type GqlMergedItem {
    "Name of the bundle owning this file"
    bundleName: String
    "Conditions set on this form/fieldset"
    condition: GqlCondition
    "Get field set detail, if item is a field set"
    fieldSet: GqlEditorFormFieldSet
    "File name and path"
    filename: String
    "Get form detail, if item is a form"
    form: GqlEditorForm
    "Override priority"
    priority: Float
}

type GqlMetricsFacetResult {
    "The field that was used to run the aggregation"
    field: String
    "Maximum value within the filtered dataset"
    max: Float
    "Minimum value within the filtered dataset"
    min: Float
}

type GqlModule {
    "User facing description for the module"
    description: String
    "Unique identifier for the module"
    id: String
    "If the module is in development, mostly because the sources have been downloaded."
    inDevelopment: Boolean
    "Bundle last modification date"
    lastModified: Long
    "User facing name for the module"
    name: String
    "Version number for the module"
    version: String
}

"Mount point object"
type GqlMountPoint {
    "Mount point name"
    mountName: String
    "Mount point local reference path"
    mountPointRefPath: String
    "Mount status"
    mountStatus: String
    "Mount node type"
    nodeType: String
    "Mount point additional properties"
    properties: [GqlMountPointProperty]
    "Mount point property"
    property(
        "The name of the property"
        name: String!
    ): String
    "Mount point node uuid"
    uuid: String
}

"Mount point mutation object"
type GqlMountPointMutation {
    "Create a mounted mount point node in /mounts"
    add(
        "Target local mount point"
        mountPointRefPath: String,
        "Mount point name"
        name: String!
    ): String
    "Create a mounted VFS mount point node in /mounts"
    addVfs(
        "Target local mount point"
        mountPointRefPath: String,
        "Name for the mount point"
        name: String!,
        "VFS root mount point"
        rootPath: String
    ): String
    "Modify an existing mount point node"
    modify(
        "Change local mount point, or set to empty string to remove"
        mountPointRefPath: String,
        "Rename existing mount point"
        name: String,
        "Mount point path or ID to modify"
        pathOrId: String!
    ): Boolean
    "Modify an existing mount point node"
    modifyVfs(
        "Change target local mount point, or set to empty string to remove"
        mountPointRefPath: String,
        "Rename existing mount point"
        name: String,
        "Mount point path or ID to modify"
        pathOrId: String!,
        "VFS root mount point"
        rootPath: String
    ): Boolean
    "Mount an existing mount point"
    mount(
        "Mount point path or ID to mount"
        pathOrId: String!
    ): Boolean
    "Unmount an existing mount point"
    unmount(
        "Mount point path or ID to unmount"
        pathOrId: String!
    ): Boolean
}

"Mount point property"
type GqlMountPointProperty {
    "The property key"
    key: String
    "The property value"
    value: String
}

"Mount point queries object"
type GqlMountPointQuery {
    "Get mount point with given name, or null if it doesn't exists"
    mountPoint(
        "Name for the mount point"
        name: String!
    ): GqlMountPoint
    "Get list of mount points, or empty list if no mounts exist"
    mountPoints: [GqlMountPoint]
}

type GqlNpmHelper {
    "Render a compoment according to the parameters"
    renderedComponent(
        "Rendering context configuration"
        contextConfiguration: String,
        "Edit mode"
        isEditMode: Boolean,
        "Language"
        language: String,
        "Main resource path"
        mainResourcePath: String,
        "Input containing the primary node type, the name, the properties and other fields of a JCR Node of a node to render"
        node: InputJCRNode,
        "Path of the node"
        path: String,
        "Template type"
        templateType: String,
        "Name of the view"
        view: String
    ): SimpleRenderedNode
}

"Possible operations on a node"
type GqlOperationsSupport {
    "Can node be locked"
    lock: Boolean
    "Can node be marked for deletion"
    markForDeletion: Boolean
    "does the node supports publication"
    publication: Boolean!
}

"Model of a plugin information (name,description,version)"
type GqlPlugin {
    "Full description of the plugin"
    description: String
    "Full name of the plugin"
    name: String
    "version of the plugin"
    version: String
}

type GqlProbe {
    "Description specified by the developer of the probe"
    description: String
    "Name of the probe"
    name: String
    "Severity of the probe (LOW to CRITICAL)"
    severity: GqlProbeSeverity
    "Status reported by the probe (GREEN to RED)"
    status: GqlProbeStatus
}

"Probe status"
type GqlProbeStatus {
    "Health of the probe"
    health: GqlProbeHealth
    "Message explaining probe status"
    message: String
}

"Publication background job"
type GqlPublicationBackgroundJob {
    "The amount of time the job ran for (in milliseconds). The returned value will be -1 until the job has actually completed"
    duration: Long
    "The job group name"
    group: String
    "The job (Boolean) property that correspond to the given name. The returned value will be null in case the job doesn't have the property"
    jobBooleanProperty(
        "The job name"
        name: String
    ): Boolean
    "The job (Int) property that correspond to the given name. The returned value will be null in case the job doesn't have the property"
    jobIntegerProperty(
        "The job name"
        name: String
    ): Int
    "The job (Long) property that correspond to the given name. The returned value will be null in case the job doesn't have the property"
    jobLongProperty(
        "The job name"
        name: String
    ): Long
    "The job state is different from the status, it reflect the last action done on the job instance (Started, Vetoed, Finished)"
    jobState: GqlBackgroundJobState
    "The job status"
    jobStatus: GqlBackgroundJobStatus
    "The job (String) property that correspond to the given name. The returned value will be null in case the job doesn't have the property"
    jobStringProperty(
        "The job name"
        name: String
    ): String
    "Publication language"
    language: String
    "The job name"
    name: String
    "The site key. The returned value will be null in case the job doesn't have associated site key"
    siteKey: String
    "The user key. The returned value will be null in case the job doesn't have associated user key"
    userKey: String
}

"Publication status information for a JCR node"
type GqlPublicationInfo {
    "Whether current user is allowed to publish the node omitting any workflows"
    allowedToPublishWithoutWorkflow: Boolean
    "Whether node exists in live workspace"
    existsInLive: Boolean
    "Aggregated locked status of the node"
    locked: Boolean
    "Aggregated publication status of the node"
    publicationStatus: PublicationStatus!
    "Aggregated work-in-progress status of the node"
    workInProgress: Boolean
}

"Representation of range facet aggregation buckets"
type GqlRangeFacetData {
    "Number of documents matching the range"
    count: Int
    "Name provided for the range"
    name: String
}

"Result of aggregation based on field and ranges"
type GqlRangeFacetResult {
    "Data based on facets specified in the search"
    data: [GqlRangeFacetData]
    "The field that was used to run the aggregation"
    field: String
}

"Scheduler object which allows to access to background jobs"
type GqlScheduler {
    "List of active jobs"
    jobs: [GqlBackgroundJob]
}

"API Scope"
type GqlScope {
    "The description of the scope"
    description: String
    "The name of the scope"
    name: String
}

"Sharding configuration details"
type GqlShardConfiguration {
    "Average shard size, based on the current index size"
    averageShardSize: Long
    "Is the number of shards evenly divisible by number of data nodes"
    divisible: Boolean
    "Available heap memory per shard"
    heapPerShard: Long
    "Number of primary shards"
    primaryCount: Int
    "Number of replicas"
    replicas: Int
}

type GqlSitemapMutation {
    "Delete existing sitemap cache if exists before expiration time difference"
    deleteSitemapCache(
        "Site key"
        siteKey: String
    ): Boolean
    "Sending sitemap(s) based on either sitemap index XML or sitemap XML URL to search engine URL(s) specified in CFG"
    sendSitemapToSearchEngine(
        "Sitemap index XML or sitemap XML URL"
        sitemapURL: String!
    ): Boolean
}

type GqlSitemapQueries {
    "Get site URL with only server domain appended from sitemap URL"
    siteUrl(
        "Sitemap index XML or sitemap XML URL"
        siteKey: String!
    ): String
}

"Aggregation bucket representation"
type GqlTermFacetData {
    "The aggregation bucket value"
    count: Int
    "The aggregation bucket value"
    value: String
}

"Result of aggregation based on field"
type GqlTermFacetResult {
    "Data based on facets specified in the search"
    data: [GqlTermFacetData]
    "The field that was used to run the aggregation"
    field: String
}

"Children data of tree facet root value"
type GqlTreeFacetData {
    "Number of documents"
    count: Int
    "Filter expression to find matching results for this path"
    filter: String
    "Indicate whether the tree element has any children"
    hasChildren: Boolean
    "Human Readable path"
    humanPath: String
    "key of this facet"
    key: String
    "System path to be used in root path for tree facets"
    rootPath: String
    "The aggregation bucket value"
    value: String
}

"Result of hierarchical facet aggregation"
type GqlTreeFacetResult {
    "Data based on facets specified in the search"
    data: [GqlTreeFacetData]
    "The field that was used to run the aggregation"
    field: String
    "rootPath passed as a parameter"
    rootPath: String
}

type GqlWorkflowEvent {
    "Number of tasks for current user"
    activeWorkflowTaskCountForUser: Int
    "Task that has just been created"
    createdTask: Task
    "Task that has just been ended"
    endedTask: Task
    "Workflow that has just been ended"
    endedWorkflow: Workflow
    "Workflow that has just been started"
    startedWorkflow: Workflow
}

"GraphQL representation of a Jahia group"
type Group implements Principal {
    "Full display name"
    displayName: String
    "List of groups this principal belongs to"
    groupMembership(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Group fields according to specified criteria"
        fieldGrouping: InputFieldGroupingInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int,
        "Return only groups which belong to this site"
        site: String
    ): GroupConnection!
    "Is this principal member of the specified group"
    memberOf(
        "Target group"
        group: String,
        "Site where the group is defined"
        site: String
    ): Boolean
    "Group members"
    members(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Group fields according to specified criteria"
        fieldGrouping: InputFieldGroupingInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int
    ): PrincipalConnection!
    "Group name"
    name: String!
    "Get the corresponding JCR node"
    node: JCRNode
    "Return GROUP principal type"
    principalType: PrincipalType
    "Group property"
    property(
        "The name of the property"
        name: String!
    ): String
    "Site where the group is defined"
    site: JCRSite
}

"A connection to a list of items."
type GroupConnection {
    "a list of edges"
    edges: [GroupEdge]
    "a list of nodes"
    nodes: [Group]
    "details about this specific page"
    pageInfo: PageInfo!
}

"An edge in a connection"
type GroupEdge {
    "cursor marks a unique position or index into the connection"
    cursor: String!
    "index in the connection"
    index: Int
    "The item at the end of the edge"
    node: Group
}

"Query for html filtering settings"
type HTMLFilteringQuery {
    "HTML filtering settings for a site"
    filteringSettings(
        "Site key for the affected site"
        siteKey: String!
    ): GqlHTMLFiltering
}

"Mutation to manipulate html filtering settings on a site"
type HtmlFilteringMutation {
    "Disables html filtering on site"
    disableFiltering(
        "Site key for the affected site"
        siteKey: String!
    ): Boolean
    "Enables html filtering on site"
    enableFiltering(
        "Site key for the affected site"
        siteKey: String!
    ): Boolean
    "Update list of filtered tags for the site"
    updateTags(
        "Site key for the affected site"
        siteKey: String!,
        "Updated list of tags, supply null to remove all tags."
        tags: [String]
    ): Boolean
}

"JCR Mutations"
type JCRMutation {
    "Creates a new JCR node under the specified parent"
    addNode(
        children: [InputJCRNode],
        "The collection of mixin type names"
        mixins: [String],
        "The name of the node to create"
        name: String!,
        "The path or id of the parent node"
        parentPathOrId: String!,
        "The primary node type of the node to create"
        primaryNodeType: String!,
        properties: [InputJCRProperty],
        "If true, use the next available name for a node, appending if needed numbers. Default is false"
        useAvailableNodeName: Boolean
    ): JCRNodeMutation
    "Batch creates a number of new JCR nodes under the specified parent"
    addNodesBatch(
        "The collection of nodes to create"
        nodes: [InputJCRNodeWithParent]!
    ): [JCRNodeMutation]
    "Copy a single node to a different parent node"
    copyNode(
        "The child node types that should be skipped during copy"
        childNodeTypesToSkip: [String],
        "The name of the node at the new location or null if its current name should be preserved"
        destName: String,
        "Path or UUID of the destination parent node to copy the node to"
        destParentPathOrId: String!,
        "Path or UUID of the node to be copied"
        pathOrId: String!
    ): JCRNodeMutation
    "Copy multiple nodes to different parent node(s)"
    copyNodes(
        "The child node types that should be skipped during copy"
        childNodeTypesToSkip: [String],
        nodes: [InputCarriedJCRNode!]!
    ): [JCRNodeMutation]
    "Delete an existing node and all its children"
    deleteNode(
        "The path or id of the node to delete"
        pathOrId: String!
    ): Boolean
    "Import a file under the specified parent"
    importContent(
        "Name of the request part that contains desired import file body"
        file: String!,
        "The path or id of the parent node"
        parentPathOrId: String!,
        "Specify the behaviour in case of existing content, possible values are in the DocumentViewImportHandler class"
        rootBehaviour: Int = 2
    ): Boolean
    "Marks the existing node and all its children for deletion"
    markNodeForDeletion(
        "Optional deletion comment"
        comment: String,
        "The path or id of the node to mark for deletion"
        pathOrId: String!
    ): Boolean
    "Get a collection of nodes that were modified by current GraphQL request"
    modifiedNodes: [JCRNode]
    "Move a single node to a different parent node"
    moveNode(
        "The name of the node at the new location or null if its current name should be preserved"
        destName: String,
        "Path or UUID of the destination parent node to move the node to"
        destParentPathOrId: String!,
        "Path or UUID of the node to be moved"
        pathOrId: String!
    ): JCRNodeMutation
    "Move multiple nodes to different parent node(s)"
    moveNodes(nodes: [InputCarriedJCRNode!]!): [JCRNodeMutation]
    "Mutates an existing node, based on path or id"
    mutateNode(
        "The path or id of the node to mutate"
        pathOrId: String!
    ): JCRNodeMutation
    "Mutates a set of existing nodes, based on path or id"
    mutateNodes(
        "The paths or id ofs the nodes to mutate"
        pathsOrIds: [String]!
    ): [JCRNodeMutation]
    "Mutates a set of existing nodes, based on query execution"
    mutateNodesByQuery(
        "The maximum size of the result set"
        limit: Long,
        "The start offset of the result set"
        offset: Long,
        "The query string"
        query: String!,
        "The query language"
        queryLanguage: QueryLanguage = SQL2
    ): [JCRNodeMutation]
    "Vanity URL Mutation"
    mutateVanityUrls(
        "Paths or UUIDs of vanity URL nodes to mutate"
        pathsOrIds: [String]!
    ): [VanityUrlMappingMutation]
    "Paste a single node to a different parent node"
    pasteNode(
        "The child node types that should be skipped during copy"
        childNodeTypesToSkip: [String],
        "The name of the node at the new location or null if its current name should be preserved"
        destName: String,
        "Path or UUID of the destination parent node to paste the node to"
        destParentPathOrId: String!,
        "Paste mode, either COPY or MOVE"
        mode: PasteMode!,
        "The way to deal with duplicate node names when they are not allowed, either FAIL or RENAME"
        namingConflictResolution: NodeNamingConflictResolutionStrategy = FAIL,
        "Path or UUID of the node to be pasted"
        pathOrId: String!
    ): JCRNodeMutation
    "Paste multiple nodes to different parent node(s)"
    pasteNodes(
        "The child node types that should be skipped during copy"
        childNodeTypesToSkip: [String],
        "Paste mode, either COPY or MOVE"
        mode: PasteMode!,
        "The way to deal with duplicate node names when they are not allowed, either FAIL or RENAME"
        namingConflictResolution: NodeNamingConflictResolutionStrategy = FAIL,
        "Info about nodes to paste and their new parent node(s)"
        nodes: [InputCarriedJCRNode!]!
    ): [JCRNodeMutation]
    "Unmarks the specified node and all its children for deletion"
    unmarkNodeForDeletion(
        "The path or id of the node to unmark for deletion"
        pathOrId: String!
    ): Boolean
}

"Aggregations on JCR Nodes"
type JCRNodeAggregation {
    "Average aggregation"
    avg: StatAggregation
    "Count aggregation"
    count: CountAggregation
    "Max aggregation"
    max: StatAggregation
    "Min aggregation"
    min: StatAggregation
    "Sum aggregation"
    sum: StatAggregation
}

"A connection to a list of items."
type JCRNodeConnection {
    "Get an aggregation by fields on nodes of this connection"
    aggregation: JCRNodeAggregation
    "a list of edges"
    edges: [JCRNodeEdge]
    "a list of nodes"
    nodes: [JCRNode]
    "details about this specific page"
    pageInfo: PageInfo!
}

"GraphQL representation of a JCR node definition"
type JCRNodeDefinition implements JCRItemDefinition {
    "Reports whether this child node can have same-name siblings. In other words, whether the parent node can have more than one child node of this name."
    allowsSameNameSiblings: Boolean!
    "Reports whether the item is to be automatically created when its parent node is created."
    autoCreated: Boolean!
    "Gets the node type that contains the declaration of this definition."
    declaringNodeType: JCRNodeType!
    "Gets the default primary node type that will be assigned to the child node if it is created without an explicitly specified primary node type."
    defaultPrimaryType: JCRNodeType
    "Reports whether the child item is hidden from UI."
    hidden: Boolean!
    "Reports whether the item is mandatory. A mandatory item is one that, if its parent node exists, must also exist."
    mandatory: Boolean!
    "Gets the name of the child item."
    name: String!
    "Reports whether the child item is protected."
    protected: Boolean!
    "Gets the minimum set of primary node types that the child node must have."
    requiredPrimaryType: [JCRNodeType]
}

"An edge in a connection"
type JCRNodeEdge {
    "cursor marks a unique position or index into the connection"
    cursor: String!
    "index in the connection"
    index: Int
    "The item at the end of the edge"
    node: JCRNode
}

"Mutations on a JCR node"
type JCRNodeMutation {
    "Creates a new JCR node under the current node"
    addChild(
        children: [InputJCRNode],
        "The collection of mixin type names"
        mixins: [String],
        "The name of the node to create"
        name: String!,
        "The primary node type of the node to create"
        primaryNodeType: String!,
        properties: [InputJCRProperty],
        "If true, use the next available name for a node, appending if needed numbers. Default is false"
        useAvailableNodeName: Boolean
    ): JCRNodeMutation
    "Batch creates a number of new JCR nodes under the current node"
    addChildrenBatch(
        "The collection of nodes to create"
        nodes: [InputJCRNode]!
    ): [JCRNodeMutation]
    "Adds mixin types on the current node"
    addMixins(
        "The collection of mixin type names"
        mixins: [String]!
    ): [String]
    "Add vanity URL"
    addVanityUrl(
        "The list of vanity url to create"
        vanityUrlInputList: [InputVanityUrl]!
    ): [VanityUrlMappingMutation]
    "Unlock all nodes under the specified node"
    clearAllLocks: Boolean
    "Create new version for the node if the node supports versioning"
    createVersion: Boolean
    "Add wip information"
    createWipInfo(
        "Work in progress information to save"
        wipInfo: InputwipInfo!
    ): Boolean
    "Delete the current node (and its subgraph)"
    delete: Boolean
    "Grant role permissions to specified principal user/group for the given node"
    grantRoles(
        "Name of principal (user/group)"
        principalName: String!,
        "Type of principal (user/group) specified"
        principalType: PrincipalType!,
        "Roles to grant user/group for this node"
        roleNames: [String]!
    ): Boolean
    "Import a file under the current node"
    importContent(
        "Name of the request part that contains desired import file body"
        file: String!
    ): Boolean
    "Lock the node"
    lock(
        "Type of lock, defaults to user"
        type: String = "user"
    ): Boolean
    "Mark the current node (and its subgraph) for deletion"
    markForDeletion(
        "Optional deletion comment"
        comment: String
    ): Boolean
    "Moves the current node to a specified destination path (if destPath is specified) or moves it under the specified node (if parentPathOrId is specified). Either of two parameters is expected."
    move(
        "The target node path of the current node after the move operation"
        destPath: String,
        "The parent node path or id under which the current node will be moved to"
        parentPathOrId: String,
        "Renames current node before moving if the name exists under destination node"
        renameOnConflict: Boolean
    ): String
    "Mutates a set of existing direct sub nodes, based on filters passed as parameter"
    mutateChildren(
        "Filter of child nodes by their names; null to avoid such filtering"
        names: [String],
        "Filter of child nodes by their property values; null to avoid such filtering"
        propertiesFilter: InputNodePropertiesInput,
        "Filter of child nodes by their types; null to avoid such filtering"
        typesFilter: InputNodeTypesInput
    ): [JCRNodeMutation]
    "Mutates an existing sub node, based on its relative path to the current node"
    mutateDescendant(
        "Name or relative path of the sub node to mutate"
        relPath: String!
    ): JCRNodeMutation
    "Mutates a set of existing descendant nodes, based on filters passed as parameter"
    mutateDescendants(
        "Filter of descendant nodes by their property values; null to avoid such filtering"
        propertiesFilter: InputNodePropertiesInput,
        "Filter out and stop recursion on nodes by their property values; null to avoid such filtering"
        recursionPropertiesFilter: InputNodePropertiesInput,
        "Filter out and stop recursion on nodes by their types; null to avoid such filtering"
        recursionTypesFilter: InputNodeTypesInput,
        "Filter of descendant nodes by their types; null to avoid such filtering"
        typesFilter: InputNodeTypesInput
    ): [JCRNodeMutation]
    "Mutates or creates a set of properties on the current node"
    mutateProperties(
        "The names of the JCR properties; null to obtain all properties"
        names: [String]
    ): [JCRPropertyMutation]
    "Mutates or creates a property on the current node"
    mutateProperty(
        "The name of the property to update"
        name: String!
    ): JCRPropertyMutation
    "Update a vanity URL"
    mutateVanityUrl(
        "The url to edit"
        url: String!
    ): VanityUrlMappingMutation
    "Update vanity URLs"
    mutateVanityUrls(
        "Filter by languages"
        languages: [String]
    ): [VanityUrlMappingMutation]
    "Mutate wip information"
    mutateWipInfo(
        "Work in progress information to save"
        wipInfo: InputwipInfo!
    ): Boolean
    "Get the graphQL representation of the node currently being mutated"
    node: JCRNode
    "Publish the node in certain languages"
    publish(
        "Publish all sub tree including sub pages. Default is false."
        includeSubTree: Boolean = false,
        "Languages to publish the node in"
        languages: [String],
        "Publish all sub and related nodes. Default is true."
        publishSubNodes: Boolean = true
    ): Boolean
    "Removes mixin types on the current node"
    removeMixins(
        "The collection of mixin type names"
        mixins: [String]!
    ): [String]
    "Rename the current node"
    rename(
        "The new name of the node"
        name: String!
    ): String
    "Reorder child nodes according to the list of names passed"
    reorderChildren(
        "List of child node names in the desired order"
        names: [String]!,
        "The target position of reordered child nodes. The default value is inplace."
        position: ReorderedChildrenPosition = INPLACE
    ): Boolean
    "Remove/deny roles to specified principal user/group for the given node"
    revokeRoles(
        "Name of principal (user/group)"
        principalName: String!,
        "Type of principal (user/group) specified"
        principalType: PrincipalType!,
        "Roles to grant user/group for this node"
        roleNames: [String]!
    ): Boolean
    "Mutates or creates a set of properties on the current node"
    setPropertiesBatch(
        "The collection of JCR properties to set"
        properties: [InputJCRProperty]
    ): [JCRPropertyMutation]
    startWorkflow(definition: String, language: String): Boolean
    "Return image transformation mutation"
    transformImage(
        "name of target file, if different"
        name: String,
        "target path, if different"
        targetPath: String
    ): GqlJcrImageTransformMutation
    "Unlock the node"
    unlock(
        "Type of lock, defaults to user"
        type: String = "user"
    ): Boolean
    "Unmark this node and all the sub-nodes for deletion"
    unmarkForDeletion: Boolean
    "Unpublish the node in certain languages"
    unpublish(
        "Languages to publish the node in"
        languages: [String]
    ): Boolean
    "Get the identifier of the node currently being mutated"
    uuid: String
    "Return zip mutation"
    zip: ZipFileMutation
}

"GraphQL representation of a JCR node type"
type JCRNodeType {
    "Returns true if this is an abstract node type; returns false otherwise."
    abstract: Boolean
    "Node type displayable name"
    displayName(
        "Language"
        language: String!
    ): String
    "Returns true if nodes of this type must support orderable child nodes; returns false otherwise."
    hasOrderableChildNodes: Boolean
    "Node type icon"
    icon: String
    "Reports if the current node type matches the nodetype(s) passed in parameter"
    isNodeType(
        "Node type name"
        type: InputNodeTypesInput!
    ): Boolean!
    "Returns true if this is a mixin type; returns false otherwise."
    mixin: Boolean
    "Node type name"
    name: String
    "Returns an array containing the child node definitions of this node type."
    nodes(
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput
    ): [JCRNodeDefinition]
    "Returns the name of the primary item (one of the child items of the nodes of this node type). If this node has no primary item, then this method null."
    primaryItem: JCRItemDefinition
    "Returns an array containing the property definitions of this node type."
    properties(
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput
    ): [JCRPropertyDefinition]
    "Returns true if the node type is queryable."
    queryable: Boolean
    "Returns all subtypes of this node type in the node type inheritance hierarchy."
    subTypes(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int
    ): JCRNodeTypeConnection
    "Returns all supertypes of this node type in the node type inheritance hierarchy."
    supertypes(
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput
    ): [JCRNodeType]
    "System ID of the node type, corresponding to the name of the module declaring it."
    systemId: String
}

"A connection to a list of items."
type JCRNodeTypeConnection {
    "a list of edges"
    edges: [JCRNodeTypeEdge]
    "a list of nodes"
    nodes: [JCRNodeType]
    "details about this specific page"
    pageInfo: PageInfo!
}

"An edge in a connection"
type JCRNodeTypeEdge {
    "cursor marks a unique position or index into the connection"
    cursor: String!
    "index in the connection"
    index: Int
    "The item at the end of the edge"
    node: JCRNodeType
}

"GraphQL representation of a JCR property."
type JCRProperty {
    "The value of the JCR property as a Boolean in case the property is single-valued, null otherwise"
    booleanValue: Boolean
    "The values of the JCR property as Booleans in case the property is multiple-valued, null otherwise"
    booleanValues: [Boolean]
    "The value of the JCR property rendered by the specified choicelist renderer in case the property is single-valued, null otherwise"
    choicelistValue(
        "The language"
        language: String,
        "The choicelist renderer name to be used"
        renderer: String
    ): String
    "The value of the JCR property rendered by the specified choicelist renderer in case the property is multiple-valued, null otherwise"
    choicelistValues(
        "The language"
        language: String,
        "The choicelist renderer name to be used"
        renderer: String
    ): [String]
    "The decrypted value of the JCR encrypted property as a String in case the property is single-valued, null otherwise"
    decryptedValue: String
    "The decrypted values of the JCR encrypted property as a Strings in case the property is multiple-valued, null otherwise"
    decryptedValues: [String]
    "Returns the property definition that applies to this property."
    definition: JCRPropertyDefinition
    "The value of the JCR property as a Float in case the property is single-valued, null otherwise"
    floatValue: Float
    "The values of the JCR property as Floats in case the property is multiple-valued, null otherwise"
    floatValues: [Float]
    "Whether the property is internationalized"
    internationalized: Boolean!
    "The language the property value was obtained in for internationalized properties; null for non-internationalized ones"
    language: String
    "The value of the JCR property as a Long in case the property is single-valued, null otherwise"
    longValue: Long
    "The values of the JCR property as Longs in case the property is multiple-valued, null otherwise"
    longValues: [Long]
    "The name of the JCR property"
    name: String!
    "The GraphQL representation of the JCR node the property belongs to."
    node: JCRNode!
    "The value of the JCR property casted as date and returned in this string format: [yyyy-MM-dd'T'HH:mm:ss.SSS] in case the property is single-valued, null otherwise"
    notZonedDateValue: String
    "The values of the JCR property casted as date and returned in this string format: [yyyy-MM-dd'T'HH:mm:ss.SSS] in case the property is multiple-valued, null otherwise"
    notZonedDateValues: [String]
    "The path of the JCR property"
    path: String!
    "GraphQL representation of the node this property references in case the property is single-valued, null otherwise"
    refNode: JCRNode
    "GraphQL representations of the nodes this property references in case the property is multiple-valued, null otherwise"
    refNodes: [JCRNode]
    "The binary size of the JCR node as a Long, null otherwise"
    size: Long
    "The type of the JCR property"
    type: JCRPropertyType!
    "The value of the JCR property as a String in case the property is single-valued, null otherwise"
    value: String
    "The values of the JCR property as Strings in case the property is multiple-valued, null otherwise"
    values: [String]
}

"A connection to a list of items."
type JCRPropertyConnection {
    "a list of edges"
    edges: [JCRPropertyEdge]
    "a list of nodes"
    nodes: [JCRProperty]
    "details about this specific page"
    pageInfo: PageInfo!
}

"GraphQL representation of a JCR property definition"
type JCRPropertyDefinition implements JCRItemDefinition {
    "Reports whether the item is to be automatically created when its parent node is created."
    autoCreated: Boolean!
    "Property constraints"
    constraints: [String]!
    "Gets the node type that contains the declaration of this definition."
    declaringNodeType: JCRNodeType!
    "Gets the displayable name of the property for the given language code. Return the system name in case the label doesn't exists"
    displayName(
        "Language"
        language: String!
    ): String!
    "Reports whether the child item is hidden from UI."
    hidden: Boolean!
    "Reports whether this property has language dependant values."
    internationalized: Boolean!
    "Reports whether the item is mandatory. A mandatory item is one that, if its parent node exists, must also exist."
    mandatory: Boolean!
    "Reports whether this property can have multiple values."
    multiple: Boolean!
    "Gets the name of the child item."
    name: String!
    "Reports whether the child item is protected."
    protected: Boolean!
    "Gets the required type of the property."
    requiredType: JCRPropertyType!
}

"An edge in a connection"
type JCRPropertyEdge {
    "cursor marks a unique position or index into the connection"
    cursor: String!
    "index in the connection"
    index: Int
    "The item at the end of the edge"
    node: JCRProperty
}

"Mutations on a JCR property"
type JCRPropertyMutation {
    "Add a new value to this property"
    addValue(language: String, option: JCRPropertyOption, type: JCRPropertyType, value: String): Boolean
    "Add new values to this property"
    addValues(language: String, option: JCRPropertyOption, type: JCRPropertyType, values: [String]): Boolean
    "Delete this property"
    delete(language: String): Boolean
    "Get the path of the property currently being mutated"
    path: String
    "Get the graphQL representation of the property currently being mutated"
    property: JCRProperty
    "Remove a new value from this property"
    removeValue(language: String, option: JCRPropertyOption, type: JCRPropertyType, value: String): Boolean
    "Remove values from this property"
    removeValues(language: String, option: JCRPropertyOption, type: JCRPropertyType, values: [String]): Boolean
    "Set property value"
    setValue(language: String, option: JCRPropertyOption, type: JCRPropertyType, value: String): Boolean
    "Set property values"
    setValues(language: String, option: JCRPropertyOption, type: JCRPropertyType, values: [String]): Boolean
}

"JCR Queries"
type JCRQuery {
    "Retrieves the number of active workflow tasks for the current user"
    activeWorkflowTaskCountForUser: Int @deprecated(reason: "Use /workflow/activeWorkflowTaskCountForUser instead")
    "Get GraphQL representation of a node by its UUID"
    nodeById(
        "The UUID of the node"
        uuid: String!,
        """

        Check node validity in this language.

        Node validity is determined by multiple conditions:

        * The node exists
        * The node is not attached to a visibility condition preventing its display
        * The node is published in this language
        * The node's language has not been invalidated.
        """
        validInLanguage: String
    ): JCRNode
    "Get GraphQL representation of a node by its path"
    nodeByPath(
        "The path of the node"
        path: String!,
        """

        Check node validity in this language.

        Node validity is determined by multiple conditions:

        * The node exists
        * The node is not attached to a visibility condition preventing its display
        * The node is published in this language
        * The node's language has not been invalidated.
        """
        validInLanguage: String
    ): JCRNode
    "Get a node type by its name"
    nodeTypeByName(
        "Node type name"
        name: String!
    ): JCRNodeType
    "Get a list of nodetypes based on specified parameter"
    nodeTypes(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Filter on node type"
        filter: InputNodeTypesListInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int
    ): JCRNodeTypeConnection
    "Get multiple node types by their names"
    nodeTypesByNames(
        "Node type names"
        names: [String]!
    ): [JCRNodeType]
    "handles query nodes with QOM factory"
    nodesByCriteria(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "The criteria to fetch nodes by"
        criteria: InputGqlJcrNodeCriteriaInput!,
        "Filter by GraphQL field values"
        fieldFilter: InputFieldFiltersInput,
        "Group fields by criteria"
        fieldGrouping: InputFieldGroupingInput,
        "sort by GraphQL field values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int
    ): JCRNodeConnection
    "Get GraphQL representations of multiple nodes by their UUIDs"
    nodesById(
        "The UUIDs of the nodes"
        uuids: [String!]!,
        """

        Check node validity in this language.

        Node validity is determined by multiple conditions:

        * The node exists
        * The node is not attached to a visibility condition preventing its display
        * The node is published in this language
        * The node's language has not been invalidated.
        """
        validInLanguage: String
    ): [JCRNode]!
    "Get GraphQL representations of multiple nodes by their paths"
    nodesByPath(
        "The paths of the nodes"
        paths: [String!]!,
        """

        Check node validity in this language.

        Node validity is determined by multiple conditions:

        * The node exists
        * The node is not attached to a visibility condition preventing its display
        * The node is published in this language
        * The node's language has not been invalidated.
        """
        validInLanguage: String
    ): [JCRNode]!
    "Get GraphQL representations of nodes using a query language supported by JCR"
    nodesByQuery(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Group fields by criteria"
        fieldGrouping: InputFieldGroupingInput,
        "Sort by GraphQL field values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "Language to use for the query"
        language: String,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int,
        "The query string"
        query: String!,
        "The query language"
        queryLanguage: QueryLanguage = SQL2
    ): JCRNodeConnection
    "Get the workspace of the query"
    workspace: Workspace!
}

"GraphQL representation of a site node"
type JCRSite implements JCRNode {
    "Get ACL info for this node"
    acl: GqlAcl
    "Get the last modified date of this node and its descendants. The recursion in descendants can be controlled by recursionTypesFilter. If no filter is passed, recursion will stop by default on sub pages."
    aggregatedLastModifiedDate(
        "The language"
        language: String,
        "Stop recursion on graphql field values"
        recursionTypesFilter: InputNodeTypesInput
    ): String
    "Aggregated publication info about the JCR node"
    aggregatedPublicationInfo(
        "Publication language"
        language: String!,
        "Whether to take references into account when calculating the aggregated publication status"
        references: Boolean = false,
        "Whether to take sub-nodes into account when calculating the aggregated publication status"
        subNodes: Boolean = false
    ): GqlPublicationInfo!
    "Render URL in ajax mode"
    ajaxRenderUrl: String
    "Returns a list of types allowed under the provided node"
    allowedChildNodeTypes(
        "Filter by GraphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Whether all sub-types of allowed child node types should be included"
        includeSubTypes: Boolean = true
    ): [JCRNodeType]
    "GraphQL representations of the ancestor nodes of the JCR node, top down direction"
    ancestors(
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "The path of the topmost ancestor node to include in the result; null or empty string to include all the ancestor nodes"
        upToPath: String
    ): [JCRNode]!
    "GraphQL representations of the child nodes, according to parameters passed"
    children(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Group fields according to specified criteria"
        fieldGrouping: InputFieldGroupingInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "Include the current node itself in results"
        includesSelf: Boolean = false,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "Filter of child nodes by their names; null to avoid such filtering"
        names: [String],
        "fetching only nodes after this node (inclusive)"
        offset: Int,
        "Filter of child nodes by their property values; null to avoid such filtering"
        propertiesFilter: InputNodePropertiesInput,
        "Filter of child nodes by their types; null to avoid such filtering"
        typesFilter: InputNodeTypesInput,
        "Language to use to get children"
        validInLanguage: String
    ): JCRNodeConnection
    "Site default language"
    defaultLanguage: String
    "Read default Work in progress information. Set by \"wip.checkbox.checked\" system proprety"
    defaultWipInfo: wipInfo
    "Returns the node definition that applies to this node."
    definition: JCRNodeDefinition
    "GraphQL representation of a descendant node, based on its relative path"
    descendant(
        "Name or relative path of the sub node"
        relPath: String!
    ): JCRNode
    "GraphQL representations of the descendant nodes, according to parameters passed"
    descendants(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Group fields according to specified criteria"
        fieldGrouping: InputFieldGroupingInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int,
        "Filter of descendant nodes by their property values; null to avoid such filtering"
        propertiesFilter: InputNodePropertiesInput,
        "Filter out and stop recursion on nodes by their property values; null to avoid such filtering"
        recursionPropertiesFilter: InputNodePropertiesInput,
        "Filter out and stop recursion on nodes by their types; null to avoid such filtering"
        recursionTypesFilter: InputNodeTypesInput,
        "Filter of descendant nodes by their types; null to avoid such filtering"
        typesFilter: InputNodeTypesInput,
        "Language to use to get children"
        validInLanguage: String
    ): JCRNodeConnection
    "Site description"
    description: String
    "The displayable name of the JCR node"
    displayName(
        "Language"
        language: String
    ): String
    "Returns the first parent of the current node that can be displayed in full page. If no matching node is found, null is returned."
    displayableNode: JCRNode
    "Returns the next available name for a node, appending if needed numbers."
    findAvailableNodeName(language: String, nodeType: String): String
    "Check if the current user has a specific permission"
    hasPermission(
        "The name of the permission"
        permissionName: String!
    ): Boolean
    "Returns the node of the home page"
    homePage: JCRNode
    "Retrieves a collection of module IDs, which are installed on the site, the node belongs to"
    installedModules: [String]
    "Retrieves a collection of module IDs, which are installed on the site, the node belongs to, as well as dependencies of those modules"
    installedModulesWithAllDependencies: [String]
    "Check if the node as a renderable template associated with it (not a view a template)."
    isDisplayableNode: Boolean
    "true if node is under a mounted node"
    isExternal: Boolean!
    "Reports if the current node matches the nodetype(s) passed in parameter"
    isNodeType(
        "Node type name"
        type: InputNodeTypesInput!
    ): Boolean!
    "Site languages"
    languages: [JCRSiteLanguage]
    "Check if the given locales need translation, by comparing last modifications dates with already existing translations"
    languagesToTranslate(
        "The languages to check"
        languagesToCheck: [String],
        "The translated languages"
        languagesTranslated: [String]
    ): [String]
    "Retrieve lock info of the current node"
    lockInfo: LockInfo
    "Returns edit lock status of the current node object"
    lockedAndCannotBeEdited: Boolean
    "Returns an array of <code>NodeType</code> objects representing the mixin node types in effect for this node."
    mixinTypes(
        "Filter by GraphQL fields values"
        fieldFilter: InputFieldFiltersInput
    ): [JCRNodeType]!
    "The name of the JCR node this object represents"
    name: String!
    "GraphQL representation of this node in certain workspace"
    nodeInWorkspace(
        "The target workspace"
        workspace: Workspace!
    ): JCRNode
    "Get information on the operations that can be done on this node"
    operationsSupport: GqlOperationsSupport
    "GraphQL representation of the parent JCR node"
    parent: JCRNode
    "The path of the JCR node this object represents"
    path: String!
    "Get the primary node type of this node"
    primaryNodeType: JCRNodeType!
    "GraphQL representations of the properties in the requested language"
    properties(
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "The language to obtain the properties in; must be a valid language code in case any internationalized properties are requested, does not matter for non-internationalized ones"
        language: String,
        "The names of the JCR properties; null to obtain all properties"
        names: [String],
        "When set to true, returns the node in the default language if there is no translation for the requested language. Returns null if the option \"Replace untranslated content with the default language content\" is not activated for the site of the requested node. Will also return null if there is no translation for the default language."
        useFallbackLanguage: Boolean = false
    ): [JCRProperty]!
    "The GraphQL representation of the property in the requested language; null if the property does not exist"
    property(
        "The language to obtain the property in; must be a valid language code for internationalized properties, does not matter for non-internationalized ones"
        language: String,
        "The name of the JCR property"
        name: String!,
        "When set to true, returns the node in the default language if there is no translation for the requested language. Returns null if the option \"Replace untranslated content with the default language content\" is not activated for the site of the requested node. Will also return null if there is no translation for the default language."
        useFallbackLanguage: Boolean = false
    ): JCRProperty
    "GraphQL representations of the reference properties that target the current JCR Node"
    references(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int
    ): JCRPropertyConnection!
    "Gets the fully rendered content for this node"
    renderedContent(
        "Rendering context configuration"
        contextConfiguration: String,
        "Is edit mode"
        isEditMode: Boolean,
        "Language"
        language: String,
        "Main resource path"
        mainResourcePath: String,
        "Additional request attributes"
        requestAttributes: [InputRenderRequestAttributeInput],
        "Template type"
        templateType: String,
        "Name of the view"
        view: String
    ): RenderedNode
    "Site server name"
    serverName: String
    "GraphQL representation of the site the JCR node belongs to, or the system site in case the node does not belong to any site"
    site: JCRSite
    "Site key"
    sitekey: String
    "Returns languages of available translations for this node"
    translationLanguages(
        "Optional: Return languages only if it is active for the site"
        isActiveOnly: Boolean
    ): [String]
    "GraphQL representations of the reference properties that target the current JCR Node"
    usages(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int
    ): UsageConnection!
    "The UUID of the JCR node this object represents"
    uuid: String!
    "Get vanity URLs from the current node filtered by the parameters"
    vanityUrls(
        "Filter results based on graphql field values"
        fieldFilter: InputFieldFiltersInput,
        "Languages"
        languages: [String]
    ): [VanityUrl]
    "Read work in progress information for a given node"
    wipInfo: wipInfo
    "Get the workspace of the query"
    workspace: Workspace!
}

"Site language representation"
type JCRSiteLanguage {
    "Is this language active in edit"
    activeInEdit: Boolean
    "Is this language active in live"
    activeInLive: Boolean
    "Display name"
    displayName(
        "Language"
        language: String
    ): String
    "Language code"
    language: String
    "Is this language mandatory"
    mandatory: Boolean
}

"GraphQL representation of a Tag"
type JCRTag {
    "The name of the tag"
    name: String!
    "Get the occurences of a tag"
    occurences: Long!
}

"JCR Queries"
type JCRTags {
    "Handles suggestion tags queries"
    suggest(
        "Max number of tags to get"
        limit: Long!,
        "Minimal occurrences to return a tag"
        minCount: Long,
        "Offset value"
        offset: Long,
        "The prefix of the tags"
        prefix: String!,
        "Sort the tags by occurrences"
        sortByCount: Boolean,
        "The root node to start the search"
        startPath: String!
    ): [JCRTag]
}

type JWTToken {
    claims: String
    id: String
    token: String
}

"Admin mutations"
type JahiaAdminMutation {
    "Mutate an OSGi configuration"
    configuration(
        "If factory pid, configiration identifier (filename suffix)"
        identifier: String,
        "Configuration pid ot factory pid"
        pid: String!,
        "Do not create new configuration, update existing one"
        updateOnly: Boolean = false
    ): GqlConfigurationMutation
    "Create a task"
    createTask(
        "Task name"
        name: String!,
        "Service name"
        service: String!
    ): Boolean
    "Delete a task"
    deleteTask(
        "Task name"
        name: String!,
        "Service name"
        service: String!
    ): Boolean
    "Shutdown the server"
    shutdown(
        "Do not send the shutdown event"
        dryRun: Boolean,
        "Force immediate shutdown even if server is busy"
        force: Boolean,
        "In seconds, maximum time to wait for server to be ready to shutdown"
        timeout: Int
    ): Boolean
}

"Jahia admin queries root"
type JahiaAdminQuery {
    "Read an OSGi configuration"
    configuration(
        "If factory pid, configuration identifier (filename suffix)"
        identifier: String,
        "Configuration pid ot factory pid"
        pid: String!
    ): GqlConfigurationQuery
    "Details about the database Jahia is connected to"
    database: JahiaDatabase
    "HealthCheck node"
    healthCheck(severity: GqlProbeSeverity): GqlHealthCheck
    "Get server load"
    load: Load
    "Get jobs scheduler"
    scheduler: GqlScheduler
    "Details about the system hosting Jahia"
    system: JahiaSystem
    "Lists tasks running on the Jahia server. A server should not be stopped/restarted when any of these tasks are present. These tasks are specific to the server being queried and are not shared accorss a cluster"
    tasks: [task]
    "Version of the running Jahia instance"
    version: JahiaVersion
}

"Details about the database Jahia is connected to"
type JahiaDatabase {
    "Name of the driver used to connect to the database"
    driverName: String
    "Version of the driver used to connect to the database"
    driverVersion: String
    "Name of the database vendor"
    name: String
    "Type of database specified in Jahia configuration"
    type: String
    "Version of the database"
    version: String
}

"Details about the system used to run Jahia"
type JahiaSystem {
    "Details about the operating system"
    java: JahiaSystemJava
    "Details about the operating system"
    os: JahiaSystemOs
}

"Details about the system OS used to run Jahia"
type JahiaSystemJava {
    "Java Runtime name"
    runtimeName: String
    "Java Runtime version"
    runtimeVersion: String
    "Java vendor"
    vendor: String
    "Java vendor version"
    vendorVersion: String
}

"Details about the system OS used to run Jahia"
type JahiaSystemOs {
    "Operating System Architecture (amd64, arm64, ...)"
    architecture: String
    "Operating System Name"
    name: String
    "Operating System Version"
    version: String
}

"Version of the running Jahia instance"
type JahiaVersion {
    "Build number of the running Jahia instance"
    build: String
    "Build date of the running Jahia instance"
    buildDate: String
    "Flag returning if running Jahia instance is a SNAPSHOT"
    isSnapshot: Boolean
    "Release of the running Jahia instance"
    release: String
}

"Details about the Jahia cluster journal"
type Journal {
    "The latest revision of the journal on the cluster"
    globalRevision: Long
    "Is the journal in sync across all nodes of a cluster"
    isClusterSync: Boolean
    "The latest revision of the journal on the current node"
    localRevision: JournalRevision
    "The latest revisions of the journal for all cluster nodes"
    revisions: [JournalRevision]
}

"Details about one journal revision"
type JournalRevision {
    "The revision"
    revision: Long
    "The cluster node server Id"
    serverId: String
}

"Server load"
type Load {
    "Get requests load"
    requests: LoadValue
    "Get JCR Sessions load"
    sessions: LoadValue
}

"Load value"
type LoadValue {
    "Exponential moving average"
    average(interval: LoadInterval): Float
    "Instantaneous count"
    count: Int
}

"Information on node lock"
type LockInfo {
    "Can the node be locked"
    canLock: Boolean
    "Can the node be unlocked"
    canUnlock: Boolean
    "Is node lockable"
    details(
        "language in which to retrieve details"
        language: String
    ): [GqlLockDetail]
    "Is node lockable"
    lockable: Boolean
}

"Root mutation type"
type Mutation {
    "Admin Mutation"
    admin: AdminMutation!
    "Main access field to the DX GraphQL Form mutation API"
    forms: GqlEditorFormMutations
    "JCR Mutation"
    jcr(
        "Should save"
        save: Boolean = true,
        "The name of the workspace to fetch the node from; either 'edit', 'live', or null to use 'edit' by default"
        workspace: Workspace
    ): JCRMutation
    "Generate a new JWT token"
    jwtToken(ips: [String], referer: [String], scopes: [String]!): JWTToken
    mutateWorkflows(definition: String): [WorkflowMutation]
    "Entry point for site settings mutations"
    siteSettings: SiteSettingsMutation
}

"GraphQL representation of node type tree entry"
type NodeTypeTreeEntry {
    "Return the children if any"
    children: [NodeTypeTreeEntry]
    "Return icon URL with png extension"
    iconURL(
        "if true (default) add '.png' to the icon path."
        addExtension: Boolean = true
    ): String
    "Return uniq identifier for tree entry"
    id: String
    "Return the i18n label"
    label: String
    "Return nodeType name"
    name: String
    "Return nodeType"
    nodeType: JCRNodeType
    "Return the parent tree entry (if any)"
    parent: NodeTypeTreeEntry
}

"Information about pagination in a connection."
type PageInfo {
    "When paginating forwards, the cursor to continue."
    endCursor: String
    "When paginating forwards, are there more items?"
    hasNextPage: Boolean!
    "When paginating backwards, are there more items?"
    hasPreviousPage: Boolean!
    "When paginating forwards, the cursor to continue."
    nodesCount: Int
    "When paginating backwards, the cursor to continue."
    startCursor: String
    "When paginating forwards, the cursor to continue."
    totalCount: Int
}

"Token details"
type PersonalApiToken {
    "Creation date and time"
    createdAt: String
    "Expiration date"
    expireAt: String
    "The key of the token, used for looking it up"
    key: String
    "The name of the token"
    name: String
    "Token state"
    state: TokenState
    "Last modification date and time"
    updatedAt: String
    "The user associated to the token"
    user: User
}

"A connection to a list of items."
type PersonalApiTokenConnection {
    "a list of edges"
    edges: [PersonalApiTokenEdge]
    "a list of nodes"
    nodes: [PersonalApiToken]
    "details about this specific page"
    pageInfo: PageInfo!
}

"An edge in a connection"
type PersonalApiTokenEdge {
    "cursor marks a unique position or index into the connection"
    cursor: String!
    "index in the connection"
    index: Int
    "The item at the end of the edge"
    node: PersonalApiToken
}

"Mutations for Personal Api Tokens"
type PersonalApiTokensMutation {
    "Create a new token"
    createToken(
        "Expiration date of the token"
        expireAt: String,
        "Name to give to the token"
        name: String!,
        "Scopes attached to this token"
        scopes: [String],
        "The site the user belongs to, null if global user"
        site: String,
        "State to give the newly created token"
        state: TokenState
    ): String
    "Delete an existing token"
    deleteToken(
        "The token key"
        key: String!
    ): Boolean
    "Update an existing token"
    updateToken(
        "Expiration date of the token, use empty string to unset expiration date"
        expireAt: String,
        "The token key"
        key: String!,
        "Name to give to the token"
        name: String,
        "Scopes attached to this token"
        scopes: [String],
        "State to give the token"
        state: TokenState
    ): Boolean
}

"Queries for Personal Api Tokens"
type PersonalApiTokensQuery {
    "Get available scopes"
    availableScopes: [GqlScope]
    "Get token details, based on key"
    tokenByKey(
        "The token key"
        key: String!
    ): PersonalApiToken
    "Get token details, based on user and token name"
    tokenByUserAndName(
        "The site the user belongs to, null if global user"
        site: String,
        "The token name"
        tokenName: String!,
        "The user id"
        userId: String!
    ): PersonalApiToken
    "List tokens attached to the provided user ID and site key"
    tokens(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int,
        "The site the user belongs to, null if global user"
        site: String,
        "If a userId is provided, only returns tokens assigned to that user."
        userId: String
    ): PersonalApiTokenConnection
    "Check if the token is valid for authentication"
    verifyToken(
        "The token"
        token: String!
    ): Boolean
}

"A connection to a list of items."
type PrincipalConnection {
    "a list of edges"
    edges: [PrincipalEdge]
    "a list of nodes"
    nodes: [Principal]
    "details about this specific page"
    pageInfo: PageInfo!
}

"An edge in a connection"
type PrincipalEdge {
    "cursor marks a unique position or index into the connection"
    cursor: String!
    "index in the connection"
    index: Int
    "The item at the end of the edge"
    node: Principal
}

"Root query type"
type Query {
    "Admin Queries"
    admin: AdminQuery!
    "Get the current user"
    currentUser: Current_32_user
    "Main access field to the DX GraphQL Dashboard API"
    dashboard: GqlDashboard
    "Main access field to the DX GraphQL Form API"
    forms: GqlEditorForms
    "JCR Queries"
    jcr(
        "The name of the workspace to fetch the node from; either EDIT, LIVE, or null to use EDIT by default"
        workspace: Workspace
    ): JCRQuery!
    "Main access field to the NPM helpers"
    npm: GqlNpmHelper
    "Search in Jahia using Augmented Search"
    search(
        "Boost specification"
        boosts: Inputboost,
        "Filtering specification"
        filters: Inputfilter,
        "Function score id"
        functionScoreId: String,
        "Language to search in"
        language: String = "en",
        "Search query"
        q: String!,
        "Where to search, can be CONTENT or FILES"
        searchIn: [SearchIn],
        "List of unique site identifiers. Search across all sites if not provided"
        siteKeys: [String],
        "Can be LIVE or EDIT"
        workspace: Workspace = LIVE
    ): augmentedSearchResult
    "Entry point for siteSettings queries"
    siteSettings: SiteSettingsQuery
    "Tag Queries"
    tag: JCRTags
    "Retrieves the number of active workflow tasks for the current user"
    workflow: WorkflowService
}

"Rendering result for a node"
type RenderedNode {
    "Contraints on this node"
    constraints: String
    "Rendering output"
    output: String
    "List of static assets"
    staticAssets(
        "Assets type"
        type: String!
    ): [StaticAsset]
}

"Rendering result for a node"
type SimpleRenderedNode {
    "Id of of the rendering node"
    id: String
    "Rendering output"
    output: String
}

"Site settings mutations entry point"
type SiteSettingsMutation {
    "HTML filtering mutation"
    htmlFiltering: HtmlFilteringMutation
}

"Entry point for site settings queries"
type SiteSettingsQuery {
    "HTML filtering settings queries"
    htmlFiltering: HTMLFilteringQuery
}

"Simple numeric aggregation on properties values"
type StatAggregation {
    "The date representation of a JCR node property"
    datePropertyValue(
        "The language to obtain the property in; must be a valid language code for internationalized properties, does not matter for non-internationalized ones"
        language: String,
        "The name of the JCR property"
        name: String!
    ): String
    "The float representation of a JCR node property"
    floatPropertyValue(
        "The language to obtain the property in; must be a valid language code for internationalized properties, does not matter for non-internationalized ones"
        language: String,
        "The name of the JCR property"
        name: String!
    ): Float
    "The long representation of a JCR node property"
    longPropertyValue(
        "The language to obtain the property in; must be a valid language code for internationalized properties, does not matter for non-internationalized ones"
        language: String,
        "The name of the JCR property"
        name: String!
    ): Long
}

"Representation of a static assert"
type StaticAsset {
    "Asset key"
    key: String
    "Asset option"
    option(
        "Asset option name"
        name: String!
    ): String
}

"Root subscription type"
type Subscription {
    "Subscription on background jobs"
    backgroundJobSubscription(
        "Subscribe only to job with matching group names"
        filterByGroups: [String],
        "Subscribe only to job with matching job states"
        filterByJobStates: [GqlBackgroundJobState],
        "Subscribe only to job with matching job statuses"
        filterByJobStatuses: [GqlBackgroundJobStatus],
        "Subscribe only to job with matching names"
        filterByNames: [String],
        "Subscribe only to job with matching user keys"
        filterByUserKey: [String],
        "The target scheduler for listening jobs"
        targetScheduler: TargetScheduler = BOTH
    ): GqlBackgroundJob
    "Lock the node for edition and subscribe to hold the lock. The node is automatically unlocked when the client disconnect or close the connection"
    subscribeToEditorLock(
        "An ID generated client side used to identify the lock"
        editorID: String!,
        "Uuid of the node to be locked."
        nodeId: String!
    ): String
    "Subscription on workflows"
    workflowEvent: GqlWorkflowEvent
}

"Workflow task"
type Task {
    "Task assignee"
    assignee: User
    "Creation time"
    creationTime: String
    "Due date"
    dueDate: String
    "Task id"
    id: String
    "Task name"
    name: String
    "Parent workflow"
    workflow: Workflow
}

"A connection to a list of items."
type TaskConnection {
    "a list of edges"
    edges: [TaskEdge]
    "a list of nodes"
    nodes: [Task]
    "details about this specific page"
    pageInfo: PageInfo!
}

"An edge in a connection"
type TaskEdge {
    "cursor marks a unique position or index into the connection"
    cursor: String!
    "index in the connection"
    index: Int
    "The item at the end of the edge"
    node: Task
}

"GraphQL representation of a usage (node holding the reference + list of properties referencing the caller)"
type Usage {
    "The GraphQL representation of the JCR node the property belongs to."
    node: JCRNode!
    "The GraphQL representation of the references on this node."
    properties: [JCRProperty]!
}

"A connection to a list of items."
type UsageConnection {
    "a list of edges"
    edges: [UsageEdge]
    "a list of nodes"
    nodes: [Usage]
    "details about this specific page"
    pageInfo: PageInfo!
}

"An edge in a connection"
type UsageEdge {
    "cursor marks a unique position or index into the connection"
    cursor: String!
    "index in the connection"
    index: Int
    "The item at the end of the edge"
    node: Usage
}

"GraphQL representation of a Jahia user"
type User implements Principal {
    "Full display name"
    displayName: String
    "Email of the user"
    email: String
    "First name of the user"
    firstname: String
    "List of groups this principal belongs to"
    groupMembership(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Group fields according to specified criteria"
        fieldGrouping: InputFieldGroupingInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int,
        "Return only groups which belong to this site"
        site: String
    ): GroupConnection!
    "Preferred language by the user"
    language: String
    "Last name of the user"
    lastname: String
    "Displays if user is locked"
    locked: Boolean
    "Is this principal member of the specified group"
    memberOf(
        "Target group"
        group: String,
        "Site where the group is defined"
        site: String
    ): Boolean
    "User name"
    name: String! @deprecated(reason: "Deprecated")
    "Get the corresponding JCR node"
    node: JCRNode
    "User organization"
    organization: String
    "Return USER principal type"
    principalType: PrincipalType
    "User property"
    property(
        "The name of the property"
        name: String!
    ): String
    "Site where the user is defined"
    site: JCRSite
    "Username of the user"
    username: String!
}

"User admin queries"
type UserAdminQuery {
    "Get a user"
    user(
        "Site where the user is defined"
        site: String,
        "User name"
        username: String!
    ): User
    "Get users list"
    users(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Group fields according to specified criteria"
        fieldGrouping: InputFieldGroupingInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int
    ): UserConnection
}

"A connection to a list of items."
type UserConnection {
    "a list of edges"
    edges: [UserEdge]
    "a list of nodes"
    nodes: [User]
    "details about this specific page"
    pageInfo: PageInfo!
}

"An edge in a connection"
type UserEdge {
    "cursor marks a unique position or index into the connection"
    cursor: String!
    "index in the connection"
    index: Int
    "The item at the end of the edge"
    node: User
}

"User group queries"
type UserGroupQuery {
    "Get a group"
    group(
        "Group name"
        groupName: String!,
        "Site where the group is defined"
        site: String
    ): Group
}

"GraphQL representation of a vanity URL"
type VanityUrl implements JCRNode {
    "Get ACL info for this node"
    acl: GqlAcl
    "true if the URL mapping is activated or false if it is not activated"
    active: Boolean
    "Get the last modified date of this node and its descendants. The recursion in descendants can be controlled by recursionTypesFilter. If no filter is passed, recursion will stop by default on sub pages."
    aggregatedLastModifiedDate(
        "The language"
        language: String,
        "Stop recursion on graphql field values"
        recursionTypesFilter: InputNodeTypesInput
    ): String
    "Aggregated publication info about the JCR node"
    aggregatedPublicationInfo(
        "Publication language"
        language: String!,
        "Whether to take references into account when calculating the aggregated publication status"
        references: Boolean = false,
        "Whether to take sub-nodes into account when calculating the aggregated publication status"
        subNodes: Boolean = false
    ): GqlPublicationInfo!
    "Render URL in ajax mode"
    ajaxRenderUrl: String
    "Returns a list of types allowed under the provided node"
    allowedChildNodeTypes(
        "Filter by GraphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Whether all sub-types of allowed child node types should be included"
        includeSubTypes: Boolean = true
    ): [JCRNodeType]
    "GraphQL representations of the ancestor nodes of the JCR node, top down direction"
    ancestors(
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "The path of the topmost ancestor node to include in the result; null or empty string to include all the ancestor nodes"
        upToPath: String
    ): [JCRNode]!
    "GraphQL representations of the child nodes, according to parameters passed"
    children(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Group fields according to specified criteria"
        fieldGrouping: InputFieldGroupingInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "Include the current node itself in results"
        includesSelf: Boolean = false,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "Filter of child nodes by their names; null to avoid such filtering"
        names: [String],
        "fetching only nodes after this node (inclusive)"
        offset: Int,
        "Filter of child nodes by their property values; null to avoid such filtering"
        propertiesFilter: InputNodePropertiesInput,
        "Filter of child nodes by their types; null to avoid such filtering"
        typesFilter: InputNodeTypesInput,
        "Language to use to get children"
        validInLanguage: String
    ): JCRNodeConnection
    "true whether this URL mapping is the default one for the language"
    default: Boolean
    "Read default Work in progress information. Set by \"wip.checkbox.checked\" system proprety"
    defaultWipInfo: wipInfo
    "Returns the node definition that applies to this node."
    definition: JCRNodeDefinition
    "GraphQL representation of a descendant node, based on its relative path"
    descendant(
        "Name or relative path of the sub node"
        relPath: String!
    ): JCRNode
    "GraphQL representations of the descendant nodes, according to parameters passed"
    descendants(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Group fields according to specified criteria"
        fieldGrouping: InputFieldGroupingInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int,
        "Filter of descendant nodes by their property values; null to avoid such filtering"
        propertiesFilter: InputNodePropertiesInput,
        "Filter out and stop recursion on nodes by their property values; null to avoid such filtering"
        recursionPropertiesFilter: InputNodePropertiesInput,
        "Filter out and stop recursion on nodes by their types; null to avoid such filtering"
        recursionTypesFilter: InputNodeTypesInput,
        "Filter of descendant nodes by their types; null to avoid such filtering"
        typesFilter: InputNodeTypesInput,
        "Language to use to get children"
        validInLanguage: String
    ): JCRNodeConnection
    "The displayable name of the JCR node"
    displayName(
        "Language"
        language: String
    ): String
    "Returns the first parent of the current node that can be displayed in full page. If no matching node is found, null is returned."
    displayableNode: JCRNode
    "Returns the next available name for a node, appending if needed numbers."
    findAvailableNodeName(language: String, nodeType: String): String
    "Check if the current user has a specific permission"
    hasPermission(
        "The name of the permission"
        permissionName: String!
    ): Boolean
    "Check if the node as a renderable template associated with it (not a view a template)."
    isDisplayableNode: Boolean
    "true if node is under a mounted node"
    isExternal: Boolean!
    "Reports if the current node matches the nodetype(s) passed in parameter"
    isNodeType(
        "Node type name"
        type: InputNodeTypesInput!
    ): Boolean!
    "The language of the content object to which the vanity URL maps to"
    language: String
    "Check if the given locales need translation, by comparing last modifications dates with already existing translations"
    languagesToTranslate(
        "The languages to check"
        languagesToCheck: [String],
        "The translated languages"
        languagesTranslated: [String]
    ): [String]
    "Retrieve lock info of the current node"
    lockInfo: LockInfo
    "Returns edit lock status of the current node object"
    lockedAndCannotBeEdited: Boolean
    "Returns an array of <code>NodeType</code> objects representing the mixin node types in effect for this node."
    mixinTypes(
        "Filter by GraphQL fields values"
        fieldFilter: InputFieldFiltersInput
    ): [JCRNodeType]!
    "The name of the JCR node this object represents"
    name: String!
    "GraphQL representation of this node in certain workspace"
    nodeInWorkspace(
        "The target workspace"
        workspace: Workspace!
    ): JCRNode
    "Get information on the operations that can be done on this node"
    operationsSupport: GqlOperationsSupport
    "GraphQL representation of the parent JCR node"
    parent: JCRNode
    "The path of the JCR node this object represents"
    path: String!
    "Get the primary node type of this node"
    primaryNodeType: JCRNodeType!
    "GraphQL representations of the properties in the requested language"
    properties(
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "The language to obtain the properties in; must be a valid language code in case any internationalized properties are requested, does not matter for non-internationalized ones"
        language: String,
        "The names of the JCR properties; null to obtain all properties"
        names: [String],
        "When set to true, returns the node in the default language if there is no translation for the requested language. Returns null if the option \"Replace untranslated content with the default language content\" is not activated for the site of the requested node. Will also return null if there is no translation for the default language."
        useFallbackLanguage: Boolean = false
    ): [JCRProperty]!
    "The GraphQL representation of the property in the requested language; null if the property does not exist"
    property(
        "The language to obtain the property in; must be a valid language code for internationalized properties, does not matter for non-internationalized ones"
        language: String,
        "The name of the JCR property"
        name: String!,
        "When set to true, returns the node in the default language if there is no translation for the requested language. Returns null if the option \"Replace untranslated content with the default language content\" is not activated for the site of the requested node. Will also return null if there is no translation for the default language."
        useFallbackLanguage: Boolean = false
    ): JCRProperty
    "GraphQL representations of the reference properties that target the current JCR Node"
    references(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int
    ): JCRPropertyConnection!
    "Gets the fully rendered content for this node"
    renderedContent(
        "Rendering context configuration"
        contextConfiguration: String,
        "Is edit mode"
        isEditMode: Boolean,
        "Language"
        language: String,
        "Main resource path"
        mainResourcePath: String,
        "Additional request attributes"
        requestAttributes: [InputRenderRequestAttributeInput],
        "Template type"
        templateType: String,
        "Name of the view"
        view: String
    ): RenderedNode
    "GraphQL representation of the site the JCR node belongs to, or the system site in case the node does not belong to any site"
    site: JCRSite
    "The node targeted by this vanity URL"
    targetNode: JCRNode
    "Returns languages of available translations for this node"
    translationLanguages(
        "Optional: Return languages only if it is active for the site"
        isActiveOnly: Boolean
    ): [String]
    "The vanity URL"
    url: String
    "GraphQL representations of the reference properties that target the current JCR Node"
    usages(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "Filter by graphQL fields values"
        fieldFilter: InputFieldFiltersInput,
        "Sort by graphQL fields values"
        fieldSorter: InputFieldSorterInput,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int
    ): UsageConnection!
    "The UUID of the JCR node this object represents"
    uuid: String!
    "Get vanity URLs from the current node filtered by the parameters"
    vanityUrls(
        "Filter results based on graphql field values"
        fieldFilter: InputFieldFiltersInput,
        "Languages"
        languages: [String]
    ): [VanityUrl]
    "Read work in progress information for a given node"
    wipInfo: wipInfo
    "Get the workspace of the query"
    workspace: Workspace!
}

type VanityUrlMappingMutation {
    "Deletes the current vanity url"
    delete: Boolean
    "Move the vanity URL to another node"
    move(
        "The path of the target node"
        target: String!
    ): Boolean
    "Get mutation on underlying node"
    nodeMutation: JCRNodeMutation
    "Update vanity URL"
    update(
        "Desired value of the active flag or null to keep existing value"
        active: Boolean,
        "Desired value of the default flag or null to keep existing value"
        defaultMapping: Boolean,
        "Desired vanity URL language or null to keep existing value"
        language: String,
        "Desired URL value or null to keep existing value"
        url: String
    ): Boolean
    "Get the identifier of the node currently being mutated"
    uuid: String
}

"Workflow process"
type Workflow {
    "Workflow creation time"
    creationTime: String
    "Workflow due date"
    dueDate: String
    "Username who started the workflow"
    startUser: String
}

type WorkflowMutation {
    abortWorkflow: Boolean
    workflow: Workflow
}

"Workflow service"
type WorkflowService {
    "Retrieves the number of active workflow tasks for the current user"
    activeWorkflowTaskCountForUser: Int
    "Retrieves the active workflow tasks for the current user"
    activeWorkflowTasksForUser(
        "fetching only nodes after this node (exclusive)"
        after: String,
        "fetching only nodes before this node (exclusive)"
        before: String,
        "fetching only the first certain number of nodes"
        first: Int,
        "fetching only the last certain number of nodes"
        last: Int,
        "fetching only the first certain number of nodes"
        limit: Int,
        "fetching only nodes after this node (inclusive)"
        offset: Int
    ): TaskConnection
}

type ZipFileMutation {
    "zip a file"
    addToZip(
        "list of paths or ids to zip"
        pathsOrIds: [String]!
    ): Boolean
    "unzip a zip file"
    unzip(
        "destination path to unzip"
        path: String!
    ): Boolean
}

"Generic object with search results which contains facets and results"
type augmentedSearchResult {
    "Provides access to min and max values for a specific field across the selected dataset"
    numberRange(
        "Defines the field to operate on, this field is required."
        field: String!
    ): GqlMetricsFacetResult
    "Retrieves aggregations for range facet"
    rangeFacet(
        "Defines the field to aggregate on, this field is required."
        field: String!,
        "List of available ranges to be used"
        ranges: [InputRange]
    ): GqlRangeFacetResult
    "Retrieves nodes matching a search"
    results(
        "Page count to offset the results window"
        page: Int,
        "Number of documents in the results window"
        size: Int = 25,
        "Sort object, by default, doesn’t do any sorting and return the results by weight."
        sortBy: [InputsortV2]
    ): searchResultsV2
    "Retrieves aggregations for term facet"
    termFacet(
        "Defines whether the facet aggregation should be executed on the exact search filter (disjunctive: false) or on a modified version of the filter without the current facet field."
        disjunctive: Boolean = false,
        "Defines the field to aggregate on, this field is required."
        field: String!,
        "Maximum number of facet groups returned."
        max: Int = 10,
        "Minimum number of documents for a value to return as a facet."
        minDocCount: Int = 1,
        "Label to be used for missing values on this field. If not specified, missing fields will not be counted"
        missingValue: String
    ): GqlTermFacetResult
    "Retrieves aggregations for tree facet"
    treeFacet(
        "Defines whether the facet aggregation should be executed on the exact search filter (disjunctive: false) or on a modified version of the filter without the current facet field."
        disjunctive: Boolean = false,
        "Defines the field to aggregate on, this field is required."
        field: String!,
        "Maximum number of facet groups returned."
        max: Int = 10,
        "Minimum number of documents for a value to return as a facet."
        minDocCount: Int = 1,
        "Label to be used for missing values on this field. If not specified, missing fields will not be counted"
        missingValue: String,
        "The root path to fetch children from"
        rootPath: String!
    ): GqlTreeFacetResult
}

"Information related to specific indexing job"
type indexJob {
    "The ID of the job that was just started"
    id: String
    "Relation to a Jahia project object"
    project: project
    "Indexing job status"
    status: jobStatus
}

"Information about indexing jobs"
type indexMutationResult {
    "Information about indexing jobs, one per site indexed"
    jobs: [indexJob]
}

"Representation of indexed site"
type indexedSite {
    "End time of most recent indexation as ISO string"
    indexationEnd: String
    "Scheduled time of most recent indexation as ISO string"
    indexationScheduled: String
    "Start time of most recent indexation as ISO string"
    indexationStart: String
    "Status of indexation"
    indexationStatus: indexationStatus
    "Site key"
    siteKey: String
}

"Site specific information "
type project {
    "Unique site identifier"
    siteKey: String
}

"Detailed information about search hit"
type searchHitV2 {
    "Date when node was created"
    created: String
    "User who created the node"
    createdBy: String
    "Prettified displayable name of the node"
    displayableName: String
    "Short extract from the hit"
    excerpt: String
    "ID of the node"
    id: String
    "Keywords associated with this hit"
    keywords: [String]
    "Date and time of last modification"
    lastModified: String
    "User who modified the node last"
    lastModifiedBy: String
    "Date and time of last publication"
    lastPublished: String
    "User who published the node last"
    lastPublishedBy: String
    "Formatted link to the node"
    link: String
    "Mime type of the node"
    mimeType: String
    "Main type of the node, e.g jnt:page"
    nodeType: String
    "Path of the node"
    path: String
    "Fetch the value of the requested property, property name can be pass as an alias or as an argument"
    property(
        "Name of the property to return"
        name: String
    ): String
    "Determines how relevant a match is to the query"
    score: Float
    "Tags associated with this hit"
    tags: [String]
}

"Object with search results"
type searchResultsV2 {
    "This flag indicates that more data is available by using different filters"
    hasMore: Boolean
    "Array of hits based on the search query"
    hits: [searchHitV2]
    "Number of hits on page"
    hitsOnPage: Long
    "Time taken by query"
    took: String
    "Total number of hits"
    totalHits: Long
}

"List of indexed sites"
type siteList {
    "Database connection id"
    connectionId: String
    "Indexed sites"
    sites: [indexedSite]
    "Total number of indexed sites"
    totalCount: Int
}

"Task that prevents server from shutdown"
type task {
    "The name of the task associated with the service"
    name: String
    "Service attached to the task being monitored"
    service: String
    "Datetime at which the task was started or registered"
    started: String
}

"Work in progress information"
type wipInfo {
    "The languages set for Work in progress"
    languages: [String]
    "Get WIP status"
    status: WipStatus
}

enum FieldEvaluation {
    "The property value is among given Strings"
    AMONG
    "The property value contains given String "
    CONTAINS
    "The property value contains given String ignoring the case"
    CONTAINS_IGNORE_CASE
    "The field value is different from given one"
    DIFFERENT
    "The field value is empty - either null value, or no items for a list"
    EMPTY
    "The field value is equal to given one"
    EQUAL
    "The field value is not empty - if a list, must contain at least one item"
    NOT_EMPTY
}

enum GqlBackgroundJobState {
    "FINISHED"
    FINISHED
    "STARTED"
    STARTED
    "VETOED"
    VETOED
}

enum GqlBackgroundJobStatus {
    "ADDED"
    ADDED
    "CANCELED"
    CANCELED
    "EXECUTING"
    EXECUTING
    "FAILED"
    FAILED
    "SCHEDULED"
    SCHEDULED
    "SUCCESSFUL"
    SUCCESSFUL
}

enum GqlProbeHealth {
    "GREEN"
    GREEN
    "RED"
    RED
    "YELLOW"
    YELLOW
}

enum GqlProbeSeverity {
    "CRITICAL"
    CRITICAL
    "HIGH"
    HIGH
    "LOW"
    LOW
    "MEDIUM"
    MEDIUM
}

enum GroupingType {
    "Put grouped items at the end in the order groups appear in the 'groups' list"
    END
    "Put grouped items at the start in the order groups appear in the 'groups' list"
    START
}

enum JCRPropertyOption {
    "ENCRYPTED"
    ENCRYPTED
    "NOT_ZONED_DATE"
    NOT_ZONED_DATE
}

enum JCRPropertyType {
    "BINARY"
    BINARY
    "BOOLEAN"
    BOOLEAN
    "DATE"
    DATE
    "DECIMAL"
    DECIMAL
    "DOUBLE"
    DOUBLE
    "LONG"
    LONG
    "NAME"
    NAME
    "PATH"
    PATH
    "REFERENCE"
    REFERENCE
    "STRING"
    STRING
    "UNDEFINED"
    UNDEFINED
    "URI"
    URI
    "WEAKREFERENCE"
    WEAKREFERENCE
}

enum LoadInterval {
    "FIFTEEN"
    FIFTEEN
    "FIVE"
    FIVE
    "ONE"
    ONE
}

enum MulticriteriaEvaluation {
    "The result criteria evaluates positive if all sub-criteria evaluate positive"
    ALL
    "The result criteria evaluates positive if any sub-criteria evaluates positive"
    ANY
    "The result criteria evaluates positive if no sub-criteria evaluates positive"
    NONE
}

enum NodeNamingConflictResolutionStrategy {
    "FAIL"
    FAIL
    "RENAME"
    RENAME
}

enum Operation {
    "AND"
    AND
    "OR"
    OR
}

"Direction of sort"
enum OrderDirection {
    "Ascendant order"
    ASC
    "Descendant order"
    DESC
}

enum OrderType {
    "Ascendant order"
    ASC
    "Descendant order"
    DESC
}

enum PasteMode {
    "COPY"
    COPY
    "MOVE"
    MOVE
}

enum PathType {
    "The specified path is an ancestor, so all its descendants will be considered in the query"
    ANCESTOR
    "The specified path is a node itself, so only this node will be considered in the query"
    OWN
    "The specified path is a parent, so all its direct children will be considered in the query"
    PARENT
}

"Principal type"
enum PrincipalType {
    "Group principal type"
    GROUP
    "User principal type"
    USER
}

enum PropertyEvaluation {
    "The property is absent"
    ABSENT
    "The property value is different from given one"
    DIFFERENT
    "The property value is equal to given one"
    EQUAL
    "The property is present"
    PRESENT
}

enum PublicationStatus {
    "CONFLICT"
    CONFLICT
    "DELETED"
    DELETED
    "LIVE_MODIFIED"
    LIVE_MODIFIED
    "LIVE_ONLY"
    LIVE_ONLY
    "MANDATORY_LANGUAGE_UNPUBLISHABLE"
    MANDATORY_LANGUAGE_UNPUBLISHABLE
    "MANDATORY_LANGUAGE_VALID"
    MANDATORY_LANGUAGE_VALID
    "MARKED_FOR_DELETION"
    MARKED_FOR_DELETION
    "MODIFIED"
    MODIFIED
    "NOT_PUBLISHED"
    NOT_PUBLISHED
    "PUBLISHED"
    PUBLISHED
    "UNPUBLISHED"
    UNPUBLISHED
}

enum QueryFunction {
    "Query function for lower case comparison"
    LOWER_CASE
    "Query function for node local name comparison"
    NODE_LOCAL_NAME
    "Query function for node name comparison"
    NODE_NAME
    "Query function for upper case comparison"
    UPPER_CASE
}

"JCR query languages available to use for nodes querying"
enum QueryLanguage {
    "SQL2 query language"
    SQL2
    "XPath query language"
    XPATH
}

"The target position of reordered child nodes"
enum ReorderedChildrenPosition {
    "Specified children are sorted in a requested order and placed at the top, before all remaining children"
    FIRST
    "Specified children are sorted in a requested order, but remaining are kept at their places"
    INPLACE
    "Specified children are sorted in a requested order and placed at the end of the list after the remaining children"
    LAST
}

"Index in which search should be performed"
enum SearchIn {
    "content index"
    CONTENT
    "files index"
    FILES
}

enum SortType {
    "Ascendant order"
    ASC
    "Descendant order"
    DESC
}

"The target scheduler(s)"
enum TargetScheduler {
    "Both persisted and RAM schedulers will be used"
    BOTH
    "RAM scheduler will be used"
    RAM_SCHEDULER
    "Persisted scheduler will be used"
    SCHEDULER
}

enum TokenState {
    "ACTIVE"
    ACTIVE
    "DISABLED"
    DISABLED
}

enum WipStatus {
    "Work in progress for all languages"
    ALL_CONTENT
    "Work in progress disabled"
    DISABLED
    "Work in progress for specified languages"
    LANGUAGES
}

"JCR workspace to use for the operations"
enum Workspace {
    "Edit workspace"
    EDIT
    "Live workspace"
    LIVE
}

"Status of indexation"
enum indexationStatus {
    "Indexation has completed"
    COMPLETED
    "Indexation has been scheduled"
    SCHEDULED
    "Indexation has started"
    STARTED
}

"Status of job"
enum jobStatus {
    "Job has completed"
    COMPLETED
    "Job has started"
    STARTED
}

"A 64-bit signed integer"
scalar Long

"Info about a node to be reproduced at (moved or copied to) another parent node"
input InputCarriedJCRNode {
    "The name of the node at the new location or null if its current name should be preserved"
    destName: String
    "Path or UUID of the destination parent node to copy/move the node to"
    destParentPathOrId: String!
    "Path or UUID of the node to be copied/moved"
    pathOrId: String!
}

input InputContextEntryInput {
    key: String
    value: [String]
}

"Input object representing either a sub-filter (so that nested conditional logic can be composed), or a condition to filter by a single field"
input InputFieldFilterInput {
    "The way to evaluate the property; null indicates default (EQUAL)"
    evaluation: FieldEvaluation
    "Either a non-null sub-filter, or null in case the input object represents a simple field filter configured via its other properties"
    fieldFilter: InputFieldFiltersInput
    "The name of the field or its alias to filter by"
    fieldName: String
    "The value to evaluate the field against (for single-valued operations)"
    value: String
    "The values to evaluate the field against (for multi-valued operations)"
    values: [String]
}

"Filter any GraphQL node based on a sub-fields values"
input InputFieldFiltersInput {
    "Individual property filters"
    filters: [InputFieldFilterInput]!
    "The way to combine multiple individual property filters; null indicates default (ALL)"
    multi: MulticriteriaEvaluation
}

"Group entries according to criteria"
input InputFieldGroupingInput {
    "fieldName to group on"
    fieldName: String!
    "grouping type"
    groupingType: GroupingType!
    "specified groups"
    groups: [String]!
}

"object with fieldName and sort direction (ASC/DESC)"
input InputFieldSorterInput {
    "fieldName to sort"
    fieldName: String
    "ignore case when sorting"
    ignoreCase: Boolean
    "direction of the sort"
    sortType: SortType
}

"An optional part of the JCR node criteria to filter nodes, specifically by their arbitrary properties"
input InputGqlJcrNodeConstraintInput {
    "A list of child constraint input for all composition"
    all: [InputGqlJcrNodeConstraintInput]
    "A list of child constraint input for any composition"
    any: [InputGqlJcrNodeConstraintInput]
    "A search expression to match the node property value(s) against, either specific property only or all node properties, dependent on the 'property' parameter value passed"
    contains: String
    "A value to compare the node property value to, using the 'equals to' operator"
    equals: String
    "A value to compare the node property value to, using the 'exists' operator"
    exists: Boolean
    "The query function name for the node for comparison"
    function: QueryFunction
    "A value to compare the node property value to, using the 'greater than' operator"
    gt: String
    "A value to compare the node property value to, using the 'greater than or equals to' operator"
    gte: String
    "A value to pick the last days for node property date value, using the 'lastDays' operator"
    lastDays: Int
    "A value to compare the node property value to, using the 'like' operator"
    like: String
    "A value to compare the node property value to, using the 'less than' operator"
    lt: String
    "A value to compare the node property value to, using the 'less than or equals to' operator"
    lte: String
    "A list of child constraint input for none composition"
    none: [InputGqlJcrNodeConstraintInput]
    "A value to compare the node property value to, using the 'not equals to' operator"
    notEquals: String
    "The name of the node property to compare/match; may be null when optional or not applicable, dependent on other parameter values"
    property: String
}

"Node criterias"
input InputGqlJcrNodeCriteriaInput {
    "Language to access node properties in"
    language: String
    "Additional constraint to filter nodes by their arbitrary properties"
    nodeConstraint: InputGqlJcrNodeConstraintInput
    "The type of nodes to query"
    nodeType: String!
    "Ordering strategies"
    ordering: InputGqlOrdering
    "The exact meaning of the paths field"
    pathType: PathType
    "Paths that restrict areas to fetch nodes from; the exact meaning is defined by the pathType field; null or empty collection means no path restrictions"
    paths: [String]
}

"Ordering"
input InputGqlOrdering {
    "ASC or DESC order"
    orderType: OrderType
    "The property to order by"
    property: String
}

"GraphQL representation of a JCR node to be created"
input InputJCRNode {
    "The collection of sub nodes to create"
    children: [InputJCRNode]
    "The collection of mixins to add to the node"
    mixins: [String]
    "The name of the node to create"
    name: String!
    "The primary node type of the node to create"
    primaryNodeType: String!
    "The collection of properties to set to the node"
    properties: [InputJCRProperty]
    "If true, use the next available name for a node, appending if needed numbers. Default is false"
    useAvailableNodeName: Boolean
}

"GraphQL representation of a JCR node to be created"
input InputJCRNodeWithParent {
    "The collection of sub nodes to create"
    children: [InputJCRNode]
    "The collection of mixins to add to the node"
    mixins: [String]
    "The name of the node to create"
    name: String!
    "The parent path or id where the node will be created"
    parentPathOrId: String!
    "The primary node type of the node to create"
    primaryNodeType: String!
    "The collection of properties to set to the node"
    properties: [InputJCRProperty]
    "If true, use the next available name for a node, appending if needed numbers. Default is false"
    useAvailableNodeName: Boolean
}

"GraphQL representation of a JCR property to set"
input InputJCRProperty {
    "The language in which the property will be set (for internationalized properties"
    language: String
    "The name of the property to set"
    name: String!
    "The option of the property"
    option: JCRPropertyOption
    "The type of the property"
    type: JCRPropertyType
    "The value to set (for single valued properties)"
    value: String
    "The values to set (for multivalued properties)"
    values: [String]
}

"Node properties selection"
input InputNodePropertiesInput {
    "Individual property filters"
    filters: [InputNodePropertyInput]!
    "The way to combine multiple individual property filters; null indicates default (ALL)"
    multi: MulticriteriaEvaluation
}

"Node property selection"
input InputNodePropertyInput {
    "The way to evaluate the property; null indicates default (EQUAL)"
    evaluation: PropertyEvaluation
    "Language to use when evaluating the property"
    language: String
    "The name of the property to filter by"
    property: String!
    "The value to evaluate the property against"
    value: String
}

"Node types selection"
input InputNodeTypesInput {
    "The way to combine multiple type criteria; null indicates default (ANY)"
    multi: MulticriteriaEvaluation
    "Node type names required for a node to pass the filter"
    types: [String]!
}

"Input for nodetypes list"
input InputNodeTypesListInput {
    "Consider sub-types when checking for included/excluded nodetypes (default true)"
    considerSubTypes: Boolean
    "Exclude the types, specified by this list (also considering sub-types, if considerSubTypes is true)"
    excludeTypes: [String]
    "Include abstract types (default true)"
    includeAbstract: Boolean
    "Include mixin types (default true)"
    includeMixins: Boolean
    "Include non mixin types (default true)"
    includeNonMixins: Boolean
    "Only include types specified by this list (also considering sub-types, if considerSubTypes is true)"
    includeTypes: [String]
    "Filter on nodetypes defined in these modules"
    modules: [String]
    "Consider only nodetypes for the specified site"
    siteKey: String
}

"Describes input using name and with principal type (user/group)"
input InputPrincipalInput {
    "Get principal name"
    name: String
    "Get principal type (user/group)"
    type: PrincipalType
}

"Number Range Input Object"
input InputRange {
    "From value [used in Range facet]"
    from: String
    "Name to describe the facet"
    name: String!
    "To value [used in Range facet]"
    to: String
}

"Request attribute that can be use by rendering API"
input InputRenderRequestAttributeInput {
    "The name of the request attribute"
    name: String!
    "The value of the request attribute"
    value: String!
}

input InputVanityUrl {
    "true if the URL mapping is activated or false if it is not activated"
    active: Boolean
    "true whether this URL mapping is the default one for the language"
    defaultMapping: Boolean!
    "The language of the content object to which the vanity URL maps to"
    language: String!
    "The vanity URL"
    url: String!
}

"Boost fields for document matching"
input Inputboost {
    "Boost configuration for fields and subfields. Overrides content, main and metadata boosts if present. Unspecified fields receive a default value as specified in .cfg file."
    boosts: InputboostConfig
    "Boost document based on their content(rich text, simple text) matching"
    content: Float
    "Boost document based on their main field (displayableName, title) matching"
    main: Float
    "Boost document based on their metadata field (tags, keywords, categories) matching"
    metadata: Float
}

"Boost configuration for fields and their subfields"
input InputboostConfig {
    "Boost for jgql:content field multimatch query"
    content: InputboostSpec
    "Boost for jgql:file_content field multimatch query. Note that stem and ngram field boosts are not taken into account."
    file: InputboostSpec
    "Boost for jgql:main field multimatch query"
    main: InputboostSpec
    "Boost for jgql:metadata field multimatch query"
    metadata: InputboostSpec
}

"Boost specification for multimatch query against a field"
input InputboostSpec {
    "Boost for default field"
    defaultField: Float
    "Boost for ngram field"
    ngram: Float
    "Boost for phrase field"
    phrase: Float
    "Overall boost for multimatch query (default field and subfields as a group)"
    query: Float
    "Boost for stem field"
    stem: Float
}

"Search filter"
input Inputfilter {
    "Author filter"
    author: String
    "Created filter"
    created: InputfilterRange
    "Custom filters"
    custom: InputfilterGroups
    "Modified filter"
    modified: InputfilterRange
    "Node type filter"
    nodeType: InputnodeTypeFilter
    "Node path filter"
    path: String
    "Published filter"
    published: InputfilterRange
}

"Custom term input object"
input InputfilterCustomTerm {
    "Mapped field to filter on"
    field: String!
    "Value to filter"
    value: String!
}

"Custom date range group"
input InputfilterDateRangeGroup {
    "AND or OR filter operation"
    operation: Operation
    "Ranges used for filtering"
    ranges: [InputfilterExtendedDateRange]!
}

"Custom extended date range input object"
input InputfilterExtendedDateRange {
    "To display hits after specified date"
    after: String
    "To display hits before specified date"
    before: String
    "Filter for strict equality to the date"
    equal: String
    "Field to filter by"
    field: String!
}

"Custom filter groups"
input InputfilterGroups {
    "Groups of date range filters"
    dateRange: [InputfilterDateRangeGroup]
    "Groups of number range filters"
    numberRange: [InputfilterNumberRangeGroup]
    "Groups of term filters"
    term: [InputfilterTermGroup]
}

"Number range input object"
input InputfilterNumberRange {
    "Numeric field to filter by"
    field: String!
    "Greater than a number"
    gt: Float
    "Greater than or equal to number"
    gte: Float
    "Less than a number"
    lt: Float
    "Less than or equal to number"
    lte: Float
}

"Custom number range group"
input InputfilterNumberRangeGroup {
    "Filter operation"
    operation: Operation
    "Ranges"
    ranges: [InputfilterNumberRange]!
}

"Range input object"
input InputfilterRange {
    "To display hits after specified date"
    after: String
    "To display hits before specified date"
    before: String
    "Filter for strict equality to the date"
    equal: String
}

"Custom filter term group"
input InputfilterTermGroup {
    "Filter operation"
    operation: Operation
    "Terms to filter by"
    terms: [InputfilterCustomTerm]!
}

"Filter for filtering on node type"
input InputnodeTypeFilter {
    "Flag to determine if sub node types should be included in filter"
    includeSubNodes: Boolean
    "Node type"
    type: String
}

"Sort object for ordering or results"
input InputsortV2 {
    "Direction in which ordering occurs"
    dir: OrderDirection!
    "The field to order by"
    field: String!
}

"Work in progress information"
input InputwipInfo {
    "The languages set for Work in progress"
    languages: [String]
    "Get WIP status"
    status: WipStatus
}