### Install a Keyboard using install()

Source: https://github.com/keymanapp/keyman/blob/master/ios/docs/engine/ResourceFileManager/install.md

Illustrates how to install a keyboard from a KMP package. Ensure the package is prepared for installation using prepareKMPInstall() before calling install().

```swift
let packageURL = Bundle.main.url(forResource: "sil_euro_latin", withExtension: "kmp")!
let keyboardID = FullKeyboardID("sil_euro_latin", "fr") // Marks the keyboard for use with French.
do {
  if let keyboardPackage = try ResourceFileManager.shared.prepareKMPInstall(packageURL) as? KeyboardKeymanPackage {
    try ResourceFileManager.shared.install(resourceWithID: keyboardID, from: keyboardPackage)
  } else {
    // Report the error
  }
} catch {
  // Report the error
}
```

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

### install()

Source: https://github.com/keymanapp/keyman/blob/master/ios/docs/engine/ResourceFileManager/install.md

Installs a resource from an opened Keyman package file. This method is part of the ResourceFileManager singleton and is used after preparing the package for installation.

```APIDOC
## install(resourceWithID: URL, from: KeymanPackage) throws

### Description
Installs resources from opened package files. This method is used to add keyboards or lexical models to the Keyman Engine after they have been prepared for installation using `prepareKMPInstall`.

### Parameters
#### Path Parameters
* **resourceWithID** (URL) - Required - Either a `FullKeyboardID` or a `FullLexicalModelID` specifying the resource to install.
* **from** (KeymanPackage) - Required - The opened package file from which to install the resource.

### Throws
May fail if the package does not contain or support the designated resource and language pairing specified by the resource's ID.

### Example: Using `install()` to install a keyboard
```swift
let packageURL = Bundle.main.url(forResource: "sil_euro_latin", withExtension: "kmp")!
let keyboardID = FullKeyboardID("sil_euro_latin", "fr") // Marks the keyboard for use with French.
do {
  if let keyboardPackage = try ResourceFileManager.shared.prepareKMPInstall(packageURL) as? KeyboardKeymanPackage {
    try ResourceFileManager.shared.install(resourceWithID: keyboardID, from: keyboardPackage)
  } else {
    // Report the error
  }
} catch {
  // Report the error
}
```
```

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

### VBScript Example

Source: https://github.com/keymanapp/keyman/blob/master/windows/docs/engine/api/IKeyman/index.md

An example demonstrating how to use the IKeyman interface in VBScript to interact with installed Keyman packages.

```APIDOC
## Examples

### VBScript

This example can be saved with a .vbs extension to run through Windows
Scripting. This is similar to the uninstall script that Keyman for Windows
generates for packages which have a Start Menu Uninstall entry.

``` basic
dim kmcom, package
Set kmcom = CreateObject("keymanapi.Keyman")
n = kmcom.Packages.IndexOf("SamplePackage")
if n >= 0 then
  Set package = kmcom.Packages(n)
  if msgbox("Uninstall package "+package.Description+"?", vbOKCancel, "Keyman for Windows") = vbOK then
    package.Uninstall(True)
  end if
else
  msgbox "The package SamplePackage could not be found."
end if
```
```

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

### Install()

Source: https://github.com/keymanapp/keyman/blob/master/windows/docs/engine/api/IKeymanPackageFile/index.md

Installs the package into Keyman Engine.

```APIDOC
## Install()

### Description
Installs the package into Keyman Engine.

### Method
[Method details not specified in source]

### Parameters
[Parameter details not specified in source]

### Request Example
[Request example not specified in source]

### Response
[Response details not specified in source]
```

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

### Build and Install Keyman for Linux

Source: https://github.com/keymanapp/keyman/blob/master/docs/linux/README.md

Use the build script to configure, build, and install Keyman components. Run with sudo for installation to system directories.

```bash
linux/build.sh configure
```

```bash
linux/build.sh build
```

```bash
sudo linux/build.sh install
```

```bash
sudo linux/build.sh uninstall
```

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

### Install Method

Source: https://github.com/keymanapp/keyman/blob/master/windows/docs/engine/api/IKeymanPackagesInstalled/index.md

Installs a specified package file into the Keyman Engine.

```APIDOC
## Install()

### Description
Installs a package file into Keyman Engine.

### Parameters
- **FilePath** (string) - Required - The path to the package file to install.
```

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

### Using KMManager.method()

Source: https://github.com/keymanapp/keyman/blob/master/android/docs/engine/KMManager/sample_template.md

This example demonstrates how to use the KMManager.method() function. Ensure necessary imports or setup are done prior to execution.

```javascript
//Code here
```

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

### Build Windows Package Installer

Source: https://github.com/keymanapp/keyman/blob/master/developer/docs/help/reference/kmc/cli/reference.md

Creates a .exe installer for a keyboard package, including the Keyman installer, specifically for Windows.

```bash
kmc build windows-package-installer
```

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

### Get Engine Install Path

Source: https://github.com/keymanapp/keyman/blob/master/windows/docs/engine/api/IKeymanSystemInfo/EngineInstallPath.md

Access the EngineInstallPath property to get the directory where the Keyman Engine is installed.

```APIDOC
## IKeymanSystemInfo::EngineInstallPath Property

### Description
The `EngineInstallPath` property returns the fully qualified path where Keyman Engine is installed.

### Specification
```clike
readonly string EngineInstallPath
```
```

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

### Build Sample Project from Command Line

Source: https://github.com/keymanapp/keyman/blob/master/android/README.md

Configure and build a sample Keyman for Android project (KMSample1 or KMSample2) from its directory.

```bash
./build.sh configure build
```

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

### Get Installed Package

Source: https://github.com/keymanapp/keyman/blob/master/ios/docs/engine/ResourceFileManager/getInstalledPackage.md

Use this method to retrieve an already installed keyboard or lexical model. Ensure the resource object passed is one that has been previously installed.

```swift
ResourceFileManager.shared.getInstalledPackage<Resource: LanguageResource>(for: Resource)
```

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

### Install Android Development Tools

Source: https://github.com/keymanapp/keyman/blob/master/docs/build/windows.md

Installs Android Studio, Ant, Gradle, Maven, and the Android SDK using Chocolatey. Ensure to start a new shell after installation.

```powershell
# Elevated PowerShell
choco install androidstudio ant gradle maven android-sdk
```

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

### HTML for Welcome Help File

Source: https://github.com/keymanapp/keyman/blob/master/developer/docs/help/guides/walkthrough/07-writing-keyboard-documentation.md

Example of HTML structure for the `welcome.htm` file, including image references for different keyboard layers.

```html
<h2>Desktop keyboard layout</h2>
<h3>Default (unshifted)</h3>
<p><a href="LayoutU_.png"><img class="keyboard" src="LayoutU_.png" alt="Default (unshifted) state" /></a></p>
<h3>Shift</h3>
<p><a href="LayoutU_S.png"><img class="keyboard" src="LayoutU_S.png" alt="Shift state" /></a></p>
<h3>Right Alt (unshifted)</h3>
<p><a href="LayoutU_RA.png"><img class="keyboard" src="LayoutU_RA.png" alt="Right Alt (unshifted) state" /></a></p>
```

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

### Install Keyman for Android Dependencies

Source: https://github.com/keymanapp/keyman/blob/master/docs/build/macos.md

Installs dependencies for Keyman for Android, including OpenJDK, Android SDK, and build tools. Remember to run Android Studio once after installation to complete setup.

```shell
brew install openjdk@21 android-sdk android-studio ant gradle maven
# update path
source ../resources/devbox/macos/keyman.macos.env.sh
# optionally install sdk images
 sdkmanager "system-images;android-30;google_apis;armeabi-v7a"
sdkmanager --update
sdkmanager --licenses
```

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

### Build Keyman Samples

Source: https://github.com/keymanapp/keyman/blob/master/ios/README.md

Build the sample applications included in the KeymanEngine project. Navigate to the project directory and run the build script.

```bash
./build.sh
```

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

### Install Android SDK Command-line Tools

Source: https://github.com/keymanapp/keyman/wiki/Linux-Build-Agent-Setup

Downloads and installs the Android SDK command-line tools and platform tools. This is part of the Android build setup.

```bash
cd ~
sudo apt install openjdk-8-jdk
wget https://dl.google.com/android/repository/commandlinetools-linux-6609375_latest.zip
unzip commandlinetools-linux-6609375_latest.zip -d cmdline-tools
sudo mkdir /user/lib/android-sdk
sudo mv cmdline-tools /usr/lib/android-sdk
sudo chown -R [login:group] /usr/lib/android-sdk
sudo dpkg -i pandoc-2.13-1-amd64.deb
```

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

### Build, Configure, and Test Keyman Packages

Source: https://github.com/keymanapp/keyman/blob/master/docs/npm-packages.md

Run this command to prepare packages for publishing. Ensure the build succeeds and tests pass before proceeding.

```bash
./build.sh configure build test
```

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

### Example API Calls for General Version

Source: https://github.com/keymanapp/keyman/wiki/downloads.keyman.com-version-API

Examples of how to call the general single version API to get information for all platforms or a specific platform like Windows.

```http
https://downloads.keyman.com/api/version
```

```http
https://downloads.keyman.com/api/version/windows
```

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

### Execute Build Actions Sequentially

Source: https://github.com/keymanapp/keyman/blob/master/docs/builder.md

Demonstrates how to structure build scripts by checking and executing actions like 'configure', 'clean', and 'build' in a defined order. Each action is started with `builder_start_action` and finished with `builder_finish_action`.

```bash
if builder_start_action configure; then
  node_select_version_and_npm_ci
  builder_finish_action success configure
fi

if builder_start_action clean; then
  npm run clean
  rm -f ./version.inc.ts
  builder_finish_action success clean
fi

if builder_start_action build; then
  npm run build -- $builder_verbose
  builder_finish_action success build
fi
```

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

### Get Installed Keyboards

Source: https://github.com/keymanapp/keyman/blob/master/web/docs/engine/reference/core/getKeyboards.md

Call this function to retrieve an array containing the specifications of all keyboards currently installed on the system. Each object in the array provides details about a specific keyboard.

```javascript
keyman.getKeyboards()
```

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

### KeymanWeb Initialization Options

Source: https://github.com/keymanapp/keyman/blob/master/web/docs/engine/reference/core/init.md

Example of configuring KeymanWeb with various initialization options. This includes setting the UI, resource paths, attachment type, and feedback preferences.

```javascript
keyman.init({
  ui: 'float',
  root: '/path/to/keymanweb/',
  resources: '/path/to/keymanweb/resources/',
  keyboards: '/path/to/keymanweb/keyboards/',
  fonts: '/path/to/keymanweb/',
  attachType: 'auto',
  setActiveOnRegister: true,
  useAlerts: true,
  spacebarText: 'languageKeyboard'
});
```

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

### ProfileGUID Property

Source: https://github.com/keymanapp/keyman/blob/master/windows/docs/engine/api/IKeymanKeyboardLanguageInstalled/ProfileGUID.md

The ProfileGUID property is a read-only property that returns the GUID of the installed TSF Text Input Processor (TIP) for the keyboard language. If the language is not installed, it returns GUID_NULL.

```APIDOC
## ProfileGUID Property

### Description
Returns the profile GUID associated with the Text Services Framework (TSF) Text Input Processor (TIP) installed for this keyboard, for this language. If the language is not currently installed, then returns `GUID_NULL`.

### Specification
```clike
readonly GUID ProfileGUID
```
```

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

### prepareKMPInstall()

Source: https://github.com/keymanapp/keyman/blob/master/ios/docs/engine/ResourceFileManager/prepareKMPInstall.md

Imports and parses a Keyman package file from a given URL, returning the package content.

```APIDOC
## prepareKMPInstall()

### Description
Imports and parses package files, making their contents easily accessible for installation.

### Syntax
```swift
ResourceFileManager.shared.prepareKMPInstall(from: URL) throws -> KeymanPackage
```

### Parameter
`from` (URL) - URL to the KMP package.

### Returns
Returns either a `KeyboardKeymanPackage` or a `LexicalModelKeymanPackage`, depending on which type of resource the .kmp package represents.

### Throws
May fail if the file specified by the URL does not exist, is not a KMP, or if the KMP is malformed or corrupted.

### Example: Using `prepareKMPInstall()` to install a keyboard

```swift
let packageURL = Bundle.main.url(forResource: "sil_euro_latin", withExtension: "kmp")!
let keyboardID = FullKeyboardID("sil_euro_latin", "fr") // Marks the keyboard for use with French.
do {
  if let keyboardPackage = try ResourceFileManager.shared.prepareKMPInstall(packageURL) as? KeyboardKeymanPackage {
    try ResourceFileManager.shared.install(resourceWithID: keyboardID, from: keyboardPackage)
  } else {
    // Report the error
  }
} catch {
  // Report the error
}
```
```

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

### Swift: Enumerate Installable Resources for a Language

Source: https://github.com/keymanapp/keyman/blob/master/ios/docs/engine/KeymanPackage/installableResources.md

Use this method to get a list of installable resources (keyboards or lexical models) for a specific language code. The result is an array of `AnyLanguageResource` objects.

```swift
KeymanPackage.installableResources(forLanguage: "en")
```

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

### WindowsPackageInstallerSources.setupExeFilename

Source: https://github.com/keymanapp/keyman/blob/master/developer/docs/help/reference/api/kmc-package.windowspackageinstallersources.setupexefilename.md

The `setupExeFilename` property specifies the name of the setup executable file for a Windows package installer. It is a string value.

```APIDOC
## WindowsPackageInstallerSources.setupExeFilename

### Description

This property defines the filename for the setup executable used in Windows package installations.

### Property Type

`string`
```

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

### Install Resources from Package

Source: https://github.com/keymanapp/keyman/blob/master/ios/docs/engine/ResourceFileManager/index.md

Installs specified resources from opened package files for use within the KeymanEngine. Ensure the package is properly opened before calling this method.

```swift
install(resourceWithID: LanguageResourceFullID, from: KeymanPackage)
```

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

### WindowsPackageInstallerCompiler.run()

Source: https://github.com/keymanapp/keyman/blob/master/developer/docs/help/reference/api/kmc-package.windowspackageinstallercompiler.run.md

Compiles a .kps file to .exe Windows package installer file. Returns an object containing binary artifacts on success. The files are passed in by name, and the compiler will use callbacks as passed to the init() function to read any input files by disk.

```APIDOC
## WindowsPackageInstallerCompiler.run()

### Description
Compiles a .kps file to .exe Windows package installer file. Returns an object containing binary artifacts on success. The files are passed in by name, and the compiler will use callbacks as passed to the [WindowsPackageInstallerCompiler.init()](./kmc-package.windowspackageinstallercompiler.init.md) function to read any input files by disk.

### Method
run(inputFilename: string, outputFilename?: string): Promise<WindowsPackageInstallerCompilerResult>;

### Parameters
#### Path Parameters
- **inputFilename** (string) - Required - 
- **outputFilename** (string) - Optional - 

### Response
#### Success Response
Promise<[WindowsPackageInstallerCompilerResult](./kmc-package.windowspackageinstallercompilerresult.md)> - Binary artifacts on success, null on failure.
```

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

### WindowsPackageInstallerSources.startDisabled Property

Source: https://github.com/keymanapp/keyman/blob/master/developer/docs/help/reference/api/kmc-package.windowspackageinstallersources.startdisabled.md

The startDisabled property is a boolean value that indicates whether the Windows package installer sources should start in a disabled state.

```APIDOC
## WindowsPackageInstallerSources.startDisabled

### Description

Indicates whether the Windows package installer sources should start in a disabled state.

### Property Type

`boolean`
```

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

### init Function

Source: https://github.com/keymanapp/keyman/blob/master/web/docs/engine/reference/core/index.md

Initializes KeymanWeb, setting the license key, selecting the user interface, and configuring other options.

```APIDOC
## init Function

### Description

Sets license key, selects user interface, and other KeymanWeb Options.

### Parameters

*   **options** (object) - Required - An object containing initialization options, such as `licenseKey`, `ui`, etc.
```

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

### Get Lexical Models List

Source: https://github.com/keymanapp/keyman/blob/master/android/docs/engine/KMManager/getLexicalModelsList.md

This method returns a list of all installed lexical models. Each model is represented as a HashMap containing its details.

```APIDOC
## KMManager.getLexicalModelsList(Context context)

### Description
Use this method to get details of all the installed lexical models.

### Parameters
#### Path Parameters
* None

#### Query Parameters
* None

#### Request Body
* None

### Returns
Returns a list of all the installed lexical models. The list is an ArrayList of HashMaps, where each HashMap contains details about a single lexical model.

### Request Example
```java
ArrayList<HashMap<String, String>> lexicalModelList = KMManager.getLexicalModelsList(context);
```

### Response
#### Success Response (200)
* **lexicalModelList** (ArrayList<HashMap<String, String>>) - A list of installed lexical models.

#### Response Example
```json
{
  "lexicalModelList": [
    {
      "name": "model1",
      "version": "1.0"
    },
    {
      "name": "model2",
      "version": "2.0"
    }
  ]
}
```
```

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

### WindowsPackageInstallerSources.startWithConfiguration

Source: https://github.com/keymanapp/keyman/blob/master/developer/docs/help/reference/api/kmc-package.windowspackageinstallersources.startwithconfiguration.md

This property is a boolean value that indicates whether the Windows package installer sources should be initialized with a configuration. Set to `true` to enable configuration-based startup, or `false` to use default settings.

```APIDOC
## WindowsPackageInstallerSources.startWithConfiguration

### Description

This property is a boolean value that indicates whether the Windows package installer sources should be initialized with a configuration. Set to `true` to enable configuration-based startup, or `false` to use default settings.

### Signature

```typescript
startWithConfiguration: boolean;
```
```

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

### Get Installables for a Specific Language

Source: https://github.com/keymanapp/keyman/blob/master/ios/docs/engine/TypedKeymanPackage/installables_forLanguage.md

Use this method to retrieve all installable keyboards or lexical models associated with a given BCP-47 language code from a Keyman package. For most packages, expect a single result, but multi-keyboard packages may return multiple entries.

```swift
TypedKeymanPackage.installables(forLanguage:)
```

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

### Get Lexical Model Information

Source: https://github.com/keymanapp/keyman/blob/master/android/docs/engine/KMManager/getLexicalModelInfo.md

Use this method to retrieve details about the first installed lexical model. Ensure a valid `Context` is provided.

```java
    // Gets information on the first installed lexical model
    HashMap<String, String> lexicalModelInfo = KMManager.getLexicalModelInfo(context, 0);
```

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

### install

Source: https://github.com/keymanapp/keyman/blob/master/ios/docs/engine/ResourceFileManager/index.md

Installs specified resources from opened package files for use within the Keyman Engine.

```APIDOC
## install

### Description
Installs specified resources from opened package files for use within the KeymanEngine.

### Method Signature
`ResourceFileManager.shared.install(resourceWithID: LanguageResourceFullID, from: KeymanPackage)`
```

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

### Build Windows Package Installer (Bash)

Source: https://github.com/keymanapp/keyman/blob/master/developer/docs/help/reference/kmc/cli/reference.md

Builds a Windows package installer using Bash, suitable for Linux, WSL, or macOS environments. It specifies the MSI, executable, license file, and output file, with paths that may vary depending on your system setup.

```shell
kmc build windows-package-installer \
  ./khmer_angkor/source/khmer_angkor.kps \
  --msi ./redist/keymandesktop.msi \
  --exe ./redist/setup-redist.exe \
  --license ./redist/LICENSE.md \
  --out-file ./khmer.exe
```

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

### Example: Using getKeyboardsList()

Source: https://github.com/keymanapp/keyman/blob/master/android/docs/engine/KMManager/getKeyboardsList.md

Illustrates how to retrieve the list of keyboards and conditionally add a new one if the list size is less than two. Requires a `Context` and assumes `Keyboard` class and `addKeyboard` method are available.

```javascript
    List<Keyboard> keyboardsList = KMManager.getKeyboardsList(this);
    if ((keyboardsList != null) && keyboardsList.size() < 2) {
        // Add another Keyboard
        Keyboard kbd = new Keyboard(...);
        KMManager.addKeyboard(kbd);
    }
```

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

### WindowsPackageInstallerSources Interface

Source: https://github.com/keymanapp/keyman/blob/master/developer/docs/help/reference/api/kmc-package.windowspackageinstallersources.md

The WindowsPackageInstallerSources interface specifies the configuration options for the Windows package installer, including filenames for executables and images, and settings for starting the application.

```APIDOC
## WindowsPackageInstallerSources Interface

Sources and metadata for the Windows package installer compiler

**Signature:**

```typescript
export interface WindowsPackageInstallerSources 
```

### Properties

- **appName?** (string) - _(Optional)_: The name of the application.
- **licenseFilename** (string): The filename for the license.
- **msiFilename** (string): The filename for the MSI installer.
- **setupExeFilename** (string): The filename for the setup executable.
- **startDisabled** (boolean): Indicates if the application should start disabled.
- **startWithConfiguration** (boolean): Indicates if the application should start with configuration.
- **titleImageFilename?** (string) - _(Optional)_: The filename for the title image.
```

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

### Get Keyboards List

Source: https://github.com/keymanapp/keyman/blob/master/android/docs/engine/KMManager/getKeyboardsList.md

Retrieves the list of all keyboards installed on the device. This method is useful for managing keyboard settings or displaying available options to the user.

```APIDOC
## KMManager.getKeyboardsList(Context context)

### Description
Use this method to get details of all keyboards in the keyboards menu.

### Parameters
- **context** (Context) - Required - The Android context.

### Returns
- **List<Keyboard>** - A list of Keyboard objects if keyboards exist, otherwise null.

### Example
```javascript
List<Keyboard> keyboardsList = KMManager.getKeyboardsList(this);
if ((keyboardsList != null) && keyboardsList.size() < 2) {
    // Add another Keyboard
    Keyboard kbd = new Keyboard(...);
    KMManager.addKeyboard(kbd);
}
```
```

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

### Start Keyman Developer Server on Linux/macOS

Source: https://github.com/keymanapp/keyman/blob/master/developer/docs/help/context/server.md

Navigate to the server directory within the extracted kmcomp folder and run the production command to start the Keyman Developer Server. Press Ctrl+C to stop.

```shell
cd server
npm run prod
```

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

### Initialize KeymanWeb with UI Object

Source: https://github.com/keymanapp/keyman/blob/master/web/docs/engine/reference/core/init.md

Example of initializing KeymanWeb with a UI configuration object, specifying the UI name and alignment.

```javascript
keyman.init({
  ui: {
    name: 'compact',
    right: true
  }
});
```

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

### IKeymanLanguage::ProfileGUID

Source: https://github.com/keymanapp/keyman/blob/master/windows/docs/engine/api/IKeymanLanguage/ProfileGUID.md

Returns the profile GUID associated with the Text Services Framework (TSF) Text Input Processor (TIP) installed for this keyboard, for this language.

```APIDOC
## IKeymanLanguage::ProfileGUID

### Description
Returns the profile GUID associated with the Text Services Framework (TSF) Text Input Processor (TIP) installed for this keyboard, for this language.

### Specification
```clike
readonly GUID ProfileGUID
```
```

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

### Instantiating the Keyman Engine

Source: https://github.com/keymanapp/keyman/blob/master/windows/docs/engine/api/index.md

Demonstrates how to create an instance of the Keyman Engine for Windows API using COM.

```APIDOC
## Instantiating the Keyman Engine

### Description

The Keyman Engine for Windows API can be instantiated using COM.

### Method

COM Instantiation

### Code Example

```
CreateObject("keymanapi.Keyman")
```
```

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

### Get List of Lexical Models

Source: https://github.com/keymanapp/keyman/blob/master/android/docs/engine/KMManager/getLexicalModelsList.md

Call this method to retrieve an ArrayList of HashMaps, where each HashMap contains information about an installed lexical model. Ensure a valid Context is provided.

```java
    ArrayList<HashMap<String, String>> lexicalModelList = KMManager.getLexicalModelsList(context);
```

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

### Run a Specific Build Action

Source: https://github.com/keymanapp/keyman/blob/master/docs/builder.md

Provides an example of how to run a specific build action, such as 'clean', within the builder framework. This involves starting the action and then finishing it with a success status.

```bash
if builder_start_action clean; then
  npm run clean
  rm -f ./version.inc.ts
  builder_finish_action success clean
fi
```

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

### IKeymanControl::OpenHelp()

Source: https://github.com/keymanapp/keyman/blob/master/windows/docs/engine/api/IKeymanControl/OpenHelp.md

Opens Keyman for Windows help at the specified topic.

```APIDOC
## IKeymanControl::OpenHelp()

### Description
Opens Keyman for Windows help at the specified topic.

### Method
``` clike
void OpenHelp(string Topic)
```

### Parameters
*   **Topic** (string) - The string identifier for the topic.
```

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

### KeymanPackage Syntax Example

Source: https://github.com/keymanapp/keyman/blob/master/ios/docs/engine/KeymanPackage/index.md

This is the general syntax for interacting with the KeymanPackage class. Use this as a reference for method calls.

```swift
KeymanPackage.methodName()
```

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

### Accessing ProfileGUID Property

Source: https://github.com/keymanapp/keyman/blob/master/windows/docs/engine/api/IKeymanLanguage/ProfileGUID.md

This property returns the profile GUID associated with the Text Services Framework (TSF) Text Input Processor (TIP) installed for this keyboard, for this language. It is a read-only property.

```clike
readonly GUID ProfileGUID
```

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

### Build and Install km-config

Source: https://github.com/keymanapp/keyman/blob/master/docs/linux/keyman-config.md

Commands to build and install the km-config tool from the repository. Use 'uninstall' to remove it.

```bash
linux/keyman-config/build.sh build
```

```bash
linux/keyman-config/build.sh install
```

```bash
linux/keyman-config/build.sh uninstall
```

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

### IKeymanPackage::ID

Source: https://github.com/keymanapp/keyman/blob/master/windows/docs/engine/api/IKeymanPackage/ID.md

Returns the base name of the package .kmp file, sans extension. This identifier is unique within a Keyman Engine installation and should consist of letters, digits, and underscores, starting with a letter.

```APIDOC
## IKeymanPackage::ID Property

### Description

The `ID` property returns the base name of the package .kmp file, sans extension. The full filename, including path, of the package is available in the [`Filename`](Filename) property.

No two packages can share the same identifier in a Keyman Engine installation. The identifier is case insensitive and should consist of letters, digits and underscore, although some legacy identifiers may contain other characters as well. The initial letter of an identifier should be a letter.

### Specification

```clike
readonly string ID
```
```

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

### prepareKMPInstall

Source: https://github.com/keymanapp/keyman/blob/master/ios/docs/engine/ResourceFileManager/index.md

Prepares a KMP package for installation by importing, opening, and parsing the file.

```APIDOC
## prepareKMPInstall

### Description
Given a local filesystem URL for a KMP package, this function imports, opens, and parses the file for use within KeymanEngine.

### Method Signature
`ResourceFileManager.shared.prepareKMPInstall(from: URL)`
```

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

### Check Package Installation Status

Source: https://github.com/keymanapp/keyman/blob/master/ios/docs/engine/ResourceFileManager/installState.md

Use this method to query the installation state of a specific Keyman package. It returns the current status, indicating whether the package is not installed, being downloaded, pending installation, or fully installed.

```swift
ResourceFileManager.shared.installState(forPackage: KeymanPackage.Key)

```

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

### LdmlKeyboardCompiler.init()

Source: https://github.com/keymanapp/keyman/blob/master/developer/docs/help/reference/api/kmc-ldml.ldmlkeyboardcompiler.init.md

Initializes the compiler, including loading the WASM host for uset parsing. Copies options.

```APIDOC
## LdmlKeyboardCompiler.init()

### Description
Initialize the compiler, including loading the WASM host for uset parsing. Copies options.

### Method
`init(callbacks: CompilerCallbacks, options: LdmlCompilerOptions): Promise<boolean>`

### Parameters
#### Path Parameters
- **callbacks** (CompilerCallbacks) - Required - Callbacks for external interfaces, including message reporting and file io
- **options** (LdmlCompilerOptions) - Required - Compiler options

### Returns
Promise<boolean>

false if initialization fails
```

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

### Install Method

Source: https://github.com/keymanapp/keyman/blob/master/windows/docs/engine/api/IKeymanKeyboardFile/index.md

The Install method is used to install the keyboard file into the Keyman Engine for Windows.

```APIDOC
## Install()

### Description
Installs the keyboard file into Keyman Engine for Windows.

### Method
[Method details not specified in source]

### Parameters
[Parameters not specified in source]

### Request Example
[Request example not specified in source]

### Response
[Response details not specified in source]
```

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

### Show Keyboard Picker Example

Source: https://github.com/keymanapp/keyman/blob/master/android/docs/engine/KMManager/showKeyboardPicker.md

Illustrates how to programmatically display the keyboard picker menu when a button is clicked. Ensure the correct context and keyboard type are provided.

```javascript
    final Context context = this;
    ImageButton globeButton = (ImageButton) findViewById(R.id.globeButton);
    globeButton.setOnClickListener(new OnClickListener() {
        @Override
        public void onClick(View v) {
            KMManager.showKeyboardPicker(context, KMManager.KeyboardType.KEYBOARD_TYPE_INAPP);
        }
    });
```