import { Any } from '@likec4/core/types';
import { AutoLayoutDirection } from '@likec4/core/types';
import { aux } from '@likec4/core/types';
import { BBox } from '@likec4/core/types';
import { BBox as BBox_2 } from '@likec4/core/geometry';
import { BBox as BBox_3 } from '@likec4/core';
import { CamelCasedProperties } from 'type-fest';
import { Color } from '@likec4/core/types';
import { ComputedNodeStyle } from '@likec4/core/types';
import { ComputedNodeStyle as ComputedNodeStyle_2 } from '@likec4/core';
import { Context as Context_4 } from 'react';
import { CSSProperties } from 'react';
import { DependencyList } from 'react';
import { DeploymentFqn } from '@likec4/core/types';
import { DetailedHTMLProps } from 'react';
import { DiagramEdge } from '@likec4/core/types';
import { DiagramNode } from '@likec4/core/types';
import { DiagramNodeDriftReason } from '@likec4/core/types';
import { DiagramView } from '@likec4/core/types';
import { DynamicViewDisplayVariant } from '@likec4/core/types';
import { Edge } from '@xyflow/react';
import { EdgeChange } from '@xyflow/system';
import { EdgeChange as EdgeChange_2 } from '@xyflow/react';
import { EdgeId } from '@likec4/core/types';
import { EdgeId as EdgeId_2 } from '@likec4/core';
import { EdgeProps } from '@xyflow/react';
import { EffectCallback } from 'react';
import { ElementKind } from '@likec4/core/types';
import { ElementProps } from '@mantine/core';
import { ElementShape as ElementShape_2 } from '@likec4/core/types';
import { ElementStyle } from '@likec4/core/types';
import { Except } from 'type-fest';
import { ExclusiveUnion } from '@likec4/core/types';
import { ExclusiveUnion as ExclusiveUnion_2 } from '@likec4/core';
import { FC } from 'react';
import { ForwardRefComponent } from 'motion/react';
import { ForwardRefExoticComponent } from 'react';
import { Fqn } from '@likec4/core/types';
import { Fqn as Fqn_3 } from '@likec4/core';
import { FunctionComponent } from 'react';
import { HTMLAttributes } from 'react';
import { HTMLMotionProps } from 'motion/react';
import { IconUrl } from '@likec4/core/types';
import { JSX } from 'react/jsx-runtime';
import { JsxStyleProps } from '@likec4/styles/types';
import { LayoutedProjectsView } from '@likec4/core/compute-view';
import { LayoutedView } from '@likec4/core/types';
import { LayoutType } from '@likec4/core/types';
import { LikeC4Model } from '@likec4/core/model';
import { LikeC4Project } from '@likec4/core/types';
import { LikeC4Styles } from '@likec4/core/styles';
import { LikeC4ViewModel } from '@likec4/core/model';
import { MarkdownOrString } from '@likec4/core/types';
import { MarkdownOrString as MarkdownOrString_2 } from '@likec4/core';
import { MemoExoticComponent } from 'react';
import { MotionNodeLayoutOptions } from 'motion/react';
import { MotionStyle } from 'motion/react';
import { MouseEvent as MouseEvent_2 } from 'react';
import { NavigationPanelRecipe } from '@likec4/styles/recipes';
import { Node as Node_2 } from '@xyflow/react';
import { NodeChange } from '@xyflow/system';
import { NodeChange as NodeChange_2 } from '@xyflow/react';
import { NodeId } from '@likec4/core/types';
import { NodeId as NodeId_3 } from '@likec4/core';
import { NodeModel } from '@likec4/core/model';
import { NodeNotation } from '@likec4/core/types';
import { NodeProps } from '@xyflow/react';
import { NodeToolbarProps } from '@xyflow/react';
import { NonEmptyArray } from '@likec4/core/types';
import { NonEmptyObject } from 'type-fest';
import { NonEmptyReadonlyArray } from '@likec4/core/types';
import { OptionalKeysOf } from 'type-fest';
import { PartialDeep } from 'type-fest';
import { ProjectId } from '@likec4/core/types';
import { ProjectId as ProjectId_2 } from '@likec4/core';
import { PropsWithChildren } from 'react';
import { ReactFlowInstance } from '@xyflow/react';
import { ReactFlowProps } from '@xyflow/react';
import { ReactFlowState } from '@xyflow/react';
import { ReactNode } from 'react';
import { Rect } from '@xyflow/system';
import { RefAttributes } from 'react';
import { RefObject } from 'react';
import { RelationId as RelationId_2 } from '@likec4/core/types';
import { RelationshipArrowType } from '@likec4/core/types';
import { RelationshipLineType } from '@likec4/core/types';
import { RichTextOrEmpty } from '@likec4/core/types';
import { SetRequired } from 'type-fest';
import { Simplify } from 'type-fest';
import { SimplifyDeep } from 'type-fest';
import { StepEdgeId } from '@likec4/core/types';
import { StyleContextConsumer } from '@likec4/styles/jsx';
import { StyleContextProvider } from '@likec4/styles/jsx';
import type * as t from '@likec4/core/types';
import { UnknownLayouted as UnknownLayouted_2 } from '@likec4/core/types';
import { UnstyledButtonProps } from '@mantine/core';
import { ViewChange } from '@likec4/core/types';
import { ViewId } from '@likec4/core/types';
import { ViewId as ViewId_3 } from '@likec4/core';
import { Viewport } from '@xyflow/system';
import { WhereOperator } from '@likec4/core/types';
import { Without } from 'type-fest/source/merge-exclusive';
import { XYPosition } from '@xyflow/system';

declare type Action<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject> = NoRequiredParams<TAction> | WithDynamicParams<TContext, TExpressionEvent, TAction> | ActionFunction<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay, TEmitted>;

declare interface ActionArgs<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> extends UnifiedArg<TContext, TExpressionEvent, TEvent> {
}

declare type ActionExecutor = (actionToExecute: ExecutableActionObject) => void;

declare type ActionFunction<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject> = {
    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
    _out_TEvent?: TEvent;
    _out_TActor?: TActor;
    _out_TAction?: TAction;
    _out_TGuard?: TGuard;
    _out_TDelay?: TDelay;
    _out_TEmitted?: TEmitted;
};

declare type ActionFunctionMap<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = string, TEmitted extends EventObject = EventObject> = {
    [K in TAction['type']]?: ActionFunction<TContext, TEvent, TEvent, GetParameterizedParams<TAction extends {
        type: K;
    } ? TAction : never>, TActor, TAction, TGuard, TDelay, TEmitted>;
};

declare type Actions<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject> = SingleOrArray<Action<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay, TEmitted>>;

declare interface ActiveMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> {
    status: 'active';
    output: undefined;
    error: undefined;
}

/**
 * An Actor is a running process that can receive events, send events and change
 * its behavior based on the events it receives, which can cause effects outside
 * of the actor. When you run a state machine, it becomes an actor.
 */
declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<SnapshotFrom<TLogic>, EventFromLogic<TLogic>, EmittedFrom<TLogic>> {
    logic: TLogic;
    /** The current internal state of the actor. */
    private _snapshot;
    /**
     * The clock that is responsible for setting and clearing timeouts, such as
     * delayed events and transitions.
     */
    clock: Clock;
    options: Readonly<ActorOptions<TLogic>>;
    /** The unique identifier for this actor relative to its parent. */
    id: string;
    private mailbox;
    private observers;
    private eventListeners;
    private logger;
    _parent?: AnyActorRef;
    ref: ActorRef<SnapshotFrom<TLogic>, EventFromLogic<TLogic>, EmittedFrom<TLogic>>;
    private _actorScope;
    systemId: string | undefined;
    /** The globally unique process ID for this invocation. */
    sessionId: string;
    /** The system to which this actor belongs. */
    system: AnyActorSystem;
    private _doneEvent?;
    src: string | AnyActorLogic;
    /**
     * Creates a new actor instance for the given logic with the provided options,
     * if any.
     *
     * @param logic The logic to create an actor from
     * @param options Actor options
     */
    constructor(logic: TLogic, options?: ActorOptions<TLogic>);
    private _initState;
    private _deferred;
    private update;
    /**
     * Subscribe an observer to an actor’s snapshot values.
     *
     * @remarks
     * The observer will receive the actor’s snapshot value when it is emitted.
     * The observer can be:
     *
     * - A plain function that receives the latest snapshot, or
     * - An observer object whose `.next(snapshot)` method receives the latest
     *   snapshot
     *
     * @example
     *
     * ```ts
     * // Observer as a plain function
     * const subscription = actor.subscribe((snapshot) => {
     *   console.log(snapshot);
     * });
     * ```
     *
     * @example
     *
     * ```ts
     * // Observer as an object
     * const subscription = actor.subscribe({
     *   next(snapshot) {
     *     console.log(snapshot);
     *   },
     *   error(err) {
     *     // ...
     *   },
     *   complete() {
     *     // ...
     *   }
     * });
     * ```
     *
     * The return value of `actor.subscribe(observer)` is a subscription object
     * that has an `.unsubscribe()` method. You can call
     * `subscription.unsubscribe()` to unsubscribe the observer:
     *
     * @example
     *
     * ```ts
     * const subscription = actor.subscribe((snapshot) => {
     *   // ...
     * });
     *
     * // Unsubscribe the observer
     * subscription.unsubscribe();
     * ```
     *
     * When the actor is stopped, all of its observers will automatically be
     * unsubscribed.
     *
     * @param observer - Either a plain function that receives the latest
     *   snapshot, or an observer object whose `.next(snapshot)` method receives
     *   the latest snapshot
     */
    subscribe(observer: Observer<SnapshotFrom<TLogic>>): Subscription;
    subscribe(nextListener?: (snapshot: SnapshotFrom<TLogic>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
    on<TType extends EmittedFrom<TLogic>['type'] | '*'>(type: TType, handler: (emitted: EmittedFrom<TLogic> & (TType extends '*' ? unknown : {
        type: TType;
    })) => void): Subscription;
    select<TSelected>(selector: (snapshot: SnapshotFrom<TLogic>) => TSelected, equalityFn?: (a: TSelected, b: TSelected) => boolean): Readable<TSelected>;
    /** Starts the Actor from the initial state */
    start(): this;
    private _process;
    private _stop;
    /** Stops the Actor and unsubscribe all listeners. */
    stop(): this;
    private _complete;
    private _reportError;
    private _error;
    private _stopProcedure;
    /**
     * Sends an event to the running Actor to trigger a transition.
     *
     * @param event The event to send
     */
    send(event: EventFromLogic<TLogic>): void;
    private attachDevTools;
    toJSON(): {
        xstate$$type: number;
        id: string;
    };
    /**
     * Obtain the internal state of the actor, which can be persisted.
     *
     * @remarks
     * The internal state can be persisted from any actor, not only machines.
     *
     * Note that the persisted state is not the same as the snapshot from
     * {@link Actor.getSnapshot}. Persisted state represents the internal state of
     * the actor, while snapshots represent the actor's last emitted value.
     *
     * Can be restored with {@link ActorOptions.state}
     * @see https://stately.ai/docs/persistence
     */
    getPersistedSnapshot(): Snapshot<unknown>;
    [symbolObservable](): InteropSubscribable<SnapshotFrom<TLogic>>;
    /**
     * Read an actor’s snapshot synchronously.
     *
     * @remarks
     * The snapshot represent an actor's last emitted value.
     *
     * When an actor receives an event, its internal state may change. An actor
     * may emit a snapshot when a state transition occurs.
     *
     * Note that some actors, such as callback actors generated with
     * `fromCallback`, will not emit snapshots.
     * @see {@link Actor.subscribe} to subscribe to an actor’s snapshot values.
     * @see {@link Actor.getPersistedSnapshot} to persist the internal state of an actor (which is more than just a snapshot).
     */
    getSnapshot(): SnapshotFrom<TLogic>;
}

/**
 * Represents logic which can be used by an actor.
 *
 * @template TSnapshot - The type of the snapshot.
 * @template TEvent - The type of the event object.
 * @template TInput - The type of the input.
 * @template TSystem - The type of the actor system.
 */
declare interface ActorLogic<in out TSnapshot extends Snapshot<unknown>, // it's invariant because it's also part of `ActorScope["self"]["getSnapshot"]`
in out TEvent extends EventObject, // it's invariant because it's also part of `ActorScope["self"]["send"]`
in TInput = NonReducibleUnknown, TSystem extends AnyActorSystem = AnyActorSystem, in out TEmitted extends EventObject = EventObject> {
    /** The initial setup/configuration used to create the actor logic. */
    config?: unknown;
    /**
     * Transition function that processes the current state and an incoming event
     * to produce a new state.
     *
     * @param snapshot - The current state.
     * @param event - The incoming event.
     * @param actorScope - The actor scope.
     * @returns The new state.
     */
    transition: (snapshot: TSnapshot, event: TEvent, actorScope: ActorScope<TSnapshot, TEvent, TSystem, TEmitted>) => TSnapshot;
    /**
     * Called to provide the initial state of the actor.
     *
     * @param actorScope - The actor scope.
     * @param input - The input for the initial state.
     * @returns The initial state.
     */
    getInitialSnapshot: (actorScope: ActorScope<TSnapshot, TEvent, TSystem, TEmitted>, input: TInput) => TSnapshot;
    /**
     * Called when Actor is created to restore the internal state of the actor
     * given a persisted state. The persisted state can be created by
     * `getPersistedSnapshot`.
     *
     * @param persistedState - The persisted state to restore from.
     * @param actorScope - The actor scope.
     * @returns The restored state.
     */
    restoreSnapshot?: (persistedState: Snapshot<unknown>, actorScope: ActorScope<TSnapshot, TEvent, AnyActorSystem, TEmitted>) => TSnapshot;
    /**
     * Called when the actor is started.
     *
     * @param snapshot - The starting state.
     * @param actorScope - The actor scope.
     */
    start?: (snapshot: TSnapshot, actorScope: ActorScope<TSnapshot, TEvent, AnyActorSystem, TEmitted>) => void;
    /**
     * Obtains the internal state of the actor in a representation which can be be
     * persisted. The persisted state can be restored by `restoreSnapshot`.
     *
     * @param snapshot - The current state.
     * @returns The a representation of the internal state to be persisted.
     */
    getPersistedSnapshot: (snapshot: TSnapshot, options?: unknown) => Snapshot<unknown>;
}

declare interface ActorOptions<TLogic extends AnyActorLogic> {
    /**
     * The clock that is responsible for setting and clearing timeouts, such as
     * delayed events and transitions.
     *
     * @remarks
     * You can create your own “clock”. The clock interface is an object with two
     * functions/methods:
     *
     * - `setTimeout` - same arguments as `window.setTimeout(fn, timeout)`
     * - `clearTimeout` - same arguments as `window.clearTimeout(id)`
     *
     * By default, the native `setTimeout` and `clearTimeout` functions are used.
     *
     * For testing, XState provides `SimulatedClock`.
     * @see {@link Clock}
     * @see {@link SimulatedClock}
     */
    clock?: Clock;
    /**
     * Specifies the logger to be used for `log(...)` actions. Defaults to the
     * native `console.log(...)` method.
     */
    logger?: (...args: any[]) => void;
    parent?: AnyActorRef;
    /** The custom `id` for referencing this service. */
    id?: string;
    /** @deprecated Use `inspect` instead. */
    devTools?: never;
    /** The system ID to register this actor under. */
    systemId?: string;
    /** The input data to pass to the actor. */
    input?: InputFrom<TLogic>;
    /**
     * Initializes actor logic from a specific persisted internal state.
     *
     * @remarks
     * If the state is compatible with the actor logic, when the actor is started
     * it will be at that persisted state. Actions from machine actors will not be
     * re-executed, because they are assumed to have been already executed.
     * However, invocations will be restarted, and spawned actors will be restored
     * recursively.
     *
     * Can be generated with {@link Actor.getPersistedSnapshot}.
     * @see https://stately.ai/docs/persistence
     */
    snapshot?: Snapshot<unknown>;
    /** @deprecated Use `snapshot` instead. */
    state?: Snapshot<unknown>;
    /** The source actor logic. */
    src?: string | AnyActorLogic;
    /**
     * A callback function or observer object which can be used to inspect actor
     * system updates.
     *
     * @remarks
     * If a callback function is provided, it can accept an inspection event
     * argument. The types of inspection events that can be observed include:
     *
     * - `@xstate.actor` - An actor ref has been created in the system
     * - `@xstate.event` - An event was sent from a source actor ref to a target
     *   actor ref in the system
     * - `@xstate.snapshot` - An actor ref emitted a snapshot due to a received
     *   event
     *
     * @example
     *
     * ```ts
     * import { createMachine } from 'xstate';
     *
     * const machine = createMachine({
     *   // ...
     * });
     *
     * const actor = createActor(machine, {
     *   inspect: (inspectionEvent) => {
     *     if (inspectionEvent.actorRef === actor) {
     *       // This event is for the root actor
     *     }
     *
     *     if (inspectionEvent.type === '@xstate.actor') {
     *       console.log(inspectionEvent.actorRef);
     *     }
     *
     *     if (inspectionEvent.type === '@xstate.event') {
     *       console.log(inspectionEvent.sourceRef);
     *       console.log(inspectionEvent.actorRef);
     *       console.log(inspectionEvent.event);
     *     }
     *
     *     if (inspectionEvent.type === '@xstate.snapshot') {
     *       console.log(inspectionEvent.actorRef);
     *       console.log(inspectionEvent.event);
     *       console.log(inspectionEvent.snapshot);
     *     }
     *   }
     * });
     * ```
     *
     * Alternately, an observer object (`{ next?, error?, complete? }`) can be
     * provided:
     *
     * @example
     *
     * ```ts
     * const actor = createActor(machine, {
     *   inspect: {
     *     next: (inspectionEvent) => {
     *       if (inspectionEvent.actorRef === actor) {
     *         // This event is for the root actor
     *       }
     *
     *       if (inspectionEvent.type === '@xstate.actor') {
     *         console.log(inspectionEvent.actorRef);
     *       }
     *
     *       if (inspectionEvent.type === '@xstate.event') {
     *         console.log(inspectionEvent.sourceRef);
     *         console.log(inspectionEvent.actorRef);
     *         console.log(inspectionEvent.event);
     *       }
     *
     *       if (inspectionEvent.type === '@xstate.snapshot') {
     *         console.log(inspectionEvent.actorRef);
     *         console.log(inspectionEvent.event);
     *         console.log(inspectionEvent.snapshot);
     *       }
     *     }
     *   }
     * });
     * ```
     */
    inspect?: Observer<InspectionEvent> | ((inspectionEvent: InspectionEvent) => void);
}

declare interface ActorRef<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TEmitted extends EventObject = EventObject> extends Subscribable<TSnapshot>, InteropObservable<TSnapshot> {
    /** The unique identifier for this actor relative to its parent. */
    id: string;
    sessionId: string;
    send: (event: TEvent) => void;
    start: () => void;
    getSnapshot: () => TSnapshot;
    getPersistedSnapshot: () => Snapshot<unknown>;
    stop: () => void;
    toJSON?: () => any;
    _parent?: AnyActorRef;
    system: AnyActorSystem;
    src: string | AnyActorLogic;
    on: <TType extends TEmitted['type'] | '*'>(type: TType, handler: (emitted: TEmitted & (TType extends '*' ? unknown : {
        type: TType;
    })) => void) => Subscription;
    select<TSelected>(selector: (snapshot: TSnapshot) => TSelected, equalityFn?: (a: TSelected, b: TSelected) => boolean): Readable<TSelected>;
}

declare type ActorRefFromLogic<T extends AnyActorLogic> = ActorRef<SnapshotFrom<T>, EventFromLogic<T>, EmittedFrom<T>>;

declare type ActorRefLike = Pick<AnyActorRef, 'sessionId' | 'send' | 'getSnapshot'>;

declare interface ActorScope<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TSystem extends AnyActorSystem = AnyActorSystem, TEmitted extends EventObject = EventObject> {
    self: ActorRef<TSnapshot, TEvent, TEmitted>;
    id: string;
    sessionId: string;
    logger: (...args: any[]) => void;
    defer: (fn: () => void) => void;
    emit: (event: TEmitted) => void;
    system: TSystem;
    stopChild: (child: AnyActorRef) => void;
    actionExecutor: ActionExecutor;
}

declare interface ActorSystem<T extends ActorSystemInfo> {
    get: <K extends keyof T['actors']>(key: K) => T['actors'][K] | undefined;
    getAll: () => Partial<T['actors']>;
    inspect: (observer: Observer<InspectionEvent> | ((inspectionEvent: InspectionEvent) => void)) => Subscription;
    scheduler: Scheduler;
    getSnapshot: () => {
        _scheduledEvents: Record<string, ScheduledEvent>;
    };
    start: () => void;
    _clock: Clock;
    _logger: (...args: any[]) => void;
}

declare interface ActorSystemInfo {
    actors: Record<string, AnyActorRef>;
}

declare type AlignmentMode = LinearAlignmentMode | GridAlignmentMode;

declare type Any_2 = t.aux.Any;

declare type Any_3 = t.aux.Any;

declare type Any_4 = t.aux.Any;

declare type Any_5 = aux.Any;

declare type AnyActorLogic = ActorLogic<any, // snapshot
any, // event
any, // input
any, // system
any>;

declare type AnyActorRef = ActorRef<any, any, // TODO: shouldn't this be AnyEventObject?
any>;

declare type AnyActorScope = ActorScope<any, // TSnapshot
any, // TEvent
AnyActorSystem, any>;

declare type AnyActorSystem = ActorSystem<any>;

declare interface AnyEventObject extends EventObject {
    [key: string]: any;
}

declare type AnyFunction = (...args: any[]) => any;

declare type AnyStateMachine = StateMachine<any, // context
any, // event
any, // children
any, // actor
any, // action
any, // guard
any, // delay
any, // state value
any, // tag
any, // input
any, // output
any, // emitted
any, // TMeta
any>;

declare type AnyTransitionDefinition = TransitionDefinition<any, any>;

export declare const Base: {
    setDimmed: typeof setDimmed;
    setHovered: typeof setHovered;
    setData: typeof setData;
};

export declare namespace Base {
    export type Dimmed = 'immediate' | boolean;
}

export declare interface BaseEdge<Data extends Record<string, unknown> = Record<string, unknown>, EdgeType extends string = string> extends SetRequired<Edge<Data & BaseEdgeData, EdgeType>, 'type' | 'data'> {
}

export declare type BaseEdgeData = {
    /**
     * Whether the cursor is hovering over the edge
     */
    hovered?: boolean;
    /**
     * Whether the edge is active (animated and highlighted)
     */
    active?: boolean;
    /**
     * Whether the edge is dimmed
     * 'immediate' means that the edge is dimmed without delay
     */
    dimmed?: Base.Dimmed;
};

/**
 * ReactFlow Base Edge properties with BaseEdgeData at least
 */
export declare interface BaseEdgeProps<E extends BaseEdge = BaseEdge> extends EdgeProps<E> {
}

export declare type BaseEdgePropsWithData<Data extends Record<string, unknown>> = BaseEdgeProps<BaseEdge<Data>>;

declare interface BaseInspectionEventProperties {
    rootId: string;
    /**
     * The relevant actorRef for the inspection event.
     *
     * - For snapshot events, this is the `actorRef` of the snapshot.
     * - For event events, this is the target `actorRef` (recipient of event).
     * - For actor events, this is the `actorRef` of the registered actor.
     */
    actorRef: ActorRefLike;
}

export declare type BaseNode<Data extends Record<string, unknown> = Record<string, unknown>, NodeType extends string = string> = SetRequired<Node_2<Data & BaseNodeData, NodeType>, 'type' | 'initialWidth' | 'initialHeight'>;

export declare type BaseNodeData = {
    /**
     * Whether the cursor is hovering over the node
     */
    hovered?: boolean;
    /**
     * Whether the node is dimmed
     * 'immediate' means that the node is dimmed without delay
     */
    dimmed?: Base.Dimmed;
};

/**
 * ReactFlow Base Node properties with BaseNodeData at least
 */
export declare interface BaseNodeProps<N extends BaseNode = BaseNode> extends NodeProps<N> {
}

export declare type BaseNodePropsWithData<Data extends Record<string, unknown>> = BaseNodeProps<BaseNode<Data>>;

declare interface Clock {
    setTimeout(fn: (...args: any[]) => void, timeout: number): any;
    clearTimeout(id: any): void;
}

export declare function CompoundActionButton({ data: { hovered: isHovered, }, icon, onClick, }: CompoundActionButtonProps): JSX.Element;

declare type CompoundActionButtonProps = Simplify<BaseNodeProps & {
    icon?: ReactNode;
    onClick: (e: MouseEvent_2) => void;
}>;

export declare const CompoundActions: (props: CompoundActionsProps) => JSX.Element | null;

declare type CompoundActionsProps = Types.NodeProps<'compound-deployment' | 'compound-element'>;

export declare function CompoundDeploymentNode(props: Types.NodeProps<'compound-deployment'>): JSX.Element;

/**
 * Node that will be used to render the compound from the deployment model.
 * It is a container node, i.e. it has children.
 *
 * Custom node renderer receives these props:
 * - `nodeProps`: props from XYFlow
 * - `nodeModel`: LikeC4 {@link NodeModel.WithDeploymentElement}
 *
 * @see [Default implementation](https://github.com/likec4/likec4/blob/main/packages/diagram/src/likec4diagram/custom/nodes/nodes.tsx)
 *
 * @example
 * ```tsx
 * import {
 *   compoundDeploymentNode,
 *   CompoundNodeContainer,
 *   CompoundTitle,
 *   CompoundActions,
 *   CompoundDeploymentToolbar,
 *   DefaultHandles,
 * } from '@likec4/diagram/custom'
 *
 * const CustomCompoundDeploymentNode = compoundDeploymentNode(({ nodeProps, nodeModel }) => (
 *   <CompoundNodeContainer nodeProps={nodeProps}>
 *     <CompoundTitle {...nodeProps} />
 *     <CompoundActions {...nodeProps} />
 *     <IfNotReadOnly>
 *       <CompoundDeploymentToolbar {...nodeProps} />
 *     </IfNotReadOnly>
 *     <DefaultHandles />
 *   </CompoundNodeContainer>
 * ```
 */
export declare function compoundDeploymentNode<A extends Any_5 = Unknown_3>(component: FC<CompoundDeploymentNodeProps<A>>): Types.NodeRenderer<'compound-deployment'>;

export declare type CompoundDeploymentNodeProps<A extends Any_5 = Unknown_3> = {
    nodeProps: Types.NodeProps<'compound-deployment'>;
    nodeModel: NodeModel.WithDeploymentElement<A>;
};

export declare function CompoundDeploymentToolbar(props: Types.NodeProps<'compound-deployment'>): JSX.Element;

export declare function CompoundDetailsButton({ data: { hovered: isHovered, }, icon, onClick, }: CompoundDetailsButtonProps): JSX.Element;

declare type CompoundDetailsButtonProps = Simplify<BaseNodeProps & {
    icon?: ReactNode;
    onClick: (e: MouseEvent_2) => void;
}>;

export declare function CompoundDetailsButtonWithHandler(props: Types.NodeProps<'compound-deployment' | 'compound-element'>): JSX.Element | null;

export declare function CompoundElementNode(props: Types.NodeProps<'compound-element'>): JSX.Element;

/**
 * Node that will be used to render the compound element from the model.
 * It is a container node, i.e. it has children.
 *
 * Custom node renderer receives these props:
 * - `nodeProps`: props from XYFlow
 * - `nodeModel`: LikeC4 {@link NodeModel.WithElement}
 *
 * @see [Default implementation](https://github.com/likec4/likec4/blob/main/packages/diagram/src/likec4diagram/custom/nodes/nodes.tsx)
 *
 * @example
 * ```tsx
 * import {
 *   compoundElementNode,
 *   CompoundNodeContainer,
 *   CompoundTitle,
 *   CompoundActions,
 *   CompoundDetailsButtonWithHandler,
 *   IfEnabled,
 *   CompoundElementToolbar,
 *   DefaultHandles,
 * } from '@likec4/diagram/custom'
 *
 * const CustomCompoundElementNode = compoundElementNode(({ nodeProps, nodeModel }) => (
 *   <CompoundNodeContainer nodeProps={props}>
 *     <CompoundTitle {...props} />
 *     <CompoundActions {...props} />
 *     <IfEnabled feature="ElementDetails">
 *       <CompoundDetailsButtonWithHandler {...props} />
 *     </IfEnabled>
 *     <IfNotReadOnly>
 *       <CompoundElementToolbar {...props} />
 *     </IfNotReadOnly>
 *     <DefaultHandles />
 *   </CompoundNodeContainer>
 * ))
 * ```
 */
export declare function compoundElementNode<A extends Any_5 = Unknown_3>(component: FC<CompoundElementNodeProps<A>>): Types.NodeRenderer<'compound-element'>;

export declare type CompoundElementNodeProps<A extends Any_5 = Unknown_3> = {
    nodeProps: Types.NodeProps<'compound-element'>;
    nodeModel: NodeModel.WithElement<A>;
};

export declare function CompoundElementToolbar(props: Types.NodeProps<'compound-element'>): JSX.Element;

export declare function CompoundNodeContainer({ nodeProps: { data: { hovered: isHovered, dimmed: isDimmed, ...data }, }, className, children, style, ...rest }: CompoundNodeContainerProps): JSX.Element;

declare type CompoundNodeContainerProps = PropsWithChildren<HTMLAttributes<HTMLDivElement> & {
    layout?: boolean | 'position' | 'size' | 'preserve-aspect';
    layoutId?: string | undefined;
    nodeProps: BaseNodeProps<BaseNode<RequiredData>>;
}>;

export declare function CompoundTitle({ data }: CompoundTitleProps): JSX.Element;

declare type CompoundTitleProps = {
    data: RequiredData_2;
};

declare type Compute<A> = {
    [K in keyof A]: A[K];
} & unknown;

declare type ConditionalRequired<T, Condition extends boolean> = Condition extends true ? Required<T> : T;

declare type Context = {
    subject: Fqn;
    currentView: DiagramView;
    initiatedFrom: {
        node: NodeId | null;
        clientRect: Rect | null;
    };
};

declare interface Context_2 {
    subject: Fqn_3;
    viewId: ViewId_3 | null;
    scope: 'global' | 'view';
    closeable: boolean;
    enableSelectSubject: boolean;
    enableChangeScope: boolean;
    xyflow: XYFLowInstance | null;
    xystore: XYStoreApi_2 | null;
    layouted: LayoutRelationshipsViewResult | null;
    navigateFromNode: string | null;
    xynodes: RelationshipsBrowserTypes.Node[];
    xyedges: RelationshipsBrowserTypes.Edge[];
}

declare type Context_3 = Readonly<{
    subject: Subject;
    viewId: ViewId_3;
    xyflow: XYFLowInstance_2 | null;
    xystore: XYStoreApi_3 | null;
    initialized: {
        xydata: boolean;
        xyflow: boolean;
    };
    xynodes: RelationshipDetailsTypes.Node[];
    xyedges: RelationshipDetailsTypes.Edge[];
    bounds: BBox_3;
}>;

declare type ContextFactory<TContext extends MachineContext, TActor extends ProvidedActor, TInput, TEvent extends EventObject = EventObject> = ({ spawn, input, self }: {
    spawn: Spawner<TActor>;
    input: TInput;
    self: ActorRef<MachineSnapshot<TContext, TEvent, Record<string, AnyActorRef | undefined>, // TODO: this should be replaced with `TChildren`
    StateValue, string, unknown, TODO, // TMeta
    TODO>, TEvent, AnyEventObject>;
}) => TContext;

export declare function createLikeC4Editor(callbacks: LikeC4EditorCallbacks): LikeC4EditorCallbacks;

export declare type CurrentViewModel = LikeC4ViewModel<UnknownLayouted, LayoutedView<UnknownLayouted>>;

declare type Data = {
    tags: readonly string[] | null | undefined;
    width: number;
};

/**
 * XYFlow requires handles to be defined on nodes.
 */
export declare function DefaultHandles({ direction }: {
    direction?: AutoLayoutDirection | undefined;
}): JSX.Element;

declare type Delay<TDelay extends string> = TDelay | number;

declare type DelayConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = number | DelayExpr<TContext, TExpressionEvent, TParams, TEvent>;

declare interface DelayedTransitionDefinition<TContext extends MachineContext, TEvent extends EventObject> extends TransitionDefinition<TContext, TEvent> {
    delay: number | string | DelayExpr<TContext, TEvent, undefined, TEvent>;
}

declare type DelayedTransitions<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = {
    [K in Delay<TDelay>]?: string | SingleOrArray<TransitionConfig<TContext, TEvent, TEvent, TActor, TAction, TGuard, TDelay, TODO, // TEmitted
    TODO>>;
};

declare type DelayExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => number;

declare type DelayFunctionMap<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject> = Record<string, DelayConfig<TContext, TEvent, TAction['params'], TEvent>>;

declare type DependenciesComparator<Deps extends DependencyList = DependencyList> = (a: Deps, b: Deps) => boolean;

/**
 * Center-Bottom action bar, includes zoom-in and browse relationships actions, if the features are enabled.
 * Intended to be used with deployment elements.
 *
 * Use generic {@link ElementActionButtons} for custom action buttons.
 *
 * @param extraButtons - Add extra action buttons
 *
 * @example
 * ```tsx
 * <DeploymentElementActions
 *   extraButtons={[
 *     {
 *       key: 'extra',
 *       icon: <IconZoomScan />,
 *       onClick: (e) => {
 *         e.stopPropagation()
 *         console.log('extra action clicked')
 *       },
 *       },
 *     },
 *   ]}
 * />
 * ```
 */
export declare const DeploymentElementActions: ({ extraButtons, ...props }: DeploymentElementActionsProps) => JSX.Element;

declare type DeploymentElementActionsProps = SimplifyDeep<{
    selected?: boolean;
    data: Pick<Types.DeploymentElementNodeData, 'id' | 'modelFqn' | 'navigateTo'> & BaseNodeData;
}> & WithExtraButtons;

export declare function DeploymentElementToolbar(props: Types.NodeProps<'deployment'>): JSX.Element;

declare type DeploymentFqn_2<A> = t.aux.DeploymentFqn<A>;

export declare function DeploymentNode(props: Types.NodeProps<'deployment'>): JSX.Element;

/**
 * Node that will be used to render the element from deployment model.
 * It is a leaf node, i.e. it does not have children.
 * Can be {@link DeploymentNodeModel} or {@link DeployedInstanceModel}.
 *
 * Custom node renderer receives these props:
 * - `nodeProps`: props from XYFlow
 * - `nodeModel`: {@link NodeModel.WithDeploymentElement}
 *
 * @see [Default implementation](https://github.com/likec4/likec4/blob/main/packages/diagram/src/likec4diagram/custom/nodes/nodes.tsx)
 *
 * @example
 * ```tsx
 * import {
 *   deploymentNode,
 *   ElementNodeContainer,
 *   ElementShape,
 *   ElementData,
 *   DeploymentElementActions,
 *   ElementDetailsButtonWithHandler,
 *   IfNotReadOnly,
 *   DeploymentElementToolbar,
 *   DefaultHandles,
 * } from '@likec4/diagram/custom'
 *
 * const CustomDeploymentNode = deploymentNode(({ nodeProps, nodeModel }) => (
 *   <ElementNodeContainer nodeProps={nodeProps}>
 *     <ElementShape {...nodeProps} />
 *     <ElementData {...nodeProps} />
 *     <DeploymentElementActions
 *       {...nodeProps}
 *       extraButtons={[
 *         {
 *           key: 'plus',
 *           icon: <IconPlus />,
 *           onClick: () => console.log('extra'),
 *         },
 *       ]}
 *     />
 *     <ElementDetailsButtonWithHandler {...nodeProps} />
 *     <IfNotReadOnly>
 *       <DeploymentElementToolbar {...nodeProps} />
 *     </IfNotReadOnly>
 *     <DefaultHandles />
 *   </ElementNodeContainer>
 * ))
 * ```
 */
export declare function deploymentNode<A extends Any_5 = Unknown_3>(component: FC<DeploymentNodeProps<A>>): Types.NodeRenderer<'deployment'>;

export declare type DeploymentNodeProps<A extends Any_5 = Unknown_3> = {
    nodeProps: Types.NodeProps<'deployment'>;
    nodeModel: NodeModel.WithDeploymentElement<A>;
};

export declare interface DiagramActorRef extends DiagramMachineRef {
    system: System;
}

export declare type DiagramActorSnapshot = MachineSnapshot<DiagramContext, DiagramEvents, {
    overlays: OverlaysActorRef | undefined;
    search: SearchActorRef | undefined;
    editor: EditorActorRef | undefined;
}, any, any, any, {}, {}>;

export declare interface DiagramApi<A extends Any_3 = Unknown_2> {
    /**
     * React ref to the diagram actor
     */
    readonly ref: RefObject<DiagramActorRef>;
    /**
     * @warning Do not use in render phase
     */
    readonly actor: DiagramActorRef;
    /**
     * @warning Do not use in render phase
     */
    readonly currentView: t.DiagramView<A>;
    /**
     * Editor actor reference
     * @warning Do not use in render phase
     */
    editorActor(): EditorActorRef;
    /**
     * Overlays actor reference
     * @warning Do not use in render phase
     */
    overlays(): OverlaysActorRef;
    /**
     * Search actor reference
     * @warning Do not use in render phase
     */
    searchActor(): SearchActorRef;
    /**
     * Send event to diagram actor
     */
    send(event: DiagramEvents): void;
    /**
     * Navigate to view
     * @param viewId - Target view ID
     * @param fromNode - Node from which navigation was triggered
     * @param focusOnElement - Element FQN to focus after navigation (from search)
     */
    navigateTo(viewId: ViewId_4<A>, fromNode?: NodeId_2, focusOnElement?: Fqn_4<A>): void;
    /**
     * Navigate back or forward in history
     */
    navigate(direction: 'back' | 'forward'): void;
    /**
     * Fit diagram to view
     */
    fitDiagram(duration?: number): void;
    /**
     * Open relationships browser
     */
    openRelationshipsBrowser(fqn: Fqn_4<A>): void;
    /**
     * If running in editor, trigger opening source file
     */
    openSource(params: OpenSourceParams<A>): void;
    /**
     * Open element details card
     */
    openElementDetails(fqn: Fqn_4<A>, fromNode?: NodeId_2): void;
    openRelationshipDetails(...params: [edgeId: EdgeId_3] | [source: Fqn_4<A>, target: Fqn_4<A>]): void;
    updateNodeData(nodeId: NodeId_2, data: PartialDeep<Types.NodeData>): void;
    updateEdgeData(edgeId: EdgeId_3, data: PartialDeep<Types.EdgeData>): void;
    highlightNode(nodeId: NodeId_2): void;
    highlightEdge(edgeId: EdgeId_3): void;
    unhighlightAll(): void;
    /**
     * Center viewport on a given node
     */
    centerViewportOnNode(target: NodeId_2): void;
    /**
     * Center viewport on a given edge (centering on edge means including both source and target nodes in view)
     */
    centerViewportOnEdge(target: EdgeId_3): void;
    /**
     * Start editing, either node or edge
     */
    startEditing(subject: 'node' | 'edge'): void;
    /**
     * Stop editing
     * @param wasChanged - whether there were changes made during editing
     * @default false
     */
    stopEditing(wasChanged?: boolean): void;
    /**
     * Undo last editing operation
     * @returns true if there was something to undo
     */
    undoEditing(): boolean;
    /**
     * Align nodes
     */
    align(mode: AlignmentMode): void;
    /**
     * Reset edge control points
     */
    resetEdgeControlPoints(): void;
    /**
     * Focus node
     */
    focusNode(nodeId: NodeId_2): void;
    /**
     * Focus on element by FQN (finds the node and focuses on it).
     * Used by search to highlight an element on the current view.
     */
    focusOnElement(elementFqn: Fqn_4<A>): void;
    /**
     * @warning Do not use in render phase
     */
    getContext(): DiagramContext;
    /**
     * @warning Do not use in render phase
     */
    findDiagramNode(xynodeId: string): t.DiagramNode<A> | null;
    /**
     * @warning Do not use in render phase
     */
    findEdge(xyedgeId: string): Types.Edge | null;
    /**
     * @warning Do not use in render phase
     */
    findDiagramEdge(xyedgeId: string): t.DiagramEdge<A> | null;
    startWalkthrough(): void;
    walkthroughStep(direction?: 'next' | 'previous'): void;
    stopWalkthrough(): void;
    toggleFeature(feature: FeatureName, forceValue?: boolean): void;
    highlightNotation(notation: NodeNotation, kind?: string): void;
    unhighlightNotation(): void;
    openSearch(searchValue?: string): void;
    triggerChange(viewChange: ViewChange): void;
    /**
     * Switch dynamic view display variant
     */
    switchDynamicViewVariant(variant: DynamicViewDisplayVariant): void;
}

export declare interface DiagramContext extends Input {
    xynodes: Types.Node[];
    xyedges: Types.Edge[];
    features: EnabledFeatures;
    toggledFeatures: ToggledFeatures;
    initialized: {
        xydata: boolean;
        xyflow: boolean;
    };
    viewport: Viewport;
    viewportChangedManually: boolean;
    /**
     * Viewport before entering focus mode, walkthrough or printing
     */
    viewportBefore: null | {
        wasChangedManually: boolean;
        value: Viewport;
    };
    viewportOnManualLayout: null | Viewport;
    viewportOnAutoLayout: null | Viewport;
    lastOnNavigate: null | {
        fromView: ViewId;
        toView: ViewId;
        fromNode: NodeId | null;
        focusOnElement?: Fqn | null;
    };
    navigationHistory: NavigationHistory;
    lastClickedNode: null | {
        id: NodeId;
        clicks: number;
        timestamp: number;
    };
    focusedNode: NodeId | null;
    autoUnfocusTimer: boolean;
    activeElementDetails: null | {
        fqn: Fqn;
        fromNode: NodeId | null;
        nodeRect?: Rect | null;
        nodeRectScreen?: Rect | null;
    };
    xyflow: XYFlowInstance | null;
    dynamicViewVariant: DynamicViewDisplayVariant;
    activeWalkthrough: null | {
        stepId: StepEdgeId;
        parallelPrefix: string | null;
    };
}

export declare type DiagramEmittedEvents = {
    type: 'initialized';
    instance: XYFlowInstance;
} | {
    type: 'navigateTo';
    viewId: ViewId;
} | {
    type: 'openSource';
    params: OpenSourceParams;
} | {
    type: 'paneClick';
} | {
    type: 'nodeClick';
    node: DiagramNode;
    xynode: Types.Node;
} | {
    type: 'edgeClick';
    edge: DiagramEdge;
    xyedge: Types.Edge;
} | {
    type: 'edgeMouseEnter';
    edge: Types.Edge;
    event: MouseEvent_2;
} | {
    type: 'edgeMouseLeave';
    edge: Types.Edge;
    event: MouseEvent_2;
} | {
    type: 'walkthroughStarted';
    edge: Types.Edge;
} | {
    type: 'walkthroughStep';
    edge: Types.Edge;
} | {
    type: 'walkthroughStopped';
} | {
    type: 'onLayoutTypeChange';
    layoutType: LayoutType;
};

declare type DiagramEventHandlersContext = RequiredOrNull<LikeC4DiagramEventHandlers> & {
    handlersRef: DiagramEventHandlersRef;
};

declare type DiagramEventHandlersRef = RefObject<Required<LikeC4DiagramEventHandlers>>;

export declare type DiagramEvents = HotKeyEvent | MediaPrintEvent | {
    type: 'xyflow.init';
    instance: XYFlowInstance;
} | {
    type: 'xyflow.applyChanges';
    edges?: EdgeChange<Types.Edge>[];
    nodes?: NodeChange<Types.Node>[];
} | {
    type: 'xyflow.viewportMoved';
    viewport: Viewport;
    manually: boolean;
} | {
    type: 'xyflow.nodeClick';
    node: Types.Node;
} | {
    type: 'xyflow.edgeClick';
    edge: Types.Edge;
} | {
    type: 'xyflow.edgeDoubleClick';
    edge: Types.Edge;
} | {
    type: 'xyflow.paneClick';
} | {
    type: 'xyflow.paneDblClick';
} | {
    type: 'xyflow.resized';
} | {
    type: 'xyflow.nodeMouseEnter';
    node: Types.Node;
} | {
    type: 'xyflow.nodeMouseLeave';
    node: Types.Node;
} | {
    type: 'xyflow.edgeMouseEnter';
    edge: Types.Edge;
    event: MouseEvent_2;
} | {
    type: 'xyflow.edgeMouseLeave';
    edge: Types.Edge;
    event: MouseEvent_2;
} | {
    type: 'xyflow.fitDiagram';
    duration?: number;
    bounds?: BBox_2;
} | {
    type: 'xyflow.setViewport';
    duration?: number;
    viewport: Viewport;
} | {
    type: 'xyflow.centerViewport';
    nodeId: NodeId;
    duration?: number;
} | {
    type: 'xyflow.centerViewport';
    edgeId: EdgeId;
    duration?: number;
} | {
    type: 'update.nodeData';
    nodeId: NodeId;
    data: PartialDeep<Types.NodeData>;
} | {
    type: 'update.edgeData';
    edgeId: EdgeId;
    data: PartialDeep<Types.EdgeData>;
} | {
    type: 'update.view';
    view: DiagramView;
    source?: 'editor' | 'external';
} | {
    type: 'update.view';
    view: DiagramView;
    source?: 'editor' | 'external';
    xynodes: Types.Node[];
    xyedges: Types.Edge[];
} | {
    type: 'update.view-bounds';
    bounds: BBox_2;
} | {
    type: 'update.inputs';
    inputs: Partial<Omit<Input, 'view' | 'xystore' | 'dynamicViewVariant' | 'features'>>;
} | {
    type: 'update.features';
    features: EnabledFeatures;
} | ({
    type: 'open.source';
} & OpenSourceParams) | {
    type: 'open.elementDetails';
    fqn: Fqn;
    fromNode?: NodeId | undefined;
} | {
    type: 'open.relationshipDetails';
    params: {
        edgeId: EdgeId;
    } | {
        source: Fqn;
        target: Fqn;
    };
} | {
    type: 'open.relationshipsBrowser';
    fqn: Fqn;
} | {
    type: 'open.search';
    search?: string;
} | {
    type: 'navigate.to';
    viewId: ViewId;
    fromNode?: NodeId | undefined;
    focusOnElement?: Fqn | undefined;
} | {
    type: 'navigate.back';
} | {
    type: 'navigate.forward';
} | {
    type: 'layout.align';
    mode: AlignmentMode;
} | {
    type: 'layout.resetEdgeControlPoints';
} | {
    type: 'layout.resetManualLayout';
} | {
    type: 'focus.node';
    nodeId: NodeId;
    autoUnfocus?: boolean;
} | {
    type: 'focus.autoUnfocus';
} | {
    type: 'switch.dynamicViewVariant';
    variant: DynamicViewDisplayVariant;
} | {
    type: 'walkthrough.start';
    stepId?: StepEdgeId;
} | {
    type: 'walkthrough.step';
    direction: 'next' | 'previous';
} | {
    type: 'walkthrough.end';
} | {
    type: 'highlight.node';
    nodeId: NodeId;
} | {
    type: 'highlight.edge';
    edgeId: EdgeId;
} | {
    type: 'unhighlight.all';
} | {
    type: 'notations.highlight';
    notation: NodeNotation;
    kind?: string;
} | {
    type: 'notations.unhighlight';
} | {
    type: 'tag.highlight';
    tag: string;
} | {
    type: 'tag.unhighlight';
} | {
    type: 'toggle.feature';
    feature: TogglableFeature;
    forceValue?: boolean;
} | {
    type: 'trigger.change';
    change: ViewChange;
} | {
    type: 'emit.onLayoutTypeChange';
    layoutType: LayoutType;
} | {
    type: 'destroy';
};

declare interface DiagramMachineRef extends ActorRef<DiagramActorSnapshot, DiagramEvents, DiagramEmittedEvents> {
}

export declare type DiagramNodeWithNavigate<A extends Any_2 = Unknown> = SetRequired<DiagramNode<A>, 'navigateTo'>;

declare type DistributeActors<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject, TMeta extends MetaObject, TSpecificActor extends ProvidedActor> = TSpecificActor extends {
    src: infer TSrc;
} ? Compute<{
    systemId?: string;
    /** The source of the machine to be invoked, or the machine itself. */
    src: TSrc;
    /**
     * The unique identifier for the invoked machine. If not specified,
     * this will be the machine's own `id`, or the URL (from `src`).
     */
    id?: TSpecificActor['id'];
    input?: Mapper<TContext, TEvent, InputFrom<TSpecificActor['logic']>, TEvent> | InputFrom<TSpecificActor['logic']>;
    /**
     * The transition to take upon the invoked child machine reaching
     * its final top-level state.
     */
    onDone?: string | SingleOrArray<TransitionConfigOrTarget<TContext, DoneActorEvent<OutputFrom<TSpecificActor['logic']>>, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
    /**
     * The transition to take upon the invoked child machine sending an
     * error event.
     */
    onError?: string | SingleOrArray<TransitionConfigOrTarget<TContext, ErrorActorEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
    onSnapshot?: string | SingleOrArray<TransitionConfigOrTarget<TContext, SnapshotEvent<SnapshotFrom<TSpecificActor['logic']>>, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
} & {
    [K in RequiredActorOptions<TSpecificActor>]: unknown;
}> | {
    id?: never;
    systemId?: string;
    src: AnyActorLogic;
    input?: Mapper<TContext, TEvent, NonReducibleUnknown, TEvent> | NonReducibleUnknown;
    onDone?: string | SingleOrArray<TransitionConfigOrTarget<TContext, DoneActorEvent<unknown>, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
    onError?: string | SingleOrArray<TransitionConfigOrTarget<TContext, ErrorActorEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
    onSnapshot?: string | SingleOrArray<TransitionConfigOrTarget<TContext, SnapshotEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
} : never;

declare interface DoneActorEvent<TOutput = unknown, TId extends string = string> extends EventObject {
    type: `xstate.done.actor.${TId}`;
    output: TOutput;
    actorId: TId;
}

declare interface DoneMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> {
    status: 'done';
    output: TOutput;
    error: undefined;
}

declare interface DoneStateEvent<TOutput = unknown> extends EventObject {
    type: `xstate.done.state.${string}`;
    output: TOutput;
}

declare type DoNotInfer<T> = [T][T extends any ? 0 : any];

declare type EdgeId_3 = t.aux.EdgeId;

declare interface EditorActorContext {
    viewId: t.ViewId;
    history: LinkedSnapshot | null;
    editing: null | {
        /**
         * The subject of the edit
         */
        subject: 'node' | 'edge';
        /**
         * The state before editing started
         */
        before: Snapshot_2;
    };
    syncQueue: Array<SyncOp>;
    processing: Exclude<SyncOp, 'sync-snapshot'> | null;
}

declare type EditorActorEmitedEvent = {
    type: 'idle';
};

declare type EditorActorEvent = {
    type: 'change.view';
    change: t.ViewChange;
} | {
    type: 'change.semantic-layout';
} | {
    type: 'change.latest-to-manual';
} | {
    type: 'change.sync-snapshot';
} | {
    type: 'view.synched';
} | {
    type: 'cancel';
} | {
    type: 'edit.move.start';
    subject: 'node' | 'edge';
} | {
    type: 'edit.move.end';
} | {
    type: 'edit.move.cancel';
} | HotKeyEvent_2;

declare interface EditorActorInput {
    viewId: t.ViewId;
}

declare interface EditorActorLogic extends StateMachine<EditorActorContext, EditorActorEvent, any, any, any, any, any, {
    editor: 'idle' | 'moving';
    syncQueue: 'idle' | 'pending' | 'suspended' | 'process';
}, EditorActorStateTag, EditorActorInput, any, EditorActorEmitedEvent, any, any> {
}

declare interface EditorActorRef extends ActorRef<EditorActorSnapshot, EditorActorEvent, EditorActorEmitedEvent> {
}

declare type EditorActorSnapshot = SnapshotFrom<EditorActorLogic>;

declare type EditorActorStateTag = 'pending' | 'busy' | 'ai-semantic-layout';

declare type EffectCallback_2 = (...args: any[]) => any;

declare type EffectHook<Callback extends EffectCallback_2 = EffectCallback_2, Deps extends DependencyList | undefined = DependencyList | undefined, RestArgs extends any[] = any[]> = ((...args: [Callback, Deps, ...RestArgs]) => void) | ((...args: [Callback, Deps]) => void);

/**
 * Center-Bottom bar with action buttons. Intended to be used inside "leaf" nodes.
 *
 * @param selected - Whether the node is selected
 * @param data - Node data
 * @param buttons - Action buttons
 *
 * @example
 * ```tsx
 * <ElementActionButtons
 *   {...nodeProps}
 *   Buttons={[
 *     {
 *       key: 'action1',
 *       icon: <IconZoomScan />,
 *       onClick: (e) => {
 *         e.stopPropagation()
 *         console.log('action1 clicked')
 *       },
 *     },
 *     //...
 *   ]}
 * />
 * ```
 */
export declare function ElementActionButtons({ selected, data: { hovered: isHovered, }, buttons, }: ElementActionButtonsProps): JSX.Element | null;

export declare namespace ElementActionButtons {
    export type Item = {
        key?: string;
        icon?: ReactNode;
        onClick: (e: MouseEvent_2) => void;
    };
}

declare type ElementActionButtonsProps = {
    selected?: boolean;
    data: {
        hovered?: boolean;
    };
    buttons: ElementActionButtons.Item[];
};

/**
 * Center-Bottom action bar, includes zoom-in and browse relationships actions, if the features are enabled.
 * Intended to be used with model elements.
 *
 * Use generic {@link ElementActionButtons} for custom action buttons.
 *
 * @param extraButtons - Add extra action buttons
 *
 * @example
 * ```tsx
 * <ElementActions
 *   extraButtons={[
 *     {
 *       key: 'extra',
 *       icon: <IconZoomScan />,
 *       onClick: (e) => {
 *         e.stopPropagation()
 *         console.log('extra action clicked')
 *       },
 *       },
 *     },
 *   ]}
 * />
 * ```
 */
export declare function ElementActions({ extraButtons, ...props }: ElementActionsProps): JSX.Element;

declare type ElementActionsProps = SimplifyDeep<{
    selected?: boolean;
    data: Pick<Types.ElementNodeData, 'id' | 'modelFqn' | 'navigateTo'> & BaseNodeData;
}> & WithExtraButtons;

/**
 * Renders an element title, technology, description, and icon.
 *
 * @example
 * ```tsx
 * <ElementData {...nodeProps} />
 * ```
 * or
 * ```tsx
 * <ElementData.Root {...nodeProps} >
 *   <ElementData.Icon {...nodeProps} />
 *   <ElementData.Content>
 *     <ElementData.Title {...nodeProps} />
 *     <ElementData.Technology {...nodeProps} />
 *     <ElementData.Description {...nodeProps} />
 *   </ElementData.Content>
 * </ElementData.Root>
 * ```
 */
export declare function ElementData({ data }: ElementDataProps): JSX.Element;

export declare namespace ElementData {
    var Root: ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & ElementDataProps & RefAttributes<HTMLDivElement>>;
    var Icon: ({ data, ...props }: IconProps) => JSX.Element;
    var Content: ForwardRefExoticComponent<Omit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & RefAttributes<HTMLDivElement>>;
    var Title: ForwardRefExoticComponent<SlotProps & RefAttributes<HTMLDivElement>>;
    var Technology: ForwardRefExoticComponent<((Without<SlotProps, {
    children?: ReactNode | undefined;
    }> & {
    children?: ReactNode | undefined;
    }) | (Without<    {
    children?: ReactNode | undefined;
    }, SlotProps> & SlotProps)) & RefAttributes<HTMLDivElement>>;
    var Description: ForwardRefExoticComponent<SlotProps & RefAttributes<HTMLDivElement>>;
}

declare type ElementDataProps = {
    data: RequiredData_3;
};

declare interface ElementDetailsActorRef extends ActorRef<ElementDetailsSnapshot, Events> {
}

export declare function ElementDetailsButton({ selected, data: { hovered: isHovered, }, icon, onClick, }: ElementDetailsButtonProps): JSX.Element;

declare type ElementDetailsButtonProps = {
    selected?: boolean;
    data: BaseNodeData;
    icon?: ReactNode;
    onClick: (e: MouseEvent_2) => void;
};

export declare function ElementDetailsButtonWithHandler(props: {
    id: string;
    selected?: boolean;
    data: BaseNodeData & {
        modelFqn?: Fqn_3 | null | undefined;
    };
}): JSX.Element | null;

declare interface ElementDetailsLogic extends StateMachine<Context, Events, {
    [key: `${string}-relationships`]: RelationshipsBrowserActorRef | undefined;
}, any, any, any, any, any, never, Input_2, any, any, any, any> {
}

declare type ElementDetailsSnapshot = SnapshotFrom<ElementDetailsLogic>;

export declare type ElementIconRenderer = (props: ElementIconRendererProps) => ReactNode;

export declare type ElementIconRendererProps = {
    node: {
        id: string;
        title: string;
        icon?: string | null | undefined;
    };
    className?: string;
};

/**
 * Renders an element node.
 */
export declare function ElementNode(props: Types.NodeProps<'element'>): JSX.Element;

/**
 * Node that will be used to render the element from the model.
 * It is a leaf node, i.e. it does not have children.
 *
 * Custom node renderer receives these props:
 * - `nodeProps`: props from XYFlow
 * - `nodeModel`: LikeC4 {@link NodeModel.WithElement}
 *
 * @see [Default implementation](https://github.com/likec4/likec4/blob/main/packages/diagram/src/likec4diagram/custom/nodes/nodes.tsx)
 *
 * @example
 * ```tsx
 * import {
 *   elementNode,
 *   ElementNodeContainer,
 *   ElementShape,
 *   ElementData,
 *   ElementActions,
 *   ElementDetailsButtonWithHandler,
 *   IfEnabled,
 *   IfNotReadOnly,
 *   ElementToolbar,
 *   DefaultHandles,
 *   ElementTags
 * } from '@likec4/diagram/custom'
 *
 * const CustomElementNode = elementNode(({ nodeProps, nodeModel }) => (
 *   <ElementNodeContainer nodeProps={nodeProps}>
 *     <ElementShape {...nodeProps} />
 *     <ElementData {...nodeProps} />
 *     <IfEnabled feature="ElementTags">
 *       <ElementTags {...nodeProps} />
 *     </IfEnabled>
 *     <ElementActions
 *       {...nodeProps}
 *       extraButtons={[
 *         {
 *           key: 'plus',
 *           icon: <IconPlus />,
 *           onClick: () => console.log('extra'),
 *         },
 *       ]}
 *     />
 *     <ElementDetailsButtonWithHandler {...nodeProps} />
 *     {nodeModel.element.getMetadata('your-attr') === 'value' && <YourComponent />}
 *     <IfNotReadOnly>
 *       <ElementToolbar {...nodeProps} />
 *     </IfNotReadOnly>
 *     <DefaultHandles />
 *   </ElementNodeContainer>
 * ))
 * ```
 */
export declare function elementNode<A extends Any_5 = Unknown_3>(component: FC<ElementNodeProps<A>>): Types.NodeRenderer<'element'>;

/**
 * Top-level primitive to compose leaf nodes renderers.
 * This container provides the state via data-* attributes
 */
export declare const ElementNodeContainer: ForwardRefExoticComponent<{
    [key: `data-${string}`]: string | undefined;
    nodeProps: BaseNodePropsWithData<RequiredData_4>;
    className?: string | undefined;
    style?: MotionStyle | undefined;
} & MotionNodeLayoutOptions & {
    children?: ReactNode | undefined;
} & RefAttributes<HTMLDivElement>>;

export declare type ElementNodeProps<A extends Any_5 = Unknown_3> = {
    nodeProps: Types.NodeProps<'element'>;
    nodeModel: NodeModel.WithElement<A>;
};

export declare function ElementShape({ data, width, height, showSelectionOutline }: ElementShapeProps): JSX.Element;

declare type ElementShapeProps = {
    data: RequiredData_5;
    width?: number | undefined;
    height?: number | undefined;
    /**
     * @default true
     */
    showSelectionOutline?: boolean | undefined;
};

export declare const ElementTag: ForwardRefExoticComponent<{
    tag: string;
    cursor?: "pointer" | "default";
} & Omit<Omit< DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "children"> & RefAttributes<HTMLDivElement>>;

export declare const ElementTags: MemoExoticComponent<({ id, data: { tags, width, hovered }, onTagClick, onTagMouseEnter, onTagMouseLeave }: ElementTagsProps) => JSX.Element | null>;

declare type ElementTagsProps = BaseNodePropsWithData<Data> & {
    onTagClick?: (tag: `#${string}`) => void;
    onTagMouseEnter?: (tag: `#${string}`) => void;
    onTagMouseLeave?: (tag: `#${string}`) => void;
};

export declare function ElementToolbar(props: Types.NodeProps<'element' | 'seq-actor'> & {
    data: {
        modelFqn: Fqn;
    };
}): JSX.Element;

declare type EmittedFrom<TLogic extends AnyActorLogic> = TLogic extends ActorLogic<infer _TSnapshot, infer _TEvent, infer _TInput, infer _TSystem, infer TEmitted> ? TEmitted : never;

export declare type EnabledFeatures = {
    [P in `enable${FeatureName}`]: boolean;
};

declare type Equals<A1, A2> = (<A>() => A extends A2 ? true : false) extends <A>() => A extends A1 ? true : false ? true : false;

declare interface ErrorActorEvent<TErrorData = unknown, TId extends string = string> extends EventObject {
    type: `xstate.error.actor.${TId}`;
    error: TErrorData;
    actorId: TId;
}

declare interface ErrorMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> {
    status: 'error';
    output: undefined;
    error: unknown;
}

declare type EventDescriptor<TEvent extends EventObject> = TEvent['type'] | PartialEventDescriptor<TEvent['type']> | '*';

declare type EventDescriptorMatches<TEventType extends string, TNormalizedDescriptor> = TEventType extends TNormalizedDescriptor ? true : false;

declare type EventFromLogic<TLogic extends AnyActorLogic> = TLogic extends ActorLogic<infer _TSnapshot, infer TEvent, infer _TInput, infer _TEmitted, infer _TSystem> ? TEvent : never;

/** The full definition of an event, with a string `type`. */
declare type EventObject = {
    /** The type of event that is sent. */
    type: string;
};

declare type Events = {
    type: 'change.subject';
    subject: Fqn;
} | {
    type: 'close';
};

declare type Events_2 = {
    type: 'xyflow.init';
    instance: XYFLowInstance;
    store: XYStoreApi_2;
} | {
    type: 'xyflow.nodeClick';
    node: RelationshipsBrowserTypes.Node;
} | {
    type: 'xyflow.edgeClick';
    edge: RelationshipsBrowserTypes.Edge;
} | {
    type: 'xyflow.applyNodeChanges';
    changes: NodeChange_2<RelationshipsBrowserTypes.Node>[];
} | {
    type: 'xyflow.applyEdgeChanges';
    changes: EdgeChange_2<RelationshipsBrowserTypes.Edge>[];
} | {
    type: 'xyflow.paneClick';
} | {
    type: 'xyflow.paneDblClick';
} | {
    type: 'xyflow.resized';
} | {
    type: 'xyflow.edgeMouseEnter';
    edge: RelationshipsBrowserTypes.Edge;
} | {
    type: 'xyflow.edgeMouseLeave';
    edge: RelationshipsBrowserTypes.Edge;
} | {
    type: 'xyflow.selectionChange';
    nodes: RelationshipsBrowserTypes.Node[];
    edges: RelationshipsBrowserTypes.Edge[];
} | {
    type: 'dim.nonhovered.edges';
} | {
    type: 'undim.edges';
} | {
    type: 'xyflow.updateNodeInternals';
} | {
    type: 'xyflow.unmount';
} | {
    type: 'fitDiagram';
    duration?: number;
    bounds?: BBox_3;
} | {
    type: 'navigate.to';
    subject: Fqn_3;
    fromNode?: string | undefined;
    viewId?: ViewId_3 | undefined;
} | {
    type: 'update.xydata';
    xynodes: RelationshipsBrowserTypes.Node[];
    xyedges: RelationshipsBrowserTypes.Edge[];
} | {
    type: 'change.scope';
    scope: 'global' | 'view';
} | {
    type: 'update.view';
    layouted: LayoutRelationshipsViewResult;
} | {
    type: 'close';
};

declare type Events_3 = {
    type: 'xyflow.init';
    instance: XYFLowInstance_2;
    store: XYStoreApi_3;
} | {
    type: 'xyflow.nodeClick';
    node: RelationshipDetailsTypes.Node;
} | {
    type: 'xyflow.edgeClick';
    edge: RelationshipDetailsTypes.Edge;
} | {
    type: 'xyflow.edgeMouseEnter';
    edge: RelationshipDetailsTypes.Edge;
} | {
    type: 'xyflow.edgeMouseLeave';
    edge: RelationshipDetailsTypes.Edge;
} | {
    type: 'dim.nonhovered.edges';
} | {
    type: 'undim.edges';
} | {
    type: 'xyflow.selectionChange';
    nodes: RelationshipDetailsTypes.Node[];
    edges: RelationshipDetailsTypes.Edge[];
} | {
    type: 'xyflow.applyNodeChanges';
    changes: NodeChange_2<RelationshipDetailsTypes.Node>[];
} | {
    type: 'xyflow.applyEdgeChanges';
    changes: EdgeChange_2<RelationshipDetailsTypes.Edge>[];
} | {
    type: 'xyflow.paneClick';
} | {
    type: 'xyflow.paneDblClick';
} | {
    type: 'xyflow.resized';
} | {
    type: 'xyflow.updateNodeInternals';
} | {
    type: 'update.layoutData';
    data: LayoutResult;
} | {
    type: 'fitDiagram';
    duration?: number;
    bounds?: BBox_3;
} | {
    type: 'navigate.to';
    params: {
        edgeId: EdgeId_2;
        viewId?: ViewId_3;
    } | {
        source: Fqn_3;
        target: Fqn_3;
        viewId?: ViewId_3;
    };
} | {
    type: 'close';
};

declare interface ExecutableActionObject {
    type: string;
    info: ActionArgs<MachineContext, EventObject, EventObject>;
    params: NonReducibleUnknown;
    exec: ((info: ActionArgs<any, any, any>, params: unknown) => void) | undefined;
}

declare type ExtractEvent<TEvent extends EventObject, TDescriptor extends EventDescriptor<TEvent>> = string extends TEvent['type'] ? TEvent : NormalizeDescriptor<TDescriptor> extends infer TNormalizedDescriptor ? TEvent extends any ? true extends EventDescriptorMatches<TEvent['type'], TNormalizedDescriptor> ? TEvent : never : never : never;

export declare type FeatureName = typeof FeatureNames[number];

declare const FeatureNames: readonly ["Controls", "Editor", "AISemanticLayout", "ReadOnly", "FocusMode", "NavigateTo", "ElementDetails", "RelationshipDetails", "RelationshipBrowser", "Search", "NavigationButtons", "Notations", "DynamicViewWalkthrough", "FitView", "CompareWithLatest", "Notes", "Vscode", "ElementTags"];

declare type Fqn_2<A> = t.aux.Fqn<A>;

declare type Fqn_4<A> = t.aux.Fqn<A>;

export declare const FramerMotionConfig: ({ reducedMotion, children, }: PropsWithChildren<{
    /**
     * If true, will respect the device prefersReducedMotion setting by switching
     * transform animations off.
     */
    reducedMotion?: "always" | "never" | "user" | undefined;
}>) => JSX.Element;

declare type GetConcreteByKey<T, TKey extends keyof T, TValue extends T[TKey]> = T & Record<TKey, TValue>;

declare type GetParameterizedParams<T extends ParameterizedObject | undefined> = T extends any ? ('params' extends keyof T ? T['params'] : undefined) : never;

declare type GridAlignmentMode = 'Column' | 'Row';

declare type Guard<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject> = NoRequiredParams<TGuard> | WithDynamicParams<TContext, TExpressionEvent, TGuard> | GuardPredicate<TContext, TExpressionEvent, TParams, TGuard>;

declare interface GuardArgs<TContext extends MachineContext, TExpressionEvent extends EventObject> {
    context: TContext;
    event: TExpressionEvent;
}

declare type GuardMap<TContext extends MachineContext, TEvent extends EventObject, TGuard extends ParameterizedObject> = {
    [K in TGuard['type']]?: GuardPredicate<TContext, TEvent, GetParameterizedParams<TGuard extends {
        type: K;
    } ? TGuard : never>, TGuard>;
};

declare type GuardPredicate<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject> = {
    (args: GuardArgs<TContext, TExpressionEvent>, params: TParams): boolean;
    _out_TGuard?: TGuard;
};

declare type HistoryValue<TContext extends MachineContext, TEvent extends EventObject> = Record<string, Array<StateNode<TContext, TEvent>>>;

declare type HotKeyEvent = {
    type: 'key.esc' | `key.arrow.${'left' | 'right' | 'up' | 'down'}`;
};

declare type HotKeyEvent_2 = {
    type: 'undo';
};

declare type IconProps = {
    data: {
        id: string;
        title: string;
        icon?: string | null | undefined;
    };
    className?: string;
    style?: CSSProperties;
};

/**
 * Provider for custom element icon renderers
 *
 * @example
 * ```tsx
 * const MyIconRenderer: ElementIconRenderer = ({ node }) => {
 *   return <div>{node.title}</div>
 * }
 *
 * <IconRendererProvider value={MyIconRenderer}>
 *   <LikeC4Diagram />
 * </IconRendererProvider>
 * ```
 */
export declare function IconRendererProvider({ value, children, }: PropsWithChildren<{
    value: ElementIconRenderer | null;
}>): JSX.Element;

/**
 * Renders children only if the specified feature is enabled
 * @param feature Feature name
 * @param and Additional AND condition
 * @example
 * <IfEnabled feature="ReadOnly" and={isSomething}>
 *   ...
 * </IfEnabled>
 */
export declare function IfEnabled({ feature, children, and, }: PropsWithChildren<{
    feature: FeatureName;
    and?: boolean;
}>): JSX.Element | null;

export declare function IfNotEnabled({ feature, children }: PropsWithChildren<{
    feature: FeatureName;
}>): JSX.Element | null;

export declare function IfNotReadOnly({ children }: PropsWithChildren): JSX.Element | null;

export declare function IfReadOnly({ children }: PropsWithChildren): JSX.Element | null;

declare type InitialContext<TContext extends MachineContext, TActor extends ProvidedActor, TInput, TEvent extends EventObject> = TContext | ContextFactory<TContext, TActor, TInput, TEvent>;

declare interface InitialTransitionConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> extends TransitionConfig<TContext, TEvent, TEvent, TActor, TAction, TGuard, TDelay, TODO, // TEmitted
TODO> {
    target: string;
}

declare interface InitialTransitionDefinition<TContext extends MachineContext, TEvent extends EventObject> extends TransitionDefinition<TContext, TEvent> {
    target: ReadonlyArray<StateNode<TContext, TEvent>>;
    guard?: never;
}

declare interface Input {
    view: DiagramView;
    xystore: XYStoreApi;
    zoomable: boolean;
    pannable: boolean;
    nodesDraggable: boolean;
    nodesSelectable: boolean;
    fitViewPadding: ViewPaddings;
    where: WhereOperator | null;
    dynamicViewVariant?: DynamicViewDisplayVariant | undefined;
    features?: EnabledFeatures;
}

declare type Input_2 = {
    subject: Fqn;
    currentView: DiagramView;
    initiatedFrom?: {
        node?: NodeId;
        clientRect?: Rect;
    };
};

declare type Input_3 = {
    subject: Fqn_3;
    viewId: ViewId_3 | null;
    scope: 'global' | 'view';
    closeable?: boolean;
    enableSelectSubject?: boolean;
    enableChangeScope?: boolean;
};

declare type Input_4 = ExclusiveUnion_2<{
    Edge: {
        edgeId: EdgeId_2;
        viewId: ViewId_3;
    };
    Between: {
        source: Fqn_3;
        target: Fqn_3;
        viewId: ViewId_3;
    };
}>;

declare type InputFrom<T> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TStateSchema> ? TInput : T extends ActorLogic<infer _TSnapshot, infer _TEvent, infer TInput, infer _TSystem, infer _TEmitted> ? TInput : never;

declare interface InspectedActionEvent extends BaseInspectionEventProperties {
    type: '@xstate.action';
    action: {
        type: string;
        params: unknown;
    };
}

declare interface InspectedActorEvent extends BaseInspectionEventProperties {
    type: '@xstate.actor';
}

declare interface InspectedEventEvent extends BaseInspectionEventProperties {
    type: '@xstate.event';
    sourceRef: ActorRefLike | undefined;
    event: AnyEventObject;
}

declare interface InspectedMicrostepEvent extends BaseInspectionEventProperties {
    type: '@xstate.microstep';
    event: AnyEventObject;
    snapshot: Snapshot<unknown>;
    _transitions: AnyTransitionDefinition[];
}

declare interface InspectedSnapshotEvent extends BaseInspectionEventProperties {
    type: '@xstate.snapshot';
    event: AnyEventObject;
    snapshot: Snapshot<unknown>;
}

declare type InspectionEvent = InspectedSnapshotEvent | InspectedEventEvent | InspectedActorEvent | InspectedMicrostepEvent | InspectedActionEvent;

declare type InternalMachineImplementations<TTypes extends StateMachineTypes> = {
    actions?: MachineImplementationsActions<TTypes>;
    actors?: MachineImplementationsActors<TTypes>;
    delays?: MachineImplementationsDelays<TTypes>;
    guards?: MachineImplementationsGuards<TTypes>;
};

declare interface InteropObservable<T> {
    [Symbol.observable]: () => InteropSubscribable<T>;
}

declare interface InteropSubscribable<T> {
    subscribe(observer: Observer<T>): Subscription;
}

declare type InvokeConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject, TMeta extends MetaObject> = IsLiteralString<TActor['src']> extends true ? DistributeActors<TContext, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta, TActor> : {
    /**
     * The unique identifier for the invoked machine. If not specified, this
     * will be the machine's own `id`, or the URL (from `src`).
     */
    id?: string;
    systemId?: string;
    /** The source of the machine to be invoked, or the machine itself. */
    src: AnyActorLogic | string;
    input?: Mapper<TContext, TEvent, NonReducibleUnknown, TEvent> | NonReducibleUnknown;
    /**
     * The transition to take upon the invoked child machine reaching its
     * final top-level state.
     */
    onDone?: string | SingleOrArray<TransitionConfigOrTarget<TContext, DoneActorEvent<any>, // TODO: consider replacing with `unknown`
    TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
    /**
     * The transition to take upon the invoked child machine sending an
     * error event.
     */
    onError?: string | SingleOrArray<TransitionConfigOrTarget<TContext, ErrorActorEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
    onSnapshot?: string | SingleOrArray<TransitionConfigOrTarget<TContext, SnapshotEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
};

declare interface InvokeDefinition<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject, TMeta extends MetaObject> {
    id: string;
    systemId: string | undefined;
    /** The source of the actor logic to be invoked */
    src: AnyActorLogic | string;
    input?: Mapper<TContext, TEvent, NonReducibleUnknown, TEvent> | NonReducibleUnknown;
    /**
     * The transition to take upon the invoked child machine reaching its final
     * top-level state.
     */
    onDone?: string | SingleOrArray<TransitionConfig<TContext, DoneActorEvent<unknown>, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
    /**
     * The transition to take upon the invoked child machine sending an error
     * event.
     */
    onError?: string | SingleOrArray<TransitionConfig<TContext, ErrorActorEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
    onSnapshot?: string | SingleOrArray<TransitionConfig<TContext, SnapshotEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
    toJSON: () => Omit<InvokeDefinition<TContext, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>, 'onDone' | 'onError' | 'toJSON'>;
}

declare type IsLiteralString<T extends string> = string extends T ? false : true;

declare type IsNever<T> = [T] extends [never] ? true : false;

declare type IsNotNever<T> = [T] extends [never] ? false : true;

declare type LayoutRelationshipsViewResult = {
    subject: Fqn;
    subjectExistsInScope: boolean;
    nodes: LayoutRelationshipsViewResult.Node[];
    edges: LayoutRelationshipsViewResult.Edge[];
    bounds: DiagramView['bounds'];
};

declare namespace LayoutRelationshipsViewResult {
    const Empty: ElementKind;
    type Node = Omit<DiagramNode, 'deploymentRef' | 'description' | 'inEdges' | 'outEdges'> & {
        description: MarkdownOrString | null;
        column: RelationshipsBrowserTypes.Column;
        ports: RelationshipsBrowserTypes.Ports;
        existsInCurrentView: boolean;
    };
    type Edge = Omit<DiagramEdge, 'description'> & {
        sourceFqn: Fqn;
        targetFqn: Fqn;
        sourceHandle: string;
        targetHandle: string;
        existsInCurrentView: boolean;
    };
}

declare type LayoutResult = {
    nodes: LayoutResult.Node[];
    edges: LayoutResult.Edge[];
    bounds: DiagramView['bounds'];
};

declare namespace LayoutResult {
    type Node = Except<DiagramNode, 'modelRef' | 'description' | 'deploymentRef' | 'inEdges' | 'outEdges'> & {
        description: MarkdownOrString | null;
        modelRef: Fqn;
        column: RelationshipDetailsTypes.Column;
        ports: RelationshipDetailsTypes.Ports;
    };
    type Edge = Except<DiagramEdge, 'relations' | 'description'> & {
        relationId: RelationId_2;
        sourceHandle: string;
        targetHandle: string;
        description: MarkdownOrString | null;
    };
}

export declare interface LikeC4BrowserProps {
    /**
     * Background pattern for the browser view.
     * @default 'dots'
     */
    background?: 'dots' | 'lines' | 'cross' | 'transparent' | 'solid' | undefined;
    /**
     * Padding around the diagram
     * @default '16px'
     */
    fitViewPadding?: PaddingWithUnit | undefined;
    /**
     * Show/hide panel with top left controls,
     *
     * @default true
     */
    controls?: boolean | undefined;
    /**
     * Show back/forward navigation buttons
     * @default true
     */
    showNavigationButtons?: undefined | boolean;
    /**
     * Enable search popup for elements and views
     * @default true
     */
    enableSearch?: boolean | undefined;
    /**
     * If double click on a node should enable focus mode
     *
     * @default true
     */
    enableFocusMode?: boolean | undefined;
    /**
     * If Walkthrough for dynamic views should be enabled
     * @default true
     */
    enableDynamicViewWalkthrough?: boolean | undefined;
    /**
     * Default dynamic view display variant
     * @default 'diagram'
     */
    dynamicViewVariant?: t.DynamicViewDisplayVariant | undefined;
    /**
     * Enable popup with element details
     * @default true
     */
    enableElementDetails?: boolean | undefined;
    /**
     * Experimental feature to browse relationships
     *
     * @default true
     */
    enableRelationshipBrowser?: boolean | undefined;
    /**
     * Display dropdown with details on relationship's label click
     * @default enableRelationshipBrowser
     */
    enableRelationshipDetails?: boolean | undefined;
    /**
     * Display element tags in the bottom left corner
     * @default true
     */
    enableElementTags?: boolean | undefined;
    /**
     * Display notations of the view
     * @default true
     */
    enableNotations?: boolean | undefined;
    /**
     * Enable "Compare with auto layout" action when view was manually modified and out of sync with latest model
     * @default true
     */
    enableCompareWithLatest?: boolean | undefined;
    /**
     * Display element notes, if they are present in the view
     *
     * @default true
     */
    enableNotes?: boolean | undefined;
    /**
     * Improve performance by hiding certain elements and reducing visual effects (disable mix-blend, shadows, animations)
     *
     * @default 'auto' - will be set to true if view is pannable and has more than 3000 * 2000 pixels
     */
    reduceGraphics?: 'auto' | boolean | undefined;
    className?: string | undefined;
    style?: CSSProperties | undefined;
    /**
     * Override some react flow props
     */
    reactFlowProps?: OverrideReactFlowProps | undefined;
    /**
     * Children to render inside the browser overlay
     */
    children?: ReactNode | undefined;
}

export declare type LikeC4ColorScheme = 'light' | 'dark';

/**
 * Low-level component to display LikeC4 view
 * Expects CSS to be injected
 *
 * Use {@link ReactLikeC4} or {@link LikeC4View} for ready-to-use component
 */
export declare function LikeC4Diagram<A extends Any = Any>({ onCanvasClick, onCanvasContextMenu, onCanvasDblClick, onEdgeClick, onEdgeContextMenu, onNavigateTo, onNodeClick, onNodeContextMenu, onOpenSource, onLogoClick, onLayoutTypeChange, onInitialized, view, className, controls, fitView, fitViewPadding: _fitViewPadding, pannable, zoomable, background, enableElementTags, enableFocusMode, enableElementDetails, enableRelationshipDetails, enableRelationshipBrowser, enableCompareWithLatest, nodesSelectable, enableNotations, showNavigationButtons, enableDynamicViewWalkthrough, dynamicViewVariant, enableSearch, enableNotes, initialWidth, initialHeight, reduceGraphics, renderIcon, where, reactFlowProps, renderNodes, children, }: LikeC4DiagramProps<A>): JSX.Element;

export declare interface LikeC4DiagramEventHandlers<A extends Any_2 = Unknown> {
    onNavigateTo?: OnNavigateTo<A> | null | undefined;
    onNodeClick?: OnNodeClick<A> | null | undefined;
    onNodeContextMenu?: OnNodeClick<A> | null | undefined;
    onCanvasContextMenu?: OnCanvasContextMenu | null | undefined;
    onEdgeClick?: OnEdgeClick<A> | null | undefined;
    onEdgeContextMenu?: OnEdgeClick<A> | null | undefined;
    onCanvasClick?: OnCanvasClick | null | undefined;
    onCanvasDblClick?: OnCanvasClick | null | undefined;
    onLogoClick?: null | undefined | (() => void);
    onOpenSource?: OnOpenSource<A> | null | undefined;
    onInitialized?: OnInitialized | null | undefined;
    /**
     * Triggered when user changes layout type (e.g. from 'manual' to 'auto')
     * Expected another `view` to be passed to the diagram
     *
     * @param layoutType new layout type
     */
    onLayoutTypeChange?: OnLayoutTypeChange | null | undefined;
}

export declare interface LikeC4DiagramProperties<A extends Any_2 = Unknown> {
    view: LayoutedView<A>;
    className?: string | undefined;
    /**
     * Enable/disable panning
     * @default true
     */
    pannable?: boolean | undefined;
    /**
     * Enable/disable zooming
     * @default true
     */
    zoomable?: boolean | undefined;
    /**
     * Show/hide panel with top left controls
     *
     * @default true
     */
    controls?: boolean | undefined;
    /**
     * If set, initial viewport will show all nodes & edges
     * @default true
     */
    fitView?: boolean | undefined;
    /**
     * Padding around the diagram (number - pixels)
     * @default 16 - 16px
     *
     * @see {@link ViewPadding}
     *
     * @example
     * ```tsx
     * <LikeC4Diagram
     *   fitViewPadding={{
     *     x: '16px',
     *     y: 16,
     *   }}
     * />
     *
     * <LikeC4Diagram
     *   fitViewPadding={{
     *     top: 8,
     *     right: '8px',
     *     bottom: '1px',
     *     left: '8px',
     *   }}
     * />
     * ```
     */
    fitViewPadding?: ViewPadding | undefined;
    /**
     * If not readonly, or `enableFocusMode`, `onNavigateTo` or  `onNodeClick` are set - nodes will be selectable
     *
     * @default false
     */
    nodesSelectable?: boolean | undefined;
    /**
     * Initial width of the diagram
     * (supposed to be used during SSR)
     */
    initialWidth?: number | undefined;
    /**
     * Initial height of the diagram
     * (supposed to be used during SSR)
     */
    initialHeight?: number | undefined;
    /**
     * Background pattern
     * @default 'dots'
     */
    background?: 'transparent' | 'solid' | 'dots' | 'lines' | 'cross' | undefined;
    /**
     * Show back/forward history navigation buttons
     * @default true if `onNavigateTo` is set
     */
    showNavigationButtons?: undefined | boolean;
    /**
     * Display notations in the bottom right corner
     * (Active if only notations are present)
     *
     * @default false
     */
    enableNotations?: boolean | undefined;
    /**
     * Display dropdown with details on relationship's label click
     * @default false
     */
    enableRelationshipDetails?: boolean | undefined;
    /**
     * If double click on a node should enable focus mode, i.e. highlight incoming/outgoing edges
     * @default false
     */
    enableFocusMode?: boolean | undefined;
    /**
     * Enable search popup for elements and views
     * @default true
     */
    enableSearch?: boolean | undefined;
    /**
     * Enable modal with element details
     * @default false
     */
    enableElementDetails?: boolean | undefined;
    /**
     * Experimental feature to browse relationships
     *
     * @default false
     */
    enableRelationshipBrowser?: boolean | undefined;
    /**
     * If Walkthrough for dynamic views should be enabled
     * @default false
     */
    enableDynamicViewWalkthrough?: boolean | undefined;
    /**
     * Enable "Compare with auto layout" action when view was manually modified and out of sync with latest model
     * @default true if `onLayoutTypeChange` is set, false otherwise
     */
    enableCompareWithLatest?: boolean | undefined;
    /**
     * Default dynamic view display variant
     * @default 'diagram'
     */
    dynamicViewVariant?: DynamicViewDisplayVariant | undefined;
    /**
     * Display element tags in the bottom left corner
     * @default false
     */
    enableElementTags?: boolean | undefined;
    /**
     * Display element notes, if they are present in the view
     *
     * @default true
     */
    enableNotes?: boolean | undefined;
    /**
     * Improve performance by hiding certain elements and reducing visual effects (disable mix-blend, shadows, animations)
     * Enable it if you have a large or static view
     * - `auto` - will be `true` if view has more then 3000 * 2000 pixels
     *
     * @default 'auto'
     */
    reduceGraphics?: 'auto' | boolean | undefined;
    /**
     * Render icon for an element, bundled or remote
     * By default, if icon is http:// or https://, it will be rendered as an image
     *
     * Consider using `IconRendererProvider`
     */
    renderIcon?: ElementIconRenderer | undefined;
    /**
     * Override node renderers
     */
    renderNodes?: NodeRenderers | undefined;
    /**
     * Dynamic filter, applies both to nodes and edges
     */
    where?: WhereOperator<A> | undefined;
    /**
     * Override ReactFlow props
     */
    reactFlowProps?: OverrideReactFlowProps | undefined;
}

export declare type LikeC4DiagramProps<A extends Any = Any> = PropsWithChildren<LikeC4DiagramProperties<A> & LikeC4DiagramEventHandlers<A>>;

/**
 * Callbacks from LikeC4 Editor.
 */
export declare interface LikeC4EditorCallbacks {
    /**
     * Apply semantic layout to a view (if AI is available)
     * See vite-plugin settings for more details
     */
    applySemanticLayout?: undefined | ((viewId: t.ViewId) => Promise<void>);
    /**
     * Fetch a view by its ID and layout type.
     *
     * @param viewId - The ID of the view to fetch.
     * @param layout - The layout type to use when fetching the view.
     */
    fetchView(viewId: t.ViewId, layout?: t.LayoutType): t.LayoutedView | Promise<t.LayoutedView>;
    /**
     * Callback invoked when the view changes.
     */
    handleChange(viewId: t.ViewId, change: t.ViewChange): void | Promise<void>;
}

/**
 * Provider for the LikeC4 Editor.
 * @example
 * ```tsx
 *
 * // Not required to use memo for editor callbacks
 * const editor = createLikeC4Editor({
 *   fetchView: async (viewId, layout) => {
 *     // fetch view logic
 *   },
 *   handleChange: (viewId, change) => {
 *     // handle change logic
 *   }
 * })
 *
 * <LikeC4EditorProvider
 *  editor={editor}>
 *   <App />
 * </LikeC4EditorProvider>
 * ```
 */
export declare function LikeC4EditorProvider({ children, editor }: LikeC4EditorProviderProps): JSX.Element;

export declare type LikeC4EditorProviderProps = PropsWithChildren<{
    editor: LikeC4EditorCallbacks;
}>;

/**
 * Ensures LikeC4Model context
 */
export declare function LikeC4ModelProvider({ children, likec4model, }: PropsWithChildren<LikeC4ModelProviderProps>): JSX.Element;

export declare interface LikeC4ModelProviderProps {
    likec4model: LikeC4Model<any>;
}

declare type LikeC4ProjectsContext = {
    projects: ReadonlyArray<LikeC4Project>;
    onProjectChange: (id: ProjectId) => void;
};

export declare function LikeC4ProjectsOverview({ view, className, onNavigateToProject, ...props }: LikeC4ProjectsOverviewProps): JSX.Element;

export declare type LikeC4ProjectsOverviewProps = Simplify<ProjectsOverviewProps & {
    className?: string;
    onSelectProject?: ProjectsOverviewProps['onNavigateToProject'];
}>;

/**
 * Ensures LikeC4Projects context
 */
export declare function LikeC4ProjectsProvider({ children, projects, onProjectChange: _onProjectChange, }: PropsWithChildren<LikeC4ProjectsProviderProps>): JSX.Element;

export declare interface LikeC4ProjectsProviderProps {
    /**
     * Projects to be used in the navigation panel.
     * Current project is taken from the LikeC4Model
     */
    projects: ReadonlyArray<LikeC4Project>;
    /**
     * Optional callback when another project is selected.
     */
    onProjectChange?: (id: ProjectId) => void;
}

/**
 * Ready-to-use component to display embedded LikeC4 view,
 * OnClick allows to browse the model.
 *
 * {@link ReactLikeC4} gives you more control.
 *
 * Component is wrapped in ShadowRoot to isolate styles.
 */
export declare function LikeC4View<A extends t.aux.Any = t.aux.UnknownLayouted>({ viewId, className, pannable, zoomable, keepAspectRatio, colorScheme, injectFontCss, controls, layoutType: initialLayoutType, background, browser, showNavigationButtons, enableNotations, enableFocusMode, enableDynamicViewWalkthrough, enableElementDetails, enableRelationshipDetails, enableRelationshipBrowser, enableNotes, reduceGraphics, mantineTheme, styleNonce, style, reactFlowProps, renderNodes, children, ...props }: LikeC4ViewProps<A>): JSX.Element;

export declare interface LikeC4ViewProps<A extends t.aux.Any = t.aux.UnknownLayouted> {
    /**
     * View to display.
     */
    viewId: t.aux.ViewId<A>;
    /**
     * Layout to display
     * - `auto`: auto-layouted from the current sources
     * - `manual`: manually layouted (if available, falls back to `auto`)
     *
     * @default 'manual'
     */
    layoutType?: t.LayoutType | undefined;
    /**
     * Enable/disable panning
     * @default false
     */
    pannable?: boolean | undefined;
    /**
     * Enable/disable zooming
     * @default false
     */
    zoomable?: boolean | undefined;
    /**
     * @default true
     */
    keepAspectRatio?: boolean | undefined;
    /**
     * Background pattern
     * @default 'transparent'
     */
    background?: 'dots' | 'lines' | 'cross' | 'transparent' | 'solid' | undefined;
    /**
     * Click on the view opens a modal with browser.
     * You can customize or disable the browser.
     *
     * @default true
     */
    browser?: boolean | LikeC4BrowserProps | undefined;
    /**
     * @default - determined by the user's system preferences.
     */
    colorScheme?: 'light' | 'dark' | undefined;
    /**
     * LikeC4 views are using 'IBM Plex Sans' font.
     * By default, component injects the CSS to document head.
     * Set to false if you want to handle the font yourself.
     *
     * @default true
     */
    injectFontCss?: boolean | undefined;
    /**
     * Show/hide panel with top left controls,
     * @default false
     */
    controls?: boolean | undefined;
    /**
     * If set, initial viewport will show all nodes & edges
     * @default true
     */
    fitView?: boolean | undefined;
    /**
     * Padding around the diagram
     * @default '16px'
     *
     * @see {@link ViewPadding}
     *
     * @example
     * ```tsx
     * <LikeC4View
     *   fitViewPadding={{
     *     x: '16px',
     *     y: 16,
     *   }}
     * />
     *
     * <LikeC4View
     *   fitViewPadding={{
     *     top: 8,
     *     right: '8px',
     *     bottom: '1px',
     *     left: '8px',
     *   }}
     * />
     * ```
     */
    fitViewPadding?: ViewPadding | undefined;
    /**
     * Show back/forward navigation buttons in controls panel
     * @default false
     */
    showNavigationButtons?: undefined | boolean;
    /**
     * Display notations of the view
     * @default false
     */
    enableNotations?: boolean | undefined;
    /**
     * If double click on a node should enable focus mode, i.e. highlight incoming/outgoing edges
     * Conflicts with `browser` prop
     *
     * @default false
     */
    enableFocusMode?: boolean | undefined;
    /**
     * If Walkthrough for dynamic views should be enabled
     * @default false
     */
    enableDynamicViewWalkthrough?: boolean | undefined;
    /**
     * Default dynamic view display variant
     * @default 'diagram'
     */
    dynamicViewVariant?: t.DynamicViewDisplayVariant | undefined;
    /**
     * Enable popup with element details
     * @default false
     */
    enableElementDetails?: boolean | undefined;
    /**
     * Display element tags in the bottom left corner
     * @default false
     */
    enableElementTags?: boolean | undefined;
    /**
     * Display dropdown with details on relationship's label click
     * @default false
     */
    enableRelationshipDetails?: boolean | undefined;
    /**
     * Allow popup to browse relationships
     *
     * @default enableRelationshipDetails
     */
    enableRelationshipBrowser?: boolean | undefined;
    /**
     * Display element notes, if they are present in the view
     *
     * @default false
     */
    enableNotes?: boolean | undefined;
    /**
     * Improve performance by hiding certain elements and reducing visual effects (disable mix-blend, shadows, animations)
     *
     * @default 'auto' - will be set to true if view is pannable and has more than 3000 * 2000 pixels
     */
    reduceGraphics?: 'auto' | boolean | undefined;
    where?: t.WhereOperator<A> | undefined;
    /**
     * Override some react flow props
     */
    reactFlowProps?: OverrideReactFlowProps | undefined;
    className?: string | undefined;
    style?: CSSProperties | undefined;
    /**
     * Override Mantine theme
     */
    mantineTheme?: any;
    /** Function to generate nonce attribute added to all generated `<style />` tags */
    styleNonce?: string | (() => string) | undefined;
    /**
     * Override node renderers
     */
    renderNodes?: NodeRenderers | undefined;
    /**
     * Render custom icon for a node
     * By default, if icon is http:// or https://, it will be rendered as an image
     */
    renderIcon?: ElementIconRenderer | undefined;
    /**
     * Children to render inside the diagram (not inside the browser overlay)
     */
    children?: ReactNode | undefined;
}

declare type LinearAlignmentMode = 'Left' | 'Center' | 'Right' | 'Top' | 'Middle' | 'Bottom';

declare type LinkedSnapshot = {
    head: Snapshot_2;
    tail: LinkedSnapshot | null;
};

declare type LowInfer<T> = T & NonNullable<unknown>;

declare type MachineConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = string, TTag extends string = string, TInput = any, TOutput = unknown, TEmitted extends EventObject = EventObject, TMeta extends MetaObject = MetaObject> = (Omit<StateNodeConfig<DoNotInfer<TContext>, DoNotInfer<TEvent>, DoNotInfer<TActor>, DoNotInfer<TAction>, DoNotInfer<TGuard>, DoNotInfer<TDelay>, DoNotInfer<TTag>, DoNotInfer<TOutput>, DoNotInfer<TEmitted>, DoNotInfer<TMeta>>, 'output'> & {
    /** The initial context (extended state) */
    /** The machine's own version. */
    version?: string;
    output?: Mapper<TContext, DoneStateEvent, TOutput, TEvent> | TOutput;
}) & (MachineContext extends TContext ? {
    context?: InitialContext<LowInfer<TContext>, TActor, TInput, TEvent>;
} : {
    context: InitialContext<LowInfer<TContext>, TActor, TInput, TEvent>;
});

declare type MachineContext = Record<string, any>;

declare type MachineImplementationsActions<TTypes extends StateMachineTypes> = {
    [K in TTypes['actions']['type']]?: ActionFunction<TTypes['context'], TTypes['events'], TTypes['events'], GetConcreteByKey<TTypes['actions'], 'type', K>['params'], TTypes['actors'], TTypes['actions'], TTypes['guards'], TTypes['delays'], TTypes['emitted']>;
};

declare type MachineImplementationsActors<TTypes extends StateMachineTypes> = {
    [K in TTypes['actors']['src']]?: GetConcreteByKey<TTypes['actors'], 'src', K>['logic'];
};

declare type MachineImplementationsDelays<TTypes extends StateMachineTypes> = {
    [K in TTypes['delays']]?: DelayConfig<TTypes['context'], TTypes['events'], undefined, TTypes['events']>;
};

declare type MachineImplementationsGuards<TTypes extends StateMachineTypes> = {
    [K in TTypes['guards']['type']]?: Guard<TTypes['context'], TTypes['events'], GetConcreteByKey<TTypes['guards'], 'type', K>['params'], TTypes['guards']>;
};

/** @ignore */
declare interface MachineImplementationsSimplified<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject> {
    guards: GuardMap<TContext, TEvent, TGuard>;
    actions: ActionFunctionMap<TContext, TEvent, TActor, TAction>;
    actors: Record<string, AnyActorLogic | {
        src: AnyActorLogic;
        input: Mapper<TContext, TEvent, unknown, TEvent> | NonReducibleUnknown;
    }>;
    delays: DelayFunctionMap<TContext, TEvent, TAction>;
}

declare type MachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema> = ActiveMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> | DoneMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> | ErrorMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> | StoppedMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>;

declare interface MachineSnapshotBase<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta, TStateSchema extends StateSchema = StateSchema> {
    /** The state machine that produced this state snapshot. */
    machine: StateMachine<TContext, TEvent, TChildren, ProvidedActor, ParameterizedObject, ParameterizedObject, string, TStateValue, TTag, unknown, TOutput, EventObject, // TEmitted
    any, // TMeta
    TStateSchema>;
    /** The tags of the active state nodes that represent the current state value. */
    tags: Set<string>;
    /**
     * The current state value.
     *
     * This represents the active state nodes in the state machine.
     *
     * - For atomic state nodes, it is a string.
     * - For compound parent state nodes, it is an object where:
     *
     *   - The key is the parent state node's key
     *   - The value is the current state value of the active child state node(s)
     *
     * @example
     *
     * ```ts
     * // single-level state node
     * snapshot.value; // => 'yellow'
     *
     * // nested state nodes
     * snapshot.value; // => { red: 'wait' }
     * ```
     */
    value: TStateValue;
    /** The current status of this snapshot. */
    status: SnapshotStatus;
    error: unknown;
    context: TContext;
    historyValue: Readonly<HistoryValue<TContext, TEvent>>;
    /** The enabled state nodes representative of the state value. */
    _nodes: Array<StateNode<TContext, TEvent>>;
    /** An object mapping actor names to spawned/invoked actors. */
    children: TChildren;
    /**
     * Whether the current state value is a subset of the given partial state
     * value.
     *
     * @param partialStateValue
     */
    matches: (partialStateValue: ToTestStateValue<TStateValue>) => boolean;
    /**
     * Whether the current state nodes has a state node with the specified `tag`.
     *
     * @param tag
     */
    hasTag: (tag: TTag) => boolean;
    /**
     * Determines whether sending the `event` will cause a non-forbidden
     * transition to be selected, even if the transitions have no actions nor
     * change the state value.
     *
     * @param event The event to test
     * @returns Whether the event will cause a transition
     */
    can: (event: TEvent) => boolean;
    getMeta: () => Record<StateId<TStateSchema> & string, TMeta | undefined>;
    toJSON: () => unknown;
}

declare type Mapper<TContext extends MachineContext, TExpressionEvent extends EventObject, TResult, TEvent extends EventObject> = (args: {
    context: TContext;
    event: TExpressionEvent;
    self: ActorRef<MachineSnapshot<TContext, TEvent, Record<string, AnyActorRef>, // TODO: this should be replaced with `TChildren`
    StateValue, string, unknown, TODO, // TMeta
    TODO>, TEvent, AnyEventObject>;
}) => TResult;

export declare const Markdown: ForwardRefExoticComponent<Omit<Omit< DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "children" | "dangerouslySetInnerHTML"> & {
    value: RichTextOrEmpty;
    /**
     * When markdown block is used inside a diagram node, this variant should be used to apply the likec4 palette.
     * @default false
     */
    uselikec4palette?: boolean;
    /**
     * Scale factor for the block
     * @default 1
     */
    textScale?: number;
    /**
     * Font size for the block
     * @default 'md'
     */
    fontSize?: (JsxStyleProps["fontSize"] & string) | undefined;
    /**
     * If true, the component will not render anything if the value is empty.
     * @default false
     */
    hideIfEmpty?: boolean | undefined;
    /**
     * Text to show if the value is empty.
     * @default "no content"
     */
    emptyText?: string;
} & RefAttributes<HTMLDivElement>>;

declare type MediaPrintEvent = {
    type: 'media.print.on';
} | {
    type: 'media.print.off';
};

export declare function memoEdge<P extends BaseEdgeProps>(Edge: FunctionComponent<P>): FunctionComponent<P>;

export declare function memoNode<P extends BaseNodeProps>(Node: FunctionComponent<P>, displayName?: string): FunctionComponent<P>;

declare type MetaObject = Record<string, any>;

declare interface NavigationHistory {
    history: ReadonlyArray<NavigationHistoryEntry_2>;
    currentIndex: number;
}

/**
 * Navigation history entry represents a current view state,
 * including viewport, focused node, dynamic view variant, etc.
 */
declare interface NavigationHistoryEntry_2 {
    viewId: ViewId;
    viewport: Viewport;
    viewportChangedManually: boolean;
    viewportBefore?: null | {
        wasChangedManually: boolean;
        value: Viewport;
    };
    focusedNode?: NodeId | null;
    dynamicViewVariant?: DynamicViewDisplayVariant | null;
    activeWalkthrough?: null | StepEdgeId;
}

export declare const NavigationPanel: {
    Root: StyleContextProvider<ForwardRefComponent<"div", HTMLMotionProps<"div">>, NavigationPanelRecipe>;
    Body: StyleContextConsumer<ForwardRefComponent<"div", HTMLMotionProps<"div">>>;
    Logo: StyleContextConsumer<ForwardRefExoticComponent<HTMLAttributes<HTMLButtonElement> & RefAttributes<HTMLButtonElement>>>;
    Label: StyleContextConsumer<ForwardRefComponent<"div", HTMLMotionProps<"div">>>;
    Dropdown: StyleContextConsumer<ForwardRefComponent<"div", HTMLMotionProps<"div">>>;
};

declare type NodeId_2 = t.aux.NodeId;

export declare type NodeRenderers = Partial<CamelCasedProperties<Types.NodeRenderers>>;

/**
 * To cooperate with `exactOptionalPropertyTypes` in `tsconfig.json`
 *
 * @example
 * interface User {
 * 	name: string;
 * 	surname?: string;
 * 	luckyNumber?: number;
 * }
 *
 * type NonOptionalUser = NonOptional<User>
 * // NonOptionalUser = {
 * //   name: string
 * //   surname: string | undefined
 * //   luckyNumber: number | undefined
 * // }
 */
declare type NonOptional<T extends object, Keys extends OptionalKeysOf<T> = OptionalKeysOf<T>> = Simplify<{
    [P in Exclude<keyof T, Keys>]: T[P];
} & {
    [P in Keys]-?: T[P] | undefined;
}>;

/**
 * @remarks
 * `T | unknown` reduces to `unknown` and that can be problematic when it comes
 * to contextual typing. It especially is a problem when the union has a
 * function member, like here:
 *
 * ```ts
 * declare function test(
 *   cbOrVal: ((arg: number) => unknown) | unknown
 * ): void;
 * test((arg) => {}); // oops, implicit any
 * ```
 *
 * This type can be used to avoid this problem. This union represents the same
 * value space as `unknown`.
 */
declare type NonReducibleUnknown = {} | null | undefined;

declare type NoRequiredParams<T extends ParameterizedObject> = T extends any ? undefined extends T['params'] ? T['type'] : never : never;

declare type NormalizeDescriptor<TDescriptor extends string> = TDescriptor extends '*' ? string : TDescriptor extends `${infer TLeading}.*` ? `${TLeading}.${string}` : TDescriptor;

/**
 * Normalize a raw search string for comparison.
 * Extracted as a pure function so both XState and standalone adapters can reuse it.
 */
export declare function normalizeSearch(value: string): string;

declare type Observer<T> = {
    next?: (value: T) => void;
    error?: (err: unknown) => void;
    complete?: () => void;
};

/**
 * On pane/canvas click (not on any node or edge)
 */
export declare type OnCanvasClick = (event: MouseEvent_2) => void;

declare type OnCanvasContextMenu = (event: MouseEvent_2) => void;

export declare type OnEdgeClick<A extends Any_2 = Unknown> = (edge: DiagramEdge<A>, event: MouseEvent_2) => void;

export declare type OnInitialized = (params: {
    diagram: DiagramApi;
    xyflow: XYFlowInstance;
}) => void;

declare type OnLayoutTypeChange = (layoutType: LayoutType) => void;

export declare type OnNavigateTo<A extends Any_2 = Unknown> = (to: ViewId_2<A>, event?: MouseEvent_2, element?: DiagramNodeWithNavigate<A>) => void;

export declare type OnNodeClick<A extends Any_2 = Unknown> = (node: DiagramNode<A>, event: MouseEvent_2) => void;

/**
 * "Go to source" action
 */
export declare type OnOpenSource<A extends Any_2 = Unknown> = (params: OpenSourceParams<A>) => void;

export declare type OpenSourceParams<A extends Any_2 = Unknown> = {
    element: Fqn_2<A>;
    property?: string;
} | {
    relation: RelationId;
} | {
    deployment: DeploymentFqn_2<A>;
    property?: string;
} | {
    view: StrictViewId<A>;
} | {
    view: StrictViewId<A>;
    astPath: string;
};

declare type OutputFrom<T> = T extends ActorLogic<infer TSnapshot, infer _TEvent, infer _TInput, infer _TSystem, infer _TEmitted> ? (TSnapshot & {
    status: 'done';
})['output'] : T extends ActorRef<infer TSnapshot, infer _TEvent, infer _TEmitted> ? (TSnapshot & {
    status: 'done';
})['output'] : never;

export declare const Overlay: ForwardRefExoticComponent<{
    fullscreen?: boolean | undefined;
    withBackdrop?: boolean | undefined;
    overlayLevel?: number;
    className?: string;
    classes?: {
        dialog?: string;
        body?: string;
    };
    backdrop?: {
        opacity?: number;
    };
    /**
     * Delay before showing the overlay content (in milliseconds) - helps to avoid flickering
     * Default: `130ms`
     * If set to `0`, the content will be shown immediately
     */
    openDelay?: number;
    /**
     * Called when the overlay is closed by outside click or escape key
     */
    onClose: () => void;
    onClick?: never;
} & {
    children?: ReactNode | undefined;
} & RefAttributes<HTMLDialogElement>>;

declare type OverlayActorEmitedEvent = {
    type: 'opened';
    overlay: 'elementDetails' | 'relationshipsBrowser' | 'relationshipDetails';
} | {
    type: 'closed';
    overlay: 'elementDetails' | 'relationshipsBrowser' | 'relationshipDetails';
} | {
    type: 'idle';
};

declare type OverlayActorEvent = {
    type: 'open.elementDetails';
} & Overlays.ElementDetails.Input | {
    type: 'open.relationshipDetails';
} & Overlays.RelationshipDetails.Input | {
    type: 'open.relationshipsBrowser';
} & Overlays.RelationshipsBrowser.Input | {
    type: 'close';
    actorId?: string | undefined;
} | {
    type: 'close.all';
};

export declare type OverlayProps = PropsWithChildren<{
    fullscreen?: boolean | undefined;
    withBackdrop?: boolean | undefined;
    overlayLevel?: number;
    className?: string;
    classes?: {
        dialog?: string;
        body?: string;
    };
    backdrop?: {
        opacity?: number;
    };
    /**
     * Delay before showing the overlay content (in milliseconds) - helps to avoid flickering
     * Default: `130ms`
     * If set to `0`, the content will be shown immediately
     */
    openDelay?: number;
    /**
     * Called when the overlay is closed by outside click or escape key
     */
    onClose: () => void;
    onClick?: never;
}>;

declare namespace Overlays {
    namespace ElementDetails {
        interface Input extends Input_2 {
        }
        interface Logic extends ElementDetailsLogic {
        }
        interface ActorRef extends ElementDetailsActorRef {
        }
    }
    namespace RelationshipDetails {
        type Input = Input_4;
        interface Logic extends RelationshipDetailsLogic {
        }
        interface ActorRef extends RelationshipDetailsActorRef {
        }
    }
    namespace RelationshipsBrowser {
        interface Input extends Input_3 {
        }
        interface Logic extends RelationshipsBrowserLogic {
        }
        interface ActorRef extends RelationshipsBrowserActorRef {
        }
    }
}

declare interface OverlaysActorLogic extends StateMachine<OverlaysContext, OverlayActorEvent, {
    [key: `elementDetails-${number}`]: Overlays.ElementDetails.ActorRef | undefined;
    [key: `relationshipDetails-${number}`]: Overlays.RelationshipDetails.ActorRef | undefined;
    [key: `relationshipsBrowser-${number}`]: Overlays.RelationshipsBrowser.ActorRef | undefined;
}, any, any, any, any, any, never, never, any, OverlayActorEmitedEvent, any, any> {
}

declare interface OverlaysActorRef extends ActorRef<OverlaysActorSnapshot, OverlayActorEvent, OverlayActorEmitedEvent> {
}

declare type OverlaysActorSnapshot = SnapshotFrom<OverlaysActorLogic>;

declare interface OverlaysContext {
    seq: number;
    overlays: Array<{
        type: 'elementDetails';
        id: `elementDetails-${number}`;
        subject: Fqn;
    } | {
        type: 'relationshipDetails';
        id: `relationshipDetails-${number}`;
    } | {
        type: 'relationshipsBrowser';
        id: `relationshipsBrowser-${number}`;
        subject: Fqn;
    }>;
}

declare type OverrideReactFlowProps = Pick<ReactFlowProps<Types.AnyNode, Types.AnyEdge>, 'paneClickDistance' | 'nodeClickDistance' | 'selectionKeyCode' | 'panActivationKeyCode' | 'multiSelectionKeyCode' | 'zoomActivationKeyCode' | 'snapToGrid' | 'snapGrid' | 'onlyRenderVisibleElements' | 'nodesDraggable' | 'nodesFocusable' | 'elementsSelectable' | 'selectNodesOnDrag' | 'panOnDrag' | 'preventScrolling' | 'zoomOnScroll' | 'zoomOnPinch' | 'panOnScroll' | 'panOnScrollSpeed' | 'panOnScrollMode' | 'zoomOnDoubleClick' | 'nodeDragThreshold'>;

export declare type PaddingUnit = 'px' | '%';

export declare type PaddingWithUnit = `${number}${PaddingUnit}` | number;

declare interface ParameterizedObject {
    type: string;
    params?: NonReducibleUnknown;
}

declare type PartialEventDescriptor<TEventType extends string> = TEventType extends `${infer TLeading}.${infer TTail}` ? `${TLeading}.*` | `${TLeading}.${PartialEventDescriptor<TTail>}` : never;

declare type PickEmittedEvent<T> = T extends DiagramEmittedEvents['type'] ? DiagramEmittedEvents & {
    type: T;
} : unknown;

/**
 * Picks appropriate bounds from the view,
 * depending on its type and dynamic variant
 */
export declare function pickViewBounds(view: LayoutedView, dynamicVariant?: DynamicViewDisplayVariant): BBox_2;

/**
 * PortalToContainer is used to render elements outside the LikeC4DiagramXYFlow, but inside the container.
 * It is used internally by the library.
 */
export declare function PortalToContainer({ children }: PropsWithChildren): JSX.Element;

declare type ProjectsOverviewProps = {
    view: LayoutedProjectsView;
    /**
     * Callback when project is selected (e.g. clicked)
     */
    onNavigateToProject?: undefined | ((projectId: ProjectId_2) => void);
    fitViewPadding?: ViewPadding | undefined;
} & ProjectsOverviewXYProps;

declare type ProjectsOverviewXYProps = {
    /**
     * Background pattern
     * @default 'dots'
     */
    background?: 'dots' | 'lines' | 'cross' | 'transparent' | 'solid' | undefined;
    /**
     * @default - determined by the user's system preferences.
     */
    colorScheme?: 'light' | 'dark' | undefined;
};

declare interface ProvidedActor {
    src: string;
    logic: UnknownActorLogic;
    id?: string | undefined;
}

/**
 * Ready-to-use component to display embedded LikeC4 view, same as {@link LikeC4View}
 * But provides more control over the diagram
 *
 * Component is wrapped in ShadowRoot to isolate styles.
 */
export declare function ReactLikeC4<A extends t.aux.Any = t.aux.UnknownLayouted>({ viewId, layoutType: initialLayoutType, className, colorScheme, injectFontCss, enableNotations, keepAspectRatio, style, mantineTheme, styleNonce, ...props }: ReactLikeC4Props<A>): JSX.Element;

export declare type ReactLikeC4Props<A extends t.aux.Any = t.aux.UnknownLayouted> = {
    viewId: t.aux.ViewId<A>;
    /**
     * Layout to display
     * - `auto`: auto-layouted from the current sources
     * - `manual`: manually layouted (if available, falls back to `auto`)
     *
     * Uncontrolled initial value, use `onLayoutTypeChange` to control it.
     *
     * @default 'manual'
     */
    layoutType?: t.LayoutType | undefined;
    /**
     * Keep aspect ratio of the diagram
     *
     * @default false
     */
    keepAspectRatio?: boolean | undefined;
    /**
     * By default determined by the user's system preferences.
     */
    colorScheme?: 'light' | 'dark' | undefined;
    /**
     * LikeC4 views are using 'IBM Plex Sans Variable' font.
     * By default, component injects the CSS to document head.
     * Set to false if you want to handle the font yourself.
     *
     * @default true
     */
    injectFontCss?: boolean | undefined;
    style?: CSSProperties | undefined;
    mantineTheme?: any;
    /** Function to generate nonce attribute added to all generated `<style />` tags */
    styleNonce?: string | (() => string) | undefined;
    children?: ReactNode | undefined;
} & Omit<LikeC4DiagramProperties<A>, 'view'> & LikeC4DiagramEventHandlers<A>;

declare interface Readable<T> extends Subscribable<T> {
    get: () => T;
}

declare type RelationId = t.aux.RelationId;

declare interface RelationshipDetailsActorRef extends ActorRef<RelationshipDetailsSnapshot, Events_3> {
}

declare interface RelationshipDetailsLogic extends StateMachine<Context_3, Events_3, {}, any, any, any, any, any, Tags_2, Input_4, any, any, any, any> {
}

declare type RelationshipDetailsSnapshot = SnapshotFrom<RelationshipDetailsLogic>;

declare namespace RelationshipDetailsTypes {
    type Column = 'sources' | 'targets';
    /**
     * The node's incoming and outgoing ports
     */
    type Ports = {
        in: string[];
        out: string[];
    };
    type ElementNodeData = Simplify<BaseNodeData & NonOptional<Pick<DiagramNode, 'id' | 'title' | 'technology' | 'description' | 'color' | 'shape' | 'width' | 'height' | 'navigateTo' | 'style' | 'tags'>> & {
        column: Column;
        fqn: Fqn;
        icon: IconUrl;
        ports: Ports;
    }>;
    type CompoundNodeData = Simplify<BaseNodeData & NonOptional<Pick<DiagramNode, 'id' | 'title' | 'color' | 'style'>> & {
        column: Column;
        fqn: Fqn;
        depth: number;
        icon?: IconUrl;
        ports: Ports;
    }>;
    type ElementNode = BaseNode<ElementNodeData, 'element'>;
    type CompoundNode = BaseNode<CompoundNodeData, 'compound'>;
    type AnyNode = ElementNode | CompoundNode;
    type NodeType = AnyNode['type'];
    type Node<T extends NodeType = NodeType> = Extract<AnyNode, {
        type: T;
    }>;
    type NodeProps<T extends NodeType = NodeType> = BaseNodeProps<Node<T>>;
    type NodeData = ExclusiveUnion<{
        ElementNodeData: ElementNodeData;
        CompoundNodeData: CompoundNodeData;
    }>;
    type NodeRenderer<T extends NodeType = NodeType> = FunctionComponent<NodeProps<T>>;
    type NodeRenderers = {
        element: NodeRenderer<'element'>;
        compound: NodeRenderer<'compound'>;
    };
    type EdgeData = Simplify<BaseEdgeData & {
        relationId: RelationId_2;
        color: Color;
        label: string | null;
        technology?: string | undefined;
        navigateTo: ViewId | null;
        line: RelationshipLineType;
        head?: RelationshipArrowType;
        tail?: RelationshipArrowType;
        description: MarkdownOrString | null;
    }>;
    type Edge = BaseEdge<EdgeData, 'relationship'>;
    type EdgeProps = BaseEdgeProps<Edge>;
}

declare interface RelationshipsBrowserActorRef extends ActorRef<RelationshipsBrowserSnapshot, Events_2> {
}

declare interface RelationshipsBrowserLogic extends StateMachine<Context_2, Events_2, {}, any, any, any, any, any, Tags, Input_3, any, any, any, any> {
}

declare type RelationshipsBrowserSnapshot = SnapshotFrom<RelationshipsBrowserLogic>;

declare namespace RelationshipsBrowserTypes {
    type Column = 'incomers' | 'subjects' | 'outgoers';
    /**
     * The node's incoming and outgoing ports
     */
    type Ports = {
        in: string[];
        out: string[];
    };
    type ElementNodeData = Simplify<BaseNodeData & NonOptional<Pick<DiagramNode, 'id' | 'title' | 'technology' | 'description' | 'color' | 'shape' | 'style' | 'width' | 'height' | 'tags' | 'navigateTo'>> & {
        column: Column;
        fqn: Fqn;
        icon: string | null;
        ports: Ports;
        existsInCurrentView: boolean;
    }>;
    type CompoundNodeData = Simplify<BaseNodeData & NonOptional<Pick<DiagramNode, 'id' | 'title' | 'color' | 'shape' | 'style'>> & {
        column: Column;
        fqn: Fqn;
        depth: number;
        icon: IconUrl;
        ports: Ports;
        existsInCurrentView: boolean;
    }>;
    type EmptyNodeData = BaseNodeData & {
        column: Column;
    };
    type ElementNode = BaseNode<ElementNodeData, 'element'>;
    type CompoundNode = BaseNode<CompoundNodeData, 'compound'>;
    type EmptyNode = BaseNode<EmptyNodeData, 'empty'>;
    type AnyNode = ElementNode | CompoundNode | EmptyNode;
    type NodeType = AnyNode['type'];
    type Node<T extends NodeType = NodeType> = Extract<AnyNode, {
        type: T;
    }>;
    type NodeProps<T extends NodeType = NodeType> = BaseNodeProps<Node<T>>;
    type NodeData = ExclusiveUnion<{
        ElementNodeData: ElementNodeData;
        CompoundNodeData: CompoundNodeData;
        EmptyNodeData: EmptyNodeData;
    }>;
    type NodeRenderer<T extends NodeType = NodeType> = FunctionComponent<NodeProps<T>>;
    type NodeRenderers = {
        [T in NodeType]: NodeRenderer<T>;
    };
    type EdgeData = Simplify<BaseEdgeData & {
        sourceFqn: Fqn;
        targetFqn: Fqn;
        relations: NonEmptyArray<RelationId_2>;
        color: Color;
        label: string | null;
        navigateTo: ViewId | null;
        line: RelationshipLineType;
        head?: RelationshipArrowType;
        tail?: RelationshipArrowType;
        existsInCurrentView: boolean;
    }>;
    type Edge = BaseEdge<EdgeData, 'relationship'>;
    type EdgeProps = BaseEdgeProps<Edge>;
}

declare type RequiredActorOptions<TActor extends ProvidedActor> = (undefined extends TActor['id'] ? never : 'id') | (undefined extends InputFrom<TActor['logic']> ? never : 'input');

declare type RequiredData = {
    color: Color;
    depth: number;
    style: ElementStyle;
};

declare type RequiredData_2 = {
    id: NodeId;
    title: string;
    color: Color;
    style: ComputedNodeStyle;
    icon?: string | null;
};

declare type RequiredData_3 = {
    id: NodeId_3;
    title: string;
    technology?: string | null | undefined;
    color: Color;
    style: ComputedNodeStyle_2;
    description?: MarkdownOrString_2 | null | undefined;
    icon?: string | null;
};

declare type RequiredData_4 = {
    color: Color;
    shape: ElementShape_2;
    style?: ComputedNodeStyle;
};

declare type RequiredData_5 = {
    shape: ElementShape_2;
    width: number;
    height: number;
    style?: ComputedNodeStyle;
};

declare type RequiredLogicInput<TLogic extends AnyActorLogic> = undefined extends InputFrom<TLogic> ? never : 'input';

declare type RequiredOrNull<T> = {
    [P in keyof T]-?: NonNullable<T[P]> | null;
};

/** @deprecated */
declare interface ResolvedStateMachineTypes<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TEmitted extends EventObject = EventObject> {
    context: TContext;
    events: TEvent;
    actors: TActor;
    actions: TAction;
    guards: TGuard;
    delays: TDelay;
    tags: TTag;
    emitted: TEmitted;
}

declare type ReturnTypeOrValue<T> = T extends AnyFunction ? ReturnType<T> : T;

declare interface RouteTransitionConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject> {
    guard?: Guard<TContext, TExpressionEvent, undefined, TGuard>;
    actions?: Actions<TContext, TExpressionEvent, TEvent, undefined, TActor, TAction, TGuard, TDelay, TEmitted>;
    meta?: Record<string, any>;
    description?: string;
}

declare interface ScheduledEvent {
    id: string;
    event: EventObject;
    startedAt: number;
    delay: number;
    source: AnyActorRef;
    target: AnyActorRef;
}

declare interface Scheduler {
    schedule(source: AnyActorRef, target: AnyActorRef, event: EventObject, delay: number, id: string | undefined): void;
    cancel(source: AnyActorRef, id: string): void;
    cancelAll(actorRef: AnyActorRef): void;
}

declare type SearchActorEvent = {
    type: 'open';
    search?: string | undefined;
} | {
    type: 'close';
} | {
    type: 'change.search';
    search: string;
} | {
    type: 'pickview.open';
    elementFqn: Fqn;
} | {
    type: 'navigate.to';
    viewId: ViewId;
    focusOnElement?: Fqn | undefined;
} | {
    type: 'animation.presence.end';
} | {
    type: 'pickview.close';
};

declare interface SearchActorLogic extends StateMachine<SearchContext_2, SearchActorEvent, {}, any, any, any, any, 'inactive' | 'opened' | 'pickView' | 'waitAnimationEnd', never, never, any, any, any, any> {
}

declare interface SearchActorRef extends ActorRef<SearchActorSnapshot, SearchActorEvent> {
}

declare type SearchActorSnapshot = SnapshotFrom<SearchActorLogic>;

export declare const searchBodyCss: string;

export declare const SearchContext: Context_4<SearchContextValue | null>;

declare interface SearchContext_2 {
    openedWithSearch: string | null;
    searchValue: string;
    pickViewFor: Fqn | null;
    navigateTo: {
        viewId: ViewId;
        focusOnElement?: Fqn | undefined;
    } | null;
}

export declare interface SearchContextValue {
    searchValue: string;
    setSearchValue: (value: string) => void;
    normalizedSearch: string;
    navigateTo: (viewId: ViewId, focusOnElement?: Fqn) => void;
    openPickView: (elementFqn: Fqn) => void;
    closePickView: () => void;
    pickViewFor: Fqn | null;
    close: () => void;
    currentViewId: string | null;
    openedWithSearch: string | null;
}

export declare function SearchControl({ className, ...others }: SearchControlProps): JSX.Element;

declare interface SearchControlProps extends UnstyledButtonProps, ElementProps<'button'> {
}

export declare const searchDialogCss: string;

/**
 * The shared search panel content used by both diagram and overview search.
 * Must be rendered inside a SearchContext.Provider.
 */
export declare const SearchPanelContent: ForwardRefExoticComponent<RefAttributes<HTMLDivElement>>;

export declare function SequenceActorNode(props: Types.NodeProps<'seq-actor'>): JSX.Element;

export declare function sequenceActorNode<A extends Any_5 = Unknown_3>(component: FC<SequenceActorNodeProps<A>>): Types.NodeRenderer<'seq-actor'>;

export declare type SequenceActorNodeProps<A extends Any_5 = Unknown_3> = {
    nodeProps: Types.NodeProps<'seq-actor'>;
    nodeModel: NodeModel.WithElement<A>;
};

export declare function SequenceParallelArea(props: Types.NodeProps<'seq-parallel'>): JSX.Element;

declare function setData<E extends WithData<any>>(value: E, state: Partial<E['data']>): E;

declare function setData<E extends WithData<any>>(state: Partial<NoInfer<E['data']>>): (value: E) => E;

declare function setDimmed<T extends WithDimmed>(value: T, dimmed: 'immediate' | boolean): T;

declare function setDimmed(dimmed: 'immediate' | boolean): <T extends WithDimmed>(value: T) => T;

declare function setHovered<T extends WithHovered>(value: T, hovered: boolean): T;

declare function setHovered(hovered: boolean): <T extends WithHovered>(value: T) => T;

declare type SingleOrArray<T> = readonly T[] | T;

declare type SlotProps = {
    data: RequiredData_3;
    className?: string;
    style?: CSSProperties;
    [key: `data-${string}`]: string;
};

declare type Snapshot<TOutput> = {
    status: 'active';
    output: undefined;
    error: undefined;
} | {
    status: 'done';
    output: TOutput;
    error: undefined;
} | {
    status: 'error';
    output: undefined;
    error: unknown;
} | {
    status: 'stopped';
    output: undefined;
    error: undefined;
};

declare type Snapshot_2 = {
    view: t.LayoutedView;
    change: t.ViewChange.SaveViewSnapshot;
    xynodes: Types.Node[];
    xyedges: Types.Edge[];
};

declare interface SnapshotEvent<TSnapshot extends Snapshot<unknown> = Snapshot<unknown>> extends EventObject {
    type: `xstate.snapshot.${string}`;
    snapshot: TSnapshot;
}

declare type SnapshotFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer TSnapshot, infer _, infer __> ? TSnapshot : R extends Actor<infer TLogic> ? SnapshotFrom<TLogic> : R extends ActorLogic<infer _TSnapshot, infer _TEvent, infer _TInput, infer _TEmitted, infer _TSystem> ? ReturnType<R['transition']> : R extends ActorScope<infer TSnapshot, infer _TEvent, infer _TEmitted, infer _TSystem> ? TSnapshot : never : never;

declare type SnapshotStatus = 'active' | 'done' | 'error' | 'stopped';

declare type Spawner<TActor extends ProvidedActor> = IsLiteralString<TActor['src']> extends true ? {
    <TSrc extends TActor['src']>(logic: TSrc, ...[options]: SpawnOptions<TActor, TSrc>): ActorRefFromLogic<GetConcreteByKey<TActor, 'src', TSrc>['logic']>;
    <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[
    options?: {
        id?: never;
        systemId?: string;
        input?: InputFrom<TLogic>;
        syncSnapshot?: boolean;
    } & {
        [K in RequiredLogicInput<TLogic>]: unknown;
    }
    ], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
} : <TLogic extends AnyActorLogic | string>(src: TLogic, ...[options]: ConditionalRequired<[
options?: {
    id?: string;
    systemId?: string;
    input?: TLogic extends string ? unknown : InputFrom<TLogic>;
    syncSnapshot?: boolean;
} & (TLogic extends AnyActorLogic ? {
    [K in RequiredLogicInput<TLogic>]: unknown;
} : {})
], IsNotNever<TLogic extends AnyActorLogic ? RequiredLogicInput<TLogic> : never>>) => TLogic extends AnyActorLogic ? ActorRefFromLogic<TLogic> : AnyActorRef;

declare type SpawnOptions<TActor extends ProvidedActor, TSrc extends TActor['src']> = TActor extends {
    src: TSrc;
} ? ConditionalRequired<[
options?: {
    id?: TActor['id'];
    systemId?: string;
    input?: InputFrom<TActor['logic']>;
    syncSnapshot?: boolean;
} & {
    [K in RequiredActorOptions<TActor>]: unknown;
}
], IsNotNever<RequiredActorOptions<TActor>>> : never;

declare type StateId<TSchema extends StateSchema, TKey extends string = '(machine)', TParentKey extends string | null = null> = (TSchema extends {
    id: string;
} ? TSchema['id'] : TParentKey extends null ? TKey : `${TParentKey}.${TKey}`) | (TSchema['states'] extends Record<string, any> ? Values<{
    [K in keyof TSchema['states'] & string]: StateId<TSchema['states'][K], K, TParentKey extends string ? `${TParentKey}.${TKey}` : TSchema['id'] extends string ? TSchema['id'] : TKey>;
}> : never);

declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TStateValue extends StateValue, TTag extends string, TInput, TOutput, TEmitted extends EventObject, TMeta extends MetaObject, TStateSchema extends StateSchema> implements ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, TEvent, TInput, AnyActorSystem, TEmitted> {
    /** The raw config used to create the machine. */
    config: MachineConfig<TContext, TEvent, any, any, any, any, any, any, TOutput, any, // TEmitted
    any> & {
        schemas?: unknown;
    };
    /** The machine's own version. */
    version?: string;
    schemas: unknown;
    implementations: MachineImplementationsSimplified<TContext, TEvent>;
    root: StateNode<TContext, TEvent>;
    id: string;
    states: StateNode<TContext, TEvent>['states'];
    events: Array<EventDescriptor<TEvent>>;
    constructor(
    /** The raw config used to create the machine. */
    config: MachineConfig<TContext, TEvent, any, any, any, any, any, any, TOutput, any, // TEmitted
    any> & {
        schemas?: unknown;
    }, implementations?: MachineImplementationsSimplified<TContext, TEvent>);
    /**
     * Clones this state machine with the provided implementations.
     *
     * @param implementations Options (`actions`, `guards`, `actors`, `delays`) to
     *   recursively merge with the existing options.
     * @returns A new `StateMachine` instance with the provided implementations.
     */
    provide(implementations: InternalMachineImplementations<ResolvedStateMachineTypes<TContext, DoNotInfer<TEvent>, TActor, TAction, TGuard, TDelay, TTag, TEmitted>>): StateMachine<TContext, TEvent, TChildren, TActor, TAction, TGuard, TDelay, TStateValue, TTag, TInput, TOutput, TEmitted, TMeta, TStateSchema>;
    resolveState(config: {
        value: StateValue;
        context?: TContext;
        historyValue?: HistoryValue<TContext, TEvent>;
        status?: SnapshotStatus;
        output?: TOutput;
        error?: unknown;
    } & (Equals<TContext, MachineContext> extends false ? {
        context: unknown;
    } : {})): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>;
    /**
     * Determines the next snapshot given the current `snapshot` and received
     * `event`. Calculates a full macrostep from all microsteps.
     *
     * @param snapshot The current snapshot
     * @param event The received event
     */
    transition(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, event: TEvent, actorScope: ActorScope<typeof snapshot, TEvent, AnyActorSystem, TEmitted>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>;
    /**
     * Determines the next state given the current `state` and `event`. Calculates
     * a microstep.
     *
     * @param state The current state
     * @param event The received event
     */
    microstep(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, event: TEvent, actorScope: AnyActorScope): Array<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>>;
    getTransitionData(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>>;
    /**
     * Returns the initial `State` instance, with reference to `self` as an
     * `ActorRef`.
     */
    getInitialSnapshot(actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, TEvent, AnyActorSystem, TEmitted>, input?: TInput): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>;
    start(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>): void;
    getStateNodeById(stateId: string): StateNode<TContext, TEvent>;
    get definition(): StateMachineDefinition<TContext, TEvent>;
    toJSON(): StateMachineDefinition<TContext, TEvent>;
    getPersistedSnapshot(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, options?: unknown): Snapshot<unknown>;
    restoreSnapshot(snapshot: Snapshot<unknown>, _actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, TEvent, AnyActorSystem, TEmitted>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>;
}

declare interface StateMachineDefinition<TContext extends MachineContext, TEvent extends EventObject> extends StateNodeDefinition<TContext, TEvent> {
}

declare interface StateMachineTypes {
    context: MachineContext;
    events: EventObject;
    actors: ProvidedActor;
    actions: ParameterizedObject;
    guards: ParameterizedObject;
    delays: string;
    tags: string;
    emitted: EventObject;
}

declare class StateNode<TContext extends MachineContext = MachineContext, TEvent extends EventObject = EventObject> {
    /** The raw config used to create the machine. */
    config: StateNodeConfig<TContext, TEvent, TODO, // actors
    TODO, // actions
    TODO, // guards
    TODO, // delays
    TODO, // tags
    TODO, // output
    TODO, // emitted
    TODO>;
    /**
     * The relative key of the state node, which represents its location in the
     * overall state value.
     */
    key: string;
    /** The unique ID of the state node. */
    id: string;
    /**
     * The type of this state node:
     *
     * - `'atomic'` - no child state nodes
     * - `'compound'` - nested child state nodes (XOR)
     * - `'parallel'` - orthogonal nested child state nodes (AND)
     * - `'history'` - history state node
     * - `'final'` - final state node
     */
    type: 'atomic' | 'compound' | 'parallel' | 'final' | 'history';
    /** The string path from the root machine node to this node. */
    path: string[];
    /** The child state nodes. */
    states: StateNodesConfig<TContext, TEvent>;
    /**
     * The type of history on this state node. Can be:
     *
     * - `'shallow'` - recalls only top-level historical state value
     * - `'deep'` - recalls historical state value at all levels
     */
    history: false | 'shallow' | 'deep';
    /** The action(s) to be executed upon entering the state node. */
    entry: UnknownAction[];
    /** The action(s) to be executed upon exiting the state node. */
    exit: UnknownAction[];
    /** The parent state node. */
    parent?: StateNode<TContext, TEvent>;
    /** The root machine node. */
    machine: StateMachine<TContext, TEvent, any, // children
    any, // actor
    any, // action
    any, // guard
    any, // delay
    any, // state value
    any, // tag
    any, // input
    any, // output
    any, // emitted
    any, // meta
    any>;
    /**
     * The meta data associated with this state node, which will be returned in
     * State instances.
     */
    meta?: any;
    /**
     * The output data sent with the "xstate.done.state._id_" event if this is a
     * final state node.
     */
    output?: Mapper<MachineContext, EventObject, unknown, EventObject> | NonReducibleUnknown;
    /**
     * The order this state node appears. Corresponds to the implicit document
     * order.
     */
    order: number;
    description?: string;
    tags: string[];
    transitions: Map<string, TransitionDefinition<TContext, TEvent>[]>;
    always?: Array<TransitionDefinition<TContext, TEvent>>;
    constructor(
    /** The raw config used to create the machine. */
    config: StateNodeConfig<TContext, TEvent, TODO, // actors
    TODO, // actions
    TODO, // guards
    TODO, // delays
    TODO, // tags
    TODO, // output
    TODO, // emitted
    TODO>, options: StateNodeOptions<TContext, TEvent>);
    /** The well-structured state node definition. */
    get definition(): StateNodeDefinition<TContext, TEvent>;
    /** The logic invoked as actors by this state node. */
    get invoke(): Array<InvokeDefinition<TContext, TEvent, ProvidedActor, ParameterizedObject, ParameterizedObject, string, TODO, // TEmitted
    TODO>>;
    /** The mapping of events to transitions. */
    get on(): TransitionDefinitionMap<TContext, TEvent>;
    get after(): Array<DelayedTransitionDefinition<TContext, TEvent>>;
    get initial(): InitialTransitionDefinition<TContext, TEvent>;
    /** All the event types accepted by this state node and its descendants. */
    get events(): Array<EventDescriptor<TEvent>>;
    /**
     * All the events that have transitions directly from this state node.
     *
     * Excludes any inert events.
     */
    get ownEvents(): Array<EventDescriptor<TEvent>>;
}

declare interface StateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, _TOutput, TEmitted extends EventObject, TMeta extends MetaObject> {
    /** The initial state transition. */
    initial?: InitialTransitionConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay> | string | undefined;
    /**
     * The type of this state node:
     *
     * - `'atomic'` - no child state nodes
     * - `'compound'` - nested child state nodes (XOR)
     * - `'parallel'` - orthogonal nested child state nodes (AND)
     * - `'history'` - history state node
     * - `'final'` - final state node
     */
    type?: 'atomic' | 'compound' | 'parallel' | 'final' | 'history';
    /**
     * Indicates whether the state node is a history state node, and what type of
     * history: shallow, deep, true (shallow), false (none), undefined (none)
     */
    history?: 'shallow' | 'deep' | boolean | undefined;
    /**
     * The mapping of state node keys to their state node configurations
     * (recursive).
     */
    states?: StatesConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, NonReducibleUnknown, TEmitted, TMeta> | undefined;
    /**
     * The services to invoke upon entering this state node. These services will
     * be stopped upon exiting this state node.
     */
    invoke?: SingleOrArray<InvokeConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
    /** The mapping of event types to their potential transition(s). */
    on?: TransitionsConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>;
    /** The action(s) to be executed upon entering the state node. */
    entry?: Actions<TContext, TEvent, TEvent, undefined, TActor, TAction, TGuard, TDelay, TEmitted>;
    /** The action(s) to be executed upon exiting the state node. */
    exit?: Actions<TContext, TEvent, TEvent, undefined, TActor, TAction, TGuard, TDelay, TEmitted>;
    /**
     * The potential transition(s) to be taken upon reaching a final child state
     * node.
     *
     * This is equivalent to defining a `[done(id)]` transition on this state
     * node's `on` property.
     */
    onDone?: string | SingleOrArray<TransitionConfig<TContext, DoneStateEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>> | undefined;
    /**
     * The mapping (or array) of delays (in milliseconds) to their potential
     * transition(s). The delayed transitions are taken after the specified delay
     * in an interpreter.
     */
    after?: DelayedTransitions<TContext, TEvent, TActor, TAction, TGuard, TDelay>;
    /**
     * An eventless transition that is always taken when this state node is
     * active.
     */
    always?: TransitionConfigOrTarget<TContext, TEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>;
    parent?: StateNode<TContext, TEvent>;
    /**
     * The meta data associated with this state node, which will be returned in
     * State instances.
     */
    meta?: TMeta;
    /**
     * The output data sent with the "xstate.done.state._id_" event if this is a
     * final state node.
     *
     * The output data will be evaluated with the current `context` and placed on
     * the `.data` property of the event.
     */
    output?: Mapper<TContext, TEvent, unknown, TEvent> | NonReducibleUnknown;
    /**
     * The unique ID of the state node, which can be referenced as a transition
     * target via the `#id` syntax.
     */
    id?: string | undefined;
    /**
     * The order this state node appears. Corresponds to the implicit document
     * order.
     */
    order?: number;
    /**
     * The tags for this state node, which are accumulated into the `state.tags`
     * property.
     */
    tags?: SingleOrArray<TTag>;
    /** A text description of the state node */
    description?: string;
    /** A default target for a history state */
    target?: string | undefined;
    route?: RouteTransitionConfig<TContext, TEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted>;
}

declare interface StateNodeDefinition<TContext extends MachineContext, TEvent extends EventObject> {
    id: string;
    version?: string | undefined;
    key: string;
    type: 'atomic' | 'compound' | 'parallel' | 'final' | 'history';
    initial: InitialTransitionDefinition<TContext, TEvent> | undefined;
    history: boolean | 'shallow' | 'deep' | undefined;
    states: StatesDefinition<TContext, TEvent>;
    on: TransitionDefinitionMap<TContext, TEvent>;
    transitions: Array<TransitionDefinition<TContext, TEvent>>;
    entry: UnknownAction[];
    exit: UnknownAction[];
    meta: any;
    order: number;
    output?: StateNodeConfig<TContext, TEvent, ProvidedActor, ParameterizedObject, ParameterizedObject, string, string, unknown, EventObject, // TEmitted
    any>['output'];
    invoke: Array<InvokeDefinition<TContext, TEvent, TODO, TODO, TODO, TODO, TODO, // TEmitted
    TODO>>;
    description?: string;
    tags: string[];
}

declare interface StateNodeOptions<TContext extends MachineContext, TEvent extends EventObject> {
    _key: string;
    _parent?: StateNode<TContext, TEvent>;
    _machine: AnyStateMachine;
}

declare type StateNodesConfig<TContext extends MachineContext, TEvent extends EventObject> = {
    [K in string]: StateNode<TContext, TEvent>;
};

declare type StateSchema = {
    id?: string;
    route?: unknown;
    states?: Record<string, StateSchema>;
    type?: unknown;
    invoke?: unknown;
    on?: unknown;
    entry?: unknown;
    exit?: unknown;
    onDone?: unknown;
    after?: unknown;
    always?: unknown;
    meta?: unknown;
    output?: unknown;
    tags?: unknown;
    description?: unknown;
};

declare type StatesConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TOutput, TEmitted extends EventObject, TMeta extends MetaObject> = {
    [K in string]: StateNodeConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TOutput, TEmitted, TMeta>;
};

declare type StatesDefinition<TContext extends MachineContext, TEvent extends EventObject> = {
    [K in string]: StateNodeDefinition<TContext, TEvent>;
};

/**
 * The string or object representing the state value relative to the parent
 * state node.
 *
 * @remarks
 * - For a child atomic state node, this is a string, e.g., `"pending"`.
 * - For complex state nodes, this is an object, e.g., `{ success:
 *   "someChildState" }`.
 */
declare type StateValue = string | StateValueMap;

declare interface StateValueMap {
    [key: string]: StateValue | undefined;
}

/* Excluded from this release type: StaticLikeC4Diagram */

declare type StaticLikeC4DiagramProps<A extends Any> = Pick<LikeC4DiagramProperties<A>, 'view' | 'className' | 'fitView' | 'fitViewPadding' | 'background' | 'enableElementDetails' | 'enableRelationshipDetails' | 'enableRelationshipBrowser' | 'enableElementTags' | 'reduceGraphics' | 'initialWidth' | 'initialHeight' | 'renderIcon' | 'renderNodes' | 'dynamicViewVariant' | 'where'>;

declare interface StoppedMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> {
    status: 'stopped';
    output: undefined;
    error: undefined;
}

declare type StrictViewId<A> = t.aux.StrictViewId<A>;

declare type Subject = {
    edgeId: EdgeId_2;
    source?: never;
    target?: never;
} | {
    source: Fqn_3;
    target: Fqn_3;
    edgeId?: never;
};

declare interface Subscribable<T> extends InteropSubscribable<T> {
    subscribe(observer: Observer<T>): Subscription;
    subscribe(next: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
}

declare interface Subscription {
    unsubscribe(): void;
}

declare const symbolObservable: typeof Symbol.observable;

declare type SyncOp = t.ViewChange | 'sync-snapshot' | 'apply-semantic-layout' | 'apply-latest-to-manual';

declare type System = ActorSystem<{
    actors: {
        diagram: DiagramMachineRef;
        overlays: OverlaysActorRef;
        search: SearchActorRef;
        editor: EditorActorRef;
    };
}>;

declare type Tags = 'active';

declare type Tags_2 = never;

declare type TODO = any;

declare type TogglableFeature = ('ReadOnly' | 'CompareWithLatest') & FeatureName;

declare type ToggledFeatures = {
    [P in `enable${TogglableFeature}`]?: boolean;
};

export declare function Toolbar({ title, children, nodeProps, ...props }: ToolbarProps): JSX.Element | null;

declare type ToolbarProps = Omit<NodeToolbarProps, 'title'> & {
    nodeProps: BaseNodeProps;
    title: ReactNode;
};

declare type ToTestStateValue<TStateValue extends StateValue> = TStateValue extends string ? TStateValue : IsNever<keyof TStateValue> extends true ? never : keyof TStateValue | {
    [K in keyof TStateValue]?: ToTestStateValue<NonNullable<TStateValue[K]>>;
};

declare interface TransitionConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject = EventObject, TMeta extends MetaObject = MetaObject> {
    guard?: Guard<TContext, TExpressionEvent, undefined, TGuard>;
    actions?: Actions<TContext, TExpressionEvent, TEvent, undefined, TActor, TAction, TGuard, TDelay, TEmitted>;
    reenter?: boolean;
    target?: TransitionTarget | undefined;
    meta?: TMeta;
    description?: string;
}

declare type TransitionConfigOrTarget<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject, TMeta extends MetaObject> = SingleOrArray<TransitionConfigTarget | TransitionConfig<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;

declare type TransitionConfigTarget = string | undefined;

declare interface TransitionDefinition<TContext extends MachineContext, TEvent extends EventObject> extends Omit<TransitionConfig<TContext, TEvent, TEvent, TODO, TODO, TODO, TODO, TODO, // TEmitted
TODO>, 'target' | 'guard'> {
    target: ReadonlyArray<StateNode<TContext, TEvent>> | undefined;
    source: StateNode<TContext, TEvent>;
    actions: readonly UnknownAction[];
    reenter: boolean;
    guard?: UnknownGuard;
    eventType: EventDescriptor<TEvent>;
    toJSON: () => {
        target: string[] | undefined;
        source: string;
        actions: readonly UnknownAction[];
        guard?: UnknownGuard;
        eventType: EventDescriptor<TEvent>;
        meta?: Record<string, any>;
    };
}

declare type TransitionDefinitionMap<TContext extends MachineContext, TEvent extends EventObject> = {
    [K in EventDescriptor<TEvent>]: Array<TransitionDefinition<TContext, ExtractEvent<TEvent, K>>>;
};

declare type TransitionsConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject, TMeta extends MetaObject> = {
    [K in EventDescriptor<TEvent>]?: TransitionConfigOrTarget<TContext, ExtractEvent<TEvent, K>, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>;
};

declare type TransitionTarget = SingleOrArray<string>;

export declare namespace Types {
    export type LeafNodeData = Simplify<BaseNodeData & NonOptional<Pick<DiagramNode, 'id' | 'title' | 'technology' | 'description' | 'notes' | 'color' | 'shape' | 'width' | 'level' | 'height' | 'style' | 'tags' | 'x' | 'y'>> & {
        /**
         * View layout direction, used by DefaultHandles to position node handles
         */
        viewLayoutDir?: AutoLayoutDirection | undefined;
        /**
         * View this node belongs to
         */
        viewId: ViewId;
        isMultiple?: boolean | undefined;
        icon: string | null;
        drifts: NonEmptyReadonlyArray<DiagramNodeDriftReason> | null;
    }>;
    /**
     * Represents element from logical model
     */
    export type ElementNodeData = Simplify<LeafNodeData & {
        modelFqn: Fqn;
        deploymentFqn?: never;
        /**
         * If set - this node has navigation to another view and diagram has handler for this
         */
        navigateTo: ViewId | null;
    }>;
    /**
     * Represents element from deployment model
     */
    export type DeploymentElementNodeData = Simplify<LeafNodeData & {
        navigateTo: ViewId | null;
        deploymentFqn: DeploymentFqn;
        modelFqn: Fqn | null;
    }>;
    export type SequenceActorNodePort = {
        id: string;
        cx: number;
        cy: number;
        height: number;
        type: 'target' | 'source';
        position: 'left' | 'right' | 'top' | 'bottom';
    };
    export type SequenceActorNodeData = Simplify<LeafNodeData & {
        navigateTo: ViewId | null;
        modelFqn: Fqn | null;
        ports: Array<SequenceActorNodePort>;
        viewHeight: number;
    }>;
    export type SequenceParallelAreaData = Simplify<LeafNodeData & {
        parallelPrefix: string;
    }>;
    export type CompoundNodeData = Simplify<BaseNodeData & NonOptional<Pick<DiagramNode, 'id' | 'title' | 'notes' | 'color' | 'shape' | 'style' | 'tags' | 'x' | 'y'>> & {
        /**
         * View layout direction, used by DefaultHandles to position node handles
         */
        viewLayoutDir?: AutoLayoutDirection | undefined;
        /**
         * View this node belongs to
         */
        viewId: ViewId;
        depth: number;
        icon?: IconUrl;
        drifts: NonEmptyReadonlyArray<DiagramNodeDriftReason> | null;
    }>;
    export type CompoundElementNodeData = Simplify<CompoundNodeData & {
        modelFqn: Fqn;
        deploymentFqn?: never;
        /**
         * If set - this node has navigation to another view and diagram has handler for this
         */
        navigateTo: ViewId | null;
    }>;
    export type CompoundDeploymentNodeData = Simplify<CompoundNodeData & {
        deploymentFqn: DeploymentFqn;
        /**
         * If set - this node refers to a model element
         */
        modelFqn: Fqn | null;
        /**
         * If set - this node has navigation to another view and diagram has handler for this
         */
        navigateTo: ViewId | null;
    }>;
    export type ViewGroupNodeData = Simplify<CompoundNodeData & {
        isViewGroup: true;
    }>;
    export type ElementNode = BaseNode<ElementNodeData, 'element'>;
    export type DeploymentElementNode = BaseNode<DeploymentElementNodeData, 'deployment'>;
    export type SequenceActorNode = BaseNode<SequenceActorNodeData, 'seq-actor'>;
    export type SequenceParallelArea = BaseNode<SequenceParallelAreaData, 'seq-parallel'>;
    export type CompoundElementNode = BaseNode<CompoundElementNodeData, 'compound-element'>;
    export type CompoundDeploymentNode = BaseNode<CompoundDeploymentNodeData, 'compound-deployment'>;
    export type ViewGroupNode = BaseNode<ViewGroupNodeData, 'view-group'>;
    export type AnyNode = ElementNode | DeploymentElementNode | CompoundElementNode | CompoundDeploymentNode | ViewGroupNode | SequenceActorNode | SequenceParallelArea;
    export type NodeType = AnyNode['type'];
    export type NodeData = ExclusiveUnion<{
        ElementNodeData: ElementNodeData;
        DeploymentElementNodeData: DeploymentElementNodeData;
        CompoundElementNodeData: CompoundElementNodeData;
        CompoundDeploymentNodeData: CompoundDeploymentNodeData;
        ViewGroupNodeData: ViewGroupNodeData;
        SequenceActorNodeData: SequenceActorNodeData;
        SequenceParallelAreaData: SequenceParallelAreaData;
    }>;
    export type Node<Type extends NodeType = NodeType> = Extract<AnyNode, {
        type: Type;
    }>;
    export type NodeProps<Type extends NodeType = NodeType> = BaseNodeProps<Node<Type>>;
    export type RelationshipEdgeData = Simplify<BaseEdgeData & NonOptional<Pick<DiagramEdge, 'id' | 'label' | 'labelBBox' | 'technology' | 'points' | 'dir' | 'color' | 'line' | 'head' | 'tail' | 'navigateTo' | 'astPath' | 'drifts'>> & {
        notes: MarkdownOrString | null;
        labelXY: XYPosition | null;
        controlPoints: XYPosition[] | undefined | null;
    }>;
    export type SequenceStepEdgeData = Simplify<BaseEdgeData & NonOptional<Pick<DiagramEdge, 'id' | 'label' | 'technology' | 'points' | 'dir' | 'color' | 'line' | 'head' | 'tail' | 'navigateTo' | 'astPath' | 'drifts'>> & {
        notes: MarkdownOrString | null;
        labelXY: XYPosition | null;
        labelBBox: BBox;
        controlPoints: XYPosition[] | undefined | null;
    }>;
    export type RelationshipEdge = BaseEdge<RelationshipEdgeData, 'relationship'>;
    export type SequenceStepEdge = BaseEdge<SequenceStepEdgeData, 'seq-step'>;
    export type AnyEdge = RelationshipEdge | SequenceStepEdge;
    export type EdgeType = AnyEdge['type'];
    export type Edge<Type extends EdgeType = EdgeType> = Extract<AnyEdge, {
        type: Type;
    }>;
    export type EdgeProps<Type extends EdgeType = EdgeType> = BaseEdgeProps<Edge<Type>>;
    export type EdgeData = ExclusiveUnion<{
        RelationshipEdgeData: RelationshipEdgeData;
        SequenceStepEdgeData: SequenceStepEdgeData;
    }>;
    export type NodeRenderer<T extends NodeType> = FunctionComponent<NodeProps<T>>;
    export type NodeRenderers = {
        [T in NodeType]: NodeRenderer<T>;
    };
    export type EdgeRenderer<T extends EdgeType> = FunctionComponent<EdgeProps<T>>;
    export type EdgeRenderers = {
        [T in EdgeType]: EdgeRenderer<T>;
    };
}

declare interface UnifiedArg<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> {
    context: TContext;
    event: TExpressionEvent;
    self: ActorRef<MachineSnapshot<TContext, TEvent, Record<string, AnyActorRef | undefined>, // TODO: this should be replaced with `TChildren`
    StateValue, string, unknown, TODO, // TMeta
    TODO>, TEvent, AnyEventObject>;
    system: AnyActorSystem;
}

declare type Unknown = t.aux.UnknownLayouted;

declare type Unknown_2 = t.aux.UnknownLayouted;

declare type Unknown_3 = aux.UnknownLayouted;

declare type UnknownAction = Action<MachineContext, EventObject, EventObject, ParameterizedObject['params'] | undefined, ProvidedActor, ParameterizedObject, ParameterizedObject, string, EventObject>;

declare type UnknownActorLogic = ActorLogic<any, // snapshot
any, // event
any, // input
AnyActorSystem, any>;

declare type UnknownGuard = UnknownReferencedGuard | UnknownInlineGuard;

declare type UnknownInlineGuard = Guard<MachineContext, EventObject, undefined, ParameterizedObject>;

declare type UnknownLayouted = t.aux.UnknownLayouted;

declare type UnknownReferencedGuard = Guard<MachineContext, EventObject, ParameterizedObject['params'], ParameterizedObject>;

/**
 * @returns The callback to change current project, or a no-op if no LikeC4ProjectsProvider is found.
 */
export declare function useChangeLikeC4Project(): (id: ProjectId) => void;

/**
 * Returns current view
 * Should be used only inside LikeC4Diagram
 */
export declare function useCurrentView(): LayoutedView;

/**
 * Returns current view id
 * Should be used only inside LikeC4Diagram
 */
export declare function useCurrentViewId(): ViewId;

/**
 * Hook to get the current view model from the context.
 * Throws an error if no view model is found in the context.
 *
 * @see useOptionalCurrentViewModel
 */
export declare function useCurrentViewModel(): CurrentViewModel;

export declare function useDiagram(): DiagramApi;

export declare function useDiagramActorRef(): DiagramActorRef;

/**
 * Read diagram context
 */
export declare function useDiagramContext<T = unknown>(selector: (context: DiagramContext) => T, compare?: (a: NoInfer<T>, b: NoInfer<T>) => boolean, deps?: DependencyList): T;

export declare function useDiagramEventHandlers(): DiagramEventHandlersContext;

export declare function useEnabledFeatures(): EnabledFeatures;

/**
 * @returns True if there are more than one project available in the context.
 */
export declare function useHasProjects(): boolean;

/**
 * @returns The LikeC4Model from context.
 * @throws If no LikeC4ModelProvider is found.
 */
export declare function useLikeC4Model<A extends Any_4 = t.aux.UnknownLayouted>(): LikeC4Model<A>;

/**
 * Returns current LikeC4 project.
 * Requires LikeC4ModelProvider in the tree.
 * Falls back to model's project if LikeC4ProjectsProvider is not available.
 */
export declare function useLikeC4Project(): LikeC4Project;

/**
 * @returns Current project id, as provided by LikeC4Model
 */
export declare function useLikeC4ProjectId(): ProjectId;

/**
 * @returns The list of available projects, or empty array if no projects are available.
 */
export declare function useLikeC4Projects(): ReadonlyArray<LikeC4Project>;

export declare function useLikeC4ProjectsContext(): LikeC4ProjectsContext;

export declare function useLikeC4Specification(): t.Specification<t.aux.UnknownLayouted>;

export declare function useLikeC4Styles(): LikeC4Styles;

export declare function useLikeC4ViewModel<A extends Any_4 = t.aux.UnknownLayouted>(viewId: t.aux.ViewId<A>): LikeC4ViewModel<A>;

/**
 * Subscribe to diagram emitted events
 * @example
 * ```tsx
 * useOnDiagramEvent('navigateTo', ({viewId}) => {
 *   console.log('Navigating to view', viewId)
 * })
 * ```
 */
export declare function useOnDiagramEvent<T extends DiagramEmittedEvents['type'] | '*'>(event: T, callback: (event: PickEmittedEvent<T>) => void, options?: {
    once?: boolean;
}): void;

export declare function useOptionalCurrentViewModel(): CurrentViewModel | null;

/**
 * @returns The LikeC4Model from context, or null if no LikeC4ModelProvider is found.
 */
export declare function useOptionalLikeC4Model<A extends t.aux.Any = UnknownLayouted>(): LikeC4Model<A> | null;

export declare function useSearchContext(): SearchContextValue;

/**
 * Differs from useState in that:
 * - it uses custom equal function (shallowEqual by default) to determine whether the state has changed.
 * - allows partial updates to the state
 */
export declare function useSetState<T extends object>(initialState: T | (() => T), equal?: (a: T, b: T) => boolean): readonly [T, (statePartial: NonEmptyObject<Partial<T>> | ((current: T) => NonEmptyObject<Partial<T>>)) => void];

export declare function useUpdateEffect<Callback extends EffectCallback = EffectCallback, Deps extends DependencyList = DependencyList>(callback: Callback, deps: Deps, equalityFn?: DependenciesComparator<Deps>, effectHook?: EffectHook<Callback, Deps>): void;

declare type Values<T> = T[keyof T];

export declare function ViewGroupNode(props: Types.NodeProps<'view-group'>): JSX.Element;

/**
 * Node that will be used to render the view group from the model.
 *
 * Custom node renderer receives these props:
 * - `nodeProps`: props from XYFlow
 * - `nodeModel`: LikeC4 {@link NodeModel.IsGroup}
 *
 * @see [Default implementation](https://github.com/likec4/likec4/blob/main/packages/diagram/src/likec4diagram/custom/nodes/nodes.tsx)
 *
 * @example
 * ```tsx
 * import {
 *   viewGroupNode,
 *   CompoundNodeContainer,
 *   CompoundTitle,
 *   DefaultHandles,
 * } from '@likec4/diagram/custom'
 *
 * const CustomViewGroupNode = viewGroupNode(({ nodeProps, nodeModel }) => (
 *   <CompoundNodeContainer nodeProps={nodeProps}>
 *     <CompoundTitle {...nodeProps} />
 *     <DefaultHandles />
 *   </CompoundNodeContainer>
 * ```
 */
export declare function viewGroupNode<A extends Any_5 = Unknown_3>(component: FC<ViewGroupNodeProps<A>>): Types.NodeRenderer<'view-group'>;

export declare type ViewGroupNodeProps<A extends Any_5 = Unknown_3> = {
    nodeProps: Types.NodeProps<'view-group'>;
    nodeModel: NodeModel.IsGroup<A>;
};

declare type ViewId_2<A> = t.aux.ViewId<A>;

declare type ViewId_4<A> = t.aux.ViewId<A>;

/**
 * Padding around the diagram
 *
 * @example
 * {
 *   top: '8px',
 *   right: '8px',
 *   bottom: '8px',
 *   left: '8px',
 * }
 *
 * {
 *   x: '16px',
 *   y: '16px',
 * }
 */
export declare type ViewPadding = PaddingWithUnit | ViewPaddings;

export declare type ViewPaddings = {
    top?: PaddingWithUnit;
    right?: PaddingWithUnit;
    bottom?: PaddingWithUnit;
    left?: PaddingWithUnit;
    x?: PaddingWithUnit;
    y?: PaddingWithUnit;
};

export { WhereOperator }

declare type WithData<D> = {
    data: D;
};

declare type WithDimmed = {
    data: {
        dimmed?: Base.Dimmed;
    };
};

declare type WithDynamicParams<TContext extends MachineContext, TExpressionEvent extends EventObject, T extends ParameterizedObject> = T extends any ? ConditionalRequired<{
    type: T['type'];
    params?: T['params'] | (({ context, event }: {
        context: TContext;
        event: TExpressionEvent;
    }) => T['params']);
}, undefined extends T['params'] ? false : true> : never;

declare type WithExtraButtons = {
    /**
     * Add extra action buttons
     * @example
     * ```tsx
     * <ElementActions
     *   extraButtons={[
     *     {
     *       key: 'extra',
     *       icon: <IconZoomScan />,
     *       onClick: (e) => {
     *         e.stopPropagation()
     *         console.log('extra action clicked')
     *       },
     *       },
     *     },
     *   ]}
     * />
     * ```
     */
    extraButtons?: ElementActionButtons.Item[];
};

declare type WithHovered = {
    data: {
        hovered?: boolean;
    };
};

declare type XYFLowInstance = ReactFlowInstance<RelationshipsBrowserTypes.AnyNode, RelationshipsBrowserTypes.Edge>;

declare type XYFlowInstance = ReactFlowInstance<Types.AnyNode, Types.AnyEdge>;

declare type XYFLowInstance_2 = ReactFlowInstance<RelationshipDetailsTypes.AnyNode, RelationshipDetailsTypes.Edge>;

declare type XYStoreApi = {
    getState: () => XYStoreState;
    setState: (state: Partial<XYStoreState> | ((state: XYStoreState) => Partial<XYStoreState>)) => void;
    subscribe: (listener: (state: XYStoreState, prevState: XYStoreState) => void) => () => void;
};

declare type XYStoreApi_2 = {
    getState: () => XYStoreState_2;
    setState: (state: XYStoreState_2) => void;
};

declare type XYStoreApi_3 = {
    getState: () => XYStoreState_3;
};

export declare type XYStoreState = ReactFlowState<Types.AnyNode, Types.AnyEdge>;

declare type XYStoreState_2 = ReactFlowState<RelationshipsBrowserTypes.AnyNode, RelationshipsBrowserTypes.Edge>;

declare type XYStoreState_3 = ReactFlowState<RelationshipDetailsTypes.AnyNode, RelationshipDetailsTypes.Edge>;

export { }