### Example MinGW-w64 Installation Path

Source: https://wyday.com/limelm/help/using-turboactivate-with-go

This is an example path for a MinGW-w64 installation on Windows. Ensure this path is correctly set in your system's PATH environment variable.

```text
C:\Program Files\mingw-w64\x86_64-7.2.0-win32-seh-rt_v5-rev0\mingw64
```

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

### Install macOS Command Line Tools

Source: https://wyday.com/limelm/help/using-turboactivate-with-go

Installs the necessary development tools required for Go without installing the full Xcode environment.

```bash
xcode-select --install
```

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

### Install TurboFloat Server

Source: https://wyday.com/limelm/help/turbofloat-server

Install the server as a background service or daemon using the -i switch. Requires elevated privileges.

```bash
TurboFloatServer.exe -i
```

```bash
sudo ./TurboFloatServer -i
```

```bash
TurboFloatServer.exe -i -pdets="YourTurboActivate.dat" -config="Config.xml"
```

```bash
TurboFloatServer.exe -i -delaystart
```

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

### Initialize TurboFloat Instance

Source: https://wyday.com/limelm/help/using-turbofloat-with-electron-nodejs

Create a TurboFloat instance in your main form. Replace 'Paste GUID Here' with the actual GUID from LimeLM.

```javascript
var TurboFloat = require('./turbofloat.js');

//TODO: goto the version page at LimeLM and paste this GUID here
var tf = new TurboFloat("Paste GUID Here", TFLeaseChange);
```

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

### Build Example C App with Makefile

Source: https://wyday.com/limelm/help/using-turboactivate-on-linux

Compile the example C application for x86 architecture using the provided makefile. This will generate an executable in the same directory as the library.

```bash
make -f makefile-x86
```

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

### Start Verified Trial from File (C/C++)

Source: https://wyday.com/limelm/help/trials

Use TA_UseTrialVerifiedFromFile to start a verified trial using a response file. Trial flags like TA_VERIFIED_TRIAL and TA_SYSTEM can be set.

```cpp
// Set the trial flags you want to use. Here we've selected that the
// trial data should be stored system-wide (TA_SYSTEM) and that we should
// use un-resetable verified trials (TA_VERIFIED_TRIAL).
uint32_t trialFlags = TA_VERIFIED_TRIAL | TA_SYSTEM;

HRESULT hr = TA_UseTrialVerifiedFromFile(taHandle, filename, trialFlags);

if (hr == TA_OK)
    printf("The verified trial started successfully!");
else
    printf("TA_UseTrialVerifiedFromFile failed: hr = 0x%x\n", hr);
```

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

### Start Unverified Trial

Source: https://wyday.com/limelm/help/turboactivate-wizard

To start an unverified trial instead of the default verified trial on the first run, use the --unverified command-line switch.

```bash
TurboActivate.exe --unverified
```

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

### Start Verified Trial from File (C#)

Source: https://wyday.com/limelm/help/trials

Use the TurboActivate.UseTrialVerifiedFromFile method to start a verified trial using a response file. Trial flags like TA_Flags.TA_VERIFIED_TRIAL and TA_Flags.TA_SYSTEM can be specified.

```csharp
// Set the trial flags you want to use. Here we've selected that the
// trial data should be stored system-wide (TA_SYSTEM) and that we should
// use un-resetable verified trials (TA_VERIFIED_TRIAL).
TA_Flags trialFlags = TA_Flags.TA_SYSTEM | TA_Flags.TA_VERIFIED_TRIAL;

try
{
    ta.UseTrialVerifiedFromFile(filename, trialFlags);
}
catch (Exception ex)
{
    MessageBox.Show(ex.Message, "UseTrialVerifiedFromFile failed.", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
```

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

### Initialize TurboFloat Instance

Source: https://wyday.com/limelm/help/using-turbofloat-with-python

Initialize the TurboFloat instance with your product's Version GUID and a lease callback function. Replace 'PASTE-VERSION-GUID-HERE' with your actual GUID.

```python
try:
    # TODO: go to the version page at LimeLM and
    # paste this GUID here
    tf = TurboFloat("PASTE-VERSION-GUID-HERE", leasecallback)

```

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

### Create TurboActivate Instance

Source: https://wyday.com/limelm/help/using-turboactivate-with-python

Instantiate the TurboActivate object with your Version GUID and activation type (user or system). Replace 'Paste GUID Here' with your actual GUID.

```python
ta = TurboActivate("Paste GUID Here", TA_USER)
```

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

### Initialize TurboActivate Instance

Source: https://wyday.com/limelm/help/using-turboactivate-with-csharp

Create a TurboActivate object in your application's constructor. Replace 'Paste GUID Here' with your actual Version GUID from LimeLM. Ensure the TurboActivate.dat file is accessible.

```csharp
public partial class Form1 : Form
{
    readonly TurboActivate ta;

    public Form1()
    {
        InitializeComponent();

        try
        {
            //TODO: goto the version page at LimeLM and
            // paste this GUID here
            ta = new TurboActivate("Paste GUID Here");

            // ...
        }
        catch (Exception ex)
        {
            // Handle exceptions during TurboActivate initialization
            MessageBox.Show($"Error initializing TurboActivate: {ex.Message}");
        }
    }

    // ...
}
```

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

### Initialize TurboFloat and Request Lease

Source: https://wyday.com/limelm/help/using-turbofloat-with-vb-dot-net

Initialize the TurboFloat library with your application's version GUID and set up an event handler for lease changes before requesting a lease. Replace 'PASTE-VERSION-GUID-HERE' with your actual GUID.

```vb
Try
    'TODO: goto the version page at LimeLM and paste this GUID here
    tf = New TurboFloat("PASTE-VERSION-GUID-HERE")

    AddHandler tf.LeaseChange, AddressOf TurboFloat_LeaseChange
    tf.RequestLease()
 


```

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

### Proxy URI Format Examples

Source: https://wyday.com/limelm/help/proxies-in-turboactivate

Examples of valid proxy string formats for TurboActivate.

```text
http://127.0.0.1/
```

```text
http://127.0.0.1:8080/
```

```text
http://user:pass@127.0.0.1:8080/
```

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

### Handle Next Button Click in Installer

Source: https://wyday.com/limelm/help/using-turboactivate-with-inno-setup

This function handles the 'Next' button click event in the installer. It retrieves the TurboActivate handle, checks activation status, validates and saves the product key, and attempts activation. The user can proceed even if activation fails.

```Pascal
function NextButtonClick(CurPage: Integer): Boolean;
var
  ret: LongInt;
begin

    if CurPage = wpWelcome then begin
        // get the handle for your version GUID
        taHandle := TA_GetHandle(VERSION_GUID);

        // error handling code
        if taHandle = 0 then begin
            MsgBox('Failed to get the TurboActivate handle. Make sure the TurboActivate.dat file is included with your installer and you''re using the correct VersionGUID.', mbError, MB_OK);
            Result := False;
            exit;
        end;

        // after the welcome page, check if we're activated
        ret := TA_IsActivated(taHandle);

        if ret = TA_OK then begin
            activated := true;
        end;

    end else if CurPage = PkeyPage.ID then begin

        // check if the product key is valid
        ret := TA_CheckAndSavePKey(taHandle, PkeyPage.Values[0], TA_SYSTEM);

        if ret = TA_OK then begin

            // try to activate, show a specific error if it fails
            ret := TA_Activate(taHandle, 0);

            if ret = 0 then begin
                activated := true;
            end;
        end;
    end;

    // let the user continue whether they're activated or not
    Result := True;
end;
```

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

### Create TurboActivate Instance in Go

Source: https://wyday.com/limelm/help/using-turboactivate-with-go

Instantiate the TurboActivate object with your Version GUID. Ensure you replace the placeholder with your actual GUID. Handle potential errors during instantiation.

```go
import "golang.wyday.com/turboactivate"

func main() {

    //TODO: goto the version page at LimeLM and paste this GUID here
    ta, err := turboactivate.NewTurboActivate("Paste GUID Here", "")

    if err != nil {
        // failed to construct the TurboActivate object
        // bail out now.
        panic(err)
    }

    // ...
}
```

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

### Initialize TurboFloat and Request Lease

Source: https://wyday.com/limelm/help/using-turbofloat-with-csharp

Initializes the TurboFloat library with a version GUID and requests a license lease. Ensure you replace 'PASTE-VERSION-GUID-HERE' with your actual GUID. This code should be placed before setting up event handlers.

```csharp
try
{
    //TODO: goto the version page at LimeLM and paste this GUID here
    tf = new TurboFloat("PASTE-VERSION-GUID-HERE");

    tf.LeaseChange += TurboFloat_LeaseChange;
    tf.RequestLease();
}
 

```

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

### Initialize TurboFloat Instance

Source: https://wyday.com/limelm/help/using-turbofloat-with-vba

Initializes the TurboFloat object and requests a license lease. Ensure the Version GUID is replaced with your specific product GUID.

```VBA
' Only call this function once. If you call it many times unexpected behavior will happen.
Public Function InitializeTurboFloat(ByVal showPrompt As Boolean) As Boolean

    ' create the new TurboFloat instance
    Set globalTfInstance = New TurboFloat

    ' tell your app to handle errors in the section
    ' at the end of the sub
    If showPrompt Then
        On Error GoTo TFProcError
    Else
        On Error GoTo FailCleanup
    End If

    'TODO: goto the version page at LimeLM and paste this GUID here
    Call globalTfInstance.Init("18324776654b3946fc44a5f3.49025204", vbNullString, Not showPrompt)

    ' if we're not showing the prompt then it's presumed
    ' that we're not trying to request a license lease, so, just skip it
    If Not showPrompt Then
        GoTo ProcExit
    End If

    ' request the lease
    Call globalTfInstance.RequestLease


AfterRequest:
    ' If you've reached this point then your app has
    ' successfully acquired a license lease. If you
    ' have custom license field values that you want
    ' to use, you can get them now.
    ' See: https://wyday.com/limelm/help/license-features/

    'Dim fieldValue As String
    'fieldValue = globalTfInstance.GetFeatureValue("your field name", "default value")
    'TODO: do something with the fieldValue

ProcExit:
    InitializeTurboFloat = True
    Exit Function

TFProcError:

    If Err.Number = TF_E_INET Or _
       Err.Number = TF_E_INET_TIMEOUT Or _
       Err.Number = TF_E_WRONG_SERVER_PRODUCT Or _
       Err.Number = TF_E_SERVER_UUID_MISMATCH Or _
       Err.Number = TF_E_USERNAME_NOT_ALLOWED Then

        ' Give the user an option to try another server if they
        ' couldn't connect to the first one, or if the first one
        ' is for a different product.
        Dim inetErr As frmFloatInternetErr
        Set inetErr = New frmFloatInternetErr

        If inetErr.ShowDialog(globalTfInstance) = vbOK Then
            Resume AfterRequest
        Else
            ' Return false and cleanup memory
            Resume FailCleanup
        End If

    ElseIf Err.Number = TF_E_SERVER Then

        ' if it's a server error, then prompt for the server
        Dim srvConf As ServerConfig
        Set srvConf = New ServerConfig

        If srvConf.ShowDialog(globalTfInstance) = vbOK Then
            Resume AfterRequest
        Else
            ' Return false and cleanup memory
            Resume FailCleanup
        End If
    End If


    MsgBox "Failed to get a lease from the floating license server: " & Err.Description

FailCleanup:

    Set globalTfInstance = Nothing

    ' Tell the customer that it failed
    InitializeTurboFloat = False

End Function
```

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

### GET /pkey/find

Source: https://wyday.com/limelm/help/api/misc.encoding

Finds a product key by its key string.

```APIDOC
## GET /pkey/find

### Description
Finds a product key by its key string.

### Method
GET

### Endpoint
/pkey/find

### Query Parameters
- **key** (string) - Required - The product key string to find.

### Response
#### Success Response (200)
- **productKey** (object) - The product key details.
  - **id** (integer) - The product key ID.
  - **key** (string) - The product key.
  - **status** (string) - The status of the product key.
  - **expirationDate** (string) - The expiration date of the product key.

#### Response Example
```json
{
  "productKey": {
    "id": 501,
    "key": "ABCD-EFGH-IJKL-MNOP",
    "status": "active",
    "expirationDate": "2024-12-31"
  }
}
```
```

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

### GET /pkey/activity

Source: https://wyday.com/limelm/help/api/misc.encoding

Retrieves activity logs for product keys.

```APIDOC
## GET /pkey/activity

### Description
Retrieves activity logs for product keys.

### Method
GET

### Endpoint
/pkey/activity

### Query Parameters
- **productId** (integer) - Optional - Filter activity by product ID.
- **licenseId** (integer) - Optional - Filter activity by license ID.
- **startDate** (string) - Optional - Filter activity from a specific start date (YYYY-MM-DD).
- **endDate** (string) - Optional - Filter activity up to a specific end date (YYYY-MM-DD).

### Response
#### Success Response (200)
- **activityLogs** (array) - A list of activity log entries.
  - **timestamp** (string) - The time of the activity.
  - **type** (string) - The type of activity (e.g., activation, deactivation).
  - **details** (string) - Details about the activity.

#### Response Example
```json
{
  "activityLogs": [
    {
      "timestamp": "2023-10-27T10:00:00Z",
      "type": "activation",
      "details": "Product key activated on machine XYZ."
    }
  ]
}
```
```

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

### Initialize the product key wizard page

Source: https://wyday.com/limelm/help/using-turboactivate-with-inno-setup

Create the input page for the product key within the InitializeWizard procedure.

```Pascal
procedure InitializeWizard;
begin
    // create the product key page
    PkeyPage := CreateInputQueryPage(wpWelcome,
        'Type your product key', '',
        'You can find the {#SetupSetting("AppName")} product key in the email we sent you. Activation will register the product key to this computer.');
    PkeyPage.Add('Product Key:', False);
end;
```

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

### Include TurboActivate files in Inno Setup

Source: https://wyday.com/limelm/help/using-turboactivate-with-inno-setup

Add the TurboActivate DLL and DAT files to the [Files] section of your Inno Setup script to ensure they are available during installation and uninstallation.

```inno
[Files]
; Install TurboActivate to {app} so we can access it at uninstall time
; Also, notice we're putting the TurboActivate files at the top of the file
; list. This is so that if you're using "SolidCompression=yes" your installer
; can still start relatively quickly.
Source: "TurboActivate.dll"; DestDir: "{app}"
Source: "TurboActivate.dat"; DestDir: "{app}"

; all other files can go below...
```

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

### Example otool Output

Source: https://wyday.com/limelm/help/using-turboactivate-on-mac-os-x

Sample output showing the compatibility and current version of the library.

```text
libTurboActivate.dylib:
    @rpath/libTurboActivate.dylib (compatibility version 1.0.0, **current version 4.0.5**)
    ...
```

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

### Start Verified Trial and Get Remaining Days

Source: https://wyday.com/limelm/help/using-turboactivate-with-electron-nodejs

Initiates a verified trial and retrieves the number of remaining trial days. Handles trial expiration by calling `TrialExpired()` and proceeds to start the application if trial days are available.

```javascript
ta.UseTrial(TATrialChange, trialFlags)
    .then((retObj) => { // result from UseTrial()

        // if null, fall through
        if (retObj === null)
            return null;

        if (retObj === TA_OK)
            return ta.TrialDaysRemaining(trialFlags);
        else if (retObj === TA_E_TRIAL_EXPIRED)
        {
            TrialExpired();
            return null;
        }
        else
            HardFailure("Failed to start the trial", retObj);
    })
    .then((retObj) => { // result from TrialDaysRemaining()

        // if null, fall through
        if (retObj === null)
            return null;

        if (retObj[0] === TA_OK)
        {
            // if the customer is in a trial, being your app
            if (retObj[1] > 0)
                BeginYourApp(true, retObj[1]);
            else // no more trial days remaining
            {
                TrialExpired();
                return null;
            }
        }
        else
        {
            HardFailure("Failed to get the trial days remaining",
                retObj[0]);
        }
    })
    .catch((retObj) => { // an error somewhere in the processing

        HardFailure("Something failed! " + retObj, 1);
    });
```

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

### Define Version GUID in Inno Setup

Source: https://wyday.com/limelm/help/using-turboactivate-with-inno-setup

Set the VERSION_GUID constant in the [Code] section of your script using the value provided by your LimeLM version page.

```inno
[Code]
//TODO: goto the version page at LimeLM and paste this GUID here
const
  VERSION_GUID = 'Paste GUID Here';
```

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

### Install turbofloat Python Package

Source: https://wyday.com/limelm/help/using-turbofloat-with-python

Install the turbofloat Python package using pip. This command installs the package for global use.

```bash
pip install turbofloat
```

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

### Prompt for Product Key and Activate

Source: https://wyday.com/limelm/help/using-turboactivate-with-python

This snippet demonstrates how to prompt the user for a product key, check and save it, and then attempt to activate the product. It includes error handling for invalid keys and activation failures. Use this when direct user input for activation is required.

```python
# Whether to prompt for the product key
prompt_for_key = False

if not isGenuine:
    # ask the user if they want to enter their pkey
    print('Would you like to enter your pkey (y/n) [n]: ')
    prompt_res = sys.stdin.read(1)

    if prompt_res != "" and prompt_res == "y":
        prompt_for_key = True
    else:
        prompt_for_key = False

# Now actually prompt for the product key and try to activate
if prompt_for_key:
    try:
        # prompt the user for a product key
        pkey = input('Enter your product key to activate: ')

        if ta.check_and_save_pkey(pkey):
            print("Product key saved successfully.")
        else:
            sys.exit("Product key was not valid for this product version")

    except TurboActivateError as e:
        sys.exit("Failed to check or save product key: " + str(e))

    # try to activate the product key
    try:
        ta.activate()

        isGenuine = True
        print("Activated successfully!")

    except TurboActivateError as e:
        sys.exit("Failed to activate online: " + str(e))
```

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

### Install TurboActivate Python Package

Source: https://wyday.com/limelm/help/using-turboactivate-with-python

Install the TurboActivate Python class to be used globally. Use the --upgrade flag to update an existing installation.

```bash
pip install turboactivate
```

```bash
pip install --upgrade turboactivate
```

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

### Define Application Start Function

Source: https://wyday.com/limelm/help/using-turboactivate-with-electron-nodejs

This function serves as the entry point for your application's main logic. It can optionally be called with parameters indicating an active trial.

```javascript
function BeginYourApp(inTrial = false, trialDays = 0)
{
    console.log("Hello world! Here's where your app code would begin.");
}
```

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

### Install or Update PyInstaller

Source: https://wyday.com/limelm/help/using-turboactivate-with-python

Commands to install or upgrade the PyInstaller package via pip.

```bash
pip install pyinstaller
```

```bash
pip install --upgrade pyinstaller
```

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

### Install GCC on CentOS/Red Hat

Source: https://wyday.com/limelm/help/using-turboactivate-with-go

Installs the GCC compiler package on RHEL-based systems.

```bash
sudo yum install gcc
```

```bash
sudo yum install gcc.x86_64
```

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

### Extract TurboActivate to installation directory

Source: https://wyday.com/limelm/help/using-turboactivate-with-nsis

Copy the required TurboActivate files into the target installation folder.

```NSIS
SetOutPath "$INSTDIR"

File "TurboActivate.dll"
File "TurboActivate.dat"
```

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

### Initialize TurboActivate in .onInit

Source: https://wyday.com/limelm/help/using-turboactivate-with-nsis

Extract TurboActivate files to the plugins directory during the installer initialization phase.

```NSIS
Function .onInit

    ; ... Your other lines

    ; TurboActivate requires at least Windows XP
    ${IfNot} ${AtLeastWinXP}
        MessageBox MB_OK "Windows XP (or newer) is required to run $(^NameDA)."
        Quit
    ${EndIf}

    ; create the plugins folder
    InitPluginsDir

    ; extract the TurboActivate files to the plugns folder
    File /oname=$PLUGINSDIR\TurboActivate.dll "TurboActivate.dll"
    File /oname=$PLUGINSDIR\TurboActivate.dat "TurboActivate.dat"

FunctionEnd
```

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

### Installing the TurboFloat Server (Linux)

Source: https://wyday.com/limelm/help/turbofloat-server

Instructions for running the TurboFloat Server on Linux, including command-line arguments for silent operation.

```APIDOC
## Installing the TurboFloat Server (Linux)

Since Linux installations vary wildly in how they run "daemons" or "startup services" we don't offer the "-i" commandline switch for Linux. However, you can build the init script yourself (for systemd, System V init, upstart, or any other init system) to launch the TurboFloat Server instance upon the computer's start.

When you're running the TurboFloat Server instance from your init script there are 2 commandline options you'll want to use:

```
/path/to/turbofloatserver **-x -silent**
```

That will tell the TurboFloat Server instance to run and to run silently (not outputting to "stderr").
```

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

### Install GCC on Ubuntu/Debian

Source: https://wyday.com/limelm/help/using-turboactivate-with-go

Updates package lists and installs the build-essential package containing GCC.

```bash
sudo apt-get update
sudo apt-get install build-essential
```

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

### Configure NSIS Installer Page Order

Source: https://wyday.com/limelm/help/using-turboactivate-with-nsis

Insert the custom product key page into the installer's page sequence.

```NSIS
!insertmacro MUI_PAGE_LICENSE "${NSISDIR}\Docs\Modern UI\License.txt"
**Page custom PagePKey PagePKeyLeave**
!insertmacro MUI_PAGE_COMPONENTS
!insertmacro MUI_PAGE_DIRECTORY
!insertmacro MUI_PAGE_INSTFILES
```

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

### Prompt and Activate Product Key

Source: https://wyday.com/limelm/help/using-turboactivate-with-go

Use this pattern to collect a product key from the user, validate it, and perform the activation process.

```go
var userEnteredPkey string

//TODO: prompt the user for the product key

// validate and save the product key if it's valid
validKey, err := ta.CheckAndSavePKey(userEnteredPkey, turboactivate.TAUser)

if err != nil {
    // a critical error happened -- likely
    // a failure to save the key
    panic(err)
}

if !validKey {
    fmt.Println("The product key entered is not valid.")
} else {
    err = ta.Activate("")

    if err != nil {
        fmt.Println("Failed to activate: " + err.Error())

        //TODO: ask the user for their product key again
    }
}
```

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

### Echo API Method Example Response

Source: https://wyday.com/limelm/help/api/limelm.test.echo

This is an example of the XML response from the limelm.test.echo method, showing how parameters are echoed back.

```xml
<method>echo</method>
<foo>bar</foo>
```

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

### Verify GCC Installation

Source: https://wyday.com/limelm/help/using-turboactivate-with-go

Command to verify the GCC compiler installation on Windows. Successful execution indicates that MinGW-w64 and its PATH configuration are correct.

```bash
gcc --version
```

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

### Initialize TurboActivate Instance in VB6

Source: https://wyday.com/limelm/help/using-turboactivate-with-vb6

This code snippet demonstrates how to create a new TurboActivate object and initialize it with your product's Version GUID. Ensure you replace 'Paste GUID Here' with the actual GUID obtained from your LimeLM version page. Error handling is set up to direct to the TAProcError label.

```vb
Public ta As TurboActivate

Private Sub Form_Load()

    ' create the new TurboFloat instance
    Set ta = New TurboActivate

    ' tell your app to handle errors in the section
    ' at the end of the sub
    On Error GoTo TAProcError

    'TODO: goto the version page at LimeLM and paste this GUID here
    Call ta.Init("Paste GUID Here")

    ' ...

```

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

### Implement activation logic in NextButtonClick

Source: https://wyday.com/limelm/help/using-turboactivate-with-inno-setup

Handle product key verification and activation during the wizard navigation process.

```Pascal
function NextButtonClick(CurPage: Integer): Boolean;
var
  ret: LongInt;
begin

    if CurPage = wpWelcome then begin
        // get the handle for your version GUID
        taHandle := TA_GetHandle(VERSION_GUID);

        // error handling code
        if taHandle = 0 then begin
            MsgBox('Failed to get the TurboActivate handle. Make sure the TurboActivate.dat file is included with your installer and you''re using the correct VersionGUID.', mbError, MB_OK);
            Result := False;
            exit;
        end;


        // after the welcome page, check if we're activated
        ret := TA_IsActivated(taHandle);

        if ret = TA_OK then begin
            activated := true;
        end;
        Result := True;
    end else if CurPage = PkeyPage.ID then begin

        // check if the product key is valid
        ret := TA_CheckAndSavePKey(taHandle, PkeyPage.Values[0], TA_SYSTEM);

        if ret = TA_OK then begin

            // try to activate, show a specific error if it fails
            ret := TA_Activate(taHandle, 0);

            case ret of
              TA_E_PKEY:
                MsgBox('The product key is invalid or there''s no product key.', mbError, MB_OK);
              TA_E_INET:
                MsgBox('Connection to the servers failed.', mbError, MB_OK);
              TA_E_INUSE:
                MsgBox('The product key has already been activated with the maximum number of computers.', mbError, MB_OK);
              TA_E_REVOKED:
                MsgBox('The product key has been revoked.', mbError, MB_OK);
              TA_E_INVALID_HANDLE:
                MsgBox('The handle is not valid. You must set the VersionGUID property.', mbError, MB_OK);
              TA_E_COM:
                MsgBox('CoInitializeEx failed. Re-enable Windows Management Instrumentation (WMI) service. Contact your system admin for more information.', mbError, MB_OK);
              TA_E_ENABLE_NETWORK_ADAPTERS:
```

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

### TurboFloat Directory Structure Example

Source: https://wyday.com/limelm/help/using-turbofloat-with-java

Illustrates the expected directory structure for including TurboFloat native binaries and the TurboActivate.dat file relative to your application's JAR file.

```text
YourApp.jar
TurboFloat/
     TurboActivate.dat
     win-x86/
          TurboFloat.dll
     win-x64/
          TurboFloat.dll
     win-arm64/
          TurboFloat.dll
     mac/
          libTurboFloat.dylib
     linux-i386/
          libTurboFloat.so
     linux-amd64/
          libTurboFloat.so
     linux-arm/
          libTurboFloat.so
     linux-arm64/
          libTurboFloat.so
     freebsd-i386/
          libTurboFloat.so
     freebsd-amd64/
          libTurboFloat.so
     ...
```

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

### Prompt and Activate Product Key

Source: https://wyday.com/limelm/help/using-turboactivate-with-electron-nodejs

Demonstrates the workflow for validating a user-provided product key and subsequently activating the application.

```javascript
var userEnteredPkey;

//TODO: prompt the user for the product key

// validate and save the product key if it's valid
ta.CheckAndSavePKey(userEnteredPkey, TA_USER)
    .then((retObj) => {

        // the product key was valid and saved successfully
        if (retObj === TA_OK)
            return ta.Activate();
        else // TA_FAIL
        {
            HardFailure("Something failed! " + retObj, 1);
            return null;
        }
    })
    .then((retObj) => { // result from Activate()

        // if null, fall through
        if (retObj === null)
            return null;

        if (retObj === TA_OK)
        {
            // the customer activated successfully, begin your app
            BeginYourApp();
        }
        else
        {
            HardFailure("Activation failed.", retObj);
        }
    })
    .catch((retObj) => { // an error somewhere in the processing

        HardFailure("Something failed! " + retObj, 1);
    });
```

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

### Initialize TurboActivate Instance

Source: https://wyday.com/limelm/help/using-turboactivate-with-vb-dot-net

Instantiate the TurboActivate object in your application's constructor. Ensure you replace the placeholder GUID with your actual Version GUID from LimeLM.

```vb
Public Class Form1

    Private ta As TurboActivate

    Public Sub New()
        InitializeComponent()

        Try
            'TODO: goto the version page at LimeLM and
            ' paste this GUID here
            ta = New TurboActivate("Paste GUID Here")

            ' ...
        End Try
    End Sub

End Class
```

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

### POST /prod/create

Source: https://wyday.com/limelm/help/api/misc.encoding

Creates a new product.

```APIDOC
## POST /prod/create

### Description
Creates a new product.

### Method
POST

### Endpoint
/prod/create

### Request Body
- **name** (string) - Required - The name of the product.
- **version** (string) - Required - The version of the product.

### Request Example
```json
{
  "name": "NewProduct",
  "version": "1.0"
}
```

### Response
#### Success Response (200)
- **id** (integer) - The ID of the newly created product.
- **message** (string) - A success message.

#### Response Example
```json
{
  "id": 103,
  "message": "Product created successfully."
}
```
```

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

### Define Version GUID and Licensing Flags

Source: https://wyday.com/limelm/help/using-turboactivate-with-nsis

Set the unique Version GUID obtained from LimeLM and define flags to enable product key and activation requirements.

```nsis
!define VersionGUID 'Paste GUID Here'
!define REQUIRE_PKEY
!define REQUIRE_ACT
```