import * as _qualcomm_ui_angular_core_machine from '@qualcomm-ui/angular-core/machine';
import { BaseApiContextService, ApiContextDirective } from '@qualcomm-ui/angular-core/machine';
import * as i0 from '@angular/core';
import { TemplateRef, Injector, OnInit } from '@angular/core';
import * as _qualcomm_ui_core_tree from '@qualcomm-ui/core/tree';
import { NodeProps, NodeState } from '@qualcomm-ui/core/tree';
import * as _qualcomm_ui_qds_core_tree from '@qualcomm-ui/qds-core/tree';
import { QdsTreeApi, QdsTreeApiProps, QdsTreeSize } from '@qualcomm-ui/qds-core/tree';
import { TreeNode } from '@qualcomm-ui/utils/collection';
import * as _qualcomm_ui_core_collapsible from '@qualcomm-ui/core/collapsible';
import { CoreTreeBranchContentDirective, CoreTreeBranchIndentGuideDirective, CoreTreeBranchNodeDirective, CoreTreeBranchTriggerDirective, CoreTreeBranchDirective, CoreTreeLabelDirective, CoreTreeLeafNodeDirective, CoreTreeNodeActionDirective, CoreTreeNodeCheckboxDirective, CoreTreeNodeIconDirective, CoreTreeNodeIndicatorDirective, CoreTreeNodeTextDirective, TreeNodePropsContextService, TreeNodeStateContextService, CoreTreeRootDirective } from '@qualcomm-ui/angular-core/tree';
import { LucideIconOrString } from '@qualcomm-ui/angular-core/lucide';
import * as _qualcomm_ui_core_presence from '@qualcomm-ui/core/presence';
import { CollapsibleContextService } from '@qualcomm-ui/angular-core/collapsible';
import * as _qualcomm_ui_qds_core_inline_icon_button from '@qualcomm-ui/qds-core/inline-icon-button';
import { QdsInlineIconButtonSize } from '@qualcomm-ui/qds-core/inline-icon-button';
import { SignalifyInput } from '@qualcomm-ui/angular-core/signals';
import * as i18 from '@qualcomm-ui/angular/icon';
import * as i20 from '@angular/common';
import * as i21 from '@qualcomm-ui/angular/checkmark';

declare class QdsTreeContextService extends BaseApiContextService<QdsTreeApi> {
    static ɵfac: i0.ɵɵFactoryDeclaration<QdsTreeContextService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<QdsTreeContextService>;
}
declare const QDS_TREE_CONTEXT: i0.InjectionToken<() => QdsTreeApi>;
declare const useQdsTreeContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => QdsTreeApi) | null : () => QdsTreeApi;
declare const provideQdsTreeContext: () => i0.Provider[];
interface TreeNodeTemplateContext<T extends TreeNode> {
    $implicit: NodeProps<T>;
}

declare class TreeBranchContentDirective extends CoreTreeBranchContentDirective {
    /**
     * HTML {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
     * omitted, a unique identifier will be generated for accessibility.)
     */
    readonly id: i0.InputSignal<string | undefined>;
    protected readonly hostId: i0.Signal<string>;
    protected qdsContext: () => _qualcomm_ui_qds_core_tree.QdsTreeApi;
    protected collapsibleContext: () => _qualcomm_ui_core_collapsible.CollapsibleApi;
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeBranchContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeBranchContentDirective, "[q-tree-branch-content]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TreeBranchIndentGuideDirective extends CoreTreeBranchIndentGuideDirective {
    protected qdsContext: () => _qualcomm_ui_qds_core_tree.QdsTreeApi;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeBranchIndentGuideDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeBranchIndentGuideDirective, "[q-tree-branch-indent-guide]", never, {}, {}, never, never, false, never>;
}

declare class TreeBranchNodeDirective extends CoreTreeBranchNodeDirective {
    protected qdsContext: () => _qualcomm_ui_qds_core_tree.QdsTreeApi;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeBranchNodeDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeBranchNodeDirective, "[q-tree-branch-node]", never, {}, {}, never, never, false, never>;
}

/**
 * Structural directive that defines the template used to render leaf nodes in a
 * tree. Apply this to an `ng-template` to customize how branch nodes (nodes with
 * children) are displayed. Note that this template will only customize the content
 * of the node. The parent `<q-tree-nodes>` component renders the branch children
 * internally.
 *
 * @example
 * ```html
 * <ng-template q-tree-branch-template let-node>
 *   <div q-tree-branch-node>
 *     <span q-tree-node-text>{{ node.item.label }}</span>
 *   </div>
 * </ng-template>
 * ```
 */
declare class TreeBranchTemplateDirective<T extends TreeNode> {
    /**
     * The root node of the tree. Used for type narrowing of the template guard.
     * {@link https://angular.dev/guide/directives/structural-directives#type-narrowing-with-template-guards Learn more}
     */
    readonly rootNode: i0.InputSignal<T | undefined>;
    template: TemplateRef<any>;
    static ngTemplateContextGuard<T extends TreeNode>(dir: TreeBranchTemplateDirective<T>, ctx: unknown): ctx is TreeNodeTemplateContext<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeBranchTemplateDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeBranchTemplateDirective<any>, "ng-template[q-tree-branch-template]", never, { "rootNode": { "alias": "rootNode"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TreeBranchTriggerDirective extends CoreTreeBranchTriggerDirective {
    /**
     * @default ChevronRight
     */
    readonly icon: i0.InputSignal<LucideIconOrString>;
    protected qdsContext: () => _qualcomm_ui_qds_core_tree.QdsTreeApi;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeBranchTriggerDirective, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TreeBranchTriggerDirective, "[q-tree-branch-trigger]", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TreeBranchDirective extends CoreTreeBranchDirective {
    protected qdsContext: () => _qualcomm_ui_qds_core_tree.QdsTreeApi;
    protected readonly collapsibleApi: CollapsibleContextService;
    protected readonly document: Document;
    protected readonly injector: Injector;
    protected readonly nodeState: () => _qualcomm_ui_core_tree.NodeState<any>;
    protected readonly renderStrategyProps: () => _qualcomm_ui_core_presence.RenderStrategyApi;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeBranchDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeBranchDirective, "[q-tree-branch]", never, {}, {}, never, never, false, never>;
}

declare class TreeLabelDirective extends CoreTreeLabelDirective {
    protected qdsContext: () => _qualcomm_ui_qds_core_tree.QdsTreeApi;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeLabelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeLabelDirective, "[q-tree-label]", never, {}, {}, never, never, false, never>;
}

declare class TreeLeafNodeDirective extends CoreTreeLeafNodeDirective {
    protected qdsContext: () => _qualcomm_ui_qds_core_tree.QdsTreeApi;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeLeafNodeDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeLeafNodeDirective, "[q-tree-leaf-node]", never, {}, {}, never, never, false, never>;
}

/**
 * Structural directive that defines the template used to render leaf nodes in a
 * tree. Apply this to an `ng-template` to customize how leaf nodes (nodes without
 * children) are displayed.
 *
 * @example
 * ```html
 * <ng-template q-tree-leaf-template let-node>
 *   <div q-tree-leaf-node>
 *     <span q-tree-node-text>{{ node.item.label }}</span>
 *   </div>
 * </ng-template>
 * ```
 */
declare class TreeLeafTemplateDirective<T extends TreeNode> {
    /**
     * The root node of the tree. Used for type narrowing of the template guard.
     * {@link https://angular.dev/guide/directives/structural-directives#type-narrowing-with-template-guards Learn more}
     */
    readonly rootNode: i0.InputSignal<T | undefined>;
    template: TemplateRef<any>;
    static ngTemplateContextGuard<T extends TreeNode>(dir: TreeLeafTemplateDirective<T>, ctx: unknown): ctx is TreeNodeTemplateContext<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeLeafTemplateDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeLeafTemplateDirective<any>, "ng-template[q-tree-leaf-template]", never, { "rootNode": { "alias": "rootNode"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TreeNodeActionDirective extends CoreTreeNodeActionDirective {
    /**
     * Lucide icon to display inside the button.
     */
    readonly icon: i0.InputSignal<LucideIconOrString | undefined>;
    /**
     * The size of the button and its icon.
     *
     * @default 'md'
     */
    readonly size: i0.InputSignal<QdsInlineIconButtonSize>;
    protected readonly inlineIconButtonApi: i0.Signal<_qualcomm_ui_qds_core_inline_icon_button.QdsInlineIconButtonApi>;
    protected readonly qdsContext: () => _qualcomm_ui_qds_core_tree.QdsTreeApi;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeActionDirective, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TreeNodeActionDirective, "[q-tree-node-action]", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
}

declare class TreeNodeCheckboxDirective extends CoreTreeNodeCheckboxDirective {
    protected readonly nodeState: () => _qualcomm_ui_core_tree.NodeState<any>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeCheckboxDirective, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TreeNodeCheckboxDirective, "[q-tree-node-checkbox]", never, {}, {}, never, ["*"], false, never>;
}

declare class TreeNodeContextDirective<T extends TreeNode> extends ApiContextDirective<NodeState<T>> {
    /**
     * The root node of the tree. Used for type narrowing of the template guard.
     * {@link https://angular.dev/guide/directives/structural-directives#type-narrowing-with-template-guards Learn more}
     */
    readonly rootNode: i0.InputSignal<T | undefined>;
    constructor();
    static ngTemplateContextGuard<T extends TreeNode>(dir: TreeNodeContextDirective<T>, ctx: unknown): ctx is {
        $implicit: NodeState<T>;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeContextDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeNodeContextDirective<any>, "[treeNodeContext]", never, { "rootNode": { "alias": "rootNode"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TreeNodeIconDirective extends CoreTreeNodeIconDirective {
    readonly icon: i0.InputSignal<LucideIconOrString | undefined>;
    protected readonly qdsContext: () => _qualcomm_ui_qds_core_tree.QdsTreeApi;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeIconDirective, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TreeNodeIconDirective, "[q-tree-node-icon]", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
}

declare class TreeNodeIndicatorDirective extends CoreTreeNodeIndicatorDirective {
    protected readonly qdsContext: () => _qualcomm_ui_qds_core_tree.QdsTreeApi;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeIndicatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeNodeIndicatorDirective, "[q-tree-node-indicator]", never, {}, {}, never, never, false, never>;
}

declare class TreeNodeTextDirective extends CoreTreeNodeTextDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeNodeTextDirective, "[q-tree-node-text]", never, {}, {}, never, never, false, never>;
}

declare class TreeNodesComponent<T extends TreeNode> implements SignalifyInput<NodeProps<T>>, OnInit {
    /**
     * The index path of the tree node
     */
    readonly indexPath: i0.InputSignal<number[]>;
    /**
     * The tree node
     *
     * @inheritDoc
     */
    readonly node: i0.InputSignal<T>;
    readonly renderBranch: i0.InputSignal<TemplateRef<TreeBranchTemplateDirective<T>> | undefined>;
    readonly renderLeaf: i0.InputSignal<TemplateRef<TreeLeafTemplateDirective<T>> | undefined>;
    readonly treeBranchContentChild: i0.Signal<TreeBranchTemplateDirective<T> | undefined>;
    readonly treeLeafContentChild: i0.Signal<TreeLeafTemplateDirective<T> | undefined>;
    readonly branchTemplate: i0.Signal<TemplateRef<any> | undefined>;
    readonly leafTemplate: i0.Signal<TemplateRef<any>>;
    protected treeContext: () => _qualcomm_ui_core_tree.TreeApi<any>;
    readonly injector: Injector;
    readonly templateContext: i0.Signal<TreeNodeTemplateContext<T>>;
    readonly childNodes: i0.Signal<any[]>;
    protected readonly treeNodePropsContextService: TreeNodePropsContextService;
    protected treeNodeStateContextService: TreeNodeStateContextService;
    ngOnInit(): void;
    getChildIndexPath(index: number): number[];
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodesComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TreeNodesComponent<any>, "q-tree-nodes", never, { "indexPath": { "alias": "indexPath"; "required": true; "isSignal": true; }; "node": { "alias": "node"; "required": true; "isSignal": true; }; "renderBranch": { "alias": "renderBranch"; "required": false; "isSignal": true; }; "renderLeaf": { "alias": "renderLeaf"; "required": false; "isSignal": true; }; }, {}, ["treeBranchContentChild", "treeLeafContentChild"], never, false, never>;
}

declare class TreeRootDirective extends CoreTreeRootDirective implements SignalifyInput<QdsTreeApiProps>, OnInit {
    /**
     * The size of the tree and its elements. Governs properties like font size,
     * item padding, and icon sizes.
     *
     * @default 'md'
     */
    readonly size: i0.InputSignal<QdsTreeSize | undefined>;
    protected readonly qdsTreeService: QdsTreeContextService;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeRootDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeRootDirective, "[q-tree-root]", ["treeRoot"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TreeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TreeModule, [typeof TreeRootDirective, typeof TreeBranchDirective, typeof TreeBranchContentDirective, typeof TreeBranchIndentGuideDirective, typeof TreeBranchNodeDirective, typeof TreeBranchTriggerDirective, typeof TreeLabelDirective, typeof TreeLeafNodeDirective, typeof TreeNodeActionDirective, typeof TreeNodeIconDirective, typeof TreeNodeIndicatorDirective, typeof TreeNodeTextDirective, typeof TreeLeafTemplateDirective, typeof TreeBranchTemplateDirective, typeof TreeNodeContextDirective, typeof TreeNodeCheckboxDirective, typeof TreeNodesComponent], [typeof i18.IconDirective, typeof _qualcomm_ui_angular_core_machine.QBindDirective, typeof i20.NgTemplateOutlet, typeof i21.CheckmarkIconComponent], [typeof TreeRootDirective, typeof TreeBranchDirective, typeof TreeBranchContentDirective, typeof TreeBranchIndentGuideDirective, typeof TreeBranchNodeDirective, typeof TreeBranchTriggerDirective, typeof TreeLabelDirective, typeof TreeLeafNodeDirective, typeof TreeNodeActionDirective, typeof TreeNodeIconDirective, typeof TreeNodeIndicatorDirective, typeof TreeNodeTextDirective, typeof TreeBranchTemplateDirective, typeof TreeLeafTemplateDirective, typeof TreeNodeContextDirective, typeof TreeNodeCheckboxDirective, typeof TreeNodesComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TreeModule>;
}

export { QDS_TREE_CONTEXT, QdsTreeContextService, TreeBranchContentDirective, TreeBranchDirective, TreeBranchIndentGuideDirective, TreeBranchNodeDirective, TreeBranchTemplateDirective, TreeBranchTriggerDirective, TreeLabelDirective, TreeLeafNodeDirective, TreeLeafTemplateDirective, TreeModule, TreeNodeActionDirective, TreeNodeCheckboxDirective, TreeNodeContextDirective, TreeNodeIconDirective, TreeNodeIndicatorDirective, TreeNodeTextDirective, TreeNodesComponent, TreeRootDirective, provideQdsTreeContext, useQdsTreeContext };
export type { TreeNodeTemplateContext };
//# sourceMappingURL=qualcomm-ui-angular-tree.d.ts.map