namespace ov::pass::low_precision

namespace low_precision {

// namespaces

namespace ov::pass::low_precision::itt;
    namespace ov::pass::low_precision::itt::domains;
namespace ov::pass::low_precision::precision_set;

// typedefs

typedef std::tuple<std::shared_ptr<ov::Node>, std::shared_ptr<ov::Node>> FakeQuantizeDequantizationValues;
typedef std::shared_ptr<LayerTransformation> LayerTransformationPtr;

// enums

enum levels;

// classes

class AddTransformation;
class AlignQuantizationIntervals;
class AlignQuantizationParameters;
class AssignAndReadValueTransformation;
class AvgPoolTransformation;
class BatchToSpaceTransformation;
class ClampTransformation;
class CleanupTransformation;
class ConcatTransformation;
class ConvertSubtractConstant;
class ConvertTransformation;
class ConvolutionBackpropDataTransformation;
class ConvolutionTransformation;
template <
    typename AttributeType,
    typename OperationType = ov::pass::pattern::op::Label
    >
class CreateAttribute;
template <typename AttributeType, typename OperationType>
class CreatePrecisionsDependentAttribute;
class DataPrecision;
class DepthToSpaceTransformation;
class EliminateFakeQuantizeTransformation;
class EltwiseBaseTransformation;
class Exception;
class FakeQuantizeDecompositionTransformation;
class FakeQuantizeDequantization;
class FakeQuantizeTransformation;
class FoldConvertTransformation;
class FoldFakeQuantizeTransformation;
class FuseConvertTransformation;
class FuseElementwiseToFakeQuantizeTransformation;
class FuseMultiplyToFakeQuantizeTransformation;
class FuseSubtractToFakeQuantizeTransformation;
class GatherTransformation;
class GroupConvolutionTransformation;
class InferenceEngineLptException;
class InterpolateTransformation;
class LayerTransformation;
class LowPrecision;
class MVNTransformation;
class MarkupAvgPoolPrecisionPreserved;
class MarkupBias;
class MarkupCanBeQuantized;
class MarkupOptimizations;
class MarkupPrecisions;
class MarkupQuantizationGranularity;
class MatMulTransformation;
class MaxPoolTransformation;
class MoveFakeQuantize;
class MultiplyPartialTransformation;
class MultiplyToGroupConvolutionTransformation;
class MultiplyTransformation;
class NetworkHelper;
class NormalizeL2Transformation;
class PReluTransformation;
class PadTransformation;
class PortQuantizationGranularityRestriction;
class PrecisionsRestriction;
class PropagatePrecisions;
template <class AttributeType>
class PropagateSharedValue;
template <typename AttributeType>
class PropagateThroughPrecisionPreserved;
template <typename AttributeType>
class PropagateToInput;
class PullReshapeThroughDequantization;
class PullTransposeThroughDequantization;
class QuantizationDetails;
class QuantizationGranularityRestriction;
class RecurrentCellTransformation;
class ReduceBaseTransformation;
class ReduceMaxTransformation;
class ReduceMeanTransformation;
class ReduceMinTransformation;
class ReduceSumTransformation;
class ReluTransformation;
class ReshapeTransformation;
class ShuffleChannelsTransformation;
class SpaceToBatchTransformation;
class SplitTransformation;
class SqueezeTransformation;
class StridedSliceTransformation;
class SubtractTransformation;
class TransformationContext;
class TransparentBaseTransformation;
class TransposeTransformation;
class TypeRelaxedReplacer;
class UnsqueezeTransformation;
template <
    typename AttributeType,
    typename ExpectedAttributeType = AttributeType
    >
class UpdateSharedPrecisionPreserved;
class VariadicSplitTransformation;
class WeightableLayerTransformation;

// global variables

class LP_TRANSFORMATIONS_API AlignQuantizationIntervals;
class LP_TRANSFORMATIONS_API AlignQuantizationParameters;
class LP_TRANSFORMATIONS_API BaseMatcherPass;
class LP_TRANSFORMATIONS_API ConvertSubtractConstant;
class LP_TRANSFORMATIONS_API TypeRelaxedReplacer;
class LP_TRANSFORMATIONS_API MarkupOptimizations;
class LP_TRANSFORMATIONS_API LowPrecision;
class LP_TRANSFORMATIONS_API MarkupAvgPoolPrecisionPreserved;
class LP_TRANSFORMATIONS_API MarkupCanBeQuantized;
class LP_TRANSFORMATIONS_API MarkupPrecisions;
class LP_TRANSFORMATIONS_API MarkupQuantizationGranularity;
class LP_TRANSFORMATIONS_API PropagatePrecisions;
class LP_TRANSFORMATIONS_API PropagateSharedValue;
class LP_TRANSFORMATIONS_API PullReshapeThroughDequantization;
class LP_TRANSFORMATIONS_API PullTransposeThroughDequantization;

// global functions

bool operator == (const DataPrecision& value1, const DataPrecision& value2);
bool operator != (const DataPrecision& value1, const DataPrecision& value2);
std::ostream& operator << (std::ostream& os, const DataPrecision& value);

template <typename T>
std::shared_ptr<Node> make_op_pattern(const ov::NodeVector& args);

template <typename T, typename... Args>
std::shared_ptr<Node> fold(Args&&... args);

std::shared_ptr<Node> foldConvert(
    const Output<Node>& node,
    const element::Type targetPrecision
    );

template <typename T, typename... Args>
std::shared_ptr<Node> fold_reshape(Args&&... args);

template <typename T>
ov::Any getAttribute(const std::shared_ptr<Node>& node);

template <typename T>
ov::Any getAttribute(const Input<Node>& input);

template <typename T>
ov::Any getAttributeFromOutput(const Output<Node>& output);

bool isDisabled(const std::shared_ptr<Node>& node);
std::ostream& operator << (std::ostream& os, const QuantizationDetails& value);

} // namespace low_precision