@synnaxlabs/client 0.56.2 → 0.57.1

package/src/lineplot/actions.gen.ts

@@ -0,0 +1,880 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+// Code generated by Oracle. DO NOT EDIT.
+import { color, spatial, text, zod } from "@synnaxlabs/x";
+import { type Draft } from "immer";
+import { z } from "zod";
+
+import { actions } from "@/actions";
+import { channel } from "@/channel";
+import {
+  axisKeyZ,
+  downsampleModeZ,
+  keyZ,
+  type LinePlot,
+  linePlotZ,
+  lineZ,
+  manualBoundsZ,
+  ruleZ,
+  tickTypeZ,
+  xAxisKeyZ,
+  yAxisKeyZ,
+} from "@/lineplot/types.gen";
+
+/**
+ * Create replaces the document with the given created state. Emitted by the Core on
+ * create so remote caches ingest new documents; clients never dispatch it.
+ */
+export const createPayloadZ = z.object({
+  linePlot: linePlotZ,
+});
+
+export type CreatePayload = z.infer<typeof createPayloadZ>;
+
+/** Rename renames the line plot. */
+export const renamePayloadZ = z.object({
+  name: z.string(),
+});
+
+export type RenamePayload = z.infer<typeof renamePayloadZ>;
+
+/** SetTitleVisible sets whether the plot title is shown above the plot. */
+export const setTitleVisiblePayloadZ = z.object({
+  visible: z.boolean(),
+});
+
+export type SetTitleVisiblePayload = z.infer<typeof setTitleVisiblePayloadZ>;
+
+/** SetTitleLevel sets the typography level of the plot title. */
+export const setTitleLevelPayloadZ = z.object({
+  level: text.levelZ,
+});
+
+export type SetTitleLevelPayload = z.infer<typeof setTitleLevelPayloadZ>;
+
+/** SetLegendHidden sets whether the plot legend is hidden. */
+export const setLegendHiddenPayloadZ = z.object({
+  hidden: z.boolean(),
+});
+
+export type SetLegendHiddenPayload = z.infer<typeof setLegendHiddenPayloadZ>;
+
+/**
+ * SetLegendPosition sets the anchor position of the plot legend within the container.
+ */
+export const setLegendPositionPayloadZ = z.object({
+  position: spatial.stickyXYZ,
+});
+
+export type SetLegendPositionPayload = z.infer<typeof setLegendPositionPayloadZ>;
+
+/**
+ * AddChannel appends the channel to the channels array bound to the y-axis named by
+ * axis_key. No-op when the channel is already present.
+ */
+export const addChannelPayloadZ = z.object({
+  axisKey: yAxisKeyZ,
+  channel: channel.keyZ,
+});
+
+export type AddChannelPayload = z.infer<typeof addChannelPayloadZ>;
+
+/**
+ * RemoveChannel removes the channel from the y-axis named by axis_key. No-op when the
+ * channel is not present.
+ */
+export const removeChannelPayloadZ = z.object({
+  axisKey: yAxisKeyZ,
+  channel: channel.keyZ,
+});
+
+export type RemoveChannelPayload = z.infer<typeof removeChannelPayloadZ>;
+
+/**
+ * SetChannels replaces the entire set of channels bound to the y-axis named by axis_key
+ * with channels. Channels absent from the new set are removed and their lines dropped;
+ * channels not previously present are added. Existing channels keep their line styling.
+ */
+export const setChannelsPayloadZ = z.object({
+  axisKey: yAxisKeyZ,
+  channels: channel.keyZ.array().default(() => []),
+});
+
+export type SetChannelsPayload = z.infer<typeof setChannelsPayloadZ>;
+
+/** SetXChannel replaces the single channel bound to the x-axis named by axis_key. */
+export const setXChannelPayloadZ = z.object({
+  axisKey: xAxisKeyZ,
+  channel: channel.keyZ,
+});
+
+export type SetXChannelPayload = z.infer<typeof setXChannelPayloadZ>;
+
+/**
+ * AddRange appends the range key to the ranges array bound to the x-axis named by
+ * axis_key. No-op when the range is already present.
+ */
+export const addRangePayloadZ = z.object({
+  axisKey: xAxisKeyZ,
+  range: z.string(),
+});
+
+export type AddRangePayload = z.infer<typeof addRangePayloadZ>;
+
+/**
+ * RemoveRange removes the range key from the x-axis named by axis_key. No-op when the
+ * range is not present.
+ */
+export const removeRangePayloadZ = z.object({
+  axisKey: xAxisKeyZ,
+  range: z.string(),
+});
+
+export type RemoveRangePayload = z.infer<typeof removeRangePayloadZ>;
+
+/**
+ * SetRanges replaces the entire set of range keys bound to the x-axis named by axis_key
+ * with ranges. Ranges absent from the new set are removed and their lines dropped;
+ * ranges not previously present are added. Existing ranges keep their line styling.
+ */
+export const setRangesPayloadZ = z.object({
+  axisKey: xAxisKeyZ,
+  ranges: z
+    .string()
+    .array()
+    .default(() => []),
+});
+
+export type SetRangesPayload = z.infer<typeof setRangesPayloadZ>;
+
+/** SetAxisLabel sets the label rendered along the axis identified by key. */
+export const setAxisLabelPayloadZ = z.object({
+  key: axisKeyZ,
+  label: z.string(),
+});
+
+export type SetAxisLabelPayload = z.infer<typeof setAxisLabelPayloadZ>;
+
+/** SetAxisLabelDirection sets the orientation in which the axis label is laid out. */
+export const setAxisLabelDirectionPayloadZ = z.object({
+  key: axisKeyZ,
+  labelDirection: spatial.directionZ,
+});
+
+export type SetAxisLabelDirectionPayload = z.infer<
+  typeof setAxisLabelDirectionPayloadZ
+>;
+
+/** SetAxisLabelLevel sets the typography level of the axis label. */
+export const setAxisLabelLevelPayloadZ = z.object({
+  key: axisKeyZ,
+  labelLevel: text.levelZ,
+});
+
+export type SetAxisLabelLevelPayload = z.infer<typeof setAxisLabelLevelPayloadZ>;
+
+/**
+ * SetAxisBounds sets the axis value-space window together with its per-edge manual
+ * override flags. The two travel together: fixing a bound enables the manual override
+ * for that edge, so callers set both at once.
+ */
+export const setAxisBoundsPayloadZ = z.object({
+  key: axisKeyZ,
+  bounds: spatial.boundsZ(),
+  manualBounds: manualBoundsZ,
+});
+
+export type SetAxisBoundsPayload = z.infer<typeof setAxisBoundsPayloadZ>;
+
+/** SetAxisTickSpacing sets the target pixel distance between adjacent tick marks. */
+export const setAxisTickSpacingPayloadZ = z.object({
+  key: axisKeyZ,
+  tickSpacing: z.number(),
+});
+
+export type SetAxisTickSpacingPayload = z.infer<typeof setAxisTickSpacingPayloadZ>;
+
+/**
+ * SetAxisType sets the axis tick label style. Null resets it to the default, which the
+ * Console derives (linear, or time for a timestamp-bound x-axis) at render time.
+ */
+export const setAxisTypePayloadZ = z.object({
+  key: axisKeyZ,
+  type: tickTypeZ.optional(),
+});
+
+export type SetAxisTypePayload = z.infer<typeof setAxisTypePayloadZ>;
+
+/**
+ * SetLineLabel sets the label of the line identified by key. Null resets it to derive
+ * from the channel name at render time.
+ */
+export const setLineLabelPayloadZ = z.object({
+  key: z.string(),
+  label: z.string().optional(),
+});
+
+export type SetLineLabelPayload = z.infer<typeof setLineLabelPayloadZ>;
+
+/**
+ * SetLineColor sets the color of the line identified by key. Null resets it to a
+ * palette color assigned at render time.
+ */
+export const setLineColorPayloadZ = z.object({
+  key: z.string(),
+  color: color.colorZ.optional(),
+});
+
+export type SetLineColorPayload = z.infer<typeof setLineColorPayloadZ>;
+
+/**
+ * SetLineStrokeWidth sets the stroke width, in pixels, of the line identified by key.
+ */
+export const setLineStrokeWidthPayloadZ = z.object({
+  key: z.string(),
+  strokeWidth: z.number(),
+});
+
+export type SetLineStrokeWidthPayload = z.infer<typeof setLineStrokeWidthPayloadZ>;
+
+/** SetLineDownsample sets the downsample factor of the line identified by key. */
+export const setLineDownsamplePayloadZ = z.object({
+  key: z.string(),
+  downsample: z.uint32(),
+});
+
+export type SetLineDownsamplePayload = z.infer<typeof setLineDownsamplePayloadZ>;
+
+/**
+ * SetLineDownsampleMode sets how the downsample factor is applied for the line
+ * identified by key.
+ */
+export const setLineDownsampleModePayloadZ = z.object({
+  key: z.string(),
+  downsampleMode: downsampleModeZ,
+});
+
+export type SetLineDownsampleModePayload = z.infer<
+  typeof setLineDownsampleModePayloadZ
+>;
+
+/**
+ * SetLine replaces the line with line.key in place, inserting it when no such line
+ * exists. The fine-grained setLine* actions cover per-field edits; this full-object
+ * form restores a line dropped by reconciliation.
+ */
+export const setLinePayloadZ = z.object({
+  line: lineZ,
+});
+
+export type SetLinePayload = z.infer<typeof setLinePayloadZ>;
+
+/**
+ * SetRule inserts the rule if no rule with rule.key exists, otherwise replaces the
+ * existing entry in place. The fine-grained setRule* actions cover per-field edits;
+ * this full-object form creates a rule or restores one removed by another action's
+ * inverse.
+ */
+export const setRulePayloadZ = z.object({
+  rule: ruleZ,
+});
+
+export type SetRulePayload = z.infer<typeof setRulePayloadZ>;
+
+/** SetRuleLabel sets the label of the rule identified by key. */
+export const setRuleLabelPayloadZ = z.object({
+  key: z.string(),
+  label: z.string(),
+});
+
+export type SetRuleLabelPayload = z.infer<typeof setRuleLabelPayloadZ>;
+
+/**
+ * SetRuleColor sets the color of the rule identified by key. Null resets it to a
+ * default color assigned at render time.
+ */
+export const setRuleColorPayloadZ = z.object({
+  key: z.string(),
+  color: color.colorZ.optional(),
+});
+
+export type SetRuleColorPayload = z.infer<typeof setRuleColorPayloadZ>;
+
+/** SetRuleAxis sets the axis the rule identified by key is anchored to. */
+export const setRuleAxisPayloadZ = z.object({
+  key: z.string(),
+  axis: axisKeyZ,
+});
+
+export type SetRuleAxisPayload = z.infer<typeof setRuleAxisPayloadZ>;
+
+/** SetRuleLineWidth sets the line width, in pixels, of the rule identified by key. */
+export const setRuleLineWidthPayloadZ = z.object({
+  key: z.string(),
+  lineWidth: z.number(),
+});
+
+export type SetRuleLineWidthPayload = z.infer<typeof setRuleLineWidthPayloadZ>;
+
+/** SetRuleLineDash sets the dash length, in pixels, of the rule identified by key. */
+export const setRuleLineDashPayloadZ = z.object({
+  key: z.string(),
+  lineDash: z.number(),
+});
+
+export type SetRuleLineDashPayload = z.infer<typeof setRuleLineDashPayloadZ>;
+
+/** SetRuleUnits sets the unit label of the rule identified by key. */
+export const setRuleUnitsPayloadZ = z.object({
+  key: z.string(),
+  units: z.string(),
+});
+
+export type SetRuleUnitsPayload = z.infer<typeof setRuleUnitsPayloadZ>;
+
+/** SetRulePosition sets the value-space position of the rule identified by key. */
+export const setRulePositionPayloadZ = z.object({
+  key: z.string(),
+  position: z.number(),
+});
+
+export type SetRulePositionPayload = z.infer<typeof setRulePositionPayloadZ>;
+
+/** RemoveRule removes the rule with the given key, if present. */
+export const removeRulePayloadZ = z.object({
+  key: z.string(),
+});
+
+export type RemoveRulePayload = z.infer<typeof removeRulePayloadZ>;
+
+export const actionZ = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("create"), create: createPayloadZ }),
+  z.object({ type: z.literal("rename"), rename: renamePayloadZ }),
+  z.object({
+    type: z.literal("set_title_visible"),
+    setTitleVisible: setTitleVisiblePayloadZ,
+  }),
+  z.object({
+    type: z.literal("set_title_level"),
+    setTitleLevel: setTitleLevelPayloadZ,
+  }),
+  z.object({
+    type: z.literal("set_legend_hidden"),
+    setLegendHidden: setLegendHiddenPayloadZ,
+  }),
+  z.object({
+    type: z.literal("set_legend_position"),
+    setLegendPosition: setLegendPositionPayloadZ,
+  }),
+  z.object({ type: z.literal("add_channel"), addChannel: addChannelPayloadZ }),
+  z.object({ type: z.literal("remove_channel"), removeChannel: removeChannelPayloadZ }),
+  z.object({ type: z.literal("set_channels"), setChannels: setChannelsPayloadZ }),
+  z.object({ type: z.literal("set_x_channel"), setXChannel: setXChannelPayloadZ }),
+  z.object({ type: z.literal("add_range"), addRange: addRangePayloadZ }),
+  z.object({ type: z.literal("remove_range"), removeRange: removeRangePayloadZ }),
+  z.object({ type: z.literal("set_ranges"), setRanges: setRangesPayloadZ }),
+  z.object({ type: z.literal("set_axis_label"), setAxisLabel: setAxisLabelPayloadZ }),
+  z.object({
+    type: z.literal("set_axis_label_direction"),
+    setAxisLabelDirection: setAxisLabelDirectionPayloadZ,
+  }),
+  z.object({
+    type: z.literal("set_axis_label_level"),
+    setAxisLabelLevel: setAxisLabelLevelPayloadZ,
+  }),
+  z.object({
+    type: z.literal("set_axis_bounds"),
+    setAxisBounds: setAxisBoundsPayloadZ,
+  }),
+  z.object({
+    type: z.literal("set_axis_tick_spacing"),
+    setAxisTickSpacing: setAxisTickSpacingPayloadZ,
+  }),
+  z.object({ type: z.literal("set_axis_type"), setAxisType: setAxisTypePayloadZ }),
+  z.object({ type: z.literal("set_line_label"), setLineLabel: setLineLabelPayloadZ }),
+  z.object({ type: z.literal("set_line_color"), setLineColor: setLineColorPayloadZ }),
+  z.object({
+    type: z.literal("set_line_stroke_width"),
+    setLineStrokeWidth: setLineStrokeWidthPayloadZ,
+  }),
+  z.object({
+    type: z.literal("set_line_downsample"),
+    setLineDownsample: setLineDownsamplePayloadZ,
+  }),
+  z.object({
+    type: z.literal("set_line_downsample_mode"),
+    setLineDownsampleMode: setLineDownsampleModePayloadZ,
+  }),
+  z.object({ type: z.literal("set_line"), setLine: setLinePayloadZ }),
+  z.object({ type: z.literal("set_rule"), setRule: setRulePayloadZ }),
+  z.object({ type: z.literal("set_rule_label"), setRuleLabel: setRuleLabelPayloadZ }),
+  z.object({ type: z.literal("set_rule_color"), setRuleColor: setRuleColorPayloadZ }),
+  z.object({ type: z.literal("set_rule_axis"), setRuleAxis: setRuleAxisPayloadZ }),
+  z.object({
+    type: z.literal("set_rule_line_width"),
+    setRuleLineWidth: setRuleLineWidthPayloadZ,
+  }),
+  z.object({
+    type: z.literal("set_rule_line_dash"),
+    setRuleLineDash: setRuleLineDashPayloadZ,
+  }),
+  z.object({ type: z.literal("set_rule_units"), setRuleUnits: setRuleUnitsPayloadZ }),
+  z.object({
+    type: z.literal("set_rule_position"),
+    setRulePosition: setRulePositionPayloadZ,
+  }),
+  z.object({ type: z.literal("remove_rule"), removeRule: removeRulePayloadZ }),
+]);
+
+export type Action = z.infer<typeof actionZ>;
+
+export const create = (payload: z.input<typeof createPayloadZ>): Action => ({
+  type: "create",
+  create: zod.parse(createPayloadZ, payload, {
+    label: "line plot create action payload",
+  }),
+});
+
+export const rename = (payload: z.input<typeof renamePayloadZ>): Action => ({
+  type: "rename",
+  rename: zod.parse(renamePayloadZ, payload, {
+    label: "line plot rename action payload",
+  }),
+});
+
+export const setTitleVisible = (
+  payload: z.input<typeof setTitleVisiblePayloadZ>,
+): Action => ({
+  type: "set_title_visible",
+  setTitleVisible: zod.parse(setTitleVisiblePayloadZ, payload, {
+    label: "line plot set_title_visible action payload",
+  }),
+});
+
+export const setTitleLevel = (
+  payload: z.input<typeof setTitleLevelPayloadZ>,
+): Action => ({
+  type: "set_title_level",
+  setTitleLevel: zod.parse(setTitleLevelPayloadZ, payload, {
+    label: "line plot set_title_level action payload",
+  }),
+});
+
+export const setLegendHidden = (
+  payload: z.input<typeof setLegendHiddenPayloadZ>,
+): Action => ({
+  type: "set_legend_hidden",
+  setLegendHidden: zod.parse(setLegendHiddenPayloadZ, payload, {
+    label: "line plot set_legend_hidden action payload",
+  }),
+});
+
+export const setLegendPosition = (
+  payload: z.input<typeof setLegendPositionPayloadZ>,
+): Action => ({
+  type: "set_legend_position",
+  setLegendPosition: zod.parse(setLegendPositionPayloadZ, payload, {
+    label: "line plot set_legend_position action payload",
+  }),
+});
+
+export const addChannel = (payload: z.input<typeof addChannelPayloadZ>): Action => ({
+  type: "add_channel",
+  addChannel: zod.parse(addChannelPayloadZ, payload, {
+    label: "line plot add_channel action payload",
+  }),
+});
+
+export const removeChannel = (
+  payload: z.input<typeof removeChannelPayloadZ>,
+): Action => ({
+  type: "remove_channel",
+  removeChannel: zod.parse(removeChannelPayloadZ, payload, {
+    label: "line plot remove_channel action payload",
+  }),
+});
+
+export const setChannels = (payload: z.input<typeof setChannelsPayloadZ>): Action => ({
+  type: "set_channels",
+  setChannels: zod.parse(setChannelsPayloadZ, payload, {
+    label: "line plot set_channels action payload",
+  }),
+});
+
+export const setXChannel = (payload: z.input<typeof setXChannelPayloadZ>): Action => ({
+  type: "set_x_channel",
+  setXChannel: zod.parse(setXChannelPayloadZ, payload, {
+    label: "line plot set_x_channel action payload",
+  }),
+});
+
+export const addRange = (payload: z.input<typeof addRangePayloadZ>): Action => ({
+  type: "add_range",
+  addRange: zod.parse(addRangePayloadZ, payload, {
+    label: "line plot add_range action payload",
+  }),
+});
+
+export const removeRange = (payload: z.input<typeof removeRangePayloadZ>): Action => ({
+  type: "remove_range",
+  removeRange: zod.parse(removeRangePayloadZ, payload, {
+    label: "line plot remove_range action payload",
+  }),
+});
+
+export const setRanges = (payload: z.input<typeof setRangesPayloadZ>): Action => ({
+  type: "set_ranges",
+  setRanges: zod.parse(setRangesPayloadZ, payload, {
+    label: "line plot set_ranges action payload",
+  }),
+});
+
+export const setAxisLabel = (
+  payload: z.input<typeof setAxisLabelPayloadZ>,
+): Action => ({
+  type: "set_axis_label",
+  setAxisLabel: zod.parse(setAxisLabelPayloadZ, payload, {
+    label: "line plot set_axis_label action payload",
+  }),
+});
+
+export const setAxisLabelDirection = (
+  payload: z.input<typeof setAxisLabelDirectionPayloadZ>,
+): Action => ({
+  type: "set_axis_label_direction",
+  setAxisLabelDirection: zod.parse(setAxisLabelDirectionPayloadZ, payload, {
+    label: "line plot set_axis_label_direction action payload",
+  }),
+});
+
+export const setAxisLabelLevel = (
+  payload: z.input<typeof setAxisLabelLevelPayloadZ>,
+): Action => ({
+  type: "set_axis_label_level",
+  setAxisLabelLevel: zod.parse(setAxisLabelLevelPayloadZ, payload, {
+    label: "line plot set_axis_label_level action payload",
+  }),
+});
+
+export const setAxisBounds = (
+  payload: z.input<typeof setAxisBoundsPayloadZ>,
+): Action => ({
+  type: "set_axis_bounds",
+  setAxisBounds: zod.parse(setAxisBoundsPayloadZ, payload, {
+    label: "line plot set_axis_bounds action payload",
+  }),
+});
+
+export const setAxisTickSpacing = (
+  payload: z.input<typeof setAxisTickSpacingPayloadZ>,
+): Action => ({
+  type: "set_axis_tick_spacing",
+  setAxisTickSpacing: zod.parse(setAxisTickSpacingPayloadZ, payload, {
+    label: "line plot set_axis_tick_spacing action payload",
+  }),
+});
+
+export const setAxisType = (payload: z.input<typeof setAxisTypePayloadZ>): Action => ({
+  type: "set_axis_type",
+  setAxisType: zod.parse(setAxisTypePayloadZ, payload, {
+    label: "line plot set_axis_type action payload",
+  }),
+});
+
+export const setLineLabel = (
+  payload: z.input<typeof setLineLabelPayloadZ>,
+): Action => ({
+  type: "set_line_label",
+  setLineLabel: zod.parse(setLineLabelPayloadZ, payload, {
+    label: "line plot set_line_label action payload",
+  }),
+});
+
+export const setLineColor = (
+  payload: z.input<typeof setLineColorPayloadZ>,
+): Action => ({
+  type: "set_line_color",
+  setLineColor: zod.parse(setLineColorPayloadZ, payload, {
+    label: "line plot set_line_color action payload",
+  }),
+});
+
+export const setLineStrokeWidth = (
+  payload: z.input<typeof setLineStrokeWidthPayloadZ>,
+): Action => ({
+  type: "set_line_stroke_width",
+  setLineStrokeWidth: zod.parse(setLineStrokeWidthPayloadZ, payload, {
+    label: "line plot set_line_stroke_width action payload",
+  }),
+});
+
+export const setLineDownsample = (
+  payload: z.input<typeof setLineDownsamplePayloadZ>,
+): Action => ({
+  type: "set_line_downsample",
+  setLineDownsample: zod.parse(setLineDownsamplePayloadZ, payload, {
+    label: "line plot set_line_downsample action payload",
+  }),
+});
+
+export const setLineDownsampleMode = (
+  payload: z.input<typeof setLineDownsampleModePayloadZ>,
+): Action => ({
+  type: "set_line_downsample_mode",
+  setLineDownsampleMode: zod.parse(setLineDownsampleModePayloadZ, payload, {
+    label: "line plot set_line_downsample_mode action payload",
+  }),
+});
+
+export const setLine = (payload: z.input<typeof setLinePayloadZ>): Action => ({
+  type: "set_line",
+  setLine: zod.parse(setLinePayloadZ, payload, {
+    label: "line plot set_line action payload",
+  }),
+});
+
+export const setRule = (payload: z.input<typeof setRulePayloadZ>): Action => ({
+  type: "set_rule",
+  setRule: zod.parse(setRulePayloadZ, payload, {
+    label: "line plot set_rule action payload",
+  }),
+});
+
+export const setRuleLabel = (
+  payload: z.input<typeof setRuleLabelPayloadZ>,
+): Action => ({
+  type: "set_rule_label",
+  setRuleLabel: zod.parse(setRuleLabelPayloadZ, payload, {
+    label: "line plot set_rule_label action payload",
+  }),
+});
+
+export const setRuleColor = (
+  payload: z.input<typeof setRuleColorPayloadZ>,
+): Action => ({
+  type: "set_rule_color",
+  setRuleColor: zod.parse(setRuleColorPayloadZ, payload, {
+    label: "line plot set_rule_color action payload",
+  }),
+});
+
+export const setRuleAxis = (payload: z.input<typeof setRuleAxisPayloadZ>): Action => ({
+  type: "set_rule_axis",
+  setRuleAxis: zod.parse(setRuleAxisPayloadZ, payload, {
+    label: "line plot set_rule_axis action payload",
+  }),
+});
+
+export const setRuleLineWidth = (
+  payload: z.input<typeof setRuleLineWidthPayloadZ>,
+): Action => ({
+  type: "set_rule_line_width",
+  setRuleLineWidth: zod.parse(setRuleLineWidthPayloadZ, payload, {
+    label: "line plot set_rule_line_width action payload",
+  }),
+});
+
+export const setRuleLineDash = (
+  payload: z.input<typeof setRuleLineDashPayloadZ>,
+): Action => ({
+  type: "set_rule_line_dash",
+  setRuleLineDash: zod.parse(setRuleLineDashPayloadZ, payload, {
+    label: "line plot set_rule_line_dash action payload",
+  }),
+});
+
+export const setRuleUnits = (
+  payload: z.input<typeof setRuleUnitsPayloadZ>,
+): Action => ({
+  type: "set_rule_units",
+  setRuleUnits: zod.parse(setRuleUnitsPayloadZ, payload, {
+    label: "line plot set_rule_units action payload",
+  }),
+});
+
+export const setRulePosition = (
+  payload: z.input<typeof setRulePositionPayloadZ>,
+): Action => ({
+  type: "set_rule_position",
+  setRulePosition: zod.parse(setRulePositionPayloadZ, payload, {
+    label: "line plot set_rule_position action payload",
+  }),
+});
+
+export const removeRule = (payload: z.input<typeof removeRulePayloadZ>): Action => ({
+  type: "remove_rule",
+  removeRule: zod.parse(removeRulePayloadZ, payload, {
+    label: "line plot remove_rule action payload",
+  }),
+});
+
+export type HandlerResult = actions.HandlerResult<Action>;
+
+export type ReduceAllResult = actions.ReduceAllResult<LinePlot, Action>;
+
+export interface Handlers {
+  create: (state: Draft<LinePlot>, payload: CreatePayload) => HandlerResult;
+  rename: (state: Draft<LinePlot>, payload: RenamePayload) => HandlerResult;
+  setTitleVisible: (
+    state: Draft<LinePlot>,
+    payload: SetTitleVisiblePayload,
+  ) => HandlerResult;
+  setTitleLevel: (
+    state: Draft<LinePlot>,
+    payload: SetTitleLevelPayload,
+  ) => HandlerResult;
+  setLegendHidden: (
+    state: Draft<LinePlot>,
+    payload: SetLegendHiddenPayload,
+  ) => HandlerResult;
+  setLegendPosition: (
+    state: Draft<LinePlot>,
+    payload: SetLegendPositionPayload,
+  ) => HandlerResult;
+  addChannel: (state: Draft<LinePlot>, payload: AddChannelPayload) => HandlerResult;
+  removeChannel: (
+    state: Draft<LinePlot>,
+    payload: RemoveChannelPayload,
+  ) => HandlerResult;
+  setChannels: (state: Draft<LinePlot>, payload: SetChannelsPayload) => HandlerResult;
+  setXChannel: (state: Draft<LinePlot>, payload: SetXChannelPayload) => HandlerResult;
+  addRange: (state: Draft<LinePlot>, payload: AddRangePayload) => HandlerResult;
+  removeRange: (state: Draft<LinePlot>, payload: RemoveRangePayload) => HandlerResult;
+  setRanges: (state: Draft<LinePlot>, payload: SetRangesPayload) => HandlerResult;
+  setAxisLabel: (state: Draft<LinePlot>, payload: SetAxisLabelPayload) => HandlerResult;
+  setAxisLabelDirection: (
+    state: Draft<LinePlot>,
+    payload: SetAxisLabelDirectionPayload,
+  ) => HandlerResult;
+  setAxisLabelLevel: (
+    state: Draft<LinePlot>,
+    payload: SetAxisLabelLevelPayload,
+  ) => HandlerResult;
+  setAxisBounds: (
+    state: Draft<LinePlot>,
+    payload: SetAxisBoundsPayload,
+  ) => HandlerResult;
+  setAxisTickSpacing: (
+    state: Draft<LinePlot>,
+    payload: SetAxisTickSpacingPayload,
+  ) => HandlerResult;
+  setAxisType: (state: Draft<LinePlot>, payload: SetAxisTypePayload) => HandlerResult;
+  setLineLabel: (state: Draft<LinePlot>, payload: SetLineLabelPayload) => HandlerResult;
+  setLineColor: (state: Draft<LinePlot>, payload: SetLineColorPayload) => HandlerResult;
+  setLineStrokeWidth: (
+    state: Draft<LinePlot>,
+    payload: SetLineStrokeWidthPayload,
+  ) => HandlerResult;
+  setLineDownsample: (
+    state: Draft<LinePlot>,
+    payload: SetLineDownsamplePayload,
+  ) => HandlerResult;
+  setLineDownsampleMode: (
+    state: Draft<LinePlot>,
+    payload: SetLineDownsampleModePayload,
+  ) => HandlerResult;
+  setLine: (state: Draft<LinePlot>, payload: SetLinePayload) => HandlerResult;
+  setRule: (state: Draft<LinePlot>, payload: SetRulePayload) => HandlerResult;
+  setRuleLabel: (state: Draft<LinePlot>, payload: SetRuleLabelPayload) => HandlerResult;
+  setRuleColor: (state: Draft<LinePlot>, payload: SetRuleColorPayload) => HandlerResult;
+  setRuleAxis: (state: Draft<LinePlot>, payload: SetRuleAxisPayload) => HandlerResult;
+  setRuleLineWidth: (
+    state: Draft<LinePlot>,
+    payload: SetRuleLineWidthPayload,
+  ) => HandlerResult;
+  setRuleLineDash: (
+    state: Draft<LinePlot>,
+    payload: SetRuleLineDashPayload,
+  ) => HandlerResult;
+  setRuleUnits: (state: Draft<LinePlot>, payload: SetRuleUnitsPayload) => HandlerResult;
+  setRulePosition: (
+    state: Draft<LinePlot>,
+    payload: SetRulePositionPayload,
+  ) => HandlerResult;
+  removeRule: (state: Draft<LinePlot>, payload: RemoveRulePayload) => HandlerResult;
+}
+
+export const createReduceAll = (handlers: Handlers) =>
+  actions.createReduceAll<LinePlot, Action>((state, action) => {
+    switch (action.type) {
+      case "create":
+        return handlers.create(state, action.create);
+      case "rename":
+        return handlers.rename(state, action.rename);
+      case "set_title_visible":
+        return handlers.setTitleVisible(state, action.setTitleVisible);
+      case "set_title_level":
+        return handlers.setTitleLevel(state, action.setTitleLevel);
+      case "set_legend_hidden":
+        return handlers.setLegendHidden(state, action.setLegendHidden);
+      case "set_legend_position":
+        return handlers.setLegendPosition(state, action.setLegendPosition);
+      case "add_channel":
+        return handlers.addChannel(state, action.addChannel);
+      case "remove_channel":
+        return handlers.removeChannel(state, action.removeChannel);
+      case "set_channels":
+        return handlers.setChannels(state, action.setChannels);
+      case "set_x_channel":
+        return handlers.setXChannel(state, action.setXChannel);
+      case "add_range":
+        return handlers.addRange(state, action.addRange);
+      case "remove_range":
+        return handlers.removeRange(state, action.removeRange);
+      case "set_ranges":
+        return handlers.setRanges(state, action.setRanges);
+      case "set_axis_label":
+        return handlers.setAxisLabel(state, action.setAxisLabel);
+      case "set_axis_label_direction":
+        return handlers.setAxisLabelDirection(state, action.setAxisLabelDirection);
+      case "set_axis_label_level":
+        return handlers.setAxisLabelLevel(state, action.setAxisLabelLevel);
+      case "set_axis_bounds":
+        return handlers.setAxisBounds(state, action.setAxisBounds);
+      case "set_axis_tick_spacing":
+        return handlers.setAxisTickSpacing(state, action.setAxisTickSpacing);
+      case "set_axis_type":
+        return handlers.setAxisType(state, action.setAxisType);
+      case "set_line_label":
+        return handlers.setLineLabel(state, action.setLineLabel);
+      case "set_line_color":
+        return handlers.setLineColor(state, action.setLineColor);
+      case "set_line_stroke_width":
+        return handlers.setLineStrokeWidth(state, action.setLineStrokeWidth);
+      case "set_line_downsample":
+        return handlers.setLineDownsample(state, action.setLineDownsample);
+      case "set_line_downsample_mode":
+        return handlers.setLineDownsampleMode(state, action.setLineDownsampleMode);
+      case "set_line":
+        return handlers.setLine(state, action.setLine);
+      case "set_rule":
+        return handlers.setRule(state, action.setRule);
+      case "set_rule_label":
+        return handlers.setRuleLabel(state, action.setRuleLabel);
+      case "set_rule_color":
+        return handlers.setRuleColor(state, action.setRuleColor);
+      case "set_rule_axis":
+        return handlers.setRuleAxis(state, action.setRuleAxis);
+      case "set_rule_line_width":
+        return handlers.setRuleLineWidth(state, action.setRuleLineWidth);
+      case "set_rule_line_dash":
+        return handlers.setRuleLineDash(state, action.setRuleLineDash);
+      case "set_rule_units":
+        return handlers.setRuleUnits(state, action.setRuleUnits);
+      case "set_rule_position":
+        return handlers.setRulePosition(state, action.setRulePosition);
+      case "remove_rule":
+        return handlers.removeRule(state, action.removeRule);
+    }
+  });
+
+export const scopedActionZ = actions.scopedZ(keyZ, actionZ);
+
+export const dispatchReqZ = actions.dispatchReqZ(keyZ, actionZ);