@adguard/agtree 2.2.0 → 3.0.0-alpha.2

package/dist/types/compatibility-tables/redirects.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @file Compatibility tables for redirects.
+ */
+import { CompatibilityTableBase } from './base';
+import { type RedirectDataSchema } from './schemas';
+import { type CompatibilityTable } from './types';
+import { type GenericPlatform, type SpecificPlatform } from './platforms';
+/**
+ * Compatibility table for redirects.
+ */
+declare class RedirectsCompatibilityTable extends CompatibilityTableBase<RedirectDataSchema> {
+    /**
+     * Creates a new instance of the compatibility table for redirects.
+     *
+     * @param data Compatibility table data.
+     */
+    constructor(data: CompatibilityTable<RedirectDataSchema>);
+    /**
+     * Gets the resource type adblock modifiers for the redirect for the given platform
+     * based on the `resourceTypes` field.
+     *
+     * @param redirect Redirect name or redirect data.
+     * @param platform Platform to get the modifiers for.
+     *
+     * @returns Set of resource type modifiers or an empty set if the redirect is not found or has no resource types.
+     */
+    getResourceTypeModifiers(redirect: string | RedirectDataSchema, platform: SpecificPlatform | GenericPlatform): Set<string>;
+}
+/**
+ * Compatibility table instance for redirects.
+ */
+export declare const redirectsCompatibilityTable: RedirectsCompatibilityTable;
+export {};

package/dist/types/compatibility-tables/schemas/base.d.ts

@@ -0,0 +1,124 @@
+/**
+ * @file Base compatibility data schema, which is commonly used in compatibility tables.
+ */
+import zod from 'zod';
+/**
+ * Zod schema for boolean values. Accepts both boolean and string values.
+ */
+export declare const booleanSchema: zod.ZodUnion<[zod.ZodEffects<zod.ZodString, boolean, string>, zod.ZodBoolean]>;
+/**
+ * Zod schema for non-empty string values.
+ */
+export declare const nonEmptyStringSchema: zod.ZodPipeline<zod.ZodEffects<zod.ZodString, string, string>, zod.ZodString>;
+/**
+ * Zod schema for base compatibility data.
+ * Here we use snake_case properties because the compatibility data is stored in YAML files.
+ */
+export declare const baseCompatibilityDataSchema: zod.ZodObject<{
+    /**
+     * Name of the actual entity.
+     */
+    name: zod.ZodPipeline<zod.ZodEffects<zod.ZodString, string, string>, zod.ZodString>;
+    /**
+     * List of aliases for the entity (if any).
+     */
+    aliases: zod.ZodDefault<zod.ZodNullable<zod.ZodArray<zod.ZodPipeline<zod.ZodEffects<zod.ZodString, string, string>, zod.ZodString>, "many">>>;
+    /**
+     * Short description of the actual entity.
+     * If not specified or it's value is `null`, then the description is not available.
+     */
+    description: zod.ZodDefault<zod.ZodNullable<zod.ZodPipeline<zod.ZodEffects<zod.ZodString, string, string>, zod.ZodString>>>;
+    /**
+     * Link to the documentation. If not specified or it's value is `null`, then the documentation is not available.
+     */
+    docs: zod.ZodDefault<zod.ZodNullable<zod.ZodPipeline<zod.ZodEffects<zod.ZodString, string, string>, zod.ZodString>>>;
+    /**
+     * The version of the adblocker in which the entity was added.
+     * For AdGuard resources, the version of the library is specified.
+     */
+    version_added: zod.ZodDefault<zod.ZodNullable<zod.ZodPipeline<zod.ZodEffects<zod.ZodString, string, string>, zod.ZodString>>>;
+    /**
+     * The version of the adblocker when the entity was removed.
+     */
+    version_removed: zod.ZodDefault<zod.ZodNullable<zod.ZodPipeline<zod.ZodEffects<zod.ZodString, string, string>, zod.ZodString>>>;
+    /**
+     * Describes whether the entity is deprecated.
+     */
+    deprecated: zod.ZodDefault<zod.ZodUnion<[zod.ZodEffects<zod.ZodString, boolean, string>, zod.ZodBoolean]>>;
+    /**
+     * Message that describes why the entity is deprecated.
+     * If not specified or it's value is `null`, then the message is not available.
+     * It's value is omitted if the entity is not marked as deprecated.
+     */
+    deprecation_message: zod.ZodDefault<zod.ZodNullable<zod.ZodPipeline<zod.ZodEffects<zod.ZodString, string, string>, zod.ZodString>>>;
+    /**
+     * Describes whether the entity is removed; for *already removed* features.
+     */
+    removed: zod.ZodDefault<zod.ZodUnion<[zod.ZodEffects<zod.ZodString, boolean, string>, zod.ZodBoolean]>>;
+    /**
+     * Message that describes why the entity is removed.
+     * If not specified or it's value is `null`, then the message is not available.
+     * It's value is omitted if the entity is not marked as deprecated.
+     */
+    removal_message: zod.ZodDefault<zod.ZodNullable<zod.ZodPipeline<zod.ZodEffects<zod.ZodString, string, string>, zod.ZodString>>>;
+}, "strip", zod.ZodTypeAny, {
+    name: string;
+    description: string | null;
+    aliases: string[] | null;
+    docs: string | null;
+    version_added: string | null;
+    version_removed: string | null;
+    deprecated: boolean;
+    deprecation_message: string | null;
+    removed: boolean;
+    removal_message: string | null;
+}, {
+    name: string;
+    aliases?: string[] | null | undefined;
+    description?: string | null | undefined;
+    docs?: string | null | undefined;
+    version_added?: string | null | undefined;
+    version_removed?: string | null | undefined;
+    deprecated?: string | boolean | undefined;
+    deprecation_message?: string | null | undefined;
+    removed?: string | boolean | undefined;
+    removal_message?: string | null | undefined;
+}>;
+/**
+ * Zod schema for base compatibility data with camelCase properties.
+ */
+export declare const baseCompatibilityDataSchemaCamelCase: zod.ZodEffects<zod.ZodTypeAny, {
+    name: string;
+    description: string | null;
+    aliases: string[] | null;
+    docs: string | null;
+    versionAdded: string | null;
+    versionRemoved: string | null;
+    deprecated: boolean;
+    deprecationMessage: string | null;
+    removed: boolean;
+    removalMessage: string | null;
+}, any>;
+/**
+ * Type of the base compatibility data schema.
+ */
+export type BaseCompatibilityDataSchema = zod.infer<typeof baseCompatibilityDataSchemaCamelCase>;
+/**
+ * Refinement logic for base compatibility data.
+ *
+ * @param data Base compatibility data.
+ * @param ctx Refinement context.
+ */
+export declare const baseRefineLogic: (data: zod.infer<typeof baseCompatibilityDataSchema>, ctx: zod.RefinementCtx) => void;
+/**
+ * Creates a base file schema.
+ *
+ * @param dataSchema Data schema.
+ *
+ * @returns Base file schema.
+ */
+export declare const baseFileSchema: <T extends BaseCompatibilityDataSchema>(dataSchema: zod.ZodType<T>) => zod.ZodPipeline<zod.ZodEffects<zod.ZodRecord<zod.ZodAny, zod.ZodAny>, Record<any, any>, Record<any, any>>, zod.ZodRecord<zod.ZodEffects<zod.ZodString, number, string>, zod.ZodType<T, zod.ZodTypeDef, T>>>;
+/**
+ * Type of the base file schema.
+ */
+export type BaseFileSchema<T extends BaseCompatibilityDataSchema> = zod.infer<ReturnType<typeof baseFileSchema<T>>>;

package/dist/types/compatibility-tables/schemas/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file Entry point for compatibility tables schemas.
+ */
+export * from './base';
+export * from './modifier';
+export * from './redirect';
+export * from './scriptlet';
+export * from './platform';

package/dist/types/compatibility-tables/schemas/modifier.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @file Schema for modifier data.
+ */
+import zod from 'zod';
+/**
+ * Known validators that don't need to be validated as regex.
+ */
+export declare const KNOWN_VALIDATORS: ReadonlySet<string>;
+/**
+ * Zod schema for modifier data.
+ */
+export declare const modifierDataSchema: zod.ZodEffects<zod.ZodTypeAny, {
+    name: string;
+    description: string | null;
+    aliases: string[] | null;
+    docs: string | null;
+    versionAdded: string | null;
+    versionRemoved: string | null;
+    deprecated: boolean;
+    deprecationMessage: string | null;
+    removed: boolean;
+    removalMessage: string | null;
+    conflicts: string[] | null;
+    inverseConflicts: boolean;
+    assignable: boolean;
+    negatable: boolean;
+    blockOnly: boolean;
+    exceptionOnly: boolean;
+    valueOptional: boolean;
+    valueFormat: string | null;
+    valueFormatFlags: string | null;
+}, any>;
+/**
+ * Type of the modifier data schema.
+ */
+export type ModifierDataSchema = zod.infer<typeof modifierDataSchema>;

package/dist/types/compatibility-tables/schemas/platform.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @file Platform schema.
+ */
+import zod from 'zod';
+/**
+ * Parses a raw platform string into a platform bitmask.
+ *
+ * @param rawPlatforms Raw platform string, e.g. 'adg_safari_any|adg_os_any'.
+ *
+ * @returns Platform bitmask.
+ */
+export declare const parseRawPlatforms: (rawPlatforms: string) => number;
+/**
+ * Platform schema.
+ */
+export declare const platformSchema: zod.ZodEffects<zod.ZodString, number, string>;

package/dist/types/compatibility-tables/schemas/redirect.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @file Schema for redirect data.
+ */
+import zod from 'zod';
+/**
+ * Zod schema for redirect data.
+ */
+export declare const redirectDataSchema: zod.ZodEffects<zod.ZodTypeAny, {
+    name: string;
+    description: string | null;
+    aliases: string[] | null;
+    docs: string | null;
+    versionAdded: string | null;
+    versionRemoved: string | null;
+    deprecated: boolean;
+    deprecationMessage: string | null;
+    removed: boolean;
+    removalMessage: string | null;
+    isBlocking: boolean;
+    resourceTypes: ("object" | "image" | "other" | "font" | "media" | "ping" | "script" | "stylesheet" | "websocket" | "xmlhttprequest" | "main_frame" | "sub_frame")[];
+}, any>;
+/**
+ * Type of the redirect data schema.
+ */
+export type RedirectDataSchema = zod.infer<typeof redirectDataSchema>;

package/dist/types/compatibility-tables/schemas/resource-type.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @file Resource type schema.
+ */
+import zod from 'zod';
+/**
+ * Resource type.
+ *
+ * @see {@link https://developer.chrome.com/docs/extensions/reference/declarativeNetRequest/#type-ResourceType}
+ */
+export declare const ResourceType: {
+    readonly MainFrame: "main_frame";
+    readonly SubFrame: "sub_frame";
+    readonly Stylesheet: "stylesheet";
+    readonly Script: "script";
+    readonly Image: "image";
+    readonly Font: "font";
+    readonly Object: "object";
+    readonly XmlHttpRequest: "xmlhttprequest";
+    readonly Ping: "ping";
+    readonly Media: "media";
+    readonly WebSocket: "websocket";
+    readonly Other: "other";
+};
+export type ResourceType = typeof ResourceType[keyof typeof ResourceType];
+/**
+ * Resource type schema.
+ */
+export declare const resourceTypeSchema: zod.ZodNativeEnum<{
+    readonly MainFrame: "main_frame";
+    readonly SubFrame: "sub_frame";
+    readonly Stylesheet: "stylesheet";
+    readonly Script: "script";
+    readonly Image: "image";
+    readonly Font: "font";
+    readonly Object: "object";
+    readonly XmlHttpRequest: "xmlhttprequest";
+    readonly Ping: "ping";
+    readonly Media: "media";
+    readonly WebSocket: "websocket";
+    readonly Other: "other";
+}>;

package/dist/types/compatibility-tables/schemas/scriptlet.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @file Schema for scriptlet data.
+ */
+import zod from 'zod';
+/**
+ * Zod schema for scriptlet data.
+ */
+export declare const scriptletDataSchema: zod.ZodEffects<zod.ZodTypeAny, {
+    name: string;
+    description: string | null;
+    aliases: string[] | null;
+    docs: string | null;
+    versionAdded: string | null;
+    versionRemoved: string | null;
+    deprecated: boolean;
+    deprecationMessage: string | null;
+    removed: boolean;
+    removalMessage: string | null;
+    parameters?: {
+        name: string;
+        debug: boolean;
+        pattern: string | null;
+        description: string | null;
+        default: string | null;
+        required: boolean;
+    }[] | undefined;
+}, any>;
+/**
+ * Type of the scriptlet data schema.
+ */
+export type ScriptletDataSchema = zod.infer<typeof scriptletDataSchema>;

package/dist/types/compatibility-tables/scriptlets.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file Compatibility tables for scriptlets.
+ */
+import { CompatibilityTableBase } from './base';
+import { type ScriptletDataSchema } from './schemas';
+/**
+ * Compatibility table for scriptlets.
+ */
+declare class ScriptletsCompatibilityTable extends CompatibilityTableBase<ScriptletDataSchema> {
+}
+/**
+ * Compatibility table instance for scriptlets.
+ */
+export declare const scriptletsCompatibilityTable: ScriptletsCompatibilityTable;
+export {};

package/dist/types/compatibility-tables/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @file Compatibility tables types.
+ */
+/**
+ * Map with shared storage.
+ * The idea is to avoid storing the same value multiple times in the map,
+ * so the value is stored in the `shared` array and the map refers to the index in the `shared` array.
+ *
+ * @template K Type of the map keys.
+ * @template V Type of the map values.
+ */
+interface MapWithSharedStorage<K extends string | number | symbol, V> {
+    /**
+     * Shared storage.
+     */
+    shared: V[];
+    /**
+     * Map of the values where the value is a pointer to the shared storage (refers to the index in the `shared` array).
+     */
+    map: Record<K, number>;
+}
+/**
+ * Compatibility table row.
+ *
+ * @template T Type of the compatibility data.
+ */
+export type CompatibilityTableRow<T> = MapWithSharedStorage<number, T>;
+/**
+ * Compatibility table.
+ *
+ * @template T Type of the compatibility data.
+ */
+export type CompatibilityTable<T> = MapWithSharedStorage<string, CompatibilityTableRow<T>>;
+export {};

package/dist/types/compatibility-tables/utils/platform-helpers.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @file Provides platform mapping and helper functions.
+ */
+import { GenericPlatform, SpecificPlatform } from '../platforms';
+/**
+ * Map of specific platforms string names to their corresponding enum values.
+ */
+export declare const SPECIFIC_PLATFORM_MAP: Map<string, SpecificPlatform>;
+/**
+ * Map of specific platforms enum values to their corresponding string names.
+ *
+ * @note Reverse of {@link SPECIFIC_PLATFORM_MAP}.
+ */
+export declare const SPECIFIC_PLATFORM_MAP_REVERSE: Map<SpecificPlatform, string>;
+/**
+ * Map of generic platforms string names to their corresponding enum values.
+ */
+export declare const GENERIC_PLATFORM_MAP: Map<string, GenericPlatform>;
+/**
+ * Check if the platform is a generic platform.
+ *
+ * @param platform Platform to check.
+ *
+ * @returns True if the platform is a generic platform, false otherwise.
+ */
+export declare const isGenericPlatform: (platform: number) => boolean;
+/**
+ * Returns the platform enum value for the given platform string name.
+ *
+ * @param platform Platform string name, e.g., 'adg_os_windows'.
+ *
+ * @returns Specific or generic platform enum value.
+ * @throws Error if the platform is unknown.
+ */
+export declare const getPlatformId: (platform: string) => SpecificPlatform | GenericPlatform;
+/**
+ * Returns the specific platform string name for the given platform enum value.
+ *
+ * @param platform Specific platform enum value.
+ *
+ * @returns Specific platform string name, e.g., 'adg_os_windows'.
+ * @throws Error if the platform is unknown.
+ */
+export declare const getSpecificPlatformName: (platform: SpecificPlatform) => string;

package/dist/types/compatibility-tables/utils/resource-type-helpers.d.ts

@@ -0,0 +1,20 @@
+import { type GenericPlatform, type SpecificPlatform } from '../platforms';
+import { ResourceType } from '../schemas/resource-type';
+/**
+ * Gets the adblock modifier name for the given resource type.
+ *
+ * @param resourceType Resource type to get the modifier name for.
+ * @param platform Platform to get the modifier for.
+ *
+ * @returns A string containing the adblock modifier name for the given resource type
+ * or `null` if the modifier could not be found.
+ */
+export declare const getResourceTypeModifier: (resourceType: ResourceType, platform: SpecificPlatform | GenericPlatform) => string | null;
+/**
+ * Checks if the given resource type is valid.
+ *
+ * @param resourceType Resource type to check.
+ *
+ * @returns `true` if the resource type is valid, `false` otherwise.
+ */
+export declare const isValidResourceType: (resourceType: string) => boolean;

package/dist/types/compatibility-tables/utils/zod-camelcase.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file Zod camelCase utility.
+ */
+import type zod from 'zod';
+import { type CamelCasedPropertiesDeep } from 'type-fest';
+/**
+ * Transforms Zod schema to camelCase.
+ *
+ * @param zod Zod schema.
+ *
+ * @returns Zod schema with camelCase properties.
+ *
+ * @see {@link https://github.com/colinhacks/zod/issues/486#issuecomment-1501097361}
+ */
+export declare const zodToCamelCase: <T extends zod.ZodTypeAny>(zod: T) => zod.ZodEffects<zod.ZodTypeAny, CamelCasedPropertiesDeep<T["_output"]>>;

package/dist/types/converter/base-interfaces/base-converter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @file Base class for converters
+ *
+ * TS doesn't support abstract static methods, so we should use
+ * a workaround and extend this class instead of implementing it
+ */
+import { type ConversionResult } from './conversion-result';
+/**
+ * Basic class for rule converters
+ */
+export declare class BaseConverter {
+    /**
+     * Converts some data to AdGuard format
+     *
+     * @param data Data to convert
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
+     * @throws If the data is invalid or incompatible
+     */
+    static convertToAdg(data: unknown): ConversionResult<unknown>;
+    /**
+     * Converts some data to Adblock Plus format
+     *
+     * @param data Data to convert
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
+     * @throws If the data is invalid or incompatible
+     */
+    static convertToAbp(data: unknown): ConversionResult<unknown>;
+    /**
+     * Converts some data to uBlock Origin format
+     *
+     * @param data Data to convert
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
+     * @throws If the data is invalid or incompatible
+     */
+    static convertToUbo(data: unknown): ConversionResult<unknown>;
+}

package/dist/types/converter/base-interfaces/conversion-result.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @file Conversion result interface and helper functions
+ */
+import { type Node } from '../../nodes';
+/**
+ * Common conversion result interface
+ *
+ * @template T Type of the item to convert
+ * @template U Type of the conversion result (defaults to `T`, but can be `T[]` as well)
+ */
+export interface ConversionResult<T, U extends T | T[] = T> {
+    /**
+     * Conversion result
+     */
+    result: U;
+    /**
+     * Indicates whether the input item was converted
+     */
+    isConverted: boolean;
+}
+/**
+ * Adblock rule node conversion result interface, where the conversion result is an array of rules
+ */
+export type NodeConversionResult<T extends Node> = ConversionResult<T, T[]>;
+/**
+ * Helper function to create a generic conversion result.
+ *
+ * @param result Conversion result
+ * @param isConverted Indicates whether the input item was converted
+ * @template T Type of the item to convert
+ * @template U Type of the conversion result (defaults to `T`, but can be `T[]` as well)
+ * @returns Generic conversion result
+ */
+export declare function createConversionResult<T, U extends T | T[] = T>(result: U, isConverted: boolean): ConversionResult<T, U>;
+/**
+ * Helper function to create a node conversion result.
+ *
+ * @param nodes Array of nodes
+ * @param isConverted Indicates whether the input item was converted
+ * @template T Type of the node (extends `Node`)
+ * @returns Node conversion result
+ */
+export declare function createNodeConversionResult<T extends Node>(nodes: T[], isConverted: boolean): NodeConversionResult<T>;

package/dist/types/converter/base-interfaces/rule-converter-base.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @file Base class for rule converters
+ *
+ * TS doesn't support abstract static methods, so we should use
+ * a workaround and extend this class instead of implementing it
+ */
+import { type Node } from '../../nodes';
+import { type NodeConversionResult } from './conversion-result';
+import { BaseConverter } from './base-converter';
+/**
+ * Basic class for rule converters
+ */
+export declare class RuleConverterBase extends BaseConverter {
+    /**
+     * Converts an adblock filtering rule to AdGuard format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rule: Node): NodeConversionResult<Node>;
+    /**
+     * Converts an adblock filtering rule to Adblock Plus format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAbp(rule: Node): NodeConversionResult<Node>;
+    /**
+     * Converts an adblock filtering rule to uBlock Origin format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToUbo(rule: Node): NodeConversionResult<Node>;
+}

package/dist/types/converter/comment/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @file Comment rule converter
+ */
+import { type AnyCommentRule } from '../../nodes';
+import { RuleConverterBase } from '../base-interfaces/rule-converter-base';
+import { type NodeConversionResult } from '../base-interfaces/conversion-result';
+/**
+ * Comment rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+export declare class CommentRuleConverter extends RuleConverterBase {
+    /**
+     * Converts a comment rule to AdGuard format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rule: AnyCommentRule): NodeConversionResult<AnyCommentRule>;
+}

package/dist/types/converter/cosmetic/css.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @file CSS injection rule converter
+ */
+import { type CssInjectionRule } from '../../nodes';
+import { RuleConverterBase } from '../base-interfaces/rule-converter-base';
+import { type NodeConversionResult } from '../base-interfaces/conversion-result';
+/**
+ * CSS injection rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+export declare class CssInjectionRuleConverter extends RuleConverterBase {
+    /**
+     * Converts a CSS injection rule to AdGuard format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rule: CssInjectionRule): NodeConversionResult<CssInjectionRule>;
+}

package/dist/types/converter/cosmetic/element-hiding.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @file Element hiding rule converter
+ */
+import { type ElementHidingRule } from '../../nodes';
+import { RuleConverterBase } from '../base-interfaces/rule-converter-base';
+import { type NodeConversionResult } from '../base-interfaces/conversion-result';
+/**
+ * Element hiding rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+export declare class ElementHidingRuleConverter extends RuleConverterBase {
+    /**
+     * Converts an element hiding rule to AdGuard format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rule: ElementHidingRule): NodeConversionResult<ElementHidingRule>;
+}