@tmlmobilidade/go-types-gtfs-validator 20260828.1636.54

package/dist/clean/rule.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+/**
+ * Represents a comparison entry for a GTFS validaton rule.
+ */
+export declare const GtfsValidationRuleCompareSchema: z.ZodObject<{
+    key: z.ZodString;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    key: string;
+}, {
+    value: string;
+    key: string;
+}>;
+/**
+ * Represents a GTFS validator rule.
+ * @see https://github.com/google/transit/blob/master/gtfs/spec/en/reference.md#211-rules
+ */
+export declare const GtfsValidationRuleSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    compare: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        key: string;
+    }, {
+        value: string;
+        key: string;
+    }>, "many">>>;
+    depends_on: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
+    options: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
+    severity: z.ZodEnum<["ignore", "info", "warning", "error", "forbidden"]>;
+}, "strip", z.ZodTypeAny, {
+    severity: "ignore" | "info" | "warning" | "error" | "forbidden";
+    options?: string[] | undefined;
+    compare?: {
+        value: string;
+        key: string;
+    }[] | undefined;
+    depends_on?: string[] | undefined;
+}, {
+    severity: "ignore" | "info" | "warning" | "error" | "forbidden";
+    options?: string[] | undefined;
+    compare?: {
+        value: string;
+        key: string;
+    }[] | undefined;
+    depends_on?: string[] | undefined;
+}>>;
+export type GtfsValidationRule = z.infer<typeof GtfsValidationRuleSchema>;

package/dist/clean/rule.js

@@ -0,0 +1,20 @@
+/* * */
+import { SeverityStatusSchema } from '@tmlmobilidade/go-types-shared';
+import { z } from 'zod';
+/**
+ * Represents a comparison entry for a GTFS validaton rule.
+ */
+export const GtfsValidationRuleCompareSchema = z.object({
+    key: z.string(),
+    value: z.string(),
+});
+/**
+ * Represents a GTFS validator rule.
+ * @see https://github.com/google/transit/blob/master/gtfs/spec/en/reference.md#211-rules
+ */
+export const GtfsValidationRuleSchema = z.record(z.string(), z.object({
+    compare: z.array(GtfsValidationRuleCompareSchema).default([]).optional(),
+    depends_on: z.array(z.string()).default([]).optional(),
+    options: z.array(z.string()).default([]).optional(),
+    severity: SeverityStatusSchema,
+}));

package/dist/clean/summary.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+export declare const GtfsValidationSummarySchema: z.ZodObject<{
+    messages: z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        file_name: z.ZodString;
+        message: z.ZodString;
+        rows: z.ZodArray<z.ZodNumber, "many">;
+        rule_id: z.ZodString;
+        severity: z.ZodEnum<["ignore", "info", "warning", "error", "forbidden"]>;
+    }, "strip", z.ZodTypeAny, {
+        field: string;
+        file_name: string;
+        message: string;
+        rows: number[];
+        rule_id: string;
+        severity: "ignore" | "info" | "warning" | "error" | "forbidden";
+    }, {
+        field: string;
+        file_name: string;
+        message: string;
+        rows: number[];
+        rule_id: string;
+        severity: "ignore" | "info" | "warning" | "error" | "forbidden";
+    }>, "many">;
+    total_errors: z.ZodNumber;
+    total_warnings: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    messages: {
+        field: string;
+        file_name: string;
+        message: string;
+        rows: number[];
+        rule_id: string;
+        severity: "ignore" | "info" | "warning" | "error" | "forbidden";
+    }[];
+    total_errors: number;
+    total_warnings: number;
+}, {
+    messages: {
+        field: string;
+        file_name: string;
+        message: string;
+        rows: number[];
+        rule_id: string;
+        severity: "ignore" | "info" | "warning" | "error" | "forbidden";
+    }[];
+    total_errors: number;
+    total_warnings: number;
+}>;
+export type GtfsValidationSummary = z.infer<typeof GtfsValidationSummarySchema>;

package/dist/clean/summary.js

@@ -0,0 +1,9 @@
+/* * */
+import { GtfsValidationMessageSchema } from './message.js';
+import { z } from 'zod';
+/* * */
+export const GtfsValidationSummarySchema = z.object({
+    messages: z.array(GtfsValidationMessageSchema),
+    total_errors: z.number(),
+    total_warnings: z.number(),
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './output/index.js';
+export * from './rules/index.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './output/index.js';
+export * from './rules/index.js';

package/dist/output/index.d.ts

@@ -0,0 +1,2 @@
+export * from './message.js';
+export * from './summary.js';

package/dist/output/index.js

@@ -0,0 +1,2 @@
+export * from './message.js';
+export * from './summary.js';

package/dist/output/message.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const GtfsValidationOutputMessageSchema: z.ZodObject<{
+    field: z.ZodString;
+    file_name: z.ZodString;
+    message: z.ZodString;
+    rows: z.ZodArray<z.ZodNumber, "many">;
+    rule_id: z.ZodString;
+    severity: z.ZodEnum<["ignore", "info", "warning", "error", "forbidden"]>;
+}, "strip", z.ZodTypeAny, {
+    field: string;
+    file_name: string;
+    message: string;
+    rows: number[];
+    rule_id: string;
+    severity: "ignore" | "info" | "warning" | "error" | "forbidden";
+}, {
+    field: string;
+    file_name: string;
+    message: string;
+    rows: number[];
+    rule_id: string;
+    severity: "ignore" | "info" | "warning" | "error" | "forbidden";
+}>;
+export type GtfsValidationOutputMessage = z.infer<typeof GtfsValidationOutputMessageSchema>;

package/dist/output/message.js

@@ -0,0 +1,12 @@
+/* * */
+import { SeverityStatusSchema } from '@tmlmobilidade/go-types-shared';
+import { z } from 'zod';
+/* * */
+export const GtfsValidationOutputMessageSchema = z.object({
+    field: z.string(),
+    file_name: z.string(),
+    message: z.string(),
+    rows: z.array(z.number()),
+    rule_id: z.string(),
+    severity: SeverityStatusSchema,
+});

package/dist/output/summary.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+export declare const GtfsValidationOutputSummarySchema: z.ZodObject<{
+    messages: z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        file_name: z.ZodString;
+        message: z.ZodString;
+        rows: z.ZodArray<z.ZodNumber, "many">;
+        rule_id: z.ZodString;
+        severity: z.ZodEnum<["ignore", "info", "warning", "error", "forbidden"]>;
+    }, "strip", z.ZodTypeAny, {
+        field: string;
+        file_name: string;
+        message: string;
+        rows: number[];
+        rule_id: string;
+        severity: "ignore" | "info" | "warning" | "error" | "forbidden";
+    }, {
+        field: string;
+        file_name: string;
+        message: string;
+        rows: number[];
+        rule_id: string;
+        severity: "ignore" | "info" | "warning" | "error" | "forbidden";
+    }>, "many">;
+    total_errors: z.ZodNumber;
+    total_warnings: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    messages: {
+        field: string;
+        file_name: string;
+        message: string;
+        rows: number[];
+        rule_id: string;
+        severity: "ignore" | "info" | "warning" | "error" | "forbidden";
+    }[];
+    total_errors: number;
+    total_warnings: number;
+}, {
+    messages: {
+        field: string;
+        file_name: string;
+        message: string;
+        rows: number[];
+        rule_id: string;
+        severity: "ignore" | "info" | "warning" | "error" | "forbidden";
+    }[];
+    total_errors: number;
+    total_warnings: number;
+}>;
+export type GtfsValidationOutputSummary = z.infer<typeof GtfsValidationOutputSummarySchema>;

package/dist/output/summary.js

@@ -0,0 +1,9 @@
+/* * */
+import { GtfsValidationOutputMessageSchema } from './message.js';
+import { z } from 'zod';
+/* * */
+export const GtfsValidationOutputSummarySchema = z.object({
+    messages: z.array(GtfsValidationOutputMessageSchema),
+    total_errors: z.number(),
+    total_warnings: z.number(),
+});

package/dist/rule-types.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/rule-types.js

@@ -0,0 +1,295 @@
+// import { type RuleConfig, type WithCompare, type WithOptions } from '@/gtfs-rules/rules-info.js';
+// import { type SeverityLevel } from '@/gtfs-validation/severity-level.js';
+export {};
+// export interface GtfsRulesTypes {
+// 	agency: {
+// 		_file: SeverityLevel
+// 		agency_email_valid_address: RuleConfig
+// 		agency_fare_url_valid_url: RuleConfig
+// 		agency_id_matched_with_agency_name: WithCompare<RuleConfig>
+// 		agency_id_unique: WithOptions<RuleConfig>
+// 		agency_lang_valid_language_tag: RuleConfig
+// 		agency_name_present: WithOptions<RuleConfig>
+// 		agency_phone_valid_phone_number: RuleConfig
+// 		agency_timezone_valid_id: RuleConfig
+// 		agency_url_valid_url: RuleConfig
+// 	}
+// 	attributions: {
+// 		_file: SeverityLevel
+// 		agency_id: RuleConfig
+// 		attribution_email: RuleConfig
+// 		attribution_id: RuleConfig
+// 		attribution_phone: RuleConfig
+// 		attribution_url: RuleConfig
+// 		is_authority: RuleConfig
+// 		is_operator: RuleConfig
+// 		is_producer: RuleConfig
+// 		organization_name: RuleConfig
+// 		route_id: RuleConfig
+// 		trip_id: RuleConfig
+// 	}
+// 	calendar: {
+// 		_file: SeverityLevel
+// 		calendar_end_date_valid_yyyymmdd: RuleConfig
+// 		calendar_service_id_unique_non_empty: RuleConfig
+// 		calendar_start_date_valid_yyyymmdd: RuleConfig
+// 		friday: RuleConfig
+// 		monday: RuleConfig
+// 		saturday: RuleConfig
+// 		sunday: RuleConfig
+// 		thursday: RuleConfig
+// 		tuesday: RuleConfig
+// 		wednesday: RuleConfig
+// 	}
+// 	calendar_dates: {
+// 		_file: SeverityLevel
+// 		calendar_dates_service_id_references_calendar: RuleConfig
+// 		day_type: WithOptions<RuleConfig>
+// 		exception_date_valid_yyyymmdd: RuleConfig
+// 		exception_type_add_or_remove_service: RuleConfig
+// 		holiday: WithOptions<RuleConfig>
+// 		period: WithOptions<RuleConfig>
+// 	}
+// 	fare_attributes: {
+// 		_file: SeverityLevel
+// 		currency_type_valid: WithOptions<RuleConfig>
+// 		fare_attributes_agency_id_references_agency_table: RuleConfig
+// 		fare_id_unique: RuleConfig
+// 		fare_price_valid_non_negative_decimal: RuleConfig
+// 		payment_method_valid_gtfs_enum: WithOptions<RuleConfig>
+// 		transfer_duration_valid_seconds_range: RuleConfig
+// 		transfers_valid_gtfs_enum: WithOptions<RuleConfig>
+// 	}
+// 	fare_media: {
+// 		_file: SeverityLevel
+// 		fare_media_id_unique: RuleConfig
+// 		fare_media_name_non_empty: RuleConfig
+// 		fare_media_type_valid: WithOptions<RuleConfig>
+// 	}
+// 	fare_rules: {
+// 		_file: SeverityLevel
+// 		fare_rule_contains_id_references_zones_stops: RuleConfig
+// 		fare_rule_destination_id_references_zones_stops: RuleConfig
+// 		fare_rule_fare_id_references_fare_attributes: RuleConfig
+// 		fare_rule_origin_id_references_zones_stops: RuleConfig
+// 		fare_rule_route_id_references_routes: RuleConfig
+// 	}
+// 	feed_info: {
+// 		_file: SeverityLevel
+// 		default_lang_matches_feed_lang_when_present: RuleConfig
+// 		feed_contact_email_valid_address: RuleConfig
+// 		feed_contact_url_valid_http_url: RuleConfig
+// 		feed_end_date_valid_yyyymmdd_not_before_start: RuleConfig
+// 		feed_lang_valid_tag: WithOptions<RuleConfig>
+// 		feed_publisher_name_non_empty: RuleConfig
+// 		feed_publisher_url_valid_http_url: RuleConfig
+// 		feed_remarks: RuleConfig
+// 		feed_start_date_valid_yyyymmdd: RuleConfig
+// 		feed_type: WithOptions<RuleConfig>
+// 		feed_version_valid_identifier: RuleConfig
+// 	}
+// 	file_validation: {
+// 		_file: SeverityLevel
+// 		gtfs_feed_file_presence_and_integrity_rule: RuleConfig
+// 	}
+// 	frequencies: {
+// 		_file: SeverityLevel
+// 		exact_times_zero_when_timed_trip_uses_frequencies: RuleConfig
+// 		frequencies_trip_id_references_trips_table: RuleConfig
+// 		frequency_end_time_valid: RuleConfig
+// 		frequency_start_time_valid: RuleConfig
+// 		headway_secs_positive_and_aligns_trip: RuleConfig
+// 	}
+// 	levels: {
+// 		_file: SeverityLevel
+// 		level_id: RuleConfig
+// 		level_index: RuleConfig
+// 		level_name: RuleConfig
+// 	}
+// 	pathways: {
+// 		_file: SeverityLevel
+// 		from_stop_id: RuleConfig
+// 		is_bidirectional: RuleConfig
+// 		length: RuleConfig
+// 		max_slope: RuleConfig
+// 		min_width: RuleConfig
+// 		pathway_id: RuleConfig
+// 		pathway_mode: RuleConfig
+// 		reversed_signposted_as: RuleConfig
+// 		signposted_as: RuleConfig
+// 		stair_count: RuleConfig
+// 		to_stop_id: RuleConfig
+// 		traversal_time: RuleConfig
+// 	}
+// 	rider_categories: {
+// 		_file: SeverityLevel
+// 		at_most_one_default_fare_category: RuleConfig
+// 		eligibility_url_valid_http_url: RuleConfig
+// 		rider_category_id_unique: RuleConfig
+// 		rider_category_name_non_empty: RuleConfig
+// 	}
+// 	routes: {
+// 		_file: SeverityLevel
+// 		circular: WithOptions<RuleConfig>
+// 		continuous_drop_off_valid_gtfs_enum: WithOptions<RuleConfig>
+// 		continuous_pickup_valid_gtfs_enum: WithOptions<RuleConfig>
+// 		line_id: RuleConfig
+// 		line_long_name: RuleConfig
+// 		line_short_name: RuleConfig
+// 		network_id_references_networks_table: RuleConfig
+// 		path_type_valid_enum: WithOptions<RuleConfig>
+// 		route_agency_id_references_agency_table: RuleConfig
+// 		route_color_valid_hex_string: RuleConfig
+// 		route_desc_per_severity_and_content_rules: RuleConfig
+// 		route_id_unique: RuleConfig
+// 		route_long_name_or_short_name_present: RuleConfig
+// 		route_remarks: RuleConfig
+// 		route_short_name_or_long_name_present: RuleConfig
+// 		route_sort_order_non_negative_integer: RuleConfig
+// 		route_text_color_valid_hex_contrast: RuleConfig
+// 		route_type_valid_gtfs_enum: WithOptions<RuleConfig>
+// 		route_url_valid_http_url: RuleConfig
+// 		school: WithOptions<RuleConfig>
+// 	}
+// 	shapes: {
+// 		_file: SeverityLevel
+// 		shape_block_distance_rows_aggregated: WithOptions<RuleConfig>
+// 		shape_dist_traveled_delta_mismatches_haversine_block: WithOptions<RuleConfig>
+// 		shape_dist_traveled_delta_mismatches_haversine_segment: WithOptions<RuleConfig>
+// 		shape_dist_traveled_non_decreasing_with_sequence: RuleConfig
+// 		shape_dist_traveled_non_negative_monotonic: RuleConfig
+// 		shape_id_and_point_sequence_required: RuleConfig
+// 		shape_id_required: RuleConfig
+// 		shape_pt_lat_valid_latitude: RuleConfig
+// 		shape_pt_lon_valid_longitude: RuleConfig
+// 		shape_pt_sequence_not_repeated_within_shape: RuleConfig
+// 		shape_pt_sequence_strictly_increasing: RuleConfig
+// 		shape_sequence_position_mismatches_cumulative_traveled_distance: RuleConfig
+// 	}
+// 	stop_times: {
+// 		_file: SeverityLevel
+// 		arrival_time_ordering_with_departure_and_frequencies: RuleConfig
+// 		departure_time_ordering_with_arrival_and_timepoint: RuleConfig
+// 		drop_off_booking_rule_id_references_booking_rules_or_empty: RuleConfig
+// 		drop_off_type_valid_gtfs_enum: RuleConfig
+// 		end_pickup_drop_off_window_valid: RuleConfig
+// 		location_group_id_consistent_with_trip_id_and_stops: RuleConfig
+// 		pickup_booking_rule_id_references_booking_rules: RuleConfig
+// 		pickup_type_valid_gtfs_enum: RuleConfig
+// 		start_pickup_drop_off_window_valid: RuleConfig
+// 		stop_headsign_present: RuleConfig
+// 		stop_times_continuous_drop_off_valid_gtfs_enum: RuleConfig
+// 		stop_times_continuous_pickup_valid_gtfs_enum: RuleConfig
+// 		stop_times_shape_dist_traveled_non_decreasing_on_trip: RuleConfig
+// 		stop_times_stop_id_references_stops_table: RuleConfig
+// 		stop_times_trip_id_references_trips_table: RuleConfig
+// 		timepoint_valid_gtfs_enum: RuleConfig
+// 	}
+// 	stops: {
+// 		_file: SeverityLevel
+// 		has_bench_valid_enum: WithOptions<RuleConfig>
+// 		has_network_map_valid_enum: WithOptions<RuleConfig>
+// 		has_pip_real_time_valid_enum: WithOptions<RuleConfig>
+// 		has_schedules_valid_enum: WithOptions<RuleConfig>
+// 		has_shelter_valid_enum: WithOptions<RuleConfig>
+// 		has_stop_sign_valid_enum: WithOptions<RuleConfig>
+// 		has_tariffs_information_valid_enum: RuleConfig
+// 		level_id_valid_id: RuleConfig
+// 		location_type_valid_enum: RuleConfig
+// 		municipality_id_valid: WithOptions<RuleConfig>
+// 		parent_station_id_valid_for_stop_hierarchy: RuleConfig
+// 		parish_id_valid: RuleConfig
+// 		platform_code_valid: RuleConfig
+// 		public_visible_valid_enum: RuleConfig
+// 		region_id_valid: WithOptions<RuleConfig>
+// 		shelter_code_valid: RuleConfig
+// 		shelter_maintainer_valid: RuleConfig
+// 		stop_code_valid: RuleConfig
+// 		stop_desc_valid: RuleConfig
+// 		stop_id_unique: RuleConfig
+// 		stop_lat_valid_latitude_range: RuleConfig
+// 		stop_lon_valid_longitude_range: RuleConfig
+// 		stop_name_required_by_location_type: RuleConfig
+// 		stop_short_name_valid: RuleConfig
+// 		stop_timezone_valid: RuleConfig
+// 		stop_url_valid_url: RuleConfig
+// 		tts_stop_name_valid: RuleConfig
+// 		wheelchair_boarding_valid_enum: WithOptions<RuleConfig>
+// 		zone_id_valid: RuleConfig
+// 	}
+// 	transfers: {
+// 		_file: SeverityLevel
+// 		from_stop_id: RuleConfig
+// 		min_transfer_time: RuleConfig
+// 		to_stop_id: RuleConfig
+// 		transfer_type: RuleConfig
+// 	}
+// 	translations: {
+// 		_file: SeverityLevel
+// 		field_name: RuleConfig
+// 		field_value: RuleConfig
+// 		language: RuleConfig
+// 		record_id: RuleConfig
+// 		record_sub_id: RuleConfig
+// 		table_name: RuleConfig
+// 		translation: RuleConfig
+// 	}
+// 	trips: {
+// 		_file: SeverityLevel
+// 		bikes_allowed_valid_gtfs_enum: RuleConfig
+// 		block_id_in_allowed_set: RuleConfig
+// 		direction_id_consistent_for_all_patterns_in_trips: RuleConfig
+// 		direction_id_matches_feed_pattern_direction: RuleConfig
+// 		direction_id_valid_enum: RuleConfig
+// 		one_pattern_id_per_shape_id_group: RuleConfig
+// 		one_shape_id_per_pattern_id_group: RuleConfig
+// 		pattern_id_matches_feed_pattern_id_syntax: WithOptions<RuleConfig>
+// 		pattern_id_present_and_references_consistent: RuleConfig
+// 		pattern_id_single_trip_signature_per_pattern: RuleConfig
+// 		pattern_id_trip_has_required_fields_for_grouping: RuleConfig
+// 		route_id_consistent_for_all_patterns_in_trips: RuleConfig
+// 		route_id_references_routes_table: RuleConfig
+// 		service_id_references_calendar_service: RuleConfig
+// 		shape_id_needs_to_be_the_same_as_pattern_id: RuleConfig
+// 		shape_id_references_shapes_table_when_present: RuleConfig
+// 		stop_sequence_increasing_by_one_along_trip: RuleConfig
+// 		trip_headsign_consistent_for_all_patterns_in_trips: RuleConfig
+// 		trip_headsign_present_when_short_name_absent: RuleConfig
+// 		trip_id_limit_max_length: RuleConfig
+// 		trip_id_unique: RuleConfig
+// 		trip_path_stop_coordinates_referenced_from_stops: RuleConfig
+// 		trip_short_name_exclusivity: RuleConfig
+// 		wheelchair_accessible_valid_gtfs_enum: RuleConfig
+// 	}
+// 	vehicles: {
+// 		_file: SeverityLevel
+// 		available_seats_non_negative: RuleConfig
+// 		available_standing_non_negative: RuleConfig
+// 		bicycles_rack_count_non_negative: WithOptions<RuleConfig>
+// 		climatization_valid_enum: WithOptions<RuleConfig>
+// 		consumption_meter_valid_format: WithOptions<RuleConfig>
+// 		emission_code_valid_for_propulsion_type: WithOptions<RuleConfig>
+// 		external_sound_valid_enum: WithOptions<RuleConfig>
+// 		front_display_valid_enum: WithOptions<RuleConfig>
+// 		internal_sound_level_valid_enum: WithOptions<RuleConfig>
+// 		kneeling_valid_enum: WithOptions<RuleConfig>
+// 		license_plate_format_per_market_rules: RuleConfig
+// 		lowered_floor_valid_enum: WithOptions<RuleConfig>
+// 		onboard_monitor_valid_enum: WithOptions<RuleConfig>
+// 		passenger_counting_valid_enum: WithOptions<RuleConfig>
+// 		propulsion_type_valid_enum: WithOptions<RuleConfig>
+// 		ramp_valid_enum: WithOptions<RuleConfig>
+// 		rear_display_valid_enum: WithOptions<RuleConfig>
+// 		registration_date_valid_day_granularity: RuleConfig
+// 		side_display_valid_enum: WithOptions<RuleConfig>
+// 		static_information_valid_enum: WithOptions<RuleConfig>
+// 		typology_in_allowed_vehicle_types: WithOptions<RuleConfig>
+// 		vehicle_agency_id_references_agency_table: RuleConfig
+// 		vehicle_id_unique: RuleConfig
+// 		vehicle_make_required: RuleConfig
+// 		vehicle_model_required: RuleConfig
+// 		vehicle_owner_required: RuleConfig
+// 		video_surveillance_valid_enum: WithOptions<RuleConfig>
+// 		wheelchair_spots_valid_enum: WithOptions<RuleConfig>
+// 	}
+// };

package/dist/rules/compare.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+/**
+ * Represents a comparison entry for a GTFS validaton rule.
+ */
+export declare const GtfsValidationRuleCompareSchema: z.ZodObject<{
+    key: z.ZodString;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    key: string;
+}, {
+    value: string;
+    key: string;
+}>;

package/dist/rules/compare.js

@@ -0,0 +1,9 @@
+/* * */
+import { z } from 'zod';
+/**
+ * Represents a comparison entry for a GTFS validaton rule.
+ */
+export const GtfsValidationRuleCompareSchema = z.object({
+    key: z.string(),
+    value: z.string(),
+});

package/dist/rules/index.d.ts

@@ -0,0 +1,3 @@
+export * from './compare.js';
+export * from './rule.js';
+export * from './rules-config.js';

package/dist/rules/index.js

@@ -0,0 +1,3 @@
+export * from './compare.js';
+export * from './rule.js';
+export * from './rules-config.js';

package/dist/rules/rule.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+/**
+ * Represents a GTFS validator rule.
+ * @see https://github.com/google/transit/blob/master/gtfs/spec/en/reference.md#211-rules
+ */
+export declare const GtfsValidationRuleSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    compare: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        key: string;
+    }, {
+        value: string;
+        key: string;
+    }>, "many">>>;
+    depends_on: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
+    options: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
+    severity: z.ZodEnum<["ignore", "info", "warning", "error", "forbidden"]>;
+}, "strip", z.ZodTypeAny, {
+    severity: "ignore" | "info" | "warning" | "error" | "forbidden";
+    options?: string[] | undefined;
+    compare?: {
+        value: string;
+        key: string;
+    }[] | undefined;
+    depends_on?: string[] | undefined;
+}, {
+    severity: "ignore" | "info" | "warning" | "error" | "forbidden";
+    options?: string[] | undefined;
+    compare?: {
+        value: string;
+        key: string;
+    }[] | undefined;
+    depends_on?: string[] | undefined;
+}>>;
+export type GtfsValidationRule = z.infer<typeof GtfsValidationRuleSchema>;

package/dist/rules/rule.js

@@ -0,0 +1,14 @@
+/* * */
+import { GtfsValidationRuleCompareSchema } from './compare.js';
+import { SeverityStatusSchema } from '@tmlmobilidade/go-types-shared';
+import { z } from 'zod';
+/**
+ * Represents a GTFS validator rule.
+ * @see https://github.com/google/transit/blob/master/gtfs/spec/en/reference.md#211-rules
+ */
+export const GtfsValidationRuleSchema = z.record(z.string(), z.object({
+    compare: z.array(GtfsValidationRuleCompareSchema).default([]).optional(),
+    depends_on: z.array(z.string()).default([]).optional(),
+    options: z.array(z.string()).default([]).optional(),
+    severity: SeverityStatusSchema,
+}));

package/dist/rules/rules-config.d.ts

@@ -0,0 +1,2 @@
+import { GtfsValidationRule } from './rule.js';
+export declare const gtfsValidationRulesConfig: GtfsValidationRule;