# coding: utf-8

"""
    node-server

    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)  # noqa: E501

    The version of the OpenAPI document: 0.0.237
    Generated by: https://openapi-generator.tech
"""

from datetime import date, datetime  # noqa: F401
import decimal  # noqa: F401
import functools  # noqa: F401
import io  # noqa: F401
import re  # noqa: F401
import typing  # noqa: F401
import typing_extensions  # noqa: F401
import uuid  # noqa: F401

import frozendict  # noqa: F401

from openapi_client import schemas  # noqa: F401


class NodeType(
    schemas.EnumBase,
    schemas.StrSchema
):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """


    class MetaOapg:
        enum_value_to_name = {
            "Activation": "ACTIVATION",
            "ActivityRegularization": "ACTIVITY_REGULARIZATION",
            "Add": "ADD",
            "AdditiveAttention": "ADDITIVE_ATTENTION",
            "AlphaDropout": "ALPHA_DROPOUT",
            "Average": "AVERAGE",
            "AveragePooling1D": "AVERAGE_POOLING1D",
            "AveragePooling2D": "AVERAGE_POOLING2D",
            "AveragePooling3D": "AVERAGE_POOLING3D",
            "BatchNormalization": "BATCH_NORMALIZATION",
            "Bidirectional": "BIDIRECTIONAL",
            "CategoryEncoding": "CATEGORY_ENCODING",
            "CenterCrop": "CENTER_CROP",
            "Concatenate": "CONCATENATE",
            "Conv1D": "CONV1D",
            "Conv1DTranspose": "CONV1DTRANSPOSE",
            "Conv2D": "CONV2D",
            "Conv2DTranspose": "CONV2DTRANSPOSE",
            "Conv3D": "CONV3D",
            "Conv3DTranspose": "CONV3DTRANSPOSE",
            "ConvLSTM1D": "CONV_LSTM1D",
            "ConvLSTM2D": "CONV_LSTM2D",
            "ConvLSTM3D": "CONV_LSTM3D",
            "Cropping1D": "CROPPING1D",
            "Cropping2D": "CROPPING2D",
            "Cropping3D": "CROPPING3D",
            "CuDNNGRU": "CU_DNNGRU",
            "CuDNNLSTM": "CU_DNNLSTM",
            "Dense": "DENSE",
            "DepthwiseConv1D": "DEPTHWISE_CONV1D",
            "DepthwiseConv2D": "DEPTHWISE_CONV2D",
            "Discretization": "DISCRETIZATION",
            "Dot": "DOT",
            "Dropout": "DROPOUT",
            "ELU": "ELU",
            "Embedding": "EMBEDDING",
            "Flatten": "FLATTEN",
            "GRU": "GRU",
            "GRUCell": "GRUCELL",
            "GRUCellV1": "GRUCELL_V1",
            "GRUCellV2": "GRUCELL_V2",
            "GRUV1": "GRUV1",
            "GRUV2": "GRUV2",
            "GaussianDropout": "GAUSSIAN_DROPOUT",
            "GaussianNoise": "GAUSSIAN_NOISE",
            "GlobalAveragePooling1D": "GLOBAL_AVERAGE_POOLING1D",
            "GlobalAveragePooling2D": "GLOBAL_AVERAGE_POOLING2D",
            "GlobalAveragePooling3D": "GLOBAL_AVERAGE_POOLING3D",
            "GlobalMaxPooling1D": "GLOBAL_MAX_POOLING1D",
            "GlobalMaxPooling2D": "GLOBAL_MAX_POOLING2D",
            "GlobalMaxPooling3D": "GLOBAL_MAX_POOLING3D",
            "GroupNormalization": "GROUP_NORMALIZATION",
            "IntegerLookup": "INTEGER_LOOKUP",
            "LSTM": "LSTM",
            "LSTMCell": "LSTMCELL",
            "LSTMCellV1": "LSTMCELL_V1",
            "LSTMCellV2": "LSTMCELL_V2",
            "LSTMV1": "LSTMV1",
            "LSTMV2": "LSTMV2",
            "LayerNormalization": "LAYER_NORMALIZATION",
            "LeakyReLU": "LEAKY_RE_LU",
            "LocallyConnected1D": "LOCALLY_CONNECTED1D",
            "LocallyConnected2D": "LOCALLY_CONNECTED2D",
            "Masking": "MASKING",
            "MaxPooling1D": "MAX_POOLING1D",
            "MaxPooling2D": "MAX_POOLING2D",
            "MaxPooling3D": "MAX_POOLING3D",
            "Maximum": "MAXIMUM",
            "Minimum": "MINIMUM",
            "MultiHeadAttention": "MULTI_HEAD_ATTENTION",
            "Multiply": "MULTIPLY",
            "Normalization": "NORMALIZATION",
            "PReLU": "PRE_LU",
            "Permute": "PERMUTE",
            "RandomBrightness": "RANDOM_BRIGHTNESS",
            "RandomContrast": "RANDOM_CONTRAST",
            "RandomCrop": "RANDOM_CROP",
            "RandomFlip": "RANDOM_FLIP",
            "RandomFourierFeatures": "RANDOM_FOURIER_FEATURES",
            "RandomHeight": "RANDOM_HEIGHT",
            "RandomRotation": "RANDOM_ROTATION",
            "RandomTranslation": "RANDOM_TRANSLATION",
            "RandomWidth": "RANDOM_WIDTH",
            "RandomZoom": "RANDOM_ZOOM",
            "ReLU": "RE_LU",
            "RepeatVector": "REPEAT_VECTOR",
            "Reshape": "RESHAPE",
            "Resizing": "RESIZING",
            "SeparableConv1D": "SEPARABLE_CONV1D",
            "SeparableConv2D": "SEPARABLE_CONV2D",
            "SimpleRNN": "SIMPLE_RNN",
            "SimpleRNNCell": "SIMPLE_RNNCELL",
            "Softmax": "SOFTMAX",
            "SpatialDropout1D": "SPATIAL_DROPOUT1D",
            "SpatialDropout2D": "SPATIAL_DROPOUT2D",
            "SpatialDropout3D": "SPATIAL_DROPOUT3D",
            "StringLookup": "STRING_LOOKUP",
            "Subtract": "SUBTRACT",
            "SyncBatchNormalization": "SYNC_BATCH_NORMALIZATION",
            "TextVectorization": "TEXT_VECTORIZATION",
            "ThresholdedReLU": "THRESHOLDED_RE_LU",
            "TimeDistributed": "TIME_DISTRIBUTED",
            "UnitNormalization": "UNIT_NORMALIZATION",
            "UpSampling1D": "UP_SAMPLING1D",
            "UpSampling2D": "UP_SAMPLING2D",
            "UpSampling3D": "UP_SAMPLING3D",
            "ZeroPadding1D": "ZERO_PADDING1D",
            "ZeroPadding2D": "ZERO_PADDING2D",
            "ZeroPadding3D": "ZERO_PADDING3D",
            "BinaryCrossentropy": "BINARY_CROSSENTROPY",
            "BinaryFocalCrossentropy": "BINARY_FOCAL_CROSSENTROPY",
            "CategoricalCrossentropy": "CATEGORICAL_CROSSENTROPY",
            "CategoricalHinge": "CATEGORICAL_HINGE",
            "CosineSimilarity": "COSINE_SIMILARITY",
            "Hinge": "HINGE",
            "Huber": "HUBER",
            "KLDivergence": "KLDIVERGENCE",
            "LogCosh": "LOG_COSH",
            "MeanAbsoluteError": "MEAN_ABSOLUTE_ERROR",
            "MeanAbsolutePercentageError": "MEAN_ABSOLUTE_PERCENTAGE_ERROR",
            "MeanSquaredError": "MEAN_SQUARED_ERROR",
            "MeanSquaredLogarithmicError": "MEAN_SQUARED_LOGARITHMIC_ERROR",
            "Poisson": "POISSON",
            "SquaredHinge": "SQUARED_HINGE",
            "Adadelta": "ADADELTA",
            "Adagrad": "ADAGRAD",
            "Adam": "ADAM",
            "Adamax": "ADAMAX",
            "Ftrl": "FTRL",
            "Nadam": "NADAM",
            "RMSprop": "RMSPROP",
            "SGD": "SGD",
            "OnnxAbs": "ONNX_ABS",
            "OnnxErf": "ONNX_ERF",
            "OnnxHardSigmoid": "ONNX_HARD_SIGMOID",
            "OnnxReduceMean": "ONNX_REDUCE_MEAN",
            "OnnxSqrt": "ONNX_SQRT",
            "Dataset": "DATASET",
            "RepresentationBlock": "REPRESENTATION_BLOCK",
            "GroundTruth": "GROUND_TRUTH",
            "CustomLayer": "CUSTOM_LAYER",
            "CustomLoss": "CUSTOM_LOSS",
            "Visualizer": "VISUALIZER",
            "Lambda": "LAMBDA",
            "TFOpLambda": "TFOP_LAMBDA",
            "SlicingOpLambda": "SLICING_OP_LAMBDA",
            "Repeat": "REPEAT",
            "Variable": "VARIABLE",
            "Gather": "GATHER",
            "FixedDropout": "FIXED_DROPOUT",
        }
    
    @schemas.classproperty
    def ACTIVATION(cls):
        return cls("Activation")
    
    @schemas.classproperty
    def ACTIVITY_REGULARIZATION(cls):
        return cls("ActivityRegularization")
    
    @schemas.classproperty
    def ADD(cls):
        return cls("Add")
    
    @schemas.classproperty
    def ADDITIVE_ATTENTION(cls):
        return cls("AdditiveAttention")
    
    @schemas.classproperty
    def ALPHA_DROPOUT(cls):
        return cls("AlphaDropout")
    
    @schemas.classproperty
    def AVERAGE(cls):
        return cls("Average")
    
    @schemas.classproperty
    def AVERAGE_POOLING1D(cls):
        return cls("AveragePooling1D")
    
    @schemas.classproperty
    def AVERAGE_POOLING2D(cls):
        return cls("AveragePooling2D")
    
    @schemas.classproperty
    def AVERAGE_POOLING3D(cls):
        return cls("AveragePooling3D")
    
    @schemas.classproperty
    def BATCH_NORMALIZATION(cls):
        return cls("BatchNormalization")
    
    @schemas.classproperty
    def BIDIRECTIONAL(cls):
        return cls("Bidirectional")
    
    @schemas.classproperty
    def CATEGORY_ENCODING(cls):
        return cls("CategoryEncoding")
    
    @schemas.classproperty
    def CENTER_CROP(cls):
        return cls("CenterCrop")
    
    @schemas.classproperty
    def CONCATENATE(cls):
        return cls("Concatenate")
    
    @schemas.classproperty
    def CONV1D(cls):
        return cls("Conv1D")
    
    @schemas.classproperty
    def CONV1DTRANSPOSE(cls):
        return cls("Conv1DTranspose")
    
    @schemas.classproperty
    def CONV2D(cls):
        return cls("Conv2D")
    
    @schemas.classproperty
    def CONV2DTRANSPOSE(cls):
        return cls("Conv2DTranspose")
    
    @schemas.classproperty
    def CONV3D(cls):
        return cls("Conv3D")
    
    @schemas.classproperty
    def CONV3DTRANSPOSE(cls):
        return cls("Conv3DTranspose")
    
    @schemas.classproperty
    def CONV_LSTM1D(cls):
        return cls("ConvLSTM1D")
    
    @schemas.classproperty
    def CONV_LSTM2D(cls):
        return cls("ConvLSTM2D")
    
    @schemas.classproperty
    def CONV_LSTM3D(cls):
        return cls("ConvLSTM3D")
    
    @schemas.classproperty
    def CROPPING1D(cls):
        return cls("Cropping1D")
    
    @schemas.classproperty
    def CROPPING2D(cls):
        return cls("Cropping2D")
    
    @schemas.classproperty
    def CROPPING3D(cls):
        return cls("Cropping3D")
    
    @schemas.classproperty
    def CU_DNNGRU(cls):
        return cls("CuDNNGRU")
    
    @schemas.classproperty
    def CU_DNNLSTM(cls):
        return cls("CuDNNLSTM")
    
    @schemas.classproperty
    def DENSE(cls):
        return cls("Dense")
    
    @schemas.classproperty
    def DEPTHWISE_CONV1D(cls):
        return cls("DepthwiseConv1D")
    
    @schemas.classproperty
    def DEPTHWISE_CONV2D(cls):
        return cls("DepthwiseConv2D")
    
    @schemas.classproperty
    def DISCRETIZATION(cls):
        return cls("Discretization")
    
    @schemas.classproperty
    def DOT(cls):
        return cls("Dot")
    
    @schemas.classproperty
    def DROPOUT(cls):
        return cls("Dropout")
    
    @schemas.classproperty
    def ELU(cls):
        return cls("ELU")
    
    @schemas.classproperty
    def EMBEDDING(cls):
        return cls("Embedding")
    
    @schemas.classproperty
    def FLATTEN(cls):
        return cls("Flatten")
    
    @schemas.classproperty
    def GRU(cls):
        return cls("GRU")
    
    @schemas.classproperty
    def GRUCELL(cls):
        return cls("GRUCell")
    
    @schemas.classproperty
    def GRUCELL_V1(cls):
        return cls("GRUCellV1")
    
    @schemas.classproperty
    def GRUCELL_V2(cls):
        return cls("GRUCellV2")
    
    @schemas.classproperty
    def GRUV1(cls):
        return cls("GRUV1")
    
    @schemas.classproperty
    def GRUV2(cls):
        return cls("GRUV2")
    
    @schemas.classproperty
    def GAUSSIAN_DROPOUT(cls):
        return cls("GaussianDropout")
    
    @schemas.classproperty
    def GAUSSIAN_NOISE(cls):
        return cls("GaussianNoise")
    
    @schemas.classproperty
    def GLOBAL_AVERAGE_POOLING1D(cls):
        return cls("GlobalAveragePooling1D")
    
    @schemas.classproperty
    def GLOBAL_AVERAGE_POOLING2D(cls):
        return cls("GlobalAveragePooling2D")
    
    @schemas.classproperty
    def GLOBAL_AVERAGE_POOLING3D(cls):
        return cls("GlobalAveragePooling3D")
    
    @schemas.classproperty
    def GLOBAL_MAX_POOLING1D(cls):
        return cls("GlobalMaxPooling1D")
    
    @schemas.classproperty
    def GLOBAL_MAX_POOLING2D(cls):
        return cls("GlobalMaxPooling2D")
    
    @schemas.classproperty
    def GLOBAL_MAX_POOLING3D(cls):
        return cls("GlobalMaxPooling3D")
    
    @schemas.classproperty
    def GROUP_NORMALIZATION(cls):
        return cls("GroupNormalization")
    
    @schemas.classproperty
    def INTEGER_LOOKUP(cls):
        return cls("IntegerLookup")
    
    @schemas.classproperty
    def LSTM(cls):
        return cls("LSTM")
    
    @schemas.classproperty
    def LSTMCELL(cls):
        return cls("LSTMCell")
    
    @schemas.classproperty
    def LSTMCELL_V1(cls):
        return cls("LSTMCellV1")
    
    @schemas.classproperty
    def LSTMCELL_V2(cls):
        return cls("LSTMCellV2")
    
    @schemas.classproperty
    def LSTMV1(cls):
        return cls("LSTMV1")
    
    @schemas.classproperty
    def LSTMV2(cls):
        return cls("LSTMV2")
    
    @schemas.classproperty
    def LAYER_NORMALIZATION(cls):
        return cls("LayerNormalization")
    
    @schemas.classproperty
    def LEAKY_RE_LU(cls):
        return cls("LeakyReLU")
    
    @schemas.classproperty
    def LOCALLY_CONNECTED1D(cls):
        return cls("LocallyConnected1D")
    
    @schemas.classproperty
    def LOCALLY_CONNECTED2D(cls):
        return cls("LocallyConnected2D")
    
    @schemas.classproperty
    def MASKING(cls):
        return cls("Masking")
    
    @schemas.classproperty
    def MAX_POOLING1D(cls):
        return cls("MaxPooling1D")
    
    @schemas.classproperty
    def MAX_POOLING2D(cls):
        return cls("MaxPooling2D")
    
    @schemas.classproperty
    def MAX_POOLING3D(cls):
        return cls("MaxPooling3D")
    
    @schemas.classproperty
    def MAXIMUM(cls):
        return cls("Maximum")
    
    @schemas.classproperty
    def MINIMUM(cls):
        return cls("Minimum")
    
    @schemas.classproperty
    def MULTI_HEAD_ATTENTION(cls):
        return cls("MultiHeadAttention")
    
    @schemas.classproperty
    def MULTIPLY(cls):
        return cls("Multiply")
    
    @schemas.classproperty
    def NORMALIZATION(cls):
        return cls("Normalization")
    
    @schemas.classproperty
    def PRE_LU(cls):
        return cls("PReLU")
    
    @schemas.classproperty
    def PERMUTE(cls):
        return cls("Permute")
    
    @schemas.classproperty
    def RANDOM_BRIGHTNESS(cls):
        return cls("RandomBrightness")
    
    @schemas.classproperty
    def RANDOM_CONTRAST(cls):
        return cls("RandomContrast")
    
    @schemas.classproperty
    def RANDOM_CROP(cls):
        return cls("RandomCrop")
    
    @schemas.classproperty
    def RANDOM_FLIP(cls):
        return cls("RandomFlip")
    
    @schemas.classproperty
    def RANDOM_FOURIER_FEATURES(cls):
        return cls("RandomFourierFeatures")
    
    @schemas.classproperty
    def RANDOM_HEIGHT(cls):
        return cls("RandomHeight")
    
    @schemas.classproperty
    def RANDOM_ROTATION(cls):
        return cls("RandomRotation")
    
    @schemas.classproperty
    def RANDOM_TRANSLATION(cls):
        return cls("RandomTranslation")
    
    @schemas.classproperty
    def RANDOM_WIDTH(cls):
        return cls("RandomWidth")
    
    @schemas.classproperty
    def RANDOM_ZOOM(cls):
        return cls("RandomZoom")
    
    @schemas.classproperty
    def RE_LU(cls):
        return cls("ReLU")
    
    @schemas.classproperty
    def REPEAT_VECTOR(cls):
        return cls("RepeatVector")
    
    @schemas.classproperty
    def RESHAPE(cls):
        return cls("Reshape")
    
    @schemas.classproperty
    def RESIZING(cls):
        return cls("Resizing")
    
    @schemas.classproperty
    def SEPARABLE_CONV1D(cls):
        return cls("SeparableConv1D")
    
    @schemas.classproperty
    def SEPARABLE_CONV2D(cls):
        return cls("SeparableConv2D")
    
    @schemas.classproperty
    def SIMPLE_RNN(cls):
        return cls("SimpleRNN")
    
    @schemas.classproperty
    def SIMPLE_RNNCELL(cls):
        return cls("SimpleRNNCell")
    
    @schemas.classproperty
    def SOFTMAX(cls):
        return cls("Softmax")
    
    @schemas.classproperty
    def SPATIAL_DROPOUT1D(cls):
        return cls("SpatialDropout1D")
    
    @schemas.classproperty
    def SPATIAL_DROPOUT2D(cls):
        return cls("SpatialDropout2D")
    
    @schemas.classproperty
    def SPATIAL_DROPOUT3D(cls):
        return cls("SpatialDropout3D")
    
    @schemas.classproperty
    def STRING_LOOKUP(cls):
        return cls("StringLookup")
    
    @schemas.classproperty
    def SUBTRACT(cls):
        return cls("Subtract")
    
    @schemas.classproperty
    def SYNC_BATCH_NORMALIZATION(cls):
        return cls("SyncBatchNormalization")
    
    @schemas.classproperty
    def TEXT_VECTORIZATION(cls):
        return cls("TextVectorization")
    
    @schemas.classproperty
    def THRESHOLDED_RE_LU(cls):
        return cls("ThresholdedReLU")
    
    @schemas.classproperty
    def TIME_DISTRIBUTED(cls):
        return cls("TimeDistributed")
    
    @schemas.classproperty
    def UNIT_NORMALIZATION(cls):
        return cls("UnitNormalization")
    
    @schemas.classproperty
    def UP_SAMPLING1D(cls):
        return cls("UpSampling1D")
    
    @schemas.classproperty
    def UP_SAMPLING2D(cls):
        return cls("UpSampling2D")
    
    @schemas.classproperty
    def UP_SAMPLING3D(cls):
        return cls("UpSampling3D")
    
    @schemas.classproperty
    def ZERO_PADDING1D(cls):
        return cls("ZeroPadding1D")
    
    @schemas.classproperty
    def ZERO_PADDING2D(cls):
        return cls("ZeroPadding2D")
    
    @schemas.classproperty
    def ZERO_PADDING3D(cls):
        return cls("ZeroPadding3D")
    
    @schemas.classproperty
    def BINARY_CROSSENTROPY(cls):
        return cls("BinaryCrossentropy")
    
    @schemas.classproperty
    def BINARY_FOCAL_CROSSENTROPY(cls):
        return cls("BinaryFocalCrossentropy")
    
    @schemas.classproperty
    def CATEGORICAL_CROSSENTROPY(cls):
        return cls("CategoricalCrossentropy")
    
    @schemas.classproperty
    def CATEGORICAL_HINGE(cls):
        return cls("CategoricalHinge")
    
    @schemas.classproperty
    def COSINE_SIMILARITY(cls):
        return cls("CosineSimilarity")
    
    @schemas.classproperty
    def HINGE(cls):
        return cls("Hinge")
    
    @schemas.classproperty
    def HUBER(cls):
        return cls("Huber")
    
    @schemas.classproperty
    def KLDIVERGENCE(cls):
        return cls("KLDivergence")
    
    @schemas.classproperty
    def LOG_COSH(cls):
        return cls("LogCosh")
    
    @schemas.classproperty
    def MEAN_ABSOLUTE_ERROR(cls):
        return cls("MeanAbsoluteError")
    
    @schemas.classproperty
    def MEAN_ABSOLUTE_PERCENTAGE_ERROR(cls):
        return cls("MeanAbsolutePercentageError")
    
    @schemas.classproperty
    def MEAN_SQUARED_ERROR(cls):
        return cls("MeanSquaredError")
    
    @schemas.classproperty
    def MEAN_SQUARED_LOGARITHMIC_ERROR(cls):
        return cls("MeanSquaredLogarithmicError")
    
    @schemas.classproperty
    def POISSON(cls):
        return cls("Poisson")
    
    @schemas.classproperty
    def SQUARED_HINGE(cls):
        return cls("SquaredHinge")
    
    @schemas.classproperty
    def ADADELTA(cls):
        return cls("Adadelta")
    
    @schemas.classproperty
    def ADAGRAD(cls):
        return cls("Adagrad")
    
    @schemas.classproperty
    def ADAM(cls):
        return cls("Adam")
    
    @schemas.classproperty
    def ADAMAX(cls):
        return cls("Adamax")
    
    @schemas.classproperty
    def FTRL(cls):
        return cls("Ftrl")
    
    @schemas.classproperty
    def NADAM(cls):
        return cls("Nadam")
    
    @schemas.classproperty
    def RMSPROP(cls):
        return cls("RMSprop")
    
    @schemas.classproperty
    def SGD(cls):
        return cls("SGD")
    
    @schemas.classproperty
    def ONNX_ABS(cls):
        return cls("OnnxAbs")
    
    @schemas.classproperty
    def ONNX_ERF(cls):
        return cls("OnnxErf")
    
    @schemas.classproperty
    def ONNX_HARD_SIGMOID(cls):
        return cls("OnnxHardSigmoid")
    
    @schemas.classproperty
    def ONNX_REDUCE_MEAN(cls):
        return cls("OnnxReduceMean")
    
    @schemas.classproperty
    def ONNX_SQRT(cls):
        return cls("OnnxSqrt")
    
    @schemas.classproperty
    def DATASET(cls):
        return cls("Dataset")
    
    @schemas.classproperty
    def REPRESENTATION_BLOCK(cls):
        return cls("RepresentationBlock")
    
    @schemas.classproperty
    def GROUND_TRUTH(cls):
        return cls("GroundTruth")
    
    @schemas.classproperty
    def CUSTOM_LAYER(cls):
        return cls("CustomLayer")
    
    @schemas.classproperty
    def CUSTOM_LOSS(cls):
        return cls("CustomLoss")
    
    @schemas.classproperty
    def VISUALIZER(cls):
        return cls("Visualizer")
    
    @schemas.classproperty
    def LAMBDA(cls):
        return cls("Lambda")
    
    @schemas.classproperty
    def TFOP_LAMBDA(cls):
        return cls("TFOpLambda")
    
    @schemas.classproperty
    def SLICING_OP_LAMBDA(cls):
        return cls("SlicingOpLambda")
    
    @schemas.classproperty
    def REPEAT(cls):
        return cls("Repeat")
    
    @schemas.classproperty
    def VARIABLE(cls):
        return cls("Variable")
    
    @schemas.classproperty
    def GATHER(cls):
        return cls("Gather")
    
    @schemas.classproperty
    def FIXED_DROPOUT(cls):
        return cls("FixedDropout")
