@tak-ps/cloudtak 12.55.0 → 12.102.0

package/dist/types/plugin.d.ts

@@ -1,11 +1,14 @@
 import type { App } from 'vue';
+import type { Component } from 'vue';
 import type { Router, RouteRecordRaw } from 'vue-router';
 import type { Pinia } from 'pinia';
+import { type PaneConfig } from './src/stores/float.ts';
 import type { MenuItemConfig } from './src/stores/modules/menu.ts';
 import { type DBFeature } from './src/base/database.ts';
 import { type Observable } from 'rxjs';
 import mapgl from 'maplibre-gl';
 export type { MenuItemConfig };
+export type { DBFeature };
 export interface PluginInstance {
     /**
      * Called after `install` if the server has the plugin enabled by default
@@ -96,4 +99,58 @@ export declare class PluginAPI {
             filter?: (feature: DBFeature) => boolean;
         }) => Observable<DBFeature[]>;
     };
+    /**
+     * Manage Breadcrumb Trails
+     */
+    get breadcrumb(): {
+        /**
+         * Manage live breadcrumb trail recording
+         */
+        live: {
+            /**
+             * Enable live breadcrumb trail recording for a given CoT UID
+             * @param uid The CoT UID to start recording
+             */
+            add: (uid: string) => Promise<void>;
+            /**
+             * Disable live breadcrumb trail recording for a given CoT UID
+             * @param uid The CoT UID to stop recording
+             */
+            remove: (uid: string) => Promise<void>;
+            /**
+             * Returns all CoT UIDs that currently have live breadcrumb recording enabled
+             */
+            list: () => Promise<string[]>;
+        };
+    };
+    /**
+     * Manage Floating Panes on top of the Map View
+     */
+    get float(): {
+        /**
+         * Add a new floating pane
+         * @param opts Floating pane configuration
+         */
+        add: (opts: {
+            uid: string;
+            name?: string;
+            component: Component;
+            actions?: Component;
+            props?: Record<string, unknown>;
+            height?: number;
+            width?: number;
+            x?: number;
+            y?: number;
+        }) => import("./src/stores/float.ts").Pane<PaneConfig>;
+        /**
+         * Remove a floating pane
+         * @param uid The unique identifier of the pane to remove
+         */
+        remove: (uid: string) => void;
+        /**
+         * Check if a floating pane exists
+         * @param uid The unique identifier to check
+         */
+        has: (uid: string) => boolean;
+    };
 }

package/dist/types/src/base/chatroom-chats.d.ts

@@ -1,5 +1,6 @@
 import type { DBChatroomChat } from './database.ts';
 import type Atlas from '../workers/atlas.ts';
+import type { Remote } from 'comlink';
 export default class ChatroomChats {
     chatroom: string;
     constructor(chatroom: string);
@@ -7,10 +8,11 @@ export default class ChatroomChats {
     list(opts?: {
         refresh?: boolean;
     }): Promise<Array<DBChatroomChat>>;
+    markRead(): Promise<void>;
     send(message: string, sender: {
         uid: string;
         callsign: string;
-    }, worker: Atlas, recipient?: {
+    }, worker: Remote<Atlas>, recipient?: {
         uid: string;
         callsign: string;
     }): Promise<void>;

package/dist/types/src/base/chatroom.d.ts

@@ -1,5 +1,6 @@
 import type { DBChatroom } from './database.ts';
 import ChatroomChats from './chatroom-chats.ts';
+import { type Observable } from 'dexie';
 import type { ProfileChatroomList, ProfileChatList } from '../types.ts';
 /**
  * High Level Wrapper around the Profile Chatroom API
@@ -10,6 +11,7 @@ export default class Chatroom {
     name: string;
     chats: ChatroomChats;
     constructor(name: string);
+    static liveUnreadCount(): Observable<number>;
     /**
      * Return a Chatroom instance if one already exists in the local DB,
      */

package/dist/types/src/base/config.d.ts

@@ -0,0 +1,17 @@
+import { type Subscription } from 'dexie';
+import type { paths } from '../derived-types.js';
+export type FullConfig = paths['/api/config']['get']['responses']['200']['content']['application/json'];
+export default class Config<K extends keyof FullConfig = keyof FullConfig> {
+    key: K;
+    value: FullConfig[K];
+    _sub?: Subscription;
+    constructor(key: K, value: FullConfig[K]);
+    subscribe(): void;
+    subscribed(): boolean;
+    destroy(): void;
+    static get<K extends keyof FullConfig>(key: K): Promise<Config<K> | undefined>;
+    static list(keys: (keyof FullConfig)[], opts?: {
+        defaults?: Partial<FullConfig>;
+    }): Promise<Partial<FullConfig>>;
+    static refresh(keys: (keyof FullConfig)[]): Promise<Partial<FullConfig>>;
+}

package/dist/types/src/base/contact.d.ts

@@ -0,0 +1,14 @@
+import { type Observable } from 'dexie';
+import type { Contact } from '../types.ts';
+export default class ContactManager {
+    static liveCount(): Observable<number>;
+    static liveList(filter?: string): Observable<Contact[]>;
+    static list(opts?: {
+        token?: string;
+        filter?: string;
+    }): Promise<Contact[]>;
+    static get(uid: string): Promise<Contact | undefined>;
+    static getByCallsign(callsign: string): Promise<Contact | undefined>;
+    static put(contact: Contact): Promise<void>;
+    static sync(token?: string): Promise<Contact[]>;
+}

package/dist/types/src/base/cot.d.ts

@@ -1,5 +1,3 @@
-import type { Remote } from 'comlink';
-import type Atlas from '../workers/atlas.ts';
 import type { Feature, Subscription } from '../types.ts';
 import type { BBox as GeoJSONBBox, Feature as GeoJSONFeature, Geometry as GeoJSONGeometry } from 'geojson';
 export interface Origin {
@@ -17,20 +15,23 @@ export default class COT {
     _path: string;
     _properties: Feature["properties"];
     _geometry: Feature["geometry"];
-    _remote: BroadcastChannel | null;
-    _atlas: Atlas | Remote<Atlas>;
+    _remote: boolean;
+    _liveQuerySubscription: {
+        unsubscribe: () => void;
+    } | null;
+    static selfUid: string | null;
     _username?: string;
     origin: Origin;
-    static load(atlas: Atlas, feat: Feature, origin?: Origin, opts?: {
+    static load(feat: Feature, origin?: Origin, opts?: {
         skipSave?: boolean;
         remote?: boolean;
     }): Promise<COT>;
-    constructor(atlas: Atlas | Remote<Atlas>, feat: Feature, origin?: Origin, opts?: {
+    constructor(feat: Feature, origin?: Origin, opts?: {
         skipSave?: boolean;
         remote?: boolean;
     });
     /**
-     * Begin listening for remote updates
+     * Begin listening for remote updates via a DexieDB live query
      * This is a seperate function due to the issues outlined in: https://stackoverflow.com/q/70184129
      */
     reactivity(): void;

package/dist/types/src/base/database.d.ts

@@ -1,5 +1,5 @@
 import Dexie, { type EntityTable } from 'dexie';
-import type { Feature, Mission, MissionRole } from '../types.ts';
+import type { Feature, GroupChannel, Mission, MissionRole, MissionChange, MissionLog, Contact, Server } from '../types.ts';
 export interface DBIcon {
     name: string;
 }
@@ -9,11 +9,21 @@ export interface DBFeature {
     properties: Feature["properties"];
     geometry: Feature["geometry"];
 }
+export interface DBBreadcrumb {
+    id: string;
+    uid: string;
+    path: string;
+    callsign: string;
+    color?: string;
+    coordinates: number[][];
+    live: boolean;
+}
 export interface DBChatroom {
     id: string;
     name: string;
     created: string;
     updated: string;
+    unread?: number;
     last_read: string | null;
 }
 export interface DBChatroomChat {
@@ -23,6 +33,7 @@ export interface DBChatroomChat {
     sender_uid: string;
     message: string;
     created: string;
+    unread?: boolean;
 }
 export interface DBIconset {
     uid: string;
@@ -78,6 +89,34 @@ export interface DBSubscriptionFeature {
     properties: Feature["properties"];
     geometry: Feature["geometry"];
 }
+export interface DBSubscriptionContent {
+    uid: string;
+    mission: string;
+    timestamp: string;
+    creatorUid?: string;
+    keywords: string[];
+    name: string;
+    hash: string;
+    submissionTime: string;
+    size: number;
+    mimeType?: string;
+    submitter?: string;
+    expiration: number;
+}
+export interface DBSubscriptionChanges extends MissionChange {
+    id?: number;
+    mission: string;
+}
+export interface DBSubscriptionChat {
+    id: string;
+    mission: string;
+    chatroom: string;
+    sender: string;
+    sender_uid: string;
+    message: string;
+    created: string;
+    unread: boolean;
+}
 export interface DBSubscription {
     guid: string;
     name: string;
@@ -87,29 +126,67 @@ export interface DBSubscription {
     dirty: boolean;
     subscribed: boolean;
 }
-export interface DBSubscriptionLog {
+export interface DBSubscriptionLog extends MissionLog {
+    mission: string;
+    read: boolean;
+}
+export interface DBMissionTemplate {
     id: string;
-    dtg?: string;
-    missionNames: string[];
+    name: string;
+    icon: string;
+    description: string;
     created: string;
-    servertime: string;
-    mission: string;
-    content: string;
-    creatorUid: string;
-    contentHashes: unknown[];
+    updated: string;
+}
+export interface DBMissionTemplateLog {
+    id: string;
+    template: string;
+    name: string;
+    icon?: string | null;
+    description: string;
+    created: string;
+    updated: string;
+    schema: unknown;
     keywords: string[];
 }
+export interface DBProfileConfig {
+    key: string;
+    value: unknown;
+}
+export interface DBConfig {
+    key: string;
+    value: unknown;
+}
+export interface DBServer extends Server {
+    _id: string;
+}
+export interface DBCache {
+    key: string;
+    updated: number;
+}
 export type DatabaseType = Dexie & {
     icon: EntityTable<DBIcon, 'name'>;
     iconset: EntityTable<DBIconset, 'uid'>;
+    group: EntityTable<GroupChannel, 'name'>;
     video: EntityTable<DBVideo, 'id'>;
     filter: EntityTable<DBFilter, 'id'>;
     feature: EntityTable<DBFeature, 'id'>;
+    breadcrumb: EntityTable<DBBreadcrumb, 'id'>;
     chatroom: EntityTable<DBChatroom, 'id'>;
     chatroom_chats: EntityTable<DBChatroomChat, 'id'>;
     notification: EntityTable<DBNotification, 'id'>;
     subscription: EntityTable<DBSubscription, 'guid'>;
+    subscription_contents: EntityTable<DBSubscriptionContent, 'uid'>;
+    subscription_changes: EntityTable<DBSubscriptionChanges, 'id'>;
+    server: EntityTable<DBServer, '_id'>;
     subscription_log: EntityTable<DBSubscriptionLog, 'id'>;
     subscription_feature: EntityTable<DBSubscriptionFeature, 'id'>;
+    subscription_chat: EntityTable<DBSubscriptionChat, 'id'>;
+    mission_template: EntityTable<DBMissionTemplate, 'id'>;
+    mission_template_log: EntityTable<DBMissionTemplateLog, 'id'>;
+    profile: EntityTable<DBProfileConfig, 'key'>;
+    config: EntityTable<DBConfig, 'key'>;
+    cache: EntityTable<DBCache, 'key'>;
+    contact: EntityTable<Contact, 'uid'>;
 };
 export declare const db: DatabaseType;

package/dist/types/src/base/events.d.ts

@@ -12,11 +12,13 @@ export declare enum WorkerMessageType {
     Feature_Archived_Removed = "cloudtak:feature:archived:removed",
     Channels_None = "channels:none",
     Channels_List = "channels:list",
-    Contact_Change = "contact:change",
     Connection_Open = "connection:open",
     Connection_Close = "connection:close",
     Mission_Change_Feature = "mission:change:feature",
-    Mission_Invite = "mission:invite"
+    Mission_Invite = "mission:invite",
+    Channel_Change = "channel:change",
+    Feature_Update = "cloudtak:feature:update",
+    Profile_Update = "cloudtak:profile:update"
 }
 export type WorkerMessage = {
     type: WorkerMessageType;

package/dist/types/src/base/group.d.ts

@@ -0,0 +1,27 @@
+import { type Observable } from 'dexie';
+import type { Group, GroupChannel } from '../types.ts';
+export default class GroupManager {
+    /**
+     * Merge an array of API Group entries (each with a single direction string)
+     * into GroupChannel entries keyed by name with direction as a string array
+     */
+    static merge(groups: Group[]): GroupChannel[];
+    /**
+     * Explode a GroupChannel (with direction array) back into individual
+     * API Group entries (each with a single direction string)
+     */
+    static explode(channels: GroupChannel[]): Group[];
+    static live(opts?: {
+        active?: boolean;
+        direction?: string;
+    }): Observable<GroupChannel[]>;
+    static list(opts?: {
+        token?: string;
+        active?: boolean;
+        direction?: string;
+    }): Promise<GroupChannel[]>;
+    static get(name: string): Promise<GroupChannel | undefined>;
+    static put(channels: GroupChannel[] | GroupChannel): Promise<void>;
+    static sync(token?: string): Promise<GroupChannel[]>;
+    static update(channels: GroupChannel[], token?: string): Promise<GroupChannel[]>;
+}

package/dist/types/src/base/handler.d.ts

@@ -1,11 +1,9 @@
 import COT from '../base/cot.ts';
-import type Atlas from '../workers/atlas.ts';
-import type { Remote, TransferHandler } from 'comlink';
+import type { TransferHandler } from 'comlink';
 import type { Feature } from '../types.ts';
 export declare class CloudTAKTransferHandler {
-    atlas: Atlas | Remote<Atlas>;
     remote: boolean;
-    constructor(atlas: Atlas | Remote<Atlas>, transferHandlers: Map<string, TransferHandler<unknown, unknown>>, remote: boolean);
+    constructor(transferHandlers: Map<string, TransferHandler<unknown, unknown>>, remote: boolean);
     cots: TransferHandler<Set<COT>, Array<Feature>>;
     cot: TransferHandler<COT, Feature>;
 }

package/dist/types/src/base/mission-template-logs.d.ts

@@ -0,0 +1,9 @@
+import type { DBMissionTemplateLog } from './database.ts';
+export default class MissionTemplateLogs {
+    template: string;
+    constructor(template: string);
+    refresh(): Promise<void>;
+    list(opts?: {
+        refresh?: boolean;
+    }): Promise<Array<DBMissionTemplateLog>>;
+}

package/dist/types/src/base/mission-template.d.ts

@@ -0,0 +1,20 @@
+import type { DBMissionTemplate } from './database.ts';
+import MissionTemplateLogs from './mission-template-logs.ts';
+import type { MissionTemplateList } from '../types.ts';
+export default class MissionTemplate {
+    id: string;
+    logs: MissionTemplateLogs;
+    name: string;
+    description: string;
+    icon: string;
+    created: string;
+    updated: string;
+    constructor(template: DBMissionTemplate);
+    static from(id: string): Promise<MissionTemplate | undefined>;
+    static load(id: string, opts?: {
+        refresh?: boolean;
+    }): Promise<MissionTemplate>;
+    refresh(): Promise<void>;
+    static list(filter?: string): Promise<DBMissionTemplate[]>;
+    static sync(): Promise<MissionTemplateList>;
+}

package/dist/types/src/base/profile.d.ts

@@ -0,0 +1,20 @@
+import type { Profile } from '../types.ts';
+import { type Subscription } from 'dexie';
+export default class ProfileConfig<K extends keyof Profile = keyof Profile> {
+    key: K;
+    value: Profile[K];
+    _sub?: Subscription;
+    constructor(key: K, value: Profile[K]);
+    subscribe(): void;
+    subscribed(): boolean;
+    destroy(): void;
+    static get<K extends keyof Profile>(key: K): Promise<ProfileConfig<K> | undefined>;
+    static fetch(token?: string): Promise<Profile>;
+    commit(value: Profile[K]): Promise<void>;
+    static delete(key: string): Promise<void>;
+    static sync(opts?: {
+        refresh?: boolean;
+        token?: string;
+    }): Promise<void>;
+    static saveAll(profile: Profile): Promise<void>;
+}

package/dist/types/src/base/server.d.ts

@@ -0,0 +1,9 @@
+import { type Observable } from 'dexie';
+import type { Server, Server_Update } from '../types.ts';
+export default class ServerManager {
+    static live(): Observable<Server | undefined>;
+    static get(token?: string): Promise<Server>;
+    static sync(token?: string): Promise<Server>;
+    static update(server: Server_Update, token?: string): Promise<Server>;
+    static create(server: Server_Update, token?: string): Promise<Server>;
+}

package/dist/types/src/base/subscription-changes.d.ts

@@ -0,0 +1,18 @@
+import type { MissionChange } from '../types.ts';
+/**
+ * High Level Wrapper around the Data/Mission Sync API
+ */
+export default class SubscriptionChanges {
+    guid: string;
+    token: string;
+    missiontoken?: string;
+    constructor(guid: string, opts: {
+        token: string;
+        missiontoken?: string;
+    });
+    headers(): Record<string, string>;
+    refresh(): Promise<void>;
+    list(opts?: {
+        refresh?: boolean;
+    }): Promise<Array<MissionChange>>;
+}

package/dist/types/src/base/subscription-chat.d.ts

@@ -0,0 +1,23 @@
+import type { DBSubscriptionChat } from './database.ts';
+import { type Observable } from 'dexie';
+import type Atlas from '../workers/atlas.ts';
+import type { Remote } from 'comlink';
+/**
+ * High Level Wrapper around Mission Chat messages stored in the local Dexie DB.
+ *
+ * Chat messages are CoT features with type `b-t-f` that arrive via the mission
+ * feature endpoint. They are stored separately from map features so they can be
+ * queried and displayed as a chronological chat thread.
+ */
+export default class SubscriptionChat {
+    guid: string;
+    name: string;
+    constructor(guid: string, name: string);
+    liveUnreadCount(): Observable<number>;
+    list(): Promise<Array<DBSubscriptionChat>>;
+    read(): Promise<void>;
+    send(message: string, sender: {
+        uid: string;
+        callsign: string;
+    }, worker: Remote<Atlas>): Promise<void>;
+}

package/dist/types/src/base/subscription-contents.d.ts

@@ -0,0 +1,27 @@
+import type { DBSubscriptionContent } from './database.ts';
+import type { Mission } from '../types.ts';
+/**
+ * High Level Wrapper around Mission Contents (file attachments)
+ */
+export default class SubscriptionContents {
+    guid: string;
+    token: string;
+    missiontoken?: string;
+    constructor(guid: string, opts: {
+        token: string;
+        missiontoken?: string;
+    });
+    headers(): Record<string, string>;
+    /**
+     * Populate the subscription_contents table from the Mission's contents field
+     */
+    refresh(contents: Mission['contents']): Promise<void>;
+    /**
+     * Delete/detach a content entry from the mission and remove it from the local database
+     */
+    delete(hash: string): Promise<void>;
+    list(opts?: {
+        refresh?: boolean;
+        contents?: Mission['contents'];
+    }): Promise<Array<DBSubscriptionContent>>;
+}

package/dist/types/src/base/subscription-feature.d.ts

@@ -17,7 +17,7 @@ export default class SubscriptionFeature {
     headers(): Record<string, string>;
     refresh(): Promise<void>;
     list(opts?: {
-        refresh: false;
+        refresh?: boolean;
     }): Promise<Array<Feature>>;
     collection(raw?: boolean): Promise<FeatureCollection>;
     bounds(): Promise<BBox>;

package/dist/types/src/base/subscription-log.d.ts

@@ -1,3 +1,4 @@
+import type { DBSubscriptionLog } from './database.ts';
 import type { MissionLog } from '../types.ts';
 /**
  * High Level Wrapper around the Data/Mission Sync API
@@ -14,8 +15,9 @@ export default class SubscriptionLog {
     refresh(): Promise<void>;
     list(opts?: {
         filter?: string;
-        refresh: false;
-    }): Promise<Array<MissionLog>>;
+        refresh?: boolean;
+    }): Promise<Array<DBSubscriptionLog>>;
+    read(): Promise<void>;
     create(body: {
         dtg?: string;
         content: string;

package/dist/types/src/base/subscription.d.ts

@@ -1,6 +1,9 @@
 import SubscriptionLog from './subscription-log.ts';
+import SubscriptionChanges from './subscription-changes.ts';
+import SubscriptionContents from './subscription-contents.ts';
 import SubscriptionFeature from './subscription-feature.ts';
-import type { Mission, MissionRole, MissionList, MissionLayer, MissionChanges, MissionLayerList, MissionLayer_Create, MissionLayer_Update, MissionSubscriptions } from '../types.ts';
+import SubscriptionChat from './subscription-chat.ts';
+import type { Mission, MissionRole, MissionList, MissionLayer, MissionLayerList, MissionLayer_Create, MissionLayer_Update, MissionSubscriptions, MissionInvite } from '../types.ts';
 export declare enum SubscriptionEventType {
     CREATE = "subscription::create",
     UPDATE = "subscription::update",
@@ -32,11 +35,15 @@ export default class Subscription {
     meta: Mission;
     role: MissionRole;
     log: SubscriptionLog;
+    change: SubscriptionChanges;
+    contents: SubscriptionContents;
     feature: SubscriptionFeature;
+    chat: SubscriptionChat;
     token: string;
     missiontoken?: string;
     dirty: boolean;
     subscribed: boolean;
+    templateid: string | null;
     _sync: BroadcastChannel;
     constructor(mission: Mission, role: MissionRole, opts: {
         subscribed: boolean;
@@ -84,7 +91,7 @@ export default class Subscription {
     refresh(opts?: {
         refreshMission?: boolean;
     }): Promise<void>;
-    fetch(): Promise<void>;
+    fetch(): Promise<Mission>;
     /**
      * List all locally stored missions, with optional filtering
      *
@@ -106,8 +113,14 @@ export default class Subscription {
         defaultRole?: boolean;
     }): Promise<MissionList>;
     static headers(token?: string): Record<string, string>;
+    invite(invitee: string, role?: string): Promise<void>;
+    invites(): Promise<MissionInvite[]>;
+    deleteInvite(invite: {
+        type: string;
+        invitee: string;
+    }): Promise<void>;
+    removeUser(uid: string): Promise<void>;
     subscriptions(): Promise<MissionSubscriptions>;
-    changes(): Promise<MissionChanges>;
     layerList(): Promise<MissionLayerList>;
     layerUpdate(guid: string, layerid: string, layer: MissionLayer_Update): Promise<MissionLayer>;
     layerCreate(layer: MissionLayer_Create): Promise<MissionLayer>;

package/dist/types/src/base/validators.d.ts

@@ -0,0 +1,9 @@
+export interface Validator {
+    (text: string): string;
+}
+export declare function validateJSON(text: string): string;
+export declare function validateTextNotEmpty(text: string): string;
+export declare function validateURL(text: string, opts?: {
+    protocols?: string[];
+}): string;
+export declare function validateLatLng(text: string): string;

package/dist/types/src/components/CloudTAK/ActiveMission.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/src/components/CloudTAK/CoTView.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/src/components/CloudTAK/DrawTools.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/src/components/CloudTAK/GenericBottomPane.vue.d.ts

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/src/components/CloudTAK/Inputs/BufferInput.vue.d.ts

@@ -0,0 +1,10 @@
+type __VLS_Props = {
+    cotId: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/src/components/CloudTAK/Inputs/CoordInput.vue.d.ts

@@ -0,0 +1,7 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;