/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* TypeDef Declarations                                                       *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

#ifdef GET_TYPEDEF_CLASSES
#undef GET_TYPEDEF_CLASSES


namespace mlir {
class AsmParser;
class AsmPrinter;
} // namespace mlir
namespace mlir {

/// Complex number with a parameterized element type
/// Syntax:
/// 
/// ```
/// complex-type ::= `complex` `<` type `>`
/// ```
/// 
/// The value of `complex` type represents a complex number with a parameterized
/// element type, which is composed of a real and imaginary value of that
/// element type. The element must be a floating point or integer scalar type.
/// 
/// #### Example:
/// 
/// ```mlir
/// complex<f32>
/// complex<i32>
/// ```
class ComplexType;
/// 8-bit floating point with 2 bit mantissa
/// An 8-bit floating point type with 1 sign bit, 5 bits exponent and 2 bits
/// mantissa. This is not a standard type as defined by IEEE-754, but it
/// follows similar conventions with the following characteristics:
/// 
///   * bit encoding: S1E5M2
///   * exponent bias: 15
///   * infinities: supported with exponent set to all 1s and mantissa 0s
///   * NaNs: supported with exponent bits set to all 1s and mantissa of
///     (01, 10, or 11)
///   * denormals when exponent is 0
/// 
/// Described in: https://arxiv.org/abs/2209.05433
class Float8E5M2Type;
/// 8-bit floating point with 3 bit mantissa
/// An 8-bit floating point type with 1 sign bit, 4 bits exponent and 3 bits
/// mantissa. This is not a standard type as defined by IEEE-754, but it
/// follows similar conventions with the following characteristics:
/// 
///   * bit encoding: S1E4M3
///   * exponent bias: 7
///   * infinities: supported with exponent set to all 1s and mantissa 0s
///   * NaNs: supported with exponent bits set to all 1s and mantissa of
///     (001, 010, 011, 100, 101, 110, 111)
///   * denormals when exponent is 0
class Float8E4M3Type;
/// 8-bit floating point with 3 bit mantissa
/// An 8-bit floating point type with 1 sign bit, 4 bits exponent and 3 bits
/// mantissa. This is not a standard type as defined by IEEE-754, but it follows
/// similar conventions, with the exception that there are no infinity values
/// and only two NaN representations. This type has the following
/// characteristics:
/// 
///   * bit encoding: S1E4M3
///   * exponent bias: 7
///   * infinities: Not supported
///   * NaNs: supported with exponent bits and mantissa bits set to all 1s
///   * denormals when exponent is 0
/// 
/// Described in: https://arxiv.org/abs/2209.05433
class Float8E4M3FNType;
/// 8-bit floating point with 2 bit mantissa
/// An 8-bit floating point type with 1 sign bit, 5 bits exponent and 2 bits
/// mantissa. This is not a standard type as defined by IEEE-754, but it follows
/// similar conventions, with the exception that there are no infinity values,
/// no negative zero, and only one NaN representation. This type has the
/// following characteristics:
/// 
///   * bit encoding: S1E5M2
///   * exponent bias: 16
///   * infinities: Not supported
///   * NaNs: Supported with sign bit set to 1, exponent bits and mantissa bits set to all 0s
///   * denormals when exponent is 0
/// 
/// Described in: https://arxiv.org/abs/2206.02915
class Float8E5M2FNUZType;
/// 8-bit floating point with 3 bit mantissa
/// An 8-bit floating point type with 1 sign bit, 4 bits exponent and 3 bits
/// mantissa. This is not a standard type as defined by IEEE-754, but it follows
/// similar conventions, with the exception that there are no infinity values,
/// no negative zero, and only one NaN representation. This type has the
/// following characteristics:
/// 
///   * bit encoding: S1E4M3
///   * exponent bias: 8
///   * infinities: Not supported
///   * NaNs: Supported with sign bit set to 1, exponent bits and mantissa bits set to all 0s
///   * denormals when exponent is 0
/// 
/// Described in: https://arxiv.org/abs/2209.05433
class Float8E4M3FNUZType;
/// 8-bit floating point with 3 bit mantissa
/// An 8-bit floating point type with 1 sign bit, 4 bits exponent and 3 bits
/// mantissa. This is not a standard type as defined by IEEE-754, but it follows
/// similar conventions, with the exception that there are no infinity values,
/// no negative zero, and only one NaN representation. This type has the
/// following characteristics:
/// 
///   * bit encoding: S1E4M3
///   * exponent bias: 11
///   * infinities: Not supported
///   * NaNs: Supported with sign bit set to 1, exponent bits and mantissa bits set to all 0s
///   * denormals when exponent is 0
/// 
/// Related to: https://dl.acm.org/doi/10.5555/3454287.3454728
class Float8E4M3B11FNUZType;
/// 8-bit floating point with 3 bits exponent and 4 bit mantissa
/// An 8-bit floating point type with 1 sign bit, 3 bits exponent and 4 bits
/// mantissa. This is not a standard type as defined by IEEE-754, but it
/// follows similar conventions with the following characteristics:
/// 
///   * bit encoding: S1E3M4
///   * exponent bias: 3
///   * infinities: supported with exponent set to all 1s and mantissa 0s
///   * NaNs: supported with exponent bits set to all 1s and mantissa values of
///     {0,1}⁴ except S.111.0000
///   * denormals when exponent is 0
class Float8E3M4Type;
/// 4-bit floating point with 2-bit exponent and 1-bit mantissa
/// An 4-bit floating point type with 1 sign bit, 2 bits exponent and 1 bit
/// mantissa. This is not a standard type as defined by IEEE-754, but it
/// follows similar conventions with the following characteristics:
/// 
///   * bit encoding: S1E2M1
///   * exponent bias: 1
///   * infinities: Not supported
///   * NaNs: Not supported
///   * denormals when exponent is 0
/// 
/// Open Compute Project (OCP) microscaling formats (MX) specification:
/// https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf
class Float4E2M1FNType;
/// 6-bit floating point with 2-bit exponent and 3-bit mantissa
/// An 6-bit floating point type with 1 sign bit, 2 bits exponent and 3 bits
/// mantissa. This is not a standard type as defined by IEEE-754, but it
/// follows similar conventions with the following characteristics:
/// 
///   * bit encoding: S1E2M3
///   * exponent bias: 1
///   * infinities: Not supported
///   * NaNs: Not supported
///   * denormals when exponent is 0
/// 
/// Open Compute Project (OCP) microscaling formats (MX) specification:
/// https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf
class Float6E2M3FNType;
/// 6-bit floating point with 3-bit exponent and 2-bit mantissa
/// An 6-bit floating point type with 1 sign bit, 3 bits exponent and 2 bits
/// mantissa. This is not a standard type as defined by IEEE-754, but it
/// follows similar conventions with the following characteristics:
/// 
///   * bit encoding: S1E3M2
///   * exponent bias: 3
///   * infinities: Not supported
///   * NaNs: Not supported
///   * denormals when exponent is 0
/// 
/// Open Compute Project (OCP) microscaling formats (MX) specification:
/// https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf
class Float6E3M2FNType;
/// 8-bit floating point with 8-bit exponent, no mantissa or sign
/// An 8-bit floating point type with no sign bit, 8 bits exponent and no
/// mantissa. This is not a standard type as defined by IEEE-754; it is intended
/// to be used for representing scaling factors, so it cannot represent zeros
/// and negative numbers. The values it can represent are powers of two in the
/// range [-127,127] and NaN.
/// 
///   * bit encoding: S0E8M0
///   * exponent bias: 127
///   * infinities: Not supported
///   * NaNs: Supported with all bits set to 1
///   * denormals: Not supported
/// 
/// Open Compute Project (OCP) microscaling formats (MX) specification:
/// https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf
class Float8E8M0FNUType;
/// bfloat16 floating-point type
class BFloat16Type;
/// 16-bit floating-point type
class Float16Type;
/// TF32 floating-point type
class FloatTF32Type;
/// 32-bit floating-point type
class Float32Type;
/// 64-bit floating-point type
class Float64Type;
/// 80-bit floating-point type
class Float80Type;
/// 128-bit floating-point type
class Float128Type;
/// Map from a list of inputs to a list of results
/// Syntax:
/// 
/// ```
/// // Function types may have multiple results.
/// function-result-type ::= type-list-parens | non-function-type
/// function-type ::= type-list-parens `->` function-result-type
/// ```
/// 
/// The function type can be thought of as a function signature. It consists of
/// a list of formal parameter types and a list of formal result types.
/// 
/// #### Example:
/// 
/// ```mlir
/// func.func @add_one(%arg0 : i64) -> i64 {
///   %c1 = arith.constant 1 : i64
///   %0 = arith.addi %arg0, %c1 : i64
///   return %0 : i64
/// }
/// ```
class FunctionType;
/// Map from a list of inputs to a list of results
/// Syntax:
/// 
/// ```
/// // Function types may have multiple results.
/// function-result-type ::= type-list-parens | non-function-type
/// function-type ::= type-list-parens `->` function-result-type
/// ```
/// 
/// The function type can be thought of as a function signature. It consists of
/// a list of formal parameter types and a list of formal result types.
/// 
/// #### Example:
/// 
/// ```mlir
/// func.func @add_one(%arg0 : i64) -> i64 {
///   %c1 = arith.constant 1 : i64
///   %0 = arith.addi %arg0, %c1 : i64
///   return %0 : i64
/// }
/// ```
class GraphType;
/// Integer-like type with unknown platform-dependent bit width
/// Syntax:
/// 
/// ```
/// // Target word-sized integer.
/// index-type ::= `index`
/// ```
/// 
/// The index type is a signless integer whose size is equal to the natural
/// machine word of the target ( [rationale](../../Rationale/Rationale/#integer-signedness-semantics) )
/// and is used by the affine constructs in MLIR.
/// 
/// **Rationale:** integers of platform-specific bit widths are practical to
/// express sizes, dimensionalities and subscripts.
class IndexType;
/// Integer type with arbitrary precision up to a fixed limit
/// Syntax:
/// 
/// ```
/// // Sized integers like i1, i4, i8, i16, i32.
/// signed-integer-type ::= `si` [1-9][0-9]*
/// unsigned-integer-type ::= `ui` [1-9][0-9]*
/// signless-integer-type ::= `i` [1-9][0-9]*
/// integer-type ::= signed-integer-type |
///                  unsigned-integer-type |
///                  signless-integer-type
/// ```
/// 
/// Integer types have a designated bit width and may optionally have signedness
/// semantics.
/// 
/// **Rationale:** low precision integers (like `i2`, `i4` etc) are useful for
/// low-precision inference chips, and arbitrary precision integers are useful
/// for hardware synthesis (where a 13 bit multiplier is a lot cheaper/smaller
/// than a 16 bit one).
class IntegerType;
/// Shaped reference to a region of memory
/// Syntax:
/// 
/// ```
/// layout-specification ::= attribute-value
/// memory-space ::= attribute-value
/// memref-type ::= `memref` `<` dimension-list-ranked type
///                 (`,` layout-specification)? (`,` memory-space)? `>`
/// ```
/// 
/// A `memref` type is a reference to a region of memory (similar to a buffer
/// pointer, but more powerful). The buffer pointed to by a memref can be
/// allocated, aliased and deallocated. A memref can be used to read and write
/// data from/to the memory region which it references. Memref types use the
/// same shape specifier as tensor types. Note that `memref<f32>`,
/// `memref<0 x f32>`, `memref<1 x 0 x f32>`, and `memref<0 x 1 x f32>` are all
/// different types.
/// 
/// A `memref` is allowed to have an unknown rank (e.g. `memref<*xf32>`). The
/// purpose of unranked memrefs is to allow external library functions to
/// receive memref arguments of any rank without versioning the functions based
/// on the rank. Other uses of this type are disallowed or will have undefined
/// behavior.
/// 
/// Are accepted as elements:
/// 
/// - built-in integer types;
/// - built-in index type;
/// - built-in floating point types;
/// - built-in vector types with elements of the above types;
/// - another memref type;
/// - any other type implementing `MemRefElementTypeInterface`.
/// 
/// ##### Layout
/// 
/// A memref may optionally have a layout that indicates how indices are
/// transformed from the multi-dimensional form into a linear address. The
/// layout must avoid internal aliasing, i.e., two distinct tuples of
/// _in-bounds_ indices must be pointing to different elements in memory. The
/// layout is an attribute that implements `MemRefLayoutAttrInterface`. The
/// bulitin dialect offers two kinds of layouts: strided and affine map, each
/// of which is available as an attribute. Other attributes may be used to
/// represent the layout as long as they can be converted to a
/// [semi-affine map](Affine.md/#semi-affine-maps) and implement the required
/// interface. Users of memref are expected to fallback to the affine
/// representation when handling unknown memref layouts. Multi-dimensional
/// affine forms are interpreted in _row-major_ fashion.
/// 
/// In absence of an explicit layout, a memref is considered to have a
/// multi-dimensional identity affine map layout.  Identity layout maps do not
/// contribute to the MemRef type identification and are discarded on
/// construction. That is, a type with an explicit identity map is
/// `memref<?x?xf32, (i,j)->(i,j)>` is strictly the same as the one without a
/// layout, `memref<?x?xf32>`.
/// 
/// ##### Affine Map Layout
/// 
/// The layout may be represented directly as an affine map from the index space
/// to the storage space. For example, the following figure shows an index map
/// which maps a 2-dimensional index from a 2x2 index space to a 3x3 index
/// space, using symbols `S0` and `S1` as offsets.
/// 
/// ![Index Map Example](/includes/img/index-map.svg)
/// 
/// Semi-affine maps are sufficiently flexible to represent a wide variety of
/// dense storage layouts, including row- and column-major and tiled:
/// 
/// ```mlir
/// // MxN matrix stored in row major layout in memory:
/// #layout_map_row_major = (i, j) -> (i, j)
/// 
/// // MxN matrix stored in column major layout in memory:
/// #layout_map_col_major = (i, j) -> (j, i)
/// 
/// // MxN matrix stored in a 2-d blocked/tiled layout with 64x64 tiles.
/// #layout_tiled = (i, j) -> (i floordiv 64, j floordiv 64, i mod 64, j mod 64)
/// ```
/// 
/// ##### Strided Layout
/// 
/// Memref layout can be expressed using strides to encode the distance, in
/// number of elements, in (linear) memory between successive entries along a
/// particular dimension. For example, a row-major strided layout for
/// `memref<2x3x4xf32>` is `strided<[12, 4, 1]>`, where the last dimension is
/// contiguous as indicated by the unit stride and the remaining strides are
/// products of the sizes of faster-variying dimensions. Strided layout can also
/// express non-contiguity, e.g., `memref<2x3, strided<[6, 2]>>` only accesses
/// even elements of the dense consecutive storage along the innermost
/// dimension.
/// 
/// The strided layout supports an optional _offset_ that indicates the
/// distance, in the number of elements, between the beginning of the memref
/// and the first accessed element. When omitted, the offset is considered to
/// be zero. That is, `memref<2, strided<[2], offset: 0>>` and
/// `memref<2, strided<[2]>>` are strictly the same type.
/// 
/// Both offsets and strides may be _dynamic_, that is, unknown at compile time.
/// This is represented by using a question mark (`?`) instead of the value in
/// the textual form of the IR.
/// 
/// The strided layout converts into the following canonical one-dimensional
/// affine form through explicit linearization:
/// 
/// ```mlir
/// affine_map<(d0, ... dN)[offset, stride0, ... strideN] ->
///             (offset + d0 * stride0 + ... dN * strideN)>
/// ```
/// 
/// Therefore, it is never subject to the implicit row-major layout
/// interpretation.
/// 
/// ##### Codegen of Unranked Memref
/// 
/// Using unranked memref in codegen besides the case mentioned above is highly
/// discouraged. Codegen is concerned with generating loop nests and specialized
/// instructions for high-performance, unranked memref is concerned with hiding
/// the rank and thus, the number of enclosing loops required to iterate over
/// the data. However, if there is a need to code-gen unranked memref, one
/// possible path is to cast into a static ranked type based on the dynamic
/// rank. Another possible path is to emit a single while loop conditioned on a
/// linear index and perform delinearization of the linear index to a dynamic
/// array containing the (unranked) indices. While this is possible, it is
/// expected to not be a good idea to perform this during codegen as the cost
/// of the translations is expected to be prohibitive and optimizations at this
/// level are not expected to be worthwhile. If expressiveness is the main
/// concern, irrespective of performance, passing unranked memrefs to an
/// external C++ library and implementing rank-agnostic logic there is expected
/// to be significantly simpler.
/// 
/// Unranked memrefs may provide expressiveness gains in the future and help
/// bridge the gap with unranked tensors. Unranked memrefs will not be expected
/// to be exposed to codegen but one may query the rank of an unranked memref
/// (a special op will be needed for this purpose) and perform a switch and cast
/// to a ranked memref as a prerequisite to codegen.
/// 
/// Example:
/// 
/// ```mlir
/// // With static ranks, we need a function for each possible argument type
/// %A = alloc() : memref<16x32xf32>
/// %B = alloc() : memref<16x32x64xf32>
/// call @helper_2D(%A) : (memref<16x32xf32>)->()
/// call @helper_3D(%B) : (memref<16x32x64xf32>)->()
/// 
/// // With unknown rank, the functions can be unified under one unranked type
/// %A = alloc() : memref<16x32xf32>
/// %B = alloc() : memref<16x32x64xf32>
/// // Remove rank info
/// %A_u = memref_cast %A : memref<16x32xf32> -> memref<*xf32>
/// %B_u = memref_cast %B : memref<16x32x64xf32> -> memref<*xf32>
/// // call same function with dynamic ranks
/// call @helper(%A_u) : (memref<*xf32>)->()
/// call @helper(%B_u) : (memref<*xf32>)->()
/// ```
/// 
/// The core syntax and representation of a layout specification is a
/// [semi-affine map](Affine.md/#semi-affine-maps). Additionally,
/// syntactic sugar is supported to make certain layout specifications more
/// intuitive to read. For the moment, a `memref` supports parsing a strided
/// form which is converted to a semi-affine map automatically.
/// 
/// The memory space of a memref is specified by a target-specific attribute.
/// It might be an integer value, string, dictionary or custom dialect attribute.
/// The empty memory space (attribute is None) is target specific.
/// 
/// The notionally dynamic value of a memref value includes the address of the
/// buffer allocated, as well as the symbols referred to by the shape, layout
/// map, and index maps.
/// 
/// Examples of memref static type
/// 
/// ```mlir
/// // Identity index/layout map
/// #identity = affine_map<(d0, d1) -> (d0, d1)>
/// 
/// // Column major layout.
/// #col_major = affine_map<(d0, d1, d2) -> (d2, d1, d0)>
/// 
/// // A 2-d tiled layout with tiles of size 128 x 256.
/// #tiled_2d_128x256 = affine_map<(d0, d1) -> (d0 div 128, d1 div 256, d0 mod 128, d1 mod 256)>
/// 
/// // A tiled data layout with non-constant tile sizes.
/// #tiled_dynamic = affine_map<(d0, d1)[s0, s1] -> (d0 floordiv s0, d1 floordiv s1,
///                              d0 mod s0, d1 mod s1)>
/// 
/// // A layout that yields a padding on two at either end of the minor dimension.
/// #padded = affine_map<(d0, d1) -> (d0, (d1 + 2) floordiv 2, (d1 + 2) mod 2)>
/// 
/// 
/// // The dimension list "16x32" defines the following 2D index space:
/// //
/// //   { (i, j) : 0 <= i < 16, 0 <= j < 32 }
/// //
/// memref<16x32xf32, #identity>
/// 
/// // The dimension list "16x4x?" defines the following 3D index space:
/// //
/// //   { (i, j, k) : 0 <= i < 16, 0 <= j < 4, 0 <= k < N }
/// //
/// // where N is a symbol which represents the runtime value of the size of
/// // the third dimension.
/// //
/// // %N here binds to the size of the third dimension.
/// %A = alloc(%N) : memref<16x4x?xf32, #col_major>
/// 
/// // A 2-d dynamic shaped memref that also has a dynamically sized tiled
/// // layout. The memref index space is of size %M x %N, while %B1 and %B2
/// // bind to the symbols s0, s1 respectively of the layout map #tiled_dynamic.
/// // Data tiles of size %B1 x %B2 in the logical space will be stored
/// // contiguously in memory. The allocation size will be
/// // (%M ceildiv %B1) * %B1 * (%N ceildiv %B2) * %B2 f32 elements.
/// %T = alloc(%M, %N) [%B1, %B2] : memref<?x?xf32, #tiled_dynamic>
/// 
/// // A memref that has a two-element padding at either end. The allocation
/// // size will fit 16 * 64 float elements of data.
/// %P = alloc() : memref<16x64xf32, #padded>
/// 
/// // Affine map with symbol 's0' used as offset for the first dimension.
/// #imapS = affine_map<(d0, d1) [s0] -> (d0 + s0, d1)>
/// // Allocate memref and bind the following symbols:
/// // '%n' is bound to the dynamic second dimension of the memref type.
/// // '%o' is bound to the symbol 's0' in the affine map of the memref type.
/// %n = ...
/// %o = ...
/// %A = alloc (%n)[%o] : <16x?xf32, #imapS>
/// ```
class MemRefType;
/// A unit type
/// Syntax:
/// 
/// ```
/// none-type ::= `none`
/// ```
/// 
/// NoneType is a unit type, i.e. a type with exactly one possible value, where
/// its value does not have a defined dynamic representation.
/// 
/// #### Example:
/// 
/// ```mlir
/// func.func @none_type() {
///   %none_val = "foo.unknown_op"() : () -> none
///   return
/// }
/// ```
class NoneType;
/// Type of a non-registered dialect
/// Syntax:
/// 
/// ```
/// opaque-type ::= `opaque` `<` type `>`
/// ```
/// 
/// Opaque types represent types of non-registered dialects. These are types
/// represented in their raw string form, and can only usefully be tested for
/// type equality.
/// 
/// #### Example:
/// 
/// ```mlir
/// opaque<"llvm", "struct<(i32, float)>">
/// opaque<"pdl", "value">
/// ```
class OpaqueType;
/// Multi-dimensional array with a fixed number of dimensions
/// Syntax:
/// 
/// ```
/// tensor-type ::= `tensor` `<` dimension-list type (`,` encoding)? `>`
/// dimension-list ::= (dimension `x`)*
/// dimension ::= `?` | decimal-literal
/// encoding ::= attribute-value
/// ```
/// 
/// Values with tensor type represents aggregate N-dimensional data values, and
/// have a known element type and a fixed rank with a list of dimensions. Each
/// dimension may be a static non-negative decimal constant or be dynamically
/// determined (indicated by `?`).
/// 
/// The runtime representation of the MLIR tensor type is intentionally
/// abstracted - you cannot control layout or get a pointer to the data. For
/// low level buffer access, MLIR has a [`memref` type](#memreftype). This
/// abstracted runtime representation holds both the tensor data values as well
/// as information about the (potentially dynamic) shape of the tensor. The
/// [`dim` operation](MemRef.md/#memrefdim-mlirmemrefdimop) returns the size of a
/// dimension from a value of tensor type.
/// 
/// The `encoding` attribute provides additional information on the tensor.
/// An empty attribute denotes a straightforward tensor without any specific
/// structure. But particular properties, like sparsity or other specific
/// characteristics of the data of the tensor can be encoded through this
/// attribute. The semantics are defined by a type and attribute interface
/// and must be respected by all passes that operate on tensor types.
/// TODO: provide this interface, and document it further.
/// 
/// Note: hexadecimal integer literals are not allowed in tensor type
/// declarations to avoid confusion between `0xf32` and `0 x f32`. Zero sizes
/// are allowed in tensors and treated as other sizes, e.g.,
/// `tensor<0 x 1 x i32>` and `tensor<1 x 0 x i32>` are different types. Since
/// zero sizes are not allowed in some other types, such tensors should be
/// optimized away before lowering tensors to vectors.
/// 
/// #### Example:
/// 
/// ```mlir
/// // Known rank but unknown dimensions.
/// tensor<? x ? x ? x ? x f32>
/// 
/// // Partially known dimensions.
/// tensor<? x ? x 13 x ? x f32>
/// 
/// // Full static shape.
/// tensor<17 x 4 x 13 x 4 x f32>
/// 
/// // Tensor with rank zero. Represents a scalar.
/// tensor<f32>
/// 
/// // Zero-element dimensions are allowed.
/// tensor<0 x 42 x f32>
/// 
/// // Zero-element tensor of f32 type (hexadecimal literals not allowed here).
/// tensor<0xf32>
/// 
/// // Tensor with an encoding attribute (where #ENCODING is a named alias).
/// tensor<?x?xf64, #ENCODING>
/// ```
class RankedTensorType;
/// Token type
/// Syntax:
/// 
/// ```
/// token-type ::= `token`
/// ```
/// 
/// A use of a token SSA value is a pointer to an operation (in case of an
/// OpResult) or a pointer to a region (in case of an entry block argument).
/// A token carries no runtime data and cannot be forwarded. Tokens are
/// excluded from the `AnyType` type constraint. Operations must define
/// `TokenProducerTrait` to produce token results or token region entry block
/// arguments, and must define `TokenConsumerTrait` to consume token operands.
class TokenType;
/// Fixed-sized collection of other types
/// Syntax:
/// 
/// ```
/// tuple-type ::= `tuple` `<` (type ( `,` type)*)? `>`
/// ```
/// 
/// The value of `tuple` type represents a fixed-size collection of elements,
/// where each element may be of a different type.
/// 
/// **Rationale:** Though this type is first class in the type system, MLIR
/// provides no standard operations for operating on `tuple` types
/// ([rationale](../../Rationale/Rationale/#tuple-types)).
/// 
/// #### Example:
/// 
/// ```mlir
/// // Empty tuple.
/// tuple<>
/// 
/// // Single element
/// tuple<f32>
/// 
/// // Many elements.
/// tuple<i32, f32, tensor<i1>, i5>
/// ```
class TupleType;
/// Shaped reference, with unknown rank, to a region of memory
/// Syntax:
/// 
/// ```
/// unranked-memref-type ::= `memref` `<*x` type (`,` memory-space)? `>`
/// memory-space ::= attribute-value
/// ```
/// 
/// A `memref` type with an unknown rank (e.g. `memref<*xf32>`). The purpose of
/// unranked memrefs is to allow external library functions to receive memref
/// arguments of any rank without versioning the functions based on the rank.
/// Other uses of this type are disallowed or will have undefined behavior.
/// 
/// See [MemRefType](#memreftype) for more information on
/// memref types.
/// 
/// #### Examples:
/// 
/// ```mlir
/// memref<*f32>
/// 
/// // An unranked memref with a memory space of 10.
/// memref<*f32, 10>
/// ```
class UnrankedMemRefType;
/// Multi-dimensional array with unknown dimensions
/// Syntax:
/// 
/// ```
/// tensor-type ::= `tensor` `<` `*` `x` type `>`
/// ```
/// 
/// An unranked tensor is a type of tensor in which the set of dimensions have
/// unknown rank. See [RankedTensorType](#rankedtensortype)
/// for more information on tensor types.
/// 
/// #### Examples:
/// 
/// ```mlir
/// tensor<*xf32>
/// ```
class UnrankedTensorType;
/// Multi-dimensional SIMD vector type
/// Syntax:
/// 
/// ```
/// vector-type ::= `vector` `<` vector-dim-list vector-element-type `>`
/// vector-element-type ::= float-type | integer-type | index-type
/// vector-dim-list := (static-dim-list `x`)?
/// static-dim-list ::= static-dim (`x` static-dim)*
/// static-dim ::= (decimal-literal | `[` decimal-literal `]`)
/// ```
/// 
/// The vector type represents a SIMD style vector used by target-specific
/// operation sets like AVX or SVE. While the most common use is for 1D
/// vectors (e.g. vector<16 x f32>) we also support multidimensional registers
/// on targets that support them (like TPUs). The dimensions of a vector type
/// can be fixed-length, scalable, or a combination of the two. The scalable
/// dimensions in a vector are indicated between square brackets ([ ]).
/// 
/// Vector shapes must be positive decimal integers. 0D vectors are allowed by
/// omitting the dimension: `vector<f32>`.
/// 
/// Note: hexadecimal integer literals are not allowed in vector type
/// declarations, `vector<0x42xi32>` is invalid because it is interpreted as a
/// 2D vector with shape `(0, 42)` and zero shapes are not allowed.
/// 
/// #### Examples:
/// 
/// ```mlir
/// // A 2D fixed-length vector of 3x42 i32 elements.
/// vector<3x42xi32>
/// 
/// // A 1D scalable-length vector that contains a multiple of 4 f32 elements.
/// vector<[4]xf32>
/// 
/// // A 2D scalable-length vector that contains a multiple of 2x8 f32 elements.
/// vector<[2]x[8]xf32>
/// 
/// // A 2D mixed fixed/scalable vector that contains 4 scalable vectors of 4 f32 elements.
/// vector<4x[4]xf32>
/// 
/// // A 3D mixed fixed/scalable vector in which only the inner dimension is
/// // scalable.
/// vector<2x[4]x8xf32>
/// ```
class VectorType;
namespace detail {

struct ComplexTypeStorage;

} // namespace detail
class ComplexType : public ::mlir::Type::TypeBase<ComplexType, ::mlir::Type, detail::ComplexTypeStorage, ::mlir::DenseElementType::Trait> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "builtin.complex";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using Base::getChecked;
  static ComplexType get(Type elementType);
  static ComplexType getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, Type elementType);
  static ::llvm::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, Type elementType);
  static ::llvm::LogicalResult verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, Type elementType);
  Type getElementType() const;
  size_t getDenseElementBitSize() const;
  ::mlir::Attribute convertToAttribute(::llvm::ArrayRef<char> rawData) const;
  ::llvm::LogicalResult convertFromAttribute(::mlir::Attribute attr, ::llvm::SmallVectorImpl<char>&result) const;
};
class Float8E5M2Type : public ::mlir::Type::TypeBase<Float8E5M2Type, ::mlir::Type, ::mlir::TypeStorage, ::mlir::QuantStorageTypeInterface::Trait, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait, ::mlir::FloatType::Trait> {
public:
  using Base::Base;
  /// QuantStorageTypeInterface method implementations
  /// Returns true if the the storage type should default to signed
  /// when used in quantization.
  bool shouldDefaultToSigned() const { return true; }
  /// Get the bit width of this 8-bit floating point type.
  unsigned getStorageWidth() const { return 8; }

  /// Get default min, max value for this 8-bit floating point type.
  int64_t getDefaultMaximum(bool isSigned) const { return 57344; }
  int64_t getDefaultMinimum(bool isSigned) const { return -getDefaultMaximum(isSigned); }

  /// Get the storage type as a string.
  std::string getStorageTypeName(bool isSigned) const { return "f8E5M2"; }

  /// Check if this 8-bit floating point type uses packed representation.
  bool isPacked() const { return false; }

  /// Get the logical bit width per value for this 8-bit floating point type.
  unsigned getLogicalBitWidth() const { return 8; }

  /// Returns how many values of this type fit in one byte
  unsigned getElementsPerByte() const { return 1; }

  /// Get the preferred alignment in bytes for this 8-bit floating point type.
  std::optional<unsigned> getPreferredAlignmentBytes() const { return std::nullopt; }
  static constexpr ::llvm::StringLiteral name = "builtin.f8E5M2";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using ::mlir::FloatType::Trait<Float8E5M2Type>::scaleElementBitwidth;
  const ::llvm::fltSemantics &getFloatSemantics() const;
};
class Float8E4M3Type : public ::mlir::Type::TypeBase<Float8E4M3Type, ::mlir::Type, ::mlir::TypeStorage, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait, ::mlir::FloatType::Trait> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "builtin.f8E4M3";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using ::mlir::FloatType::Trait<Float8E4M3Type>::scaleElementBitwidth;
  const ::llvm::fltSemantics &getFloatSemantics() const;
};
class Float8E4M3FNType : public ::mlir::Type::TypeBase<Float8E4M3FNType, ::mlir::Type, ::mlir::TypeStorage, ::mlir::QuantStorageTypeInterface::Trait, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait, ::mlir::FloatType::Trait> {
public:
  using Base::Base;
  /// QuantStorageTypeInterface method implementations
  /// Returns true if the the storage type should default to signed
  /// when used in quantization.
  bool shouldDefaultToSigned() const { return true; }
  /// Get the bit width of this 8-bit floating point type.
  unsigned getStorageWidth() const { return 8; }

  /// Get default min, max value for this 8-bit floating point type.
  int64_t getDefaultMaximum(bool isSigned) const { return 448; }
  int64_t getDefaultMinimum(bool isSigned) const { return -getDefaultMaximum(isSigned); }

  /// Get the storage type as a string.
  std::string getStorageTypeName(bool isSigned) const { return "f8E4M3FN"; }

  /// Check if this 8-bit floating point type uses packed representation.
  bool isPacked() const { return false; }

  /// Get the logical bit width per value for this 8-bit floating point type.
  unsigned getLogicalBitWidth() const { return 8; }

  /// Returns how many values of this type fit in one byte
  unsigned getElementsPerByte() const { return 1; }

  /// Get the preferred alignment in bytes for this 8-bit floating point type.
  std::optional<unsigned> getPreferredAlignmentBytes() const { return std::nullopt; }
  static constexpr ::llvm::StringLiteral name = "builtin.f8E4M3FN";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using ::mlir::FloatType::Trait<Float8E4M3FNType>::scaleElementBitwidth;
  const ::llvm::fltSemantics &getFloatSemantics() const;
};
class Float8E5M2FNUZType : public ::mlir::Type::TypeBase<Float8E5M2FNUZType, ::mlir::Type, ::mlir::TypeStorage, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait, ::mlir::FloatType::Trait> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "builtin.f8E5M2FNUZ";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using ::mlir::FloatType::Trait<Float8E5M2FNUZType>::scaleElementBitwidth;
  const ::llvm::fltSemantics &getFloatSemantics() const;
};
class Float8E4M3FNUZType : public ::mlir::Type::TypeBase<Float8E4M3FNUZType, ::mlir::Type, ::mlir::TypeStorage, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait, ::mlir::FloatType::Trait> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "builtin.f8E4M3FNUZ";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using ::mlir::FloatType::Trait<Float8E4M3FNUZType>::scaleElementBitwidth;
  const ::llvm::fltSemantics &getFloatSemantics() const;
};
class Float8E4M3B11FNUZType : public ::mlir::Type::TypeBase<Float8E4M3B11FNUZType, ::mlir::Type, ::mlir::TypeStorage, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait, ::mlir::FloatType::Trait> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "builtin.f8E4M3B11FNUZ";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using ::mlir::FloatType::Trait<Float8E4M3B11FNUZType>::scaleElementBitwidth;
  const ::llvm::fltSemantics &getFloatSemantics() const;
};
class Float8E3M4Type : public ::mlir::Type::TypeBase<Float8E3M4Type, ::mlir::Type, ::mlir::TypeStorage, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait, ::mlir::FloatType::Trait> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "builtin.f8E3M4";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using ::mlir::FloatType::Trait<Float8E3M4Type>::scaleElementBitwidth;
  const ::llvm::fltSemantics &getFloatSemantics() const;
};
class Float4E2M1FNType : public ::mlir::Type::TypeBase<Float4E2M1FNType, ::mlir::Type, ::mlir::TypeStorage, ::mlir::QuantStorageTypeInterface::Trait, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait, ::mlir::FloatType::Trait> {
public:
  using Base::Base;
  /// QuantStorageTypeInterface method implementations
  /// Returns true if the the storage type should default to signed
  /// when used in quantization.
  bool shouldDefaultToSigned() const { return true; }
  /// Get the bit width of this 4-bit floating point type.
  unsigned getStorageWidth() const { return 4; }

  /// Get default min, max value for this 4-bit floating point type.
  int64_t getDefaultMaximum(bool isSigned) const { return 6; }
  int64_t getDefaultMinimum(bool isSigned) const { return -getDefaultMaximum(isSigned); }

  /// Get the storage type as a string.
  std::string getStorageTypeName(bool isSigned) const { return "f4E2M1FN"; }

  /// Check if this 4-bit floating point type uses packed representation.
  bool isPacked() const { return true; }

  /// Get the logical bit width per value for this 4-bit floating point type.
  unsigned getLogicalBitWidth() const { return 4; }

  /// Returns how many values of this type fit in one byte
  unsigned getElementsPerByte() const { return 2; }

  /// Get the preferred alignment in bytes for this 4-bit floating point type.
  std::optional<unsigned> getPreferredAlignmentBytes() const { return std::nullopt; }
  static constexpr ::llvm::StringLiteral name = "builtin.f4E2M1FN";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using ::mlir::FloatType::Trait<Float4E2M1FNType>::scaleElementBitwidth;
  const ::llvm::fltSemantics &getFloatSemantics() const;
};
class Float6E2M3FNType : public ::mlir::Type::TypeBase<Float6E2M3FNType, ::mlir::Type, ::mlir::TypeStorage, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait, ::mlir::FloatType::Trait> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "builtin.f6E2M3FN";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using ::mlir::FloatType::Trait<Float6E2M3FNType>::scaleElementBitwidth;
  const ::llvm::fltSemantics &getFloatSemantics() const;
};
class Float6E3M2FNType : public ::mlir::Type::TypeBase<Float6E3M2FNType, ::mlir::Type, ::mlir::TypeStorage, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait, ::mlir::FloatType::Trait> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "builtin.f6E3M2FN";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using ::mlir::FloatType::Trait<Float6E3M2FNType>::scaleElementBitwidth;
  const ::llvm::fltSemantics &getFloatSemantics() const;
};
class Float8E8M0FNUType : public ::mlir::Type::TypeBase<Float8E8M0FNUType, ::mlir::Type, ::mlir::TypeStorage, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait, ::mlir::FloatType::Trait> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "builtin.f8E8M0FNU";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using ::mlir::FloatType::Trait<Float8E8M0FNUType>::scaleElementBitwidth;
  const ::llvm::fltSemantics &getFloatSemantics() const;
};
class BFloat16Type : public ::mlir::Type::TypeBase<BFloat16Type, ::mlir::Type, ::mlir::TypeStorage, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait, ::mlir::FloatType::Trait> {
public:
  using Base::Base;
  static BFloat16Type get(MLIRContext *context);
  static constexpr ::llvm::StringLiteral name = "builtin.bf16";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  const ::llvm::fltSemantics &getFloatSemantics() const;
  ::mlir::FloatType scaleElementBitwidth(unsigned scale) const;
};
class Float16Type : public ::mlir::Type::TypeBase<Float16Type, ::mlir::Type, ::mlir::TypeStorage, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait, ::mlir::FloatType::Trait> {
public:
  using Base::Base;
  static Float16Type get(MLIRContext *context);
  static constexpr ::llvm::StringLiteral name = "builtin.f16";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  const ::llvm::fltSemantics &getFloatSemantics() const;
  ::mlir::FloatType scaleElementBitwidth(unsigned scale) const;
};
class FloatTF32Type : public ::mlir::Type::TypeBase<FloatTF32Type, ::mlir::Type, ::mlir::TypeStorage, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait, ::mlir::FloatType::Trait> {
public:
  using Base::Base;
  static FloatTF32Type get(MLIRContext *context);
  static constexpr ::llvm::StringLiteral name = "builtin.tf32";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using ::mlir::FloatType::Trait<FloatTF32Type>::scaleElementBitwidth;
  const ::llvm::fltSemantics &getFloatSemantics() const;
};
class Float32Type : public ::mlir::Type::TypeBase<Float32Type, ::mlir::Type, ::mlir::TypeStorage, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait, ::mlir::FloatType::Trait> {
public:
  using Base::Base;
  static Float32Type get(MLIRContext *context);
  static constexpr ::llvm::StringLiteral name = "builtin.f32";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  const ::llvm::fltSemantics &getFloatSemantics() const;
  ::mlir::FloatType scaleElementBitwidth(unsigned scale) const;
};
class Float64Type : public ::mlir::Type::TypeBase<Float64Type, ::mlir::Type, ::mlir::TypeStorage, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait, ::mlir::FloatType::Trait> {
public:
  using Base::Base;
  static Float64Type get(MLIRContext *context);
  static constexpr ::llvm::StringLiteral name = "builtin.f64";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using ::mlir::FloatType::Trait<Float64Type>::scaleElementBitwidth;
  const ::llvm::fltSemantics &getFloatSemantics() const;
};
class Float80Type : public ::mlir::Type::TypeBase<Float80Type, ::mlir::Type, ::mlir::TypeStorage, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait, ::mlir::FloatType::Trait> {
public:
  using Base::Base;
  static Float80Type get(MLIRContext *context);
  static constexpr ::llvm::StringLiteral name = "builtin.f80";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using ::mlir::FloatType::Trait<Float80Type>::scaleElementBitwidth;
  const ::llvm::fltSemantics &getFloatSemantics() const;
};
class Float128Type : public ::mlir::Type::TypeBase<Float128Type, ::mlir::Type, ::mlir::TypeStorage, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait, ::mlir::FloatType::Trait> {
public:
  using Base::Base;
  static Float128Type get(MLIRContext *context);
  static constexpr ::llvm::StringLiteral name = "builtin.f128";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using ::mlir::FloatType::Trait<Float128Type>::scaleElementBitwidth;
  const ::llvm::fltSemantics &getFloatSemantics() const;
};
class FunctionType : public ::mlir::Type::TypeBase<FunctionType, ::mlir::Type, detail::FunctionTypeStorage> {
public:
  using Base::Base;
  /// Input types.
  unsigned getNumInputs() const;
  Type getInput(unsigned i) const { return getInputs()[i]; }

  /// Result types.
  unsigned getNumResults() const;
  Type getResult(unsigned i) const { return getResults()[i]; }

  /// Returns a clone of this function-like type with the given argument
  /// and result types.
  FunctionType clone(TypeRange inputs, TypeRange results) const;

  /// Returns a new function-like type with the specified arguments and results
  /// inserted.
  FunctionType getWithArgsAndResults(ArrayRef<unsigned> argIndices,
                                     TypeRange argTypes,
                                     ArrayRef<unsigned> resultIndices,
                                     TypeRange resultTypes);

  /// Returns a new function-like type without the specified arguments and results.
  FunctionType getWithoutArgsAndResults(const BitVector &argIndices,
                                        const BitVector &resultIndices);
  static constexpr ::llvm::StringLiteral name = "builtin.function";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  static FunctionType get(::mlir::MLIRContext *context, TypeRange inputs, TypeRange results);
  ArrayRef<Type> getInputs() const;
  ArrayRef<Type> getResults() const;
};
class GraphType : public ::mlir::Type::TypeBase<GraphType, ::mlir::Type, detail::FunctionTypeStorage> {
public:
  using Base::Base;
  /// Input types.
  unsigned getNumInputs() const;
  Type getInput(unsigned i) const { return getInputs()[i]; }

  /// Result types.
  unsigned getNumResults() const;
  Type getResult(unsigned i) const { return getResults()[i]; }

  /// Returns a clone of this function-like type with the given argument
  /// and result types.
  GraphType clone(TypeRange inputs, TypeRange results) const;

  /// Returns a new function-like type with the specified arguments and results
  /// inserted.
  GraphType getWithArgsAndResults(ArrayRef<unsigned> argIndices,
                                     TypeRange argTypes,
                                     ArrayRef<unsigned> resultIndices,
                                     TypeRange resultTypes);

  /// Returns a new function-like type without the specified arguments and results.
  GraphType getWithoutArgsAndResults(const BitVector &argIndices,
                                        const BitVector &resultIndices);
  static constexpr ::llvm::StringLiteral name = "builtin.graph";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  static GraphType get(::mlir::MLIRContext *context, TypeRange inputs, TypeRange results);
  ArrayRef<Type> getInputs() const;
  ArrayRef<Type> getResults() const;
};
class IndexType : public ::mlir::Type::TypeBase<IndexType, ::mlir::Type, ::mlir::TypeStorage, ::mlir::DenseElementType::Trait, ::mlir::VectorElementTypeInterface::Trait> {
public:
  using Base::Base;
  static IndexType get(MLIRContext *context);

  /// Storage bit width used for IndexType by internal compiler data
  /// structures.
  static constexpr unsigned kInternalStorageBitWidth = 64;
  static constexpr ::llvm::StringLiteral name = "builtin.index";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  size_t getDenseElementBitSize() const;
  ::mlir::Attribute convertToAttribute(::llvm::ArrayRef<char> rawData) const;
  ::llvm::LogicalResult convertFromAttribute(::mlir::Attribute attr, ::llvm::SmallVectorImpl<char>&result) const;
};
class IntegerType : public ::mlir::Type::TypeBase<IntegerType, ::mlir::Type, detail::IntegerTypeStorage, ::mlir::VectorElementTypeInterface::Trait, ::mlir::QuantStorageTypeInterface::Trait, ::mlir::DenseElementType::Trait> {
public:
  using Base::Base;
  /// Signedness semantics.
  enum SignednessSemantics : uint32_t {
    Signless, /// No signedness semantics
    Signed,   /// Signed integer
    Unsigned, /// Unsigned integer
  };

  /// Return true if this is a signless integer type.
  bool isSignless() const { return getSignedness() == Signless; }
  /// Return true if this is a signed integer type.
  bool isSigned() const { return getSignedness() == Signed; }
  /// Return true if this is an unsigned integer type.
  bool isUnsigned() const { return getSignedness() == Unsigned; }

  /// Get or create a new IntegerType with the same signedness as `this` and a
  /// bitwidth scaled by `scale`.
  /// Return null if the scaled element type cannot be represented.
  IntegerType scaleElementBitwidth(unsigned scale);

  /// Integer representation maximal bitwidth.
  /// Note: This is aligned with the maximum width of llvm::IntegerType.
  static constexpr unsigned kMaxWidth = (1 << 24) - 1;

  /// QuantStorageTypeInterface method implementations
  /// Returns true if the storage type should default to signed when used
  /// in quantization. Returns true for signed or signless integer types.
  bool shouldDefaultToSigned() const { return !isUnsigned(); }
  /// Get the bit width of this integer type.
  unsigned getStorageWidth() const { return getWidth(); }

  /// Get default min, max value for this integer type.
  int64_t getDefaultMaximum(bool isSigned) const {
    if (isSigned) {
      return llvm::maxIntN(getWidth());
    }
    return llvm::maxUIntN(getWidth());
  }
  int64_t getDefaultMinimum(bool isSigned) const {
    if (isSigned) {
      return llvm::minIntN(getWidth());
    }
    return 0;
  }

  /// Get the storage type as a string.
  std::string getStorageTypeName(bool isSigned) const {
    if (isSignless()) {
      return (isSigned ? "i" : "u") + std::to_string(getWidth());
    } else {
      std::string s;
      llvm::raw_string_ostream(s) << *this;
      return s;
    }
  }

  /// Check if this integer type uses packed representation.
  bool isPacked() const { return getStorageWidth() < 8; }

  /// Get the logical bit width per value for this integer type.
  unsigned getLogicalBitWidth() const { return getWidth(); }

  /// Returns how many values of this type fit in one byte
  unsigned getElementsPerByte() const { return 8 / getLogicalBitWidth(); }

  /// Get the preferred alignment in bytes for this integer type.
  std::optional<unsigned> getPreferredAlignmentBytes() const { return std::nullopt; }
  static constexpr ::llvm::StringLiteral name = "builtin.integer";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using Base::getChecked;
  static IntegerType get(::mlir::MLIRContext *context, unsigned width, SignednessSemantics signedness = Signless);
  static IntegerType getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, unsigned width, SignednessSemantics signedness = Signless);
  static ::llvm::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, unsigned width, SignednessSemantics signedness);
  static ::llvm::LogicalResult verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, unsigned width, SignednessSemantics signedness);
  unsigned getWidth() const;
  SignednessSemantics getSignedness() const;
  size_t getDenseElementBitSize() const;
  ::mlir::Attribute convertToAttribute(::llvm::ArrayRef<char> rawData) const;
  ::llvm::LogicalResult convertFromAttribute(::mlir::Attribute attr, ::llvm::SmallVectorImpl<char>&result) const;
};
namespace detail {

struct MemRefTypeStorage;

} // namespace detail
class MemRefType : public ::mlir::Type::TypeBase<MemRefType, BaseMemRefType, detail::MemRefTypeStorage, ::mlir::PtrLikeTypeInterface::Trait, ::mlir::ShapedType::Trait> {
public:
  using Base::Base;
  using BaseMemRefType::clone;
  using ShapedType::Trait<MemRefType>::getElementTypeBitWidth;
  using ShapedType::Trait<MemRefType>::getRank;
  using ShapedType::Trait<MemRefType>::getNumElements;
  using ShapedType::Trait<MemRefType>::isDynamicDim;
  using ShapedType::Trait<MemRefType>::hasStaticShape;
  using ShapedType::Trait<MemRefType>::getNumDynamicDims;
  using ShapedType::Trait<MemRefType>::getDimSize;
  using ShapedType::Trait<MemRefType>::getDynamicDimIndex;

  /// This is a builder type that keeps local references to arguments.
  /// Arguments that are passed into the builder must outlive the builder.
  class Builder;

  /// Return "true" if the last N dimensions are contiguous.
  ///
  /// Examples:
  ///   - memref<5x4x3x2xi8, strided<[24, 6, 2, 1]> is contiguous when
  ///   considering both _all_ and _only_ the trailing 3 dims,
  ///   - memref<5x4x3x2xi8, strided<[48, 6, 2, 1]> is _only_ contiguous when
  ///   considering the trailing 3 dims.
  ///
  bool areTrailingDimsContiguous(int64_t n);

  /// Return the number of trailing dimensions that are contiguous.
  ///
  /// Examples:
  ///   - memref<5x3x2xi8, strided<[6,2,1]>>, the number of collapsable
  ///     trailing dimensions is 3
  ///   - memref<5x3x2xi8, strided<[12,2,1]>>, the number of collapsable
  ///     trailing dimensions is 2 (dimension 0 is non-contiguous)
  ///   - memref<5x3x2xi8, strided<[12,4,1]>>, the number of collapsable
  ///     trailing dimensions is 1 (dimension 1 is non-contiguous)
  ///   - memref<5x3x2xi8, strided<[12,4,2]>>, the number of collapsable
  ///     trailing dimensions is 0 (dimension 2 is non-contiguous)
  ///   - memref<?x3x2xi8, strided<[6,2,1]>>, the number of collapsable
  ///     trailing dimensions is 3
  ///   - memref<?x3x2xi8, strided<[12,2,1]>>, the number of collapsable
  ///     trailing dimensions is 2 (dimension 0 is non-contiguous)
  ///   - memref<5x?x2xi8, strided<[?,2,1]>>, the number of collapsable
  ///     trailing dimensions is 2 (stride 0 is dynamic)
  int64_t getNumContiguousTrailingDims();

  /// Return a version of this type with identity layout if it can be
  /// determined statically that the layout is the canonical contiguous
  /// strided layout. Otherwise pass the layout into `simplifyAffineMap`
  /// and return a copy of this type with simplified layout.
  MemRefType canonicalizeStridedLayout();

  /// [deprecated] Returns the memory space in old raw integer representation.
  /// New `Attribute getMemorySpace()` method should be used instead.
  unsigned getMemorySpaceAsInt() const;

  /// Returns the strides of the MemRef if the layout map is in strided form.
  /// MemRefs with a layout map in strided form include:
  ///   1. empty or identity layout map, in which case the stride information
  ///      is the canonical form computed from sizes;
  ///   2. a StridedLayoutAttr layout;
  ///   3. any other layout that be converted into a single affine map layout
  ///      of the form `K + k0 * d0 + ... kn * dn`, where K and ki's are
  ///      constants or symbols.
  ///
  /// A stride specification is a list of integer values that are either
  /// static or dynamic (encoded with ShapedType::kDynamic). Strides encode
  /// the distance in the number of elements between successive entries along
  /// a particular dimension.
  LogicalResult getStridesAndOffset(SmallVectorImpl<int64_t> &strides,
                                    int64_t &offset) const;

  /// Wrapper around getStridesAndOffset(SmallVectorImpl<int64_t>, int64_t)
  /// that will assert if the logical result is not succeeded.
  std::pair<SmallVector<int64_t>, int64_t> getStridesAndOffset() const;

  /// Return "true" if the layout is compatible with strided semantics.
  bool isStrided();

  /// Return "true" if the last dimension has a static unit stride. Also
  /// return "true" for types with no strides.
  bool isLastDimUnitStride();
  static constexpr ::llvm::StringLiteral name = "builtin.memref";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using Base::getChecked;
  static MemRefType get(ArrayRef<int64_t> shape, Type elementType, MemRefLayoutAttrInterface layout = {}, Attribute memorySpace = {});
  static MemRefType getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ArrayRef<int64_t> shape, Type elementType, MemRefLayoutAttrInterface layout = {}, Attribute memorySpace = {});
  static MemRefType get(ArrayRef<int64_t> shape, Type elementType, AffineMap map, Attribute memorySpace = {});
  static MemRefType getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ArrayRef<int64_t> shape, Type elementType, AffineMap map, Attribute memorySpace = {});
  static MemRefType get(ArrayRef<int64_t> shape, Type elementType, AffineMap map, unsigned memorySpaceInd);
  static MemRefType getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ArrayRef<int64_t> shape, Type elementType, AffineMap map, unsigned memorySpaceInd);
  static ::llvm::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::llvm::ArrayRef<int64_t> shape, Type elementType, MemRefLayoutAttrInterface layout, Attribute memorySpace);
  static ::llvm::LogicalResult verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::llvm::ArrayRef<int64_t> shape, Type elementType, MemRefLayoutAttrInterface layout, Attribute memorySpace);
  ::llvm::ArrayRef<int64_t> getShape() const;
  Type getElementType() const;
  MemRefLayoutAttrInterface getLayout() const;
  Attribute getMemorySpace() const;
};
class NoneType : public ::mlir::Type::TypeBase<NoneType, ::mlir::Type, ::mlir::TypeStorage> {
public:
  using Base::Base;
  static NoneType get(MLIRContext *context);
  static constexpr ::llvm::StringLiteral name = "builtin.none";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
};
namespace detail {

struct OpaqueTypeStorage;

} // namespace detail
class OpaqueType : public ::mlir::Type::TypeBase<OpaqueType, ::mlir::Type, detail::OpaqueTypeStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "builtin.opaque";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using Base::getChecked;
  static OpaqueType get(StringAttr dialectNamespace, StringRef typeData = {});
  static OpaqueType getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, StringAttr dialectNamespace, StringRef typeData = {});
  static ::llvm::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, StringAttr dialectNamespace, ::llvm::StringRef typeData);
  static ::llvm::LogicalResult verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, StringAttr dialectNamespace, ::llvm::StringRef typeData);
  StringAttr getDialectNamespace() const;
  ::llvm::StringRef getTypeData() const;
};
namespace detail {

struct RankedTensorTypeStorage;

} // namespace detail
class RankedTensorType : public ::mlir::Type::TypeBase<RankedTensorType, TensorType, detail::RankedTensorTypeStorage, ::mlir::ShapedType::Trait, ::mlir::ValueSemantics> {
public:
  using Base::Base;
  using TensorType::clone;
  using ShapedType::Trait<RankedTensorType>::getElementTypeBitWidth;
  using ShapedType::Trait<RankedTensorType>::getRank;
  using ShapedType::Trait<RankedTensorType>::getNumElements;
  using ShapedType::Trait<RankedTensorType>::isDynamicDim;
  using ShapedType::Trait<RankedTensorType>::hasStaticShape;
  using ShapedType::Trait<RankedTensorType>::getNumDynamicDims;
  using ShapedType::Trait<RankedTensorType>::getDimSize;
  using ShapedType::Trait<RankedTensorType>::getDynamicDimIndex;

  /// This is a builder type that keeps local references to arguments.
  /// Arguments that are passed into the builder must outlive the builder.
  class Builder;

  /// Return a clone of this type with the given new element type and the same
  /// shape as this type.
  RankedTensorType clone(::mlir::Type elementType) {
    return ::llvm::cast<RankedTensorType>(cloneWith(getShape(), elementType));
  }

  /// Return a clone of this type without the encoding.
  RankedTensorType dropEncoding() {
    return RankedTensorType::get(getShape(), getElementType());
  }

  /// Return a clone of this type with the given new encoding and the same
  /// shape and element type as this type.
  RankedTensorType cloneWithEncoding(::mlir::Attribute encoding) {
    return RankedTensorType::get(getShape(), getElementType(), encoding);
  }
  static constexpr ::llvm::StringLiteral name = "builtin.tensor";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using Base::getChecked;
  static RankedTensorType get(ArrayRef<int64_t> shape, Type elementType, Attribute encoding = {});
  static RankedTensorType getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ArrayRef<int64_t> shape, Type elementType, Attribute encoding = {});
  static ::llvm::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::llvm::ArrayRef<int64_t> shape, Type elementType, Attribute encoding);
  static ::llvm::LogicalResult verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::llvm::ArrayRef<int64_t> shape, Type elementType, Attribute encoding);
  ::llvm::ArrayRef<int64_t> getShape() const;
  Type getElementType() const;
  Attribute getEncoding() const;
};
class TokenType : public ::mlir::Type::TypeBase<TokenType, ::mlir::Type, ::mlir::TypeStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "builtin.token";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
};
class TupleType : public ::mlir::Type::TypeBase<TupleType, ::mlir::Type, detail::TupleTypeStorage> {
public:
  using Base::Base;
  /// Accumulate the types contained in this tuple and tuples nested within
  /// it. Note that this only flattens nested tuples, not any other container
  /// type, e.g. a tuple<i32, tensor<i32>, tuple<f32, tuple<i64>>> is
  /// flattened to (i32, tensor<i32>, f32, i64)
  void getFlattenedTypes(SmallVectorImpl<Type> &types);

  /// Return the number of held types.
  size_t size() const;

  /// Iterate over the held elements.
  using iterator = ArrayRef<Type>::iterator;
  iterator begin() const { return getTypes().begin(); }
  iterator end() const { return getTypes().end(); }

  /// Return the element type at index 'index'.
  Type getType(size_t index) const {
    assert(index < size() && "invalid index for tuple type");
    return getTypes()[index];
  }
  static constexpr ::llvm::StringLiteral name = "builtin.tuple";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  static TupleType get(::mlir::MLIRContext *context, TypeRange elementTypes);
  static TupleType get(::mlir::MLIRContext *context);
  ArrayRef<Type> getTypes() const;
};
namespace detail {

struct UnrankedMemRefTypeStorage;

} // namespace detail
class UnrankedMemRefType : public ::mlir::Type::TypeBase<UnrankedMemRefType, BaseMemRefType, detail::UnrankedMemRefTypeStorage, ::mlir::PtrLikeTypeInterface::Trait, ::mlir::ShapedType::Trait> {
public:
  using Base::Base;
  using BaseMemRefType::clone;
  using ShapedType::Trait<UnrankedMemRefType>::getElementTypeBitWidth;
  using ShapedType::Trait<UnrankedMemRefType>::getRank;
  using ShapedType::Trait<UnrankedMemRefType>::getNumElements;
  using ShapedType::Trait<UnrankedMemRefType>::isDynamicDim;
  using ShapedType::Trait<UnrankedMemRefType>::hasStaticShape;
  using ShapedType::Trait<UnrankedMemRefType>::getNumDynamicDims;
  using ShapedType::Trait<UnrankedMemRefType>::getDimSize;
  using ShapedType::Trait<UnrankedMemRefType>::getDynamicDimIndex;

  ArrayRef<int64_t> getShape() const { return {}; }

  /// [deprecated] Returns the memory space in old raw integer representation.
  /// New `Attribute getMemorySpace()` method should be used instead.
  unsigned getMemorySpaceAsInt() const;

  /// Return a clone of this type with the given new element type and the same
  /// shape as this type.
  MemRefType clone(::mlir::Type elementType) {
    return ::llvm::cast<MemRefType>(cloneWith(getShape(), elementType));
  }
  static constexpr ::llvm::StringLiteral name = "builtin.unranked_memref";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using Base::getChecked;
  static UnrankedMemRefType get(Type elementType, Attribute memorySpace);
  static UnrankedMemRefType getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, Type elementType, Attribute memorySpace);
  static UnrankedMemRefType get(Type elementType, unsigned memorySpace);
  static UnrankedMemRefType getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, Type elementType, unsigned memorySpace);
  static ::llvm::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, Type elementType, Attribute memorySpace);
  static ::llvm::LogicalResult verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, Type elementType, Attribute memorySpace);
  Type getElementType() const;
  Attribute getMemorySpace() const;
};
namespace detail {

struct UnrankedTensorTypeStorage;

} // namespace detail
class UnrankedTensorType : public ::mlir::Type::TypeBase<UnrankedTensorType, TensorType, detail::UnrankedTensorTypeStorage, ::mlir::ShapedType::Trait, ::mlir::ValueSemantics> {
public:
  using Base::Base;
  using TensorType::clone;
  using ShapedType::Trait<UnrankedTensorType>::getElementTypeBitWidth;
  using ShapedType::Trait<UnrankedTensorType>::getRank;
  using ShapedType::Trait<UnrankedTensorType>::getNumElements;
  using ShapedType::Trait<UnrankedTensorType>::isDynamicDim;
  using ShapedType::Trait<UnrankedTensorType>::hasStaticShape;
  using ShapedType::Trait<UnrankedTensorType>::getNumDynamicDims;
  using ShapedType::Trait<UnrankedTensorType>::getDimSize;
  using ShapedType::Trait<UnrankedTensorType>::getDynamicDimIndex;

  ArrayRef<int64_t> getShape() const { return {}; }
  static constexpr ::llvm::StringLiteral name = "builtin.unranked_tensor";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using Base::getChecked;
  static UnrankedTensorType get(Type elementType);
  static UnrankedTensorType getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, Type elementType);
  static ::llvm::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, Type elementType);
  static ::llvm::LogicalResult verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, Type elementType);
  Type getElementType() const;
};
namespace detail {

struct VectorTypeStorage;

} // namespace detail
class VectorType : public ::mlir::Type::TypeBase<VectorType, Type, detail::VectorTypeStorage, ::mlir::ShapedType::Trait, ::mlir::ValueSemantics> {
public:
  using Base::Base;
  /// This is a builder type that keeps local references to arguments.
  /// Arguments that are passed into the builder must outlive the builder.
  class Builder;

  /// Returns true if the given type can be used as an element of a vector
  /// type. See "Builtin_VectorTypeElementType" for allowed types.
  static bool isValidElementType(Type t);

  /// Returns true if the vector contains scalable dimensions.
  bool isScalable() const {
    return llvm::is_contained(getScalableDims(), true);
  }
  bool allDimsScalable() const {
    // Treat 0-d vectors as fixed size.
    if (getRank() == 0)
      return false;
    return !llvm::is_contained(getScalableDims(), false);
  }

  /// Get the number of scalable dimensions.
  size_t getNumScalableDims() const {
    return llvm::count(getScalableDims(), true);
  }

  /// Get or create a new VectorType with the same shape as `this` and an
  /// element type of bitwidth scaled by `scale`.
  /// Return null if the scaled element type cannot be represented.
  VectorType scaleElementBitwidth(unsigned scale);

  /// Returns if this type is ranked (always true).
  bool hasRank() const { return true; }

  /// Clone this vector type with the given shape and element type. If the
  /// provided shape is `std::nullopt`, the current shape of the type is used.
  VectorType cloneWith(std::optional<ArrayRef<int64_t>> shape,
                       Type elementType) const;
  static constexpr ::llvm::StringLiteral name = "builtin.vector";
  static constexpr ::llvm::StringLiteral dialectName = "builtin";
  using Base::getChecked;
  static VectorType get(ArrayRef<int64_t> shape, Type elementType, ArrayRef<bool> scalableDims = {});
  static VectorType getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ArrayRef<int64_t> shape, Type elementType, ArrayRef<bool> scalableDims = {});
  static ::llvm::LogicalResult verifyInvariantsImpl(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::llvm::ArrayRef<int64_t> shape, ::mlir::Type elementType, ::llvm::ArrayRef<bool> scalableDims);
  static ::llvm::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::llvm::ArrayRef<int64_t> shape, ::mlir::Type elementType, ::llvm::ArrayRef<bool> scalableDims);
  static ::llvm::LogicalResult verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::llvm::ArrayRef<int64_t> shape, ::mlir::Type elementType, ::llvm::ArrayRef<bool> scalableDims);
  ::llvm::ArrayRef<int64_t> getShape() const;
  ::mlir::Type getElementType() const;
  ::llvm::ArrayRef<bool> getScalableDims() const;
};

} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::ComplexType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::Float8E5M2Type)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::Float8E4M3Type)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::Float8E4M3FNType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::Float8E5M2FNUZType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::Float8E4M3FNUZType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::Float8E4M3B11FNUZType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::Float8E3M4Type)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::Float4E2M1FNType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::Float6E2M3FNType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::Float6E3M2FNType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::Float8E8M0FNUType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::BFloat16Type)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::Float16Type)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::FloatTF32Type)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::Float32Type)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::Float64Type)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::Float80Type)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::Float128Type)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::FunctionType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::GraphType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::IndexType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::IntegerType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::MemRefType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NoneType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::OpaqueType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::RankedTensorType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::TokenType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::TupleType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::UnrankedMemRefType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::UnrankedTensorType)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::VectorType)

#endif // GET_TYPEDEF_CLASSES

