@formicoidea/labre-framework-uml 0.42.0

package/dist/toolbar/icons.d.ts

@@ -0,0 +1,440 @@
+/**
+ * The UML senior-button tile: a class box with its two compartment separators,
+ * beside a use-case ellipse — the two shapes the pack's two diagram families
+ * are recognised by, in one glyph.
+ *
+ * The one tile of this file, and unlike C4's it is NOT coloured: UML 2.5.1 has
+ * no stencil palette of its own (§7 draws in ink on paper), so the tile reads
+ * off the shared neutral scale exactly as the canvas does — `UML_INK` for the
+ * outlines, `UML_CARD` for the body, `UML_FRAME_INK` for the ellipse that
+ * stands a shade back (R33: never a grey hex literal here).
+ *
+ * Everything below it is a 24×24 monochrome outline drawn in `currentColor`,
+ * because a command glyph sits in a menu row and takes the row's colour.
+ */
+export declare const umlToolbarIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Class diagram — the frame of §C.2's diagram notation: a rectangle with the
+ * cut-corner name tag in its top-left corner, which is what tells a UML frame
+ * from any other box on the canvas.
+ */
+export declare const umlDiagramIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Subject — the rectangle a use-case diagram draws round the use cases that
+ * belong to one system (§18.1.1): a plain frame, its name along the top.
+ */
+export declare const umlSubjectIcon: import("lit-html").TemplateResult<2>;
+/** Class — the canonical three-compartment rectangle (§11.4.4). */
+export declare const umlClassIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Interface — the same box, with the guillemets keyword above the name
+ * (§10.4.2.1). Drawn as the two chevrons, which is the whole of what
+ * `«interface»` looks like at this size.
+ */
+export declare const umlInterfaceIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Enumeration — the box whose lower compartment is a LIST of literals
+ * (§10.2.4): three stacked rules rather than the two tiers of a class.
+ */
+export declare const umlEnumerationIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Object — an instance specification: the same box with its name UNDERLINED,
+ * which is the one notation that tells an instance from its classifier
+ * (§9.8.4).
+ */
+export declare const umlObjectIcon: import("lit-html").TemplateResult<2>;
+/** Package — the folder: a tab over a body (§12.2.4). */
+export declare const umlPackageIcon: import("lit-html").TemplateResult<2>;
+/** Note — the rectangle with its top-right corner turned down (§7.5.4). */
+export declare const umlNoteIcon: import("lit-html").TemplateResult<2>;
+/** Actor — the stick figure (§18.1.1). */
+export declare const umlActorIcon: import("lit-html").TemplateResult<2>;
+/** Use case — the ellipse, and nothing else (§18.1.1). */
+export declare const umlUseCaseIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Component — the rectangle with the two protruding tabs on its left edge
+ * (§11.6.4). The one classifier UML announces with a MARK rather than with a
+ * keyword, which is why the glyph is the mark and not a box with words in it.
+ */
+export declare const umlComponentIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Port — the small square straddling the border of what owns it (§11.3.4).
+ * FILLED, and drawn half in and half out, because the whole of what a port
+ * means is that it sits ON the boundary: a square inside the box would be a
+ * part, and one outside it would be a neighbour.
+ */
+export declare const umlPortIcon: import("lit-html").TemplateResult<2>;
+/** Provided interface — the LOLLIPOP: a stub ending in a full circle (§10.4.4). */
+export declare const umlProvidedInterfaceIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Required interface — the SOCKET: the same stub ending in the half circle that
+ * cups a ball (§10.4.4). Open on the side the ball comes from, which is what
+ * makes an assembly read as one joint rather than as two marks that happen to
+ * touch.
+ */
+export declare const umlRequiredInterfaceIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Artifact — the document with its corner turned down (§19.3.4), told from the
+ * note beside it by the lines written ON it: a note is a comment about the
+ * model, an artifact is a FILE that is part of the system.
+ */
+export declare const umlArtifactIcon: import("lit-html").TemplateResult<2>;
+/** Node — the bare 3D box: a computational resource, and nothing said of it. */
+export declare const umlNodeIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Device — the same cube, carrying the filled chip that says this node is a
+ * piece of HARDWARE (§19.4.4's `«device»`, as a mark rather than as a word,
+ * because a 24-unit glyph has no room for a keyword).
+ */
+export declare const umlDeviceIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Execution environment — the cube with the RUN mark on its face: software that
+ * other software is deployed into (§19.4.4's `«executionEnvironment»`), which is
+ * exactly the distinction from the device beside it.
+ */
+export declare const umlExecutionEnvironmentIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Action — the round-cornered rectangle of §15.2.4, and the one shape of an
+ * activity diagram that holds a sentence. The corners are the whole of what
+ * tells it from a class box at this size, so they are drawn generously.
+ */
+export declare const umlActionIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Initial node — the FILLED disc where a flow begins (§15.3.4), with the first
+ * arrow leaving it. One per region, and the arrow is what says the disc is a
+ * start rather than a junction.
+ */
+export declare const umlInitialIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Activity final — the BULLSEYE that ends the whole activity (§15.3.4): every
+ * token in it stops, not only the one that arrived.
+ */
+export declare const umlActivityFinalIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Flow final — the circle with the CROSS through it (§15.3.4): this one token
+ * ends here and the rest of the activity carries on. The distinction the
+ * bullseye beside it cannot draw, and the one everybody forgets exists.
+ */
+export declare const umlFlowFinalIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Decision — the diamond one token leaves by ONE branch (§15.3.4). The two
+ * outgoing stubs are the glyph's argument: a bare diamond is a shape, a diamond
+ * with a choice coming out of it is a decision.
+ */
+export declare const umlDecisionIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Fork — the filled BAR one token leaves by every branch at once (§15.3.4),
+ * which is exactly the difference from the diamond above: concurrency, not
+ * choice. Drawn with the two outgoing lines, because a bar on its own is a rule.
+ */
+export declare const umlForkIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Object node — the plain rectangle DATA travels through (§15.4.4), drawn with
+ * the flow entering and leaving it. The arrows are not decoration: an object
+ * node is told from every other rectangle on the sheet by sitting ON a flow.
+ */
+export declare const umlObjectNodeIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Send signal — the CONVEX pentagon of §16.3.4: a box with its right edge
+ * pushed out into a point, which is the message leaving.
+ */
+export declare const umlSendSignalIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Accept event — the CONCAVE pentagon of §16.10.4: the same box with its LEFT
+ * edge notched IN, the cup the message arrives into. The pair is the one thing
+ * on an activity diagram a reader tells apart by silhouette alone, which is why
+ * the two glyphs are deliberately mirror images.
+ */
+export declare const umlAcceptEventIcon: import("lit-html").TemplateResult<2>;
+/** Time event — the HOURGLASS that fires when its moment comes (§16.10.4). */
+export declare const umlTimeEventIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Partition — the swimlane (§15.6.4): two bands with a name strip on top, which
+ * is what a vertical partition set actually looks like. The strip is the half
+ * of the drawing that matters — a lane with no heading is a line.
+ */
+export declare const umlPartitionIcon: import("lit-html").TemplateResult<2>;
+/**
+ * State — the round-cornered box with a NAME BAND (§14.2.4). The separator is
+ * what tells it from the action it shares a silhouette with: an action is one
+ * sentence, a state is a name over the `entry` / `do` / `exit` lines below it.
+ */
+export declare const umlStateIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Final state — the bullseye that ends the machine (§14.2.4).
+ *
+ * The SAME drawing as the activity final beside it, deliberately: §14.2.4 and
+ * §15.3.4 both draw a filled circle inside a ring, and inventing a difference
+ * would be this pack teaching a notation UML does not have. What separates them
+ * is the role and the sheet they are legal on — a final state on an activity
+ * diagram is what the per-frame admissibility lists refuse.
+ */
+export declare const umlFinalStateIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Choice — the diamond a transition branches at (§14.2.4), and the state
+ * machine's twin of the activity decision: the same drawing, on the other
+ * diagram, for the same reason the two finals share theirs.
+ */
+export declare const umlChoiceIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Junction — the small filled dot several transitions MERGE at (§14.2.4). The
+ * three incoming stubs are what tells it from the initial node's disc: an
+ * initial has one arrow out and nothing in, a junction is a knot.
+ */
+export declare const umlJunctionIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Shallow history — the `H` in a circle (§14.2.4): re-enter this region at the
+ * sub-state it was last in.
+ */
+export declare const umlShallowHistoryIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Deep history — the same `H` with the ASTERISK (§14.2.4): restore the whole
+ * nested configuration, not only the top level. One star apart, which is why
+ * the circle is drawn smaller here to make room for it rather than redrawn.
+ */
+export declare const umlDeepHistoryIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Entry point — the hollow circle ON a composite state's border (§14.2.4): the
+ * named way IN. The border is drawn because the mark means nothing off it.
+ */
+export declare const umlEntryPointIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Exit point — the same circle on the same border, CROSSED (§14.2.4): the named
+ * way out.
+ */
+export declare const umlExitPointIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Terminate — the bare CROSS (§14.2.4): the machine stops here and nothing
+ * else runs. No circle round it, which is the whole of what tells it from the
+ * flow final and from the exit point.
+ */
+export declare const umlTerminateIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Region — the composite state (§14.2.4): the rounded box with its name band
+ * and a sub-machine inside it. The two little states are the point — a region
+ * is a container, and a glyph of an empty rounded box would be the state's.
+ */
+export declare const umlRegionIcon: import("lit-html").TemplateResult<2>;
+/** Association — a plain solid line, undirected (§11.5.4). */
+export declare const umlAssociationIcon: import("lit-html").TemplateResult<2>;
+/** Aggregation — the HOLLOW diamond at the whole's end (§11.5.4). */
+export declare const umlAggregationIcon: import("lit-html").TemplateResult<2>;
+/** Composition — the same diamond, FILLED (§11.5.4). */
+export declare const umlCompositionIcon: import("lit-html").TemplateResult<2>;
+/** Generalization — a solid line with a hollow triangle on the general end. */
+export declare const umlGeneralizationIcon: import("lit-html").TemplateResult<2>;
+/** Realization — the same hollow triangle, on a DASHED line (§10.4.2.1). */
+export declare const umlRealizationIcon: import("lit-html").TemplateResult<2>;
+/** Dependency — a dashed line with an open arrowhead (§7.8.4). */
+export declare const umlDependencyIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Anchor — the DASHED line with no head at all, which is how a note is tied to
+ * what it comments on (§7.5.4). The only relationship of this pack that says
+ * nothing about direction, and the glyph says so by carrying no arrow.
+ */
+export declare const umlAnchorIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Include — a dependency whose keyword is `«include»`, drawn with the chevrons
+ * over the line so the two use-case relationships are told apart at a glance
+ * rather than by their tooltip (§18.1.4).
+ */
+export declare const umlIncludeIcon: import("lit-html").TemplateResult<2>;
+/** Extend — the same dashed arrow, with the chevrons pointing outward. */
+export declare const umlExtendIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Deploy — the dashed dependency arrow of §19.2.4, pointed at the NODE it lands
+ * on. The box above it is the target, not decoration: `«deploy»` and
+ * `«manifest»` are the same line, and the only thing that can tell them apart in
+ * a menu row is what sits at the far end.
+ */
+export declare const umlDeployIcon: import("lit-html").TemplateResult<2>;
+/** Manifest — the same arrow, landing on the artifact's own document glyph. */
+export declare const umlManifestIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Communication path — a plain solid line between two NODES (§19.4.4). The two
+ * boxes are what separates it from the association it is drawn exactly like: a
+ * network link joins machines, and it claims no direction at either end.
+ */
+export declare const umlCommunicationPathIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Control flow — the SOLID line with an open arrowhead (§15.2.4). The look no
+ * structural relationship wears: a behaviour diagram states an order and
+ * therefore always points.
+ */
+export declare const umlControlFlowIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Object flow — the same arrow, with the DATA on it. §15.2.4 draws no line of
+ * its own for an object flow and tells it apart by what the flow runs between,
+ * so the glyph says that rather than inventing a dash: the little rectangle is
+ * the object node the line passes through.
+ */
+export declare const umlObjectFlowIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Transition — the same arrow again (§14.2.4.8), carrying its LABEL: the
+ * `trigger [guard] / effect` written over the line is the whole of what a state
+ * machine's arrow says, and the only thing that separates this glyph from the
+ * control flow above it.
+ */
+export declare const umlTransitionIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Lifeline — the named head with the dashed spine falling out of it (§17.2.4).
+ *
+ * The dashes are the half that matters: a head on its own is a class box, and
+ * what makes a lifeline a lifeline is that time runs down the line under it.
+ */
+export declare const umlLifelineIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Execution specification — the thin BAR sat on a spine (§17.2.4): the stretch
+ * of the diagram during which this participant is doing something. Drawn ON the
+ * dashes, because a bar floating beside a lifeline means nothing at all.
+ */
+export declare const umlExecutionIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Destruction occurrence — the CROSS that ends a lifeline (§17.2.4). The spine
+ * stops at it, which is the whole statement: nothing happens to this
+ * participant afterwards.
+ */
+export declare const umlDestructionIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Combined fragment — the rectangle with the PENTAGON tag in its corner
+ * (§17.6.4), and the dashed rule that separates two operands.
+ *
+ * The cut corner and the dashed line are the two things the notation draws and
+ * nothing else does: a plain rectangle is a subject, a region or a partition.
+ */
+export declare const umlFragmentIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Interaction use — the same frame with `ref` in its tag (§17.7.4), drawn here
+ * as the ARROW out of the box: the glyph has no room for three letters at 24
+ * units, and "this happens somewhere else" is what the reader has to take from
+ * it. No dashed rule, which is the one thing that tells it from the fragment
+ * above: a `ref` has no operands to separate.
+ */
+export declare const umlInteractionUseIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Synchronous message — a solid line with a FILLED arrowhead (§17.4.4): the
+ * caller waits, and the black triangle is the whole of what says so.
+ */
+export declare const umlMessageSyncIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Asynchronous message — the same solid line with an OPEN stick arrowhead: the
+ * caller does not wait. The one pair in this pack where getting the head's fill
+ * backwards inverts the meaning of every call on the sheet.
+ */
+export declare const umlMessageAsyncIcon: import("lit-html").TemplateResult<2>;
+/** Reply — the open head on a DASHED line, travelling back (§17.4.4). */
+export declare const umlMessageReplyIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Create message — the dashed arrow landing on a lifeline's HEAD (§17.4.4).
+ * The box at the end is the point: a create message is the one message that
+ * does not arrive on a spine, because the spine does not exist until it does.
+ */
+export declare const umlMessageCreateIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Delete message — the call that ends at the X (§17.4.4). The solid line with
+ * the filled head is the ordinary call; the cross is what makes it a deletion,
+ * and it is drawn here because the LINE alone cannot say so.
+ */
+export declare const umlMessageDeleteIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Export as PlantUML — the generic "document, going out" glyph the other packs
+ * use for an export, restated here rather than imported from BPMN's or C4's
+ * private module: a cross-framework import for one path would tie this pack's
+ * build to theirs, and the three are meant to ship separately.
+ */
+export declare const umlExportPlantumlIcon: import("lit-html").TemplateResult<2>;
+/** Export as XMI — the same document, marked as the angle-bracketed one. */
+export declare const umlExportXmiIcon: import("lit-html").TemplateResult<2>;
+/**
+ * The three IMPORTS — the same page glyph as the exports beside them, with the
+ * arrow turned round (`docs/adr/0019`).
+ *
+ * Deliberately the same family as `bpmnImportXmlIcon`: a file becoming a board
+ * is one gesture across this library, and a user who has met it once in BPMN
+ * should not have to learn a second picture for it in UML. What differs between
+ * the three is the mark under the page — the arrow alone for PlantUML, the
+ * angle brackets for XMI, and the two connected boxes for draw.io, which is
+ * the only one of the three whose file is a DRAWING.
+ */
+export declare const umlImportPlantumlIcon: import("lit-html").TemplateResult<2>;
+/** Import XMI — the page arriving, marked as the angle-bracketed document. */
+export declare const umlImportXmiIcon: import("lit-html").TemplateResult<2>;
+/** Import draw.io — two connected boxes, which is what the file actually holds. */
+export declare const umlImportDrawioIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Every command glyph of the TOOLBOX, keyed by its `iconKey`.
+ *
+ * Registered together with the commands themselves
+ * (`CommandExtension(umlCommands, umlCommandIcons)`), so a key a descriptor
+ * names and this record does not hold renders as nothing.
+ *
+ * The two export glyphs are deliberately NOT here and are added to
+ * {@link umlToolbarIcon}'s sibling `umlCommandIcons` in `commands.ts` instead:
+ * this record is the glyphs of things UML DRAWS, and an export draws nothing.
+ */
+export declare const UML_TOOLBOX_ICONS: {
+    readonly 'uml.diagram': import("lit-html").TemplateResult<2>;
+    readonly 'uml.class': import("lit-html").TemplateResult<2>;
+    readonly 'uml.interface': import("lit-html").TemplateResult<2>;
+    readonly 'uml.enumeration': import("lit-html").TemplateResult<2>;
+    readonly 'uml.object': import("lit-html").TemplateResult<2>;
+    readonly 'uml.package': import("lit-html").TemplateResult<2>;
+    readonly 'uml.note': import("lit-html").TemplateResult<2>;
+    readonly 'uml.actor': import("lit-html").TemplateResult<2>;
+    readonly 'uml.use-case': import("lit-html").TemplateResult<2>;
+    readonly 'uml.subject': import("lit-html").TemplateResult<2>;
+    readonly 'uml.association': import("lit-html").TemplateResult<2>;
+    readonly 'uml.aggregation': import("lit-html").TemplateResult<2>;
+    readonly 'uml.composition': import("lit-html").TemplateResult<2>;
+    readonly 'uml.generalization': import("lit-html").TemplateResult<2>;
+    readonly 'uml.realization': import("lit-html").TemplateResult<2>;
+    readonly 'uml.dependency': import("lit-html").TemplateResult<2>;
+    readonly 'uml.anchor': import("lit-html").TemplateResult<2>;
+    readonly 'uml.include': import("lit-html").TemplateResult<2>;
+    readonly 'uml.extend': import("lit-html").TemplateResult<2>;
+    readonly 'uml.component': import("lit-html").TemplateResult<2>;
+    readonly 'uml.port': import("lit-html").TemplateResult<2>;
+    readonly 'uml.provided-interface': import("lit-html").TemplateResult<2>;
+    readonly 'uml.required-interface': import("lit-html").TemplateResult<2>;
+    readonly 'uml.artifact': import("lit-html").TemplateResult<2>;
+    readonly 'uml.node': import("lit-html").TemplateResult<2>;
+    readonly 'uml.device': import("lit-html").TemplateResult<2>;
+    readonly 'uml.execution-environment': import("lit-html").TemplateResult<2>;
+    readonly 'uml.deploy': import("lit-html").TemplateResult<2>;
+    readonly 'uml.manifest': import("lit-html").TemplateResult<2>;
+    readonly 'uml.communication-path': import("lit-html").TemplateResult<2>;
+    readonly 'uml.action': import("lit-html").TemplateResult<2>;
+    readonly 'uml.initial': import("lit-html").TemplateResult<2>;
+    readonly 'uml.activity-final': import("lit-html").TemplateResult<2>;
+    readonly 'uml.flow-final': import("lit-html").TemplateResult<2>;
+    readonly 'uml.decision': import("lit-html").TemplateResult<2>;
+    readonly 'uml.fork': import("lit-html").TemplateResult<2>;
+    readonly 'uml.object-node': import("lit-html").TemplateResult<2>;
+    readonly 'uml.send-signal': import("lit-html").TemplateResult<2>;
+    readonly 'uml.accept-event': import("lit-html").TemplateResult<2>;
+    readonly 'uml.time-event': import("lit-html").TemplateResult<2>;
+    readonly 'uml.partition': import("lit-html").TemplateResult<2>;
+    readonly 'uml.state': import("lit-html").TemplateResult<2>;
+    readonly 'uml.final-state': import("lit-html").TemplateResult<2>;
+    readonly 'uml.choice': import("lit-html").TemplateResult<2>;
+    readonly 'uml.junction': import("lit-html").TemplateResult<2>;
+    readonly 'uml.shallow-history': import("lit-html").TemplateResult<2>;
+    readonly 'uml.deep-history': import("lit-html").TemplateResult<2>;
+    readonly 'uml.entry-point': import("lit-html").TemplateResult<2>;
+    readonly 'uml.exit-point': import("lit-html").TemplateResult<2>;
+    readonly 'uml.terminate': import("lit-html").TemplateResult<2>;
+    readonly 'uml.region': import("lit-html").TemplateResult<2>;
+    readonly 'uml.control-flow': import("lit-html").TemplateResult<2>;
+    readonly 'uml.object-flow': import("lit-html").TemplateResult<2>;
+    readonly 'uml.transition': import("lit-html").TemplateResult<2>;
+    readonly 'uml.lifeline': import("lit-html").TemplateResult<2>;
+    readonly 'uml.execution': import("lit-html").TemplateResult<2>;
+    readonly 'uml.destruction': import("lit-html").TemplateResult<2>;
+    readonly 'uml.fragment': import("lit-html").TemplateResult<2>;
+    readonly 'uml.interaction-use': import("lit-html").TemplateResult<2>;
+    readonly 'uml.message-sync': import("lit-html").TemplateResult<2>;
+    readonly 'uml.message-async': import("lit-html").TemplateResult<2>;
+    readonly 'uml.message-reply': import("lit-html").TemplateResult<2>;
+    readonly 'uml.message-create': import("lit-html").TemplateResult<2>;
+    readonly 'uml.message-delete': import("lit-html").TemplateResult<2>;
+};