LicenseLynx

https://licenselynx.org
Admin
LicenseLynx is a tool and multi-language library that deterministically maps arbitrary license...
Tokens:14,442
Snippets:131
Trust Score:5.3
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### Install licenselynx with go get

Source: https://licenselynx.org/installation

Fetch the licenselynx Go module. Requires go 1.25 or higher.

```bash
go get github.com/licenselynx/licenselynx/v2

```

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

### Install licenselynx with pip

Source: https://licenselynx.org/installation

Install the licenselynx Python package. Requires Python 3.9 or higher.

```bash
pip install licenselynx

```

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

### Install licenselynx with npm

Source: https://licenselynx.org/installation

Install the licenselynx npm package. Compatible with Node.js 10 and above, with no runtime dependencies.

```bash
npm install @licenselynx/licenselynx

```

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

### Version tag example

Source: https://licenselynx.org/contributing/releases

Example of a version tag used for all LicenseLynx libraries. The version follows semantic versioning with X.Y.Z format.

```text
v0.1.0
```

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

### Example license JSON file (GPL-3.0-only)

Source: https://licenselynx.org/data/data-specification

Shows the structure of an individual license file. The canonical.id must match the filename without .json. Aliases are grouped by source (spdx, custom, osi, scancodeLicensedb, pypi). The risky array contains ambiguous strings returned only when the caller opts in. isMajorVersionOnly indicates whether the canonical identifier has only a major version.

```json
{
    "canonical": {
        "id": "GPL-3.0-only",
        "src": "spdx"
    },
    "aliases": {
        "spdx": [
            "GNU General Public License v3.0 only",
            "GPL-3.0"
        ],
        "custom": [
            "GENERAL PUBLIC LICENSE, version 3 (GPL-3.0)",
            "GPL v3"
        ],
        "osi": [
            "GNU General Public License, Version 3.0"
        ],
        "scancodeLicensedb": [
            "GNU General Public License 3.0",
            "gpl-3.0"
        ],
        "pypi": [
            "License :: GNU General Public License v3",
            "License :: OSI Approved :: GPLv3"
        ]
    },
    "rejected": [],
    "risky": [
        "gpl3"
    ],
    "isMajorVersionOnly": true
}
```

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

### License JSON file structure

Source: https://licenselynx.org/licenselynxworks

Example of a single license JSON file stored in the data folder. Shows the canonical identifier (SPDX ID) and aliases from SPDX, custom, and ScanCode LicenseDB sources, plus empty rejected and risky arrays.

```json
{
  "canonical": {
    "id": "LGPL-2.0-only",
    "src": "spdx"
  },
  "aliases": {
    "spdx": [
      "GNU Library General Public License v2 only",
      "LGPL-2.0"
    ],
    "custom": [],
    "scancodeLicensedb": [
      "GNU Library General Public License 2.0",
      "LicenseRef-LGPL-2",
      "LGPL 2.0",
      "LicenseRef-LGPL-2.0",
      "lgpl-2.0"
    ]
  },
  "rejected": [],
  "risky": []
}
```

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

### Folder layout for organization mappings

Source: https://licenselynx.org/contributing/organization-mappings

Shows the folder layout for organization mappings. Each organization gets its own folder under data/orgs/, and each file uses the same JSON structure as an OSS mapping.

```text
data/
  orgs/
    siemens/
      SISL-1.4.json
      SISL-1.5.json

```

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

### map()

Source: https://licenselynx.org/api-reference

Documents the map() function that resolves a license name to a canonical LicenseObject, including parameters, return values, and examples in Python, Java, and TypeScript.

```APIDOC
## map()

### Description
Maps a license name string to its canonical LicenseObject. The lookup order is: normalize Unicode quotes, search stable map, then risky map (if enabled), then organization-specific map (if provided).

### Method
Function call

### Parameters
- **license_name** (string) - Required - License string to look up
- **risky** (boolean) - Optional, default false - Include risky/ambiguous mappings in the search
- **org** (Organization) - Optional, default None - Additionally search organization-specific mappings

### Returns
- **LicenseObject** or **None** if no match is found (Python/Java). In TypeScript, returns a Promise that rejects with an Error if no match is found.

### Language-Specific Signatures
- **Python**: `LicenseLynx.map(license_name: str, risky: bool = False, org: Optional[Organization] = None) -> Optional[LicenseObject]`
- **Java**: `static LicenseObject map(String licenseName)`, `static LicenseObject map(String licenseName, boolean risky)`, `static LicenseObject map(String licenseName, Organization organization)`, `static LicenseObject map(String licenseName, boolean risky, Organization organization)`
- **TypeScript**: `map(licenseName: string, risky?: boolean, org?: Organization): Promise<LicenseObject>`

### Examples
#### Python
```python
from licenselynx.licenselynx import LicenseLynx
from licenselynx.organization import Organization

result = LicenseLynx.map("Apache-2.0")
if result:
    print(result.id)   # "Apache-2.0"
    print(result.src)  # "spdx"

# No match
result = LicenseLynx.map("nonexistent")
assert result is None

# With risky mappings
result = LicenseLynx.map("gpl3", risky=True)

# With organization
result = LicenseLynx.map("SISL-1.4", org=Organization.SIEMENS)
```

#### Java
```java
import org.licenselynx.LicenseLynx;
import org.licenselynx.LicenseObject;
import org.licenselynx.Organization;

// Basic lookup
LicenseObject result = LicenseLynx.map("Apache-2.0");
if (result != null) {
    System.out.println(result.getId());   // "Apache-2.0"
    System.out.println(result.getSrc());  // "spdx"
}

// No match returns null
LicenseObject missing = LicenseLynx.map("nonexistent");
assert missing == null;

// With risky mappings
LicenseObject risky = LicenseLynx.map("gpl3", true);

// With organization
LicenseObject org = LicenseLynx.map("SISL-1.4", Organization.Siemens);

// With both risky and organization
LicenseObject both = LicenseLynx.map("SISL-1.4", true, Organization.Siemens);
```

#### TypeScript
```typescript
import {map, Organization} from "@licenselynx/licenselynx";

// Basic lookup
const result = map('Apache-2.0');
console.log(result.id);   // "Apache-2.0"
console.log(result.src);  // "spdx"

// With risky mappings
const risky = map('gpl3', true);

// With organization
const orgResult = map('SISL-1.4', false, Organization.Siemens);

// Error handling
try {
    map('nonexistent');
} catch (e) {
    console.error(e.message);  // "License nonexistent not found."
}
```
```

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

### Enable risky mappings in Python

Source: https://licenselynx.org/data/risky-mappings

Shows how to use LicenseLynx in Python. By default, ambiguous aliases like 'gpl3' return None. With risky=True, the mapping returns a LicenseObject for GPL-3.0-only.

```python
from licenselynx.licenselynx import LicenseLynx

# Stable only (default)
result = LicenseLynx.map("gpl3")          # None

# With risky mappings
result = LicenseLynx.map("gpl3", risky=True)  # LicenseObject(id="GPL-3.0-only", src="spdx")
```

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

### Enable risky mappings in Java

Source: https://licenselynx.org/data/risky-mappings

Shows how to use LicenseLynx in Java. By default, ambiguous aliases like 'gpl3' return null. With the risky flag set to true, the mapping returns a LicenseObject.

```java
import org.licenselynx.LicenseLynx;

// Stable only (default)
LicenseLynx.map("gpl3");          // null

// With risky mappings
LicenseLynx.map("gpl3", true);    // LicenseObject
```

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

### Python map() signature and usage

Source: https://licenselynx.org/api-reference

Python signature and usage of LicenseLynx.map(). Returns None when no match is found. The risky flag enables risky/ambiguous mappings; org adds organization-specific lookups.

```python
LicenseLynx.map(
    license_name: str,
    risky: bool = False,
    org: Optional[Organization] = None
) -> Optional[LicenseObject]

```

```python
from licenselynx.licenselynx import LicenseLynx
from licenselynx.organization import Organization

result = LicenseLynx.map("Apache-2.0")
if result:
    print(result.id)   # "Apache-2.0"
    print(result.src)  # "spdx"

# No match
result = LicenseLynx.map("nonexistent")
assert result is None

# With risky mappings
result = LicenseLynx.map("gpl3", risky=True)

# With organization
result = LicenseLynx.map("SISL-1.4", org=Organization.SIEMENS)

```

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

### Java map() overloads and usage

Source: https://licenselynx.org/api-reference

Java overloads and usage of LicenseLynx.map(). Returns null when no match is found. The risky flag enables risky/ambiguous mappings; org adds organization-specific lookups.

```java
static LicenseObject map(String licenseName)
static LicenseObject map(String licenseName, boolean risky)
static LicenseObject map(String licenseName, Organization organization)
static LicenseObject map(String licenseName, boolean risky, Organization organization)

```

```java
import org.licenselynx.LicenseLynx;
import org.licenselynx.LicenseObject;
import org.licenselynx.Organization;

// Basic lookup
LicenseObject result = LicenseLynx.map("Apache-2.0");
if (result != null) {
    System.out.println(result.getId());   // "Apache-2.0"
    System.out.println(result.getSrc());  // "spdx"
}

// No match returns null
LicenseObject missing = LicenseLynx.map("nonexistent");
assert missing == null;

// With risky mappings
LicenseObject risky = LicenseLynx.map("gpl3", true);

// With organization
LicenseObject org = LicenseLynx.map("SISL-1.4", Organization.Siemens);

// With both risky and organization
LicenseObject both = LicenseLynx.map("SISL-1.4", true, Organization.Siemens);

```

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

### Source type helper methods in Java

Source: https://licenselynx.org/api-reference

Shows how to classify a LicenseObject by its source using the helper methods. All return boolean. Methods: isSpdxIdentifier(), isScanCodeLicenseDbIdentifier(), isCustomSource(), isOrganizationSource(), isOrganizationSource(Organization.Siemens).

```java
import org.licenselynx.LicenseLynx;
import org.licenselynx.LicenseObject;
import org.licenselynx.Organization;

LicenseObject result = LicenseLynx.map("MIT");

result.isSpdxIdentifier();
result.isScanCodeLicenseDbIdentifier();
result.isCustomSource();
result.isOrganizationSource();
result.isOrganizationSource(Organization.Siemens);

```

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

### Enable risky mappings in TypeScript

Source: https://licenselynx.org/data/risky-mappings

Shows how to use LicenseLynx in TypeScript. By default, ambiguous aliases like 'gpl3' throw an error. With the risky flag set to true, the mapping returns GPL-3.0-only.

```typescript
import {map} from "@licenselynx/licenselynx";

// Stable only (default)
map('gpl3');                // throws an error

// With risky mappings
map('gpl3', true);          // returns GPL-3.0-only
```

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

### Add licenselynx dependency with Gradle

Source: https://licenselynx.org/installation

Add the licenselynx dependency to a Gradle build. Requires Java 8 or higher.

```groovy
implementation 'org.licenselynx:licenselynx:2.3.4'

```

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

### Source type helper methods in Python

Source: https://licenselynx.org/api-reference

Shows how to classify a LicenseObject by its source using the helper methods. All return boolean. Methods: is_spdx_identifier(), is_scancode_licensedb_identifier(), is_custom_identifier(), is_organization_source(), is_organization_source_of(Organization.SIEMENS).

```python
from licenselynx.licenselynx import LicenseLynx
from licenselynx.organization import Organization

result = LicenseLynx.map("MIT")

result.is_spdx_identifier()
result.is_scancode_licensedb_identifier()
result.is_custom_identifier()
result.is_organization_source()
result.is_organization_source_of(Organization.SIEMENS)

```

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

### Python: Basic map usage

Source: https://licenselynx.org/usage

Basic usage of the map method in Python. Returns a LicenseObject with id and src properties. If no match is found, returns None.

```python
from licenselynx.licenselynx import LicenseLynx

result = LicenseLynx.map("MIT")
print(result.id)   # "MIT"
print(result.src)  # "spdx"

```

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

### Go: Basic map usage

Source: https://licenselynx.org/usage

Basic usage of the map method in Go. Returns a LicenseObject and a boolean indicating success. If not found, the boolean is false and the code panics.

```go
package main

import (
    "fmt"

    "github.com/licenselynx/licenselynx/v2/go"
)

func main() {
    licenseObject, ok := licenselynx.Map("MIT")
    if !ok {
        panic("license not found")
    }

    fmt.Println(licenseObject.ID) // "MIT"
    fmt.Println(licenseObject.Src) // "spdx"
}

```

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

### Add licenselynx dependency with Maven

Source: https://licenselynx.org/installation

Add the licenselynx dependency to a Maven pom.xml. Requires Java 8 or higher.

```xml
<dependency>
    <groupId>org.licenselynx</groupId>
    <artifactId>licenselynx</artifactId>
    <version>2.3.4</version>
</dependency>

```

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

### Run data update for all sources

Source: https://licenselynx.org/data/data-retrieval

Executes the data update entry point for SPDX, ScanCode, and OSI sources. Each flag runs independently, and after the selected updates, the major-version metadata update and validation run automatically.

```bash
poetry run data_update --spdx --scancode --osi

```

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

### Java: Basic map usage

Source: https://licenselynx.org/usage

Basic usage of the map method in Java. Returns a LicenseObject with getId() and getSrc() methods. If no match is found, returns null.

```java
import org.licenselynx.LicenseLynx;
import org.licenselynx.LicenseObject;

LicenseObject result = LicenseLynx.map("MIT");
System.out.println(result.getId());   // "MIT"
System.out.println(result.getSrc());  // "spdx"

```

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

### Source Type Helpers

Source: https://licenselynx.org/api-reference

Methods to classify a LicenseObject by its source. All return boolean. These helpers are available on the result of the map() function.

```APIDOC
## Source Type Helpers

### Description
Methods to classify a `LicenseObject` by its source. All return `boolean`.

### Methods
- **is_spdx_identifier()** (boolean) - Returns true if the license object is an SPDX identifier.
- **is_scancode_licensedb_identifier()** (boolean) - Returns true if the license object is a ScanCode LicenseDB identifier.
- **is_custom_identifier()** (boolean) - Returns true if the license object is a custom identifier.
- **is_organization_source()** (boolean) - Returns true if the license object is from an organization source.
- **is_organization_source_of(org)** (boolean) - Returns true if the license object is from the specified organization.

### Usage Examples

#### Python
```python
from licenselynx.licenselynx import LicenseLynx
from licenselynx.organization import Organization

result = LicenseLynx.map("MIT")

result.is_spdx_identifier()
result.is_scancode_licensedb_identifier()
result.is_custom_identifier()
result.is_organization_source()
result.is_organization_source_of(Organization.SIEMENS)
```

#### Java
```java
import org.licenselynx.LicenseLynx;
import org.licenselynx.LicenseObject;
import org.licenselynx.Organization;

LicenseObject result = LicenseLynx.map("MIT");

result.isSpdxIdentifier();
result.isScanCodeLicenseDbIdentifier();
result.isCustomSource();
result.isOrganizationSource();
result.isOrganizationSource(Organization.Siemens);
```

#### TypeScript
```typescript
import {
  isCustomIdentifier,
  isOrganizationSource,
  isOrganizationSourceOf,
  isScancodeLicensedbIdentifier,
  isSpdxIdentifier,
  map,
  Organization,
} from "@licenselynx/licenselynx";

const result = map('MIT');

isSpdxIdentifier(result);
isScancodeLicensedbIdentifier(result);
isCustomIdentifier(result);
isOrganizationSource(result);
isOrganizationSourceOf(result, Organization.Siemens);
```
```

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

### LicenseObject

Source: https://licenselynx.org/api-reference

Describes the LicenseObject return type with its fields and language-specific accessors.

```APIDOC
## LicenseObject

### Description
Represents the result of a license lookup. Contains the canonical license identifier and its source.

### Fields
- **id** (string) - Canonical license identifier (e.g., "MIT", "Apache-2.0", "bsd-new")
- **src** (string) - Origin of the mapping: "spdx", "scancode-licensedb", "custom", or an organization name

### Language-Specific Accessors
- **Python**: `result.id`, `result.src`
- **Java**: `result.getId()`, `result.getSrc()` (deprecated, use `getCanonicalSource()`)
- **TypeScript**: `result.id`, `result.src`
```

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

### TypeScript: Basic map usage

Source: https://licenselynx.org/usage

Basic usage of the map method in TypeScript. Returns a LicenseObject with id and src properties. If no match is found, the Promise rejects.

```typescript
import { map } from "@licenselynx/licenselynx";

const result = map("MIT");
console.log(result.id); // "MIT"
console.log(result.src); // "spdx"

```

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

### Source type helper functions in TypeScript

Source: https://licenselynx.org/api-reference

Shows how to classify a LicenseObject by its source using the helper functions. All return boolean. Functions: isSpdxIdentifier, isScancodeLicensedbIdentifier, isCustomIdentifier, isOrganizationSource, isOrganizationSourceOf(result, Organization.Siemens).

```typescript
import {
  isCustomIdentifier,
  isOrganizationSource,
  isOrganizationSourceOf,
  isScancodeLicensedbIdentifier,
  isSpdxIdentifier,
  map,
  Organization,
} from "@licenselynx/licenselynx";

const result = map('MIT');

isSpdxIdentifier(result);
isScancodeLicensedbIdentifier(result);
isCustomIdentifier(result);
isOrganizationSource(result);
isOrganizationSourceOf(result, Organization.Siemens);

```

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

### Organization Mappings: map with org parameter

Source: https://licenselynx.org/usage

Usage of the optional org parameter for looking up organization-specific licenses (e.g., inner-source licenses). The full Organization enum is in the API Reference.

```python
from licenselynx.organization import Organization

result = LicenseLynx.map("SISL-1.4", org=Organization.SIEMENS)

```

```java
import org.licenselynx.Organization;

LicenseObject result = LicenseLynx.map("SISL-1.4", Organization.Siemens);

```

```typescript
import {map, Organization} from "@licenselynx/licenselynx";

const result = map('SISL-1.4', false, Organization.Siemens);

```

```go
licenseObject, ok := licenselynx.Map("SISL 1.5", licenselynx.WithOrganization(licenselynx.OrgSiemens))

```

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

### Merged Mapping File Structure (merged_data.json)

Source: https://licenselynx.org/data/data-specification

Shows the structure of the merged_data.json file produced by the build pipeline. The top-level keys are stableMap, riskyMap, and organization-specific maps (e.g., siemens). Each entry is keyed by an alias string and contains an id (canonical license identifier) and a src (source of the canonical name).

```json
{
    "stableMap": {
        "MIT": {
            "id": "MIT",
            "src": "spdx"
        },
        "MIT License": {
            "id": "MIT",
            "src": "spdx"
        },
        "mit": {
            "id": "MIT",
            "src": "scancode-licensedb"
        },
        ...
    },
    "riskyMap": {
        "gpl3": {
            "id": "GPL-3.0-only",
            "src": "spdx"
        },
        ...
    },
    "siemens": {
        "SISL-1.4": {
            "id": "SISL-1.4",
            "src": "siemens"
        },
        ...
    }
}
```

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

### LicenseSource enum values in Python

Source: https://licenselynx.org/api-reference

Shows the LicenseSource enum values for Python. The enum is available in all three libraries. Values: SPDX ("spdx"), SCANCODE_LICENSEDB ("scancode-licensedb"), CUSTOM ("custom").

```python
from licenselynx.license_source import LicenseSource

LicenseSource.SPDX                # "spdx"
LicenseSource.SCANCODE_LICENSEDB   # "scancode-licensedb"
LicenseSource.CUSTOM               # "custom"

```

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

### Risky Mappings: map with risky parameter

Source: https://licenselynx.org/usage

Usage of the optional risky parameter in all languages. When enabled, the lookup falls back to lower-confidence mappings if no match is found in the stable map.

```python
result = LicenseLynx.map("gpl3", risky=True)

```

```java
LicenseObject result = LicenseLynx.map("gpl3", true);

```

```typescript
const result = map('gpl3', true);

```

```go
riskyLicenseObject, ok := licenselynx.Map("License :: LGPLv3", licenselynx.WithRisky())
if ok {
    fmt.Println(riskyLicenseObject.ID)
}

```

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

### LicenseSource enum values in Java

Source: https://licenselynx.org/api-reference

Shows the LicenseSource enum values for Java. The enum is available in all three libraries. Values: Spdx ("spdx"), ScancodeLicensedb ("scancode-licensedb"), Custom ("custom").

```java
import org.licenselynx.LicenseSource;

LicenseSource.Spdx                // "spdx"
LicenseSource.ScancodeLicensedb   // "scancode-licensedb"
LicenseSource.Custom              // "custom"

```

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

### LicenseSource Enum

Source: https://licenselynx.org/api-reference

Enum representing the available license sources: SPDX, ScanCode LicenseDB, and custom. Available in Python, Java, and TypeScript.

```APIDOC
## LicenseSource Enum

### Description
Enum representing the available license sources: SPDX, ScanCode LicenseDB, and custom.

### Values
- **SPDX** (string) - "spdx"
- **SCANCODE_LICENSEDB** (string) - "scancode-licensedb"
- **CUSTOM** (string) - "custom"

### Usage Examples

#### Python
```python
from licenselynx.license_source import LicenseSource

LicenseSource.SPDX                # "spdx"
LicenseSource.SCANCODE_LICENSEDB   # "scancode-licensedb"
LicenseSource.CUSTOM               # "custom"
```

#### Java
```java
import org.licenselynx.LicenseSource;

LicenseSource.Spdx                // "spdx"
LicenseSource.ScancodeLicensedb   // "scancode-licensedb"
LicenseSource.Custom              // "custom"
```

#### TypeScript
```typescript
import {LicenseSource} from "@licenselynx/licenselynx";

LicenseSource.Spdx                // "spdx"
LicenseSource.ScancodeLicensedb   // "scancode-licensedb"
LicenseSource.Custom              // "custom"
```
```

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

### LicenseObject fields in Python, Java, and TypeScript

Source: https://licenselynx.org/api-reference

Shows the fields of the LicenseObject returned by map() in each language. In Java, getSrc() is deprecated in favor of getCanonicalSource().

```python
result.id   # str
result.src  # str

```

```java
result.getId()   // String (annotated @Nonnull)
result.getSrc()  // String (annotated @Nonnull, deprecated -- use getCanonicalSource())

```

```typescript
result.id   // readonly string
result.src  // readonly string

```

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

### TypeScript map() signature and usage

Source: https://licenselynx.org/api-reference

TypeScript signature and usage of map(). Returns a Promise that rejects with an Error if no match is found. The risky flag enables risky/ambiguous mappings; org adds organization-specific lookups.

```typescript
map(licenseName: string, risky?: boolean, org?: Organization): Promise<LicenseObject>

```

```typescript
import {map, Organization} from "@licenselynx/licenselynx";

// Basic lookup
const result = map('Apache-2.0');
console.log(result.id);   // "Apache-2.0"
console.log(result.src);  // "spdx"

// With risky mappings
const risky = map('gpl3', true);

// With organization
const orgResult = map('SISL-1.4', false, Organization.Siemens);

// Error handling
try {
    map('nonexistent');
} catch (e) {
    console.error(e.message);  // "License nonexistent not found."
}

```

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

### Recognized Quote Characters List

Source: https://licenselynx.org/data/matching-behavior

Defines the set of Unicode quote characters that LicenseLynx normalizes to ASCII single quotes. Includes single and double quote variants, primes, and angle quotation marks.

```python
quote_characters = [
    # Single quotes
    "\u2018",  # LEFT SINGLE QUOTATION MARK '
    "\u2019",  # RIGHT SINGLE QUOTATION MARK '
    "\u201A",  # SINGLE LOW-9 QUOTATION MARK ‚
    "\u201B",  # SINGLE HIGH-REVERSED-9 QUOTATION MARK ‛
    "\u2032",  # PRIME (often used as an apostrophe) ′
    "\uFF07",  # FULLWIDTH APOSTROPHE ＇
    # Double quotes
    "\u201C",  # LEFT DOUBLE QUOTATION MARK "
    "\u201D",  # RIGHT DOUBLE QUOTATION MARK "
    "\u201E",  # DOUBLE LOW-9 QUOTATION MARK „
    "\u201F",  # DOUBLE HIGH-REVERSED-9 QUOTATION MARK ‟
    "\u2033",  # DOUBLE PRIME ″
    "\u00AB",  # LEFT-POINTING DOUBLE ANGLE QUOTATION MARK «
    "\u00BB",  # RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK »
    "\uFF02",  # FULLWIDTH QUOTATION MARK ＂
]
```

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

### LicenseSource enum values in TypeScript

Source: https://licenselynx.org/api-reference

Shows the LicenseSource enum values for TypeScript. The enum is available in all three libraries. Values: Spdx ("spdx"), ScancodeLicensedb ("scancode-licensedb"), Custom ("custom").

```typescript
import {LicenseSource} from "@licenselynx/licenselynx";

LicenseSource.Spdx                // "spdx"
LicenseSource.ScancodeLicensedb   // "scancode-licensedb"
LicenseSource.Custom              // "custom"

```

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

### Organization Enum

Source: https://licenselynx.org/api-reference

Enum representing organization-specific license mappings. Used as the optional `org` parameter of `map()` to include organization-specific license mappings in the lookup.

```APIDOC
## Organization Enum

### Description
Enum representing organization-specific license mappings. Used as the optional `org` parameter of `map()` to include organization-specific license mappings in the lookup.

### Values
- **SIEMENS** (string) - "siemens"

### Usage Examples

#### Python
```python
from licenselynx.organization import Organization

Organization.SIEMENS   # "siemens"
```

#### Java
```java
import org.licenselynx.Organization;

Organization.Siemens   // "siemens"
```

#### TypeScript
```typescript
import {Organization} from "@licenselynx/licenselynx";

Organization.Siemens   // "siemens"
```
```

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

### Organization enum values in Java

Source: https://licenselynx.org/api-reference

Shows the Organization enum values for Java. Used as the optional `org` parameter of `map()` to include organization-specific license mappings. Value: Siemens ("siemens").

```java
import org.licenselynx.Organization;

Organization.Siemens   // "siemens"

```

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

### Organization enum values in Python

Source: https://licenselynx.org/api-reference

Shows the Organization enum values for Python. Used as the optional `org` parameter of `map()` to include organization-specific license mappings. Value: SIEMENS ("siemens").

```python
from licenselynx.organization import Organization

Organization.SIEMENS   # "siemens"

```

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

### Organization enum values in TypeScript

Source: https://licenselynx.org/api-reference

Shows the Organization enum values for TypeScript. Used as the optional `org` parameter of `map()` to include organization-specific license mappings. Value: Siemens ("siemens").

```typescript
import {Organization} from "@licenselynx/licenselynx";

Organization.Siemens   // "siemens"

```
Tokens:
Raw