code: def _validate_needs(
      node: SchemaNode,
      graph: GraphSchema,
      create_fn_params: Dict[Text, ParameterInfo],
      run_fn_params: Dict[Text, ParameterInfo],
  ) -> None:
      available_args, has_kwargs = _get_available_args(
          node, create_fn_params, run_fn_params
      )
  
      for param_name, parent_name in node.needs.items():
          if not has_kwargs and param_name not in available_args:
              raise GraphSchemaValidationException(
                  f"Your model uses a component '{node.uses.__name__}' which is "
                  f"supposed to retrieve a value for the "
                  f"param '{param_name}' although "
                  f"its method '{node.fn}' does not accept a parameter with this "
                  f"name. Please make sure that you registered "
                  f"your component correctly and and that your model configuration is "
                  f"valid."
                  f"See {DOCS_URL_GRAPH_COMPONENTS} for more information."
              )
  
          if (
              not _is_placeholder_input(parent_name)
              and parent_name not in graph.nodes
          ):
              raise GraphSchemaValidationException(
                  f"Missing graph component '{parent_name}'."
                  f"Your model uses a component '{node.uses.__name__}' which expects "
                  f"input from the missing component. The component is missing from "
                  f"your model configuration. Please make sure that you registered "
                  f"your component correctly and and that your model configuration is "
                  f"valid."
                  f"See {DOCS_URL_GRAPH_COMPONENTS} for more information."
              )
  
          required_type = available_args.get(param_name)
  
          if not has_kwargs and required_type is not None:
              parent = None
              if _is_placeholder_input(parent_name):
                  parent_return_type: TypeAnnotation = (
                      RESERVED_PLACEHOLDERS[parent_name]
                  )
              else:
                  parent = graph.nodes[parent_name]
                  _, parent_return_type = _get_parameter_information(
                      parent.uses, parent.fn
                  )
  
              _validate_parent_return_type(
                  node,
                  parent,
                  parent_return_type,
                  required_type.type_annotation,
              )
  
imports: import inspect
  import logging
  import typing
  from typing import Optional, Callable, Text, Tuple, Dict, Type, Any, Set, Union, TypeVar, List
  import dataclasses
  from rasa.core.policies.policy import PolicyPrediction
  from rasa.engine.training.fingerprinting import Fingerprintable
  import rasa.utils.common
  import typing_utils
  from rasa.engine.exceptions import GraphSchemaValidationException
  from rasa.engine.graph import GraphSchema, GraphComponent, SchemaNode, ExecutionContext, GraphModelConfiguration
  from rasa.engine.constants import RESERVED_PLACEHOLDERS
  from rasa.engine.storage.resource import Resource
  from rasa.engine.storage.storage import ModelStorage
  from rasa.shared.constants import DOCS_URL_GRAPH_COMPONENTS
  from rasa.shared.exceptions import RasaException
  from rasa.shared.nlu.training_data.message import Message
label_desc: Use image node_id 19 for calling a global function with example usage: _validate_needs(node, graph, create_fn_params, run_fn_params) without return types