@tak-ps/cloudtak 12.94.0 → 12.102.1

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/notification.d.ts

@@ -0,0 +1,37 @@
+import { NotificationType } from './database.ts';
+import type { DBNotification } from './database.ts';
+export { NotificationType };
+export default class TAKNotification {
+    id: string;
+    type: NotificationType;
+    name: string;
+    body: string;
+    url: string;
+    created: string;
+    toast: boolean;
+    read: boolean;
+    constructor(id: string, type: NotificationType, name: string, body: string, url: string, opts?: {
+        read?: boolean;
+        toast?: boolean;
+        created?: string;
+    });
+    /**
+     * Return a Notification instance if one already exists in the local DB,
+     */
+    static from(id: string): Promise<TAKNotification | null>;
+    static create(type: NotificationType, name: string, body: string, url: string, toast?: boolean): Promise<TAKNotification>;
+    static update(id: string, opts: {
+        read?: boolean;
+        toast?: boolean;
+    }): Promise<void>;
+    update(opts: {
+        read?: boolean;
+        toast?: boolean;
+    }): Promise<void>;
+    popup(): Promise<void>;
+    static clear(): Promise<void>;
+    static delete(id: string): Promise<void>;
+    delete(): Promise<void>;
+    static count(): Promise<number>;
+    static list(): Promise<DBNotification[]>;
+}

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

@@ -0,0 +1,94 @@
+import type { ProfileOverlay, ProfileOverlay_Create } from '../types.ts';
+import type { LayerSpecification } from 'maplibre-gl';
+/**
+ * @class
+ */
+export default class Overlay {
+    _destroyed: boolean;
+    _internal: boolean;
+    _timer: ReturnType<typeof setInterval> | null;
+    _clickable: Array<{
+        id: string;
+        type: string;
+    }>;
+    _error?: Error;
+    _loaded: boolean;
+    id: number;
+    name: string;
+    active: boolean;
+    username?: string;
+    frequency: number | null;
+    iconset: string | null;
+    created: string;
+    updated: string;
+    pos: number;
+    type: string;
+    opacity: number;
+    visible: boolean;
+    mode: string;
+    mode_id: string | null;
+    actions: ProfileOverlay["actions"];
+    url?: string;
+    styles: Array<LayerSpecification>;
+    token: string | null;
+    static create(body: ProfileOverlay | ProfileOverlay_Create, opts?: {
+        internal?: boolean;
+        skipSave?: boolean;
+        clickable?: Array<{
+            id: string;
+            type: string;
+        }>;
+        before?: string;
+        skipLayers?: boolean;
+    }): Promise<Overlay>;
+    static internal(body: {
+        id: number;
+        type: string;
+        name: string;
+        styles?: Array<LayerSpecification>;
+        clickable?: Array<{
+            id: string;
+            type: string;
+        }>;
+    }): Promise<Overlay>;
+    static load(id: number): Promise<Overlay>;
+    constructor(overlay: ProfileOverlay, opts?: {
+        internal?: boolean;
+    });
+    healthy(): boolean;
+    hasBounds(): boolean;
+    zoomTo(): Promise<void>;
+    addLayers(before?: string): Promise<void>;
+    init(opts?: {
+        clickable?: Array<{
+            id: string;
+            type: string;
+        }>;
+        before?: string;
+        skipLayers?: boolean;
+    }): Promise<void>;
+    remove(): void;
+    replace(overlay: {
+        name?: string;
+        active?: boolean;
+        username?: string;
+        actions?: ProfileOverlay["actions"];
+        type?: string;
+        opacity?: number;
+        visible?: boolean;
+        mode?: string;
+        mode_id?: string;
+        url?: string;
+        token?: string;
+        styles?: Array<LayerSpecification>;
+    }, opts?: {
+        before?: string;
+    }): Promise<void>;
+    delete(): Promise<void>;
+    update(body: {
+        pos?: number;
+        visible?: boolean;
+        opacity?: number;
+    }): Promise<void>;
+    save(): Promise<void>;
+}

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

@@ -0,0 +1,49 @@
+import COT from './cot.ts';
+import Subscription from './subscription.ts';
+import type Atlas from '../workers/atlas.ts';
+import type { BBox } from 'geojson';
+import type { Feature, FeatureCollection } from '../types.ts';
+/**
+ * High Level Wrapper around the Data/Mission Sync API
+ */
+export default class SubscriptionFeature {
+    parent: Subscription;
+    token: string;
+    missiontoken?: string;
+    constructor(parent: Subscription, opts: {
+        token: string;
+        missiontoken?: string;
+    });
+    headers(): Record<string, string>;
+    refresh(): Promise<void>;
+    list(opts?: {
+        refresh?: boolean;
+    }): Promise<Array<Feature>>;
+    collection(raw?: boolean): Promise<FeatureCollection>;
+    bounds(): Promise<BBox>;
+    from(uid: string): Promise<Feature | undefined>;
+    /**
+     * Upsert a feature into the mission.
+     * This will udpate the feature in the local DB, submit it to the TAK Server and
+     * mark the subscription as dirty for a re-render
+     *
+     * @param atlas - The Atlas instance
+     * @param cot - The COT object to upsert
+     * @param opts - Options for updating the feature
+     * @param opts.skipNetwork - If true, the feature will not be updated on the server - IE in response to a Mission Change event
+     */
+    update(atlas: Atlas, cot: COT, opts?: {
+        skipNetwork?: boolean;
+    }): Promise<void>;
+    /**
+     * Delete a feature from the mission.
+     *
+     * @param atlas - The Atlas instance
+     * @param uid - The unique ID of the feature to delete
+     * @param opts - Options for deleting the feature
+     * @param opts.skipNetwork - If true, the feature will not be deleted from the server - IE in response to a Mission Change event
+     */
+    delete(atlas: Atlas, uid: string, opts?: {
+        skipNetwork?: boolean;
+    }): Promise<void>;
+}

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

@@ -0,0 +1,34 @@
+import type { DBSubscriptionLog } from './database.ts';
+import type { MissionLog } from '../types.ts';
+/**
+ * High Level Wrapper around the Data/Mission Sync API
+ */
+export default class SubscriptionLog {
+    guid: string;
+    token: string;
+    missiontoken?: string;
+    constructor(guid: string, opts: {
+        token: string;
+        missiontoken?: string;
+    });
+    headers(): Record<string, string>;
+    refresh(): Promise<void>;
+    list(opts?: {
+        filter?: string;
+        refresh?: boolean;
+    }): Promise<Array<DBSubscriptionLog>>;
+    read(): Promise<void>;
+    create(body: {
+        dtg?: string;
+        content: string;
+        contentHashes?: Array<string>;
+        keywords?: Array<string>;
+    }): Promise<MissionLog>;
+    update(logid: string, body: {
+        dtg?: string;
+        content: string;
+        contentHashes?: Array<string>;
+        keywords?: Array<string>;
+    }): Promise<MissionLog>;
+    delete(logid: string): Promise<void>;
+}

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

@@ -0,0 +1,128 @@
+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 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",
+    DELETE = "subscription::delete"
+}
+export type SubscriptionEvent = {
+    guid: string;
+    type: SubscriptionEventType;
+    state: {
+        dirty: boolean;
+        subscribed: boolean;
+    };
+};
+/**
+ * High Level Wrapper around the Data/Mission Sync API
+ *
+ * @property {string} guid - The unique identifier for the mission
+ * @property {string} name - The name of the mission
+ * @property {Mission} meta - The mission metadata
+ * @property {MissionRole} role - The role of the user in the mission
+ * @property {string} token - The CloudTAK Authentication token for API calls
+ * @property {string} [missiontoken] - The mission token for authentication
+ *
+ * @property {boolean} subscribed - Whether the user is subscribed to the mission
+ */
+export default class Subscription {
+    guid: string;
+    name: string;
+    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;
+        token: string;
+        missiontoken?: string;
+    });
+    /**
+     * Return a Subscription instance of one already exists in the local DB,
+     */
+    static from(guid: string, token: string, opts?: {
+        subscribed?: boolean;
+    }): Promise<Subscription | undefined>;
+    /**
+     * Loads an existing Subscription from the local DB an refreshes it,
+     * or creates a new Subscription from the server if it does not exist locally.
+     *
+     * @param guid - The unique identifier for the mission
+     * @param opts - Options for loading the subscription
+     * @param opts.token - The CloudTAK Authentication token for API calls
+     * @param opts.reload - Whether to reload the mission from the local DB
+     * @param opts.missiontoken - The mission token for authentication
+     * @param opts.subscribed - Whether the user is subscribed to the mission
+     */
+    static load(guid: string, opts: {
+        token: string;
+        reload?: boolean;
+        missiontoken?: string;
+        subscribed?: boolean;
+    }): Promise<Subscription>;
+    update(body: {
+        dirty?: boolean;
+        subscribed?: boolean;
+        token?: string;
+        description?: string;
+    }): Promise<void>;
+    delete(): Promise<void>;
+    headers(): Record<string, string>;
+    /**
+     * Reload the Mission from the local Database
+     */
+    reload(): Promise<void>;
+    /**
+     * Perform a hard refresh of the Mission from the Server
+     */
+    refresh(opts?: {
+        refreshMission?: boolean;
+    }): Promise<void>;
+    fetch(): Promise<Mission>;
+    /**
+     * List all locally stored missions, with optional filtering
+     *
+     * @param filter - Filter options for the local mission list
+     * @param filter.role - Filter by minimum role
+     * @param filter.subscribed - Filter by subscription status
+     * @param filter.dirty - Filter by dirty status
+     */
+    static localList(filter?: {
+        role?: 'MISSION_OWNER' | 'MISSION_SUBSCRIBER' | 'MISSION_READONLY_SUBSCRIBER';
+        subscribed?: boolean;
+        dirty?: boolean;
+    }): Promise<Set<{
+        guid: string;
+        name: string;
+    }>>;
+    static list(opts?: {
+        passwordProtected?: boolean;
+        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>;
+    layerList(): Promise<MissionLayerList>;
+    layerUpdate(guid: string, layerid: string, layer: MissionLayer_Update): Promise<MissionLayer>;
+    layerCreate(layer: MissionLayer_Create): Promise<MissionLayer>;
+    layerDelete(layeruid: string): Promise<void>;
+}

package/dist/types/src/base/utils/styles.d.ts

@@ -0,0 +1,11 @@
+import type { LayerSpecification } from 'maplibre-gl';
+export default function styles(id: string, opts?: {
+    sourceLayer?: string;
+    group?: boolean;
+    course?: boolean;
+    labels?: {
+        size: number;
+    };
+    icons?: boolean;
+    rotateIcons?: boolean;
+}): Array<LayerSpecification>;

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;

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

@@ -0,0 +1,24 @@
+import type { InputFeature } from '../../../types.ts';
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    features: {
+        type: () => InputFeature[];
+        required: false;
+        default: () => never[];
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    done: (...args: any[]) => void;
+    close: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    features: {
+        type: () => InputFeature[];
+        required: false;
+        default: () => never[];
+    };
+}>> & Readonly<{
+    onDone?: ((...args: any[]) => any) | undefined;
+    onClose?: ((...args: any[]) => any) | undefined;
+}>, {
+    features: InputFeature[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/src/components/CloudTAK/Inputs/RangeInput.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;

package/dist/types/src/components/CloudTAK/Inputs/RangeRingsInput.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;

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

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

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

@@ -0,0 +1,16 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    compact: BooleanConstructor;
+    modal: BooleanConstructor;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    compact: BooleanConstructor;
+    modal: BooleanConstructor;
+}>> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {
+    compact: boolean;
+    modal: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,8 @@
+import 'maplibre-gl/dist/maplibre-gl.css';
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    err: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onErr?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/src/components/CloudTAK/MapLoading.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/Menu/Basemaps/EditModal.vue.d.ts

@@ -0,0 +1,13 @@
+import type { BasemapList } from '../../../../types.ts';
+type __VLS_Props = {
+    basemap?: Partial<BasemapList['items'][0]>;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+}>, {
+    basemap: Partial<BasemapList["items"][0]>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/src/components/CloudTAK/Menu/Debugger.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/Menu/Iconset/EditModal.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;