file-tree headless API

export declare const FileTree: {
  Root: import("react").ForwardRefExoticComponent<FileTreeRootProps & import("react").RefAttributes<HTMLDivElement>>;
  RootProvider: import("react").ForwardRefExoticComponent<FileTreeRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
  Header: import("react").ForwardRefExoticComponent<FileTreeHeaderProps & import("react").RefAttributes<HTMLDivElement>>;
  Tree: import("react").ForwardRefExoticComponent<FileTreeTreeProps & import("react").RefAttributes<HTMLDivElement>>;
  Row: import("react").ForwardRefExoticComponent<FileTreeRowProps & import("react").RefAttributes<HTMLDivElement>>;
};

export declare const FileTreeContext: import("react").Context<FileTreeContextValue | null>;

interface FileTreeContextValue {
  readonly service: FileTreeService;
  readonly connector: FileTreeApi;
  readonly scope: PartScope;
}

interface FileTreeHeaderProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
}

interface FileTreeRootProps extends Omit<ComponentPropsWithoutRef<"div">, "onSelect"> {
  readonly asChild?: boolean;
  readonly nodes: FileTreeInput["nodes"];
  readonly repo?: string;
  readonly selected?: string;
  readonly defaultSelected?: string;
  readonly onSelect?: UseFileTreeOptions["onSelect"];
  readonly children?: ReactNode;
}

interface FileTreeRootProviderProps extends ComponentPropsWithoutRef<"div"> {
  readonly value: UseFileTreeResult;
  readonly asChild?: boolean;
}

interface FileTreeRowProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly row: FileTreeRow$1;
}

interface FileTreeTreeProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
}

export declare const Header: import("react").ForwardRefExoticComponent<FileTreeHeaderProps & import("react").RefAttributes<HTMLDivElement>>;

export declare const Root: import("react").ForwardRefExoticComponent<FileTreeRootProps & import("react").RefAttributes<HTMLDivElement>>;

export declare const RootProvider: import("react").ForwardRefExoticComponent<FileTreeRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;

export declare const Row: import("react").ForwardRefExoticComponent<FileTreeRowProps & import("react").RefAttributes<HTMLDivElement>>;

export declare const Tree: import("react").ForwardRefExoticComponent<FileTreeTreeProps & import("react").RefAttributes<HTMLDivElement>>;

declare function useFileTree(input: FileTreeInput, options?: UseFileTreeOptions): UseFileTreeResult;

declare function useFileTreeContext(partName: string): FileTreeContextValue;

interface UseFileTreeOptions {
  readonly repo?: string;
  readonly onSelect?: (detail: {
    value: string;
    reason: FileTreeChangeReason;
  }) => void;
}

interface UseFileTreeResult {
  readonly service: FileTreeService;
  readonly connector: FileTreeApi;
  readonly scope: PartScope;
  readonly snapshot: FileTreeSnapshot;
}

declare function useServiceVersion<S extends Service<any, any, any, any, any, any>>(service: S): ReturnType<S["getSnapshot"]>;

export declare const FileTree: {
  Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    nodes: {
      type: import("vue").PropType<import("@grassroot/ui-machines/file-tree").FileTreeInput["nodes"]>;
      required: true;
    };
    repo: {
      type: StringConstructor;
      default: string;
    };
    selected: {
      type: import("vue").PropType<string | undefined>;
      default: undefined;
    };
    defaultSelected: {
      type: import("vue").PropType<string | undefined>;
      default: undefined;
    };
    asChild: {
      type: BooleanConstructor;
      default: boolean;
    };
  }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
    [key: string]: any;
  }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    select: (_detail: {
      value: string;
      reason: string;
    }) => true;
  }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    nodes: {
      type: import("vue").PropType<import("@grassroot/ui-machines/file-tree").FileTreeInput["nodes"]>;
      required: true;
    };
    repo: {
      type: StringConstructor;
      default: string;
    };
    selected: {
      type: import("vue").PropType<string | undefined>;
      default: undefined;
    };
    defaultSelected: {
      type: import("vue").PropType<string | undefined>;
      default: undefined;
    };
    asChild: {
      type: BooleanConstructor;
      default: boolean;
    };
  }>> & Readonly<{
    onSelect?: ((_detail: {
      value: string;
      reason: string;
    }) => any) | undefined;
  }>, {
    repo: string;
    selected: string | undefined;
    defaultSelected: string | undefined;
    asChild: boolean;
  }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  RootProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    value: {
      type: import("vue").PropType<ReturnType<typeof useFileTree>>;
      required: true;
    };
    asChild: {
      type: BooleanConstructor;
      default: boolean;
    };
  }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
    [key: string]: any;
  }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    value: {
      type: import("vue").PropType<ReturnType<typeof useFileTree>>;
      required: true;
    };
    asChild: {
      type: BooleanConstructor;
      default: boolean;
    };
  }>> & Readonly<{}>, {
    asChild: boolean;
  }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  Header: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    asChild: {
      type: BooleanConstructor;
      default: boolean;
    };
  }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
    [key: string]: any;
  }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    asChild: {
      type: BooleanConstructor;
      default: boolean;
    };
  }>> & Readonly<{}>, {
    asChild: boolean;
  }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  Tree: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    asChild: {
      type: BooleanConstructor;
      default: boolean;
    };
  }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
    [key: string]: any;
  }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    asChild: {
      type: BooleanConstructor;
      default: boolean;
    };
  }>> & Readonly<{}>, {
    asChild: boolean;
  }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  Row: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    row: {
      type: import("vue").PropType<import("@grassroot/ui-machines/file-tree").FileTreeRow>;
      required: true;
    };
    asChild: {
      type: BooleanConstructor;
      default: boolean;
    };
  }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
    [key: string]: any;
  }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    row: {
      type: import("vue").PropType<import("@grassroot/ui-machines/file-tree").FileTreeRow>;
      required: true;
    };
    asChild: {
      type: BooleanConstructor;
      default: boolean;
    };
  }>> & Readonly<{}>, {
    asChild: boolean;
  }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
};

export declare const FileTreeContextKey: InjectionKey<FileTreeContextValue>;

export declare const Header: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

declare function provideFileTreeContext(value: FileTreeContextValue): void;

export declare const Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  nodes: {
    type: PropType<FileTreeInput["nodes"]>;
    required: true;
  };
  repo: {
    type: StringConstructor;
    default: string;
  };
  selected: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  defaultSelected: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  select: (_detail: {
    value: string;
    reason: string;
  }) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  nodes: {
    type: PropType<FileTreeInput["nodes"]>;
    required: true;
  };
  repo: {
    type: StringConstructor;
    default: string;
  };
  selected: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  defaultSelected: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{
  onSelect?: ((_detail: {
    value: string;
    reason: string;
  }) => any) | undefined;
}>, {
  repo: string;
  selected: string | undefined;
  defaultSelected: string | undefined;
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const RootProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  value: {
    type: PropType<ReturnType<typeof useFileTree>>;
    required: true;
  };
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  value: {
    type: PropType<ReturnType<typeof useFileTree>>;
    required: true;
  };
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const Row: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  row: {
    type: PropType<FileTreeRow$1>;
    required: true;
  };
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  row: {
    type: PropType<FileTreeRow$1>;
    required: true;
  };
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const Tree: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

declare function useFileTree(input: FileTreeInput | (() => FileTreeInput), options?: UseFileTreeOptions): UseFileTreeResult;

declare function useFileTreeContext(partName: string): FileTreeContextValue;

interface UseFileTreeOptions {
  readonly repo?: string;
  readonly onSelect?: (detail: {
    value: string;
    reason: FileTreeChangeReason;
  }) => void;
}

interface UseFileTreeResult {
  readonly service: FileTreeService;
  readonly connector: FileTreeApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<FileTreeSnapshot>;
}

export declare function createFileTreeStore(initialInput: FileTreeInput, options?: FileTreeOptions): FileTreeStore;

export declare const FILE_TREE_STORE: InjectionToken<FileTreeStore>;

export interface FileTreeStore {
    readonly service: FileTreeService;
    readonly connector: FileTreeApi;
    readonly scope: PartScope;
    readonly version: WritableSignal<number>;
    start(): void;
    stop(): void;
    sync(input: FileTreeInput): void;
}

export declare const GR_FILE_TREE_DECLARATIONS: readonly [typeof GrFileTreeRoot, typeof GrFileTreeHeader, typeof GrFileTreeTree, typeof GrFileTreeRow];

export declare class GrFileTreeHeader extends FileTreePart {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<GrFileTreeHeader, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrFileTreeHeader, "[grFileTreeHeader]", never, {}, {}, never, never, true, never>;
}

export declare class GrFileTreeRoot implements OnDestroy {
    readonly nodes: import("@angular/core").InputSignal<readonly import("@grassroot/ui-machines/file-tree").FileTreeNode[]>;
    readonly repo: import("@angular/core").InputSignal<string>;
    readonly selected: import("@angular/core").InputSignal<string | undefined>;
    readonly defaultSelected: import("@angular/core").InputSignal<string | undefined>;
    readonly select: import("@angular/core").OutputEmitterRef<{
        value: string;
        reason: string;
    }>;
    private readonly injector;
    private readonly element;
    private readonly listeners;
    private readonly consumerProps;
    readonly store: import("./context.js").FileTreeStore;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrFileTreeRoot, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrFileTreeRoot, "[grFileTreeRoot]", never, { "nodes": { "alias": "nodes"; "required": false; "isSignal": true; }; "repo": { "alias": "repo"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "defaultSelected": { "alias": "defaultSelected"; "required": false; "isSignal": true; }; }, { "select": "select"; }, never, never, true, never>;
}

export declare class GrFileTreeRow implements OnDestroy {
    readonly row: import("@angular/core").InputSignal<FileTreeRow>;
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumerProps;
    private key;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrFileTreeRow, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrFileTreeRow, "[grFileTreeRow]", never, { "row": { "alias": "row"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

export declare class GrFileTreeTree extends FileTreePart {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<GrFileTreeTree, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrFileTreeTree, "[grFileTreeTree]", never, {}, {}, never, never, true, never>;
}

export declare function createFileTree(inputGetter: () => FileTreeInput, options?: UseFileTreeOptions): UseFileTreeResult;

export declare const FileTree: {
    Root: import("svelte/legacy").LegacyComponentType;
    RootProvider: import("svelte/legacy").LegacyComponentType;
    Header: import("svelte/legacy").LegacyComponentType;
    Tree: import("svelte/legacy").LegacyComponentType;
    Row: import("svelte/legacy").LegacyComponentType;
};

export declare const Header: LegacyComponentType;