# All Classes

- All Classes Interface Summary Class Summary Enum Summary Exception Summary Error Summary Annotation Types Summary
  Class | Description
  --- | ---
  Accessor | Defines an accessor method in a mixin, the method can be a getter (must return the field type and take no arguments) or a setter (must take an argument of the field type and return void).
  AccessorGenerator | Base class for accessor generators
  AccessorGeneratorField | Accessor generator for field accessors
  AccessorGeneratorFieldGetter | Generator for instance field getters
  AccessorGeneratorFieldSetter | Generator for field setters
  AccessorGeneratorMethodProxy | Generator for proxy methods
  AccessorGeneratorObjectFactory | Generator for factory methods (constructor invokers)
  AccessorInfo | Information about an accessor
  AccessorInfo.AccessorName | Accessor Name struct
  AccessorInfo.AccessorType | Accessor types
  ActivityStack | Tracker for processors which want to express their activity stack on crash in a user-readable way.
  AfterInvoke | This injection point searches for INVOKEVIRTUAL, INVOKESTATIC and INVOKESPECIAL opcodes matching its arguments and returns a list of insns after the matching instructions, with special handling for methods invocations which return a value and immediately assign it to a local variable.
  AfterStoreLocal | This injection point is a companion for the `ModifyVariable` injector which searches for STORE operations which match the local variables described by the injector's defined discriminators.
  AnnotatedMethodInfo | Data bundle for an annotated method in a mixin
  Annotations | Utility class for working with ASM annotations
  Annotations.Handle | Wrapper for `AnnotationNode` to support access via common interface
  ArgOffsets | Decoration which stores a linear offset of arguments when a node replacement results in a call to a method with the same arguments as the original (replaced) call but offset by some fixed amount.
  Args | Argument bundle class used in `ModifyArgs` callbacks.
  ArgsClassGenerator | Class generator which creates subclasses of `Args` to be used by the `ModifyArgs` injector.
  ArgumentCountException | Exception thrown when varargs array passed into `Args.setAll(java.lang.Object...)` is of a different length than the args
  ArgumentIndexOutOfBoundsException | Exception thrown when attempting to set an argument (via) `Args` which is out of bounds
  ASM | Utility methods for determining ASM version and other version-specific shenanigans
  At | Annotation for specifying the type of `InjectionPoint` to use to perform an `Inject` process.
  At.Shift | Shift is used to shift resulting opcodes
  BeforeConstant | Special injection point which can be defined by an `Constant` annotation or using the at code `CONSTANT`.
  BeforeFieldAccess | This injection point searches for GETFIELD and PUTFIELD (and static equivalent) opcodes matching its arguments and returns a list of insns immediately prior to matching instructions.
  BeforeFinalReturn | This injection point searches for the last RETURN opcode in the target method and returns it.
  BeforeInvoke | This injection point searches for INVOKEVIRTUAL, INVOKESTATIC and INVOKESPECIAL opcodes matching its arguments and returns a list of insns immediately prior to matching instructions.
  BeforeInvoke.SearchType | Member search type, the `PERMISSIVE` search is only used when refmap remapping is enabled.
  BeforeLoadLocal | This injection point is a companion for the `ModifyVariable` injector which searches for LOAD operations which match the local variables described by the injector's defined discriminators.
  BeforeNew | This injection point searches for NEW opcodes matching its arguments and returns a list of insns immediately prior to matching instructions.
  BeforeReturn | This injection point searches for RETURN opcodes in the target method and returns a list of insns immediately prior to matching instructions.
  BeforeStringInvoke | Like `BeforeInvoke`, this injection point searches for INVOKEVIRTUAL, INVOKESTATIC and INVOKESPECIAL opcodes matching its arguments and returns a list of insns immediately prior to matching instructions.
  Bytecode | Utility methods for working with bytecode via ASM
  Bytecode.DelegateInitialiser | Information bundle returned from `Bytecode.findDelegateInit(org.objectweb.asm.tree.MethodNode, java.lang.String, java.lang.String)`
  Bytecode.Visibility | Ordinal member visibility level.
  CallbackInfo | CallbackInfo instances are passed to callbacks in order to provide information and handling opportunities to the callback to interact with the callback itself.
  CallbackInfoReturnable<R> | For callbacks with a non-void return type, a CallbackInfoReturnable is passed to the callback instead to allow the callback to interact with the method return value.
  CallbackInjectionInfo | Information about a callback to inject, usually specified by `Inject`
  CallbackInjector | This class is responsible for generating the bytecode for injected callbacks, for details of usage see `@Inject`.
  Cancellable | Interface for things which can be cancelled
  CancellationException | Exception thrown when a consumer attemtps to call `cancel()` on a callback not marked as `cancellable`.
  ClassInfo | Information about a class, used as a way of keeping track of class hierarchy information needed to support more complex mixin behaviour such as detached superclass and mixin inheritance.
  ClassInfo.FrameData | Information about frames in a method
  ClassInfo.SearchType | Search type for the findInHierarchy methods, replaces a boolean flag which made calling code difficult to read
  ClassInfo.Traversal | To all intents and purposes, the "real" class hierarchy and the mixin class hierarchy exist in parallel, this means that for some hierarchy validation operations we need to walk across to the other hierarchy in order to allow meaningful validation to occur.
  ClassInfo.TypeLookup | When using `ClassInfo.forType`, determines whether an array type should be returned as declared (eg.
  ClassNodeAdapter | Adapter for ClassNode to access members added after ASM 5
  ClassSignature | Represents an object-oriented view of a generic class signature.
  Coerce | Usage with callback injectors (`@Inject`)
  CommandLineOptions | Options passed in to Mixin via the command line
  Config | Handle for marshalling mixin configs outside of the transformer package
  Constant | Annotation for specifying the injection point for an `ModifyConstant` injector.
  Constant.Condition | Available options for the `Constant.expandZeroConditions()` setting.
  Constants | Miscellaneous shared constants
  Constants.ManifestAttributes | Shared Jar Manifest Attributes
  ConstraintParser | Parser for constraints
  ConstraintParser.Constraint | A constraint.
  Constructor | A `Target` which is a constructor
  ConstructorHead | Like `HEAD`, this injection point can be used to specify the first instruction in a method, but provides special handling for constructors.
  ContainerHandleURI | Container handle which directly replaces the use of classpath location URIs from previous mixin versions
  ContainerHandleVirtual | A virtual container, used to marshal other containers around
  Counter | Mutable integer for use in collections
  Debug | Anotation used to decorate items you might wish to examine after mixin application.
  Desc | A descriptor for matching a target element, for details of usage see `DynamicSelectorDesc`.
  DescriptorResolver | Utility class which contains the logic for resolving descriptors (`Desc` annotations) starting from an element and recursing up the tree of parent elements looking for a matching descriptor
  Descriptors | Collection type for `Desc` to allow `Repeatable` to work.
  Dynamic | Decorator annotation for mixin elements whose targets are not available in the original class and are either fabricated or transformed at runtime.
  DynamicSelectorDesc | A `Target Selector` which matches candidates using descriptors contained in `@Desc` annotations.
  ElementNode<TNode> | Wrapper for all node types supported by `target selectors` (`FieldNode`, `MethodNode`, `FieldInsnNode`, `MethodInsnNode` and `InvokeDynamicInsnNode`) which allows access to common properties of things which are basically "arbitrary node with owner, name and descriptor"
  ElementNode.NodeType | Element node type, returned by `getType` so consumers don't need to do instanceof checks, and allows switching on element type in a more expressive way
  ExtensionCheckClass | Mixin transformer module which runs CheckClassAdapter on the post-mixin bytecode
  ExtensionCheckClass.ValidationFailedException | Exception thrown when checkclass fails
  ExtensionCheckInterfaces | Checks whether interfaces declared on mixin target classes are actually fully implemented and generates reports to the console and to files on disk
  ExtensionClassExporter | Debug exporter
  ExtensionLVTCleaner | Strips synthetic local variables from the LVT after exporting to avoid debuggers becoming confused by them.
  Extensions | Mixin transformer extensions and common modules such as class generators
  FabricUtil |
  Files | Utility class for file operations
  Final | This annotation has two uses: On an `Shadow` field, it can be used to raise an error-level log message if any write occurrences appear in the mixin bytecode.
  GlobalProperties | Access to underlying global property service provided by the current environment
  GlobalProperties.Keys | Global property keys
  Group | This annotation can be used on any injector callback to define a value for total required injections across multiple callbacks.
  Handles | Utility class for working with method and field handles
  IActivityContext |
  IActivityContext.IActivity |
  IAnnotatedElement | Interface for objects which can be annotated since main classes may need to read info from mirror annotations in the AP
  IAnnotationHandle | Interface for annotation handle since some classes may need to read info from both ASM `AnnotationNode`s at runtime and mirror annotations in the AP at compile time.
  IChainedDecoration<T> | An InjectionNode decoration which can chain to a previously registered decoration with the same type and key.
  IClassBytecodeProvider | Interface for object which can provide class bytecode
  IClassGenerator | Base interface for class generators
  IClassProvider | Interface for marshal object which can retrieve classes from the environment
  IClassReferenceMapper |
  IClassTracker | Class trackers are responsible for interacting with the class loading process to for the purposes of tracking class load activity and class load restrictions.
  IConsumer<TItem> | No Java 8 here but I need this interface
  IContainerHandle | Interface for container handles.
  IDecompiler | Interface to allow the actual decompiler to be loaded on-demand
  IEnvironmentTokenProvider | Provides a token value into the attached environment
  IExtension | Mixin Transformer extension interface for pre- and post-processors
  IExtensionRegistry | Interface for the mixin Extensions registry
  IGlobalPropertyService | Global property service
  IHotSwap | Interface to allow the hot-swap agent to be loaded on-demand
  IInjectionPointContext | Context for an injection point, used to access the mixin as well as the owner method and annotation for the injection point
  IInsnListEx | Interface for extensions for InsnList which provide additional context for the InsnList.
  IInsnListEx.SpecialNodeType | Type of special nodes supported by `IInsnListEx.getSpecialNode(org.spongepowered.asm.mixin.injection.code.IInsnListEx.SpecialNodeType)`
  ILegacyClassTransformer | Adapter interface for legacy class transformers.
  ILogger | Interface extracted from Log4j2's Logger (`org.apache.logging.log4j.Logger` ) with only the main methods used by Mixin included.
  IMapping<TMapping> | Base class for member mapping entries
  IMapping.Type | Type of mapping
  IMessageSink | Interface for generic message consumers
  IMixinAuditTrail | Audit trail is responsible for logging activities during mixin application to target classes for use as debugging information later on.
  IMixinConfig | Interface for loaded mixin configurations
  IMixinConfigPlugin | A companion plugin for a mixin configuration object.
  IMixinConfigSource | Interface for loaded mixin configurations
  IMixinConnector | A connector class is a bootstrap agent for a mixin consumer.
  IMixinContext | Context for performing reference mapping
  IMixinErrorHandler | Interface for objects which want to perform custom behaviour when fatal mixin errors occur.
  IMixinErrorHandler.ErrorAction | Action to take when handling an error.
  IMixinInfo | Interface for MixinInfo, used in extensibility API
  IMixinInternal | A mixin internal part, offered to services.
  IMixinPlatformAgent | Base interface for platform agents.
  IMixinPlatformAgent.AcceptResult | Result type returned from `IMixinPlatformAgent.accept(org.spongepowered.asm.launch.platform.MixinPlatformManager, org.spongepowered.asm.launch.platform.container.IContainerHandle)`
  IMixinPlatformServiceAgent | Service agents provide additional platform-specific extensions leveraged by mixin services.
  IMixinService | Mixin Service interface.
  IMixinServiceBootstrap | Bootstrap interface for Mixin services.
  IMixinTransformer | Transformation engine
  IMixinTransformerFactory | Factory for the mixin transformer, concrete instances of this class are only provided to services since only the service should be able to decide when the mixin transformer is initialised.
  Implements | Pseudo-implements decorator for Mixins with conflicting methods in a superclass to soft-implement an interface.
  Initialiser |
  Initialiser.InjectionMode | Strategy for injecting initialiser insns
  Inject | Specifies that this mixin method should inject a callback (or callbacks) to itself in the target method(s) identified by `Inject.method()`.
  InjectionInfo | Contructs information about an injection from an `Inject` annotation and allows the injection to be processed.
  InjectionInfo.AnnotationType | Decoration for subclasses which indicates the injector annotation that the subclass handles
  InjectionInfo.HandlerPrefix | Decoration for subclasses which specifies the prefix to use when conforming annotated handler methods
  InjectionInfo.InjectorOrder | Decoration for subclasses which specifies the order (phase) in which the injector should be applied relative to other injectors.
  InjectionNodes | Used to keep track of instruction nodes in a `Target` method which are targetted by various types of injector.
  InjectionNodes.InjectionNode | A node targetted by one or more injectors.
  InjectionPoint | Base class for injection point discovery classes.
  InjectionPoint.AtCode | Injection point code for `At` annotations to use
  InjectionPoint.Flags | Boolean extensions for the At parser, mainly to avoid having to add many booleans in the future
  InjectionPoint.RestrictTargetLevel | Target restriction level for different injection point types when used by restricted injectors (eg.
  InjectionPoint.Specifier | Additional specifier for injection points.
  InjectionPointAnnotationContext | Specialised SelectorAnnotationContext for injection points
  InjectionPointData | Data read from an `At` annotation and passed into an InjectionPoint ctor
  Injector | Base class for bytecode injectors
  Injector.InjectorData | Redirection data bundle base.
  Injector.TargetNode | A nominated target node
  InjectorGroupInfo | Information store for injector groups
  InjectorGroupInfo.Map | Storage for injector groups
  InjectorTarget | Couples `method slices` to a `Target` for injection purposes.
  InsnFinder | Utility class for finding instructions using static analysis
  InsnListEx | InsnList with extensions, see `IInsnListEx`
  InsnListReadOnly | Read-only wrapper for InsnList, defensively passed to InjectionPoint instances so that custom InjectionPoint implementations cannot modify the insn list whilst inspecting it.
  InsnRange | Struct for representing a range of instructions
  Interface | This annotation is used to define information for a soft-implemented interface.
  Interface.Remap | Describes the remapping strategy applied to methods matching this interface.
  Intrinsic | This annotation allows fine-tuning of the overwrite policy for a soft-implemented interface member method.
  InvalidImplicitDiscriminatorException | Thrown when an implicit discriminator (no args) fails to identify a unique candidate.
  InvalidMemberDescriptorException | Thrown when a `MemberInfo` fails basic syntax validation
  InvalidSelector | Since the contract of `TargetSelector.parse(java.lang.Iterable<?>, org.spongepowered.asm.mixin.injection.selectors.ISelectorContext)` prohibits returing `null`, instances of this selector are returned when supplied arguments are unparseable in order to throw exceptions only during validation.
  InvalidSelectorException | Exception to be thrown from `ITargetSelector.validate()` when a target selector fails verification
  InvokeInjector | Base class for injectors which inject at method invokes
  Invoker | Defines an invoker method (also known as a proxy method in a mixin, the method.
  IPropertyKey | Marker interface for property keys
  IReferenceMapper | Interface for reference mapper objects
  IRemapper | Interface for remap chain participants
  IResolvedDescriptor | A resolved descriptor, or rather the result of resolving a descriptor.
  ISelectorContext | Context passed to a `Target Selector` in order to support context-sensitive behaviour for the selector.
  ISliceContext | Context for a slice declaration
  ISyntheticClassInfo | Interface for information bundle about a synthetic class provided by Mixin.
  ISyntheticClassRegistry | Registry for synthetic classes, used internally to track which classes need to be generated at runtime by the mixin pipeline.
  ITargetClassContext | Interface for target classes passed into transformer modules via `IExtension`
  ITargetSelector | Target Selectors are used to identify target members in a class, with the criteria for selection being specified in a single string, effectively defining the query parameters.
  ITargetSelector.Configure | Available selector reconfigurations
  ITargetSelectorByName | A target selector which selects elements directly by name.
  ITargetSelectorConstructor | A target selector which can identify constructor types
  ITargetSelectorDynamic | Decoration interface for dynamic target selectors
  ITargetSelectorDynamic.SelectorAnnotation | Decoration for subclasses which indicates an annotation type from which the selector can be parsed.
  ITargetSelectorDynamic.SelectorId | Decoration for subclasses which indicates id used for a specific selector when specified, for example `@MyNamespace:MySelector(argshere)` would specify "MySelector"
  ITargetSelectorRemappable | A target selector which can be remapped at compile time via an obfuscation service
  ITokenProvider | Agent which can supply token values to a `ConstraintParser.Constraint`.
  ITransformer | Base interface for transformer types
  ITransformerProvider | Interface for interacting with transforming classloaders.
  ITreeClassTransformer | Adapter interface for tree class transformers.
  JavaVersion | Small helper to resolve the current java version
  JumpInsnPoint | This injection point searches for JUMP opcodes (if, try/catch, continue, break, conditional assignment, etc.) with either a particular opcode or at a particular ordinal in the method body (eg.
  LanguageFeatures | Bitmask values for language features supported.
  Level |
  LocalCapture | Specifies the behaviour for capturing local variables at an injection point.
  Locals | Utility methods for working with local variables using ASM
  Locals.Settings | Settings for `getLocalsAt` containing the tunable options for the algorithm.
  Locals.SyntheticLocalVariableNode | A local variable entry added by mixin itself, eg.
  LocalVariableDiscriminator | Encapsulates logic for identifying a local variable in a target method using 3 criteria: ordinal, index and name.
  LocalVariableDiscriminator.Context | Discriminator context information, wraps all relevant information about a target location for use when performing discrimination
  LoggerAdapterAbstract | Abstract base adapter which contains a convenience class for formatting log4j2-style messages and also routes all level-specific overloads to calls to `log`, which can simplify some implementations.
  LoggerAdapterAbstract.FormattedMessage | This is a very naive implementation of log4j2's `ParameterizedMessage` which is less efficient and less defensive because it doesn't need to handle all the cases that the log4j2 formatter does.
  LoggerAdapterConsole | A very basic logger adapter which does not log anything to file and simply emits formatted log messages to the console printstreams
  LoggerAdapterDefault | Default logger adapter which sinks log messages but doesn't emit them anywhere, used only in cases where no logging framework is available and no logging is desired.
  LoggerAdapterJava | Logger adapter which uses the built-in Java logging functionality to emit logging messages.
  MainAttributes | "Main" attribute cache for a URI container, mainly to avoid constantly opening jar files just to read odd values out of the manifest.
  MappingField | Stores information about a field mapping during AP runs
  MappingFieldSrg | An SRG field mapping
  MappingMethod | Stores information about a method mapping during AP runs
  MarkerNode | A label node used as a marker in the bytecode.
  MatchResult | Result of a `target selector` match operation which describes the type of match.
  MemberInfo | Struct which defines an Explcit Target selector, See `ITargetSelector` for other supported selector types.
  MemberMatcher | A `Target Selector` which matches an element of candidate members using a regular expression.
  MemberRef | Reference to a field or method that also includes invocation instructions.
  MemberRef.Field | A static reference to a field backed by field get/put instruction
  MemberRef.Handle | A reference to a field or method backed by a method handle
  MemberRef.Method | A static reference to a method backed by an invoke instruction
  MessageRouter | Logging router for objects which may need to log messages during standard runtime or during Annotation Processor sessions.
  MethodHead | This injection point simply returns the first instruction in the target method body, allowing the injection to be placed at the "head" of the target method.
  MethodNodeEx | MethodNode with some extra convenience functionality
  MethodSlice | Stores information about a defined method slice for a particular injector.
  MethodSlices | Represents a collection of `MethodSlice`s, mapped by ID.
  MethodVisitorEx | MethodVisitor with some extra convenience functionality
  Mixin | The main decorator for mixin classes, this annotation denotes a class as a mixin and specifies two key attributes: The target classes Every mixin requires at least one target class in order to be valid.
  MixinBootstrap | Bootstraps the mixin subsystem.
  MixinClassGenerator | Handles delegation of class generation tasks to the extensions
  MixinClassReader | A ClassReader which returns a more verbose exception message when the incoming class major version is higher than the version supported by the active ASM.
  MixinClassWriter | ClassWriter which resolves common superclasses using Mixin's metadata instead of calling Class.forName
  MixinConnectorManager | Manager for Mixin containers bootstrapping via `IMixinConnector`
  MixinContainer | A collection of `IMixinPlatformAgent` platform agents) for a particular container
  MixinEnvironment | The mixin environment manages global state information for the mixin subsystem.
  MixinEnvironment.CompatibilityLevel | Operational compatibility level for the mixin subsystem
  MixinEnvironment.Feature | Mixin features which can be specified in mixin configs as required for the config to be valid.
  MixinEnvironment.Option | Mixin options
  MixinEnvironment.Phase | Environment phase, deliberately not implemented as an enum
  MixinEnvironment.Side | Represents a "side", client or dedicated server
  MixinInheritanceTracker |
  MixinInitialisationError | Error raised when mixin subsystem initialisation fails
  MixinInner | Decoration annotation used by the mixin inner class generator to mark inner classes which have been generated from an existing inner class in a mixin
  MixinMerged | For internal use only! Contains small parts.
  MixinPlatformAgentAbstract | Platform agent base class
  MixinPlatformAgentDefault | Default platform agent, handles the mixin manifest keys such as `MixinConfigs` and `MixinTokenProviders`.
  MixinPlatformManager | Handler for platform-specific behaviour required in different mixin environments.
  MixinProxy | Decoration annotation used by postprocessor to mark methods which have had their contents replaced with a proxy.
  MixinRenamed | Internal use only.
  Mixins | Entry point for registering global mixin resources.
  MixinService | Provides access to the service layer which connects the mixin transformer to a particular host environment.
  MixinServiceAbstract | Mixin Service base class
  MixinTargetContext | This object keeps track of data for applying a mixin to a specific target class during a mixin application.
  MixinVerifier | Verifier which handles class info lookups via `ClassInfo`
  ModifyArg | Specifies that this mixin method should inject an argument modifier to itself in the target method(s) identified by `ModifyArg.method()`.
  ModifyArgInjectionInfo | Information about a `ModifyArg` injector
  ModifyArgInjector | A bytecode injector which allows a single argument of a chosen method call to be altered.
  ModifyArgs | Specifies that this mixin method should inject an multi-argument modifier callback to itself in the target method(s) identified by `ModifyArgs.method()`.
  ModifyArgsInjectionInfo | Information about a `ModifyArgs` injector
  ModifyArgsInjector | A bytecode injector which allows a single argument of a chosen method call to be altered.
  ModifyConstant | Specifies that this mixin method should inject a constant modifier callback to itself in the target method(s) identified by `ModifyConstant.method()` at the specified LDC (or specialised const opcode) instruction in order to adjust the constant value returned.
  ModifyConstantInjectionInfo | Information about a constant modifier injector
  ModifyConstantInjector | A bytecode injector which allows a specific constant value to be identified and replaced with a callback.
  ModifyVariable | Specifies that this mixin method should inject a variable modifier callback to itself in the target method(s) identified by `ModifyVariable.method()`.
  ModifyVariableInjectionInfo | Information about a `ModifyVariable` injector
  ModifyVariableInjector | A bytecode injector which allows a single local variable in the target method to be captured and altered.
  Mutable | Use in conjunction with `Final` or `Accessor` to indicate that whilst a target field is final in the target class, mutation within the mixin is intentional.
  Next | See `@Desc.next`
  ObfuscationUtil | Utility methods for obfuscation tasks
  ObfuscationUtil.IClassRemapper | Interface for remapper proxies
  Overwrite | Annotation used to indicate a mixin class member which must overwrite a method in the target class.
  PrettyPrinter | Prints information in a pretty box
  PrettyPrinter.Alignment | Table column alignment
  PrettyPrinter.IPrettyPrintable | Interface for object which supports printing to pretty printer
  Profiler | Performance profiler for Mixin.
  Profiler.Section | Base abstract profiler section.
  Pseudo | A Mixin marked as `@Pseudo` is allowed to target classes which are not available at compile time and may not be available at runtime.
  Quantifier | A regex-style quantifier, specified as a number or pair of numbers in braces.
  Redirect | Specifies that this mixin method should redirect the specified method call, field access or object construction (via the `new` keyword) to the method decorated with this annotation.
  RedirectInjectionInfo | Information about a redirector injector
  RedirectInjector | A bytecode injector which allows a method call, field access or `new` object creation to be redirected to the annotated handler method.
  ReEntranceLock | Re-entrance semaphore used to share re-entrance data with the metadata service
  ReferenceMapper | Stores runtime information allowing field, method and type references which cannot be hard remapped by the reobfuscation process to be remapped in a "soft" manner at runtime.
  RemapperChain | Mixin environment remapper chain.
  RemappingReferenceMapper | This adapter is designed to apply the same remapping used elsewhere in the development chain (RemapperChain) to reference maps.
  SelectorAnnotationContext | Narrowed context for selectors in annotations which are themselves inside a parent annotation, for example @At annotations within a parent @Inject annotation.
  ServiceInitialisationException | Exception thrown when a service fails during initialisation, expected if the service is missing a dependency or is attempting to boot in an incompatible environment
  ServiceNotAvailableError | Error to throw when no service is available in the current environment
  ServiceVersionError | Error to throw when loaded service is out of date or mismatched
  Shadow | Used to indicate a Mixin class member which is acting as a placeholder for a method or field in the target class
  SignaturePrinter | Generates callback signature for callback pretty-print
  Slice | A `Slice` identifies a section of a method to search for injection points.
  SoftOverride | Decorator for methods which override a method in a supermixin which the containing mixin does not directly extend
  SourceMap | Structure which contains information about a SourceDebugExtension SMAP
  SourceMap.File | Defines a source code file within a source map stratum
  SpecialMethodInfo | Information about a special mixin method such as an injector or accessor
  Surrogate | Annotation used to decorate surrogate injector methods.
  SyntheticClassInfo | Information bundle about a synthetic class provided by Mixin
  Target | Information about the current injection target (method) which bundles common injection context with the target method in order to allow injectors to interoperate.
  TargetNotSupportedException | Exception thrown when target selector is not valid for the supplied target context during `ITargetSelector.attach(org.spongepowered.asm.mixin.injection.selectors.ISelectorContext)`
  TargetSelector | Utility class for parsing selectors
  TargetSelector.Result<TNode> | Query result struct
  TargetSelectors |
  TargetSelectors.SelectedMethod | Selected target method, paired with the selector which identified it
  TreeTransformer | Base class for transformers which work with ASM tree model
  Unique | This annotation, when applied to a member method or field in a mixin, indicates that the member should never overwrite a matching member in the target class.
  VersionNumber | Represents a software version number in `major.minor.revision.build` format as a sequence of four shorts packed into a long.