@termix-ssh/plugin-sdk 1.0.0

package/dist/backend.js

@@ -0,0 +1,84 @@
+/**
+ * The backend contract: what a plugin's activate(ctx) receives.
+ *
+ * These are types only. Core builds the real object in
+ * src/backend/plugins/ctx.ts and injects it at activation, so the SDK stays a
+ * description of the contract rather than an implementation a plugin could
+ * reach around.
+ *
+ * ctx.ssh is the part of step B's host surface that A8 needed early, so plugin
+ * transports could leave core's internals behind.
+ */
+/**
+ * Thrown when a plugin calls a guarded member without the capability.
+ *
+ * Two things must be true: the manifest declares it, and it is granted. A
+ * grant for something the manifest never declared is ignored, so widening a
+ * plugin's reach always needs a new manifest the user can see.
+ */
+export class PluginCapabilityError extends Error {
+    code = "EPLUGINCAP";
+    pluginId;
+    capability;
+    constructor(pluginId, capability) {
+        super(`Plugin "${pluginId}" is not granted the "${capability}" capability. ` +
+            `Declare it in the manifest's capabilities array and grant it in the plugin's settings.`);
+        this.name = "PluginCapabilityError";
+        this.pluginId = pluginId;
+        this.capability = capability;
+    }
+}
+/**
+ * Thrown by a login method or second factor to refuse a sign-in with a
+ * message the user can see. `code` is a stable id the login screen can map to
+ * its own text; `status` is the HTTP status for form methods.
+ */
+export class LoginMethodError extends Error {
+    status;
+    code;
+    constructor(message, status = 401, code) {
+        super(message);
+        this.name = "LoginMethodError";
+        this.status = status;
+        this.code = code;
+    }
+}
+/** Every key PluginHostCreateInput and PluginHostUpdateInput accept. */
+export const PLUGIN_HOST_INPUT_KEYS = [
+    "name",
+    "ip",
+    "port",
+    "username",
+    "authType",
+    "credentialId",
+    "overrideCredentialUsername",
+    "connectionType",
+    "tags",
+    "folder",
+    "pin",
+    "notes",
+    "jumpHosts",
+    "enableSsh",
+    "sshPort",
+    "statusCheckEnabled",
+    "statusCheckInterval",
+    "forceKeyboardInteractive",
+    "sshOptions",
+    "pluginSettings",
+];
+/** Thrown by ctx.ssh.startInteraction when no provider can start it. */
+export class PluginSshInteractionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PluginSshInteractionError";
+    }
+}
+/**
+ * Identity helper that gives a plugin entry its types without importing the
+ * runtime. Everything a plugin creates belongs inside activate: the module is
+ * cached by the ESM loader, so disable-then-enable re-runs activate on the
+ * same module object.
+ */
+export function definePlugin(plugin) {
+    return plugin;
+}

package/dist/capabilities.d.ts

@@ -0,0 +1,38 @@
+/**
+ * What a plugin's code may do.
+ *
+ * A capability is declared in the manifest and checked by the SDK method that
+ * needs it. It is not a user permission: those stay in core RBAC and are dotted
+ * (hosts.view), while capabilities are colon-separated (hosts:read) so the two
+ * can never be confused in a grant table or a log line.
+ *
+ * Adding one means an entry here plus the SDK method that checks it. The i18n
+ * keys resolve against core's en.json under plugins.capabilities.<id>.
+ *
+ * The copy those keys carry describes the consequence to the person deciding,
+ * not the mechanism. "Run commands on your servers", not "grants ssh:connect".
+ */
+export type CapabilityRisk = "low" | "medium" | "high" | "critical";
+export interface CapabilityInfo {
+    id: string;
+    risk: CapabilityRisk;
+    /** i18n key for the short consequence, e.g. "Run commands on your servers". */
+    titleKey: string;
+    /** i18n key for the qualifying sentence under the title. */
+    consequenceKey: string;
+}
+/**
+ * Ordered critical -> low. The install and review UI reads this order directly
+ * so the worst line is never folded into a summary row.
+ */
+export declare const CAPABILITY_CATALOG: readonly CapabilityInfo[];
+export declare const CAPABILITY_IDS: readonly string[];
+/**
+ * Kept as a string rather than a union of the catalog ids: a capability is
+ * data the runtime checks at load time, and a union here would force every
+ * caller holding a manifest value to cast.
+ */
+export type Capability = string;
+export declare function isKnownCapability(capability: string): boolean;
+export declare function getCapabilityInfo(capability: string): CapabilityInfo | undefined;
+export declare const CAPABILITY_RISK_ORDER: readonly CapabilityRisk[];

package/dist/capabilities.js

@@ -0,0 +1,71 @@
+/**
+ * What a plugin's code may do.
+ *
+ * A capability is declared in the manifest and checked by the SDK method that
+ * needs it. It is not a user permission: those stay in core RBAC and are dotted
+ * (hosts.view), while capabilities are colon-separated (hosts:read) so the two
+ * can never be confused in a grant table or a log line.
+ *
+ * Adding one means an entry here plus the SDK method that checks it. The i18n
+ * keys resolve against core's en.json under plugins.capabilities.<id>.
+ *
+ * The copy those keys carry describes the consequence to the person deciding,
+ * not the mechanism. "Run commands on your servers", not "grants ssh:connect".
+ */
+function entry(id, risk) {
+    return {
+        id,
+        risk,
+        titleKey: `plugins.capabilities.${id}.title`,
+        consequenceKey: `plugins.capabilities.${id}.consequence`,
+    };
+}
+/**
+ * Ordered critical -> low. The install and review UI reads this order directly
+ * so the worst line is never folded into a summary row.
+ */
+export const CAPABILITY_CATALOG = [
+    entry("credentials:read", "critical"),
+    entry("system:tls", "critical"),
+    entry("ssh:connect", "high"),
+    entry("process:spawn", "high"),
+    entry("users:write", "high"),
+    entry("users:impersonate", "high"),
+    entry("db:core-refs", "high"),
+    entry("auth:provide", "high"),
+    entry("device:serial", "high"),
+    entry("notify:hub", "high"),
+    entry("hosts:write", "medium"),
+    entry("credentials:use", "medium"),
+    entry("credentials:write", "medium"),
+    entry("network:outbound", "medium"),
+    entry("network:serve", "medium"),
+    entry("network:broadcast", "medium"),
+    entry("users:read", "medium"),
+    entry("events:core", "medium"),
+    entry("notify:send", "medium"),
+    entry("audit:read", "medium"),
+    entry("desktop:window", "medium"),
+    entry("hosts:read", "low"),
+    entry("db:own", "low"),
+    entry("kv:own", "low"),
+    entry("files:own", "low"),
+    entry("secrets:own", "low"),
+    entry("settings:read-core", "low"),
+    entry("plugins:read", "low"),
+    entry("ui:surface", "low"),
+];
+export const CAPABILITY_IDS = CAPABILITY_CATALOG.map((capability) => capability.id);
+const BY_ID = new Map(CAPABILITY_CATALOG.map((capability) => [capability.id, capability]));
+export function isKnownCapability(capability) {
+    return BY_ID.has(capability);
+}
+export function getCapabilityInfo(capability) {
+    return BY_ID.get(capability);
+}
+export const CAPABILITY_RISK_ORDER = [
+    "critical",
+    "high",
+    "medium",
+    "low",
+];

package/dist/db.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Table definitions a plugin owns.
+ *
+ * A definition is a plain descriptor, not a live Drizzle table. Core turns it
+ * into one at runtime (src/backend/plugins/table-builder.ts) and emits the DDL
+ * for whichever dialect the server is on, which keeps this entry a description
+ * of the contract rather than an implementation a plugin could reach around.
+ *
+ * Why one table object and three DDL emitters, rather than three table
+ * objects: the sqlite-core definitions already encode correctly for every
+ * engine at query time. text and integer encode as themselves; a boolean
+ * writes 1/0, which Postgres and MySQL both accept; real is a plain number.
+ * What genuinely differs between the engines is DDL. See the header of
+ * scripts/generate-dialect-schema.cjs, which this mapping is taken from.
+ */
+export type PluginColumnType = "id" | "text" | "varchar" | "integer" | "bigint" | "real" | "boolean" | "timestamp" | "json" | "encryptedText" | "refUser" | "refHost";
+export interface PluginColumn {
+    readonly type: PluginColumnType;
+    /** varchar only. The ceiling MySQL can index. */
+    readonly length?: number;
+    readonly notNull?: boolean;
+    readonly primaryKey?: boolean;
+    readonly unique?: boolean;
+    readonly defaultValue?: string | number | boolean | null;
+    /** timestamp only: default CURRENT_TIMESTAMP. */
+    readonly defaultNow?: boolean;
+}
+/** The longest string MySQL will index, and so the width of every key column. */
+export declare const KEY_LENGTH = 255;
+interface Builder<T extends PluginColumn = PluginColumn> {
+    notNull: () => Builder<T>;
+    primaryKey: () => Builder<T>;
+    unique: () => Builder<T>;
+    default: (value: string | number | boolean | null) => Builder<T>;
+    defaultNow: () => Builder<T>;
+    readonly column: PluginColumn;
+}
+/** Auto-incrementing surrogate key: integer on sqlite, serial, auto_increment. */
+export declare const id: () => Builder<PluginColumn>;
+/** Unbounded string. Never indexable: MySQL cannot index TEXT. */
+export declare const text: () => Builder<PluginColumn>;
+/** Bounded string. Indexable on every engine. */
+export declare const varchar: (length?: number) => Builder<PluginColumn>;
+export declare const integer: () => Builder<PluginColumn>;
+export declare const bigint: () => Builder<PluginColumn>;
+/** Floating point. A plain number on every engine. Never indexable. */
+export declare const real: () => Builder<PluginColumn>;
+export declare const boolean: () => Builder<PluginColumn>;
+/** Stored as text on every engine. See src/backend/database/repositories/sql-timestamp.ts. */
+export declare const timestamp: () => Builder<PluginColumn>;
+/** JSON held as text. Never indexable, for the same reason as text(). */
+export declare const json: () => Builder<PluginColumn>;
+/** Text encrypted with the owning user's key before it is written. */
+export declare const encryptedText: () => Builder<PluginColumn>;
+/** Foreign key to users.id, cascading on delete. */
+export declare const refUser: () => Builder<PluginColumn>;
+/** Foreign key to ssh_data.id, cascading on delete. */
+export declare const refHost: () => Builder<PluginColumn>;
+export interface PluginTableIndex {
+    readonly name: string;
+    readonly columns: readonly string[];
+    readonly unique?: boolean;
+}
+export interface PluginTableOptions {
+    readonly indexes?: readonly PluginTableIndex[];
+    readonly uniques?: readonly PluginTableIndex[];
+}
+export interface PluginTableDefinition {
+    /** The unprefixed name as the plugin wrote it. */
+    readonly name: string;
+    readonly columns: Readonly<Record<string, PluginColumn>>;
+    readonly indexes: readonly PluginTableIndex[];
+    /** A legacy core table this definition takes over by rename. See adoptLegacyTable. */
+    readonly adopts?: string;
+}
+type Columns = Record<string, Builder | PluginColumn>;
+/**
+ * Declares a table this plugin owns.
+ *
+ * The name is unprefixed here; core prefixes it with p_<plugin id>_ when the
+ * definition is registered, so a plugin cannot name a table into another
+ * plugin's namespace or into core's.
+ */
+export declare function defineTable(name: string, columns: Columns, options?: PluginTableOptions): PluginTableDefinition;
+/** p_<id with - as _>_ - the prefix every table a plugin owns carries. */
+export declare function tablePrefix(pluginId: string): string;
+/** The physical table name for a definition owned by a plugin. */
+export declare function prefixedTableName(pluginId: string, name: string): string;
+/**
+ * Legacy core tables, and the one plugin allowed to adopt each.
+ *
+ * Adoption is how a feature keeps its rows when it moves out of core: the
+ * table is renamed into the plugin's namespace rather than copied. One owner
+ * per table, because two plugins adopting the same one would mean whichever
+ * activated second found it already gone.
+ *
+ * Shared with the CLI so a migration that reaches for someone else's table is
+ * caught at build time as well as at activation.
+ */
+export declare const LEGACY_TABLE_OWNERS: Readonly<Record<string, string>>;
+/**
+ * Marks a definition as the new home of a legacy core table.
+ *
+ * The migration the CLI writes for it renames the legacy table into the
+ * plugin's namespace, and creates it first when there is none (a fresh
+ * install), so both paths end with the same table. Keep the legacy column and
+ * index names in the definition: the rename carries the old indexes across,
+ * and reusing their names is what stops the migration from creating a second
+ * copy of each.
+ */
+export declare function adoptLegacyTable(legacyName: string, definition: PluginTableDefinition): PluginTableDefinition;
+export {};

package/dist/db.js

@@ -0,0 +1,189 @@
+/**
+ * Table definitions a plugin owns.
+ *
+ * A definition is a plain descriptor, not a live Drizzle table. Core turns it
+ * into one at runtime (src/backend/plugins/table-builder.ts) and emits the DDL
+ * for whichever dialect the server is on, which keeps this entry a description
+ * of the contract rather than an implementation a plugin could reach around.
+ *
+ * Why one table object and three DDL emitters, rather than three table
+ * objects: the sqlite-core definitions already encode correctly for every
+ * engine at query time. text and integer encode as themselves; a boolean
+ * writes 1/0, which Postgres and MySQL both accept; real is a plain number.
+ * What genuinely differs between the engines is DDL. See the header of
+ * scripts/generate-dialect-schema.cjs, which this mapping is taken from.
+ */
+/** The longest string MySQL will index, and so the width of every key column. */
+export const KEY_LENGTH = 255;
+function builder(column) {
+    const next = (patch) => builder({ ...column, ...patch });
+    return {
+        column,
+        notNull: () => next({ notNull: true }),
+        primaryKey: () => next({ primaryKey: true, notNull: true }),
+        unique: () => next({ unique: true }),
+        default: (defaultValue) => next({ defaultValue }),
+        defaultNow: () => next({ defaultNow: true }),
+    };
+}
+/** Auto-incrementing surrogate key: integer on sqlite, serial, auto_increment. */
+export const id = () => builder({ type: "id", primaryKey: true, notNull: true });
+/** Unbounded string. Never indexable: MySQL cannot index TEXT. */
+export const text = () => builder({ type: "text" });
+/** Bounded string. Indexable on every engine. */
+export const varchar = (length = KEY_LENGTH) => builder({ type: "varchar", length });
+export const integer = () => builder({ type: "integer" });
+export const bigint = () => builder({ type: "bigint" });
+/** Floating point. A plain number on every engine. Never indexable. */
+export const real = () => builder({ type: "real" });
+export const boolean = () => builder({ type: "boolean" });
+/** Stored as text on every engine. See src/backend/database/repositories/sql-timestamp.ts. */
+export const timestamp = () => builder({ type: "timestamp" });
+/** JSON held as text. Never indexable, for the same reason as text(). */
+export const json = () => builder({ type: "json" });
+/** Text encrypted with the owning user's key before it is written. */
+export const encryptedText = () => builder({ type: "encryptedText" });
+/** Foreign key to users.id, cascading on delete. */
+export const refUser = () => builder({ type: "refUser", length: KEY_LENGTH, notNull: true });
+/** Foreign key to ssh_data.id, cascading on delete. */
+export const refHost = () => builder({ type: "refHost", notNull: true });
+/** Columns that can never carry an index, because MySQL cannot index them. */
+const UNINDEXABLE = new Set([
+    "text",
+    "json",
+    "encryptedText",
+]);
+const NAME_PATTERN = /^[a-z][a-z0-9_]*$/;
+function unwrap(value) {
+    return "column" in value ? value.column : value;
+}
+/**
+ * Declares a table this plugin owns.
+ *
+ * The name is unprefixed here; core prefixes it with p_<plugin id>_ when the
+ * definition is registered, so a plugin cannot name a table into another
+ * plugin's namespace or into core's.
+ */
+export function defineTable(name, columns, options = {}) {
+    if (!NAME_PATTERN.test(name)) {
+        throw new Error(`Table name "${name}" must be lower snake_case and start with a letter`);
+    }
+    const resolved = {};
+    for (const [key, value] of Object.entries(columns)) {
+        resolved[key] = unwrap(value);
+    }
+    if (Object.keys(resolved).length === 0) {
+        throw new Error(`Table "${name}" declares no columns`);
+    }
+    const indexes = [
+        ...(options.uniques ?? []).map((entry) => ({ ...entry, unique: true })),
+        ...(options.indexes ?? []),
+    ];
+    // Checked here rather than at migration time so the error names the table
+    // and column while the author is still looking at the definition.
+    for (const index of indexes) {
+        if (!NAME_PATTERN.test(index.name)) {
+            throw new Error(`Index name "${index.name}" must be lower snake_case and start with a letter`);
+        }
+        if (index.columns.length === 0) {
+            throw new Error(`Index "${index.name}" names no columns`);
+        }
+        for (const column of index.columns) {
+            const declared = resolved[column];
+            if (!declared) {
+                throw new Error(`Index "${index.name}" names "${column}", which table "${name}" does not declare`);
+            }
+            if (UNINDEXABLE.has(declared.type)) {
+                throw new Error(`Index "${index.name}" covers "${column}", a ${declared.type} column. ` +
+                    `MySQL cannot index an unbounded column: use varchar(n) instead.`);
+            }
+        }
+    }
+    return { name, columns: resolved, indexes };
+}
+/** p_<id with - as _>_ - the prefix every table a plugin owns carries. */
+export function tablePrefix(pluginId) {
+    return `p_${pluginId.replace(/-/g, "_")}_`;
+}
+/** The physical table name for a definition owned by a plugin. */
+export function prefixedTableName(pluginId, name) {
+    return `${tablePrefix(pluginId)}${name}`;
+}
+/**
+ * Legacy core tables, and the one plugin allowed to adopt each.
+ *
+ * Adoption is how a feature keeps its rows when it moves out of core: the
+ * table is renamed into the plugin's namespace rather than copied. One owner
+ * per table, because two plugins adopting the same one would mean whichever
+ * activated second found it already gone.
+ *
+ * Shared with the CLI so a migration that reaches for someone else's table is
+ * caught at build time as well as at activation.
+ */
+export const LEGACY_TABLE_OWNERS = {
+    fleets: "fleets",
+    fleet_members: "fleets",
+    fleet_inventory: "fleets",
+    user_workspaces: "workspaces",
+    network_topology: "network-topology",
+    snippets: "snippets",
+    snippet_folders: "snippets",
+    snippet_access: "snippets",
+    c2s_tunnel_presets: "tunnels",
+    command_history: "ssh-terminal",
+    file_manager_recent: "file-manager",
+    file_manager_pinned: "file-manager",
+    file_manager_shortcuts: "file-manager",
+    transfer_recent: "file-manager",
+    tmux_session_tags: "tmux-monitor",
+    session_shares: "session-sharing",
+    session_share_participants: "session-sharing",
+    collab_rooms: "session-sharing",
+    collab_room_members: "session-sharing",
+    session_recordings: "session-recording",
+    host_metrics_preferences: "host-metrics",
+    host_health_checks: "host-metrics",
+    host_health_history: "host-metrics",
+    host_metrics_history: "host-metrics",
+    proxmox_stats_preferences: "proxmox",
+    proxmox_node_history: "proxmox",
+    automations: "automations",
+    automation_trigger_state: "automations",
+    automation_schedules: "automations",
+    automation_runs: "automations",
+    automation_run_steps: "automations",
+    automation_channels: "automations",
+    ai_providers: "ai",
+    ai_conversations: "ai",
+    ai_messages: "ai",
+    ai_proposals: "ai",
+    homepage_items: "homepage",
+    homepage_layouts: "homepage",
+    dashboard_service_links: "homepage",
+    secret_sources: "secret-sources",
+    opkssh_tokens: "opkssh",
+    vault_profiles: "vault",
+    vault_tokens: "vault",
+    termix_identities: "termix-identity",
+    termix_identity_keys: "termix-identity",
+    termix_identity_ca: "termix-identity",
+    webauthn_credentials: "webauthn",
+    sso_providers: "sso",
+    dismissed_alerts: "alerts",
+};
+/**
+ * Marks a definition as the new home of a legacy core table.
+ *
+ * The migration the CLI writes for it renames the legacy table into the
+ * plugin's namespace, and creates it first when there is none (a fresh
+ * install), so both paths end with the same table. Keep the legacy column and
+ * index names in the definition: the rename carries the old indexes across,
+ * and reusing their names is what stops the migration from creating a second
+ * copy of each.
+ */
+export function adoptLegacyTable(legacyName, definition) {
+    if (!Object.prototype.hasOwnProperty.call(LEGACY_TABLE_OWNERS, legacyName)) {
+        throw new Error(`"${legacyName}" is not a legacy core table a plugin may adopt. See LEGACY_TABLE_OWNERS.`);
+    }
+    return { ...definition, adopts: legacyName };
+}

package/dist/ddl.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The DDL a table definition becomes, per dialect.
+ *
+ * Lives in the SDK because two things need the identical mapping: the CLI,
+ * which writes a plugin's migration files, and the server, which applies them.
+ * A second copy would drift and produce a migration the runner could not
+ * reproduce.
+ *
+ * The mapping itself is the one scripts/generate-dialect-schema.cjs applies to
+ * core's schema, kept deliberately in step with it.
+ */
+import type { PluginColumn, PluginTableDefinition } from "./db.js";
+/** Which engine the DDL is for. Matches core's DatabaseDialect exactly. */
+export type SqlDialect = "sqlite" | "postgres" | "mysql";
+/** The core tables a plugin may point a foreign key at, and nothing else. */
+export declare const REFERENCEABLE: {
+    readonly refUser: {
+        readonly table: "users";
+        readonly column: "id";
+    };
+    readonly refHost: {
+        readonly table: "ssh_data";
+        readonly column: "id";
+    };
+};
+/** The SQL column name for a declared property. */
+export declare function columnName(property: string, column?: PluginColumn): string;
+/** Every column that carries a key, and so must be indexable on MySQL. */
+export declare function keyedColumns(definition: PluginTableDefinition): ReadonlySet<string>;
+/** The CREATE TABLE and CREATE INDEX statements for one definition. */
+export declare function createTableSql(dialect: SqlDialect, pluginId: string, definition: PluginTableDefinition): string[];
+/**
+ * Takes over a legacy core table by renaming it into the plugin's namespace.
+ *
+ * A plain SQL migration cannot ask whether the legacy table exists, so it
+ * creates it first when it does not (a fresh install) and then renames either
+ * way. Both paths end with the same table and the same rows.
+ *
+ * Indexes are created on the legacy name with IF NOT EXISTS before the rename,
+ * which is why an adopted definition keeps the legacy index names: an index
+ * that already exists is left alone and follows the table. MySQL has no
+ * CREATE INDEX IF NOT EXISTS, so there none are emitted. That is safe because
+ * every legacy table reached MySQL through core's drizzle migrations, which
+ * already created its indexes.
+ */
+export declare function adoptTableSql(dialect: SqlDialect, pluginId: string, definition: PluginTableDefinition): string[];
+/**
+ * Splits a migration file into statements.
+ *
+ * Deliberately simple: statements end at a semicolon that is not inside a
+ * string literal or a comment. A plugin needing more than that should put the
+ * logic in its own code, not in DDL.
+ */
+export declare function splitStatements(source: string): string[];
+/** DROP statement for a definition, for removePluginData. */
+export declare function dropTableSql(dialect: SqlDialect, pluginId: string, definition: PluginTableDefinition): string;
+/** The ALTER that adds one newly declared column. */
+export declare function addColumnSql(dialect: SqlDialect, pluginId: string, definition: PluginTableDefinition, property: string): string;
+/**
+ * Every problem with the tables a migration writes to.
+ *
+ * The check has to hold against a plugin that is trying, not only one that
+ * made a typo, so it reads each statement the way the engine does rather
+ * than matching one pattern: a comment between a keyword and a name, bracket
+ * quoting, a second name in a DROP list, a schema-qualified name and
+ * `ALTER ... RENAME TO users` are all seen. Reads (FROM, JOIN, REFERENCES)
+ * are allowed; writes outside the plugin's prefix are not.
+ *
+ * `ownedLegacy` lists the legacy core tables this plugin adopts.
+ */
+export declare function findUnownedTableWrites(pluginId: string, sql: string, ownedLegacy?: ReadonlySet<string>, ownedIndexes?: ReadonlySet<string>): string[];
+/**
+ * Names of the indexes a plugin's migrations create on its own tables, so a
+ * later DROP INDEX with no ON clause can be checked against them.
+ */
+export declare function collectOwnedIndexes(pluginId: string, sqls: readonly string[], ownedLegacy?: ReadonlySet<string>): Set<string>;