circuit-json 0.0.203 → 0.0.205

package/dist/index.mjs

@@ -259,12 +259,26 @@ var getZodPrefixedIdWithDefault = (prefix) => {
   return z5.string().optional().default(() => `${prefix}_${nanoid(10)}`);
 };
 
+// src/common/NinePointAnchor.ts
+import { z as z6 } from "zod";
+var ninePointAnchor = z6.enum([
+  "top_left",
+  "top_center",
+  "top_right",
+  "center_left",
+  "center",
+  "center_right",
+  "bottom_left",
+  "bottom_center",
+  "bottom_right"
+]);
+
 // src/source/source_simple_capacitor.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/pcb/properties/supplier_name.ts
-import { z as z6 } from "zod";
-var supplier_name = z6.enum([
+import { z as z7 } from "zod";
+var supplier_name = z7.enum([
   "jlcpcb",
   "macrofab",
   "pcbway",
@@ -294,147 +308,150 @@ expectStringUnionsMatch(
 expectStringUnionsMatch(true);
 
 // src/source/base/source_component_base.ts
-import { z as z7 } from "zod";
-var source_component_base = z7.object({
-  type: z7.literal("source_component"),
-  ftype: z7.string().optional(),
-  source_component_id: z7.string(),
-  name: z7.string(),
-  manufacturer_part_number: z7.string().optional(),
-  supplier_part_numbers: z7.record(supplier_name, z7.array(z7.string())).optional(),
-  display_value: z7.string().optional(),
-  are_pins_interchangeable: z7.boolean().optional(),
-  internally_connected_source_port_ids: z7.array(z7.array(z7.string())).optional(),
-  source_group_id: z7.string().optional()
+import { z as z8 } from "zod";
+var source_component_base = z8.object({
+  type: z8.literal("source_component"),
+  ftype: z8.string().optional(),
+  source_component_id: z8.string(),
+  name: z8.string(),
+  manufacturer_part_number: z8.string().optional(),
+  supplier_part_numbers: z8.record(supplier_name, z8.array(z8.string())).optional(),
+  display_value: z8.string().optional(),
+  are_pins_interchangeable: z8.boolean().optional(),
+  internally_connected_source_port_ids: z8.array(z8.array(z8.string())).optional(),
+  source_group_id: z8.string().optional()
 });
 expectTypesMatch(true);
 
 // src/source/source_simple_capacitor.ts
 var source_simple_capacitor = source_component_base.extend({
-  ftype: z8.literal("simple_capacitor"),
+  ftype: z9.literal("simple_capacitor"),
   capacitance,
   max_voltage_rating: voltage.optional(),
-  display_capacitance: z8.string().optional(),
+  display_capacitance: z9.string().optional(),
   max_decoupling_trace_length: distance.optional()
 });
 expectTypesMatch(true);
 
 // src/source/source_simple_resistor.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var source_simple_resistor = source_component_base.extend({
-  ftype: z9.literal("simple_resistor"),
+  ftype: z10.literal("simple_resistor"),
   resistance,
-  display_resistance: z9.string().optional()
+  display_resistance: z10.string().optional()
 });
 expectTypesMatch(true);
 
 // src/source/source_simple_diode.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var source_simple_diode = source_component_base.extend({
-  ftype: z10.literal("simple_diode")
+  ftype: z11.literal("simple_diode")
 });
 expectTypesMatch(true);
 
 // src/source/source_simple_led.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var source_simple_led = source_simple_diode.extend({
-  ftype: z11.literal("simple_led"),
-  color: z11.string().optional(),
-  wavelength: z11.string().optional()
+  ftype: z12.literal("simple_led"),
+  color: z12.string().optional(),
+  wavelength: z12.string().optional()
 });
 expectTypesMatch(true);
 
 // src/source/source_simple_ground.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var source_simple_ground = source_component_base.extend({
-  ftype: z12.literal("simple_ground")
+  ftype: z13.literal("simple_ground")
 });
 expectTypesMatch(true);
 
 // src/source/source_simple_bug.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var source_simple_bug = source_component_base.extend({
-  ftype: z13.literal("simple_bug")
+  ftype: z14.literal("simple_bug")
 }).describe("@deprecated");
 
 // src/source/source_simple_chip.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var source_simple_chip = source_component_base.extend({
-  ftype: z14.literal("simple_chip")
+  ftype: z15.literal("simple_chip")
 });
 expectTypesMatch(true);
 
 // src/source/source_simple_power_source.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var source_simple_power_source = source_component_base.extend({
-  ftype: z15.literal("simple_power_source"),
+  ftype: z16.literal("simple_power_source"),
   voltage
 });
 expectTypesMatch(true);
 
 // src/source/any_source_component.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 
 // src/source/source_simple_fuse.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var source_simple_fuse = source_component_base.extend({
-  ftype: z16.literal("simple_fuse"),
-  current_rating_amps: z16.number().describe("Nominal current in amps the fuse is rated for"),
-  voltage_rating_volts: z16.number().describe("Voltage rating in volts, e.g. \xB15V would be 5")
+  ftype: z17.literal("simple_fuse"),
+  current_rating_amps: z17.number().describe("Nominal current in amps the fuse is rated for"),
+  voltage_rating_volts: z17.number().describe("Voltage rating in volts, e.g. \xB15V would be 5")
 });
 expectTypesMatch(true);
 
 // src/source/source_simple_battery.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var source_simple_battery = source_component_base.extend({
-  ftype: z17.literal("simple_battery"),
+  ftype: z18.literal("simple_battery"),
   capacity: battery_capacity
 });
 expectTypesMatch(true);
 
 // src/source/source_simple_inductor.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var source_simple_inductor = source_component_base.extend({
-  ftype: z18.literal("simple_inductor"),
+  ftype: z19.literal("simple_inductor"),
   inductance
 });
 expectTypesMatch(true);
 
 // src/source/source_simple_push_button.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var source_simple_push_button = source_component_base.extend({
-  ftype: z19.literal("simple_push_button")
+  ftype: z20.literal("simple_push_button")
 });
 expectTypesMatch(true);
 
 // src/source/source_simple_potentiometer.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var source_simple_potentiometer = source_component_base.extend({
-  ftype: z20.literal("simple_potentiometer"),
+  ftype: z21.literal("simple_potentiometer"),
   max_resistance: resistance
 });
+expectTypesMatch(
+  true
+);
 
 // src/source/source_simple_crystal.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var source_simple_crystal = source_component_base.extend({
-  ftype: z21.literal("simple_crystal"),
-  frequency: z21.number().describe("Frequency in Hz"),
-  load_capacitance: z21.number().optional().describe("Load capacitance in pF")
+  ftype: z22.literal("simple_crystal"),
+  frequency: z22.number().describe("Frequency in Hz"),
+  load_capacitance: z22.number().optional().describe("Load capacitance in pF")
 });
 expectTypesMatch(true);
 
 // src/source/source_simple_pin_header.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var source_simple_pin_header = source_component_base.extend({
-  ftype: z22.literal("simple_pin_header"),
-  pin_count: z22.number(),
-  gender: z22.enum(["male", "female"]).optional().default("male")
+  ftype: z23.literal("simple_pin_header"),
+  pin_count: z23.number(),
+  gender: z23.enum(["male", "female"]).optional().default("male")
 });
 
 // src/source/source_simple_resonator.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var source_simple_resonator = source_component_base.extend({
-  ftype: z23.literal("simple_resonator"),
+  ftype: z24.literal("simple_resonator"),
   load_capacitance: capacitance,
   equivalent_series_resistance: resistance.optional(),
   frequency
@@ -442,92 +459,92 @@ var source_simple_resonator = source_component_base.extend({
 expectTypesMatch(true);
 
 // src/source/source_simple_transistor.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var source_simple_transistor = source_component_base.extend({
-  ftype: z24.literal("simple_transistor"),
-  transistor_type: z24.enum(["npn", "pnp"])
+  ftype: z25.literal("simple_transistor"),
+  transistor_type: z25.enum(["npn", "pnp"])
 });
 expectTypesMatch(true);
 
 // src/source/source_simple_test_point.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var source_simple_test_point = source_component_base.extend({
-  ftype: z25.literal("simple_test_point"),
-  footprint_variant: z25.enum(["pad", "through_hole"]).optional(),
-  pad_shape: z25.enum(["rect", "circle"]).optional(),
-  pad_diameter: z25.union([z25.number(), z25.string()]).optional(),
-  hole_diameter: z25.union([z25.number(), z25.string()]).optional(),
-  width: z25.union([z25.number(), z25.string()]).optional(),
-  height: z25.union([z25.number(), z25.string()]).optional()
+  ftype: z26.literal("simple_test_point"),
+  footprint_variant: z26.enum(["pad", "through_hole"]).optional(),
+  pad_shape: z26.enum(["rect", "circle"]).optional(),
+  pad_diameter: z26.union([z26.number(), z26.string()]).optional(),
+  hole_diameter: z26.union([z26.number(), z26.string()]).optional(),
+  width: z26.union([z26.number(), z26.string()]).optional(),
+  height: z26.union([z26.number(), z26.string()]).optional()
 });
 expectTypesMatch(true);
 
 // src/source/source_simple_mosfet.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var source_simple_mosfet = source_component_base.extend({
-  ftype: z26.literal("simple_mosfet"),
-  channel_type: z26.enum(["n", "p"]),
-  mosfet_mode: z26.enum(["enhancement", "depletion"])
+  ftype: z27.literal("simple_mosfet"),
+  channel_type: z27.enum(["n", "p"]),
+  mosfet_mode: z27.enum(["enhancement", "depletion"])
 });
 expectTypesMatch(true);
 
 // src/source/source_simple_switch.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var source_simple_switch = source_component_base.extend({
-  ftype: z27.literal("simple_switch")
+  ftype: z28.literal("simple_switch")
 });
 expectTypesMatch(true);
 
 // src/source/source_project_metadata.ts
-import { z as z28 } from "zod";
-var source_project_metadata = z28.object({
-  type: z28.literal("source_project_metadata"),
-  name: z28.string().optional(),
-  software_used_string: z28.string().optional(),
-  project_url: z28.string().optional(),
-  created_at: z28.string().datetime().optional()
+import { z as z29 } from "zod";
+var source_project_metadata = z29.object({
+  type: z29.literal("source_project_metadata"),
+  name: z29.string().optional(),
+  software_used_string: z29.string().optional(),
+  project_url: z29.string().optional(),
+  created_at: z29.string().datetime().optional()
 });
 expectTypesMatch(true);
 
 // src/source/source_missing_property_error.ts
-import { z as z29 } from "zod";
-var source_missing_property_error = z29.object({
-  type: z29.literal("source_missing_property_error"),
+import { z as z30 } from "zod";
+var source_missing_property_error = z30.object({
+  type: z30.literal("source_missing_property_error"),
   source_missing_property_error_id: getZodPrefixedIdWithDefault(
     "source_missing_property_error"
   ),
-  source_component_id: z29.string(),
-  property_name: z29.string(),
-  error_type: z29.literal("source_missing_property_error").default("source_missing_property_error"),
-  message: z29.string()
+  source_component_id: z30.string(),
+  property_name: z30.string(),
+  error_type: z30.literal("source_missing_property_error").default("source_missing_property_error"),
+  message: z30.string()
 }).describe("The source code is missing a property");
 expectTypesMatch(true);
 
 // src/source/source_failed_to_create_component_error.ts
-import { z as z30 } from "zod";
-var source_failed_to_create_component_error = z30.object({
-  type: z30.literal("source_failed_to_create_component_error"),
+import { z as z31 } from "zod";
+var source_failed_to_create_component_error = z31.object({
+  type: z31.literal("source_failed_to_create_component_error"),
   source_failed_to_create_component_error_id: getZodPrefixedIdWithDefault(
     "source_failed_to_create_component_error"
   ),
-  error_type: z30.literal("source_failed_to_create_component_error").default("source_failed_to_create_component_error"),
-  component_name: z30.string().optional(),
-  subcircuit_id: z30.string().optional(),
-  parent_source_component_id: z30.string().optional(),
-  message: z30.string(),
-  pcb_center: z30.object({
-    x: z30.number().optional(),
-    y: z30.number().optional()
+  error_type: z31.literal("source_failed_to_create_component_error").default("source_failed_to_create_component_error"),
+  component_name: z31.string().optional(),
+  subcircuit_id: z31.string().optional(),
+  parent_source_component_id: z31.string().optional(),
+  message: z31.string(),
+  pcb_center: z31.object({
+    x: z31.number().optional(),
+    y: z31.number().optional()
   }).optional(),
-  schematic_center: z30.object({
-    x: z30.number().optional(),
-    y: z30.number().optional()
+  schematic_center: z31.object({
+    x: z31.number().optional(),
+    y: z31.number().optional()
   }).optional()
 }).describe("Error emitted when a component fails to be constructed");
 expectTypesMatch(true);
 
 // src/source/any_source_component.ts
-var any_source_component = z31.union([
+var any_source_component = z32.union([
   source_simple_resistor,
   source_simple_capacitor,
   source_simple_diode,
@@ -554,152 +571,152 @@ var any_source_component = z31.union([
 ]);
 
 // src/source/source_port.ts
-import { z as z32 } from "zod";
-var source_port = z32.object({
-  type: z32.literal("source_port"),
-  pin_number: z32.number().optional(),
-  port_hints: z32.array(z32.string()).optional(),
-  name: z32.string(),
-  source_port_id: z32.string(),
-  source_component_id: z32.string(),
-  subcircuit_id: z32.string().optional(),
-  subcircuit_connectivity_map_key: z32.string().optional()
-});
-expectTypesMatch(true);
-
-// src/source/source_trace.ts
 import { z as z33 } from "zod";
-var source_trace = z33.object({
-  type: z33.literal("source_trace"),
-  source_trace_id: z33.string(),
-  connected_source_port_ids: z33.array(z33.string()),
-  connected_source_net_ids: z33.array(z33.string()),
+var source_port = z33.object({
+  type: z33.literal("source_port"),
+  pin_number: z33.number().optional(),
+  port_hints: z33.array(z33.string()).optional(),
+  name: z33.string(),
+  source_port_id: z33.string(),
+  source_component_id: z33.string(),
   subcircuit_id: z33.string().optional(),
-  subcircuit_connectivity_map_key: z33.string().optional(),
-  max_length: z33.number().optional(),
-  min_trace_thickness: z33.number().optional(),
-  display_name: z33.string().optional()
+  subcircuit_connectivity_map_key: z33.string().optional()
 });
 expectTypesMatch(true);
 
-// src/source/source_group.ts
+// src/source/source_trace.ts
 import { z as z34 } from "zod";
-var source_group = z34.object({
-  type: z34.literal("source_group"),
-  source_group_id: z34.string(),
+var source_trace = z34.object({
+  type: z34.literal("source_trace"),
+  source_trace_id: z34.string(),
+  connected_source_port_ids: z34.array(z34.string()),
+  connected_source_net_ids: z34.array(z34.string()),
   subcircuit_id: z34.string().optional(),
-  parent_subcircuit_id: z34.string().optional(),
-  is_subcircuit: z34.boolean().optional(),
-  name: z34.string().optional()
+  subcircuit_connectivity_map_key: z34.string().optional(),
+  max_length: z34.number().optional(),
+  min_trace_thickness: z34.number().optional(),
+  display_name: z34.string().optional()
 });
+expectTypesMatch(true);
 
-// src/source/source_net.ts
+// src/source/source_group.ts
 import { z as z35 } from "zod";
-var source_net = z35.object({
-  type: z35.literal("source_net"),
-  source_net_id: z35.string(),
-  name: z35.string(),
-  member_source_group_ids: z35.array(z35.string()),
-  is_power: z35.boolean().optional(),
-  is_ground: z35.boolean().optional(),
-  is_digital_signal: z35.boolean().optional(),
-  is_analog_signal: z35.boolean().optional(),
-  trace_width: z35.number().optional(),
+var source_group = z35.object({
+  type: z35.literal("source_group"),
+  source_group_id: z35.string(),
   subcircuit_id: z35.string().optional(),
-  subcircuit_connectivity_map_key: z35.string().optional()
+  parent_subcircuit_id: z35.string().optional(),
+  is_subcircuit: z35.boolean().optional(),
+  name: z35.string().optional()
 });
 
-// src/schematic/schematic_box.ts
+// src/source/source_net.ts
 import { z as z36 } from "zod";
-var schematic_box = z36.object({
-  type: z36.literal("schematic_box"),
-  schematic_component_id: z36.string(),
+var source_net = z36.object({
+  type: z36.literal("source_net"),
+  source_net_id: z36.string(),
+  name: z36.string(),
+  member_source_group_ids: z36.array(z36.string()),
+  is_power: z36.boolean().optional(),
+  is_ground: z36.boolean().optional(),
+  is_digital_signal: z36.boolean().optional(),
+  is_analog_signal: z36.boolean().optional(),
+  trace_width: z36.number().optional(),
+  subcircuit_id: z36.string().optional(),
+  subcircuit_connectivity_map_key: z36.string().optional()
+});
+
+// src/schematic/schematic_box.ts
+import { z as z37 } from "zod";
+var schematic_box = z37.object({
+  type: z37.literal("schematic_box"),
+  schematic_component_id: z37.string(),
   width: distance,
   height: distance,
-  is_dashed: z36.boolean().default(false),
+  is_dashed: z37.boolean().default(false),
   x: distance,
   y: distance
 }).describe("Draws a box on the schematic");
 expectTypesMatch(true);
 
 // src/schematic/schematic_path.ts
-import { z as z37 } from "zod";
-var schematic_path = z37.object({
-  type: z37.literal("schematic_path"),
-  schematic_component_id: z37.string(),
-  fill_color: z37.enum(["red", "blue"]).optional(),
-  is_filled: z37.boolean().optional(),
-  points: z37.array(point)
+import { z as z38 } from "zod";
+var schematic_path = z38.object({
+  type: z38.literal("schematic_path"),
+  schematic_component_id: z38.string(),
+  fill_color: z38.enum(["red", "blue"]).optional(),
+  is_filled: z38.boolean().optional(),
+  points: z38.array(point)
 });
 expectTypesMatch(true);
 
 // src/schematic/schematic_component.ts
-import { z as z38 } from "zod";
-var schematic_pin_styles = z38.record(
-  z38.object({
+import { z as z39 } from "zod";
+var schematic_pin_styles = z39.record(
+  z39.object({
     left_margin: length.optional(),
     right_margin: length.optional(),
     top_margin: length.optional(),
     bottom_margin: length.optional()
   })
 );
-var schematic_component_port_arrangement_by_size = z38.object({
-  left_size: z38.number(),
-  right_size: z38.number(),
-  top_size: z38.number().optional(),
-  bottom_size: z38.number().optional()
+var schematic_component_port_arrangement_by_size = z39.object({
+  left_size: z39.number(),
+  right_size: z39.number(),
+  top_size: z39.number().optional(),
+  bottom_size: z39.number().optional()
 });
 expectTypesMatch(true);
-var schematic_component_port_arrangement_by_sides = z38.object({
-  left_side: z38.object({
-    pins: z38.array(z38.number()),
+var schematic_component_port_arrangement_by_sides = z39.object({
+  left_side: z39.object({
+    pins: z39.array(z39.number()),
     // @ts-ignore
-    direction: z38.enum(["top-to-bottom", "bottom-to-top"]).optional()
+    direction: z39.enum(["top-to-bottom", "bottom-to-top"]).optional()
   }).optional(),
-  right_side: z38.object({
-    pins: z38.array(z38.number()),
+  right_side: z39.object({
+    pins: z39.array(z39.number()),
     // @ts-ignore
-    direction: z38.enum(["top-to-bottom", "bottom-to-top"]).optional()
+    direction: z39.enum(["top-to-bottom", "bottom-to-top"]).optional()
   }).optional(),
-  top_side: z38.object({
-    pins: z38.array(z38.number()),
+  top_side: z39.object({
+    pins: z39.array(z39.number()),
     // @ts-ignore
-    direction: z38.enum(["left-to-right", "right-to-left"]).optional()
+    direction: z39.enum(["left-to-right", "right-to-left"]).optional()
   }).optional(),
-  bottom_side: z38.object({
-    pins: z38.array(z38.number()),
+  bottom_side: z39.object({
+    pins: z39.array(z39.number()),
     // @ts-ignore
-    direction: z38.enum(["left-to-right", "right-to-left"]).optional()
+    direction: z39.enum(["left-to-right", "right-to-left"]).optional()
   }).optional()
 });
 expectTypesMatch(true);
-var port_arrangement = z38.union([
+var port_arrangement = z39.union([
   schematic_component_port_arrangement_by_size,
   schematic_component_port_arrangement_by_sides
 ]);
-var schematic_component = z38.object({
-  type: z38.literal("schematic_component"),
+var schematic_component = z39.object({
+  type: z39.literal("schematic_component"),
   size,
   center: point,
-  source_component_id: z38.string(),
-  schematic_component_id: z38.string(),
+  source_component_id: z39.string(),
+  schematic_component_id: z39.string(),
   pin_spacing: length.optional(),
   pin_styles: schematic_pin_styles.optional(),
   box_width: length.optional(),
-  symbol_name: z38.string().optional(),
+  symbol_name: z39.string().optional(),
   port_arrangement: port_arrangement.optional(),
-  port_labels: z38.record(z38.string()).optional(),
-  symbol_display_value: z38.string().optional(),
-  subcircuit_id: z38.string().optional(),
-  schematic_group_id: z38.string().optional()
+  port_labels: z39.record(z39.string()).optional(),
+  symbol_display_value: z39.string().optional(),
+  subcircuit_id: z39.string().optional(),
+  schematic_group_id: z39.string().optional()
 });
 expectTypesMatch(true);
 
 // src/schematic/schematic_line.ts
-import { z as z39 } from "zod";
-var schematic_line = z39.object({
-  type: z39.literal("schematic_line"),
-  schematic_component_id: z39.string(),
+import { z as z40 } from "zod";
+var schematic_line = z40.object({
+  type: z40.literal("schematic_line"),
+  schematic_component_id: z40.string(),
   x1: distance,
   x2: distance,
   y1: distance,
@@ -708,30 +725,30 @@ var schematic_line = z39.object({
 expectTypesMatch(true);
 
 // src/schematic/schematic_trace.ts
-import { z as z40 } from "zod";
-var schematic_trace = z40.object({
-  type: z40.literal("schematic_trace"),
-  schematic_trace_id: z40.string(),
-  source_trace_id: z40.string(),
-  junctions: z40.array(
-    z40.object({
-      x: z40.number(),
-      y: z40.number()
+import { z as z41 } from "zod";
+var schematic_trace = z41.object({
+  type: z41.literal("schematic_trace"),
+  schematic_trace_id: z41.string(),
+  source_trace_id: z41.string(),
+  junctions: z41.array(
+    z41.object({
+      x: z41.number(),
+      y: z41.number()
     })
   ),
-  edges: z40.array(
-    z40.object({
-      from: z40.object({
-        x: z40.number(),
-        y: z40.number()
+  edges: z41.array(
+    z41.object({
+      from: z41.object({
+        x: z41.number(),
+        y: z41.number()
       }),
-      to: z40.object({
-        x: z40.number(),
-        y: z40.number()
+      to: z41.object({
+        x: z41.number(),
+        y: z41.number()
       }),
-      is_crossing: z40.boolean().optional(),
-      from_schematic_port_id: z40.string().optional(),
-      to_schematic_port_id: z40.string().optional()
+      is_crossing: z41.boolean().optional(),
+      from_schematic_port_id: z41.string().optional(),
+      to_schematic_port_id: z41.string().optional()
     })
   )
 });
@@ -740,20 +757,6 @@ expectTypesMatch(true);
 // src/schematic/schematic_text.ts
 import { z as z43 } from "zod";
 
-// src/common/NinePointAnchor.ts
-import { z as z41 } from "zod";
-var ninePointAnchor = z41.enum([
-  "top_left",
-  "top_center",
-  "top_right",
-  "center_left",
-  "center",
-  "center_right",
-  "bottom_left",
-  "bottom_center",
-  "bottom_right"
-]);
-
 // src/common/FivePointAnchor.ts
 import { z as z42 } from "zod";
 var fivePointAnchor = z42.enum([
@@ -1817,6 +1820,7 @@ export {
   layer_ref,
   layer_string,
   length,
+  ninePointAnchor,
   pcb_autorouting_error,
   pcb_board,
   pcb_breakout_point,