@tak-ps/node-cot 14.0.1 → 14.0.2

package/CHANGELOG.md

@@ -12,6 +12,10 @@
 
 ### Pending Fixed
 
+### v14.0.2 - 2025-07-13
+
+- :rocket: Include .d.ts files in output
+
 ### v14.0.1 - 2025-07-13
 
 - :bug: Ensure `archived: true` is set on normalized features as these will result in `u-d` type CoTs

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import CoT from './lib/cot.js';
+export * from './lib/parser.js';
+export * from './lib/types/geojson.js';
+export * as Feature from './lib/types/feature.js';
+export * as Types from './lib/types/types.js';
+export * as CoTTypes from './lib/types/cot-types.js';
+export * as MilSymType from './lib/utils/2525.js';
+export * from './lib/sensor.js';
+export * from './lib/data-package.js';
+export * from './lib/xml/basemap.js';
+export * from './lib/xml/iconset.js';
+export * from './lib/builders/chat.js';
+export * from './lib/builders/route.js';
+export * from './lib/builders/fileshare.js';
+export * from './lib/builders/force-delete.js';
+export default CoT;

package/dist/lib/builders/chat.d.ts

@@ -0,0 +1,18 @@
+import CoT from '../cot.js';
+export type DirectChatMember = {
+    uid: string;
+    callsign: string;
+};
+export type DirectChatInput = {
+    to: DirectChatMember;
+    from: DirectChatMember;
+    message: string;
+    parent?: string;
+    chatroom?: string;
+    groupOwner?: boolean;
+    messageId?: string;
+    id?: string;
+};
+export declare class DirectChat extends CoT {
+    constructor(chat: DirectChatInput);
+}

package/dist/lib/builders/fileshare.d.ts

@@ -0,0 +1,6 @@
+import CoT from '../cot.js';
+import type { FileShareAttributes } from '../types/types.js';
+import type { Static } from '@sinclair/typebox';
+export declare class FileShare extends CoT {
+    constructor(fileshare: Static<typeof FileShareAttributes>);
+}

package/dist/lib/builders/force-delete.d.ts

@@ -0,0 +1,4 @@
+import CoT from '../cot.js';
+export declare class ForceDelete extends CoT {
+    constructor(uid: string);
+}

package/dist/lib/builders/route.d.ts

@@ -0,0 +1,4 @@
+import CoT from '../cot.js';
+export declare class Route extends CoT {
+    constructor(cot?: CoT);
+}

package/dist/lib/cot.d.ts

@@ -0,0 +1,189 @@
+import type { Static } from '@sinclair/typebox';
+import type { Polygon, Position } from './types/feature.js';
+import type { MartiDestAttributes, LinkAttributes, CreatorAttributes, VideoAttributes, SensorAttributes, VideoConnectionEntryAttributes } from './types/types.js';
+import JSONCoT, { Detail } from './types/types.js';
+export type CoTOptions = {
+    creator?: CoT | {
+        uid: string;
+        type: string;
+        callsign: string;
+        time?: Date | string;
+    };
+};
+/**
+ * Convert to and from an XML CoT message
+ * @class
+ *
+ * @param cot A string/buffer containing the XML representation or the xml-js object tree
+ *
+ * @prop raw Raw XML-JS representation of CoT
+ */
+export default class CoT {
+    raw: Static<typeof JSONCoT>;
+    metadata: Record<string, unknown>;
+    path: string;
+    constructor(cot: Static<typeof JSONCoT>, opts?: CoTOptions);
+    /**
+     * Returns or sets the UID of the CoT
+     */
+    uid(uid?: string): string;
+    /**
+     * Returns or sets the Callsign of the CoT
+     */
+    type(type?: string): string;
+    /**
+     * Returns or sets the Archived State of the CoT
+     *
+     * @param callsign - Optional Archive state to set
+     */
+    archived(archived?: boolean): boolean;
+    /**
+     * Returns or sets the Callsign of the CoT
+     *
+     * @param callsign - Optional Callsign to set
+     */
+    callsign(callsign?: string): string;
+    /**
+     * Return Detail Object of CoT or create one if it doesn't yet exist and pass a reference
+     */
+    detail(): Static<typeof Detail>;
+    /**
+     * Add a given Dest tag to a CoT
+     */
+    addDest(dest: Static<typeof MartiDestAttributes>): CoT;
+    addVideo(video: Static<typeof VideoAttributes>, connection?: Static<typeof VideoConnectionEntryAttributes>): CoT;
+    position(position?: Static<typeof Position>): Static<typeof Position>;
+    sensor(sensor?: Static<typeof SensorAttributes>): Static<typeof Polygon> | null;
+    creator(creator?: {
+        uid: string;
+        type: string;
+        callsign: string;
+        time: Date | string | undefined;
+    }): Static<typeof CreatorAttributes> | undefined;
+    addLink(link: Static<typeof LinkAttributes>): CoT;
+    is_stale(): boolean;
+    /**
+     * Determines if the CoT message represents a Tasking Message
+     *
+     * @return {boolean}
+     */
+    is_tasking(): boolean;
+    /**
+     * Determines if the CoT message represents a Chat Message
+     *
+     * @return {boolean}
+     */
+    is_chat(): boolean;
+    /**
+     * Determines if the CoT message represents a Friendly Element
+     *
+     * @return {boolean}
+     */
+    is_friend(): boolean;
+    /**
+     * Determines if the CoT message represents a Hostile Element
+     *
+     * @return {boolean}
+     */
+    is_hostile(): boolean;
+    /**
+     * Determines if the CoT message represents a Unknown Element
+     *
+     * @return {boolean}
+     */
+    is_unknown(): boolean;
+    /**
+     * Determines if the CoT message represents a Pending Element
+     *
+     * @return {boolean}
+     */
+    is_pending(): boolean;
+    /**
+     * Determines if the CoT message represents an Assumed Element
+     *
+     * @return {boolean}
+     */
+    is_assumed(): boolean;
+    /**
+     * Determines if the CoT message represents a Neutral Element
+     *
+     * @return {boolean}
+     */
+    is_neutral(): boolean;
+    /**
+     * Determines if the CoT message represents a Suspect Element
+     *
+     * @return {boolean}
+     */
+    is_suspect(): boolean;
+    /**
+     * Determines if the CoT message represents a Joker Element
+     *
+     * @return {boolean}
+     */
+    is_joker(): boolean;
+    /**
+     * Determines if the CoT message represents a Faker Element
+     *
+     * @return {boolean}
+     */
+    is_faker(): boolean;
+    /**
+     * Determines if the CoT message represents an Element
+     *
+     * @return {boolean}
+     */
+    is_atom(): boolean;
+    /**
+     * Determines if the CoT message represents an Airborne Element
+     *
+     * @return {boolean}
+     */
+    is_airborne(): boolean;
+    /**
+     * Determines if the CoT message represents a Ground Element
+     *
+     * @return {boolean}
+     */
+    is_ground(): boolean;
+    /**
+     * Determines if the CoT message represents an Installation
+     *
+     * @return {boolean}
+     */
+    is_installation(): boolean;
+    /**
+     * Determines if the CoT message represents a Vehicle
+     *
+     * @return {boolean}
+     */
+    is_vehicle(): boolean;
+    /**
+     * Determines if the CoT message represents Equipment
+     *
+     * @return {boolean}
+     */
+    is_equipment(): boolean;
+    /**
+     * Determines if the CoT message represents a Surface Element
+     *
+     * @return {boolean}
+     */
+    is_surface(): boolean;
+    /**
+     * Determines if the CoT message represents a Subsurface Element
+     *
+     * @return {boolean}
+     */
+    is_subsurface(): boolean;
+    /**
+     * Determines if the CoT message represents a UAV Element
+     *
+     * @return {boolean}
+     */
+    is_uav(): boolean;
+    /**
+     * Return a CoT Message
+     */
+    static ping(): CoT;
+}

package/dist/lib/data-package.d.ts

@@ -0,0 +1,248 @@
+import type { Static } from '@sinclair/typebox';
+import { Readable } from 'node:stream';
+import CoT from './cot.js';
+export declare const Parameter: import("@sinclair/typebox").TObject<{
+    _attributes: import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+        value: import("@sinclair/typebox").TString;
+    }>;
+}>;
+export declare const ManifestContent: import("@sinclair/typebox").TObject<{
+    _attributes: import("@sinclair/typebox").TObject<{
+        ignore: import("@sinclair/typebox").TBoolean;
+        zipEntry: import("@sinclair/typebox").TString;
+    }>;
+    Parameter: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+        _attributes: import("@sinclair/typebox").TObject<{
+            name: import("@sinclair/typebox").TString;
+            value: import("@sinclair/typebox").TString;
+        }>;
+    }>, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        _attributes: import("@sinclair/typebox").TObject<{
+            name: import("@sinclair/typebox").TString;
+            value: import("@sinclair/typebox").TString;
+        }>;
+    }>>]>;
+}>;
+export declare const Group: import("@sinclair/typebox").TObject<{
+    _attributes: import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+    }>;
+}>;
+export declare const Permission: import("@sinclair/typebox").TObject<{
+    _attributes: import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+    }>;
+}>;
+export declare const Manifest: import("@sinclair/typebox").TObject<{
+    MissionPackageManifest: import("@sinclair/typebox").TObject<{
+        _attributes: import("@sinclair/typebox").TObject<{
+            version: import("@sinclair/typebox").TString;
+        }>;
+        Configuration: import("@sinclair/typebox").TObject<{
+            Parameter: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                _attributes: import("@sinclair/typebox").TObject<{
+                    name: import("@sinclair/typebox").TString;
+                    value: import("@sinclair/typebox").TString;
+                }>;
+            }>>;
+        }>;
+        Contents: import("@sinclair/typebox").TObject<{
+            Content: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                _attributes: import("@sinclair/typebox").TObject<{
+                    ignore: import("@sinclair/typebox").TBoolean;
+                    zipEntry: import("@sinclair/typebox").TString;
+                }>;
+                Parameter: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                    _attributes: import("@sinclair/typebox").TObject<{
+                        name: import("@sinclair/typebox").TString;
+                        value: import("@sinclair/typebox").TString;
+                    }>;
+                }>, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                    _attributes: import("@sinclair/typebox").TObject<{
+                        name: import("@sinclair/typebox").TString;
+                        value: import("@sinclair/typebox").TString;
+                    }>;
+                }>>]>;
+            }>, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                _attributes: import("@sinclair/typebox").TObject<{
+                    ignore: import("@sinclair/typebox").TBoolean;
+                    zipEntry: import("@sinclair/typebox").TString;
+                }>;
+                Parameter: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                    _attributes: import("@sinclair/typebox").TObject<{
+                        name: import("@sinclair/typebox").TString;
+                        value: import("@sinclair/typebox").TString;
+                    }>;
+                }>, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                    _attributes: import("@sinclair/typebox").TObject<{
+                        name: import("@sinclair/typebox").TString;
+                        value: import("@sinclair/typebox").TString;
+                    }>;
+                }>>]>;
+            }>>]>>;
+        }>;
+        Groups: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            group: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                _attributes: import("@sinclair/typebox").TObject<{
+                    name: import("@sinclair/typebox").TString;
+                }>;
+            }>, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                _attributes: import("@sinclair/typebox").TObject<{
+                    name: import("@sinclair/typebox").TString;
+                }>;
+            }>>]>>;
+        }>>;
+        Role: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            _attributes: import("@sinclair/typebox").TObject<{
+                name: import("@sinclair/typebox").TString;
+            }>;
+            Permissions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                _attributes: import("@sinclair/typebox").TObject<{
+                    name: import("@sinclair/typebox").TString;
+                }>;
+            }>, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                _attributes: import("@sinclair/typebox").TObject<{
+                    name: import("@sinclair/typebox").TString;
+                }>;
+            }>>]>>;
+        }>>;
+    }>;
+}>;
+/**
+ * Helper class for creating and parsing static Data Packages
+ * @class
+ *
+ * @prop path           The local path to the Data Package working directory
+ * @prop destroyed      Indcates that the DataPackage has been destroyed and all local files removed
+ * @prop version        DataPackage schema version - 2 is most common
+ * @prop contents       Array Manifest of DataPackage contents
+ * @prop settings       Top level DataPackage settings
+ */
+export declare class DataPackage {
+    #private;
+    path: string;
+    destroyed: boolean;
+    version: string;
+    contents: Array<Static<typeof ManifestContent>>;
+    settings: {
+        uid: string;
+        name: string;
+        onReceiveImport?: boolean;
+        onReceiveDelete?: boolean;
+        [k: string]: boolean | string | undefined;
+    };
+    unknown: Record<string, unknown>;
+    /**
+     * @constructor
+     * @param uid       Unique ID of the Data Package
+     * @param name      Human Readable name of the DataPackage
+     * @param opts      Optional Options
+    */
+    constructor(uid?: string, name?: string, opts?: {
+        path?: string;
+    });
+    /**
+     * The Package should be imported and then removed
+     */
+    setEphemeral(): void;
+    /**
+     * The Package should be imported and the package retained
+     */
+    setPermanent(): void;
+    /**
+     * Return a string version of the Manifest document
+     */
+    manifest(): string;
+    /**
+     * Mission Sync archived are returned in DataPackage format
+     * Return true if the DataPackage is a MissionSync Archive
+     */
+    isMissionArchive(): boolean;
+    /**
+     * When DataPackages are uploaded to TAK Server they generally use an EUD
+     * calculated Hash
+     */
+    static hash(path: string): Promise<string>;
+    /**
+     * When DataPackages are uploaded to TAK Server they generally use an EUD
+     * calculated Hash
+     */
+    hash(entry: string): Promise<string>;
+    /**
+     * Return a DataPackage version of a raw Data Package Zip
+     *
+     * @public
+     * @param input path to zipped DataPackage on disk
+     * @param [opts] Parser Options
+     * @param [opts.strict] By default the DataPackage must contain a manifest file, turning strict mode off will generate a manifest based on the contents of the file
+     * @param [opts.cleanup] If the Zip is parsed as a DataSync successfully, remove the initial zip file
+     */
+    static parse(input: string | URL, opts?: {
+        strict?: boolean;
+        cleanup?: boolean;
+    }): Promise<DataPackage>;
+    /**
+     * Return CoT objects for all CoT type features in the Data Package
+     *
+     * CoTs have their `attachment_list` field populated if parseAttachments is set to true.
+     *   While this field is populated automatically by some ATAK actions such as QuickPic
+         other attachment actions do not automatically populate this field other than the link
+         provided between a CoT and it's attachment in the MANIFEST file
+     */
+    cots(opts?: {
+        respectIgnore: boolean;
+        parseAttachments: boolean;
+    }): Promise<Array<CoT>>;
+    /**
+     * Return a list of files that are NOT attachments or CoT markers
+     * The Set returned has a list of file paths that can be passed to getFile(path)
+     */
+    files(opts?: {
+        respectIgnore: boolean;
+    }): Promise<Set<string>>;
+    /**
+     * Return attachments that are associated in the Manifest with a given CoT
+     * Note: this does not return files that are NOT associated with a CoT
+     */
+    attachments(opts?: {
+        respectIgnore: boolean;
+    }): Promise<Map<string, Array<Static<typeof ManifestContent>>>>;
+    getFileBuffer(path: string): Promise<Buffer>;
+    /**
+     * Get any file from a Package
+     */
+    getFile(path: string): Promise<Readable>;
+    /**
+     * Add any file to a Package
+     *
+     * @param file - Input ReadableStream of File at attach
+     * @param opts - Options
+     * @param opts.uid - Optional UID for the File, a UUID will be generated if not supplied
+     * @param opts.name - Filename for the file
+     * @param opts.ignore - Should the file be ignore, defaults to false
+     * @param opts.attachment - Should the file be associated as an attachment to a CoT. If so this should contain the UID of the CoT
+     */
+    addFile(file: Readable | Buffer | string, opts: {
+        uid?: string;
+        name: string;
+        ignore?: boolean;
+        attachment?: string;
+    }): Promise<void>;
+    /**
+     * Add a CoT marker to the Package
+     */
+    addCoT(cot: CoT, opts?: {
+        ignore: boolean;
+    }): Promise<void>;
+    /**
+     * Destory the underlying FS resources and prevent further mutation
+     */
+    destroy(): Promise<void>;
+    /**
+     * Compile the DataPackage into a TAK compatible ZIP File
+     * Note this function can be called multiple times and does not
+     * affect the ability of the class to continue building a Package
+     */
+    finalize(): Promise<string>;
+}

package/dist/lib/parser/from_geojson.d.ts

@@ -0,0 +1,12 @@
+import type { Static } from '@sinclair/typebox';
+import { InputFeature } from '../types/feature.js';
+import CoT from '../cot.js';
+import type { CoTOptions } from '../cot.js';
+/**
+ * Return an CoT Message given a GeoJSON Feature
+ *
+ * @param {Object} feature GeoJSON Point Feature
+ *
+ * @return {CoT}
+ */
+export declare function from_geojson(feature: Static<typeof InputFeature>, opts?: CoTOptions): Promise<CoT>;

package/dist/lib/parser/normalize_geojson.d.ts

@@ -0,0 +1,11 @@
+import type { Static } from '@sinclair/typebox';
+import { Feature } from '../types/feature.js';
+import { GeoJSONFeature } from '../types/geojson.js';
+/**
+ * Given a generic GeoJSON Feature, convert it to a CoT Featurt
+ *
+ * @param {Object} feature GeoJSON Feature
+ *
+ * @return {CoT}
+ */
+export declare function normalize_geojson(feature: Static<typeof GeoJSONFeature>): Promise<Static<typeof Feature>>;

package/dist/lib/parser/to_geojson.d.ts

@@ -0,0 +1,7 @@
+import type { Static } from '@sinclair/typebox';
+import type { Feature } from '../types/feature.js';
+import CoT from '../cot.js';
+/**
+ * Return a GeoJSON Feature from an XML CoT message
+ */
+export declare function to_geojson(cot: CoT): Promise<Static<typeof Feature>>;

package/dist/lib/parser.d.ts

@@ -0,0 +1,53 @@
+import type { Static } from '@sinclair/typebox';
+import type { Feature } from './types/feature.js';
+import type { GeoJSONFeature } from './types/geojson.js';
+import { InputFeature } from './types/feature.js';
+import CoT from './cot.js';
+import type { CoTOptions } from './cot.js';
+/**
+ * Convert to and from an XML CoT message
+ * @class
+ *
+ * @param cot A string/buffer containing the XML representation or the xml-js object tree
+ *
+ * @prop raw Raw XML-JS representation of CoT
+ */
+export declare class CoTParser {
+    static validate(cot: CoT, opts?: {
+        flow: boolean;
+    }): CoT;
+    /**
+     * Detect difference between CoT messages
+     * Note: This diffs based on GeoJSON Representation of message
+     *       So if unknown properties are present they will be excluded from the diff
+     */
+    static isDiff(aCoT: CoT, bCoT: CoT, opts?: {
+        diffMetadata: boolean;
+        diffStaleStartTime: boolean;
+        diffDest: boolean;
+        diffFlow: boolean;
+    }): Promise<boolean>;
+    static from_xml(raw: Buffer | string, opts?: CoTOptions): CoT;
+    static to_xml(cot: CoT): string;
+    /**
+     * Return an ATAK Compliant Protobuf
+     */
+    static to_proto(cot: CoT, version?: number): Promise<Uint8Array>;
+    /**
+     * Return a GeoJSON Feature from an XML CoT message
+     */
+    static to_geojson(cot: CoT): Promise<Static<typeof Feature>>;
+    /**
+     * Parse an ATAK compliant Protobuf to a JS Object
+     */
+    static from_proto(raw: Uint8Array, version?: number, opts?: CoTOptions): Promise<CoT>;
+    static normalize_geojson(feature: Static<typeof GeoJSONFeature>): Promise<Static<typeof Feature>>;
+    /**
+     * Return an CoT Message given a GeoJSON Feature
+     *
+     * @param {Object} feature GeoJSON Point Feature
+     *
+     * @return {CoT}
+     */
+    static from_geojson(feature: Static<typeof InputFeature>, opts?: CoTOptions): Promise<CoT>;
+}

package/dist/lib/sensor.d.ts

@@ -0,0 +1,9 @@
+import type { Static } from '@sinclair/typebox';
+import { Position, Polygon } from './types/feature.js';
+import { SensorAttributes } from './types/types.js';
+export default class Sensor {
+    center: Static<typeof Position>;
+    sensor: Static<typeof SensorAttributes>;
+    constructor(center: Static<typeof Position>, sensor: Static<typeof SensorAttributes>);
+    to_geojson(): Static<typeof Polygon> | null;
+}

package/dist/lib/type.d.ts

@@ -0,0 +1,10 @@
+import type { Static, TSchema, TUnknown } from '@sinclair/typebox';
+export type TypeOpts = {
+    verbose?: boolean;
+    default?: boolean;
+    convert?: boolean;
+    clean?: boolean;
+};
+export default class TypeValidator {
+    static type<T extends TSchema = TUnknown>(type: T, body: unknown, opts?: TypeOpts): Static<T>;
+}

package/dist/lib/types/basemap.d.ts

@@ -0,0 +1,49 @@
+export declare const BasemapMapSource: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TObject<{
+        _text: import("@sinclair/typebox").TString;
+    }>;
+    minZoom: import("@sinclair/typebox").TObject<{
+        _text: import("@sinclair/typebox").TInteger;
+    }>;
+    maxZoom: import("@sinclair/typebox").TObject<{
+        _text: import("@sinclair/typebox").TInteger;
+    }>;
+    tileType: import("@sinclair/typebox").TObject<{
+        _text: import("@sinclair/typebox").TString;
+    }>;
+    tileUpdate: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        _text: import("@sinclair/typebox").TString;
+    }>>;
+    url: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        _text: import("@sinclair/typebox").TString;
+    }>>;
+    backgroundColor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        _text: import("@sinclair/typebox").TString;
+    }>>;
+}>;
+declare const _default: import("@sinclair/typebox").TObject<{
+    customMapSource: import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TObject<{
+            _text: import("@sinclair/typebox").TString;
+        }>;
+        minZoom: import("@sinclair/typebox").TObject<{
+            _text: import("@sinclair/typebox").TInteger;
+        }>;
+        maxZoom: import("@sinclair/typebox").TObject<{
+            _text: import("@sinclair/typebox").TInteger;
+        }>;
+        tileType: import("@sinclair/typebox").TObject<{
+            _text: import("@sinclair/typebox").TString;
+        }>;
+        tileUpdate: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            _text: import("@sinclair/typebox").TString;
+        }>>;
+        url: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            _text: import("@sinclair/typebox").TString;
+        }>>;
+        backgroundColor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            _text: import("@sinclair/typebox").TString;
+        }>>;
+    }>;
+}>;
+export default _default;