LiteRT for Dart

https://pub.dev/documentation/lite_rt_for_dart/latest/
Admin
LiteRT for Dart provides bindings for LiteRT (formerly TensorFlow Lite) for standalone Dart...
Tokens:30,627
Snippets:327
Trust Score:9.9
Update:2 months ago
Show doc for...
Tokens:
Raw
### String get libTfLiteBasePath

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/libTfLiteBasePath.html

Retrieves the path to the library containing the base LiteRT implementation. Throws an exception if the library has not been initialized.

```APIDOC
## Property: libTfLiteBasePath

### Description
Returns the path to the library which contains the base LiteRT implementation. This property must only be accessed after a successful call to `initLiteRT`.

### Signature
`String get libTfLiteBasePath`

### Exceptions
- **Exception**: Thrown if `initLiteRT` has not been called prior to accessing this property.
```

--------------------------------

### int get address

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter/address.html

Retrieves the memory address of the interpreter instance.

```APIDOC
## int get address

### Description
Returns the memory address of the interpreter instance.

### Signature
`int get address`

### Returns
- **int** - The address of the interpreter.
```

--------------------------------

### String get libTfLiteCoreMLDelegatePath

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/libTfLiteCoreMLDelegatePath.html

Retrieves the path to the library containing the CoreML Delegate for LiteRT. Throws an exception if LiteRT has not been initialized.

```APIDOC
## String get libTfLiteCoreMLDelegatePath

### Description
Returns the path to the library which contains the CoreML Delegate for LiteRT. This property must be accessed only after calling `initLiteRT`.

### Return Type
String

### Exceptions
- Throws an Exception if `initLiteRT` has not been called prior to accessing this property.
```

--------------------------------

### int get zeroPoint

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/QuantizationParams/zeroPoint.html

Retrieves the zero-point value for the quantization parameters.

```APIDOC
## int get zeroPoint

### Description
Returns the integer zero-point value associated with the quantization parameters.

### Signature
`int get zeroPoint`
```

--------------------------------

### String get libTfLiteFlexDelegatePath

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/libTfLiteFlexDelegatePath.html

Retrieves the path to the library containing the Flex Delegate for LiteRT. This property must be accessed only after the library has been initialized via initLiteRT.

```APIDOC
## String get libTfLiteFlexDelegatePath

### Description
Returns the path to the library which contains the Flex Delegate for LiteRT. 

### Usage
Access this property to obtain the path string. Note that an exception will be thrown if the library has not been initialized using `initLiteRT` prior to access.

### Returns
- **String** - The file path to the Flex Delegate library.
```

--------------------------------

### bool get isAllocated

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter/isAllocated.html

Returns true if the interpreter is currently allocated, false otherwise.

```APIDOC
## bool get isAllocated

### Description
Returns a boolean value indicating the allocation status of the interpreter instance.

### Signature
`bool get isAllocated`

### Returns
- **bool** - True if the interpreter is allocated, false otherwise.
```

--------------------------------

### String get name

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Tensor/name.html

Retrieves the name of the tensor element as a Dart String.

```APIDOC
## String get name

### Description
Returns the name of the tensor element.

### Signature
`String get name`

### Returns
- **String**: The name of the tensor element.
```

--------------------------------

### Initialize GpuDelegateV2

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/GpuDelegateV2/GpuDelegateV2.html

Creates a new instance of GpuDelegateV2, defaulting to standard options if none are provided.

```dart
factory GpuDelegateV2({GpuDelegateOptionsV2? options}) {
  if (options == null) {
    return GpuDelegateV2._(
      tfliteGpuDelegateBinding.TfLiteGpuDelegateV2Create(nullptr),
    );
  }
  return GpuDelegateV2._(
      tfliteGpuDelegateBinding.TfLiteGpuDelegateV2Create(options.base));
}
```

--------------------------------

### void initLiteRT(String libraryPath, {String? gpuDelegatelibraryPath, String? coreMLDelegatelibraryPath, String? flexDelegatelibraryPath})

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/initLiteRT.html

Initializes the LiteRT package by setting the paths for the required TensorFlow Lite dynamic libraries and delegates. This must be called before any other package methods.

```APIDOC
## void initLiteRT(String libraryPath, {String? gpuDelegatelibraryPath, String? coreMLDelegatelibraryPath, String? flexDelegatelibraryPath})

### Description
Initializes the LiteRT package. This function must be called before using any other methods of the package to ensure the necessary dynamic libraries are configured.

### Parameters
- **libraryPath** (String) - Required - Path to the TensorFlow Lite dynamic library.
- **gpuDelegatelibraryPath** (String?) - Optional - Path to the TensorFlow Lite GPU delegate dynamic library.
- **coreMLDelegatelibraryPath** (String?) - Optional - Path to the TensorFlow Lite CoreML delegate dynamic library.
- **flexDelegatelibraryPath** (String?) - Optional - Path to the TensorFlow Lite Flex delegate dynamic library.
```

--------------------------------

### Initialize Library and Load Model

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/index.html

Import the package, initialize the plugin with the library path, and load a model from a file.

```dart
import 'package:lite_rt_for_dart/tflite_flutter.dart';

// IMPORTANT: initialize the plugin
initLiteRT("path/to/your/lib_tflite")

// Load a model from file
final interpreter = await Interpreter.fromFile('path/to/your/model.tflite');
```

--------------------------------

### List<int> get shape

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Tensor/shape.html

Retrieves the dimensions of the tensor as a List of integers.

```APIDOC
## Property: shape

### Description
Returns the dimensions of the tensor as a `List<int>`. Each integer in the list represents the size of the corresponding dimension.

### Signature
`List<int> get shape`

### Returns
- **List<int>** - A list containing the size of each dimension of the tensor.
```

--------------------------------

### GpuDelegateV2(GpuDelegateOptionsV2? options)

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/GpuDelegateV2-class.html

Creates a new instance of GpuDelegateV2. If options are not provided, it defaults to GpuDelegateOptionsV2.defaultOptions().

```APIDOC
### Constructor
`GpuDelegateV2({GpuDelegateOptionsV2? options})`

### Description
Creates a GpuDelegateV2 instance. Uses `GpuDelegateOptionsV2.defaultOptions()` if options are not specified.
```

--------------------------------

### Usage of Interpreter.fromFile

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter/Interpreter.fromFile.html

Demonstrates loading a model file from assets and initializing the interpreter.

```dart
final dataFile = await getFile('assets/your_model.tflite');
final interpreter = Interpreter.fromFile(dataFile);

Future<File> getFile(String fileName) async {
  final appDir = await getTemporaryDirectory();
  final appPath = appDir.path;
  final fileOnDevice = File('$appPath/$fileName');
  final rawAssetFile = await rootBundle.load(fileName);
  final rawBytes = rawAssetFile.buffer.asUint8List();
  await fileOnDevice.writeAsBytes(rawBytes, flush: true);
  return fileOnDevice;
}
```

--------------------------------

### get data

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Tensor/data.html

Retrieves the underlying data buffer of the tensor as an unmodifiable Uint8List.

```APIDOC
## Uint8List get data

### Description
Returns the underlying data buffer of the tensor as an unmodifiable view of bytes.

### Returns
- **Uint8List** - The tensor data as a list of bytes.
```

--------------------------------

### double get scale

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/QuantizationParams/scale.html

Retrieves the scale value associated with the quantization parameters.

```APIDOC
## double get scale

### Description
Returns the scale factor used for quantization. This value is a double representing the multiplier applied to the quantized values.

### Signature
`double get scale`
```

--------------------------------

### Initialize GpuDelegate

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/GpuDelegate/GpuDelegate.html

Creates a new GpuDelegate instance using the provided options or default settings if null.

```dart
factory GpuDelegate({GpuDelegateOptions? options}) {
  if (options == null) {
    return GpuDelegate._(
      tfliteGpuDelegateBinding.TFLGpuDelegateCreate(nullptr),
    );
  }
  return GpuDelegate._(tfliteGpuDelegateBinding.TFLGpuDelegateCreate(options.base));
}
```

--------------------------------

### TensorType get type

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Tensor/type.html

Retrieves the data type of the tensor element as a TensorType object.

```APIDOC
## Tensor.type

### Description
Returns the data type of the tensor element. The returned value is an instance of `TensorType`.

### Signature
`TensorType get type`

### Returns
- **TensorType** - The data type of the tensor elements.
```

--------------------------------

### XNNPackDelegate(XNNPackDelegateOptions? options)

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/XNNPackDelegate-class.html

Creates a new instance of the XNNPackDelegate.

```APIDOC
### Constructor
`XNNPackDelegate({XNNPackDelegateOptions? options})`

### Description
Creates a new XNNPackDelegate instance. Optionally accepts XNNPackDelegateOptions to configure the delegate.
```

--------------------------------

### GpuDelegateOptionsV2.new

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/GpuDelegateOptionsV2/GpuDelegateOptionsV2.html

Creates a new instance of GpuDelegateOptionsV2 with specified configuration parameters for GPU inference.

```APIDOC
## GpuDelegateOptionsV2.new

### Description
Creates a GpuDelegateOptionsV2 object with specified parameters to control GPU delegate behavior.

### Parameters
- **isPrecisionLossAllowed** (bool) - Optional - When set to true, the GPU may quantify tensors or downcast values to increase performance. Defaults to false.
- **inferencePreference** (int) - Optional - Preference defined in TfLiteGpuInferenceUsage. Defaults to TFLITE_GPU_INFERENCE_PREFERENCE_FAST_SINGLE_ANSWER.
- **inferencePriority1** (int) - Optional - First priority for inference engine decisions, defined in TfLiteGpuInferencePriority. Defaults to TFLITE_GPU_INFERENCE_PRIORITY_MAX_PRECISION.
- **inferencePriority2** (int) - Optional - Second priority for inference engine decisions. Defaults to TFLITE_GPU_INFERENCE_PRIORITY_AUTO.
- **inferencePriority3** (int) - Optional - Third priority for inference engine decisions. Defaults to TFLITE_GPU_INFERENCE_PRIORITY_AUTO.
- **experimentalFlags** (List<int>) - Optional - List of flags to enable, defined in TfLiteGpuExperimentalFlags. Defaults to [TFLITE_GPU_EXPERIMENTAL_FLAGS_ENABLE_QUANT].
- **maxDelegatePartitions** (int) - Optional - Limits the maximum number of graph partitions to be delegated to the GPU. Defaults to 1.
```

--------------------------------

### void run(Object input, Object output)

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter/run.html

Executes the interpreter using a single input and a single output object.

```APIDOC
## void run(Object input, Object output)

### Description
Executes the interpreter for a single input and output pair. This method maps the provided output to index 0 and invokes the internal runForMultipleInputs method.

### Parameters
- **input** (Object) - The input data for the interpreter.
- **output** (Object) - The output container for the interpreter results.

### Implementation
```dart
void run(Object input, Object output) {
  var map = <int, Object>{};
  map[0] = output;
  runForMultipleInputs([input], map);
}
```
```

--------------------------------

### bool get isDeleted

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter/isDeleted.html

Returns a boolean value indicating if the interpreter instance is deleted.

```APIDOC
## bool get isDeleted

### Description
Returns the deletion status of the interpreter instance.

### Signature
`bool get isDeleted`

### Returns
- **bool** - Returns true if the interpreter is deleted, false otherwise.
```

--------------------------------

### Initialize XNNPackDelegateOptions

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/XNNPackDelegateOptions/XNNPackDelegateOptions.html

Creates a new instance of XNNPackDelegateOptions with a specified number of threads.

```dart
factory XNNPackDelegateOptions({
  int numThreads = 1,
}) {
  final options = calloc<TfLiteXNNPackDelegateOptions>();
  options.ref.num_threads = numThreads;

  return XNNPackDelegateOptions._(options);
}
```

--------------------------------

### List<int> get shape

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/ListShape/shape.html

Retrieves the shape of the list, representing the length of each nested dimension.

```APIDOC
## List<int> get shape

### Description
Returns the shape of the list as a List of integers. If the list is empty, it returns an empty list. For nested lists, it recursively determines the length of each dimension.

### Return Value
- **List<int>** - A list containing the lengths of each dimension of the nested structure.
```

--------------------------------

### Initialize XNNPackDelegate

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/XNNPackDelegate/XNNPackDelegate.html

Creates a new XNNPackDelegate instance, using default settings if no options are provided.

```dart
factory XNNPackDelegate({XNNPackDelegateOptions? options}) {
  if (options == null) {
    return XNNPackDelegate._(
      tfliteBinding.TfLiteXNNPackDelegateCreate(nullptr),
    );
  }
  return XNNPackDelegate._(
      tfliteBinding.TfLiteXNNPackDelegateCreate(options.base));
}
```

--------------------------------

### int get lastNativeInferenceDurationMicroSeconds

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter/lastNativeInferenceDurationMicroSeconds.html

Retrieves the duration of the last native inference performed by the interpreter in microseconds.

```APIDOC
## int get lastNativeInferenceDurationMicroSeconds

### Description
Returns the duration of the last native inference operation in microseconds as an integer.

### Return Value
- **int** - The duration in microseconds.
```

--------------------------------

### Initialize GpuDelegateOptions

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/GpuDelegateOptions/GpuDelegateOptions.html

Factory constructor for creating GpuDelegateOptions with specific configuration parameters.

```dart
factory GpuDelegateOptions({
  bool allowPrecisionLoss = false,
  int waitType = TFLGpuDelegateWaitType.TFLGpuDelegateWaitTypePassive,
  bool enableQuantization = true,
}) {
  final options = calloc<TFLGpuDelegateOptions>();

  options.ref
    ..allow_precision_loss = allowPrecisionLoss
    ..wait_type = waitType
    ..enable_quantization = enableQuantization;

  return GpuDelegateOptions._(options);
}
```

--------------------------------

### int get computeNumElements

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/ListShape/computeNumElements.html

Returns the total number of elements in the list by calculating the product of all dimensions in the shape.

```APIDOC
## computeNumElements

### Description
Calculates and returns the total number of elements in the list by multiplying all values defined in the shape.

### Signature
`int get computeNumElements`

### Returns
- **int**: The total count of elements.
```

--------------------------------

### Usage of Interpreter.fromBuffer

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter/Interpreter.fromBuffer.html

Demonstrates loading a model buffer from assets and initializing the interpreter.

```dart
  final buffer = await getBuffer('assets/your_model.tflite');
  final interpreter = Interpreter.fromBuffer(buffer);

  Future<Uint8List> getBuffer(String filePath) async {
      final rawAssetFile = await rootBundle.load(filePath);
      final rawBytes = rawAssetFile.buffer.asUint8List();
      return rawBytes;
  }
```

--------------------------------

### GpuDelegateOptionsV2 constructor

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/GpuDelegateOptionsV2-class.html

Creates a new instance of GpuDelegateOptionsV2 with configurable inference settings.

```APIDOC
## GpuDelegateOptionsV2({bool isPrecisionLossAllowed, int inferencePreference, int inferencePriority1, int inferencePriority2, int inferencePriority3, List<int> experimentalFlags, int maxDelegatePartitions})

### Description
Creates a GpuDelegateOptionsV2 object to configure GPU delegate behavior.

### Parameters
- **isPrecisionLossAllowed** (bool) - Optional - Whether to allow precision loss.
- **inferencePreference** (int) - Optional - Preference for inference usage.
- **inferencePriority1** (int) - Optional - First priority for inference.
- **inferencePriority2** (int) - Optional - Second priority for inference.
- **inferencePriority3** (int) - Optional - Third priority for inference.
- **experimentalFlags** (List<int>) - Optional - List of experimental flags.
- **maxDelegatePartitions** (int) - Optional - Maximum number of delegate partitions.
```

--------------------------------

### Interpreter.fromFile(File modelFile, {InterpreterOptions? options})

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter/Interpreter.fromFile.html

Creates an Interpreter instance from a provided model file. Throws an ArgumentError if the initialization is unsuccessful.

```APIDOC
## Interpreter.fromFile

### Description
Creates an Interpreter instance from a model file. This factory constructor initializes the interpreter using the specified file path and optional configuration settings.

### Signature
`Interpreter.fromFile(File modelFile, {InterpreterOptions? options})`

### Parameters
- **modelFile** (File) - Required - The model file to be loaded by the interpreter.
- **options** (InterpreterOptions) - Optional - Configuration options for the interpreter instance.

### Throws
- **ArgumentError** - Thrown if the interpreter cannot be created from the provided file.

### Example
```dart
final dataFile = await getFile('assets/your_model.tflite');
final interpreter = Interpreter.fromFile(dataFile);
```
```

--------------------------------

### run

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/IsolateInterpreter-class.html

Executes inference for a single input and output.

```APIDOC
## Future<dynamic> run(Object input, Object output)

### Description
Run for single input and output.

### Parameters
- **input** (Object) - Required - The input data for the model.
- **output** (Object) - Required - The output container for the model results.
```

--------------------------------

### Implementation of createFromFile

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/IsolateInterpreter/createFromFile.html

The internal implementation of the createFromFile method which delegates to the private _create method.

```dart
static Future<IsolateInterpreter> createFromFile(File? file, {
  String debugName = 'TfLiteInterpreterIsolate',
  InterpreterOptions? options
}) async => await _create(file, null, null, debugName, options: options);
```

--------------------------------

### Initialize CoreMlDelegate

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/CoreMlDelegate/CoreMlDelegate.html

Creates a new instance of CoreMlDelegate using the provided options or default settings.

```dart
factory CoreMlDelegate({CoreMlDelegateOptions? options}) {
  final delegateOptions = options ?? CoreMlDelegateOptions();

  return CoreMlDelegate._(
    tfliteCoreMLDelegateBinding.TfLiteCoreMlDelegateCreate(delegateOptions.base),
  );
}
```

--------------------------------

### CoreMlDelegateOptions.new

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/CoreMlDelegateOptions/CoreMlDelegateOptions.html

Creates a new instance of CoreMlDelegateOptions with specified configuration parameters for the Core ML delegate.

```APIDOC
## CoreMlDelegateOptions.new

### Description
Creates a new configuration object for the Core ML delegate, which is used to enable hardware acceleration on iOS devices.

### Constructor Signature
CoreMlDelegateOptions({
  int enabledDevices = TfLiteCoreMlDelegateEnabledDevices.TfLiteCoreMlDelegateDevicesWithNeuralEngine,
  int coremlVersion = 0,
  int maxDelegatedPartitions = 0,
  int minNodesPerPartition = 2
})

### Parameters
- **enabledDevices** (int) - Optional - Specifies which devices are enabled for delegation. Defaults to TfLiteCoreMlDelegateDevicesWithNeuralEngine.
- **coremlVersion** (int) - Optional - Sets the Core ML version. Defaults to 0.
- **maxDelegatedPartitions** (int) - Optional - Sets the maximum number of partitions to be delegated. Defaults to 0.
- **minNodesPerPartition** (int) - Optional - Sets the minimum number of nodes required per partition. Defaults to 2.
```

--------------------------------

### GpuDelegateOptions.new

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/GpuDelegateOptions/GpuDelegateOptions.html

Creates a new instance of GpuDelegateOptions with specified configuration parameters for the GPU delegate.

```APIDOC
## GpuDelegateOptions.new

### Description
Creates a new GpuDelegateOptions object to configure GPU delegate behavior for LiteRT.

### Constructor Signature
```dart
GpuDelegateOptions({
  bool allowPrecisionLoss = false,
  int waitType = TFLGpuDelegateWaitType.TFLGpuDelegateWaitTypePassive,
  bool enableQuantization = true,
})
```

### Parameters
- **allowPrecisionLoss** (bool) - Optional - Whether to allow precision loss (default: false).
- **waitType** (int) - Optional - The wait type for the GPU delegate, using TFLGpuDelegateWaitType constants (default: TFLGpuDelegateWaitType.TFLGpuDelegateWaitTypePassive).
- **enableQuantization** (bool) - Optional - Whether to enable quantization (default: true).
```

--------------------------------

### Implementation of Interpreter.fromFile

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter/Interpreter.fromFile.html

The internal factory implementation that creates the model and interpreter instances.

```dart
factory Interpreter.fromFile(File modelFile, {InterpreterOptions? options}) {
  final model = Model.fromFile(modelFile.path);
  final interpreter = Interpreter._create(model, options: options);
  model.delete();
  return interpreter;
}
```

--------------------------------

### InterpreterOptions()

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/InterpreterOptions-class.html

Creates a new instance of InterpreterOptions.

```APIDOC
### InterpreterOptions()

Creates a new options instance for the TensorFlow Lite interpreter.
```

--------------------------------

### InterpreterOptions.fromAddress

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/InterpreterOptions/InterpreterOptions.fromAddress.html

Creates an instance of InterpreterOptions from a raw pointer address.

```APIDOC
## InterpreterOptions.fromAddress

### Signature
`InterpreterOptions.fromAddress(int address)`

### Description
Creates an instance of InterpreterOptions from a raw pointer address.

### Parameters
- **address** (int) - The raw pointer address to initialize the InterpreterOptions instance.
```

--------------------------------

### CoreMlDelegate.new

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/CoreMlDelegate/CoreMlDelegate.html

Creates a new instance of the CoreMlDelegate, optionally accepting CoreMlDelegateOptions to configure the delegate behavior.

```APIDOC
## CoreMlDelegate.new

### Description
Initializes a new CoreMlDelegate instance. If no options are provided, default CoreMlDelegateOptions are used.

### Signature
CoreMlDelegate({CoreMlDelegateOptions? options})

### Parameters
- **options** (CoreMlDelegateOptions) - Optional - Configuration options for the Core ML delegate.
```

--------------------------------

### initLiteRT

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart

Initializes the LiteRT library. This function must be called before using any other methods of the package.

```APIDOC
## initLiteRT(String libraryPath, {String? gpuDelegatelibraryPath, String? coreMLDelegatelibraryPath, String? flexDelegatelibraryPath})

### Description
Initializes the LiteRT library. This function must be called before using any methods of this package.

### Parameters
- **libraryPath** (String) - Required - The path to the base LiteRT library.
- **gpuDelegatelibraryPath** (String?) - Optional - The path to the GPU delegate library.
- **coreMLDelegatelibraryPath** (String?) - Optional - The path to the CoreML delegate library.
- **flexDelegatelibraryPath** (String?) - Optional - The path to the Flex delegate library.
```

--------------------------------

### Implementation of createFromAddress

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/IsolateInterpreter/createFromAddress.html

The internal implementation of the createFromAddress method which delegates to the private _create method.

```dart
static Future<IsolateInterpreter> createFromAddress(int? address, {
  String debugName = 'TfLiteInterpreterIsolate',
  InterpreterOptions? options
}) async => await _create(null, null, address, debugName, options: options);
```

--------------------------------

### GpuDelegateOptions constructor

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/GpuDelegateOptions-class.html

Creates a new instance of GpuDelegateOptions with specified configuration parameters.

```APIDOC
### GpuDelegateOptions(bool allowPrecisionLoss, int waitType, bool enableQuantization)

#### Description
Initializes a new GpuDelegateOptions object to configure the Metal delegate.

#### Parameters
- **allowPrecisionLoss** (bool) - Optional - Whether to allow precision loss. Defaults to false.
- **waitType** (int) - Optional - The wait type for the delegate, using TFLGpuDelegateWaitType constants. Defaults to TFLGpuDelegateWaitType.TFLGpuDelegateWaitTypePassive.
- **enableQuantization** (bool) - Optional - Whether to enable quantization. Defaults to true.
```

--------------------------------

### XNNPackDelegateOptions(int numThreads)

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/XNNPackDelegateOptions-class.html

Creates an instance of XNNPackDelegateOptions with the specified number of threads.

```APIDOC
## XNNPackDelegateOptions(int numThreads)

### Description
Constructs a new XNNPackDelegateOptions object to configure the XNNPack delegate.

### Parameters
- **numThreads** (int) - Optional - The number of threads to use for execution. Defaults to 1.
```

--------------------------------

### Initialize CoreMlDelegateOptions

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/CoreMlDelegateOptions/CoreMlDelegateOptions.html

This factory constructor allocates memory for delegate options and sets the specified configuration parameters.

```dart
factory CoreMlDelegateOptions({
  int enabledDevices = TfLiteCoreMlDelegateEnabledDevices
      .TfLiteCoreMlDelegateDevicesWithNeuralEngine,
  int coremlVersion = 0,
  int maxDelegatedPartitions = 0,
  int minNodesPerPartition = 2,
}) {
  final options = calloc<TfLiteCoreMlDelegateOptions>();

  options.ref
    ..enabled_devices = enabledDevices
    ..coreml_version = coremlVersion
    ..max_delegated_partitions = maxDelegatedPartitions
    ..min_nodes_per_partition = minNodesPerPartition;

  return CoreMlDelegateOptions._(options);
}
```

--------------------------------

### Delegate()

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Delegate-class.html

Constructor for the Delegate class.

```APIDOC
## Delegate()

### Description
Creates a new instance of a Delegate.
```

--------------------------------

### Interpreter.fromBuffer(Uint8List buffer, {InterpreterOptions? options})

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter/Interpreter.fromBuffer.html

Creates an interpreter instance from a provided model buffer. Throws an ArgumentError if the initialization is unsuccessful.

```APIDOC
## Interpreter.fromBuffer

### Description
Creates an interpreter instance from a `Uint8List` buffer containing the model data. This is a factory constructor used to load models directly from memory.

### Signature
`Interpreter.fromBuffer(Uint8List buffer, {InterpreterOptions? options})`

### Parameters
- **buffer** (Uint8List) - Required - The model data as a byte array.
- **options** (InterpreterOptions) - Optional - Configuration options for the interpreter.

### Example
```dart
final buffer = await getBuffer('assets/your_model.tflite');
final interpreter = Interpreter.fromBuffer(buffer);
```
```

--------------------------------

### GpuDelegate constructor

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/GpuDelegate-class.html

Creates a new instance of the GpuDelegate, optionally accepting GpuDelegateOptions.

```APIDOC
### GpuDelegate({GpuDelegateOptions? options})

Creates a new GpuDelegate instance. 

- **options** (GpuDelegateOptions) - Optional - Configuration options for the GPU delegate.
```

--------------------------------

### void addDelegate(Delegate delegate)

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/InterpreterOptions/addDelegate.html

Adds a specified delegate to the InterpreterOptions instance to configure hardware acceleration for the interpreter.

```APIDOC
## void addDelegate(Delegate delegate)

### Description
Adds a delegate to the InterpreterOptions. This is used to configure the interpreter to use specific hardware acceleration backends.

### Parameters
- **delegate** (Delegate) - Required - The delegate instance to be added to the interpreter options.
```

--------------------------------

### libTfLiteGPUDelegatePath

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/libTfLiteGPUDelegatePath.html

Accesses the path to the GPU Delegate library. Throws an exception if LiteRT has not been initialized.

```APIDOC
## String get libTfLiteGPUDelegatePath

### Description
Returns the path to the library which contains the GPU Delegate for LiteRT. This property must only be accessed after calling `initLiteRT`.

### Returns
- **String**: The file path to the GPU Delegate library.

### Throws
- **Exception**: Throws an exception if `initLiteRT` has not been called prior to accessing this property.
```

--------------------------------

### CoreMlDelegate constructor

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/CoreMlDelegate-class.html

Creates a new instance of the CoreMlDelegate, optionally accepting CoreMlDelegateOptions.

```APIDOC
## CoreMlDelegate({CoreMlDelegateOptions? options})

### Description
Creates a new instance of the CoreMlDelegate. This factory constructor initializes the delegate with the provided options.

### Parameters
- **options** (CoreMlDelegateOptions) - Optional - Configuration options for the Core ML delegate.
```

--------------------------------

### Interpreter Constructors

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter-class.html

Methods to instantiate an Interpreter from different sources.

```APIDOC
## Interpreter Constructors

### Interpreter.fromBuffer(Uint8List buffer, {InterpreterOptions? options})
Creates an interpreter from a byte buffer.

### Interpreter.fromFile(File modelFile, {InterpreterOptions? options})
Creates an interpreter from a model file.

### Interpreter.fromAddress(int address, {bool allocated = false, bool deleted = false})
Creates an interpreter from a native memory address.
```

--------------------------------

### Initialize QuantizationParams

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/QuantizationParams/QuantizationParams.html

Use this constructor to create a new instance of QuantizationParams with the specified scale and zero-point values.

```dart
QuantizationParams(this._scale, this._zeroPoint);
```

--------------------------------

### Implementation of Interpreter.fromBuffer

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter/Interpreter.fromBuffer.html

The internal factory implementation that creates a model from the buffer and initializes the interpreter.

```dart
factory Interpreter.fromBuffer(Uint8List buffer,
    {InterpreterOptions? options}) {
  final model = Model.fromBuffer(buffer);
  final interpreter = Interpreter._create(model, options: options);
  model.delete();
  return interpreter;
}
```

--------------------------------

### Implementation of createFromBuffer

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/IsolateInterpreter/createFromBuffer.html

The internal implementation of the createFromBuffer method, which delegates to the private _create method.

```dart
static Future<IsolateInterpreter> createFromBuffer(Uint8List? buffer, {
  String debugName = 'TfLiteInterpreterIsolate',
  InterpreterOptions? options
}) async => await _create(null, buffer, null, debugName, options: options);
```

--------------------------------

### Implementation of initLiteRT

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/initLiteRT.html

The internal implementation of the initLiteRT function, which assigns library paths and initializes the Android Flex delegate if provided.

```dart
void initLiteRT(String libraryPath, {
    String? gpuDelegatelibraryPath,
    String? coreMLDelegatelibraryPath,
    String? flexDelegatelibraryPath,
  }){

  _libTfLiteBasePath           = libraryPath;
  _libTfLiteGPUDelegatePath    = gpuDelegatelibraryPath;
  _libTfLiteCoreMLDelegatePath = coreMLDelegatelibraryPath;
  _libTfLiteFlexDelegatePath   = flexDelegatelibraryPath;

  if(Platform.isAndroid && _libTfLiteFlexDelegatePath != null){
    initAndroidFlexDelegate(_libTfLiteFlexDelegatePath!);
  }

}
```

--------------------------------

### Accessing libTfLiteGPUDelegatePath

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/libTfLiteGPUDelegatePath.html

Retrieves the path to the GPU Delegate library. Throws an exception if LiteRT has not been initialized via initLiteRT.

```dart
String get libTfLiteGPUDelegatePath {

  if(_libTfLiteGPUDelegatePath == null){
    throw Exception("LiteRT has not been initialized! Run `initLiteRT` first!");
  }

  return _libTfLiteGPUDelegatePath!;
}
```

--------------------------------

### Implement GpuDelegateOptionsV2 factory constructor

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/GpuDelegateOptionsV2/GpuDelegateOptionsV2.html

The factory constructor initializes the GPU delegate options by allocating memory and mapping Dart parameters to the underlying C structure.

```dart
factory GpuDelegateOptionsV2({
  bool isPrecisionLossAllowed = false,
  int inferencePreference = TfLiteGpuInferenceUsage
      .TFLITE_GPU_INFERENCE_PREFERENCE_FAST_SINGLE_ANSWER,
  int inferencePriority1 =
      TfLiteGpuInferencePriority.TFLITE_GPU_INFERENCE_PRIORITY_MAX_PRECISION,
  int inferencePriority2 =
      TfLiteGpuInferencePriority.TFLITE_GPU_INFERENCE_PRIORITY_AUTO,
  int inferencePriority3 =
      TfLiteGpuInferencePriority.TFLITE_GPU_INFERENCE_PRIORITY_AUTO,
  List<int> experimentalFlags = const [
    TfLiteGpuExperimentalFlags.TFLITE_GPU_EXPERIMENTAL_FLAGS_ENABLE_QUANT
  ],
  int maxDelegatePartitions = 1,
}) {
  final options = calloc<TfLiteGpuDelegateOptionsV2>();
  options.ref
    ..is_precision_loss_allowed = isPrecisionLossAllowed ? 1 : 0
    ..inference_preference = inferencePreference
    ..inference_priority1 = inferencePriority1
    ..inference_priority2 = inferencePriority2
    ..inference_priority3 = inferencePriority3
    ..experimental_flags =
        _TfLiteGpuExperimentalFlagsUtil.getBitmask(experimentalFlags)
    ..max_delegated_partitions = maxDelegatePartitions;

  return GpuDelegateOptionsV2._(options);
}
```

--------------------------------

### Interpreter.fromAddress Implementation

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter/Interpreter.fromAddress.html

The factory constructor initializes an Interpreter from a pointer address, setting the allocated and deleted status flags.

```dart
factory Interpreter.fromAddress(int address,
    {bool allocated = false, bool deleted = false}) {
  final interpreter = Pointer<TfLiteInterpreter>.fromAddress(address);
  return Interpreter._(interpreter)
    .._deleted = deleted
    .._allocated = allocated;
}
```

--------------------------------

### Configuration Properties

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/InterpreterOptions-class.html

Properties to configure interpreter behavior such as threading and hardware acceleration.

```APIDOC
### Properties

- **threads** (int) - Sets the number of CPU threads to use.
- **useMetalDelegateForIOS** (bool) - Set true to use Metal Delegate for iOS.
- **useNnApiForAndroid** (bool) - Set true to use NnApi Delegate for Android (TensorFlow version >= v2.2).
```

--------------------------------

### QuantizationParams constructor

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/QuantizationParams-class.html

Creates a new instance of QuantizationParams with the specified scale and zero-point values.

```APIDOC
## QuantizationParams(double scale, int zeroPoint)

### Description
Initializes a new QuantizationParams object with the provided scale and zero-point values.

### Parameters
- **scale** (double) - The scale factor for quantization.
- **zeroPoint** (int) - The zero-point value for quantization.
```

--------------------------------

### IsolateInterpreter.createFromAddress

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/IsolateInterpreter/createFromAddress.html

Instantiates an isolate interpreter from an already existing interpreter's address.

```APIDOC
## static Future<IsolateInterpreter> createFromAddress(int? address, {String debugName = 'TfLiteInterpreterIsolate', InterpreterOptions? options})

### Description
Instantiates an isolate interpreter from an already existing interpreter's address.

### Parameters
- **address** (int?) - Required - The memory address of the existing interpreter.
- **debugName** (String) - Optional - A name for debugging purposes, defaults to 'TfLiteInterpreterIsolate'.
- **options** (InterpreterOptions?) - Optional - Configuration options for the interpreter.

### Returns
- **Future<IsolateInterpreter>** - A future that completes with the created IsolateInterpreter instance.
```

--------------------------------

### Create InterpreterOptions from a raw pointer address

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/InterpreterOptions/InterpreterOptions.fromAddress.html

Use this factory constructor to instantiate InterpreterOptions when you have a raw memory address.

```dart
factory InterpreterOptions.fromAddress(int address) {
  return InterpreterOptions._(Pointer.fromAddress(address));
}
```

--------------------------------

### Generate FFI Bindings

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/index.html

Use the melos command to trigger ffigen for generating FFI bindings.

```bash
melos run ffigen
```

--------------------------------

### Interpreter.fromAddress(int address, {bool allocated, bool deleted})

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter/Interpreter.fromAddress.html

Creates an Interpreter instance from a raw memory address. This is primarily used for inter-isolate communication.

```APIDOC
## Interpreter.fromAddress

### Description
Creates an interpreter instance from a provided memory address. This is typically used for passing an interpreter between isolates.

### Signature
`Interpreter.fromAddress(int address, {bool allocated = false, bool deleted = false})`

### Parameters
- **address** (int) - Required - The memory address of the TfLiteInterpreter pointer.
- **allocated** (bool) - Optional - Indicates if the interpreter is allocated. Defaults to false.
- **deleted** (bool) - Optional - Indicates if the interpreter is marked as deleted. Defaults to false.
```

--------------------------------

### runForMultipleInputs(List<Object> inputs, Map<int, Object> outputs)

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter/runForMultipleInputs.html

Executes model inference using a list of input objects and populates the provided map with output tensors.

```APIDOC
## runForMultipleInputs

### Description
Runs inference for multiple inputs and maps the output tensors to the provided output map.

### Signature
`void runForMultipleInputs(List<Object> inputs, Map<int, Object> outputs)`

### Parameters
- **inputs** (List<Object>) - The list of input data objects for the model.
- **outputs** (Map<int, Object>) - A map where keys are output indices and values are the objects to store the output tensors.

### Errors
- Throws `ArgumentError` if the `outputs` map is empty.
```

--------------------------------

### QuantizationParams(double scale, int zeroPoint)

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/QuantizationParams/QuantizationParams.html

Initializes a new instance of QuantizationParams with the specified scale and zero-point values.

```APIDOC
## QuantizationParams(double scale, int zeroPoint)

### Description
Creates a new instance of the QuantizationParams class. This is used to define the quantization parameters for a tensor.

### Parameters
- **scale** (double) - The scale factor used for quantization.
- **zeroPoint** (int) - The zero-point value used for quantization.

### Implementation
```dart
QuantizationParams(this._scale, this._zeroPoint);
```
```

--------------------------------

### Static Utility Methods

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Tensor-class.html

Static methods for calculating tensor dimensions, shapes, and data types.

```APIDOC
## Static Methods

- **computeNumDimensions(Object? o)** -> int: Returns the number of dimensions of a multi-dimensional array.
- **computeNumElements(List<int> shape)** -> int: Returns the number of elements in a flattened (1-D) view of the tensor's shape.
- **computeShapeOf(Object o)** -> List<int>: Returns shape of an object as an int list.
- **dataTypeOf(Object o)** -> int: Returns data type of given object.
```

--------------------------------

### base property

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/XNNPackDelegateOptions/base.html

Retrieves the pointer to the TfLiteXNNPackDelegateOptions structure.

```APIDOC
## Property: base

### Description
Returns the underlying pointer to the `TfLiteXNNPackDelegateOptions` structure used by the XNNPack delegate.

### Signature
`Pointer<TfLiteXNNPackDelegateOptions> get base`

### Returns
- **Pointer<TfLiteXNNPackDelegateOptions>** - A pointer to the delegate options configuration.
```

--------------------------------

### useMetalDelegateForIOS(bool useMetal)

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/InterpreterOptions/useMetalDelegateForIOS.html

Sets whether to use the Metal Delegate for iOS. When set to true, the interpreter adds a GpuDelegate to the execution pipeline if the platform is iOS.

```APIDOC
## useMetalDelegateForIOS(bool useMetal)

### Description
Enables or disables the Metal Delegate for iOS inference acceleration. When enabled, the interpreter utilizes the GPU for processing.

### Parameters
- **useMetal** (bool) - Required - Set to true to enable the Metal Delegate on iOS devices.
```

--------------------------------

### Future runForMultipleInputs(List<Object> inputs, Map<int, Object> outputs)

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/IsolateInterpreter/runForMultipleInputs.html

Executes the interpreter function for multiple inputs and outputs by sending a message to the isolate port and awaiting the result.

```APIDOC
## runForMultipleInputs

### Description
Runs the interpreter for multiple inputs and outputs. This method communicates with the isolate to perform the operation and returns the result asynchronously.

### Signature
`Future<dynamic> runForMultipleInputs(List<Object> inputs, Map<int, Object> outputs)`

### Parameters
- **inputs** (List<Object>) - A list of input objects to be processed by the interpreter.
- **outputs** (Map<int, Object>) - A map representing the output indices and their corresponding objects.

### Returns
- **Future<dynamic>** - A future that completes with the result of the interpreter execution.
```

--------------------------------

### void delete()

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/XNNPackDelegateOptions/delete.html

Deletes the XNNPackDelegateOptions instance, freeing the underlying memory. Throws a StateError if the instance has already been deleted.

```APIDOC
## void delete()

### Description
Frees the memory allocated for the XNNPackDelegateOptions object. This method should be called when the options are no longer needed to prevent memory leaks.

### Signature
`void delete()`

### Behavior
- Checks if the object has already been deleted; if so, it throws a StateError.
- Frees the native memory associated with the options.
- Sets the internal deleted state to true.
```

--------------------------------

### set useNnApiForAndroid(bool useNnApi)

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/InterpreterOptions/useNnApiForAndroid.html

Sets whether to use the NNAPI delegate for Android acceleration. This is only applicable on Android platforms.

```APIDOC
## set useNnApiForAndroid(bool useNnApi)

### Description
Enables or disables the use of the NNAPI delegate for hardware acceleration on Android devices. This requires TensorFlow Lite version 2.2 or higher.

### Parameters
- **useNnApi** (bool) - Required - Set to true to enable the NNAPI delegate, false to disable it.
```

--------------------------------

### Accessing libTfLiteBasePath

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/libTfLiteBasePath.html

Retrieves the path to the LiteRT base library. Throws an exception if the library has not been initialized.

```dart
String get libTfLiteBasePath {

  if(_libTfLiteBasePath == null){
    throw Exception("LiteRT has not been initialized! Run `initLiteRT` first!");
  }

  return _libTfLiteBasePath!;
}
```

--------------------------------

### runInference(List<Object> inputs)

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter/runInference.html

Executes the inference process for the loaded model using the provided list of input objects. This method automatically manages tensor resizing and memory allocation if necessary.

```APIDOC
## void runInference(List<Object> inputs)

### Description
Runs model inference using the provided input data. This method validates inputs, resizes tensors if the input shape differs from the current tensor shape, allocates memory if not already allocated, and invokes the native inference engine.

### Parameters
- **inputs** (List<Object>) - Required - A list of input data objects to be processed by the model.

### Throws
- **ArgumentError** - Thrown if the provided inputs list is null or empty.
```

--------------------------------

### Implementation of runForMultipleInputs

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/IsolateInterpreter/runForMultipleInputs.html

This method sends the runForMultipleInputs command to the isolate port with the provided inputs and outputs, then returns the result from the isolate message queue.

```dart
Future<dynamic> runForMultipleInputs(
  List<Object> inputs, Map<int, Object> outputs) async {
  _sendToIsolatePort.send(IsolateInterpreterFunctionArguments(
    name: InterpreterFunctionNames.runForMultipleInputs,
    positionalArguments: [inputs, outputs]
  ));

  return (await isolateMessageQueue.next);
}
```

--------------------------------

### Accessing libTfLiteFlexDelegatePath

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/libTfLiteFlexDelegatePath.html

Retrieves the path to the Flex Delegate library. Throws an exception if LiteRT has not been initialized via initLiteRT.

```dart
String get libTfLiteFlexDelegatePath {

  if(_libTfLiteFlexDelegatePath == null){
    throw Exception("LiteRT has not been initialized! Run `initLiteRT` first!");
  }

  return _libTfLiteFlexDelegatePath!;
}
```

--------------------------------

### void invoke()

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter/invoke.html

Runs inference for the loaded graph. This method requires the interpreter to be allocated before it is called.

```APIDOC
## void invoke()

### Description
Runs inference for the loaded graph. This method triggers the execution of the TensorFlow Lite model using the currently allocated interpreter.

### Signature
`void invoke()`

### Requirements
- The interpreter must be allocated before calling this method. If not allocated, it will throw an error.
```

--------------------------------

### Implementation of setTo method

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Tensor/setTo.html

This method handles memory allocation, data conversion, and the native call to copy buffer data into the tensor.

```dart
void setTo(Object src) {
  Uint8List bytes = _convertObjectToBytes(src);
  int size = bytes.length;
  final ptr = calloc<Uint8>(size);
  checkState(isNotNull(ptr), message: 'unallocated');
  final externalTypedData = ptr.asTypedList(size);
  externalTypedData.setRange(0, bytes.length, bytes);
  try {
    checkState(tfliteBinding.TfLiteTensorCopyFromBuffer(
            _tensor, ptr.cast(), bytes.length) ==
        TfLiteStatus.kTfLiteOk);
  } catch (_) {
    rethrow;
  } finally {
    calloc.free(ptr);
  }
}
```

--------------------------------

### Implementation of runInference

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter/runInference.html

This method validates inputs, resizes tensors if necessary, allocates memory, and invokes the native inference engine.

```dart
void runInference(List<Object> inputs) {
  if (inputs.isEmpty) {
    throw ArgumentError('Input error: Inputs should not be null or empty.');
  }

  var inputTensors = getInputTensors();

  for (int i = 0; i < inputs.length; i++) {
    var tensor = inputTensors.elementAt(i);
    final newShape = tensor.getInputShapeIfDifferent(inputs[i]);
    if (newShape != null) {
      resizeInputTensor(i, newShape);
    }
  }

  if (!_allocated) {
    allocateTensors();
    _allocated = true;
  }

  inputTensors = getInputTensors();
  for (int i = 0; i < inputs.length; i++) {
    inputTensors.elementAt(i).setTo(inputs[i]);
  }

  var inferenceStartNanos = DateTime.now().microsecondsSinceEpoch;
  invoke();
  _lastNativeInferenceDurationMicroSeconds =
      DateTime.now().microsecondsSinceEpoch - inferenceStartNanos;
}
```

--------------------------------

### IsolateInterpreter.createFromFile

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/IsolateInterpreter/createFromFile.html

Instantiates an isolate interpreter from a .tflite model provided as a File object.

```APIDOC
## Future<IsolateInterpreter> createFromFile(File? file, {String debugName = 'TfLiteInterpreterIsolate', InterpreterOptions? options})

### Description
Instantiates an isolate interpreter from a .tflite model as a `File` object.

### Parameters
- **file** (File?) - Required - The .tflite model file.
- **debugName** (String) - Optional - A name for the isolate, defaults to 'TfLiteInterpreterIsolate'.
- **options** (InterpreterOptions?) - Optional - Configuration options for the interpreter.
```

--------------------------------

### runInference(List<Object> inputs)

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/IsolateInterpreter/runInference.html

Executes model inference using the provided inputs. This method does not return a result.

```APIDOC
## runInference

### Description
Executes model inference using the provided inputs. This method runs the inference process in an isolate and does not return a result.

### Signature
`Future<void> runInference(List<Object> inputs)`

### Parameters
- **inputs** (List<Object>) - Required - The list of input objects to be used for the inference process.
```

--------------------------------

### Implement useMetalDelegateForIOS

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/InterpreterOptions/useMetalDelegateForIOS.html

Sets the Metal delegate for iOS platforms by checking the current operating system and adding a GpuDelegate.

```dart
set useMetalDelegateForIOS(bool useMetal) {
  if (Platform.isIOS) {
    addDelegate(GpuDelegate());
  }
}
```

--------------------------------

### Accessing libTfLiteCoreMLDelegatePath

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/libTfLiteCoreMLDelegatePath.html

Retrieves the path to the CoreML Delegate library. Throws an exception if LiteRT has not been initialized via initLiteRT.

```dart
String get libTfLiteCoreMLDelegatePath {

  if(_libTfLiteCoreMLDelegatePath == null){
    throw Exception("LiteRT has not been initialized! Run `initLiteRT` first!");
  }

  return _libTfLiteCoreMLDelegatePath!;
}
```

--------------------------------

### Accessing the base property

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/XNNPackDelegateOptions/base.html

Retrieves the underlying pointer for the XNNPack delegate options.

```dart
Pointer<TfLiteXNNPackDelegateOptions> get base => _options;
```

--------------------------------

### String toString()

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/QuantizationParams/toString.html

Returns a string representation of the QuantizationParams object, including the current scale and zeroPoint values.

```APIDOC
## String toString()

### Description
Returns a string representation of the QuantizationParams object. This is primarily used for debugging or logging purposes to inspect the internal state of the object.

### Signature
`String toString()`

### Returns
- **String** - A string containing the values of `_scale` and `_zeroPoint`.
```

--------------------------------

### Execute model with single input and output

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/Interpreter/run.html

Use this method to run a model when there is exactly one input and one output. It internally maps the inputs to a map structure required by the multi-input runner.

```dart
void run(Object input, Object output) {
  var map = <int, Object>{};
  map[0] = output;
  runForMultipleInputs([input], map);
}
```

--------------------------------

### Initialize InterpreterOptions

Source: https://pub.dev/documentation/lite_rt_for_dart/latest/lite_rt_for_dart/InterpreterOptions/InterpreterOptions.html

Creates a new instance of InterpreterOptions using the underlying TfLiteInterpreterOptionsCreate binding.

```dart
factory InterpreterOptions() =>
    InterpreterOptions._(tfliteBinding.TfLiteInterpreterOptionsCreate());
```
Tokens:
Raw