# Auto generated from neat_ml_schema.yaml by pythongen.py version: 0.9.0
# Generation date: 2022-06-16T12:10:14
# Schema: neat_ml_schema
#
# id: https://w3id.org/neat
# description: A schema generated by LinkML for specifying graph ML pipelines in NEAT.
# license: https://fsf.org/

import dataclasses
import sys
import re
from jsonasobj2 import JsonObj, as_dict
from typing import Optional, List, Union, Dict, ClassVar, Any
from dataclasses import dataclass
from linkml_runtime.linkml_model.meta import EnumDefinition, PermissibleValue, PvFormulaOptions

from linkml_runtime.utils.slot import Slot
from linkml_runtime.utils.metamodelcore import empty_list, empty_dict, bnode
from linkml_runtime.utils.yamlutils import YAMLRoot, extended_str, extended_float, extended_int
from linkml_runtime.utils.dataclass_extensions_376 import dataclasses_init_fn_with_kwargs
from linkml_runtime.utils.formatutils import camelcase, underscore, sfx
from linkml_runtime.utils.enumerations import EnumDefinitionImpl
from rdflib import Namespace, URIRef
from linkml_runtime.utils.curienamespace import CurieNamespace
from linkml_runtime.linkml_model.types import Boolean, Float, Integer, String
from linkml_runtime.utils.metamodelcore import Bool

metamodel_version = "1.7.0"
version = None

# Overwrite dataclasses _init_fn to add **kwargs in __init__
dataclasses._init_fn = dataclasses_init_fn_with_kwargs

# Namespaces
LINKML = CurieNamespace('linkml', 'https://w3id.org/linkml/')
DEFAULT_ = CurieNamespace('', 'https://w3id.org/neat/')


# Types

# Class references



@dataclass
class NeatConfiguration(YAMLRoot):
    """
    Root class for the schema.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/NeatConfiguration")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "NeatConfiguration"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/NeatConfiguration")

    graph_data: Optional[Union[dict, "GraphDataConfiguration"]] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.graph_data is not None and not isinstance(self.graph_data, GraphDataConfiguration):
            self.graph_data = GraphDataConfiguration(**as_dict(self.graph_data))

        super().__post_init__(**kwargs)


@dataclass
class GraphDataConfiguration(YAMLRoot):
    """
    Configuration for the graph training and validation data for ML pipeline.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/GraphDataConfiguration")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "GraphDataConfiguration"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/GraphDataConfiguration")

    graph: Optional[Union[dict, "EnsmallenRunConfig"]] = None
    evaluation_data: Optional[Union[dict, "TrainValidData"]] = None
    source_data: Optional[Union[dict, "FileResourceContainer"]] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.graph is not None and not isinstance(self.graph, EnsmallenRunConfig):
            self.graph = EnsmallenRunConfig(**as_dict(self.graph))

        if self.evaluation_data is not None and not isinstance(self.evaluation_data, TrainValidData):
            self.evaluation_data = TrainValidData(**as_dict(self.evaluation_data))

        if self.source_data is not None and not isinstance(self.source_data, FileResourceContainer):
            self.source_data = FileResourceContainer(**as_dict(self.source_data))

        super().__post_init__(**kwargs)


@dataclass
class FileResourceContainer(YAMLRoot):
    """
    A container of paths and descriptions
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/FileResourceContainer")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "FileResourceContainer"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/FileResourceContainer")

    files: Optional[Union[Union[dict, "FileResource"], List[Union[dict, "FileResource"]]]] = empty_list()

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if not isinstance(self.files, list):
            self.files = [self.files] if self.files is not None else []
        self.files = [v if isinstance(v, FileResource) else FileResource(**as_dict(v)) for v in self.files]

        super().__post_init__(**kwargs)


@dataclass
class FileResource(YAMLRoot):
    """
    Path (or url) and description of source files (tar.gz).
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/FileResource")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "FileResource"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/FileResource")

    path: Optional[str] = None
    desc: Optional[str] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.path is not None and not isinstance(self.path, str):
            self.path = str(self.path)

        if self.desc is not None and not isinstance(self.desc, str):
            self.desc = str(self.desc)

        super().__post_init__(**kwargs)


@dataclass
class TrainValidData(YAMLRoot):
    """
    Postive and negative training and validation graph data filepaths.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/TrainValidData")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "TrainValidData"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/TrainValidData")

    train_data: Optional[Union[dict, "PosNegData"]] = None
    valid_data: Optional[Union[dict, "PosNegData"]] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.train_data is not None and not isinstance(self.train_data, PosNegData):
            self.train_data = PosNegData(**as_dict(self.train_data))

        if self.valid_data is not None and not isinstance(self.valid_data, PosNegData):
            self.valid_data = PosNegData(**as_dict(self.valid_data))

        super().__post_init__(**kwargs)


@dataclass
class PosNegData(YAMLRoot):
    """
    File paths for positive an negative edge data.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/PosNegData")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "PosNegData"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/PosNegData")

    pos_edge_filepath: Optional[str] = None
    neg_edge_filepath: Optional[str] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.pos_edge_filepath is not None and not isinstance(self.pos_edge_filepath, str):
            self.pos_edge_filepath = str(self.pos_edge_filepath)

        if self.neg_edge_filepath is not None and not isinstance(self.neg_edge_filepath, str):
            self.neg_edge_filepath = str(self.neg_edge_filepath)

        super().__post_init__(**kwargs)


@dataclass
class EmbeddingsConfig(YAMLRoot):
    """
    Embeddings configuration.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/EmbeddingsConfig")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "EmbeddingsConfig"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/EmbeddingsConfig")

    filename: Optional[str] = None
    history_filename: Optional[str] = None
    node_embeddings_params: Optional[Union[dict, "NodeEmbeddingsParams"]] = None
    tsne_filename: Optional[str] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.filename is not None and not isinstance(self.filename, str):
            self.filename = str(self.filename)

        if self.history_filename is not None and not isinstance(self.history_filename, str):
            self.history_filename = str(self.history_filename)

        if self.node_embeddings_params is not None and not isinstance(self.node_embeddings_params, NodeEmbeddingsParams):
            self.node_embeddings_params = NodeEmbeddingsParams(**as_dict(self.node_embeddings_params))

        if self.tsne_filename is not None and not isinstance(self.tsne_filename, str):
            self.tsne_filename = str(self.tsne_filename)

        super().__post_init__(**kwargs)


@dataclass
class NodeEmbeddingsParams(YAMLRoot):
    """
    Node embeddings parameters.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/NodeEmbeddingsParams")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "NodeEmbeddingsParams"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/NodeEmbeddingsParams")

    method_name: Optional[Union[str, "NodeEmbedMethodEnum"]] = None
    walk_length: Optional[int] = None
    batch_size: Optional[int] = None
    window_size: Optional[int] = None
    return_weight: Optional[float] = None
    explore_weight: Optional[float] = None
    iterations: Optional[int] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.method_name is not None and not isinstance(self.method_name, NodeEmbedMethodEnum):
            self.method_name = NodeEmbedMethodEnum(self.method_name)

        if self.walk_length is not None and not isinstance(self.walk_length, int):
            self.walk_length = int(self.walk_length)

        if self.batch_size is not None and not isinstance(self.batch_size, int):
            self.batch_size = int(self.batch_size)

        if self.window_size is not None and not isinstance(self.window_size, int):
            self.window_size = int(self.window_size)

        if self.return_weight is not None and not isinstance(self.return_weight, float):
            self.return_weight = float(self.return_weight)

        if self.explore_weight is not None and not isinstance(self.explore_weight, float):
            self.explore_weight = float(self.explore_weight)

        if self.iterations is not None and not isinstance(self.iterations, int):
            self.iterations = int(self.iterations)

        super().__post_init__(**kwargs)


@dataclass
class ClassifierContainer(YAMLRoot):
    """
    A container with multiple classifiers in it.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/ClassifierContainer")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "ClassifierContainer"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/ClassifierContainer")

    classifiers: Optional[Union[Union[dict, "Classifier"], List[Union[dict, "Classifier"]]]] = empty_list()

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if not isinstance(self.classifiers, list):
            self.classifiers = [self.classifiers] if self.classifiers is not None else []
        self.classifiers = [v if isinstance(v, Classifier) else Classifier(**as_dict(v)) for v in self.classifiers]

        super().__post_init__(**kwargs)


@dataclass
class Classifier(YAMLRoot):
    """
    ML classifiers to be trained-tested-validated and applied for predictions.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/Classifier")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "Classifier"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/Classifier")

    classifier_id: Optional[str] = None
    classifier_name: Optional[str] = None
    classifier_type: Optional[str] = None
    edge_method: Optional[Union[str, "EdgeMethodEnum"]] = None
    outfile: Optional[str] = None
    history_filename: Optional[str] = None
    parameters: Optional[Union[dict, "ClassifierParams"]] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.classifier_id is not None and not isinstance(self.classifier_id, str):
            self.classifier_id = str(self.classifier_id)

        if self.classifier_name is not None and not isinstance(self.classifier_name, str):
            self.classifier_name = str(self.classifier_name)

        if self.classifier_type is not None and not isinstance(self.classifier_type, str):
            self.classifier_type = str(self.classifier_type)

        if self.edge_method is not None and not isinstance(self.edge_method, EdgeMethodEnum):
            self.edge_method = EdgeMethodEnum(self.edge_method)

        if self.outfile is not None and not isinstance(self.outfile, str):
            self.outfile = str(self.outfile)

        if self.history_filename is not None and not isinstance(self.history_filename, str):
            self.history_filename = str(self.history_filename)

        if self.parameters is not None and not isinstance(self.parameters, ClassifierParams):
            self.parameters = ClassifierParams(**as_dict(self.parameters))

        super().__post_init__(**kwargs)


@dataclass
class ClassifierParams(YAMLRoot):
    """
    Parameters needed to define a classifier.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/ClassifierParams")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "ClassifierParams"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/ClassifierParams")

    sklearn_params: Optional[Union[dict, "SkLearnParams"]] = None
    tf_keras_params: Optional[Union[dict, "TFKerasParams"]] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.sklearn_params is not None and not isinstance(self.sklearn_params, SkLearnParams):
            self.sklearn_params = SkLearnParams(**as_dict(self.sklearn_params))

        if self.tf_keras_params is not None and not isinstance(self.tf_keras_params, TFKerasParams):
            self.tf_keras_params = TFKerasParams(**as_dict(self.tf_keras_params))

        super().__post_init__(**kwargs)


@dataclass
class SkLearnParams(YAMLRoot):
    """
    Parameters specific to the SKLearn library.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/SkLearnParams")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "SkLearnParams"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/SkLearnParams")

    random_state: Optional[int] = None
    max_iter: Optional[int] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.random_state is not None and not isinstance(self.random_state, int):
            self.random_state = int(self.random_state)

        if self.max_iter is not None and not isinstance(self.max_iter, int):
            self.max_iter = int(self.max_iter)

        super().__post_init__(**kwargs)


@dataclass
class TFKerasParams(YAMLRoot):
    """
    Parameters specific to the Tensorflow Keras library.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/TFKerasParams")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "TFKerasParams"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/TFKerasParams")

    layers_config: Optional[Union[dict, "LayerContainer"]] = None
    loss: Optional[str] = None
    metrics_config: Optional[Union[dict, "MetricContainer"]] = None
    optimizer: Optional[Union[str, "OptimizerEnum"]] = None
    fit_config: Optional[Union[dict, "ClassifierFitParams"]] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.layers_config is not None and not isinstance(self.layers_config, LayerContainer):
            self.layers_config = LayerContainer(**as_dict(self.layers_config))

        if self.loss is not None and not isinstance(self.loss, str):
            self.loss = str(self.loss)

        if self.metrics_config is not None and not isinstance(self.metrics_config, MetricContainer):
            self.metrics_config = MetricContainer(**as_dict(self.metrics_config))

        if self.optimizer is not None and not isinstance(self.optimizer, OptimizerEnum):
            self.optimizer = OptimizerEnum(self.optimizer)

        if self.fit_config is not None and not isinstance(self.fit_config, ClassifierFitParams):
            self.fit_config = ClassifierFitParams(**as_dict(self.fit_config))

        super().__post_init__(**kwargs)


@dataclass
class LayerContainer(YAMLRoot):
    """
    A container of neural network layers.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/LayerContainer")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "LayerContainer"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/LayerContainer")

    layers: Optional[Union[Union[dict, "Layer"], List[Union[dict, "Layer"]]]] = empty_list()

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if not isinstance(self.layers, list):
            self.layers = [self.layers] if self.layers is not None else []
        self.layers = [v if isinstance(v, Layer) else Layer(**as_dict(v)) for v in self.layers]

        super().__post_init__(**kwargs)


@dataclass
class Layer(YAMLRoot):
    """
    Layers for a neural network.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/Layer")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "Layer"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/Layer")

    type: Optional[str] = None
    parameters: Optional[Union[dict, "LayerParams"]] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.type is not None and not isinstance(self.type, str):
            self.type = str(self.type)

        if self.parameters is not None and not isinstance(self.parameters, LayerParams):
            self.parameters = LayerParams(**as_dict(self.parameters))

        super().__post_init__(**kwargs)


@dataclass
class LayerParams(YAMLRoot):
    """
    Parameters for each layer of a neural network.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/LayerParams")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "LayerParams"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/LayerParams")

    units: Optional[int] = None
    activation: Optional[Union[str, "ActivationEnum"]] = None
    rate: Optional[float] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.units is not None and not isinstance(self.units, int):
            self.units = int(self.units)

        if self.activation is not None and not isinstance(self.activation, ActivationEnum):
            self.activation = ActivationEnum(self.activation)

        if self.rate is not None and not isinstance(self.rate, float):
            self.rate = float(self.rate)

        super().__post_init__(**kwargs)


@dataclass
class MetricContainer(YAMLRoot):
    """
    Container of metrics for a trained classifier.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/MetricContainer")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "MetricContainer"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/MetricContainer")

    metrics: Optional[Union[Union[dict, "Metric"], List[Union[dict, "Metric"]]]] = empty_list()

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if not isinstance(self.metrics, list):
            self.metrics = [self.metrics] if self.metrics is not None else []
        self.metrics = [v if isinstance(v, Metric) else Metric(**as_dict(v)) for v in self.metrics]

        super().__post_init__(**kwargs)


@dataclass
class Metric(YAMLRoot):
    """
    Metrics of a trained classifier (model).
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/Metric")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "Metric"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/Metric")

    type: Optional[str] = None
    name: Optional[str] = None
    curve: Optional[str] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.type is not None and not isinstance(self.type, str):
            self.type = str(self.type)

        if self.name is not None and not isinstance(self.name, str):
            self.name = str(self.name)

        if self.curve is not None and not isinstance(self.curve, str):
            self.curve = str(self.curve)

        super().__post_init__(**kwargs)


@dataclass
class ClassifierFitParams(YAMLRoot):
    """
    Paramters for fitting a classifier.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/ClassifierFitParams")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "ClassifierFitParams"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/ClassifierFitParams")

    batch_size: Optional[int] = None
    epochs: Optional[int] = None
    callbacks_list: Optional[Union[dict, "ClassifierCallbackContainer"]] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.batch_size is not None and not isinstance(self.batch_size, int):
            self.batch_size = int(self.batch_size)

        if self.epochs is not None and not isinstance(self.epochs, int):
            self.epochs = int(self.epochs)

        if self.callbacks_list is not None and not isinstance(self.callbacks_list, ClassifierCallbackContainer):
            self.callbacks_list = ClassifierCallbackContainer(**as_dict(self.callbacks_list))

        super().__post_init__(**kwargs)


@dataclass
class ClassifierCallbackContainer(YAMLRoot):
    """
    A container of classifier callbacks.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/ClassifierCallbackContainer")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "ClassifierCallbackContainer"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/ClassifierCallbackContainer")

    callbacks: Optional[Union[Union[dict, "ClassifierCallback"], List[Union[dict, "ClassifierCallback"]]]] = empty_list()

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if not isinstance(self.callbacks, list):
            self.callbacks = [self.callbacks] if self.callbacks is not None else []
        self.callbacks = [v if isinstance(v, ClassifierCallback) else ClassifierCallback(**as_dict(v)) for v in self.callbacks]

        super().__post_init__(**kwargs)


@dataclass
class ClassifierCallback(YAMLRoot):
    """
    Utilities called at certain points during model training.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/ClassifierCallback")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "ClassifierCallback"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/ClassifierCallback")

    type: Optional[str] = None
    monitor: Optional[str] = None
    patience: Optional[int] = None
    min_delta: Optional[int] = None
    verbose: Optional[Union[bool, Bool]] = None
    mode: Optional[Union[str, "ClassifierCallbackModeEnum"]] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.type is not None and not isinstance(self.type, str):
            self.type = str(self.type)

        if self.monitor is not None and not isinstance(self.monitor, str):
            self.monitor = str(self.monitor)

        if self.patience is not None and not isinstance(self.patience, int):
            self.patience = int(self.patience)

        if self.min_delta is not None and not isinstance(self.min_delta, int):
            self.min_delta = int(self.min_delta)

        if self.verbose is not None and not isinstance(self.verbose, Bool):
            self.verbose = Bool(self.verbose)

        if self.mode is not None and not isinstance(self.mode, ClassifierCallbackModeEnum):
            self.mode = ClassifierCallbackModeEnum(self.mode)

        super().__post_init__(**kwargs)


@dataclass
class ApplyTrainedModelsContainer(YAMLRoot):
    """
    A container with multiple classifiers in it.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/ApplyTrainedModelsContainer")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "ApplyTrainedModelsContainer"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/ApplyTrainedModelsContainer")

    models: Optional[Union[Union[dict, "ApplyTrainedModel"], List[Union[dict, "ApplyTrainedModel"]]]] = empty_list()

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if not isinstance(self.models, list):
            self.models = [self.models] if self.models is not None else []
        self.models = [v if isinstance(v, ApplyTrainedModel) else ApplyTrainedModel(**as_dict(v)) for v in self.models]

        super().__post_init__(**kwargs)


@dataclass
class ApplyTrainedModel(YAMLRoot):
    """
    Trained model used for prediction.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/ApplyTrainedModel")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "ApplyTrainedModel"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/ApplyTrainedModel")

    model_id: Optional[str] = None
    node_types: Optional[Union[dict, "NodeType"]] = None
    cutoff: Optional[str] = None
    outfile: Optional[str] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.model_id is not None and not isinstance(self.model_id, str):
            self.model_id = str(self.model_id)

        if self.node_types is not None and not isinstance(self.node_types, NodeType):
            self.node_types = NodeType(**as_dict(self.node_types))

        if self.cutoff is not None and not isinstance(self.cutoff, str):
            self.cutoff = str(self.cutoff)

        if self.outfile is not None and not isinstance(self.outfile, str):
            self.outfile = str(self.outfile)

        super().__post_init__(**kwargs)


@dataclass
class NodeType(YAMLRoot):
    """
    Source node or Destination node.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/NodeType")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "NodeType"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/NodeType")

    source: Optional[Union[str, List[str]]] = empty_list()
    destination: Optional[Union[str, List[str]]] = empty_list()

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if not isinstance(self.source, list):
            self.source = [self.source] if self.source is not None else []
        self.source = [v if isinstance(v, str) else str(v) for v in self.source]

        if not isinstance(self.destination, list):
            self.destination = [self.destination] if self.destination is not None else []
        self.destination = [v if isinstance(v, str) else str(v) for v in self.destination]

        super().__post_init__(**kwargs)


@dataclass
class Upload(YAMLRoot):
    """
    Configuration for uploading to Amazon S3 bucket.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/Upload")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "Upload"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/Upload")

    s3_bucket: Optional[str] = None
    s3_bucket_dir: Optional[str] = None
    extra_args: Optional[Union[str, List[str]]] = empty_list()

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.s3_bucket is not None and not isinstance(self.s3_bucket, str):
            self.s3_bucket = str(self.s3_bucket)

        if self.s3_bucket_dir is not None and not isinstance(self.s3_bucket_dir, str):
            self.s3_bucket_dir = str(self.s3_bucket_dir)

        if not isinstance(self.extra_args, list):
            self.extra_args = [self.extra_args] if self.extra_args is not None else []
        self.extra_args = [v if isinstance(v, str) else str(v) for v in self.extra_args]

        super().__post_init__(**kwargs)


@dataclass
class Target(YAMLRoot):
    """
    Path for output to be saved.
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/Target")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "Target"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/Target")

    target_path: Optional[str] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.target_path is not None and not isinstance(self.target_path, str):
            self.target_path = str(self.target_path)

        super().__post_init__(**kwargs)


@dataclass
class EnsmallenRunConfig(YAMLRoot):
    """
    All params used by ensmallen's csv_reader
    """
    _inherited_slots: ClassVar[List[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/EnsmallenRunConfig")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "EnsmallenRunConfig"
    class_model_uri: ClassVar[URIRef] = URIRef("https://w3id.org/neat/EnsmallenRunConfig")

    node_type_path: Optional[str] = None
    node_type_list_separator: Optional[str] = None
    node_types_column_number: Optional[int] = None
    node_types_column: Optional[str] = None
    node_types_ids_column_number: Optional[int] = None
    node_types_ids_column: Optional[str] = None
    node_types_number: Optional[int] = None
    numeric_node_type_ids: Optional[Union[bool, Bool]] = None
    minimum_node_type_id: Optional[int] = None
    node_type_list_header: Optional[Union[bool, Bool]] = None
    node_type_list_support_balanced_quotes: Optional[Union[bool, Bool]] = None
    node_type_list_rows_to_skip: Optional[int] = None
    node_type_list_is_correct: Optional[Union[bool, Bool]] = None
    node_type_list_max_rows_number: Optional[int] = None
    node_type_list_comment_symbol: Optional[str] = None
    load_node_type_list_in_parallel: Optional[Union[bool, Bool]] = None
    node_path: Optional[str] = None
    node_list_separator: Optional[str] = None
    node_list_header: Optional[Union[bool, Bool]] = None
    node_list_support_balanced_quotes: Optional[Union[bool, Bool]] = None
    node_list_rows_to_skip: Optional[int] = None
    node_list_is_correct: Optional[Union[bool, Bool]] = None
    node_list_max_rows_number: Optional[int] = None
    node_list_comment_symbol: Optional[str] = None
    default_node_type: Optional[str] = None
    nodes_column_number: Optional[int] = None
    nodes_column: Optional[str] = None
    node_types_separator: Optional[str] = None
    node_list_node_types_column_number: Optional[int] = None
    node_list_node_types_column: Optional[str] = None
    node_ids_column: Optional[str] = None
    node_ids_column_number: Optional[int] = None
    nodes_number: Optional[int] = None
    minimum_node_id: Optional[int] = None
    numeric_node_ids: Optional[Union[bool, Bool]] = None
    node_list_numeric_node_type_ids: Optional[Union[bool, Bool]] = None
    skip_node_types_if_unavailable: Optional[Union[bool, Bool]] = None
    load_node_list_in_parallel: Optional[Union[bool, Bool]] = None
    edge_type_path: Optional[str] = None
    edge_types_column_number: Optional[int] = None
    edge_types_column: Optional[str] = None
    edge_types_number: Optional[int] = None
    numeric_edge_type_ids: Optional[Union[bool, Bool]] = None
    minimum_edge_type_id: Optional[int] = None
    edge_type_list_separator: Optional[str] = None
    edge_type_list_header: Optional[Union[bool, Bool]] = None
    edge_type_list_support_balanced_quotes: Optional[Union[bool, Bool]] = None
    edge_type_list_rows_to_skip: Optional[int] = None
    edge_type_list_is_correct: Optional[Union[bool, Bool]] = None
    edge_type_list_max_rows_number: Optional[int] = None
    edge_type_list_comment_symbol: Optional[str] = None
    load_edge_type_list_in_parallel: Optional[Union[bool, Bool]] = None
    edge_path: Optional[str] = None
    edge_list_separator: Optional[str] = None
    edge_list_header: Optional[Union[bool, Bool]] = None
    edge_list_support_balanced_quotes: Optional[Union[bool, Bool]] = None
    edge_list_rows_to_skip: Optional[int] = None
    sources_column_number: Optional[int] = None
    sources_column: Optional[str] = None
    destinations_column_number: Optional[int] = None
    destinations_column: Optional[str] = None
    edge_list_edge_types_column_number: Optional[int] = None
    edge_list_edge_types_column: Optional[str] = None
    default_edge_type: Optional[str] = None
    weights_column_number: Optional[int] = None
    weights_column: Optional[str] = None
    default_weight: Optional[float] = None
    edge_ids_column: Optional[str] = None
    edge_ids_column_number: Optional[int] = None
    edge_list_numeric_edge_type_ids: Optional[Union[bool, Bool]] = None
    edge_list_numeric_node_ids: Optional[Union[bool, Bool]] = None
    skip_weights_if_unavailable: Optional[Union[bool, Bool]] = None
    skip_edge_types_if_unavailable: Optional[Union[bool, Bool]] = None
    edge_list_is_complete: Optional[Union[bool, Bool]] = None
    edge_list_may_contain_duplicates: Optional[Union[bool, Bool]] = None
    edge_list_is_sorted: Optional[Union[bool, Bool]] = None
    edge_list_is_correct: Optional[Union[bool, Bool]] = None
    edge_list_max_rows_number: Optional[int] = None
    edge_list_comment_symbol: Optional[str] = None
    edges_number: Optional[int] = None
    load_edge_list_in_parallel: Optional[Union[bool, Bool]] = None
    verbose: Optional[Union[bool, Bool]] = None
    may_have_singletons: Optional[Union[bool, Bool]] = None
    may_have_singleton_with_selfloops: Optional[Union[bool, Bool]] = None
    directed: Optional[Union[bool, Bool]] = None
    name: Optional[str] = None

    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
        if self.node_type_path is not None and not isinstance(self.node_type_path, str):
            self.node_type_path = str(self.node_type_path)

        if self.node_type_list_separator is not None and not isinstance(self.node_type_list_separator, str):
            self.node_type_list_separator = str(self.node_type_list_separator)

        if self.node_types_column_number is not None and not isinstance(self.node_types_column_number, int):
            self.node_types_column_number = int(self.node_types_column_number)

        if self.node_types_column is not None and not isinstance(self.node_types_column, str):
            self.node_types_column = str(self.node_types_column)

        if self.node_types_ids_column_number is not None and not isinstance(self.node_types_ids_column_number, int):
            self.node_types_ids_column_number = int(self.node_types_ids_column_number)

        if self.node_types_ids_column is not None and not isinstance(self.node_types_ids_column, str):
            self.node_types_ids_column = str(self.node_types_ids_column)

        if self.node_types_number is not None and not isinstance(self.node_types_number, int):
            self.node_types_number = int(self.node_types_number)

        if self.numeric_node_type_ids is not None and not isinstance(self.numeric_node_type_ids, Bool):
            self.numeric_node_type_ids = Bool(self.numeric_node_type_ids)

        if self.minimum_node_type_id is not None and not isinstance(self.minimum_node_type_id, int):
            self.minimum_node_type_id = int(self.minimum_node_type_id)

        if self.node_type_list_header is not None and not isinstance(self.node_type_list_header, Bool):
            self.node_type_list_header = Bool(self.node_type_list_header)

        if self.node_type_list_support_balanced_quotes is not None and not isinstance(self.node_type_list_support_balanced_quotes, Bool):
            self.node_type_list_support_balanced_quotes = Bool(self.node_type_list_support_balanced_quotes)

        if self.node_type_list_rows_to_skip is not None and not isinstance(self.node_type_list_rows_to_skip, int):
            self.node_type_list_rows_to_skip = int(self.node_type_list_rows_to_skip)

        if self.node_type_list_is_correct is not None and not isinstance(self.node_type_list_is_correct, Bool):
            self.node_type_list_is_correct = Bool(self.node_type_list_is_correct)

        if self.node_type_list_max_rows_number is not None and not isinstance(self.node_type_list_max_rows_number, int):
            self.node_type_list_max_rows_number = int(self.node_type_list_max_rows_number)

        if self.node_type_list_comment_symbol is not None and not isinstance(self.node_type_list_comment_symbol, str):
            self.node_type_list_comment_symbol = str(self.node_type_list_comment_symbol)

        if self.load_node_type_list_in_parallel is not None and not isinstance(self.load_node_type_list_in_parallel, Bool):
            self.load_node_type_list_in_parallel = Bool(self.load_node_type_list_in_parallel)

        if self.node_path is not None and not isinstance(self.node_path, str):
            self.node_path = str(self.node_path)

        if self.node_list_separator is not None and not isinstance(self.node_list_separator, str):
            self.node_list_separator = str(self.node_list_separator)

        if self.node_list_header is not None and not isinstance(self.node_list_header, Bool):
            self.node_list_header = Bool(self.node_list_header)

        if self.node_list_support_balanced_quotes is not None and not isinstance(self.node_list_support_balanced_quotes, Bool):
            self.node_list_support_balanced_quotes = Bool(self.node_list_support_balanced_quotes)

        if self.node_list_rows_to_skip is not None and not isinstance(self.node_list_rows_to_skip, int):
            self.node_list_rows_to_skip = int(self.node_list_rows_to_skip)

        if self.node_list_is_correct is not None and not isinstance(self.node_list_is_correct, Bool):
            self.node_list_is_correct = Bool(self.node_list_is_correct)

        if self.node_list_max_rows_number is not None and not isinstance(self.node_list_max_rows_number, int):
            self.node_list_max_rows_number = int(self.node_list_max_rows_number)

        if self.node_list_comment_symbol is not None and not isinstance(self.node_list_comment_symbol, str):
            self.node_list_comment_symbol = str(self.node_list_comment_symbol)

        if self.default_node_type is not None and not isinstance(self.default_node_type, str):
            self.default_node_type = str(self.default_node_type)

        if self.nodes_column_number is not None and not isinstance(self.nodes_column_number, int):
            self.nodes_column_number = int(self.nodes_column_number)

        if self.nodes_column is not None and not isinstance(self.nodes_column, str):
            self.nodes_column = str(self.nodes_column)

        if self.node_types_separator is not None and not isinstance(self.node_types_separator, str):
            self.node_types_separator = str(self.node_types_separator)

        if self.node_list_node_types_column_number is not None and not isinstance(self.node_list_node_types_column_number, int):
            self.node_list_node_types_column_number = int(self.node_list_node_types_column_number)

        if self.node_list_node_types_column is not None and not isinstance(self.node_list_node_types_column, str):
            self.node_list_node_types_column = str(self.node_list_node_types_column)

        if self.node_ids_column is not None and not isinstance(self.node_ids_column, str):
            self.node_ids_column = str(self.node_ids_column)

        if self.node_ids_column_number is not None and not isinstance(self.node_ids_column_number, int):
            self.node_ids_column_number = int(self.node_ids_column_number)

        if self.nodes_number is not None and not isinstance(self.nodes_number, int):
            self.nodes_number = int(self.nodes_number)

        if self.minimum_node_id is not None and not isinstance(self.minimum_node_id, int):
            self.minimum_node_id = int(self.minimum_node_id)

        if self.numeric_node_ids is not None and not isinstance(self.numeric_node_ids, Bool):
            self.numeric_node_ids = Bool(self.numeric_node_ids)

        if self.node_list_numeric_node_type_ids is not None and not isinstance(self.node_list_numeric_node_type_ids, Bool):
            self.node_list_numeric_node_type_ids = Bool(self.node_list_numeric_node_type_ids)

        if self.skip_node_types_if_unavailable is not None and not isinstance(self.skip_node_types_if_unavailable, Bool):
            self.skip_node_types_if_unavailable = Bool(self.skip_node_types_if_unavailable)

        if self.load_node_list_in_parallel is not None and not isinstance(self.load_node_list_in_parallel, Bool):
            self.load_node_list_in_parallel = Bool(self.load_node_list_in_parallel)

        if self.edge_type_path is not None and not isinstance(self.edge_type_path, str):
            self.edge_type_path = str(self.edge_type_path)

        if self.edge_types_column_number is not None and not isinstance(self.edge_types_column_number, int):
            self.edge_types_column_number = int(self.edge_types_column_number)

        if self.edge_types_column is not None and not isinstance(self.edge_types_column, str):
            self.edge_types_column = str(self.edge_types_column)

        if self.edge_types_number is not None and not isinstance(self.edge_types_number, int):
            self.edge_types_number = int(self.edge_types_number)

        if self.numeric_edge_type_ids is not None and not isinstance(self.numeric_edge_type_ids, Bool):
            self.numeric_edge_type_ids = Bool(self.numeric_edge_type_ids)

        if self.minimum_edge_type_id is not None and not isinstance(self.minimum_edge_type_id, int):
            self.minimum_edge_type_id = int(self.minimum_edge_type_id)

        if self.edge_type_list_separator is not None and not isinstance(self.edge_type_list_separator, str):
            self.edge_type_list_separator = str(self.edge_type_list_separator)

        if self.edge_type_list_header is not None and not isinstance(self.edge_type_list_header, Bool):
            self.edge_type_list_header = Bool(self.edge_type_list_header)

        if self.edge_type_list_support_balanced_quotes is not None and not isinstance(self.edge_type_list_support_balanced_quotes, Bool):
            self.edge_type_list_support_balanced_quotes = Bool(self.edge_type_list_support_balanced_quotes)

        if self.edge_type_list_rows_to_skip is not None and not isinstance(self.edge_type_list_rows_to_skip, int):
            self.edge_type_list_rows_to_skip = int(self.edge_type_list_rows_to_skip)

        if self.edge_type_list_is_correct is not None and not isinstance(self.edge_type_list_is_correct, Bool):
            self.edge_type_list_is_correct = Bool(self.edge_type_list_is_correct)

        if self.edge_type_list_max_rows_number is not None and not isinstance(self.edge_type_list_max_rows_number, int):
            self.edge_type_list_max_rows_number = int(self.edge_type_list_max_rows_number)

        if self.edge_type_list_comment_symbol is not None and not isinstance(self.edge_type_list_comment_symbol, str):
            self.edge_type_list_comment_symbol = str(self.edge_type_list_comment_symbol)

        if self.load_edge_type_list_in_parallel is not None and not isinstance(self.load_edge_type_list_in_parallel, Bool):
            self.load_edge_type_list_in_parallel = Bool(self.load_edge_type_list_in_parallel)

        if self.edge_path is not None and not isinstance(self.edge_path, str):
            self.edge_path = str(self.edge_path)

        if self.edge_list_separator is not None and not isinstance(self.edge_list_separator, str):
            self.edge_list_separator = str(self.edge_list_separator)

        if self.edge_list_header is not None and not isinstance(self.edge_list_header, Bool):
            self.edge_list_header = Bool(self.edge_list_header)

        if self.edge_list_support_balanced_quotes is not None and not isinstance(self.edge_list_support_balanced_quotes, Bool):
            self.edge_list_support_balanced_quotes = Bool(self.edge_list_support_balanced_quotes)

        if self.edge_list_rows_to_skip is not None and not isinstance(self.edge_list_rows_to_skip, int):
            self.edge_list_rows_to_skip = int(self.edge_list_rows_to_skip)

        if self.sources_column_number is not None and not isinstance(self.sources_column_number, int):
            self.sources_column_number = int(self.sources_column_number)

        if self.sources_column is not None and not isinstance(self.sources_column, str):
            self.sources_column = str(self.sources_column)

        if self.destinations_column_number is not None and not isinstance(self.destinations_column_number, int):
            self.destinations_column_number = int(self.destinations_column_number)

        if self.destinations_column is not None and not isinstance(self.destinations_column, str):
            self.destinations_column = str(self.destinations_column)

        if self.edge_list_edge_types_column_number is not None and not isinstance(self.edge_list_edge_types_column_number, int):
            self.edge_list_edge_types_column_number = int(self.edge_list_edge_types_column_number)

        if self.edge_list_edge_types_column is not None and not isinstance(self.edge_list_edge_types_column, str):
            self.edge_list_edge_types_column = str(self.edge_list_edge_types_column)

        if self.default_edge_type is not None and not isinstance(self.default_edge_type, str):
            self.default_edge_type = str(self.default_edge_type)

        if self.weights_column_number is not None and not isinstance(self.weights_column_number, int):
            self.weights_column_number = int(self.weights_column_number)

        if self.weights_column is not None and not isinstance(self.weights_column, str):
            self.weights_column = str(self.weights_column)

        if self.default_weight is not None and not isinstance(self.default_weight, float):
            self.default_weight = float(self.default_weight)

        if self.edge_ids_column is not None and not isinstance(self.edge_ids_column, str):
            self.edge_ids_column = str(self.edge_ids_column)

        if self.edge_ids_column_number is not None and not isinstance(self.edge_ids_column_number, int):
            self.edge_ids_column_number = int(self.edge_ids_column_number)

        if self.edge_list_numeric_edge_type_ids is not None and not isinstance(self.edge_list_numeric_edge_type_ids, Bool):
            self.edge_list_numeric_edge_type_ids = Bool(self.edge_list_numeric_edge_type_ids)

        if self.edge_list_numeric_node_ids is not None and not isinstance(self.edge_list_numeric_node_ids, Bool):
            self.edge_list_numeric_node_ids = Bool(self.edge_list_numeric_node_ids)

        if self.skip_weights_if_unavailable is not None and not isinstance(self.skip_weights_if_unavailable, Bool):
            self.skip_weights_if_unavailable = Bool(self.skip_weights_if_unavailable)

        if self.skip_edge_types_if_unavailable is not None and not isinstance(self.skip_edge_types_if_unavailable, Bool):
            self.skip_edge_types_if_unavailable = Bool(self.skip_edge_types_if_unavailable)

        if self.edge_list_is_complete is not None and not isinstance(self.edge_list_is_complete, Bool):
            self.edge_list_is_complete = Bool(self.edge_list_is_complete)

        if self.edge_list_may_contain_duplicates is not None and not isinstance(self.edge_list_may_contain_duplicates, Bool):
            self.edge_list_may_contain_duplicates = Bool(self.edge_list_may_contain_duplicates)

        if self.edge_list_is_sorted is not None and not isinstance(self.edge_list_is_sorted, Bool):
            self.edge_list_is_sorted = Bool(self.edge_list_is_sorted)

        if self.edge_list_is_correct is not None and not isinstance(self.edge_list_is_correct, Bool):
            self.edge_list_is_correct = Bool(self.edge_list_is_correct)

        if self.edge_list_max_rows_number is not None and not isinstance(self.edge_list_max_rows_number, int):
            self.edge_list_max_rows_number = int(self.edge_list_max_rows_number)

        if self.edge_list_comment_symbol is not None and not isinstance(self.edge_list_comment_symbol, str):
            self.edge_list_comment_symbol = str(self.edge_list_comment_symbol)

        if self.edges_number is not None and not isinstance(self.edges_number, int):
            self.edges_number = int(self.edges_number)

        if self.load_edge_list_in_parallel is not None and not isinstance(self.load_edge_list_in_parallel, Bool):
            self.load_edge_list_in_parallel = Bool(self.load_edge_list_in_parallel)

        if self.verbose is not None and not isinstance(self.verbose, Bool):
            self.verbose = Bool(self.verbose)

        if self.may_have_singletons is not None and not isinstance(self.may_have_singletons, Bool):
            self.may_have_singletons = Bool(self.may_have_singletons)

        if self.may_have_singleton_with_selfloops is not None and not isinstance(self.may_have_singleton_with_selfloops, Bool):
            self.may_have_singleton_with_selfloops = Bool(self.may_have_singleton_with_selfloops)

        if self.directed is not None and not isinstance(self.directed, Bool):
            self.directed = Bool(self.directed)

        if self.name is not None and not isinstance(self.name, str):
            self.name = str(self.name)

        super().__post_init__(**kwargs)


# Enumerations
class NodeEmbedMethodEnum(EnumDefinitionImpl):
    """
    Enums containing possible values for node embedding methods.
    """
    SkipGram = PermissibleValue(text="SkipGram",
                                       description="Skip-gram is used to predict the context word for a given target word. It's reverse of CBOW algorithm.")
    CBOW = PermissibleValue(text="CBOW",
                               description="Continuous Bag of Words Model (CBOW). In the CBOW model, the distributed representations of context (or surrounding words) are combined to predict the word in the middle.")
    GloVe = PermissibleValue(text="GloVe",
                                 description="GloVe is an unsupervised learning algorithm for obtaining vector representations for words. Training is performed on aggregated global word-word co-occurrence statistics from a corpus, and the resulting representations showcase interesting linear substructures of the word vector space.")
    Siamese = PermissibleValue(text="Siamese",
                                     description="A Siamese neural network (sometimes called a twin neural network) is an artificial neural network that uses the same weights while working in tandem on two different input vectors to compute comparable output vectors.")
    TransE = PermissibleValue(text="TransE",
                                   description="TransE, or Translating Embeddings for Modeling Multi-relational Data, lets us embed the contents of a knowledge graph by assigning vectors to nodes and edge types (a.k.a. predicates) and, for each subject-predicate-object triple, minimizing the distance between the object vector and the translation of the subject vector along the predicate vector.")
    SimplE = PermissibleValue(text="SimplE")
    TransH = PermissibleValue(text="TransH",
                                   description="TransH defines a hyperplane for each relationship r, and uses the translation vector r and normal vector w of the relationship r on the plane to represent it.")
    TransR = PermissibleValue(text="TransR")

    _defn = EnumDefinition(
        name="NodeEmbedMethodEnum",
        description="Enums containing possible values for node embedding methods.",
    )

class EdgeMethodEnum(EnumDefinitionImpl):
    """
    Enums containing possible values for node edge methods.
    """
    Average = PermissibleValue(text="Average")
    Hadamard = PermissibleValue(text="Hadamard")
    Sum = PermissibleValue(text="Sum")
    L1 = PermissibleValue(text="L1")
    L2 = PermissibleValue(text="L2")
    AbsoluteL1 = PermissibleValue(text="AbsoluteL1")

    _defn = EnumDefinition(
        name="EdgeMethodEnum",
        description="Enums containing possible values for node edge methods.",
    )

class ActivationEnum(EnumDefinitionImpl):
    """
    Enums containing possible values for activation functions.
    """
    linear = PermissibleValue(text="linear",
                                   description="Linear function.")
    relu = PermissibleValue(text="relu",
                               description="Rectified Linear Unit (ReLU)")
    sigmoid = PermissibleValue(text="sigmoid",
                                     description="Sigmoid activation function.")
    tanh = PermissibleValue(text="tanh",
                               description="The tanh function.")
    softmax = PermissibleValue(text="softmax",
                                     description="Softmax (or softargmax) function.")

    _defn = EnumDefinition(
        name="ActivationEnum",
        description="Enums containing possible values for activation functions.",
    )

class OptimizerEnum(EnumDefinitionImpl):
    """
    Optimizers that can be implemented in the neural network.
    """
    adagrad = PermissibleValue(text="adagrad",
                                     description="Optimizer that implements the Adagrad algorithm.")
    adam = PermissibleValue(text="adam",
                               description="Optimizer that implements the Adam algorithm.")
    adamax = PermissibleValue(text="adamax",
                                   description="Optimizer that implements the Adamax algorithm.")
    nadam = PermissibleValue(text="nadam",
                                 description="Optimizer that implements the NAdam algorithm.")
    sgd = PermissibleValue(text="sgd",
                             description="Stochastic gradient descent (with momentum) optimizer.")

    _defn = EnumDefinition(
        name="OptimizerEnum",
        description="Optimizers that can be implemented in the neural network.",
    )

class ClassifierCallbackModeEnum(EnumDefinitionImpl):
    """
    Callback modes while fitting a classifier.
    """
    auto = PermissibleValue(text="auto",
                               description="In 'auto' mode, the direction is automatically inferred from the name of the monitored quantity.")
    min = PermissibleValue(text="min",
                             description="In 'min' mode, the learning rate will be reduced when the quantity monitored has stopped decreasing.")
    max = PermissibleValue(text="max",
                             description="In 'max' mode, the learning rate will be reduced when the quantity monitored has stopped increasing")

    _defn = EnumDefinition(
        name="ClassifierCallbackModeEnum",
        description="Callback modes while fitting a classifier.",
    )

# Slots
class slots:
    pass

slots.neatConfiguration__graph_data = Slot(uri=DEFAULT_.graph_data, name="neatConfiguration__graph_data", curie=DEFAULT_.curie('graph_data'),
                   model_uri=DEFAULT_.neatConfiguration__graph_data, domain=None, range=Optional[Union[dict, GraphDataConfiguration]])

slots.graphDataConfiguration__graph = Slot(uri=DEFAULT_.graph, name="graphDataConfiguration__graph", curie=DEFAULT_.curie('graph'),
                   model_uri=DEFAULT_.graphDataConfiguration__graph, domain=None, range=Optional[Union[dict, EnsmallenRunConfig]])

slots.graphDataConfiguration__evaluation_data = Slot(uri=DEFAULT_.evaluation_data, name="graphDataConfiguration__evaluation_data", curie=DEFAULT_.curie('evaluation_data'),
                   model_uri=DEFAULT_.graphDataConfiguration__evaluation_data, domain=None, range=Optional[Union[dict, TrainValidData]])

slots.graphDataConfiguration__source_data = Slot(uri=DEFAULT_.source_data, name="graphDataConfiguration__source_data", curie=DEFAULT_.curie('source_data'),
                   model_uri=DEFAULT_.graphDataConfiguration__source_data, domain=None, range=Optional[Union[dict, FileResourceContainer]])

slots.fileResourceContainer__files = Slot(uri=DEFAULT_.files, name="fileResourceContainer__files", curie=DEFAULT_.curie('files'),
                   model_uri=DEFAULT_.fileResourceContainer__files, domain=None, range=Optional[Union[Union[dict, FileResource], List[Union[dict, FileResource]]]])

slots.fileResource__path = Slot(uri=DEFAULT_.path, name="fileResource__path", curie=DEFAULT_.curie('path'),
                   model_uri=DEFAULT_.fileResource__path, domain=None, range=Optional[str])

slots.fileResource__desc = Slot(uri=DEFAULT_.desc, name="fileResource__desc", curie=DEFAULT_.curie('desc'),
                   model_uri=DEFAULT_.fileResource__desc, domain=None, range=Optional[str])

slots.trainValidData__train_data = Slot(uri=DEFAULT_.train_data, name="trainValidData__train_data", curie=DEFAULT_.curie('train_data'),
                   model_uri=DEFAULT_.trainValidData__train_data, domain=None, range=Optional[Union[dict, PosNegData]])

slots.trainValidData__valid_data = Slot(uri=DEFAULT_.valid_data, name="trainValidData__valid_data", curie=DEFAULT_.curie('valid_data'),
                   model_uri=DEFAULT_.trainValidData__valid_data, domain=None, range=Optional[Union[dict, PosNegData]])

slots.posNegData__pos_edge_filepath = Slot(uri=DEFAULT_.pos_edge_filepath, name="posNegData__pos_edge_filepath", curie=DEFAULT_.curie('pos_edge_filepath'),
                   model_uri=DEFAULT_.posNegData__pos_edge_filepath, domain=None, range=Optional[str])

slots.posNegData__neg_edge_filepath = Slot(uri=DEFAULT_.neg_edge_filepath, name="posNegData__neg_edge_filepath", curie=DEFAULT_.curie('neg_edge_filepath'),
                   model_uri=DEFAULT_.posNegData__neg_edge_filepath, domain=None, range=Optional[str])

slots.embeddingsConfig__filename = Slot(uri=DEFAULT_.filename, name="embeddingsConfig__filename", curie=DEFAULT_.curie('filename'),
                   model_uri=DEFAULT_.embeddingsConfig__filename, domain=None, range=Optional[str])

slots.embeddingsConfig__history_filename = Slot(uri=DEFAULT_.history_filename, name="embeddingsConfig__history_filename", curie=DEFAULT_.curie('history_filename'),
                   model_uri=DEFAULT_.embeddingsConfig__history_filename, domain=None, range=Optional[str])

slots.embeddingsConfig__node_embeddings_params = Slot(uri=DEFAULT_.node_embeddings_params, name="embeddingsConfig__node_embeddings_params", curie=DEFAULT_.curie('node_embeddings_params'),
                   model_uri=DEFAULT_.embeddingsConfig__node_embeddings_params, domain=None, range=Optional[Union[dict, NodeEmbeddingsParams]])

slots.embeddingsConfig__tsne_filename = Slot(uri=DEFAULT_.tsne_filename, name="embeddingsConfig__tsne_filename", curie=DEFAULT_.curie('tsne_filename'),
                   model_uri=DEFAULT_.embeddingsConfig__tsne_filename, domain=None, range=Optional[str])

slots.nodeEmbeddingsParams__method_name = Slot(uri=DEFAULT_.method_name, name="nodeEmbeddingsParams__method_name", curie=DEFAULT_.curie('method_name'),
                   model_uri=DEFAULT_.nodeEmbeddingsParams__method_name, domain=None, range=Optional[Union[str, "NodeEmbedMethodEnum"]])

slots.nodeEmbeddingsParams__walk_length = Slot(uri=DEFAULT_.walk_length, name="nodeEmbeddingsParams__walk_length", curie=DEFAULT_.curie('walk_length'),
                   model_uri=DEFAULT_.nodeEmbeddingsParams__walk_length, domain=None, range=Optional[int])

slots.nodeEmbeddingsParams__batch_size = Slot(uri=DEFAULT_.batch_size, name="nodeEmbeddingsParams__batch_size", curie=DEFAULT_.curie('batch_size'),
                   model_uri=DEFAULT_.nodeEmbeddingsParams__batch_size, domain=None, range=Optional[int])

slots.nodeEmbeddingsParams__window_size = Slot(uri=DEFAULT_.window_size, name="nodeEmbeddingsParams__window_size", curie=DEFAULT_.curie('window_size'),
                   model_uri=DEFAULT_.nodeEmbeddingsParams__window_size, domain=None, range=Optional[int])

slots.nodeEmbeddingsParams__return_weight = Slot(uri=DEFAULT_.return_weight, name="nodeEmbeddingsParams__return_weight", curie=DEFAULT_.curie('return_weight'),
                   model_uri=DEFAULT_.nodeEmbeddingsParams__return_weight, domain=None, range=Optional[float])

slots.nodeEmbeddingsParams__explore_weight = Slot(uri=DEFAULT_.explore_weight, name="nodeEmbeddingsParams__explore_weight", curie=DEFAULT_.curie('explore_weight'),
                   model_uri=DEFAULT_.nodeEmbeddingsParams__explore_weight, domain=None, range=Optional[float])

slots.nodeEmbeddingsParams__iterations = Slot(uri=DEFAULT_.iterations, name="nodeEmbeddingsParams__iterations", curie=DEFAULT_.curie('iterations'),
                   model_uri=DEFAULT_.nodeEmbeddingsParams__iterations, domain=None, range=Optional[int])

slots.classifierContainer__classifiers = Slot(uri=DEFAULT_.classifiers, name="classifierContainer__classifiers", curie=DEFAULT_.curie('classifiers'),
                   model_uri=DEFAULT_.classifierContainer__classifiers, domain=None, range=Optional[Union[Union[dict, Classifier], List[Union[dict, Classifier]]]])

slots.classifier__classifier_id = Slot(uri=DEFAULT_.classifier_id, name="classifier__classifier_id", curie=DEFAULT_.curie('classifier_id'),
                   model_uri=DEFAULT_.classifier__classifier_id, domain=None, range=Optional[str])

slots.classifier__classifier_name = Slot(uri=DEFAULT_.classifier_name, name="classifier__classifier_name", curie=DEFAULT_.curie('classifier_name'),
                   model_uri=DEFAULT_.classifier__classifier_name, domain=None, range=Optional[str])

slots.classifier__classifier_type = Slot(uri=DEFAULT_.classifier_type, name="classifier__classifier_type", curie=DEFAULT_.curie('classifier_type'),
                   model_uri=DEFAULT_.classifier__classifier_type, domain=None, range=Optional[str])

slots.classifier__edge_method = Slot(uri=DEFAULT_.edge_method, name="classifier__edge_method", curie=DEFAULT_.curie('edge_method'),
                   model_uri=DEFAULT_.classifier__edge_method, domain=None, range=Optional[Union[str, "EdgeMethodEnum"]])

slots.classifier__outfile = Slot(uri=DEFAULT_.outfile, name="classifier__outfile", curie=DEFAULT_.curie('outfile'),
                   model_uri=DEFAULT_.classifier__outfile, domain=None, range=Optional[str])

slots.classifier__history_filename = Slot(uri=DEFAULT_.history_filename, name="classifier__history_filename", curie=DEFAULT_.curie('history_filename'),
                   model_uri=DEFAULT_.classifier__history_filename, domain=None, range=Optional[str])

slots.classifier__parameters = Slot(uri=DEFAULT_.parameters, name="classifier__parameters", curie=DEFAULT_.curie('parameters'),
                   model_uri=DEFAULT_.classifier__parameters, domain=None, range=Optional[Union[dict, ClassifierParams]])

slots.classifierParams__sklearn_params = Slot(uri=DEFAULT_.sklearn_params, name="classifierParams__sklearn_params", curie=DEFAULT_.curie('sklearn_params'),
                   model_uri=DEFAULT_.classifierParams__sklearn_params, domain=None, range=Optional[Union[dict, SkLearnParams]])

slots.classifierParams__tf_keras_params = Slot(uri=DEFAULT_.tf_keras_params, name="classifierParams__tf_keras_params", curie=DEFAULT_.curie('tf_keras_params'),
                   model_uri=DEFAULT_.classifierParams__tf_keras_params, domain=None, range=Optional[Union[dict, TFKerasParams]])

slots.skLearnParams__random_state = Slot(uri=DEFAULT_.random_state, name="skLearnParams__random_state", curie=DEFAULT_.curie('random_state'),
                   model_uri=DEFAULT_.skLearnParams__random_state, domain=None, range=Optional[int])

slots.skLearnParams__max_iter = Slot(uri=DEFAULT_.max_iter, name="skLearnParams__max_iter", curie=DEFAULT_.curie('max_iter'),
                   model_uri=DEFAULT_.skLearnParams__max_iter, domain=None, range=Optional[int])

slots.tFKerasParams__layers_config = Slot(uri=DEFAULT_.layers_config, name="tFKerasParams__layers_config", curie=DEFAULT_.curie('layers_config'),
                   model_uri=DEFAULT_.tFKerasParams__layers_config, domain=None, range=Optional[Union[dict, LayerContainer]])

slots.tFKerasParams__loss = Slot(uri=DEFAULT_.loss, name="tFKerasParams__loss", curie=DEFAULT_.curie('loss'),
                   model_uri=DEFAULT_.tFKerasParams__loss, domain=None, range=Optional[str])

slots.tFKerasParams__metrics_config = Slot(uri=DEFAULT_.metrics_config, name="tFKerasParams__metrics_config", curie=DEFAULT_.curie('metrics_config'),
                   model_uri=DEFAULT_.tFKerasParams__metrics_config, domain=None, range=Optional[Union[dict, MetricContainer]])

slots.tFKerasParams__optimizer = Slot(uri=DEFAULT_.optimizer, name="tFKerasParams__optimizer", curie=DEFAULT_.curie('optimizer'),
                   model_uri=DEFAULT_.tFKerasParams__optimizer, domain=None, range=Optional[Union[str, "OptimizerEnum"]])

slots.tFKerasParams__fit_config = Slot(uri=DEFAULT_.fit_config, name="tFKerasParams__fit_config", curie=DEFAULT_.curie('fit_config'),
                   model_uri=DEFAULT_.tFKerasParams__fit_config, domain=None, range=Optional[Union[dict, ClassifierFitParams]])

slots.layerContainer__layers = Slot(uri=DEFAULT_.layers, name="layerContainer__layers", curie=DEFAULT_.curie('layers'),
                   model_uri=DEFAULT_.layerContainer__layers, domain=None, range=Optional[Union[Union[dict, Layer], List[Union[dict, Layer]]]])

slots.layer__type = Slot(uri=DEFAULT_.type, name="layer__type", curie=DEFAULT_.curie('type'),
                   model_uri=DEFAULT_.layer__type, domain=None, range=Optional[str])

slots.layer__parameters = Slot(uri=DEFAULT_.parameters, name="layer__parameters", curie=DEFAULT_.curie('parameters'),
                   model_uri=DEFAULT_.layer__parameters, domain=None, range=Optional[Union[dict, LayerParams]])

slots.layerParams__units = Slot(uri=DEFAULT_.units, name="layerParams__units", curie=DEFAULT_.curie('units'),
                   model_uri=DEFAULT_.layerParams__units, domain=None, range=Optional[int])

slots.layerParams__activation = Slot(uri=DEFAULT_.activation, name="layerParams__activation", curie=DEFAULT_.curie('activation'),
                   model_uri=DEFAULT_.layerParams__activation, domain=None, range=Optional[Union[str, "ActivationEnum"]])

slots.layerParams__rate = Slot(uri=DEFAULT_.rate, name="layerParams__rate", curie=DEFAULT_.curie('rate'),
                   model_uri=DEFAULT_.layerParams__rate, domain=None, range=Optional[float])

slots.metricContainer__metrics = Slot(uri=DEFAULT_.metrics, name="metricContainer__metrics", curie=DEFAULT_.curie('metrics'),
                   model_uri=DEFAULT_.metricContainer__metrics, domain=None, range=Optional[Union[Union[dict, Metric], List[Union[dict, Metric]]]])

slots.metric__type = Slot(uri=DEFAULT_.type, name="metric__type", curie=DEFAULT_.curie('type'),
                   model_uri=DEFAULT_.metric__type, domain=None, range=Optional[str])

slots.metric__name = Slot(uri=DEFAULT_.name, name="metric__name", curie=DEFAULT_.curie('name'),
                   model_uri=DEFAULT_.metric__name, domain=None, range=Optional[str])

slots.metric__curve = Slot(uri=DEFAULT_.curve, name="metric__curve", curie=DEFAULT_.curie('curve'),
                   model_uri=DEFAULT_.metric__curve, domain=None, range=Optional[str])

slots.classifierFitParams__batch_size = Slot(uri=DEFAULT_.batch_size, name="classifierFitParams__batch_size", curie=DEFAULT_.curie('batch_size'),
                   model_uri=DEFAULT_.classifierFitParams__batch_size, domain=None, range=Optional[int])

slots.classifierFitParams__epochs = Slot(uri=DEFAULT_.epochs, name="classifierFitParams__epochs", curie=DEFAULT_.curie('epochs'),
                   model_uri=DEFAULT_.classifierFitParams__epochs, domain=None, range=Optional[int])

slots.classifierFitParams__callbacks_list = Slot(uri=DEFAULT_.callbacks_list, name="classifierFitParams__callbacks_list", curie=DEFAULT_.curie('callbacks_list'),
                   model_uri=DEFAULT_.classifierFitParams__callbacks_list, domain=None, range=Optional[Union[dict, ClassifierCallbackContainer]])

slots.classifierCallbackContainer__callbacks = Slot(uri=DEFAULT_.callbacks, name="classifierCallbackContainer__callbacks", curie=DEFAULT_.curie('callbacks'),
                   model_uri=DEFAULT_.classifierCallbackContainer__callbacks, domain=None, range=Optional[Union[Union[dict, ClassifierCallback], List[Union[dict, ClassifierCallback]]]])

slots.classifierCallback__type = Slot(uri=DEFAULT_.type, name="classifierCallback__type", curie=DEFAULT_.curie('type'),
                   model_uri=DEFAULT_.classifierCallback__type, domain=None, range=Optional[str])

slots.classifierCallback__monitor = Slot(uri=DEFAULT_.monitor, name="classifierCallback__monitor", curie=DEFAULT_.curie('monitor'),
                   model_uri=DEFAULT_.classifierCallback__monitor, domain=None, range=Optional[str])

slots.classifierCallback__patience = Slot(uri=DEFAULT_.patience, name="classifierCallback__patience", curie=DEFAULT_.curie('patience'),
                   model_uri=DEFAULT_.classifierCallback__patience, domain=None, range=Optional[int])

slots.classifierCallback__min_delta = Slot(uri=DEFAULT_.min_delta, name="classifierCallback__min_delta", curie=DEFAULT_.curie('min_delta'),
                   model_uri=DEFAULT_.classifierCallback__min_delta, domain=None, range=Optional[int])

slots.classifierCallback__verbose = Slot(uri=DEFAULT_.verbose, name="classifierCallback__verbose", curie=DEFAULT_.curie('verbose'),
                   model_uri=DEFAULT_.classifierCallback__verbose, domain=None, range=Optional[Union[bool, Bool]])

slots.classifierCallback__mode = Slot(uri=DEFAULT_.mode, name="classifierCallback__mode", curie=DEFAULT_.curie('mode'),
                   model_uri=DEFAULT_.classifierCallback__mode, domain=None, range=Optional[Union[str, "ClassifierCallbackModeEnum"]])

slots.applyTrainedModelsContainer__models = Slot(uri=DEFAULT_.models, name="applyTrainedModelsContainer__models", curie=DEFAULT_.curie('models'),
                   model_uri=DEFAULT_.applyTrainedModelsContainer__models, domain=None, range=Optional[Union[Union[dict, ApplyTrainedModel], List[Union[dict, ApplyTrainedModel]]]])

slots.applyTrainedModel__model_id = Slot(uri=DEFAULT_.model_id, name="applyTrainedModel__model_id", curie=DEFAULT_.curie('model_id'),
                   model_uri=DEFAULT_.applyTrainedModel__model_id, domain=None, range=Optional[str])

slots.applyTrainedModel__node_types = Slot(uri=DEFAULT_.node_types, name="applyTrainedModel__node_types", curie=DEFAULT_.curie('node_types'),
                   model_uri=DEFAULT_.applyTrainedModel__node_types, domain=None, range=Optional[Union[dict, NodeType]])

slots.applyTrainedModel__cutoff = Slot(uri=DEFAULT_.cutoff, name="applyTrainedModel__cutoff", curie=DEFAULT_.curie('cutoff'),
                   model_uri=DEFAULT_.applyTrainedModel__cutoff, domain=None, range=Optional[str])

slots.applyTrainedModel__outfile = Slot(uri=DEFAULT_.outfile, name="applyTrainedModel__outfile", curie=DEFAULT_.curie('outfile'),
                   model_uri=DEFAULT_.applyTrainedModel__outfile, domain=None, range=Optional[str])

slots.nodeType__source = Slot(uri=DEFAULT_.source, name="nodeType__source", curie=DEFAULT_.curie('source'),
                   model_uri=DEFAULT_.nodeType__source, domain=None, range=Optional[Union[str, List[str]]])

slots.nodeType__destination = Slot(uri=DEFAULT_.destination, name="nodeType__destination", curie=DEFAULT_.curie('destination'),
                   model_uri=DEFAULT_.nodeType__destination, domain=None, range=Optional[Union[str, List[str]]])

slots.upload__s3_bucket = Slot(uri=DEFAULT_.s3_bucket, name="upload__s3_bucket", curie=DEFAULT_.curie('s3_bucket'),
                   model_uri=DEFAULT_.upload__s3_bucket, domain=None, range=Optional[str])

slots.upload__s3_bucket_dir = Slot(uri=DEFAULT_.s3_bucket_dir, name="upload__s3_bucket_dir", curie=DEFAULT_.curie('s3_bucket_dir'),
                   model_uri=DEFAULT_.upload__s3_bucket_dir, domain=None, range=Optional[str])

slots.upload__extra_args = Slot(uri=DEFAULT_.extra_args, name="upload__extra_args", curie=DEFAULT_.curie('extra_args'),
                   model_uri=DEFAULT_.upload__extra_args, domain=None, range=Optional[Union[str, List[str]]])

slots.target__target_path = Slot(uri=DEFAULT_.target_path, name="target__target_path", curie=DEFAULT_.curie('target_path'),
                   model_uri=DEFAULT_.target__target_path, domain=None, range=Optional[str])

slots.ensmallenRunConfig__node_type_path = Slot(uri=DEFAULT_.node_type_path, name="ensmallenRunConfig__node_type_path", curie=DEFAULT_.curie('node_type_path'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_type_path, domain=None, range=Optional[str])

slots.ensmallenRunConfig__node_type_list_separator = Slot(uri=DEFAULT_.node_type_list_separator, name="ensmallenRunConfig__node_type_list_separator", curie=DEFAULT_.curie('node_type_list_separator'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_type_list_separator, domain=None, range=Optional[str])

slots.ensmallenRunConfig__node_types_column_number = Slot(uri=DEFAULT_.node_types_column_number, name="ensmallenRunConfig__node_types_column_number", curie=DEFAULT_.curie('node_types_column_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_types_column_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__node_types_column = Slot(uri=DEFAULT_.node_types_column, name="ensmallenRunConfig__node_types_column", curie=DEFAULT_.curie('node_types_column'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_types_column, domain=None, range=Optional[str])

slots.ensmallenRunConfig__node_types_ids_column_number = Slot(uri=DEFAULT_.node_types_ids_column_number, name="ensmallenRunConfig__node_types_ids_column_number", curie=DEFAULT_.curie('node_types_ids_column_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_types_ids_column_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__node_types_ids_column = Slot(uri=DEFAULT_.node_types_ids_column, name="ensmallenRunConfig__node_types_ids_column", curie=DEFAULT_.curie('node_types_ids_column'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_types_ids_column, domain=None, range=Optional[str])

slots.ensmallenRunConfig__node_types_number = Slot(uri=DEFAULT_.node_types_number, name="ensmallenRunConfig__node_types_number", curie=DEFAULT_.curie('node_types_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_types_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__numeric_node_type_ids = Slot(uri=DEFAULT_.numeric_node_type_ids, name="ensmallenRunConfig__numeric_node_type_ids", curie=DEFAULT_.curie('numeric_node_type_ids'),
                   model_uri=DEFAULT_.ensmallenRunConfig__numeric_node_type_ids, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__minimum_node_type_id = Slot(uri=DEFAULT_.minimum_node_type_id, name="ensmallenRunConfig__minimum_node_type_id", curie=DEFAULT_.curie('minimum_node_type_id'),
                   model_uri=DEFAULT_.ensmallenRunConfig__minimum_node_type_id, domain=None, range=Optional[int])

slots.ensmallenRunConfig__node_type_list_header = Slot(uri=DEFAULT_.node_type_list_header, name="ensmallenRunConfig__node_type_list_header", curie=DEFAULT_.curie('node_type_list_header'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_type_list_header, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__node_type_list_support_balanced_quotes = Slot(uri=DEFAULT_.node_type_list_support_balanced_quotes, name="ensmallenRunConfig__node_type_list_support_balanced_quotes", curie=DEFAULT_.curie('node_type_list_support_balanced_quotes'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_type_list_support_balanced_quotes, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__node_type_list_rows_to_skip = Slot(uri=DEFAULT_.node_type_list_rows_to_skip, name="ensmallenRunConfig__node_type_list_rows_to_skip", curie=DEFAULT_.curie('node_type_list_rows_to_skip'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_type_list_rows_to_skip, domain=None, range=Optional[int])

slots.ensmallenRunConfig__node_type_list_is_correct = Slot(uri=DEFAULT_.node_type_list_is_correct, name="ensmallenRunConfig__node_type_list_is_correct", curie=DEFAULT_.curie('node_type_list_is_correct'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_type_list_is_correct, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__node_type_list_max_rows_number = Slot(uri=DEFAULT_.node_type_list_max_rows_number, name="ensmallenRunConfig__node_type_list_max_rows_number", curie=DEFAULT_.curie('node_type_list_max_rows_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_type_list_max_rows_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__node_type_list_comment_symbol = Slot(uri=DEFAULT_.node_type_list_comment_symbol, name="ensmallenRunConfig__node_type_list_comment_symbol", curie=DEFAULT_.curie('node_type_list_comment_symbol'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_type_list_comment_symbol, domain=None, range=Optional[str])

slots.ensmallenRunConfig__load_node_type_list_in_parallel = Slot(uri=DEFAULT_.load_node_type_list_in_parallel, name="ensmallenRunConfig__load_node_type_list_in_parallel", curie=DEFAULT_.curie('load_node_type_list_in_parallel'),
                   model_uri=DEFAULT_.ensmallenRunConfig__load_node_type_list_in_parallel, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__node_path = Slot(uri=DEFAULT_.node_path, name="ensmallenRunConfig__node_path", curie=DEFAULT_.curie('node_path'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_path, domain=None, range=Optional[str])

slots.ensmallenRunConfig__node_list_separator = Slot(uri=DEFAULT_.node_list_separator, name="ensmallenRunConfig__node_list_separator", curie=DEFAULT_.curie('node_list_separator'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_list_separator, domain=None, range=Optional[str])

slots.ensmallenRunConfig__node_list_header = Slot(uri=DEFAULT_.node_list_header, name="ensmallenRunConfig__node_list_header", curie=DEFAULT_.curie('node_list_header'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_list_header, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__node_list_support_balanced_quotes = Slot(uri=DEFAULT_.node_list_support_balanced_quotes, name="ensmallenRunConfig__node_list_support_balanced_quotes", curie=DEFAULT_.curie('node_list_support_balanced_quotes'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_list_support_balanced_quotes, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__node_list_rows_to_skip = Slot(uri=DEFAULT_.node_list_rows_to_skip, name="ensmallenRunConfig__node_list_rows_to_skip", curie=DEFAULT_.curie('node_list_rows_to_skip'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_list_rows_to_skip, domain=None, range=Optional[int])

slots.ensmallenRunConfig__node_list_is_correct = Slot(uri=DEFAULT_.node_list_is_correct, name="ensmallenRunConfig__node_list_is_correct", curie=DEFAULT_.curie('node_list_is_correct'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_list_is_correct, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__node_list_max_rows_number = Slot(uri=DEFAULT_.node_list_max_rows_number, name="ensmallenRunConfig__node_list_max_rows_number", curie=DEFAULT_.curie('node_list_max_rows_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_list_max_rows_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__node_list_comment_symbol = Slot(uri=DEFAULT_.node_list_comment_symbol, name="ensmallenRunConfig__node_list_comment_symbol", curie=DEFAULT_.curie('node_list_comment_symbol'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_list_comment_symbol, domain=None, range=Optional[str])

slots.ensmallenRunConfig__default_node_type = Slot(uri=DEFAULT_.default_node_type, name="ensmallenRunConfig__default_node_type", curie=DEFAULT_.curie('default_node_type'),
                   model_uri=DEFAULT_.ensmallenRunConfig__default_node_type, domain=None, range=Optional[str])

slots.ensmallenRunConfig__nodes_column_number = Slot(uri=DEFAULT_.nodes_column_number, name="ensmallenRunConfig__nodes_column_number", curie=DEFAULT_.curie('nodes_column_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__nodes_column_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__nodes_column = Slot(uri=DEFAULT_.nodes_column, name="ensmallenRunConfig__nodes_column", curie=DEFAULT_.curie('nodes_column'),
                   model_uri=DEFAULT_.ensmallenRunConfig__nodes_column, domain=None, range=Optional[str])

slots.ensmallenRunConfig__node_types_separator = Slot(uri=DEFAULT_.node_types_separator, name="ensmallenRunConfig__node_types_separator", curie=DEFAULT_.curie('node_types_separator'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_types_separator, domain=None, range=Optional[str])

slots.ensmallenRunConfig__node_list_node_types_column_number = Slot(uri=DEFAULT_.node_list_node_types_column_number, name="ensmallenRunConfig__node_list_node_types_column_number", curie=DEFAULT_.curie('node_list_node_types_column_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_list_node_types_column_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__node_list_node_types_column = Slot(uri=DEFAULT_.node_list_node_types_column, name="ensmallenRunConfig__node_list_node_types_column", curie=DEFAULT_.curie('node_list_node_types_column'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_list_node_types_column, domain=None, range=Optional[str])

slots.ensmallenRunConfig__node_ids_column = Slot(uri=DEFAULT_.node_ids_column, name="ensmallenRunConfig__node_ids_column", curie=DEFAULT_.curie('node_ids_column'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_ids_column, domain=None, range=Optional[str])

slots.ensmallenRunConfig__node_ids_column_number = Slot(uri=DEFAULT_.node_ids_column_number, name="ensmallenRunConfig__node_ids_column_number", curie=DEFAULT_.curie('node_ids_column_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_ids_column_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__nodes_number = Slot(uri=DEFAULT_.nodes_number, name="ensmallenRunConfig__nodes_number", curie=DEFAULT_.curie('nodes_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__nodes_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__minimum_node_id = Slot(uri=DEFAULT_.minimum_node_id, name="ensmallenRunConfig__minimum_node_id", curie=DEFAULT_.curie('minimum_node_id'),
                   model_uri=DEFAULT_.ensmallenRunConfig__minimum_node_id, domain=None, range=Optional[int])

slots.ensmallenRunConfig__numeric_node_ids = Slot(uri=DEFAULT_.numeric_node_ids, name="ensmallenRunConfig__numeric_node_ids", curie=DEFAULT_.curie('numeric_node_ids'),
                   model_uri=DEFAULT_.ensmallenRunConfig__numeric_node_ids, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__node_list_numeric_node_type_ids = Slot(uri=DEFAULT_.node_list_numeric_node_type_ids, name="ensmallenRunConfig__node_list_numeric_node_type_ids", curie=DEFAULT_.curie('node_list_numeric_node_type_ids'),
                   model_uri=DEFAULT_.ensmallenRunConfig__node_list_numeric_node_type_ids, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__skip_node_types_if_unavailable = Slot(uri=DEFAULT_.skip_node_types_if_unavailable, name="ensmallenRunConfig__skip_node_types_if_unavailable", curie=DEFAULT_.curie('skip_node_types_if_unavailable'),
                   model_uri=DEFAULT_.ensmallenRunConfig__skip_node_types_if_unavailable, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__load_node_list_in_parallel = Slot(uri=DEFAULT_.load_node_list_in_parallel, name="ensmallenRunConfig__load_node_list_in_parallel", curie=DEFAULT_.curie('load_node_list_in_parallel'),
                   model_uri=DEFAULT_.ensmallenRunConfig__load_node_list_in_parallel, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__edge_type_path = Slot(uri=DEFAULT_.edge_type_path, name="ensmallenRunConfig__edge_type_path", curie=DEFAULT_.curie('edge_type_path'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_type_path, domain=None, range=Optional[str])

slots.ensmallenRunConfig__edge_types_column_number = Slot(uri=DEFAULT_.edge_types_column_number, name="ensmallenRunConfig__edge_types_column_number", curie=DEFAULT_.curie('edge_types_column_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_types_column_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__edge_types_column = Slot(uri=DEFAULT_.edge_types_column, name="ensmallenRunConfig__edge_types_column", curie=DEFAULT_.curie('edge_types_column'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_types_column, domain=None, range=Optional[str])

slots.ensmallenRunConfig__edge_types_number = Slot(uri=DEFAULT_.edge_types_number, name="ensmallenRunConfig__edge_types_number", curie=DEFAULT_.curie('edge_types_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_types_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__numeric_edge_type_ids = Slot(uri=DEFAULT_.numeric_edge_type_ids, name="ensmallenRunConfig__numeric_edge_type_ids", curie=DEFAULT_.curie('numeric_edge_type_ids'),
                   model_uri=DEFAULT_.ensmallenRunConfig__numeric_edge_type_ids, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__minimum_edge_type_id = Slot(uri=DEFAULT_.minimum_edge_type_id, name="ensmallenRunConfig__minimum_edge_type_id", curie=DEFAULT_.curie('minimum_edge_type_id'),
                   model_uri=DEFAULT_.ensmallenRunConfig__minimum_edge_type_id, domain=None, range=Optional[int])

slots.ensmallenRunConfig__edge_type_list_separator = Slot(uri=DEFAULT_.edge_type_list_separator, name="ensmallenRunConfig__edge_type_list_separator", curie=DEFAULT_.curie('edge_type_list_separator'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_type_list_separator, domain=None, range=Optional[str])

slots.ensmallenRunConfig__edge_type_list_header = Slot(uri=DEFAULT_.edge_type_list_header, name="ensmallenRunConfig__edge_type_list_header", curie=DEFAULT_.curie('edge_type_list_header'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_type_list_header, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__edge_type_list_support_balanced_quotes = Slot(uri=DEFAULT_.edge_type_list_support_balanced_quotes, name="ensmallenRunConfig__edge_type_list_support_balanced_quotes", curie=DEFAULT_.curie('edge_type_list_support_balanced_quotes'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_type_list_support_balanced_quotes, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__edge_type_list_rows_to_skip = Slot(uri=DEFAULT_.edge_type_list_rows_to_skip, name="ensmallenRunConfig__edge_type_list_rows_to_skip", curie=DEFAULT_.curie('edge_type_list_rows_to_skip'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_type_list_rows_to_skip, domain=None, range=Optional[int])

slots.ensmallenRunConfig__edge_type_list_is_correct = Slot(uri=DEFAULT_.edge_type_list_is_correct, name="ensmallenRunConfig__edge_type_list_is_correct", curie=DEFAULT_.curie('edge_type_list_is_correct'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_type_list_is_correct, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__edge_type_list_max_rows_number = Slot(uri=DEFAULT_.edge_type_list_max_rows_number, name="ensmallenRunConfig__edge_type_list_max_rows_number", curie=DEFAULT_.curie('edge_type_list_max_rows_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_type_list_max_rows_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__edge_type_list_comment_symbol = Slot(uri=DEFAULT_.edge_type_list_comment_symbol, name="ensmallenRunConfig__edge_type_list_comment_symbol", curie=DEFAULT_.curie('edge_type_list_comment_symbol'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_type_list_comment_symbol, domain=None, range=Optional[str])

slots.ensmallenRunConfig__load_edge_type_list_in_parallel = Slot(uri=DEFAULT_.load_edge_type_list_in_parallel, name="ensmallenRunConfig__load_edge_type_list_in_parallel", curie=DEFAULT_.curie('load_edge_type_list_in_parallel'),
                   model_uri=DEFAULT_.ensmallenRunConfig__load_edge_type_list_in_parallel, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__edge_path = Slot(uri=DEFAULT_.edge_path, name="ensmallenRunConfig__edge_path", curie=DEFAULT_.curie('edge_path'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_path, domain=None, range=Optional[str])

slots.ensmallenRunConfig__edge_list_separator = Slot(uri=DEFAULT_.edge_list_separator, name="ensmallenRunConfig__edge_list_separator", curie=DEFAULT_.curie('edge_list_separator'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_list_separator, domain=None, range=Optional[str])

slots.ensmallenRunConfig__edge_list_header = Slot(uri=DEFAULT_.edge_list_header, name="ensmallenRunConfig__edge_list_header", curie=DEFAULT_.curie('edge_list_header'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_list_header, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__edge_list_support_balanced_quotes = Slot(uri=DEFAULT_.edge_list_support_balanced_quotes, name="ensmallenRunConfig__edge_list_support_balanced_quotes", curie=DEFAULT_.curie('edge_list_support_balanced_quotes'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_list_support_balanced_quotes, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__edge_list_rows_to_skip = Slot(uri=DEFAULT_.edge_list_rows_to_skip, name="ensmallenRunConfig__edge_list_rows_to_skip", curie=DEFAULT_.curie('edge_list_rows_to_skip'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_list_rows_to_skip, domain=None, range=Optional[int])

slots.ensmallenRunConfig__sources_column_number = Slot(uri=DEFAULT_.sources_column_number, name="ensmallenRunConfig__sources_column_number", curie=DEFAULT_.curie('sources_column_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__sources_column_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__sources_column = Slot(uri=DEFAULT_.sources_column, name="ensmallenRunConfig__sources_column", curie=DEFAULT_.curie('sources_column'),
                   model_uri=DEFAULT_.ensmallenRunConfig__sources_column, domain=None, range=Optional[str])

slots.ensmallenRunConfig__destinations_column_number = Slot(uri=DEFAULT_.destinations_column_number, name="ensmallenRunConfig__destinations_column_number", curie=DEFAULT_.curie('destinations_column_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__destinations_column_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__destinations_column = Slot(uri=DEFAULT_.destinations_column, name="ensmallenRunConfig__destinations_column", curie=DEFAULT_.curie('destinations_column'),
                   model_uri=DEFAULT_.ensmallenRunConfig__destinations_column, domain=None, range=Optional[str])

slots.ensmallenRunConfig__edge_list_edge_types_column_number = Slot(uri=DEFAULT_.edge_list_edge_types_column_number, name="ensmallenRunConfig__edge_list_edge_types_column_number", curie=DEFAULT_.curie('edge_list_edge_types_column_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_list_edge_types_column_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__edge_list_edge_types_column = Slot(uri=DEFAULT_.edge_list_edge_types_column, name="ensmallenRunConfig__edge_list_edge_types_column", curie=DEFAULT_.curie('edge_list_edge_types_column'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_list_edge_types_column, domain=None, range=Optional[str])

slots.ensmallenRunConfig__default_edge_type = Slot(uri=DEFAULT_.default_edge_type, name="ensmallenRunConfig__default_edge_type", curie=DEFAULT_.curie('default_edge_type'),
                   model_uri=DEFAULT_.ensmallenRunConfig__default_edge_type, domain=None, range=Optional[str])

slots.ensmallenRunConfig__weights_column_number = Slot(uri=DEFAULT_.weights_column_number, name="ensmallenRunConfig__weights_column_number", curie=DEFAULT_.curie('weights_column_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__weights_column_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__weights_column = Slot(uri=DEFAULT_.weights_column, name="ensmallenRunConfig__weights_column", curie=DEFAULT_.curie('weights_column'),
                   model_uri=DEFAULT_.ensmallenRunConfig__weights_column, domain=None, range=Optional[str])

slots.ensmallenRunConfig__default_weight = Slot(uri=DEFAULT_.default_weight, name="ensmallenRunConfig__default_weight", curie=DEFAULT_.curie('default_weight'),
                   model_uri=DEFAULT_.ensmallenRunConfig__default_weight, domain=None, range=Optional[float])

slots.ensmallenRunConfig__edge_ids_column = Slot(uri=DEFAULT_.edge_ids_column, name="ensmallenRunConfig__edge_ids_column", curie=DEFAULT_.curie('edge_ids_column'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_ids_column, domain=None, range=Optional[str])

slots.ensmallenRunConfig__edge_ids_column_number = Slot(uri=DEFAULT_.edge_ids_column_number, name="ensmallenRunConfig__edge_ids_column_number", curie=DEFAULT_.curie('edge_ids_column_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_ids_column_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__edge_list_numeric_edge_type_ids = Slot(uri=DEFAULT_.edge_list_numeric_edge_type_ids, name="ensmallenRunConfig__edge_list_numeric_edge_type_ids", curie=DEFAULT_.curie('edge_list_numeric_edge_type_ids'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_list_numeric_edge_type_ids, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__edge_list_numeric_node_ids = Slot(uri=DEFAULT_.edge_list_numeric_node_ids, name="ensmallenRunConfig__edge_list_numeric_node_ids", curie=DEFAULT_.curie('edge_list_numeric_node_ids'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_list_numeric_node_ids, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__skip_weights_if_unavailable = Slot(uri=DEFAULT_.skip_weights_if_unavailable, name="ensmallenRunConfig__skip_weights_if_unavailable", curie=DEFAULT_.curie('skip_weights_if_unavailable'),
                   model_uri=DEFAULT_.ensmallenRunConfig__skip_weights_if_unavailable, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__skip_edge_types_if_unavailable = Slot(uri=DEFAULT_.skip_edge_types_if_unavailable, name="ensmallenRunConfig__skip_edge_types_if_unavailable", curie=DEFAULT_.curie('skip_edge_types_if_unavailable'),
                   model_uri=DEFAULT_.ensmallenRunConfig__skip_edge_types_if_unavailable, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__edge_list_is_complete = Slot(uri=DEFAULT_.edge_list_is_complete, name="ensmallenRunConfig__edge_list_is_complete", curie=DEFAULT_.curie('edge_list_is_complete'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_list_is_complete, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__edge_list_may_contain_duplicates = Slot(uri=DEFAULT_.edge_list_may_contain_duplicates, name="ensmallenRunConfig__edge_list_may_contain_duplicates", curie=DEFAULT_.curie('edge_list_may_contain_duplicates'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_list_may_contain_duplicates, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__edge_list_is_sorted = Slot(uri=DEFAULT_.edge_list_is_sorted, name="ensmallenRunConfig__edge_list_is_sorted", curie=DEFAULT_.curie('edge_list_is_sorted'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_list_is_sorted, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__edge_list_is_correct = Slot(uri=DEFAULT_.edge_list_is_correct, name="ensmallenRunConfig__edge_list_is_correct", curie=DEFAULT_.curie('edge_list_is_correct'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_list_is_correct, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__edge_list_max_rows_number = Slot(uri=DEFAULT_.edge_list_max_rows_number, name="ensmallenRunConfig__edge_list_max_rows_number", curie=DEFAULT_.curie('edge_list_max_rows_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_list_max_rows_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__edge_list_comment_symbol = Slot(uri=DEFAULT_.edge_list_comment_symbol, name="ensmallenRunConfig__edge_list_comment_symbol", curie=DEFAULT_.curie('edge_list_comment_symbol'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edge_list_comment_symbol, domain=None, range=Optional[str])

slots.ensmallenRunConfig__edges_number = Slot(uri=DEFAULT_.edges_number, name="ensmallenRunConfig__edges_number", curie=DEFAULT_.curie('edges_number'),
                   model_uri=DEFAULT_.ensmallenRunConfig__edges_number, domain=None, range=Optional[int])

slots.ensmallenRunConfig__load_edge_list_in_parallel = Slot(uri=DEFAULT_.load_edge_list_in_parallel, name="ensmallenRunConfig__load_edge_list_in_parallel", curie=DEFAULT_.curie('load_edge_list_in_parallel'),
                   model_uri=DEFAULT_.ensmallenRunConfig__load_edge_list_in_parallel, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__verbose = Slot(uri=DEFAULT_.verbose, name="ensmallenRunConfig__verbose", curie=DEFAULT_.curie('verbose'),
                   model_uri=DEFAULT_.ensmallenRunConfig__verbose, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__may_have_singletons = Slot(uri=DEFAULT_.may_have_singletons, name="ensmallenRunConfig__may_have_singletons", curie=DEFAULT_.curie('may_have_singletons'),
                   model_uri=DEFAULT_.ensmallenRunConfig__may_have_singletons, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__may_have_singleton_with_selfloops = Slot(uri=DEFAULT_.may_have_singleton_with_selfloops, name="ensmallenRunConfig__may_have_singleton_with_selfloops", curie=DEFAULT_.curie('may_have_singleton_with_selfloops'),
                   model_uri=DEFAULT_.ensmallenRunConfig__may_have_singleton_with_selfloops, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__directed = Slot(uri=DEFAULT_.directed, name="ensmallenRunConfig__directed", curie=DEFAULT_.curie('directed'),
                   model_uri=DEFAULT_.ensmallenRunConfig__directed, domain=None, range=Optional[Union[bool, Bool]])

slots.ensmallenRunConfig__name = Slot(uri=DEFAULT_.name, name="ensmallenRunConfig__name", curie=DEFAULT_.curie('name'),
                   model_uri=DEFAULT_.ensmallenRunConfig__name, domain=None, range=Optional[str])