directive @unionElementOf(union: String!, discriminator: String!, key: String!) on INPUT_OBJECT

"""
The `ArrayLike` scalar type represents a reference to a store previously created by the user n a datalayer
"""
scalar ActionHash

"""The kind of action."""
enum ActionKind {
  FUNCTION
  GENERATOR
}

"""The kind of action scope."""
enum ActionScope {
  GLOBAL
  LOCAL
  BRIDGE_GLOBAL_TO_LOCAL
  BRIDGE_LOCAL_TO_GLOBAL
}

"""
The `ArrayLike` scalar type represents a reference to a store previously created by the user n a datalayer
"""
scalar AnyDefault

"""A user of the bridge server. Maps to an authentikate user"""
type App {
  id: ID!
  identifier: String!
}

"""Create a new Github repository input"""
input AppImageInput {
  flavourName: String
  manifest: ManifestInput!
  selectors: [SelectorInput!]!
  appImageId: String!
  inspection: InspectionInput!
  image: DockerImageInput!
}

interface AssignWidget {
  kind: AssignWidgetKind!
  followValue: String
}

input AssignWidgetInput {
  """
  Whether to display the input as a paragraph or not. This is used for text inputs and dropdowns
  """
  asParagraph: Boolean = null
  kind: AssignWidgetKind!
  query: SearchQuery = null
  choices: [ChoiceInput!] = null
  min: Float = null
  max: Float = null
  step: Float = null
  placeholder: String = null
  hook: String = null
  ward: String = null
  fallback: AssignWidgetInput = null
  filters: [PortInput!]
  dependencies: [String!] = null
}

"""The kind of assign widget."""
enum AssignWidgetKind {
  SEARCH
  CHOICE
  SLIDER
  CUSTOM
  STRING
  STATE_CHOICE
}

"""A user of the bridge server. Maps to an authentikate user"""
type Backend {
  id: ID!
  user: User!
  client: Client!
  name: String!
  kind: String!
  pods(filters: PodFilter, pagination: OffsetPaginationInput): [Pod!]!
  resources(filters: ResourceFilter, pagination: OffsetPaginationInput): [Resource!]!
  instanceId: String!
  clientId: String!
}

"""Filter for Resources"""
input BackendFilter {
  ids: [ID!] = null
  search: String = null
  AND: BackendFilter
  OR: BackendFilter
  NOT: BackendFilter
  DISTINCT: Boolean
}

input BindsInput {
  implementations: [String!] = null
  clients: [String!] = null
  desiredInstances: Int! = 1
}

""" A selector is a way to select a release"""
type CPUSelector implements Selector {
  kind: String!
  required: Boolean!
  min: Int
  frequency: Float
}

type Choice {
  label: String!
  value: String!
  image: String
  description: String
}

type ChoiceAssignWidget implements AssignWidget {
  kind: AssignWidgetKind!
  followValue: String
  choices: [Choice!]
}

"\nA choice is a value that can be selected in a dropdown.\n\nIt is composed of a value, a label, and a description. The value is the\nvalue that is returned when the choice is selected. The label is the\ntext that is displayed in the dropdown. The description is the text\nthat is displayed when the user hovers over the choice.\n\n    "
input ChoiceInput {
  value: AnyDefault!
  label: String!
  image: String
  description: String
}

type ChoiceReturnWidget implements ReturnWidget {
  kind: ReturnWidgetKind!
  choices: [Choice!]
}

type Client {
  clientId: String!
  name: String!
}

"""A user of the bridge server. Maps to an authentikate user"""
type Collection {
  id: ID!
  name: String!
  description: String!
  definedAt: DateTime!
}

"""The state of a dask cluster"""
enum ContainerType {
  APPTAINER
  DOCKER
}

input CpuSelectorInput {
  """The frequency in MHz"""
  frequency: Int

  """The memory in MB"""
  memory: Int
}

"""Create a new Github repository input"""
input CreateDeploymentInput {
  instanceId: String!
  localId: ID!
  flavour: ID!
  lastPulled: DateTime = null
  secretParams: UntypedParams
}

"""Create a new Github repository input"""
input CreateGithubRepoInput {
  name: String = null
  user: String = null
  branch: String = null
  repo: String = null
  identifier: String = null
  autoScan: Boolean = true
}

"""Create a new Github repository input"""
input CreatePodInput {
  deployment: ID!
  localId: ID!
  resource: ID = null
  instanceId: String!
  clientId: String = null
}

""" A selector is a way to select a release"""
type CudaSelector implements Selector {
  kind: String!
  required: Boolean!

  """The number of cuda cores"""
  cudaCores: Int

  """The minimum cuda version"""
  cudaVersion: String
}

input CudaSelectorInput {
  """The minimum cuda version"""
  cudaVersion: String = null

  """The cuda cores"""
  cudaCores: Int = null
}

type CustomAssignWidget implements AssignWidget {
  kind: AssignWidgetKind!
  followValue: String
  hook: String!
  ward: String!
}

type CustomEffect implements Effect {
  dependencies: [String!]!
  kind: EffectKind!
  function: ValidatorFunction!
  hook: String!
  ward: String!
}

type CustomReturnWidget implements ReturnWidget {
  kind: ReturnWidgetKind!
  hook: String!
  ward: String!
}

"""Date with time (isoformat)"""
scalar DateTime

"""Create a new Github repository input"""
input DeclareBackendInput {
  instanceId: String!
  name: String!
  kind: String!
}

"""Create a resource"""
input DeclareResourceInput {
  backend: ID!
  name: String
  localId: String!
  qualifiers: [QualifierInput!] = null
}

type Definition {
  id: ID!
  hash: ActionHash!
  name: String!
  kind: ActionKind!
  description: String
  collections: [Collection!]!
  flavours(filters: FlavourFilter, pagination: OffsetPaginationInput): [Flavour!]!
  scope: ActionScope!
  isTestFor(filters: DefinitionFilter, order: DefinitionOrder, pagination: OffsetPaginationInput): [Definition!]!
  tests(filters: DefinitionFilter, order: DefinitionOrder, pagination: OffsetPaginationInput): [Definition!]!
  protocols: [Protocol!]!
  definedAt: DateTime!
  args: [Port!]!
  returns: [Port!]!
}

"""Filter for Dask Clusters"""
input DefinitionFilter {
  ids: [ID!] = null
  search: String = null
  demands: [PortDemandInput!]
  AND: DefinitionFilter
  OR: DefinitionFilter
  NOT: DefinitionFilter
  DISTINCT: Boolean
}

"A definition\n\n    Definitions are the building implementation for Actions and provide the\n    information needed to create a action. They are primarly composed of a name,\n    a description, and a list of ports.\n\n    Definitions provide a protocol of input and output, and do not contain\n    any information about the actual implementation of the action ( this is handled\n    by a implementation that implements a action).\n\n\n\n\n    "
input DefinitionInput {
  """
  The description of the definition. This is the text that is displayed in the UI
  """
  description: String = null

  """
  The collections of the definition. This is used to group definitions together in the UI
  """
  collections: [String!]! = []

  """
  The name of the actions. This is used to uniquely identify the definition
  """
  name: String!

  """
  Whether the definition is stateful or not. If the definition is stateful, it can be used to create a stateful action. If the definition is not stateful, it cannot be used to create a stateful action
  """
  stateful: Boolean! = false

  """
  The port groups of the definition. This is used to group ports together in the UI
  """
  portGroups: [PortGroupInput!]! = []

  """The args of the definition. This is the input ports of the definition"""
  args: [PortInput!]! = []

  """
  The returns of the definition. This is the output ports of the definition
  """
  returns: [PortInput!]! = []

  """
  The kind of the definition. This is the type of the definition. Can be either a function or a generator
  """
  kind: ActionKind!

  """
  The tests for the definition. This is used to group definitions together in the UI
  """
  isTestFor: [String!]! = []

  """
  The interfaces of the definition. This is used to group definitions together in the UI
  """
  interfaces: [String!]! = []

  """
  Whether the definition is a dev definition or not. If the definition is a dev definition, it can be used to create a dev action. If the definition is not a dev definition, it cannot be used to create a dev action
  """
  isDev: Boolean! = false

  """The logo of the definition. This is used to display the logo in the UI"""
  logo: String = null
}

input DefinitionOrder {
  definedAt: Ordering
}

input DeletePodInput {
  id: ID!
}

enum DemandKind {
  ARGS
  RETURNS
}

"""
A dependency for a implementation. By defining dependencies, you can
    create a dependency graph for your implementations and actions
"""
input DependencyInput {
  hash: ActionHash
  reference: String
  binds: BindsInput
  optional: Boolean! = false
  viableInstances: Int
}

"""A user of the bridge server. Maps to an authentikate user"""
type Deployment {
  id: ID!
  flavour: Flavour!
  apiToken: String!
  backend: Backend!
  localId: ID!
  name: String!
}

"""Filter for Dask Clusters"""
input DeploymentFilter {
  ids: [ID!] = null
  search: String = null
  AND: DeploymentFilter
  OR: DeploymentFilter
  NOT: DeploymentFilter
  DISTINCT: Boolean
}

"""The Feature you are trying to match"""
input DeviceFeature {
  kind: String!
  cpuCount: String!
}

"""A docker image descriptor"""
type DockerImage {
  imageString: String!
  buildAt: DateTime!
}

input DockerImageInput {
  imageString: String!
  buildAt: DateTime!
}

"""Create a new Github repository input"""
input DumpLogsInput {
  pod: ID!
  logs: String!
}

interface Effect {
  dependencies: [String!]!
  kind: EffectKind!
  function: ValidatorFunction!
}

"\n                 An effect is a way to modify a port based on a condition. For example,\n    you could have an effect that sets a port to null if another port is null.\n\n    Or, you could have an effect that hides the port if another port meets a condition.\n    E.g when the user selects a certain option in a dropdown, another port is hidden.\n\n\n    "
input EffectInput {
  function: ValidatorFunction!
  dependencies: [String!] = []
  message: String = null
  kind: EffectKind!
  hook: String
  ward: String
}

"""The kind of effect."""
enum EffectKind {
  MESSAGE
  HIDE
  CUSTOM
}

"""Which environment do you want to match against?"""
input EnvironmentInput {
  features: [DeviceFeature!]
  containerType: ContainerType!
}

"""A user of the bridge server. Maps to an authentikate user"""
type Flavour {
  id: ID!
  name: String!
  logo: String
  image: DockerImage!
  originalLogo: String
  entrypoint: CudaSelector!
  release: Release!
  deployments(filters: DeploymentFilter, pagination: OffsetPaginationInput): [Deployment!]!
  definitions(filters: DefinitionFilter, order: DefinitionOrder, pagination: OffsetPaginationInput): [Definition!]!
  manifest: UntypedParams!
  selectors: [Selector!]!
  requirements: [Requirement!]!
  description: String!
}

"""Filter for Dask Clusters"""
input FlavourFilter {
  ids: [ID!] = null
  search: String = null
  AND: FlavourFilter
  OR: FlavourFilter
  NOT: FlavourFilter
  DISTINCT: Boolean
}

"""A user of the bridge server. Maps to an authentikate user"""
type GithubRepo {
  id: ID!
  name: String!
  repo: String!
  branch: String!
  user: String!
  flavours(filters: FlavourFilter, pagination: OffsetPaginationInput): [Flavour!]!
}

"""Filter for Dask Clusters"""
input GithubRepoFilter {
  ids: [ID!] = null
  search: String = null
  AND: GithubRepoFilter
  OR: GithubRepoFilter
  NOT: GithubRepoFilter
  DISTINCT: Boolean
}

"""
The `ArrayLike` scalar type represents a reference to a store previously created by the user n a datalayer
"""
scalar Identifier

"""
A implementation is a blueprint for a action. It is composed of a definition, a list of dependencies, and a list of params.
"""
input ImplementationInput {
  definition: DefinitionInput!
  dependencies: [DependencyInput!]!
  interface: String
  params: AnyDefault = null
  dynamic: Boolean! = false
  logo: String = null
}

input InspectionInput {
  size: Int
  implementations: [ImplementationInput!]!
  requirements: [RequirementInput!]!
}

"""The logs of a pod"""
type LogDump {
  id: ID!
  pod: Pod!
  logs: String!
  createdAt: DateTime!
}

input ManifestInput {
  """The entrypoint of the app, defaults to 'app'"""
  entrypoint: String
  identifier: String!
  version: String!
  author: String! = "unknown"
  logo: String = null
  scopes: [String!]! = []
}

"""Create a new Github repository input"""
input MatchFlavoursInput {
  environment: EnvironmentInput = null
  release: ID = null
  actions: [ActionHash!]
}

type MessageEffect implements Effect {
  dependencies: [String!]!
  kind: EffectKind!
  function: ValidatorFunction!
  message: String!
}

type Mutation {
  """Create a new dask cluster on a bridge server"""
  scanRepo(input: ScanRepoInput!): GithubRepo!

  """Rescan all repos"""
  rescanRepos: [GithubRepo!]!

  """Create a new Github repository on a bridge server"""
  createGithubRepo(input: CreateGithubRepoInput!): GithubRepo!

  """Create a new dask cluster on a bridge server"""
  createDeployment(input: CreateDeploymentInput!): Deployment!

  """Create a new dask cluster on a bridge server"""
  updateDeployment(input: UpdateDeploymentInput!): Deployment!

  """Create a new dask cluster on a bridge server"""
  createPod(input: CreatePodInput!): Pod!

  """Create a new dask cluster on a bridge server"""
  updatePod(input: UpdatePodInput!): Pod!

  """Create a new dask cluster on a bridge server"""
  dumpLogs(input: DumpLogsInput!): LogDump!

  """Create a new dask cluster on a bridge server"""
  declareBackend(input: DeclareBackendInput!): Backend!

  """Create a new resource for your backend"""
  declareResource(input: DeclareResourceInput!): Resource!

  """Create a new dask cluster on a bridge server"""
  deletePod(input: DeletePodInput!): ID!

  """Create a new release"""
  createAppImage(input: AppImageInput!): Release!
}

input OffsetPaginationInput {
  offset: Int! = 0
  limit: Int
}

input OneApiSelectorInput {
  """The api versison of the selector"""
  oneapiVersion: String = null
}

enum Ordering {
  ASC
  ASC_NULLS_FIRST
  ASC_NULLS_LAST
  DESC
  DESC_NULLS_FIRST
  DESC_NULLS_LAST
}

"""A user of the bridge server. Maps to an authentikate user"""
type Pod {
  id: ID!
  resource: Resource
  backend: Backend!
  deployment: Deployment!
  latestLogDump: LogDump
  podId: String!
  clientId: String
  status: PodStatus!
  name: String!
}

"""Filter for Dask Clusters"""
input PodFilter {
  ids: [ID!] = null
  search: String = null
  backend: ID = null
  AND: PodFilter
  OR: PodFilter
  NOT: PodFilter
  DISTINCT: Boolean
}

"""The state of a dask cluster"""
enum PodStatus {
  PENDING
  RUNNING
  STOPPING
  STOPPED
  FAILED
  UNKOWN
}

"""An update on a pod"""
type PodUpdateMessage {
  id: String!
  status: String!
  created: Boolean!
  progress: Int
}

type Port {
  key: String!
  label: String
  kind: PortKind!
  description: String
  identifier: Identifier
  nullable: Boolean!
  effects: [Effect!]
  default: AnyDefault
  children: [Port!]
  choices: [Choice!]
  assignWidget: AssignWidget
  returnWidget: ReturnWidget
  validators: [Validator!]
}

input PortDemandInput {
  kind: DemandKind!
  matches: [PortMatchInput!] = null
  forceLength: Int = null
  forceNonNullableLength: Int = null
}

"""
A Port Group is a group of ports that are related to each other. It is used to group ports together in the UI and provide a better user experience.
"""
input PortGroupInput {
  """
  The key of the port group. This is used to uniquely identify the port group
  """
  key: String!
  title: String
  description: String
  effects: [EffectInput!] = []
  ports: [String!] = []
}

"Port\n\n    A Port is a single input or output of a action. It is composed of a key and a kind\n    which are used to uniquely identify the port.\n\n    If the Port is a structure, we need to define a identifier and scope,\n    Identifiers uniquely identify a specific type of model for the scopes (e.g\n    all the ports that have the identifier \"@mikro/image\" are of the same type, and\n    are hence compatible with each other). Scopes are used to define in which context\n    the identifier is valid (e.g. a port with the identifier \"@mikro/image\" and the\n    scope \"local\", can only be wired to other ports that have the same identifier and\n    are running in the same app). Global ports are ports that have the scope \"global\",\n    and can be wired to any other port that has the same identifier, as there exists a\n    mechanism to resolve and retrieve the object for each app. Please check the rekuest\n    documentation for more information on how this works.\n\n\n    "
input PortInput {
  key: String!
  label: String = null
  kind: PortKind!
  description: String = null
  identifier: String = null
  nullable: Boolean! = false
  validators: [ValidatorInput!] = null
  effects: [EffectInput!] = null
  default: AnyDefault = null
  children: [PortInput!] = null
  choices: [ChoiceInput!] = null
  assignWidget: AssignWidgetInput = null
  returnWidget: ReturnWidgetInput = null
}

"""The kind of port."""
enum PortKind {
  INT
  STRING
  STRUCTURE
  LIST
  BOOL
  DICT
  FLOAT
  DATE
  UNION
  ENUM
  MODEL
  MEMORY_STRUCTURE
}

input PortMatchInput {
  at: Int = null
  key: String = null
  kind: PortKind = null
  identifier: String = null
  nullable: Boolean = null
  children: [PortMatchInput!] = null
}

"""A user of the bridge server. Maps to an authentikate user"""
type Protocol {
  id: ID!
  name: String!
  description: String!
}

"""A qualifier that describes some property of the action"""
input QualifierInput {
  key: String!
  value: String!
}

type Query {
  """Return all dask clusters"""
  githubRepo(id: ID!): GithubRepo!

  """Return all dask clusters"""
  definition(id: ID = null, hash: ActionHash = null): Definition!

  """Return all dask clusters"""
  release(id: ID!): Release!

  """Return all dask clusters"""
  resource(id: ID!): Resource!

  """Return all dask clusters"""
  flavour(id: ID!): Flavour!

  """Return all dask clusters"""
  deployment(id: ID!): Deployment!

  """Return all dask clusters"""
  backend(id: ID!): Backend!

  """Return all dask clusters"""
  pod(id: ID!): Pod!

  """Return the currently logged in user"""
  me: User!

  """Return the currently logged in user"""
  matchFlavour(input: MatchFlavoursInput!): Flavour!
  flavours(filters: FlavourFilter, pagination: OffsetPaginationInput): [Flavour!]!
  releases(filters: ReleaseFilter, pagination: OffsetPaginationInput): [Release!]!
  resources(filters: ResourceFilter, pagination: OffsetPaginationInput): [Resource!]!
  deployments(filters: DeploymentFilter, pagination: OffsetPaginationInput): [Deployment!]!
  githubRepos(filters: GithubRepoFilter, pagination: OffsetPaginationInput): [GithubRepo!]!
  definitions(filters: DefinitionFilter, order: DefinitionOrder, pagination: OffsetPaginationInput): [Definition!]!
  pods(filters: PodFilter, pagination: OffsetPaginationInput): [Pod!]!
  backends(filters: BackendFilter, pagination: OffsetPaginationInput): [Backend!]!

  """Return the pod for an agent"""
  podForAgent(clientId: ID!, instanceId: ID!): Pod
}

"""A user of the bridge server. Maps to an authentikate user"""
type Release {
  id: ID!
  version: String!
  app: App!
  scopes: [String!]!
  logo: String
  originalLogo: String
  entrypoint: String!
  flavours(filters: FlavourFilter, pagination: OffsetPaginationInput): [Flavour!]!

  """Is this release deployed"""
  installed: Boolean!

  """Is this release deployed"""
  deployments: [Deployment!]!

  """Is this release deployed"""
  description: String!

  """Is this release deployed"""
  colour: String!

  """Is this release deployed"""
  name: String!
}

"""Filter for Dask Clusters"""
input ReleaseFilter {
  ids: [ID!] = null
  search: String = null
  AND: ReleaseFilter
  OR: ReleaseFilter
  NOT: ReleaseFilter
  DISTINCT: Boolean
}

"""A requirement"""
type Requirement {
  key: String!
  service: String!
  description: String
  optional: Boolean!
}

input RequirementInput {
  key: String!
  service: String!
  optional: Boolean! = false
  description: String = null
}

"""
A resource on a backend. Resource define allocated resources on a backend. E.g a computational action
"""
type Resource {
  id: ID!
  backend: Backend!
  resourceId: String!
  name: String!
  pods(filters: PodFilter, pagination: OffsetPaginationInput): [Pod!]!
  qualifiers: UntypedParams
}

"""Filter for Resources"""
input ResourceFilter {
  ids: [ID!] = null
  search: String = null
  AND: ResourceFilter
  OR: ResourceFilter
  NOT: ResourceFilter
  DISTINCT: Boolean
}

interface ReturnWidget {
  kind: ReturnWidgetKind!
}

"A Return Widget is a UI element that is used to display the value of a port.\n\n    Return Widgets get displayed both if we show the return values of an assignment,\n    but also when we inspect the given arguments of a previous run task. Their primary\n    usecase is to adequately display the value of a port, in a user readable way.\n\n    Return Widgets are often overwriten by the underlying UI framework (e.g. Orkestrator)\n    to provide a better user experience. For example, a return widget that displays a\n    date could be overwriten to display a calendar widget.\n\n    Return Widgets provide more a way to customize this overwriten behavior.\n\n    "
input ReturnWidgetInput {
  kind: ReturnWidgetKind!
  query: SearchQuery = null
  choices: [ChoiceInput!] = null
  min: Int = null
  max: Int = null
  step: Int = null
  placeholder: String = null
  hook: String = null
  ward: String = null
}

"""The kind of return widget."""
enum ReturnWidgetKind {
  CHOICE
  CUSTOM
}

""" A selector is a way to select a release"""
type RocmSelector implements Selector {
  kind: String!
  required: Boolean!
  apiThing: String
  apiVersion: String
}

input RocmSelectorInput {
  """The api version of the selector"""
  apiVersion: String = null

  """The api thing of the selector"""
  apiThing: String = null
}

"""Create a dask cluster input"""
input ScanRepoInput {
  id: String!
}

type SearchAssignWidget implements AssignWidget {
  kind: AssignWidgetKind!
  followValue: String
  query: String!
  ward: String!
  filters: [Port!]
  dependencies: [String!]
}

"""
The `ArrayLike` scalar type represents a reference to a store previously created by the user n a datalayer
"""
scalar SearchQuery

""" A selector is a way to select a release"""
interface Selector {
  kind: String!
  required: Boolean!
}

input SelectorInput {
  """The kind of the selector"""
  kind: String!

  """The api version of the selector"""
  apiVersion: String = null

  """The api thing of the selector"""
  apiThing: String = null

  """The api version of the selector"""
  oneapiVersion: String = null

  """The cuda cores"""
  cudaCores: Int = null

  """The frequency in MHz"""
  frequency: Int = null

  """The memory in MB"""
  memory: Int = null
}

type SliderAssignWidget implements AssignWidget {
  kind: AssignWidgetKind!
  followValue: String
  min: Float
  max: Float
  step: Float
}

type StateChoiceAssignWidget implements AssignWidget {
  kind: AssignWidgetKind!
  followValue: String
  stateChoices: String!
}

type StringAssignWidget implements AssignWidget {
  kind: AssignWidgetKind!
  followValue: String
  placeholder: String!
  asParagraph: Boolean!
}

type Subscription {
  """Create a new dask cluster on a bridge server"""
  pod(podId: ID!): PodUpdateMessage!

  """Create a new dask cluster on a bridge server"""
  pods: PodUpdateMessage!
}

"""
UntypedParams represents an untyped options object returned by the Dask Gateway API.
"""
scalar UntypedParams

"""Create a new Github repository input"""
input UpdateDeploymentInput {
  deployment: ID!
  status: PodStatus!
}

"""Create a new Github repository input"""
input UpdatePodInput {
  pod: ID
  localId: ID
  status: PodStatus!
  instanceId: String!
}

type User {
  sub: String!
  preferredUsername: String!
  roles: [String!]!
}

type Validator {
  function: ValidatorFunction!
  dependencies: [String!]
  label: String
  errorMessage: String
}

"\n    The `Validator` scalar represents a javascript function that should execute on the client side (inside a shadow realm)\n      to validate a value (or a set of values) before it is sent to the server.  The function has two parameters (value, otherValues) and should return a string if the value is invalid and undefined if the value is valid.\n        The otherValues parameter is an object with the other values in the form {fieldName: value}."
scalar ValidatorFunction

" \nA validating function for a port. Can specify a function that will run when validating values of the port.\nIf outside dependencies are needed they need to be specified in the dependencies field. With the .. syntax\nwhen transversing the tree of ports. \n\n"
input ValidatorInput {
  function: ValidatorFunction!
  dependencies: [String!] = []
  label: String = null
  errorMessage: String = null
}