diff-viewer headless API

interface DiffViewerRootProps extends Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
  readonly mode?: DiffViewerMode;
  readonly defaultMode?: DiffViewerMode;
  readonly disabled?: boolean;
  readonly ariaLabel?: string;
  readonly id?: string;
  readonly onModeChange?: (detail: DiffViewerChangeDetail) => void;
  readonly children?: ReactNode;
}

interface DiffViewerRootProviderProps extends Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
  readonly value: UseDiffViewerResult;
  readonly children?: ReactNode;
}

export declare const ModeButton: import("react").ForwardRefExoticComponent<ModeButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

interface ModeButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
  readonly mode: DiffViewerMode;
  readonly children?: ReactNode;
}

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

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

declare function useDiffViewer(input: DiffViewerInput, options?: UseDiffViewerOptions): UseDiffViewerResult;

interface UseDiffViewerOptions extends DiffViewerConnectOptions {
  readonly id?: string;
  readonly onModeChange?: (detail: DiffViewerChangeDetail) => void;
}

interface UseDiffViewerResult {
  readonly service: DiffViewerService;
  readonly connector: DiffViewerApi;
  readonly scope: PartScope;
  readonly snapshot: DiffViewerSnapshot;
}

export declare const DiffViewerModeButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  mode: {
    type: PropType<DiffViewerMode>;
    required: true;
  };
}>, () => 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;
  };
  mode: {
    type: PropType<DiffViewerMode>;
    required: true;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const DiffViewerRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  mode: PropType<DiffViewerMode>;
  defaultMode: PropType<DiffViewerMode>;
  disabled: BooleanConstructor;
  ariaLabel: StringConstructor;
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  modeChange: (_detail: DiffViewerChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  mode: PropType<DiffViewerMode>;
  defaultMode: PropType<DiffViewerMode>;
  disabled: BooleanConstructor;
  ariaLabel: StringConstructor;
}>> & Readonly<{
  onModeChange?: ((_detail: DiffViewerChangeDetail) => any) | undefined;
}>, {
  asChild: boolean;
  disabled: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const DiffViewerRootProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  mode: PropType<DiffViewerMode>;
  defaultMode: PropType<DiffViewerMode>;
  disabled: BooleanConstructor;
  ariaLabel: StringConstructor;
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  modeChange: (_detail: DiffViewerChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  mode: PropType<DiffViewerMode>;
  defaultMode: PropType<DiffViewerMode>;
  disabled: BooleanConstructor;
  ariaLabel: StringConstructor;
}>> & Readonly<{
  onModeChange?: ((_detail: DiffViewerChangeDetail) => any) | undefined;
}>, {
  asChild: boolean;
  disabled: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

declare function useDiffViewer(input: () => DiffViewerInput, options?: () => DiffViewerOptions): UseDiffViewerResult;

interface UseDiffViewerResult {
  readonly service: DiffViewerService;
  readonly connector: DiffViewerApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<DiffViewerSnapshot>;
}

export declare function createDiffViewerStore(initial: DiffViewerInput, options?: CreateDiffViewerStoreOptions): DiffViewerStore;

export interface CreateDiffViewerStoreOptions {
    readonly ariaLabel?: string;
    readonly onModeChange?: (detail: DiffViewerChangeDetail) => void;
    readonly onCommit?: () => void;
}

export interface DiffViewerStore {
    readonly service: DiffViewerService;
    readonly connector: DiffViewerApi;
    readonly scope: PartScope;
    readonly version: WritableSignal<number>;
    start(): void;
    stop(): void;
    sync(input: DiffViewerInput): void;
}

export declare class GrDiffViewerModeButton implements OnDestroy {
    readonly mode: import("@angular/core").InputSignal<DiffViewerMode>;
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    private registered;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrDiffViewerModeButton, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrDiffViewerModeButton, "[grDiffViewerModeButton]", never, { "mode": { "alias": "mode"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

export declare class GrDiffViewerRoot implements OnDestroy {
    readonly mode: import("@angular/core").InputSignal<DiffViewerMode | undefined>;
    readonly defaultMode: import("@angular/core").InputSignal<DiffViewerMode | undefined>;
    readonly disabled: import("@angular/core").InputSignal<boolean | undefined>;
    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
    readonly modeChange: import("@angular/core").OutputEmitterRef<DiffViewerChangeDetail>;
    readonly store: DiffViewerStore;
    private readonly host;
    private readonly listeners;
    private last;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrDiffViewerRoot, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrDiffViewerRoot, "gr-diff-viewer-root", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "defaultMode": { "alias": "defaultMode"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "modeChange": "modeChange"; }, never, ["*"], true, never>;
}

export declare class GrDiffViewerRootProvider implements OnDestroy {
    private readonly store;
    private readonly host;
    private readonly listeners;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrDiffViewerRootProvider, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrDiffViewerRootProvider, "gr-diff-viewer-root-provider", never, {}, {}, never, ["*"], true, never>;
}

export declare function createDiffViewer(input: () => DiffViewerInput, options?: UseDiffViewerOptions): UseDiffViewerResult;

export declare const ModeButton: LegacyComponentType;

export declare const Root: LegacyComponentType;

export declare const RootProvider: LegacyComponentType;

export interface UseDiffViewerOptions {
    readonly id?: string;
    readonly ariaLabel?: string;
    readonly onModeChange?: (detail: import("@grassroot/ui-headless-core/diff-viewer").DiffViewerChangeDetail) => void;
}

export interface UseDiffViewerResult {
    readonly service: DiffViewerService;
    readonly connector: DiffViewerApi;
    readonly scope: ReturnType<typeof import("@grassroot/ui-headless-core").createPartScope>;
    readonly version: () => number;
}

export interface DiffViewerRootProps extends Omit<JSX.HTMLAttributes<HTMLDivElement>, "onChange">, DiffViewerInput {
    readonly ariaLabel?: string;
    readonly id?: string;
    readonly onModeChange?: (detail: DiffViewerChangeDetail) => void;
    readonly children?: JSX.Element;
}

export interface DiffViewerRootProviderProps extends Omit<JSX.HTMLAttributes<HTMLDivElement>, "onChange"> {
    readonly value: UseDiffViewerResult;
    readonly children?: JSX.Element;
}

export declare function ModeButton(props: ModeButtonProps): JSX.Element;

export interface ModeButtonProps extends JSX.ButtonHTMLAttributes<HTMLButtonElement> {
    readonly mode: DiffViewerMode;
    readonly children?: JSX.Element;
}

export declare function Root(props: DiffViewerRootProps): JSX.Element;

export declare function RootProvider(props: DiffViewerRootProviderProps): JSX.Element;

export declare function useDiffViewer(input: Accessor<DiffViewerInput>, options?: UseDiffViewerOptions): UseDiffViewerResult;

export interface UseDiffViewerOptions extends DiffViewerConnectOptions {
    readonly id?: string;
    readonly onModeChange?: (detail: DiffViewerChangeDetail) => void;
}

export interface UseDiffViewerResult {
    readonly service: DiffViewerService;
    readonly connector: DiffViewerApi;
    readonly scope: PartScope;
    readonly snapshot: Accessor<DiffViewerSnapshot>;
}