@termix-ssh/plugin-sdk 1.0.0

package/dist/host/types/src/ui/api/rbac-api.d.ts

@@ -0,0 +1,167 @@
+import { type AccessRecord, type Role, type UserRole } from "../main-axios";
+import type { AuthOverrideProtocol } from "../../types/auth-protocols";
+export declare function getRoles(): Promise<{
+    roles: Role[];
+}>;
+export declare function createRole(roleData: {
+    name: string;
+    displayName: string;
+    description?: string | null;
+}): Promise<{
+    role: Role;
+}>;
+export declare function updateRole(roleId: number, roleData: {
+    displayName?: string;
+    description?: string | null;
+    permissions?: string[];
+}): Promise<{
+    role: Role;
+}>;
+export declare function deleteRole(roleId: number): Promise<{
+    success: boolean;
+}>;
+export declare function getUserRoles(userId: string): Promise<{
+    roles: UserRole[];
+}>;
+export declare function assignRoleToUser(userId: string, roleId: number): Promise<{
+    success: boolean;
+}>;
+export declare function removeRoleFromUser(userId: string, roleId: number): Promise<{
+    success: boolean;
+}>;
+export interface RoleMember {
+    userId: string;
+    username: string;
+    grantedAt: string;
+    grantedBy: string | null;
+}
+export declare function getRoleMembers(roleId: number): Promise<{
+    members: RoleMember[];
+}>;
+export type SharePermissionLevel = "connect" | "view" | "edit" | "manage";
+export interface ShareTarget {
+    type: "user" | "role";
+    id: string | number;
+}
+export declare function shareHost(hostId: number, shareData: {
+    targets: ShareTarget[];
+    permissionLevel: SharePermissionLevel;
+    durationHours?: number;
+}, syncId?: string | null): Promise<{
+    success: boolean;
+    expiresAt: string | null;
+    results: Array<{
+        type: "user" | "role";
+        id: string | number;
+        accessId: number;
+        created: boolean;
+    }>;
+}>;
+export declare function shareFolder(folder: string, shareData: {
+    targets: ShareTarget[];
+    permissionLevel: SharePermissionLevel;
+    durationHours?: number;
+}): Promise<{
+    success: boolean;
+    expiresAt: string | null;
+    hostsShared: number;
+    hostsTotal: number;
+    hostResults: Array<{
+        hostId: number;
+        shared: boolean;
+        reason?: string;
+    }>;
+}>;
+export interface FolderAccessRule {
+    id: number;
+    folder: string;
+    targetType: "user" | "role";
+    userId: string | null;
+    roleId: number | null;
+    username: string | null;
+    roleName: string | null;
+    roleDisplayName: string | null;
+    permissionLevel: SharePermissionLevel;
+    expiresAt: string | null;
+    createdAt: string;
+}
+/** Standing shares on a folder - what hosts added to it later inherit. */
+export declare function getFolderAccess(folder: string): Promise<{
+    rules: FolderAccessRule[];
+}>;
+export declare function revokeFolderAccess(ruleId: number): Promise<void>;
+export declare function updateHostAccess(hostId: number, accessId: number, update: {
+    permissionLevel?: SharePermissionLevel;
+    durationHours?: number | null;
+}, syncId?: string | null): Promise<{
+    success: boolean;
+    expiresAt: string | null;
+}>;
+export declare function getHostAccess(hostId: number, syncId?: string | null): Promise<{
+    accessList: AccessRecord[];
+    isOwner?: boolean;
+}>;
+export interface PermissionCatalogItem {
+    permission: string;
+    /** Plugin-relative keys; resolve them with pluginKey(). */
+    titleKey: string;
+    descriptionKey: string;
+}
+export interface PermissionCatalogEntry {
+    group: string;
+    permissions: string[];
+    /** Set for a group a plugin contributed. */
+    pluginId?: string;
+    /** Core groups carry an i18n key, plugin groups their display name. */
+    labelKey?: string;
+    label?: string;
+    icon?: string;
+    /** False once the owning plugin is disabled or gone. */
+    enabled?: boolean;
+    items?: PermissionCatalogItem[];
+}
+export declare function getPermissionsCatalog(): Promise<{
+    catalog: PermissionCatalogEntry[];
+}>;
+export interface MyPermissions {
+    permissions: string[];
+    isAdmin: boolean;
+}
+/** The current user's own grants, for hiding UI they could not use. */
+export declare function getMyPermissions(): Promise<MyPermissions>;
+export declare function getSharedHosts(): Promise<{
+    sharedHosts: Array<{
+        id: number;
+        name: string | null;
+        ip: string;
+        port: number;
+        username: string;
+        folder: string | null;
+        tags: string | null;
+        permissionLevel: SharePermissionLevel;
+        expiresAt: string | null;
+        grantedBy: string;
+        ownerUsername: string;
+    }>;
+}>;
+export declare function revokeHostAccess(hostId: number, accessId: number, syncId?: string | null): Promise<{
+    success: boolean;
+}>;
+export declare function getHostAuthOverride(hostId: number, protocol: AuthOverrideProtocol, sharedCopySyncId?: string | null): Promise<{
+    protocol: AuthOverrideProtocol;
+    credentialId: number | null;
+}>;
+export declare function setHostAuthOverride(hostId: number, protocol: AuthOverrideProtocol, credentialId: number | null, sharedCopySyncId?: string | null): Promise<{
+    success: boolean;
+    protocol: AuthOverrideProtocol;
+    credentialId: number | null;
+}>;
+export type CredentialPermissionLevel = "use" | "manage";
+export declare function shareCredential(credentialId: number, targets: ShareTarget[], permissionLevel: CredentialPermissionLevel, durationHours?: number): Promise<{
+    success: boolean;
+    expiresAt: string | null;
+}>;
+export declare function getCredentialAccess(credentialId: number): Promise<{
+    access: AccessRecord[];
+}>;
+export declare function revokeCredentialAccess(credentialId: number, accessId: number): Promise<void>;

package/dist/host/types/src/ui/api/settings-api.d.ts

@@ -0,0 +1,22 @@
+export declare function getLogLevel(): Promise<{
+    level: string;
+}>;
+export declare function updateLogLevel(level: string): Promise<void>;
+export declare function getSessionTimeout(): Promise<{
+    timeoutHours: number;
+}>;
+export declare function updateSessionTimeout(timeoutHours: number): Promise<void>;
+export interface BrandingSettings {
+    appName: string;
+    tagline: string;
+    /** PNG data URL, or null when no custom logo is configured. */
+    logo: string | null;
+}
+export interface BrandingSettingsUpdate {
+    appName?: string;
+    tagline?: string;
+    logo?: string | null;
+}
+/** Public endpoint -- no auth required, so the login screen can read it. */
+export declare function getBranding(): Promise<BrandingSettings>;
+export declare function updateBranding(update: BrandingSettingsUpdate): Promise<BrandingSettings>;

package/dist/host/types/src/ui/api/ssh-host-management-api.d.ts

@@ -0,0 +1,65 @@
+import type { SSHHost, SSHHostData, ProxyNode } from "../../types/index";
+import type { SSHHostWithStatus } from "../main-axios";
+/** Host config only. Live status comes from ServerStatusContext. */
+export declare function getSSHHosts(): Promise<SSHHostWithStatus[]>;
+export declare function createSSHHost(hostData: SSHHostData): Promise<SSHHost>;
+export declare function updateSSHHost(hostId: number, hostData: SSHHostData): Promise<SSHHost>;
+export declare function bulkImportSSHHosts(hosts: SSHHostData[], overwrite?: boolean, credentials?: Record<string, unknown>[]): Promise<{
+    message: string;
+    success: number;
+    updated: number;
+    skipped: number;
+    failed: number;
+    errors: string[];
+}>;
+export declare function importSSHConfigHosts(content: string, overwrite?: boolean): Promise<{
+    message: string;
+    success: number;
+    updated: number;
+    skipped: number;
+    failed: number;
+    errors: string[];
+}>;
+export declare function bulkUpdateSSHHosts(hostIds: number[], updates: Record<string, unknown>): Promise<{
+    updated: number;
+    failed: number;
+    errors: string[];
+}>;
+export declare function reorderSSHHosts(positions: {
+    id: number;
+    sortOrder: number;
+}[]): Promise<{
+    updated: number;
+}>;
+export declare function deleteSSHHost(hostId: number): Promise<Record<string, unknown>>;
+export declare function getSSHHostById(hostId: number): Promise<SSHHost>;
+export declare function exportSSHHostWithCredentials(hostId: number): Promise<SSHHost>;
+export declare function exportAllSSHHosts(): Promise<{
+    hosts: SSHHost[];
+}>;
+export declare function exportAllSSHHosts(options: {
+    share: true;
+}): Promise<{
+    version: string;
+    exportedAt: string;
+    credentials: Record<string, unknown>[];
+    hosts: SSHHost[];
+}>;
+export declare function testProxyConnection(options: {
+    singleProxy?: {
+        host: string;
+        port: number;
+        type?: 4 | 5 | "http";
+        username?: string;
+        password?: string;
+    };
+    proxyChain?: ProxyNode[];
+    testTarget?: {
+        host: string;
+        port: number;
+    };
+}): Promise<{
+    success: boolean;
+    latencyMs?: number;
+    error?: string;
+}>;

package/dist/host/types/src/ui/api/sync-api.d.ts

@@ -0,0 +1,93 @@
+export type SyncState = "idle" | "syncing" | "offline" | "error" | "signed_out";
+export interface SyncProxyHeader {
+    name: string;
+    value: string;
+    /** A saved header whose value is not sent back. */
+    set?: boolean;
+}
+export interface SyncBasicAuth {
+    username: string;
+    password: string;
+    set?: boolean;
+}
+export interface SyncEntityInfo {
+    type: string;
+    owner: string;
+    ownerName: string | null;
+    readOnly: boolean;
+    onServer: boolean;
+    onDevice: boolean;
+    enabled: boolean;
+}
+export interface SyncStatus {
+    linked: boolean;
+    serverUrl?: string;
+    serverName?: string | null;
+    serverVersion?: string | null;
+    account?: {
+        username?: string;
+        isAdmin?: boolean;
+        roles?: string[];
+        permissions?: string[];
+    };
+    status?: SyncState;
+    lastError?: string | null;
+    linkedAt?: string;
+    lastSyncAt?: string | null;
+    pending?: number;
+    conflicts?: number;
+    errors?: number;
+    firstSyncDone?: boolean;
+    allowInvalidCertificate?: boolean;
+    customHeaders?: SyncProxyHeader[];
+    basicAuth?: SyncBasicAuth | null;
+    entities: SyncEntityInfo[];
+}
+export type ProbeProblem = "invalid_url" | "unreachable" | "tls_untrusted" | "basic_auth_required" | "proxy_login" | "not_termix" | "version_mismatch" | "different_account";
+export interface ProbeResult {
+    ok: boolean;
+    serverUrl?: string;
+    name?: string;
+    version?: string | null;
+    problem?: ProbeProblem;
+    message?: string;
+}
+export interface ServerTarget {
+    serverUrl: string;
+    customHeaders?: SyncProxyHeader[];
+    basicAuth?: SyncBasicAuth | null;
+    allowInvalidCertificate?: boolean;
+}
+export interface SyncConflictItem {
+    id: number;
+    entityType: string;
+    syncId: string;
+    name: string;
+    createdAt: string;
+}
+export interface SyncErrorItem {
+    entityType: string;
+    syncId: string;
+    reason: string | null;
+}
+export declare function getSyncStatus(): Promise<SyncStatus>;
+export declare function probeServer(target: ServerTarget): Promise<ProbeResult>;
+export declare function getLinkPreview(): Promise<Record<string, number>>;
+export declare function completeLink(input: ServerTarget & {
+    token: string;
+    mode: "merge" | "replace";
+    serverName?: string;
+}): Promise<SyncStatus>;
+export declare function reloginLink(token: string): Promise<SyncStatus>;
+export declare function unlinkServer(keepData: boolean): Promise<SyncStatus>;
+export declare function syncNow(): Promise<SyncStatus>;
+export declare function updateSyncSettings(settings: {
+    disabledTypes?: string[];
+    customHeaders?: SyncProxyHeader[];
+    basicAuth?: SyncBasicAuth | null;
+    allowInvalidCertificate?: boolean;
+}): Promise<SyncStatus>;
+export declare function getSyncConflicts(): Promise<SyncConflictItem[]>;
+export declare function settleSyncConflict(id: number, keep: "mine" | "server"): Promise<void>;
+export declare function getSyncErrors(): Promise<SyncErrorItem[]>;
+export declare function retrySyncErrors(): Promise<SyncStatus>;

package/dist/host/types/src/ui/api/system-status-api.d.ts

@@ -0,0 +1,49 @@
+export interface ReleaseItem {
+    id: number;
+    title: string;
+    description: string;
+    link: string;
+    pubDate: string;
+    version: string;
+    isPrerelease: boolean;
+    isDraft: boolean;
+    assets: Array<{
+        name: string;
+        size: number;
+        download_count: number;
+        download_url: string;
+    }>;
+}
+export interface ReleasesRSSResponse {
+    feed: {
+        title: string;
+        description: string;
+        link: string;
+        updated: string;
+    };
+    items: ReleaseItem[];
+    total_count: number;
+    cached: boolean;
+    cache_age?: number;
+}
+export declare function getReleasesRSS(perPage?: number): Promise<ReleasesRSSResponse>;
+export interface VersionInfo {
+    status?: "up_to_date" | "requires_update" | "beta" | "unknown";
+    /** Same value as remoteVersion; the endpoint sends both. */
+    version?: string;
+    localVersion?: string;
+    remoteVersion?: string;
+    latest_release?: {
+        tag_name?: string;
+        name?: string;
+        published_at?: string;
+        html_url?: string;
+        body?: string;
+    };
+    cached?: boolean;
+    cache_age?: number;
+    [key: string]: unknown;
+}
+export declare function releaseUrlFrom(info: VersionInfo | null | undefined): string;
+export declare function getVersionInfo(checkRemote?: boolean): Promise<VersionInfo>;
+export declare function getDatabaseHealth(): Promise<Record<string, unknown>>;

package/dist/host/types/src/ui/api/ui-preferences-api.d.ts

@@ -0,0 +1,8 @@
+import { type UiPreferences } from "../../types/ui-preferences";
+export declare function getUiPreferences(): Promise<UiPreferences>;
+/**
+ * Sends a partial document. The backend merges overrides two levels deep, so
+ * only changed keys need to be sent; a null clears an override and hands the
+ * knob back to the preset.
+ */
+export declare function saveUiPreferences(preferences: Partial<UiPreferences> & Record<string, unknown>): Promise<void>;

package/dist/host/types/src/ui/api/user-management-api.d.ts

@@ -0,0 +1,80 @@
+import { type UserInfo } from "../main-axios";
+export type UserListOptions = {
+    /** Case-insensitive username substring filter. */
+    search?: string;
+    /** Page size. Omit to fetch every user (what the share pickers want). */
+    limit?: number;
+    offset?: number;
+};
+export declare function getUserList(options?: UserListOptions): Promise<{
+    users: UserInfo[];
+    total?: number;
+}>;
+export declare function getSessions(): Promise<{
+    sessions: {
+        id: string;
+        userId: string;
+        username?: string;
+        deviceType: string;
+        deviceInfo: string;
+        createdAt: string;
+        expiresAt: string;
+        lastActiveAt: string;
+        isRevoked?: boolean;
+        isCurrentSession?: boolean;
+    }[];
+}>;
+export declare function revokeSession(sessionId: string): Promise<{
+    success: boolean;
+    message: string;
+}>;
+export declare function revokeAllUserSessions(userId: string): Promise<{
+    success: boolean;
+    message: string;
+}>;
+export interface ApiKey {
+    id: string;
+    name: string;
+    userId: string;
+    username: string | null;
+    tokenPrefix: string;
+    createdAt: string;
+    expiresAt: string | null;
+    lastUsedAt: string | null;
+    isActive: boolean;
+}
+export interface CreatedApiKey extends ApiKey {
+    token: string;
+}
+export declare function createApiKey(name: string, userId: string, expiresAt?: string): Promise<CreatedApiKey>;
+export declare function getApiKeys(): Promise<{
+    apiKeys: ApiKey[];
+}>;
+export declare function deleteApiKey(keyId: string): Promise<{
+    success: boolean;
+}>;
+export declare function makeUserAdmin(userId: string): Promise<Record<string, unknown>>;
+export declare function removeAdminStatus(userId: string): Promise<Record<string, unknown>>;
+export declare function deleteUser(username: string, successorUserId?: string | "none"): Promise<Record<string, unknown>>;
+export declare function deleteAccount(password: string): Promise<Record<string, unknown>>;
+export declare function adminResetUserPassword(userId: string, newPassword: string, confirmDataWipe?: boolean): Promise<{
+    message: string;
+    dataWiped?: boolean;
+}>;
+export declare function adminExportUserData(userId: string): Promise<Record<string, unknown>>;
+export declare function updateRegistrationAllowed(allowed: boolean): Promise<Record<string, unknown>>;
+export declare function getExternalAutoProvision(): Promise<{
+    enabled: boolean;
+}>;
+export declare function updateExternalAutoProvision(enabled: boolean): Promise<Record<string, unknown>>;
+export declare function getSecondFactorAfterExternalLogin(): Promise<{
+    enabled: boolean;
+}>;
+export declare function updateSecondFactorAfterExternalLogin(enabled: boolean): Promise<Record<string, unknown>>;
+export declare function updatePasswordLoginAllowed(allowed: boolean): Promise<{
+    allowed: boolean;
+}>;
+export declare function getPasswordResetAllowed(): Promise<boolean>;
+export declare function updatePasswordResetAllowed(allowed: boolean): Promise<{
+    allowed: boolean;
+}>;

package/dist/host/types/src/ui/auth/Auth.d.ts

@@ -0,0 +1,12 @@
+export declare function getStoredAuth(): {
+    loggedIn: boolean;
+    username: string;
+} | null;
+export declare function clearStoredAuth(): void;
+export declare function markDesktopManualLogout(): void;
+export declare function clearDesktopManualLogout(): void;
+interface AuthProps {
+    onLogin: (username: string, userId?: string, isAdmin?: boolean) => void;
+}
+export declare function Auth({ onLogin }: AuthProps): import("react").JSX.Element;
+export {};

package/dist/host/types/src/ui/auth/auth-bits.d.ts

@@ -0,0 +1,11 @@
+/** The left half of the sign-in screen: brand mark, tagline, a rule. */
+export declare function BrandPanel({ logo, appName, tagline, }: {
+    logo?: string | null;
+    appName: string;
+    tagline: string;
+}): import("react").JSX.Element;
+/** The brand line shown above the form when the brand panel is hidden. */
+export declare function CompactBrand({ logo, appName, }: {
+    logo?: string | null;
+    appName: string;
+}): import("react").JSX.Element;

package/dist/host/types/src/ui/auth/silent-signin.d.ts

@@ -0,0 +1,2 @@
+export declare function shouldTriggerSilentSignin(search: string): boolean;
+export declare function removeSilentSigninFromSearch(search: string): string;

package/dist/host/types/src/ui/components/FullScreenAppWrapper.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import type { SSHHost } from "../../types";
+export type FullScreenAppPhase = "loading" | "not-found" | "ready";
+interface FullScreenAppWrapperProps {
+    hostId?: string;
+    children: (hostConfig: SSHHost | null, phase: FullScreenAppPhase) => React.ReactNode;
+}
+export declare const FullScreenAppWrapper: React.FC<FullScreenAppWrapperProps>;
+export {};

package/dist/host/types/src/ui/components/alert-dialog.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+declare function AlertDialog({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Root>): React.JSX.Element;
+declare function AlertDialogTrigger({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Trigger>): React.JSX.Element;
+declare function AlertDialogPortal({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Portal>): React.JSX.Element;
+declare function AlertDialogOverlay({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Overlay>): React.JSX.Element;
+declare function AlertDialogContent({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Content>): React.JSX.Element;
+declare function AlertDialogHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function AlertDialogFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function AlertDialogTitle({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Title>): React.JSX.Element;
+declare function AlertDialogDescription({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Description>): React.JSX.Element;
+declare function AlertDialogAction({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Action>): React.JSX.Element;
+declare function AlertDialogCancel({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Cancel>): React.JSX.Element;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };

package/dist/host/types/src/ui/components/alert.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const alertVariants: (props?: {
+    variant?: "default" | "destructive";
+} & import("class-variance-authority/types").ClassProp) => string;
+declare function Alert({ className, variant, ...props }: React.ComponentProps<"div"> & VariantProps<typeof alertVariants>): React.JSX.Element;
+declare function AlertTitle({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function AlertDescription({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+export { Alert, AlertTitle, AlertDescription };

package/dist/host/types/src/ui/components/badge.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const badgeVariants: (props?: {
+    variant?: "default" | "destructive" | "outline" | "secondary";
+} & import("class-variance-authority/types").ClassProp) => string;
+declare function Badge({ className, variant, asChild, ...props }: React.ComponentProps<"span"> & VariantProps<typeof badgeVariants> & {
+    asChild?: boolean;
+}): React.JSX.Element;
+export { Badge, badgeVariants };

package/dist/host/types/src/ui/components/button.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const buttonVariants: (props?: {
+    variant?: "default" | "destructive" | "link" | "outline" | "secondary" | "ghost";
+    size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg";
+} & import("class-variance-authority/types").ClassProp) => string;
+declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): React.JSX.Element;
+export type ButtonProps = React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+};
+export { Button, buttonVariants };

package/dist/host/types/src/ui/components/card-grid/CardGridCanvas.d.ts

@@ -0,0 +1,22 @@
+import { type ReactNode } from "react";
+import type { GridSlot, GridCardCatalogEntry } from "./types";
+interface CardGridCanvasProps {
+    slots: GridSlot[];
+    columns: number;
+    editMode: boolean;
+    /** Render the card body for a given slot id. */
+    renderCard: (id: string) => ReactNode;
+    /** Cards available to add in edit mode (already-present ones are filtered out). */
+    cardCatalog: GridCardCatalogEntry[];
+    onChange: (slots: GridSlot[], columns: number) => void;
+    /** Human label lookup for a card id (used by remove/add chrome). */
+    cardLabel?: (id: string) => string;
+    className?: string;
+}
+export declare function CardGridCanvas({ slots, columns, editMode, renderCard, cardCatalog, onChange, cardLabel, className, }: CardGridCanvasProps): import("react").JSX.Element;
+/** Small stepper to change the masonry column count, for an edit toolbar. */
+export declare function ColumnCountStepper({ columns, onChange, }: {
+    columns: number;
+    onChange: (columns: number) => void;
+}): import("react").JSX.Element;
+export {};

package/dist/host/types/src/ui/components/card-grid/layout-utils.d.ts

@@ -0,0 +1,26 @@
+import type { GridSlot, GridColSpan, GridCardCatalogEntry } from "./types";
+export declare const MIN_TILE_HEIGHT = 80;
+export declare const MAX_COLUMNS = 4;
+export declare const MIN_COLUMNS = 1;
+export declare function clampColumns(n: number): number;
+/** Cycle a tile width 1 -> 2 -> 3 -> 1, capped at the available column count. */
+export declare function nextColSpan(current: GridColSpan, columns: number): GridColSpan;
+/** Sort slots by order ascending (stable copy). */
+export declare function sortSlots(slots: GridSlot[]): GridSlot[];
+/**
+ * Move the dragged slot so it lands at `targetOrder`, then renumber every slot's
+ * order to a dense 0..n-1 sequence (the masonry placement is derived from order).
+ */
+export declare function reorderSlots(slots: GridSlot[], draggedId: string, targetOrder: number): GridSlot[];
+/** Append a catalog card as a new slot, clamping its width to the column count. */
+export declare function addSlot(slots: GridSlot[], entry: GridCardCatalogEntry, columns: number): GridSlot[];
+export declare function removeSlot(slots: GridSlot[], id: string): GridSlot[];
+export declare function setColSpan(slots: GridSlot[], id: string, colSpan: GridColSpan): GridSlot[];
+export declare function setHeight(slots: GridSlot[], id: string, height: number): GridSlot[];
+/**
+ * Convert a tile pixel height into the number of grid rows it should span for
+ * the masonry (row-span) layout. The grid uses `rowUnit`px rows separated by
+ * `rowGap`px, so a tile of height H occupies ceil((H + gap) / (unit + gap))
+ * rows. Kept pure for unit testing the packing math.
+ */
+export declare function heightToRowSpan(height: number, rowUnit: number, rowGap: number): number;

package/dist/host/types/src/ui/components/card-grid/types.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared types for the CardGridCanvas: a content-agnostic, N-column masonry of
+ * movable, variable-width, resizable tiles. The dashboard and Host Metrics both
+ * describe their layout with these primitives.
+ */
+export type GridColSpan = 1 | 2 | 3;
+export interface GridSlot {
+    /** Stable card identifier (the consumer's card id). */
+    id: string;
+    /** Global order across the masonry; column placement is derived from order. */
+    order: number;
+    /** Tile width in grid columns (the "tetris" piece width). */
+    colSpan: GridColSpan;
+    /** Fixed pixel height, or null for content/auto height. */
+    height: number | null;
+}
+export interface GridLayout {
+    slots: GridSlot[];
+    /** Number of masonry columns (1..4). */
+    columns: number;
+}
+/** Catalog entry describing an addable card, used by the edit-mode Add tray. */
+export interface GridCardCatalogEntry {
+    id: string;
+    label: string;
+    description?: string;
+    defaultColSpan?: GridColSpan;
+    defaultHeight?: number | null;
+}