@discourse/types 2026.8.0-fb9247e0 → 2026.9.0-c0ef3a11

package/declarations/app/ui-kit/modifiers/d-drag-and-drop-external-target.d.ts

@@ -0,0 +1,80 @@
+import { type DropPosition, type DropTargetKernelArgs, type DropTargetKernelEvent, type DropTargetKernelFeedback } from "discourse/lib/-internals/drag-and-drop/drop-target-kernel";
+import { type ExternalDragKind, type ExternalDragPayload } from "discourse/lib/-internals/drag-and-drop/external-vocabulary";
+import type { Axis } from "discourse/lib/geometry";
+/** What a synchronous gate (`canDrop`, a `dropEffect` function) is asked about. */
+export type ExternalDropTargetFeedback = DropTargetKernelFeedback<ExternalDragPayload>;
+/** What a lifecycle callback is told. */
+export type ExternalDropTargetEvent = DropTargetKernelEvent<ExternalDragPayload>;
+/**
+ * The external drop target's named args, shared by the
+ * `dDragAndDropExternalTarget` modifier and
+ * {@link registerDragAndDropExternalTarget}.
+ */
+export interface DragAndDropExternalTargetArgs extends DropTargetKernelArgs<ExternalDragPayload> {
+    /**
+     * Filters which external drag kinds engage the target. Omit to accept any
+     * external drag.
+     */
+    accepts?: ExternalDragKind | ExternalDragKind[];
+    /** Setting this or `axis` opts the target into resolving a position at all. */
+    position?: DropPosition;
+    /**
+     * Without this or `position` the target is one destination, not a slot:
+     * callbacks get `position: null` and the indicator is the single
+     * `--drag-over-external` class.
+     */
+    axis?: Axis;
+}
+/**
+ * Imperative external drop-target registration, wrapped by the
+ * `dDragAndDropExternalTarget` modifier below; the counterpart of
+ * `registerDragAndDropTarget` for drags from outside the window.
+ *
+ * @param element - The element to register as a drop target.
+ * @param getArgsRef - Closure returning the latest args. Adapter callbacks read
+ *   it on every invocation, so arg changes apply without re-registering.
+ * @returns Cleanup; call it once on teardown.
+ */
+export declare function registerDragAndDropExternalTarget(element: Element, getArgsRef: () => DragAndDropExternalTargetArgs): import("@atlaskit/pragmatic-drag-and-drop/dist/types/internal-types").CleanupFn;
+/**
+ * Marks an element as a drop target for drags from outside the window: files,
+ * URLs, HTML or text from another application or tab. Every arg is documented
+ * on {@link DragAndDropExternalTargetArgs}, and the payload every callback
+ * receives on {@link ExternalDragPayload}.
+ *
+ * An accepted drop cancels the native event's default without stopping its
+ * propagation, so another `dragover` / `drop` handler still runs and sees
+ * `defaultPrevented`.
+ *
+ * Files:
+ *
+ * ```hbs
+ * <div {{dDragAndDropExternalTarget
+ *   accepts="files"
+ *   onDrop=this.handleFileDrop
+ * }}>...</div>
+ * ```
+ *
+ * A slot rather than a destination, with `axis` opting into a before/after
+ * position:
+ *
+ * ```hbs
+ * <li {{dDragAndDropExternalTarget
+ *   accepts="urls"
+ *   axis="vertical"
+ *   onDrop=this.insertBeside
+ * }}>...</li>
+ * ```
+ *
+ * An ancestor that should stay lit while a nested target is hovered reads
+ * `@service dragAndDrop` instead of registering a target of its own.
+ */
+declare const _default: import("ember-modifier").FunctionBasedModifier<{
+    Element: HTMLElement;
+    Args: {
+        Named: DragAndDropExternalTargetArgs;
+        Positional: [];
+    };
+}>;
+export default _default;
+//# sourceMappingURL=d-drag-and-drop-external-target.d.ts.map

package/declarations/app/ui-kit/modifiers/d-drag-and-drop-external-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"d-drag-and-drop-external-target.d.ts","sourceRoot":"","sources":["../../../../../discourse/app/ui-kit/modifiers/d-drag-and-drop-external-target.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAE9B,MAAM,2DAA2D,CAAC;AACnE,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EAEzB,MAAM,4DAA4D,CAAC;AACpE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAEnD,mFAAmF;AACnF,MAAM,MAAM,0BAA0B,GACpC,wBAAwB,CAAC,mBAAmB,CAAC,CAAC;AAEhD,yCAAyC;AACzC,MAAM,MAAM,uBAAuB,GACjC,qBAAqB,CAAC,mBAAmB,CAAC,CAAC;AAE7C;;;;GAIG;AACH,MAAM,WAAW,6BAA8B,SAAQ,oBAAoB,CAAC,mBAAmB,CAAC;IAC9F;;;OAGG;IACH,OAAO,CAAC,EAAE,gBAAgB,GAAG,gBAAgB,EAAE,CAAC;IAEhD,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,YAAY,CAAC;IAExB;;;;OAIG;IACH,IAAI,CAAC,EAAE,IAAI,CAAC;CACb;AAWD;;;;;;;;;GASG;AACH,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,6BAA6B,mFAahD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;;;;;;;;AACH,wBAKE"}

package/declarations/app/ui-kit/modifiers/d-drag-and-drop-monitor.d.ts

@@ -0,0 +1,80 @@
+import { type ElementEventBasePayload } from "@atlaskit/pragmatic-drag-and-drop/adapter/element-adapter";
+import { type NormalizedDragSource } from "discourse/lib/-internals/drag-and-drop/vocabulary";
+/**
+ * What a monitor callback is told: the normalized source and the drag's
+ * location history.
+ */
+export type DragMonitorEvent = Omit<ElementEventBasePayload, "source"> & {
+    source: NormalizedDragSource;
+};
+interface DDragAndDropMonitorSignature {
+    /**
+     * A monitor is global. The element only anchors the modifier's lifecycle.
+     */
+    Element: HTMLElement;
+    Args: {
+        Named: {
+            /**
+             * Only drags whose `type` matches are observed. Omit to observe any drag.
+             */
+            types?: string | string[];
+            /** A drag started. */
+            onDragStart?: (event: DragMonitorEvent) => void;
+            /** The drag moved. */
+            onDrag?: (event: DragMonitorEvent) => void;
+            /** The drag ended, whether or not it landed on a target. */
+            onDrop?: (event: DragMonitorEvent) => void;
+        };
+        Positional: [];
+    };
+}
+/**
+ * The monitor's named args, for a consumer driving
+ * {@link registerDragAndDropMonitor} imperatively rather than through the
+ * modifier.
+ */
+export type DragAndDropMonitorArgs = DDragAndDropMonitorSignature["Args"]["Named"];
+/**
+ * Imperative monitor registration; the `dDragAndDropMonitor` modifier below
+ * wraps it.
+ *
+ * @param getArgsRef - Closure returning the latest args. Callbacks read it on
+ *   every invocation; `types` is consulted once as a drag starts, so a change
+ *   applies from the next drag.
+ * @returns Cleanup; call it once on teardown.
+ */
+export declare function registerDragAndDropMonitor(getArgsRef: () => DragAndDropMonitorArgs): import("@atlaskit/pragmatic-drag-and-drop/dist/types/internal-types").CleanupFn;
+/**
+ * Observes the in-flight element drag regardless of drop targets, to react to
+ * its progress without making an element droppable. Every arg is documented on
+ * {@link DragAndDropMonitorArgs}.
+ *
+ * ```hbs
+ * <div {{dDragAndDropMonitor types=this.dragTypes onDrag=this.onDrag}}></div>
+ * ```
+ *
+ * @see The `dragAndDrop` service to read drag state reactively; rendering from
+ *   these callbacks duplicates what it keeps.
+ * @see `dDragDwell` for the packaged case of acting once a drag has hovered
+ *   one element for a delay.
+ */
+declare const _default: import("ember-modifier").FunctionBasedModifier<{
+    Element: HTMLElement;
+    Args: {
+        Named: {
+            /**
+             * Only drags whose `type` matches are observed. Omit to observe any drag.
+             */
+            types?: string | string[];
+            /** A drag started. */
+            onDragStart?: (event: DragMonitorEvent) => void;
+            /** The drag moved. */
+            onDrag?: (event: DragMonitorEvent) => void;
+            /** The drag ended, whether or not it landed on a target. */
+            onDrop?: (event: DragMonitorEvent) => void;
+        };
+        Positional: [];
+    };
+}>;
+export default _default;
+//# sourceMappingURL=d-drag-and-drop-monitor.d.ts.map

package/declarations/app/ui-kit/modifiers/d-drag-and-drop-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"d-drag-and-drop-monitor.d.ts","sourceRoot":"","sources":["../../../../../discourse/app/ui-kit/modifiers/d-drag-and-drop-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uBAAuB,EAE7B,MAAM,2DAA2D,CAAC;AAGnE,OAAO,EAEL,KAAK,oBAAoB,EAE1B,MAAM,mDAAmD,CAAC;AAE3D;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,uBAAuB,EAAE,QAAQ,CAAC,GAAG;IACvE,MAAM,EAAE,oBAAoB,CAAC;CAC9B,CAAC;AAEF,UAAU,4BAA4B;IACpC;;OAEG;IACH,OAAO,EAAE,WAAW,CAAC;IACrB,IAAI,EAAE;QACJ,KAAK,EAAE;YACL;;eAEG;YACH,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;YAE1B,sBAAsB;YACtB,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;YAEhD,sBAAsB;YACtB,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;YAE3C,4DAA4D;YAC5D,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;SAC5C,CAAC;QACF,UAAU,EAAE,EAAE,CAAC;KAChB,CAAC;CACH;AAED;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAChC,4BAA4B,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC;AAEhD;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,MAAM,sBAAsB,mFAezC;AAED;;;;;;;;;;;;;GAaG;;;;;YAlEG;;eAEG;oBACK,MAAM,GAAG,MAAM,EAAE;YAEzB,sBAAsB;0BACR,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI;YAE/C,sBAAsB;qBACb,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI;YAE1C,4DAA4D;qBACnD,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI;;;;;AAuDhD,wBAUE"}

package/declarations/app/ui-kit/modifiers/d-drag-and-drop-source.d.ts

@@ -0,0 +1,249 @@
+import type Owner from "@ember/owner";
+import Modifier, { type ArgsFor } from "ember-modifier";
+import type { DragInput, DragLocation } from "discourse/lib/-internals/drag-and-drop/drop-target-kernel";
+import { normalizeOwnedDragSource } from "discourse/lib/-internals/drag-and-drop/vocabulary";
+/**
+ * Renders a drag preview into an isolated, offscreen container the browser
+ * photographs. Return a cleanup function that tears the preview down.
+ */
+export type DragPreviewRenderer = (args: {
+    /** The offscreen container to render into. */
+    container: HTMLElement;
+    /** The source element the drag began on. */
+    element: HTMLElement;
+}) => (() => void) | void;
+/** The dragged source, as the lifecycle callbacks receive it. */
+export type DragSource = ReturnType<typeof normalizeOwnedDragSource>;
+interface DDragAndDropSourceSignature {
+    /** The element to mark draggable. */
+    Element: HTMLElement;
+    Args: {
+        Named: {
+            /**
+             * Discriminator string. Targets filter on this via their `accepts` arg, and
+             * it is stamped onto `source.data.type` for callbacks.
+             *
+             * Reserved: it overwrites any `type` the payload carries. The `dragAndDrop`
+             * service also identifies drags by it, so a source without one is invisible
+             * there.
+             */
+            type: string;
+            /**
+             * Static payload the source attaches to the drag, exposed as `source.data`
+             * in target callbacks. A `type` key on it is overwritten; see `type`.
+             */
+            data?: object;
+            /**
+             * Alternative to `data` for dynamic payloads. Called once just before
+             * `dragstart`. Its `type` key is overwritten the same way.
+             */
+            getInitialData?: () => object;
+            /**
+             * A custom native drag preview. An `Element` is photographed in place: the
+             * source element keeps the grab point as its hotspot, any other element
+             * uses its top-left. Defaults to the source element.
+             *
+             * A render function mounts a fresh preview into an isolated, offscreen
+             * container, so nothing around the source bleeds into the drag image.
+             */
+            dragPreview?: Element | DragPreviewRenderer;
+            /**
+             * CSS lengths (e.g. `{x: "1rem", y: "0.5rem"}`) that push the preview clear
+             * of the pointer. Applies only to the render-function `dragPreview`; an
+             * `Element` preview is placed by its own hotspot.
+             */
+            dragPreviewOffset?: {
+                x: string;
+                y: string;
+            };
+            /**
+             * Which drop operations this drag permits, written onto the native
+             * `dataTransfer` at `dragstart`. Defaults to `"move"`, which also stops the
+             * browser badging the pointer with its copy offer.
+             *
+             * A source whose drop duplicates wants `"copyMove"`: a target's
+             * `dropEffect` may only name an effect this permits.
+             */
+            effectAllowed?: DataTransfer["effectAllowed"];
+            /** Returning `false` blocks the drag from starting. */
+            canDrag?: (feedback: {
+                /**
+                 * The source as it stands before the drag begins. `data` is the arg
+                 * exactly as passed, before it is merged into the drag payload.
+                 */
+                source: {
+                    type?: string;
+                    data?: object;
+                    element: HTMLElement;
+                };
+                /** Where the pointer is. */
+                input: DragInput;
+            }) => boolean | void;
+            /** Fires once the drag is confirmed. */
+            onDragStart?: (event: {
+                /** The dragged source. */
+                source: DragSource;
+                /** Where the pointer is. */
+                input: DragInput;
+            }) => void;
+            /**
+             * Fires once at the end of every drag, landed or abandoned, and is where
+             * drag-time state gets undone. A source destroyed before the deferred
+             * dispatch fires does not receive it.
+             *
+             * Fires after the whole drop dispatch, target and monitor callbacks
+             * included, so shared dispatch state can be cleared here. Branch on the
+             * outcome with `location.current.dropTargets`.
+             */
+            onDragEnd?: (event: {
+                /** The dragged source. */
+                source: DragSource;
+                /** The drag's location history. */
+                location: DragLocation;
+            }) => void;
+            /**
+             * Fires only for a drag that ended on at least one drop target, so this is
+             * where the operation is performed. `onDragEnd` fires first, with the same
+             * `source` and `location`.
+             */
+            onDrop?: (event: {
+                /** The dragged source. */
+                source: DragSource;
+                /** The drag's location history. */
+                location: DragLocation;
+            }) => void;
+            /**
+             * An element inside this one that a drag must start from, so the rest stays
+             * free for selecting text and operating controls. Pass the element itself,
+             * captured with a modifier on the handle, not a selector.
+             *
+             * Changing it re-registers, so a ref that only arrives on a later render
+             * still takes effect. Omit it and the whole element initiates a drag.
+             *
+             * The handle carries `draggable="true"`; this element stays the body: it
+             * gets the state markers, is the target's `source.element`, and is what the
+             * default preview photographs.
+             */
+            dragHandle?: Element;
+            /**
+             * When `true`, the draggable registration is detached; a drag already in
+             * flight finishes and reports first. This, not `dragHandle`, is how to stop
+             * an element being dragged: a handle only moves where a drag may begin.
+             *
+             * Style and assert on `data-drag-source`, never on `draggable`: the
+             * attribute sits on whichever element was registered.
+             */
+            disabled?: boolean;
+        };
+        Positional: [];
+    };
+}
+/**
+ * What a registration still owes after being detached without cancelling, and
+ * the ways its owner can resume or let go of it.
+ *
+ * A registration waiting for its drag can be reclaimed when the modifier needs
+ * that same element again. Work holding only a scheduled dispatch cannot: its
+ * drag has ended and its registration has already been torn down.
+ */
+export interface DetachedSourceWork {
+    /**
+     * The element the registration was created on: the drag handle when one was
+     * given, the source element otherwise. A replacement registering on the same
+     * element can reclaim this work; one registering elsewhere must leave it
+     * waiting, because the underlying library dispatches an in-flight drag's end
+     * by looking this element up.
+     */
+    registeredElement: HTMLElement;
+    /**
+     * Re-adopts a registration still waiting for its drag, or returns `null` when
+     * only a scheduled dispatch remains.
+     */
+    reclaim: () => DragAndDropSourceCleanup | null;
+    /** The consumer is going away. Drops everything, dispatch included. */
+    abandon: () => void;
+    /**
+     * Whether anything is still owed. Goes false once the dispatch has fired and
+     * no teardown is waiting; a holder has no other way to know when to let go.
+     */
+    outstanding: () => boolean;
+}
+/**
+ * Tears a drag source registration down.
+ *
+ * `cancelPending` decides the fate of a drop dispatch already scheduled for the
+ * next task. `true` (the default) drops it: the consumer is going away. `false`
+ * keeps it: the registration is only being replaced and the consumer lives on.
+ *
+ * Returns the work still owed, or `null`. A caller that kept the dispatch must
+ * hold onto it: it is the only way left to reach the registration, and a
+ * reclaimed one is torn down by calling this again.
+ */
+export type DragAndDropSourceCleanup = (options?: {
+    cancelPending?: boolean;
+}) => DetachedSourceWork | null;
+/**
+ * The drag source's named args, for a consumer driving
+ * {@link registerDragAndDropSource} imperatively rather than through the
+ * modifier.
+ */
+export type DragAndDropSourceArgs = DDragAndDropSourceSignature["Args"]["Named"];
+/** Test-only: forget every source and unbind the listener between tests. */
+export declare function resetDragSourcesForTesting(): void;
+/**
+ * Wraps the underlying draggable registration with payload normalisation, the
+ * source's state markers, and the end-of-drag deferral. Exported so a consumer
+ * can register a source imperatively, beside `registerDragAndDropTarget`.
+ *
+ * End-of-drag callbacks are deferred to the next task, after the drop event has
+ * finished propagating: `onDragEnd` for every drag, then `onDrop` for one that
+ * landed on a target.
+ *
+ * One registration per element: the underlying library keys registrations by
+ * element, so a second one must wait for the first's cleanup.
+ *
+ * @param element - The element to mark draggable.
+ * @param getArgsRef - Closure returning the latest args, read on every library
+ *   callback, so changes apply without re-registering. `dragHandle` is read once
+ *   at registration; change it by re-registering.
+ * @returns Cleanup function; see {@link DragAndDropSourceCleanup}.
+ */
+export declare function registerDragAndDropSource(element: HTMLElement, getArgsRef: () => DragAndDropSourceArgs): DragAndDropSourceCleanup;
+/**
+ * Marks an element as a drag source for the Discourse drag-and-drop vocabulary,
+ * paired with `dDragAndDropTarget`. A thin wrapper around
+ * {@link registerDragAndDropSource}; every arg is documented on
+ * {@link DragAndDropSourceArgs}.
+ *
+ * ```hbs
+ * <li {{dDragAndDropSource
+ *   type="sidebar-link"
+ *   data=this.link
+ *   dragPreview=this.previewEl
+ *   canDrag=this.canDrag
+ *   onDragStart=this.handleDragStart
+ *   onDragEnd=this.clearDragState
+ *   onDrop=this.applyDrop
+ * }}>...</li>
+ * ```
+ *
+ * Stamps `data-drag-source` for the registration's lifetime and `--dragging`
+ * while a drag is active; the ui-kit drag-and-drop stylesheet gates its
+ * selectors on the attribute.
+ *
+ * Testing: see the note on `dDragAndDropTarget`; the same helpers drive both
+ * ends of a drag.
+ *
+ * Pointer-only. A native drag has no keyboard equivalent, so a surface built on
+ * this needs a keyboard route to the same operation beside it.
+ *
+ * @see The `dPointerDrag` modifier when there is no drop target and no payload:
+ *   a press that changes a value continuously is a different gesture.
+ */
+export default class DDragAndDropSourceModifier extends Modifier<DDragAndDropSourceSignature> {
+    #private;
+    constructor(owner: Owner, args: ArgsFor<DDragAndDropSourceSignature>);
+    modify(element: HTMLElement, _positional: [], args?: DragAndDropSourceArgs): void;
+}
+export {};
+//# sourceMappingURL=d-drag-and-drop-source.d.ts.map

package/declarations/app/ui-kit/modifiers/d-drag-and-drop-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"d-drag-and-drop-source.d.ts","sourceRoot":"","sources":["../../../../../discourse/app/ui-kit/modifiers/d-drag-and-drop-source.ts"],"names":[],"mappings":"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"}

package/declarations/app/ui-kit/modifiers/d-drag-and-drop-target.d.ts

@@ -0,0 +1,102 @@
+import { type DropTargetKernelArgs, type DropTargetKernelEvent, type DropTargetKernelFeedback } from "discourse/lib/-internals/drag-and-drop/drop-target-kernel";
+import { type NativeDragAdoption } from "discourse/lib/-internals/drag-and-drop/native-drag-adoption";
+import { type NormalizedDragSource } from "discourse/lib/-internals/drag-and-drop/vocabulary";
+export type { NativeDragAdoption, NativeDragAdoptionFeedback, } from "discourse/lib/-internals/drag-and-drop/native-drag-adoption";
+export { type DropEffect, type DropPosition, type DropPositionOptions, } from "discourse/lib/-internals/drag-and-drop/drop-target-kernel";
+/**
+ * The dragged source, normalized to the shape `dDragAndDropSource` publishes.
+ * An adopted drag also carries `native`, with the same reader API as an
+ * external target's payload; its `items` is always empty.
+ */
+export type DropTargetSource = NormalizedDragSource;
+/** What a synchronous gate (`canDrop`, a `dropEffect` function) is asked about. */
+export type DropTargetFeedback = DropTargetKernelFeedback<DropTargetSource>;
+/** What a lifecycle callback is told. */
+export type DropTargetEvent = DropTargetKernelEvent<DropTargetSource>;
+/**
+ * The drop target's named args, shared by the `dDragAndDropTarget` modifier
+ * and {@link registerDragAndDropTarget}.
+ */
+export interface DragAndDropTargetArgs extends DropTargetKernelArgs<DropTargetSource> {
+    /**
+     * The dragged source's `type` must be in this list for the target to engage.
+     * Omit to accept any registered source, unless `adopts` is set; then omission
+     * accepts only the adopted drags named there.
+     */
+    accepts?: string | string[];
+    /**
+     * Also accept browser-started drags from page content that no
+     * `dDragAndDropSource` registered, such as native links or images.
+     * Independent of `accepts`, since such content carries no source type;
+     * adopted payloads arrive on `source.native`.
+     *
+     * Adoption is resolved once for the page, not per target. At `dragstart` the
+     * first live adoption whose predicate matches names the drag, and every
+     * target listing that name accepts it.
+     *
+     * So two adoptions sharing a name must share a predicate. Declare one as a
+     * module constant and offer it from each target.
+     *
+     * Covers only what the browser started on this page. Pair it with
+     * `dDragAndDropExternalTarget` on the same element to take the same content
+     * dragged in from outside the window.
+     */
+    adopts?: NativeDragAdoption | NativeDragAdoption[];
+    /**
+     * `false` refuses a drop whose dragged element is this element. Defaults to
+     * `true`: an element that is both source and target has a meaningful drop
+     * onto itself, so excluding it is opt-in.
+     */
+    acceptsSelf?: boolean;
+}
+/**
+ * Imperative drop-target registration; the `dDragAndDropTarget` modifier
+ * below wraps it.
+ *
+ * @param element - The element to register as a drop target.
+ * @param getArgsRef - Closure returning the latest args. Library callbacks read
+ *   it on every invocation, so arg changes apply without re-registering.
+ * @returns Cleanup; call it once on teardown.
+ */
+export declare function registerDragAndDropTarget(element: Element, getArgsRef: () => DragAndDropTargetArgs): import("@atlaskit/pragmatic-drag-and-drop/dist/types/internal-types").CleanupFn;
+/**
+ * Marks an element as a drop target for `dDragAndDropSource` drags. Every arg
+ * is documented on {@link DragAndDropTargetArgs}. The indicator classes are
+ * styled in `app/assets/stylesheets/common/ui-kit/d-drag-and-drop.scss`.
+ *
+ * Position from the pointer against the element's midpoint:
+ *
+ * ```hbs
+ * <li {{dDragAndDropTarget accepts="sidebar-link" onDrop=this.reorder}}>...</li>
+ * ```
+ *
+ * A fixed position:
+ *
+ * ```hbs
+ * <div {{dDragAndDropTarget
+ *   accepts="block"
+ *   position="inside"
+ *   onDrop=this.applyMove
+ * }}></div>
+ * ```
+ *
+ * Testing: use `simulateDrag` from
+ * `discourse/tests/helpers/ui-kit/drag-and-drop-helper` in JS, and
+ * `SystemHelpers#drag_and_drop` in system specs; synthetic mouse drags stall.
+ *
+ * Element drags, and with `adopts` browser-started drags from page content;
+ * see `dDragAndDropExternalTarget` for payloads dragged in from outside the
+ * window.
+ *
+ * @see `dDragDwell` to act once a drag has hovered this element for a delay;
+ *   it composes beside this modifier without joining the target hierarchy.
+ */
+declare const _default: import("ember-modifier").FunctionBasedModifier<{
+    Element: HTMLElement;
+    Args: {
+        Named: DragAndDropTargetArgs;
+        Positional: [];
+    };
+}>;
+export default _default;
+//# sourceMappingURL=d-drag-and-drop-target.d.ts.map

package/declarations/app/ui-kit/modifiers/d-drag-and-drop-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"d-drag-and-drop-target.d.ts","sourceRoot":"","sources":["../../../../../discourse/app/ui-kit/modifiers/d-drag-and-drop-target.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAE9B,MAAM,2DAA2D,CAAC;AACnE,OAAO,EAEL,KAAK,kBAAkB,EAGxB,MAAM,6DAA6D,CAAC;AACrE,OAAO,EAGL,KAAK,oBAAoB,EAE1B,MAAM,mDAAmD,CAAC;AAE3D,YAAY,EACV,kBAAkB,EAClB,0BAA0B,GAC3B,MAAM,6DAA6D,CAAC;AAErE,OAAO,EACL,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,mBAAmB,GACzB,MAAM,2DAA2D,CAAC;AAEnE;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,oBAAoB,CAAC;AAEpD,mFAAmF;AACnF,MAAM,MAAM,kBAAkB,GAAG,wBAAwB,CAAC,gBAAgB,CAAC,CAAC;AAE5E,yCAAyC;AACzC,MAAM,MAAM,eAAe,GAAG,qBAAqB,CAAC,gBAAgB,CAAC,CAAC;AAEtE;;;GAGG;AACH,MAAM,WAAW,qBAAsB,SAAQ,oBAAoB,CAAC,gBAAgB,CAAC;IACnF;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAE5B;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,EAAE,kBAAkB,GAAG,kBAAkB,EAAE,CAAC;IAEnD;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAWD;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,qBAAqB,mFA+BxC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;;;;;;;;AACH,wBAKE"}