@tmlmobilidade/types 20260121.2332.6 → 20260128.2248.28

package/dist/offer/pattern.js

@@ -0,0 +1,75 @@
+/* * */
+import { DocumentSchema } from '../_common/document.js';
+import { StopSchema } from '../stops/stop.js';
+import { z } from 'zod';
+import { ScheduleRuleSchema } from './scheduleRule.js';
+/* * */
+export const directionOptions = [
+    { label: 'Ida', value: '0' },
+    { label: 'Volta', value: '1' },
+];
+/* * */
+export const PathSchema = z.object({
+    _id: z.string(),
+    allow_drop_off: z.boolean().default(true),
+    allow_pickup: z.boolean().default(true),
+    distance_delta: z.number().nullable().default(null),
+    stop: StopSchema.nullable().optional(),
+    stop_id: z.string(),
+    timepoint: z.boolean().default(true),
+    zones: z.array(z.string()).optional(),
+});
+/* * */
+export const PatternSchema = DocumentSchema.extend({
+    code: z.string().trim().min(1).max(10),
+    destination: z.string().trim().min(1).max(100),
+    direction: z.enum(['0', '1']).default('0'),
+    headsign: z.string().trim().min(1).max(100),
+    is_locked: z.boolean().default(false),
+    line_id: z.string(),
+    origin: z.string().trim().min(1).max(100),
+    path: z.array(PathSchema).optional(),
+    presets: z.object({
+        dwell_time: z.number().default(0),
+        velocity: z.number().default(20),
+    }).optional(),
+    route_id: z.string(),
+    rules: z.array(ScheduleRuleSchema).optional().default([]),
+    shape: z.object({
+        extension: z.number(),
+        geojson: z.object({
+            geometry: z.object({
+                coordinates: z.array(z.array(z.number())),
+                type: z.string().default('LineString'),
+            }),
+            properties: z.object({}).optional(),
+            type: z.string().default('Feature'),
+        }),
+    }).optional(),
+});
+export const PatternSimplifiedSchema = z.object({
+    _id: z.string(),
+    code: z.string().trim().min(1).max(10),
+    headsign: z.string().trim().min(1).max(100),
+    line_id: z.string(),
+    route_id: z.string(),
+});
+/* * */
+export const CreatePatternSchema = PatternSchema.omit({ _id: true, created_at: true, updated_at: true });
+export const UpdatePatternSchema = CreatePatternSchema
+    .omit({ created_by: true })
+    .partial();
+/* * */
+/**
+ * Pattern with populated stop data (returned by API)
+ */
+// export interface PatternWithStops extends Pattern {
+// 	path?: (Path & {
+// 		stop?: null | {
+// 			_id: string
+// 			latitude: number
+// 			longitude: number
+// 			name: string
+// 		}
+// 	})[]
+// }

package/dist/offer/route.d.ts

@@ -0,0 +1,187 @@
+import { z } from 'zod';
+export declare const PATH_TYPE: {
+    readonly BASE: "0";
+    readonly PARCEL: "1";
+    readonly VARIANT: "2";
+};
+export declare const pathTypeOptions: ({
+    label: string;
+    value: "0";
+} | {
+    label: string;
+    value: "1";
+} | {
+    label: string;
+    value: "2";
+})[];
+export declare const RouteSchema: z.ZodObject<{
+    _id: z.ZodString;
+    created_at: z.ZodEffects<z.ZodNumber, import("../index.js").UnixTimestamp, number>;
+    created_by: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    is_locked: z.ZodDefault<z.ZodBoolean>;
+    updated_at: z.ZodEffects<z.ZodNumber, import("../index.js").UnixTimestamp, number>;
+    updated_by: z.ZodOptional<z.ZodString>;
+} & {
+    code: z.ZodString;
+    line_id: z.ZodString;
+    name: z.ZodString;
+    path_type: z.ZodDefault<z.ZodNativeEnum<{
+        readonly BASE: "0";
+        readonly PARCEL: "1";
+        readonly VARIANT: "2";
+    }>>;
+    patterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        _id: z.ZodString;
+        code: z.ZodString;
+        headsign: z.ZodString;
+        line_id: z.ZodString;
+        route_id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        _id: string;
+        code: string;
+        line_id: string;
+        headsign: string;
+        route_id: string;
+    }, {
+        _id: string;
+        code: string;
+        line_id: string;
+        headsign: string;
+        route_id: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    _id: string;
+    created_at: number & {
+        __brand: "UnixTimestamp";
+    };
+    created_by: string | null;
+    is_locked: boolean;
+    updated_at: number & {
+        __brand: "UnixTimestamp";
+    };
+    code: string;
+    name: string;
+    line_id: string;
+    path_type: "0" | "1" | "2";
+    updated_by?: string | undefined;
+    patterns?: {
+        _id: string;
+        code: string;
+        line_id: string;
+        headsign: string;
+        route_id: string;
+    }[] | undefined;
+}, {
+    _id: string;
+    created_at: number;
+    updated_at: number;
+    code: string;
+    name: string;
+    line_id: string;
+    created_by?: string | null | undefined;
+    is_locked?: boolean | undefined;
+    updated_by?: string | undefined;
+    path_type?: "0" | "1" | "2" | undefined;
+    patterns?: {
+        _id: string;
+        code: string;
+        line_id: string;
+        headsign: string;
+        route_id: string;
+    }[] | undefined;
+}>;
+export declare const RouteSimplifiedSchema: z.ZodObject<{
+    _id: z.ZodString;
+    code: z.ZodString;
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    _id: string;
+    code: string;
+    name: string;
+}, {
+    _id: string;
+    code: string;
+    name: string;
+}>;
+export declare const CreateRouteSchema: z.ZodObject<Omit<{
+    _id: z.ZodString;
+    created_at: z.ZodEffects<z.ZodNumber, import("../index.js").UnixTimestamp, number>;
+    created_by: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    is_locked: z.ZodDefault<z.ZodBoolean>;
+    updated_at: z.ZodEffects<z.ZodNumber, import("../index.js").UnixTimestamp, number>;
+    updated_by: z.ZodOptional<z.ZodString>;
+} & {
+    code: z.ZodString;
+    line_id: z.ZodString;
+    name: z.ZodString;
+    path_type: z.ZodDefault<z.ZodNativeEnum<{
+        readonly BASE: "0";
+        readonly PARCEL: "1";
+        readonly VARIANT: "2";
+    }>>;
+    patterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        _id: z.ZodString;
+        code: z.ZodString;
+        headsign: z.ZodString;
+        line_id: z.ZodString;
+        route_id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        _id: string;
+        code: string;
+        line_id: string;
+        headsign: string;
+        route_id: string;
+    }, {
+        _id: string;
+        code: string;
+        line_id: string;
+        headsign: string;
+        route_id: string;
+    }>, "many">>;
+}, "_id" | "created_at" | "updated_at" | "patterns">, "strip", z.ZodTypeAny, {
+    created_by: string | null;
+    is_locked: boolean;
+    code: string;
+    name: string;
+    line_id: string;
+    path_type: "0" | "1" | "2";
+    updated_by?: string | undefined;
+}, {
+    code: string;
+    name: string;
+    line_id: string;
+    created_by?: string | null | undefined;
+    is_locked?: boolean | undefined;
+    updated_by?: string | undefined;
+    path_type?: "0" | "1" | "2" | undefined;
+}>;
+export declare const UpdateRouteSchema: z.ZodObject<{
+    is_locked: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    updated_by: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    code: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    line_id: z.ZodOptional<z.ZodString>;
+    path_type: z.ZodOptional<z.ZodDefault<z.ZodNativeEnum<{
+        readonly BASE: "0";
+        readonly PARCEL: "1";
+        readonly VARIANT: "2";
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    is_locked?: boolean | undefined;
+    updated_by?: string | undefined;
+    code?: string | undefined;
+    name?: string | undefined;
+    line_id?: string | undefined;
+    path_type?: "0" | "1" | "2" | undefined;
+}, {
+    is_locked?: boolean | undefined;
+    updated_by?: string | undefined;
+    code?: string | undefined;
+    name?: string | undefined;
+    line_id?: string | undefined;
+    path_type?: "0" | "1" | "2" | undefined;
+}>;
+export type Route = z.infer<typeof RouteSchema>;
+export type CreateRouteDto = z.infer<typeof CreateRouteSchema>;
+export type UpdateRouteDto = z.infer<typeof UpdateRouteSchema>;
+export type RouteSimplified = z.infer<typeof RouteSimplifiedSchema>;

package/dist/offer/route.js

@@ -0,0 +1,33 @@
+/* * */
+import { DocumentSchema } from '../_common/document.js';
+import { z } from 'zod';
+import { PatternSimplifiedSchema } from './pattern.js';
+/* * */
+export const PATH_TYPE = {
+    BASE: '0',
+    PARCEL: '1',
+    VARIANT: '2',
+};
+export const pathTypeOptions = [
+    { label: 'Rota Base (Principal)', value: PATH_TYPE.BASE },
+    { label: 'Parcelar', value: PATH_TYPE.PARCEL },
+    { label: 'Variante', value: PATH_TYPE.VARIANT },
+];
+/* * */
+export const RouteSchema = DocumentSchema.extend({
+    code: z.string().trim().min(1).max(10),
+    line_id: z.string(),
+    name: z.string().trim().min(1).max(50),
+    path_type: z.nativeEnum(PATH_TYPE).default(PATH_TYPE.BASE),
+    patterns: z.array(PatternSimplifiedSchema).optional(),
+});
+export const RouteSimplifiedSchema = z.object({
+    _id: z.string(),
+    code: z.string().trim().min(1).max(10),
+    name: z.string().trim().min(1).max(50),
+});
+/* * */
+export const CreateRouteSchema = RouteSchema.omit({ _id: true, created_at: true, patterns: true, updated_at: true });
+export const UpdateRouteSchema = CreateRouteSchema
+    .omit({ created_by: true })
+    .partial();

package/dist/offer/scheduleRule.d.ts

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+export declare enum OPERATING_MODE {
+    EXCLUDE = "exclude",
+    INCLUDE = "include"
+}
+export declare const ScheduleRuleSchema: z.ZodObject<{
+    _id: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    operatingMode: z.ZodNativeEnum<typeof OPERATING_MODE>;
+    periodIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    weekdays: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<{
+        readonly Fri: 5;
+        readonly Mon: 1;
+        readonly Sat: 6;
+        readonly Sun: 7;
+        readonly Thu: 4;
+        readonly Tue: 2;
+        readonly Wed: 3;
+    }>, "many">>;
+    holidays: z.ZodOptional<z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+        mode: z.ZodLiteral<"ignore">;
+    }, "strip", z.ZodTypeAny, {
+        mode: "ignore";
+    }, {
+        mode: "ignore";
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"all">;
+    }, "strip", z.ZodTypeAny, {
+        mode: "all";
+    }, {
+        mode: "all";
+    }>, z.ZodObject<{
+        ids: z.ZodArray<z.ZodString, "many">;
+        mode: z.ZodLiteral<"specific">;
+    }, "strip", z.ZodTypeAny, {
+        mode: "specific";
+        ids: string[];
+    }, {
+        mode: "specific";
+        ids: string[];
+    }>]>>;
+    events: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    travelTime: z.ZodOptional<z.ZodString>;
+    timePoints: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    operatingMode: OPERATING_MODE;
+    timePoints: string[];
+    _id?: string | undefined;
+    name?: string | undefined;
+    periodIds?: string[] | undefined;
+    weekdays?: (1 | 2 | 3 | 5 | 4 | 6 | 7)[] | undefined;
+    holidays?: {
+        mode: "ignore";
+    } | {
+        mode: "all";
+    } | {
+        mode: "specific";
+        ids: string[];
+    } | undefined;
+    events?: string[] | undefined;
+    travelTime?: string | undefined;
+}, {
+    operatingMode: OPERATING_MODE;
+    timePoints: string[];
+    _id?: string | undefined;
+    name?: string | undefined;
+    periodIds?: string[] | undefined;
+    weekdays?: (1 | 2 | 3 | 5 | 4 | 6 | 7)[] | undefined;
+    holidays?: {
+        mode: "ignore";
+    } | {
+        mode: "all";
+    } | {
+        mode: "specific";
+        ids: string[];
+    } | undefined;
+    events?: string[] | undefined;
+    travelTime?: string | undefined;
+}>;
+export type ScheduleRule = z.infer<typeof ScheduleRuleSchema>;

package/dist/offer/scheduleRule.js

@@ -0,0 +1,50 @@
+// interface Rule {
+//   operatingMode: 'include' | 'exclude'; // include = schedules operate, exclude = schedules do not operate
+//   periodIds: string[]; // e.g., ["escolar", "ferias"]
+//   weekdays?: string[]; // ["Mon", "Tue", ...], optional
+//   holidays?: {
+//     all?: boolean;          // applies to all holidays
+//     specific?: string[];    // holidayIds this rule applies to
+//   };
+//   events?: string[]; // list of event IDs or names this rule applies to
+//   travelTime?: string; // optional travel info
+// }
+import { WEEKDAYS } from '../dates/date.js';
+import { z } from 'zod';
+/* * */
+export var OPERATING_MODE;
+(function (OPERATING_MODE) {
+    OPERATING_MODE["EXCLUDE"] = "exclude";
+    OPERATING_MODE["INCLUDE"] = "include";
+})(OPERATING_MODE || (OPERATING_MODE = {}));
+// Holidays schema
+const HolidaysSchema = z.discriminatedUnion('mode', [
+    z.object({
+        mode: z.literal('ignore'),
+    }),
+    z.object({
+        mode: z.literal('all'),
+    }),
+    z.object({
+        ids: z.array(z.string()).min(1),
+        mode: z.literal('specific'),
+    }),
+]);
+/* * */
+export const ScheduleRuleSchema = z.object({
+    _id: z.string().optional(), // Client-side ID for tracking
+    name: z.string().optional(),
+    operatingMode: z.nativeEnum(OPERATING_MODE),
+    // Can reference multiple periods by ID
+    periodIds: z.array(z.string()).optional(),
+    // Optional weekdays filter
+    weekdays: z.array(z.nativeEnum(WEEKDAYS)).optional(),
+    // Optional holidays filter
+    holidays: HolidaysSchema.optional(),
+    // Optional events
+    events: z.array(z.string()).optional(),
+    // Optional travel time
+    travelTime: z.string().optional(),
+    // Optional timepoints when this rule applies (HH:mm format)
+    timePoints: z.array(z.string().regex(/^([0-1]?[0-9]|2[0-3]):[0-5][0-9]$/)),
+});

package/dist/offer/typology.d.ts

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+export declare const TypologySchema: z.ZodObject<{
+    _id: z.ZodString;
+    created_at: z.ZodEffects<z.ZodNumber, import("../index.js").UnixTimestamp, number>;
+    created_by: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    updated_at: z.ZodEffects<z.ZodNumber, import("../index.js").UnixTimestamp, number>;
+    updated_by: z.ZodOptional<z.ZodString>;
+} & {
+    agency_ids: z.ZodArray<z.ZodString, "many">;
+    code: z.ZodString;
+    color: z.ZodString;
+    default_onboard_fare_ids: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+    default_prepaid_fare_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    is_locked: z.ZodDefault<z.ZodBoolean>;
+    name: z.ZodString;
+    text_color: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    _id: string;
+    created_at: number & {
+        __brand: "UnixTimestamp";
+    };
+    created_by: string | null;
+    is_locked: boolean;
+    updated_at: number & {
+        __brand: "UnixTimestamp";
+    };
+    code: string;
+    name: string;
+    agency_ids: string[];
+    color: string;
+    default_onboard_fare_ids: string[] | null;
+    default_prepaid_fare_id: string | null;
+    text_color: string;
+    updated_by?: string | undefined;
+}, {
+    _id: string;
+    created_at: number;
+    updated_at: number;
+    code: string;
+    name: string;
+    agency_ids: string[];
+    color: string;
+    text_color: string;
+    created_by?: string | null | undefined;
+    is_locked?: boolean | undefined;
+    updated_by?: string | undefined;
+    default_onboard_fare_ids?: string[] | null | undefined;
+    default_prepaid_fare_id?: string | null | undefined;
+}>;
+export declare const CreateTypologySchema: z.ZodObject<{
+    agency_ids: z.ZodArray<z.ZodString, "many">;
+    code: z.ZodString;
+    name: z.ZodString;
+} & {
+    _id: z.ZodOptional<z.ZodString>;
+    created_by: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
+    is_locked: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    updated_by: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    color: z.ZodOptional<z.ZodString>;
+    default_onboard_fare_ids: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>>;
+    default_prepaid_fare_id: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
+    text_color: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    name: string;
+    agency_ids: string[];
+    _id?: string | undefined;
+    created_by?: string | null | undefined;
+    is_locked?: boolean | undefined;
+    updated_by?: string | undefined;
+    color?: string | undefined;
+    default_onboard_fare_ids?: string[] | null | undefined;
+    default_prepaid_fare_id?: string | null | undefined;
+    text_color?: string | undefined;
+}, {
+    code: string;
+    name: string;
+    agency_ids: string[];
+    _id?: string | undefined;
+    created_by?: string | null | undefined;
+    is_locked?: boolean | undefined;
+    updated_by?: string | undefined;
+    color?: string | undefined;
+    default_onboard_fare_ids?: string[] | null | undefined;
+    default_prepaid_fare_id?: string | null | undefined;
+    text_color?: string | undefined;
+}>;
+export declare const UpdateTypologySchema: z.ZodObject<{
+    _id: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    is_locked: z.ZodOptional<z.ZodOptional<z.ZodDefault<z.ZodBoolean>>>;
+    updated_by: z.ZodOptional<z.ZodOptional<z.ZodOptional<z.ZodString>>>;
+    code: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    agency_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    color: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    default_onboard_fare_ids: z.ZodOptional<z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>>>;
+    default_prepaid_fare_id: z.ZodOptional<z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>>;
+    text_color: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    _id?: string | undefined;
+    is_locked?: boolean | undefined;
+    updated_by?: string | undefined;
+    code?: string | undefined;
+    name?: string | undefined;
+    agency_ids?: string[] | undefined;
+    color?: string | undefined;
+    default_onboard_fare_ids?: string[] | null | undefined;
+    default_prepaid_fare_id?: string | null | undefined;
+    text_color?: string | undefined;
+}, {
+    _id?: string | undefined;
+    is_locked?: boolean | undefined;
+    updated_by?: string | undefined;
+    code?: string | undefined;
+    name?: string | undefined;
+    agency_ids?: string[] | undefined;
+    color?: string | undefined;
+    default_onboard_fare_ids?: string[] | null | undefined;
+    default_prepaid_fare_id?: string | null | undefined;
+    text_color?: string | undefined;
+}>;
+export type Typology = z.infer<typeof TypologySchema>;
+export type CreateTypologyDto = z.infer<typeof CreateTypologySchema>;
+export type UpdateTypologyDto = z.infer<typeof UpdateTypologySchema>;

package/dist/offer/typology.js

@@ -0,0 +1,30 @@
+/* * */
+import { DocumentSchema } from '../_common/document.js';
+import { z } from 'zod';
+/* * */
+export const TypologySchema = DocumentSchema.extend({
+    agency_ids: z.array(z.string()).min(1, 'At least one agency ID is required'),
+    code: z.string().trim().min(1).max(10),
+    color: z.string().trim().min(1).max(7), // Hex color code
+    default_onboard_fare_ids: z.array(z.string()).nullable().default(null),
+    default_prepaid_fare_id: z.string().nullable().default(null),
+    is_locked: z.boolean().default(false),
+    name: z.string().trim().min(1).max(50),
+    text_color: z.string().trim().min(1).max(7), // Hex color code
+});
+/* * */
+// Only name, code, and agency_ids are required for creation
+export const CreateTypologySchema = z.object({
+    agency_ids: TypologySchema.shape.agency_ids,
+    code: TypologySchema.shape.code,
+    name: TypologySchema.shape.name,
+}).merge(TypologySchema.omit({
+    agency_ids: true,
+    code: true,
+    created_at: true,
+    name: true,
+    updated_at: true,
+}).partial());
+export const UpdateTypologySchema = CreateTypologySchema
+    .omit({ created_by: true })
+    .partial();