export { C as CacheFlushDateScheduleInput, a as CacheFlushDateSchedules } from '../../cacheFlushDate-BK9e1T2n.mjs';
import { T as TerminalMatesInput, d as TerminalList } from '../../validDateRange.output-BosEyUNp.mjs';
export { c as Terminal, a as TerminalsInput, V as ValidDateRange, e as terminalListSchema, t as terminalMatesInputSchema, f as terminalSchema, b as terminalsInputSchema, v as validDateRangeSchema } from '../../validDateRange.output-BosEyUNp.mjs';
import { z } from 'zod';

/**
 * @fileoverview WSF Schedule API Input Schemas for Active Seasons
 *
 * This module provides Zod schemas for validating input parameters for the WSF
 * Schedule API endpoints related to active seasons operations.
 */

/**
 * Schema for ActiveScheduledSeasons input parameters
 *
 * This operation retrieves a summary of active seasons. */
declare const activeSeasonsInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
type ActiveSeasonsInput = z.infer<typeof activeSeasonsInputSchema>;

/**
 * @fileoverview WSF Schedule API Output Schemas for Active Seasons
 *
 * This module provides Zod schemas for validating responses from the WSF
 * Schedule API active seasons operations.
 */

/**
 * Base schedule schema containing common schedule fields
 *
 * This operation retrieves a summary of active seasons.
 */
declare const scheduleBaseSchema: z.ZodObject<{
    ScheduleID: z.ZodNumber;
    ScheduleName: z.ZodString;
    ScheduleSeason: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
    SchedulePDFUrl: z.ZodString;
    ScheduleStart: z.ZodDate;
    ScheduleEnd: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    ScheduleID: number;
    ScheduleName: string;
    ScheduleSeason: 0 | 2 | 1 | 3;
    SchedulePDFUrl: string;
    ScheduleStart: Date;
    ScheduleEnd: Date;
}, {
    ScheduleID: number;
    ScheduleName: string;
    ScheduleSeason: 0 | 2 | 1 | 3;
    SchedulePDFUrl: string;
    ScheduleStart: Date;
    ScheduleEnd: Date;
}>;
type ScheduleBase = z.infer<typeof scheduleBaseSchema>;
/**
 * Schema for ActiveSeason - represents active season information
 */
declare const activeSeasonSchema: z.ZodObject<{
    ScheduleID: z.ZodNumber;
    ScheduleName: z.ZodString;
    ScheduleSeason: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
    SchedulePDFUrl: z.ZodString;
    ScheduleStart: z.ZodDate;
    ScheduleEnd: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    ScheduleID: number;
    ScheduleName: string;
    ScheduleSeason: 0 | 2 | 1 | 3;
    SchedulePDFUrl: string;
    ScheduleStart: Date;
    ScheduleEnd: Date;
}, {
    ScheduleID: number;
    ScheduleName: string;
    ScheduleSeason: 0 | 2 | 1 | 3;
    SchedulePDFUrl: string;
    ScheduleStart: Date;
    ScheduleEnd: Date;
}>;
type ActiveSeason = z.infer<typeof activeSeasonSchema>;

/**
 * @fileoverview WSF Schedule API Input Schemas for Routes
 *
 * This module provides Zod schemas for validating input parameters for the WSF
 * Schedule API endpoints related to route operations.
 */

/**
 * Schema for Routes input parameters
 *
 * This operation retrieves the most basic / brief information pertaining to routes. If only a trip date is included in the URL string, all routes available for that date of travel are returned. If a trip date, departing terminal and arriving terminal are included then routes in the resultset are filtered to match accordingly. Valid departing and arriving terminals may be found using `/terminalsandmates`. Similarly, a valid trip date may be determined using `/validdaterange`. Please format the trip date input as `'YYYY-MM-DD'` (eg. `'2014-04-01'` for a trip date occurring on April 1, 2014). */
declare const routesByTripDateInputSchema: z.ZodObject<{
    TripDate: z.ZodString;
    DepartingTerminalID: z.ZodOptional<z.ZodNumber>;
    ArrivingTerminalID: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    TripDate: string;
    DepartingTerminalID?: number | undefined;
    ArrivingTerminalID?: number | undefined;
}, {
    TripDate: string;
    DepartingTerminalID?: number | undefined;
    ArrivingTerminalID?: number | undefined;
}>;
type RoutesByTripDateInput = z.infer<typeof routesByTripDateInputSchema>;
/**
 * Schema for RoutesHavingServiceDisruptions input parameters
 *
 * This operation retrieves the most basic / brief information for routes currently associated with service disruptions. A valid trip date may be determined using `/validdaterange`. Please format the trip date input as `'YYYY-MM-DD'` (eg. `'2014-04-01'` for a trip date occurring on April 1, 2014). */
declare const routesHavingServiceDisruptionsByTripDateInputSchema: z.ZodObject<{
    TripDate: z.ZodString;
}, "strip", z.ZodTypeAny, {
    TripDate: string;
}, {
    TripDate: string;
}>;
type RoutesHavingServiceDisruptionsByTripDateInput = z.infer<typeof routesHavingServiceDisruptionsByTripDateInputSchema>;
/**
 * Schema for RouteDetails input parameters
 *
 * This operation retrieves highly detailed information pertaining to routes. If only a trip date is included in the URL string, all routes available for that date of travel are returned. If a trip date, departing terminal and arriving terminal are included then routes in the resultset are filtered to match accordingly. Along the same lines, including only a trip date and route will filter the resultset to a single route. Valid departing and arriving terminals may be found using `/terminalsandmates` while valid routes may be found using `/routes`. Similarly, a valid trip date may be determined using `/validdaterange`. Please format the trip date input as `'YYYY-MM-DD'` (eg. `'2014-04-01'` for a trip date occurring on April 1, 2014). */
declare const routeDetailsSchema: z.ZodObject<{
    /** The trip date in 'YYYY-MM-DD' format (e.g., '2014-04-01'). */
    TripDate: z.ZodString;
    /** Unique identifier for the departing terminal. */
    DepartingTerminalID: z.ZodOptional<z.ZodNumber>;
    /** Unique identifier for the arriving terminal. */
    ArrivingTerminalID: z.ZodOptional<z.ZodNumber>;
    /** Unique identifier for a route. */
    RouteID: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    TripDate: string;
    DepartingTerminalID?: number | undefined;
    ArrivingTerminalID?: number | undefined;
    RouteID?: number | undefined;
}, {
    TripDate: string;
    DepartingTerminalID?: number | undefined;
    ArrivingTerminalID?: number | undefined;
    RouteID?: number | undefined;
}>;
type RouteDetailsInput = z.infer<typeof routeDetailsSchema>;
/**
 * Schema for RouteDetailsByTripDate input parameters
 *
 * This operation retrieves highly detailed information pertaining to routes for a specific trip date.
 */
declare const routeDetailsByTripDateInputSchema: z.ZodObject<{
    TripDate: z.ZodString;
}, "strip", z.ZodTypeAny, {
    TripDate: string;
}, {
    TripDate: string;
}>;
type RouteDetailsByTripDateInput = z.infer<typeof routeDetailsByTripDateInputSchema>;
/**
 * Schema for RouteDetailsByTripDateAndRouteId input parameters
 *
 * This operation retrieves highly detailed information pertaining to a specific route for a specific trip date.
 */
declare const routeDetailsByTripDateAndRouteIdInputSchema: z.ZodObject<{
    TripDate: z.ZodString;
    RouteID: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    TripDate: string;
    RouteID: number;
}, {
    TripDate: string;
    RouteID: number;
}>;
type RouteDetailsByTripDateAndRouteIdInput = z.infer<typeof routeDetailsByTripDateAndRouteIdInputSchema>;
/**
 * Schema for RouteDetailsByTripDateAndTerminals input parameters
 *
 * This operation retrieves highly detailed information pertaining to routes for a specific trip date and terminal combination.
 */
declare const routeDetailsByTripDateAndTerminalsInputSchema: z.ZodObject<{
    TripDate: z.ZodString;
    DepartingTerminalID: z.ZodNumber;
    ArrivingTerminalID: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    TripDate: string;
    DepartingTerminalID: number;
    ArrivingTerminalID: number;
}, {
    TripDate: string;
    DepartingTerminalID: number;
    ArrivingTerminalID: number;
}>;
type RouteDetailsByTripDateAndTerminalsInput = z.infer<typeof routeDetailsByTripDateAndTerminalsInputSchema>;
/**
 * Schema for RoutesByTerminals input parameters
 *
 * This operation retrieves routes for a specific trip date and terminal combination.
 */
declare const routesByTripDateAndTerminalsInputSchema: z.ZodObject<{
    TripDate: z.ZodString;
    DepartingTerminalID: z.ZodNumber;
    ArrivingTerminalID: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    TripDate: string;
    DepartingTerminalID: number;
    ArrivingTerminalID: number;
}, {
    TripDate: string;
    DepartingTerminalID: number;
    ArrivingTerminalID: number;
}>;
type RoutesByTripDateAndTerminalsInput = z.infer<typeof routesByTripDateAndTerminalsInputSchema>;

/**
 * @fileoverview WSF Schedule API Output Schemas for Routes
 *
 * This module provides Zod schemas for validating responses from the WSF
 * Schedule API route operations.
 */

/**
 * Base route schema containing common route fields
 */
declare const routeBaseSchema: z.ZodObject<{
    RouteID: z.ZodNumber;
    RouteAbbrev: z.ZodNullable<z.ZodString>;
    Description: z.ZodNullable<z.ZodString>;
    RegionID: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    Description: string | null;
    RegionID: number;
    RouteID: number;
    RouteAbbrev: string | null;
}, {
    Description: string | null;
    RegionID: number;
    RouteID: number;
    RouteAbbrev: string | null;
}>;
type RouteBase = z.infer<typeof routeBaseSchema>;
/**
 * Schema for ServiceDisruption - represents service disruption information
 */
declare const serviceDisruptionSchema: z.ZodObject<{
    BulletinID: z.ZodNumber;
    BulletinFlag: z.ZodBoolean;
    PublishDate: z.ZodNullable<z.ZodDate>;
    DisruptionDescription: z.ZodString;
}, "strip", z.ZodTypeAny, {
    BulletinID: number;
    BulletinFlag: boolean;
    PublishDate: Date | null;
    DisruptionDescription: string;
}, {
    BulletinID: number;
    BulletinFlag: boolean;
    PublishDate: Date | null;
    DisruptionDescription: string;
}>;
type ServiceDisruption = z.infer<typeof serviceDisruptionSchema>;
/**
 * Service Disruptions List Schema - represents an list of service disruptions
 */
declare const serviceDisruptionsListSchema: z.ZodArray<z.ZodObject<{
    BulletinID: z.ZodNumber;
    BulletinFlag: z.ZodBoolean;
    PublishDate: z.ZodNullable<z.ZodDate>;
    DisruptionDescription: z.ZodString;
}, "strip", z.ZodTypeAny, {
    BulletinID: number;
    BulletinFlag: boolean;
    PublishDate: Date | null;
    DisruptionDescription: string;
}, {
    BulletinID: number;
    BulletinFlag: boolean;
    PublishDate: Date | null;
    DisruptionDescription: string;
}>, "many">;
type ServiceDisruptionList = z.infer<typeof serviceDisruptionsListSchema>;
/**
 * Schema for Route - represents basic route information
 */
declare const routeSchema: z.ZodObject<{
    RouteID: z.ZodNumber;
    RouteAbbrev: z.ZodNullable<z.ZodString>;
    Description: z.ZodNullable<z.ZodString>;
    RegionID: z.ZodNumber;
} & {
    ServiceDisruptions: z.ZodNullable<z.ZodArray<z.ZodObject<{
        BulletinID: z.ZodNumber;
        BulletinFlag: z.ZodBoolean;
        PublishDate: z.ZodNullable<z.ZodDate>;
        DisruptionDescription: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string;
    }, {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string;
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    Description: string | null;
    RegionID: number;
    RouteID: number;
    RouteAbbrev: string | null;
    ServiceDisruptions: {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string;
    }[] | null;
}, {
    Description: string | null;
    RegionID: number;
    RouteID: number;
    RouteAbbrev: string | null;
    ServiceDisruptions: {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string;
    }[] | null;
}>;
type Route = z.infer<typeof routeSchema>;
/**
 * Schema for Alert - represents alert information
 *
 * A Highway Alert.
 */
declare const routeAlertSchema: z.ZodObject<{
    BulletinID: z.ZodNumber;
    BulletinFlag: z.ZodBoolean;
    CommunicationFlag: z.ZodBoolean;
    PublishDate: z.ZodNullable<z.ZodDate>;
    AlertDescription: z.ZodNullable<z.ZodString>;
    DisruptionDescription: z.ZodNullable<z.ZodString>;
    AlertFullTitle: z.ZodString;
    AlertFullText: z.ZodNullable<z.ZodString>;
    IVRText: z.ZodNullable<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    BulletinID: number;
    BulletinFlag: boolean;
    PublishDate: Date | null;
    DisruptionDescription: string | null;
    CommunicationFlag: boolean;
    AlertDescription: string | null;
    AlertFullTitle: string;
    AlertFullText: string | null;
    IVRText: string | null;
}, {
    BulletinID: number;
    BulletinFlag: boolean;
    PublishDate: Date | null;
    DisruptionDescription: string | null;
    CommunicationFlag: boolean;
    AlertDescription: string | null;
    AlertFullTitle: string;
    AlertFullText: string | null;
    IVRText: string | null;
}>;
type RouteAlert = z.infer<typeof routeAlertSchema>;
/**
 * Alerts List Schema - represents an list of alerts
 */
declare const alertsListSchema: z.ZodArray<z.ZodObject<{
    BulletinID: z.ZodNumber;
    BulletinFlag: z.ZodBoolean;
    CommunicationFlag: z.ZodBoolean;
    PublishDate: z.ZodNullable<z.ZodDate>;
    AlertDescription: z.ZodNullable<z.ZodString>;
    DisruptionDescription: z.ZodNullable<z.ZodString>;
    AlertFullTitle: z.ZodString;
    AlertFullText: z.ZodNullable<z.ZodString>;
    IVRText: z.ZodNullable<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    BulletinID: number;
    BulletinFlag: boolean;
    PublishDate: Date | null;
    DisruptionDescription: string | null;
    CommunicationFlag: boolean;
    AlertDescription: string | null;
    AlertFullTitle: string;
    AlertFullText: string | null;
    IVRText: string | null;
}, {
    BulletinID: number;
    BulletinFlag: boolean;
    PublishDate: Date | null;
    DisruptionDescription: string | null;
    CommunicationFlag: boolean;
    AlertDescription: string | null;
    AlertFullTitle: string;
    AlertFullText: string | null;
    IVRText: string | null;
}>, "many">;
type AlertList = z.infer<typeof alertsListSchema>;
/**
 * Schema for RouteDetail - represents detailed route information
 */
declare const routeDetailSchema: z.ZodObject<{
    RouteID: z.ZodNumber;
    RouteAbbrev: z.ZodNullable<z.ZodString>;
    Description: z.ZodNullable<z.ZodString>;
    RegionID: z.ZodNumber;
} & {
    VesselWatchID: z.ZodNumber;
    ReservationFlag: z.ZodBoolean;
    InternationalFlag: z.ZodBoolean;
    PassengerOnlyFlag: z.ZodBoolean;
    CrossingTime: z.ZodNullable<z.ZodString>;
    AdaNotes: z.ZodNullable<z.ZodString>;
    GeneralRouteNotes: z.ZodNullable<z.ZodString>;
    SeasonalRouteNotes: z.ZodNullable<z.ZodString>;
    Alerts: z.ZodArray<z.ZodObject<{
        BulletinID: z.ZodNumber;
        BulletinFlag: z.ZodBoolean;
        CommunicationFlag: z.ZodBoolean;
        PublishDate: z.ZodNullable<z.ZodDate>;
        AlertDescription: z.ZodNullable<z.ZodString>;
        DisruptionDescription: z.ZodNullable<z.ZodString>;
        AlertFullTitle: z.ZodString;
        AlertFullText: z.ZodNullable<z.ZodString>;
        IVRText: z.ZodNullable<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string | null;
        CommunicationFlag: boolean;
        AlertDescription: string | null;
        AlertFullTitle: string;
        AlertFullText: string | null;
        IVRText: string | null;
    }, {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string | null;
        CommunicationFlag: boolean;
        AlertDescription: string | null;
        AlertFullTitle: string;
        AlertFullText: string | null;
        IVRText: string | null;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    Description: string | null;
    RegionID: number;
    RouteID: number;
    RouteAbbrev: string | null;
    VesselWatchID: number;
    ReservationFlag: boolean;
    InternationalFlag: boolean;
    PassengerOnlyFlag: boolean;
    CrossingTime: string | null;
    AdaNotes: string | null;
    GeneralRouteNotes: string | null;
    SeasonalRouteNotes: string | null;
    Alerts: {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string | null;
        CommunicationFlag: boolean;
        AlertDescription: string | null;
        AlertFullTitle: string;
        AlertFullText: string | null;
        IVRText: string | null;
    }[];
}, {
    Description: string | null;
    RegionID: number;
    RouteID: number;
    RouteAbbrev: string | null;
    VesselWatchID: number;
    ReservationFlag: boolean;
    InternationalFlag: boolean;
    PassengerOnlyFlag: boolean;
    CrossingTime: string | null;
    AdaNotes: string | null;
    GeneralRouteNotes: string | null;
    SeasonalRouteNotes: string | null;
    Alerts: {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string | null;
        CommunicationFlag: boolean;
        AlertDescription: string | null;
        AlertFullTitle: string;
        AlertFullText: string | null;
        IVRText: string | null;
    }[];
}>;
type RouteDetail = z.infer<typeof routeDetailSchema>;
/**
 * Schema for RouteDetailsList - represents a list of route details
 */
declare const routeDetailsListSchema: z.ZodArray<z.ZodObject<{
    RouteID: z.ZodNumber;
    RouteAbbrev: z.ZodNullable<z.ZodString>;
    Description: z.ZodNullable<z.ZodString>;
    RegionID: z.ZodNumber;
} & {
    VesselWatchID: z.ZodNumber;
    ReservationFlag: z.ZodBoolean;
    InternationalFlag: z.ZodBoolean;
    PassengerOnlyFlag: z.ZodBoolean;
    CrossingTime: z.ZodNullable<z.ZodString>;
    AdaNotes: z.ZodNullable<z.ZodString>;
    GeneralRouteNotes: z.ZodNullable<z.ZodString>;
    SeasonalRouteNotes: z.ZodNullable<z.ZodString>;
    Alerts: z.ZodArray<z.ZodObject<{
        BulletinID: z.ZodNumber;
        BulletinFlag: z.ZodBoolean;
        CommunicationFlag: z.ZodBoolean;
        PublishDate: z.ZodNullable<z.ZodDate>;
        AlertDescription: z.ZodNullable<z.ZodString>;
        DisruptionDescription: z.ZodNullable<z.ZodString>;
        AlertFullTitle: z.ZodString;
        AlertFullText: z.ZodNullable<z.ZodString>;
        IVRText: z.ZodNullable<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string | null;
        CommunicationFlag: boolean;
        AlertDescription: string | null;
        AlertFullTitle: string;
        AlertFullText: string | null;
        IVRText: string | null;
    }, {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string | null;
        CommunicationFlag: boolean;
        AlertDescription: string | null;
        AlertFullTitle: string;
        AlertFullText: string | null;
        IVRText: string | null;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    Description: string | null;
    RegionID: number;
    RouteID: number;
    RouteAbbrev: string | null;
    VesselWatchID: number;
    ReservationFlag: boolean;
    InternationalFlag: boolean;
    PassengerOnlyFlag: boolean;
    CrossingTime: string | null;
    AdaNotes: string | null;
    GeneralRouteNotes: string | null;
    SeasonalRouteNotes: string | null;
    Alerts: {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string | null;
        CommunicationFlag: boolean;
        AlertDescription: string | null;
        AlertFullTitle: string;
        AlertFullText: string | null;
        IVRText: string | null;
    }[];
}, {
    Description: string | null;
    RegionID: number;
    RouteID: number;
    RouteAbbrev: string | null;
    VesselWatchID: number;
    ReservationFlag: boolean;
    InternationalFlag: boolean;
    PassengerOnlyFlag: boolean;
    CrossingTime: string | null;
    AdaNotes: string | null;
    GeneralRouteNotes: string | null;
    SeasonalRouteNotes: string | null;
    Alerts: {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string | null;
        CommunicationFlag: boolean;
        AlertDescription: string | null;
        AlertFullTitle: string;
        AlertFullText: string | null;
        IVRText: string | null;
    }[];
}>, "many">;
type RouteDetailsList = z.infer<typeof routeDetailsListSchema>;

/**
 * @fileoverview WSF Schedule API Input Schemas for Sailings
 *
 * This module provides Zod schemas for validating input parameters for the WSF
 * Schedule API endpoints related to sailing operations.
 */

/**
 * Schema for SchedSailingsBySchedRoute input parameters
 *
 * This operation provides sailings for a particular scheduled route. Sailings are departure times organized by direction of travel (eastbound / westbound), days of operation groups (daily, weekday, weekend, etc) and, in some cases, date ranges (eg. Early Fall / Late Fall). Sailings largely mimic the groupings of departures found on the printed PDF version of the schedule. Scheduled routes may be determined using `/schedroutes`. */
declare const sailingsByRouteIDInputSchema: z.ZodObject<{
    SchedRouteID: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    SchedRouteID: number;
}, {
    SchedRouteID: number;
}>;
type SailingsByRouteIDInput = z.infer<typeof sailingsByRouteIDInputSchema>;
/**
 * Schema for AllSchedSailingsBySchedRoute input parameters
 *
 * This operation provides all sailings for a particular scheduled route. Sailings are departure times organized by direction of travel (eastbound / westbound), days of operation groups (daily, weekday, weekend, etc) and, in some cases, date ranges (eg. Early Fall / Late Fall). Sailings largely mimic the groupings of departures found on the printed PDF version of the schedule. Scheduled routes may be determined using `/schedroutes`. */
declare const allSailingsBySchedRouteIDInputSchema: z.ZodObject<{
    SchedRouteID: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    SchedRouteID: number;
}, {
    SchedRouteID: number;
}>;
type AllSailingsBySchedRouteIDInput = z.infer<typeof allSailingsBySchedRouteIDInputSchema>;

/**
 * @fileoverview WSF Schedule API Output Schemas for Sailings
 *
 * This module provides Zod schemas for validating responses from the WSF
 * Schedule API sailing operations.
 */

/**
 * Schema for ActiveDateRange - represents active date range information
 */
declare const activeDateRangeSchema: z.ZodObject<{
    DateFrom: z.ZodDate;
    DateThru: z.ZodDate;
    EventID: z.ZodNullable<z.ZodNumber>;
    EventDescription: z.ZodNullable<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    DateFrom: Date;
    DateThru: Date;
    EventID: number | null;
    EventDescription: string | null;
}, {
    DateFrom: Date;
    DateThru: Date;
    EventID: number | null;
    EventDescription: string | null;
}>;
type ActiveDateRange = z.infer<typeof activeDateRangeSchema>;
/**
 * Active Date Ranges List Schema - represents an list of active date ranges
 */
declare const activeDateRangesListSchema: z.ZodArray<z.ZodObject<{
    DateFrom: z.ZodDate;
    DateThru: z.ZodDate;
    EventID: z.ZodNullable<z.ZodNumber>;
    EventDescription: z.ZodNullable<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    DateFrom: Date;
    DateThru: Date;
    EventID: number | null;
    EventDescription: string | null;
}, {
    DateFrom: Date;
    DateThru: Date;
    EventID: number | null;
    EventDescription: string | null;
}>, "many">;
type ActiveDateRangeList = z.infer<typeof activeDateRangesListSchema>;
/**
 * Schema for Annotation - represents annotation information
 */
declare const annotationSchema: z.ZodObject<{
    AnnotationID: z.ZodNumber;
    AnnotationText: z.ZodNullable<z.ZodString>;
    AnnotationIVRText: z.ZodNullable<z.ZodString>;
    AdjustedCrossingTime: z.ZodNullable<z.ZodNumber>;
    AnnotationImg: z.ZodNullable<z.ZodString>;
    TypeDescription: z.ZodNullable<z.ZodString>;
    SortSeq: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    AnnotationID: number;
    AnnotationText: string | null;
    AnnotationIVRText: string | null;
    AdjustedCrossingTime: number | null;
    AnnotationImg: string | null;
    TypeDescription: string | null;
    SortSeq: number;
}, {
    AnnotationID: number;
    AnnotationText: string | null;
    AnnotationIVRText: string | null;
    AdjustedCrossingTime: number | null;
    AnnotationImg: string | null;
    TypeDescription: string | null;
    SortSeq: number;
}>;
type Annotation = z.infer<typeof annotationSchema>;
/**
 * Annotations List Schema - represents an list of annotations
 */
declare const annotationsListSchema: z.ZodArray<z.ZodObject<{
    AnnotationID: z.ZodNumber;
    AnnotationText: z.ZodNullable<z.ZodString>;
    AnnotationIVRText: z.ZodNullable<z.ZodString>;
    AdjustedCrossingTime: z.ZodNullable<z.ZodNumber>;
    AnnotationImg: z.ZodNullable<z.ZodString>;
    TypeDescription: z.ZodNullable<z.ZodString>;
    SortSeq: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    AnnotationID: number;
    AnnotationText: string | null;
    AnnotationIVRText: string | null;
    AdjustedCrossingTime: number | null;
    AnnotationImg: string | null;
    TypeDescription: string | null;
    SortSeq: number;
}, {
    AnnotationID: number;
    AnnotationText: string | null;
    AnnotationIVRText: string | null;
    AdjustedCrossingTime: number | null;
    AnnotationImg: string | null;
    TypeDescription: string | null;
    SortSeq: number;
}>, "many">;
type AnnotationList = z.infer<typeof annotationsListSchema>;
/**
 * Schema for TerminalTime - represents terminal time information
 */
declare const terminalTimeSchema: z.ZodObject<{
    JourneyTerminalID: z.ZodNumber;
    TerminalID: z.ZodNumber;
    TerminalDescription: z.ZodNullable<z.ZodString>;
    TerminalBriefDescription: z.ZodNullable<z.ZodString>;
    Time: z.ZodNullable<z.ZodDate>;
    DepArrIndicator: z.ZodNullable<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
    IsNA: z.ZodBoolean;
    Annotations: z.ZodNullable<z.ZodArray<z.ZodObject<{
        AnnotationID: z.ZodNumber;
        AnnotationText: z.ZodNullable<z.ZodString>;
        AnnotationIVRText: z.ZodNullable<z.ZodString>;
        AdjustedCrossingTime: z.ZodNullable<z.ZodNumber>;
        AnnotationImg: z.ZodNullable<z.ZodString>;
        TypeDescription: z.ZodNullable<z.ZodString>;
        SortSeq: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        AnnotationID: number;
        AnnotationText: string | null;
        AnnotationIVRText: string | null;
        AdjustedCrossingTime: number | null;
        AnnotationImg: string | null;
        TypeDescription: string | null;
        SortSeq: number;
    }, {
        AnnotationID: number;
        AnnotationText: string | null;
        AnnotationIVRText: string | null;
        AdjustedCrossingTime: number | null;
        AnnotationImg: string | null;
        TypeDescription: string | null;
        SortSeq: number;
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    Time: Date | null;
    TerminalID: number;
    JourneyTerminalID: number;
    TerminalDescription: string | null;
    TerminalBriefDescription: string | null;
    DepArrIndicator: 2 | 1 | null;
    IsNA: boolean;
    Annotations: {
        AnnotationID: number;
        AnnotationText: string | null;
        AnnotationIVRText: string | null;
        AdjustedCrossingTime: number | null;
        AnnotationImg: string | null;
        TypeDescription: string | null;
        SortSeq: number;
    }[] | null;
}, {
    Time: Date | null;
    TerminalID: number;
    JourneyTerminalID: number;
    TerminalDescription: string | null;
    TerminalBriefDescription: string | null;
    DepArrIndicator: 2 | 1 | null;
    IsNA: boolean;
    Annotations: {
        AnnotationID: number;
        AnnotationText: string | null;
        AnnotationIVRText: string | null;
        AdjustedCrossingTime: number | null;
        AnnotationImg: string | null;
        TypeDescription: string | null;
        SortSeq: number;
    }[] | null;
}>;
type TerminalTime = z.infer<typeof terminalTimeSchema>;
/**
 * Terminal Times List Schema - represents an list of terminal times
 */
declare const terminalTimesListSchema: z.ZodArray<z.ZodObject<{
    JourneyTerminalID: z.ZodNumber;
    TerminalID: z.ZodNumber;
    TerminalDescription: z.ZodNullable<z.ZodString>;
    TerminalBriefDescription: z.ZodNullable<z.ZodString>;
    Time: z.ZodNullable<z.ZodDate>;
    DepArrIndicator: z.ZodNullable<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
    IsNA: z.ZodBoolean;
    Annotations: z.ZodNullable<z.ZodArray<z.ZodObject<{
        AnnotationID: z.ZodNumber;
        AnnotationText: z.ZodNullable<z.ZodString>;
        AnnotationIVRText: z.ZodNullable<z.ZodString>;
        AdjustedCrossingTime: z.ZodNullable<z.ZodNumber>;
        AnnotationImg: z.ZodNullable<z.ZodString>;
        TypeDescription: z.ZodNullable<z.ZodString>;
        SortSeq: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        AnnotationID: number;
        AnnotationText: string | null;
        AnnotationIVRText: string | null;
        AdjustedCrossingTime: number | null;
        AnnotationImg: string | null;
        TypeDescription: string | null;
        SortSeq: number;
    }, {
        AnnotationID: number;
        AnnotationText: string | null;
        AnnotationIVRText: string | null;
        AdjustedCrossingTime: number | null;
        AnnotationImg: string | null;
        TypeDescription: string | null;
        SortSeq: number;
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    Time: Date | null;
    TerminalID: number;
    JourneyTerminalID: number;
    TerminalDescription: string | null;
    TerminalBriefDescription: string | null;
    DepArrIndicator: 2 | 1 | null;
    IsNA: boolean;
    Annotations: {
        AnnotationID: number;
        AnnotationText: string | null;
        AnnotationIVRText: string | null;
        AdjustedCrossingTime: number | null;
        AnnotationImg: string | null;
        TypeDescription: string | null;
        SortSeq: number;
    }[] | null;
}, {
    Time: Date | null;
    TerminalID: number;
    JourneyTerminalID: number;
    TerminalDescription: string | null;
    TerminalBriefDescription: string | null;
    DepArrIndicator: 2 | 1 | null;
    IsNA: boolean;
    Annotations: {
        AnnotationID: number;
        AnnotationText: string | null;
        AnnotationIVRText: string | null;
        AdjustedCrossingTime: number | null;
        AnnotationImg: string | null;
        TypeDescription: string | null;
        SortSeq: number;
    }[] | null;
}>, "many">;
type TerminalTimeList = z.infer<typeof terminalTimesListSchema>;
/**
 * Schema for Journey - represents journey information
 */
declare const journeySchema: z.ZodObject<{
    JourneyID: z.ZodNumber;
    ReservationInd: z.ZodBoolean;
    InternationalInd: z.ZodBoolean;
    InterislandInd: z.ZodBoolean;
    VesselID: z.ZodNumber;
    VesselName: z.ZodNullable<z.ZodString>;
    VesselHandicapAccessible: z.ZodBoolean;
    VesselPositionNum: z.ZodNumber;
    TerminalTimes: z.ZodNullable<z.ZodArray<z.ZodObject<{
        JourneyTerminalID: z.ZodNumber;
        TerminalID: z.ZodNumber;
        TerminalDescription: z.ZodNullable<z.ZodString>;
        TerminalBriefDescription: z.ZodNullable<z.ZodString>;
        Time: z.ZodNullable<z.ZodDate>;
        DepArrIndicator: z.ZodNullable<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
        IsNA: z.ZodBoolean;
        Annotations: z.ZodNullable<z.ZodArray<z.ZodObject<{
            AnnotationID: z.ZodNumber;
            AnnotationText: z.ZodNullable<z.ZodString>;
            AnnotationIVRText: z.ZodNullable<z.ZodString>;
            AdjustedCrossingTime: z.ZodNullable<z.ZodNumber>;
            AnnotationImg: z.ZodNullable<z.ZodString>;
            TypeDescription: z.ZodNullable<z.ZodString>;
            SortSeq: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            AnnotationID: number;
            AnnotationText: string | null;
            AnnotationIVRText: string | null;
            AdjustedCrossingTime: number | null;
            AnnotationImg: string | null;
            TypeDescription: string | null;
            SortSeq: number;
        }, {
            AnnotationID: number;
            AnnotationText: string | null;
            AnnotationIVRText: string | null;
            AdjustedCrossingTime: number | null;
            AnnotationImg: string | null;
            TypeDescription: string | null;
            SortSeq: number;
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        Time: Date | null;
        TerminalID: number;
        JourneyTerminalID: number;
        TerminalDescription: string | null;
        TerminalBriefDescription: string | null;
        DepArrIndicator: 2 | 1 | null;
        IsNA: boolean;
        Annotations: {
            AnnotationID: number;
            AnnotationText: string | null;
            AnnotationIVRText: string | null;
            AdjustedCrossingTime: number | null;
            AnnotationImg: string | null;
            TypeDescription: string | null;
            SortSeq: number;
        }[] | null;
    }, {
        Time: Date | null;
        TerminalID: number;
        JourneyTerminalID: number;
        TerminalDescription: string | null;
        TerminalBriefDescription: string | null;
        DepArrIndicator: 2 | 1 | null;
        IsNA: boolean;
        Annotations: {
            AnnotationID: number;
            AnnotationText: string | null;
            AnnotationIVRText: string | null;
            AdjustedCrossingTime: number | null;
            AnnotationImg: string | null;
            TypeDescription: string | null;
            SortSeq: number;
        }[] | null;
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    JourneyID: number;
    ReservationInd: boolean;
    InternationalInd: boolean;
    InterislandInd: boolean;
    VesselID: number;
    VesselName: string | null;
    VesselHandicapAccessible: boolean;
    VesselPositionNum: number;
    TerminalTimes: {
        Time: Date | null;
        TerminalID: number;
        JourneyTerminalID: number;
        TerminalDescription: string | null;
        TerminalBriefDescription: string | null;
        DepArrIndicator: 2 | 1 | null;
        IsNA: boolean;
        Annotations: {
            AnnotationID: number;
            AnnotationText: string | null;
            AnnotationIVRText: string | null;
            AdjustedCrossingTime: number | null;
            AnnotationImg: string | null;
            TypeDescription: string | null;
            SortSeq: number;
        }[] | null;
    }[] | null;
}, {
    JourneyID: number;
    ReservationInd: boolean;
    InternationalInd: boolean;
    InterislandInd: boolean;
    VesselID: number;
    VesselName: string | null;
    VesselHandicapAccessible: boolean;
    VesselPositionNum: number;
    TerminalTimes: {
        Time: Date | null;
        TerminalID: number;
        JourneyTerminalID: number;
        TerminalDescription: string | null;
        TerminalBriefDescription: string | null;
        DepArrIndicator: 2 | 1 | null;
        IsNA: boolean;
        Annotations: {
            AnnotationID: number;
            AnnotationText: string | null;
            AnnotationIVRText: string | null;
            AdjustedCrossingTime: number | null;
            AnnotationImg: string | null;
            TypeDescription: string | null;
            SortSeq: number;
        }[] | null;
    }[] | null;
}>;
type Journey = z.infer<typeof journeySchema>;
/**
 * Journeys List Schema - represents an list of journeys
 */
declare const journeysListSchema: z.ZodArray<z.ZodObject<{
    JourneyID: z.ZodNumber;
    ReservationInd: z.ZodBoolean;
    InternationalInd: z.ZodBoolean;
    InterislandInd: z.ZodBoolean;
    VesselID: z.ZodNumber;
    VesselName: z.ZodNullable<z.ZodString>;
    VesselHandicapAccessible: z.ZodBoolean;
    VesselPositionNum: z.ZodNumber;
    TerminalTimes: z.ZodNullable<z.ZodArray<z.ZodObject<{
        JourneyTerminalID: z.ZodNumber;
        TerminalID: z.ZodNumber;
        TerminalDescription: z.ZodNullable<z.ZodString>;
        TerminalBriefDescription: z.ZodNullable<z.ZodString>;
        Time: z.ZodNullable<z.ZodDate>;
        DepArrIndicator: z.ZodNullable<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
        IsNA: z.ZodBoolean;
        Annotations: z.ZodNullable<z.ZodArray<z.ZodObject<{
            AnnotationID: z.ZodNumber;
            AnnotationText: z.ZodNullable<z.ZodString>;
            AnnotationIVRText: z.ZodNullable<z.ZodString>;
            AdjustedCrossingTime: z.ZodNullable<z.ZodNumber>;
            AnnotationImg: z.ZodNullable<z.ZodString>;
            TypeDescription: z.ZodNullable<z.ZodString>;
            SortSeq: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            AnnotationID: number;
            AnnotationText: string | null;
            AnnotationIVRText: string | null;
            AdjustedCrossingTime: number | null;
            AnnotationImg: string | null;
            TypeDescription: string | null;
            SortSeq: number;
        }, {
            AnnotationID: number;
            AnnotationText: string | null;
            AnnotationIVRText: string | null;
            AdjustedCrossingTime: number | null;
            AnnotationImg: string | null;
            TypeDescription: string | null;
            SortSeq: number;
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        Time: Date | null;
        TerminalID: number;
        JourneyTerminalID: number;
        TerminalDescription: string | null;
        TerminalBriefDescription: string | null;
        DepArrIndicator: 2 | 1 | null;
        IsNA: boolean;
        Annotations: {
            AnnotationID: number;
            AnnotationText: string | null;
            AnnotationIVRText: string | null;
            AdjustedCrossingTime: number | null;
            AnnotationImg: string | null;
            TypeDescription: string | null;
            SortSeq: number;
        }[] | null;
    }, {
        Time: Date | null;
        TerminalID: number;
        JourneyTerminalID: number;
        TerminalDescription: string | null;
        TerminalBriefDescription: string | null;
        DepArrIndicator: 2 | 1 | null;
        IsNA: boolean;
        Annotations: {
            AnnotationID: number;
            AnnotationText: string | null;
            AnnotationIVRText: string | null;
            AdjustedCrossingTime: number | null;
            AnnotationImg: string | null;
            TypeDescription: string | null;
            SortSeq: number;
        }[] | null;
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    JourneyID: number;
    ReservationInd: boolean;
    InternationalInd: boolean;
    InterislandInd: boolean;
    VesselID: number;
    VesselName: string | null;
    VesselHandicapAccessible: boolean;
    VesselPositionNum: number;
    TerminalTimes: {
        Time: Date | null;
        TerminalID: number;
        JourneyTerminalID: number;
        TerminalDescription: string | null;
        TerminalBriefDescription: string | null;
        DepArrIndicator: 2 | 1 | null;
        IsNA: boolean;
        Annotations: {
            AnnotationID: number;
            AnnotationText: string | null;
            AnnotationIVRText: string | null;
            AdjustedCrossingTime: number | null;
            AnnotationImg: string | null;
            TypeDescription: string | null;
            SortSeq: number;
        }[] | null;
    }[] | null;
}, {
    JourneyID: number;
    ReservationInd: boolean;
    InternationalInd: boolean;
    InterislandInd: boolean;
    VesselID: number;
    VesselName: string | null;
    VesselHandicapAccessible: boolean;
    VesselPositionNum: number;
    TerminalTimes: {
        Time: Date | null;
        TerminalID: number;
        JourneyTerminalID: number;
        TerminalDescription: string | null;
        TerminalBriefDescription: string | null;
        DepArrIndicator: 2 | 1 | null;
        IsNA: boolean;
        Annotations: {
            AnnotationID: number;
            AnnotationText: string | null;
            AnnotationIVRText: string | null;
            AdjustedCrossingTime: number | null;
            AnnotationImg: string | null;
            TypeDescription: string | null;
            SortSeq: number;
        }[] | null;
    }[] | null;
}>, "many">;
type JourneyList = z.infer<typeof journeysListSchema>;
/**
 * Schema for Sailing - represents sailing information
 */
declare const sailingSchema: z.ZodObject<{
    ScheduleID: z.ZodNumber;
    SchedRouteID: z.ZodNumber;
    RouteID: z.ZodNumber;
    SailingID: z.ZodNumber;
    SailingDescription: z.ZodNullable<z.ZodString>;
    SailingNotes: z.ZodNullable<z.ZodString>;
    DisplayColNum: z.ZodNumber;
    SailingDir: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>;
    DayOpDescription: z.ZodNullable<z.ZodString>;
    DayOpUseForHoliday: z.ZodBoolean;
    ActiveDateRanges: z.ZodNullable<z.ZodArray<z.ZodObject<{
        DateFrom: z.ZodDate;
        DateThru: z.ZodDate;
        EventID: z.ZodNullable<z.ZodNumber>;
        EventDescription: z.ZodNullable<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
    }, {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
    }>, "many">>;
    Journs: z.ZodNullable<z.ZodArray<z.ZodObject<{
        JourneyID: z.ZodNumber;
        ReservationInd: z.ZodBoolean;
        InternationalInd: z.ZodBoolean;
        InterislandInd: z.ZodBoolean;
        VesselID: z.ZodNumber;
        VesselName: z.ZodNullable<z.ZodString>;
        VesselHandicapAccessible: z.ZodBoolean;
        VesselPositionNum: z.ZodNumber;
        TerminalTimes: z.ZodNullable<z.ZodArray<z.ZodObject<{
            JourneyTerminalID: z.ZodNumber;
            TerminalID: z.ZodNumber;
            TerminalDescription: z.ZodNullable<z.ZodString>;
            TerminalBriefDescription: z.ZodNullable<z.ZodString>;
            Time: z.ZodNullable<z.ZodDate>;
            DepArrIndicator: z.ZodNullable<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
            IsNA: z.ZodBoolean;
            Annotations: z.ZodNullable<z.ZodArray<z.ZodObject<{
                AnnotationID: z.ZodNumber;
                AnnotationText: z.ZodNullable<z.ZodString>;
                AnnotationIVRText: z.ZodNullable<z.ZodString>;
                AdjustedCrossingTime: z.ZodNullable<z.ZodNumber>;
                AnnotationImg: z.ZodNullable<z.ZodString>;
                TypeDescription: z.ZodNullable<z.ZodString>;
                SortSeq: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                AnnotationID: number;
                AnnotationText: string | null;
                AnnotationIVRText: string | null;
                AdjustedCrossingTime: number | null;
                AnnotationImg: string | null;
                TypeDescription: string | null;
                SortSeq: number;
            }, {
                AnnotationID: number;
                AnnotationText: string | null;
                AnnotationIVRText: string | null;
                AdjustedCrossingTime: number | null;
                AnnotationImg: string | null;
                TypeDescription: string | null;
                SortSeq: number;
            }>, "many">>;
        }, "strip", z.ZodTypeAny, {
            Time: Date | null;
            TerminalID: number;
            JourneyTerminalID: number;
            TerminalDescription: string | null;
            TerminalBriefDescription: string | null;
            DepArrIndicator: 2 | 1 | null;
            IsNA: boolean;
            Annotations: {
                AnnotationID: number;
                AnnotationText: string | null;
                AnnotationIVRText: string | null;
                AdjustedCrossingTime: number | null;
                AnnotationImg: string | null;
                TypeDescription: string | null;
                SortSeq: number;
            }[] | null;
        }, {
            Time: Date | null;
            TerminalID: number;
            JourneyTerminalID: number;
            TerminalDescription: string | null;
            TerminalBriefDescription: string | null;
            DepArrIndicator: 2 | 1 | null;
            IsNA: boolean;
            Annotations: {
                AnnotationID: number;
                AnnotationText: string | null;
                AnnotationIVRText: string | null;
                AdjustedCrossingTime: number | null;
                AnnotationImg: string | null;
                TypeDescription: string | null;
                SortSeq: number;
            }[] | null;
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        JourneyID: number;
        ReservationInd: boolean;
        InternationalInd: boolean;
        InterislandInd: boolean;
        VesselID: number;
        VesselName: string | null;
        VesselHandicapAccessible: boolean;
        VesselPositionNum: number;
        TerminalTimes: {
            Time: Date | null;
            TerminalID: number;
            JourneyTerminalID: number;
            TerminalDescription: string | null;
            TerminalBriefDescription: string | null;
            DepArrIndicator: 2 | 1 | null;
            IsNA: boolean;
            Annotations: {
                AnnotationID: number;
                AnnotationText: string | null;
                AnnotationIVRText: string | null;
                AdjustedCrossingTime: number | null;
                AnnotationImg: string | null;
                TypeDescription: string | null;
                SortSeq: number;
            }[] | null;
        }[] | null;
    }, {
        JourneyID: number;
        ReservationInd: boolean;
        InternationalInd: boolean;
        InterislandInd: boolean;
        VesselID: number;
        VesselName: string | null;
        VesselHandicapAccessible: boolean;
        VesselPositionNum: number;
        TerminalTimes: {
            Time: Date | null;
            TerminalID: number;
            JourneyTerminalID: number;
            TerminalDescription: string | null;
            TerminalBriefDescription: string | null;
            DepArrIndicator: 2 | 1 | null;
            IsNA: boolean;
            Annotations: {
                AnnotationID: number;
                AnnotationText: string | null;
                AnnotationIVRText: string | null;
                AdjustedCrossingTime: number | null;
                AnnotationImg: string | null;
                TypeDescription: string | null;
                SortSeq: number;
            }[] | null;
        }[] | null;
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    ScheduleID: number;
    RouteID: number;
    SchedRouteID: number;
    SailingID: number;
    SailingDescription: string | null;
    SailingNotes: string | null;
    DisplayColNum: number;
    SailingDir: 2 | 1;
    DayOpDescription: string | null;
    DayOpUseForHoliday: boolean;
    ActiveDateRanges: {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
    }[] | null;
    Journs: {
        JourneyID: number;
        ReservationInd: boolean;
        InternationalInd: boolean;
        InterislandInd: boolean;
        VesselID: number;
        VesselName: string | null;
        VesselHandicapAccessible: boolean;
        VesselPositionNum: number;
        TerminalTimes: {
            Time: Date | null;
            TerminalID: number;
            JourneyTerminalID: number;
            TerminalDescription: string | null;
            TerminalBriefDescription: string | null;
            DepArrIndicator: 2 | 1 | null;
            IsNA: boolean;
            Annotations: {
                AnnotationID: number;
                AnnotationText: string | null;
                AnnotationIVRText: string | null;
                AdjustedCrossingTime: number | null;
                AnnotationImg: string | null;
                TypeDescription: string | null;
                SortSeq: number;
            }[] | null;
        }[] | null;
    }[] | null;
}, {
    ScheduleID: number;
    RouteID: number;
    SchedRouteID: number;
    SailingID: number;
    SailingDescription: string | null;
    SailingNotes: string | null;
    DisplayColNum: number;
    SailingDir: 2 | 1;
    DayOpDescription: string | null;
    DayOpUseForHoliday: boolean;
    ActiveDateRanges: {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
    }[] | null;
    Journs: {
        JourneyID: number;
        ReservationInd: boolean;
        InternationalInd: boolean;
        InterislandInd: boolean;
        VesselID: number;
        VesselName: string | null;
        VesselHandicapAccessible: boolean;
        VesselPositionNum: number;
        TerminalTimes: {
            Time: Date | null;
            TerminalID: number;
            JourneyTerminalID: number;
            TerminalDescription: string | null;
            TerminalBriefDescription: string | null;
            DepArrIndicator: 2 | 1 | null;
            IsNA: boolean;
            Annotations: {
                AnnotationID: number;
                AnnotationText: string | null;
                AnnotationIVRText: string | null;
                AdjustedCrossingTime: number | null;
                AnnotationImg: string | null;
                TypeDescription: string | null;
                SortSeq: number;
            }[] | null;
        }[] | null;
    }[] | null;
}>;
type Sailing = z.infer<typeof sailingSchema>;
/**
 * Sailings List Schema - represents an list of sailings
 */
declare const sailingsListSchema: z.ZodArray<z.ZodObject<{
    ScheduleID: z.ZodNumber;
    SchedRouteID: z.ZodNumber;
    RouteID: z.ZodNumber;
    SailingID: z.ZodNumber;
    SailingDescription: z.ZodNullable<z.ZodString>;
    SailingNotes: z.ZodNullable<z.ZodString>;
    DisplayColNum: z.ZodNumber;
    SailingDir: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>;
    DayOpDescription: z.ZodNullable<z.ZodString>;
    DayOpUseForHoliday: z.ZodBoolean;
    ActiveDateRanges: z.ZodNullable<z.ZodArray<z.ZodObject<{
        DateFrom: z.ZodDate;
        DateThru: z.ZodDate;
        EventID: z.ZodNullable<z.ZodNumber>;
        EventDescription: z.ZodNullable<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
    }, {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
    }>, "many">>;
    Journs: z.ZodNullable<z.ZodArray<z.ZodObject<{
        JourneyID: z.ZodNumber;
        ReservationInd: z.ZodBoolean;
        InternationalInd: z.ZodBoolean;
        InterislandInd: z.ZodBoolean;
        VesselID: z.ZodNumber;
        VesselName: z.ZodNullable<z.ZodString>;
        VesselHandicapAccessible: z.ZodBoolean;
        VesselPositionNum: z.ZodNumber;
        TerminalTimes: z.ZodNullable<z.ZodArray<z.ZodObject<{
            JourneyTerminalID: z.ZodNumber;
            TerminalID: z.ZodNumber;
            TerminalDescription: z.ZodNullable<z.ZodString>;
            TerminalBriefDescription: z.ZodNullable<z.ZodString>;
            Time: z.ZodNullable<z.ZodDate>;
            DepArrIndicator: z.ZodNullable<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
            IsNA: z.ZodBoolean;
            Annotations: z.ZodNullable<z.ZodArray<z.ZodObject<{
                AnnotationID: z.ZodNumber;
                AnnotationText: z.ZodNullable<z.ZodString>;
                AnnotationIVRText: z.ZodNullable<z.ZodString>;
                AdjustedCrossingTime: z.ZodNullable<z.ZodNumber>;
                AnnotationImg: z.ZodNullable<z.ZodString>;
                TypeDescription: z.ZodNullable<z.ZodString>;
                SortSeq: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                AnnotationID: number;
                AnnotationText: string | null;
                AnnotationIVRText: string | null;
                AdjustedCrossingTime: number | null;
                AnnotationImg: string | null;
                TypeDescription: string | null;
                SortSeq: number;
            }, {
                AnnotationID: number;
                AnnotationText: string | null;
                AnnotationIVRText: string | null;
                AdjustedCrossingTime: number | null;
                AnnotationImg: string | null;
                TypeDescription: string | null;
                SortSeq: number;
            }>, "many">>;
        }, "strip", z.ZodTypeAny, {
            Time: Date | null;
            TerminalID: number;
            JourneyTerminalID: number;
            TerminalDescription: string | null;
            TerminalBriefDescription: string | null;
            DepArrIndicator: 2 | 1 | null;
            IsNA: boolean;
            Annotations: {
                AnnotationID: number;
                AnnotationText: string | null;
                AnnotationIVRText: string | null;
                AdjustedCrossingTime: number | null;
                AnnotationImg: string | null;
                TypeDescription: string | null;
                SortSeq: number;
            }[] | null;
        }, {
            Time: Date | null;
            TerminalID: number;
            JourneyTerminalID: number;
            TerminalDescription: string | null;
            TerminalBriefDescription: string | null;
            DepArrIndicator: 2 | 1 | null;
            IsNA: boolean;
            Annotations: {
                AnnotationID: number;
                AnnotationText: string | null;
                AnnotationIVRText: string | null;
                AdjustedCrossingTime: number | null;
                AnnotationImg: string | null;
                TypeDescription: string | null;
                SortSeq: number;
            }[] | null;
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        JourneyID: number;
        ReservationInd: boolean;
        InternationalInd: boolean;
        InterislandInd: boolean;
        VesselID: number;
        VesselName: string | null;
        VesselHandicapAccessible: boolean;
        VesselPositionNum: number;
        TerminalTimes: {
            Time: Date | null;
            TerminalID: number;
            JourneyTerminalID: number;
            TerminalDescription: string | null;
            TerminalBriefDescription: string | null;
            DepArrIndicator: 2 | 1 | null;
            IsNA: boolean;
            Annotations: {
                AnnotationID: number;
                AnnotationText: string | null;
                AnnotationIVRText: string | null;
                AdjustedCrossingTime: number | null;
                AnnotationImg: string | null;
                TypeDescription: string | null;
                SortSeq: number;
            }[] | null;
        }[] | null;
    }, {
        JourneyID: number;
        ReservationInd: boolean;
        InternationalInd: boolean;
        InterislandInd: boolean;
        VesselID: number;
        VesselName: string | null;
        VesselHandicapAccessible: boolean;
        VesselPositionNum: number;
        TerminalTimes: {
            Time: Date | null;
            TerminalID: number;
            JourneyTerminalID: number;
            TerminalDescription: string | null;
            TerminalBriefDescription: string | null;
            DepArrIndicator: 2 | 1 | null;
            IsNA: boolean;
            Annotations: {
                AnnotationID: number;
                AnnotationText: string | null;
                AnnotationIVRText: string | null;
                AdjustedCrossingTime: number | null;
                AnnotationImg: string | null;
                TypeDescription: string | null;
                SortSeq: number;
            }[] | null;
        }[] | null;
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    ScheduleID: number;
    RouteID: number;
    SchedRouteID: number;
    SailingID: number;
    SailingDescription: string | null;
    SailingNotes: string | null;
    DisplayColNum: number;
    SailingDir: 2 | 1;
    DayOpDescription: string | null;
    DayOpUseForHoliday: boolean;
    ActiveDateRanges: {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
    }[] | null;
    Journs: {
        JourneyID: number;
        ReservationInd: boolean;
        InternationalInd: boolean;
        InterislandInd: boolean;
        VesselID: number;
        VesselName: string | null;
        VesselHandicapAccessible: boolean;
        VesselPositionNum: number;
        TerminalTimes: {
            Time: Date | null;
            TerminalID: number;
            JourneyTerminalID: number;
            TerminalDescription: string | null;
            TerminalBriefDescription: string | null;
            DepArrIndicator: 2 | 1 | null;
            IsNA: boolean;
            Annotations: {
                AnnotationID: number;
                AnnotationText: string | null;
                AnnotationIVRText: string | null;
                AdjustedCrossingTime: number | null;
                AnnotationImg: string | null;
                TypeDescription: string | null;
                SortSeq: number;
            }[] | null;
        }[] | null;
    }[] | null;
}, {
    ScheduleID: number;
    RouteID: number;
    SchedRouteID: number;
    SailingID: number;
    SailingDescription: string | null;
    SailingNotes: string | null;
    DisplayColNum: number;
    SailingDir: 2 | 1;
    DayOpDescription: string | null;
    DayOpUseForHoliday: boolean;
    ActiveDateRanges: {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
    }[] | null;
    Journs: {
        JourneyID: number;
        ReservationInd: boolean;
        InternationalInd: boolean;
        InterislandInd: boolean;
        VesselID: number;
        VesselName: string | null;
        VesselHandicapAccessible: boolean;
        VesselPositionNum: number;
        TerminalTimes: {
            Time: Date | null;
            TerminalID: number;
            JourneyTerminalID: number;
            TerminalDescription: string | null;
            TerminalBriefDescription: string | null;
            DepArrIndicator: 2 | 1 | null;
            IsNA: boolean;
            Annotations: {
                AnnotationID: number;
                AnnotationText: string | null;
                AnnotationIVRText: string | null;
                AdjustedCrossingTime: number | null;
                AnnotationImg: string | null;
                TypeDescription: string | null;
                SortSeq: number;
            }[] | null;
        }[] | null;
    }[] | null;
}>, "many">;
type SailingList = z.infer<typeof sailingsListSchema>;

/**
 * @fileoverview WSF Schedule API Input Schemas for Schedule Alerts
 *
 * This module provides Zod schemas for validating input parameters for the WSF
 * Schedule API endpoints related to schedule alert operations.
 */

/**
 * Schema for AllAlerts input parameters
 *
 * This operation provides alert information tailored for routes, bulletins, service disruptions, etc. */
declare const scheduleAlertsInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
type ScheduleAlertsInput = z.infer<typeof scheduleAlertsInputSchema>;

/**
 * @fileoverview WSF Schedule API Output Schemas for Schedule Alerts
 *
 * This module provides Zod schemas for validating responses from the WSF
 * Schedule API schedule alert operations.
 */

/**
 * Schema for AlertDetail - represents detailed alert information
 */
declare const alertDetailSchema: z.ZodObject<{
    BulletinID: z.ZodNumber;
    BulletinFlag: z.ZodBoolean;
    BulletinText: z.ZodNullable<z.ZodString>;
    CommunicationFlag: z.ZodBoolean;
    CommunicationText: z.ZodNullable<z.ZodString>;
    RouteAlertFlag: z.ZodBoolean;
    RouteAlertText: z.ZodNullable<z.ZodString>;
    HomepageAlertText: z.ZodNullable<z.ZodString>;
    PublishDate: z.ZodNullable<z.ZodDate>;
    DisruptionDescription: z.ZodNullable<z.ZodString>;
    AllRoutesFlag: z.ZodBoolean;
    SortSeq: z.ZodNumber;
    AlertTypeID: z.ZodNumber;
    AlertType: z.ZodString;
    AlertFullTitle: z.ZodString;
    AffectedRouteIDs: z.ZodArray<z.ZodNumber, "many">;
    IVRText: z.ZodNullable<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    BulletinID: number;
    BulletinFlag: boolean;
    PublishDate: Date | null;
    DisruptionDescription: string | null;
    CommunicationFlag: boolean;
    AlertFullTitle: string;
    IVRText: string | null;
    SortSeq: number;
    BulletinText: string | null;
    CommunicationText: string | null;
    RouteAlertFlag: boolean;
    RouteAlertText: string | null;
    HomepageAlertText: string | null;
    AllRoutesFlag: boolean;
    AlertTypeID: number;
    AlertType: string;
    AffectedRouteIDs: number[];
}, {
    BulletinID: number;
    BulletinFlag: boolean;
    PublishDate: Date | null;
    DisruptionDescription: string | null;
    CommunicationFlag: boolean;
    AlertFullTitle: string;
    IVRText: string | null;
    SortSeq: number;
    BulletinText: string | null;
    CommunicationText: string | null;
    RouteAlertFlag: boolean;
    RouteAlertText: string | null;
    HomepageAlertText: string | null;
    AllRoutesFlag: boolean;
    AlertTypeID: number;
    AlertType: string;
    AffectedRouteIDs: number[];
}>;
type AlertDetail = z.infer<typeof alertDetailSchema>;
/**
 * Alert Details List Schema - represents an list of detailed alerts
 */
declare const alertDetailsListSchema: z.ZodArray<z.ZodObject<{
    BulletinID: z.ZodNumber;
    BulletinFlag: z.ZodBoolean;
    BulletinText: z.ZodNullable<z.ZodString>;
    CommunicationFlag: z.ZodBoolean;
    CommunicationText: z.ZodNullable<z.ZodString>;
    RouteAlertFlag: z.ZodBoolean;
    RouteAlertText: z.ZodNullable<z.ZodString>;
    HomepageAlertText: z.ZodNullable<z.ZodString>;
    PublishDate: z.ZodNullable<z.ZodDate>;
    DisruptionDescription: z.ZodNullable<z.ZodString>;
    AllRoutesFlag: z.ZodBoolean;
    SortSeq: z.ZodNumber;
    AlertTypeID: z.ZodNumber;
    AlertType: z.ZodString;
    AlertFullTitle: z.ZodString;
    AffectedRouteIDs: z.ZodArray<z.ZodNumber, "many">;
    IVRText: z.ZodNullable<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    BulletinID: number;
    BulletinFlag: boolean;
    PublishDate: Date | null;
    DisruptionDescription: string | null;
    CommunicationFlag: boolean;
    AlertFullTitle: string;
    IVRText: string | null;
    SortSeq: number;
    BulletinText: string | null;
    CommunicationText: string | null;
    RouteAlertFlag: boolean;
    RouteAlertText: string | null;
    HomepageAlertText: string | null;
    AllRoutesFlag: boolean;
    AlertTypeID: number;
    AlertType: string;
    AffectedRouteIDs: number[];
}, {
    BulletinID: number;
    BulletinFlag: boolean;
    PublishDate: Date | null;
    DisruptionDescription: string | null;
    CommunicationFlag: boolean;
    AlertFullTitle: string;
    IVRText: string | null;
    SortSeq: number;
    BulletinText: string | null;
    CommunicationText: string | null;
    RouteAlertFlag: boolean;
    RouteAlertText: string | null;
    HomepageAlertText: string | null;
    AllRoutesFlag: boolean;
    AlertTypeID: number;
    AlertType: string;
    AffectedRouteIDs: number[];
}>, "many">;
type AlertDetailList = z.infer<typeof alertDetailsListSchema>;

/**
 * @fileoverview WSF Schedule API Input Schemas for Scheduled Routes
 *
 * This module provides Zod schemas for validating input parameters for the WSF
 * Schedule API endpoints related to scheduled routes operations.
 */

/**
 * Schema for SchedRoutes input parameters
 *
 * This operation provides a listing of routes that are active for a season. For example, "Anacortes / Sidney B.C." may be a valid route, but if it's not scheduled to run during Winter 2014, it won't be returned as part of the Winter 2014 scheduled routes resultset. Results will include all known scheduled routes spanning current and upcoming seasons or, alternatively, results can be filtered to only include scheduled routes for a specific season (when the season is specified with a ScheduleID value). Seasons may be determined using `/activeseasons`. */
declare const scheduledRoutesInputSchema: z.ZodObject<{
    ScheduleID: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    ScheduleID?: number | undefined;
}, {
    ScheduleID?: number | undefined;
}>;
type ScheduledRoutesInput = z.infer<typeof scheduledRoutesInputSchema>;
/**
 * Schema for SchedRoutes input parameters
 *
 * This operation provides a listing of routes that are active for a season. For example, "Anacortes / Sidney B.C." may be a valid route, but if it's not scheduled to run during Winter 2014, it won't be returned as part of the Winter 2014 scheduled routes resultset. Results will include all known scheduled routes spanning current and upcoming seasons or, alternatively, results can be filtered to only include scheduled routes for a specific season (when the season is specified with a ScheduleID value). Seasons may be determined using `/activeseasons`. */
declare const scheduledRoutesByIdInputSchema: z.ZodObject<{
    ScheduleID: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    ScheduleID?: number | undefined;
}, {
    ScheduleID?: number | undefined;
}>;
type ScheduledRoutesByIdInput = z.infer<typeof scheduledRoutesByIdInputSchema>;

/**
 * @fileoverview WSF Schedule API Output Schemas for Scheduled Routes
 *
 * This module provides Zod schemas for validating responses from the WSF
 * Schedule API scheduled routes operations.
 */

/**
 * Schema for ContingencyAdj - represents contingency adjustment information
 */
declare const contingencyAdjSchema: z.ZodObject<{
    DateFrom: z.ZodDate;
    DateThru: z.ZodDate;
    EventID: z.ZodNullable<z.ZodNumber>;
    EventDescription: z.ZodNullable<z.ZodString>;
    AdjType: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>;
    ReplacedBySchedRouteID: z.ZodNullable<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    DateFrom: Date;
    DateThru: Date;
    EventID: number | null;
    EventDescription: string | null;
    AdjType: 2 | 1;
    ReplacedBySchedRouteID: number | null;
}, {
    DateFrom: Date;
    DateThru: Date;
    EventID: number | null;
    EventDescription: string | null;
    AdjType: 2 | 1;
    ReplacedBySchedRouteID: number | null;
}>;
type ContingencyAdj = z.infer<typeof contingencyAdjSchema>;
/**
 * Contingency Adjs List Schema - represents an list of contingency adjustments
 */
declare const contingencyAdjsListSchema: z.ZodArray<z.ZodObject<{
    DateFrom: z.ZodDate;
    DateThru: z.ZodDate;
    EventID: z.ZodNullable<z.ZodNumber>;
    EventDescription: z.ZodNullable<z.ZodString>;
    AdjType: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>;
    ReplacedBySchedRouteID: z.ZodNullable<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    DateFrom: Date;
    DateThru: Date;
    EventID: number | null;
    EventDescription: string | null;
    AdjType: 2 | 1;
    ReplacedBySchedRouteID: number | null;
}, {
    DateFrom: Date;
    DateThru: Date;
    EventID: number | null;
    EventDescription: string | null;
    AdjType: 2 | 1;
    ReplacedBySchedRouteID: number | null;
}>, "many">;
type ContingencyAdjList = z.infer<typeof contingencyAdjsListSchema>;
/**
 * Schema for SchedRoute - represents scheduled route information
 */
declare const schedRouteSchema: z.ZodObject<{
    ScheduleID: z.ZodNumber;
    SchedRouteID: z.ZodNumber;
    ContingencyOnly: z.ZodBoolean;
    RouteID: z.ZodNumber;
    RouteAbbrev: z.ZodString;
    Description: z.ZodString;
    SeasonalRouteNotes: z.ZodNullable<z.ZodString>;
    RegionID: z.ZodNumber;
    ServiceDisruptions: z.ZodArray<z.ZodObject<{
        BulletinID: z.ZodNumber;
        BulletinFlag: z.ZodBoolean;
        PublishDate: z.ZodNullable<z.ZodDate>;
        DisruptionDescription: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string;
    }, {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string;
    }>, "many">;
    ContingencyAdj: z.ZodArray<z.ZodObject<{
        DateFrom: z.ZodDate;
        DateThru: z.ZodDate;
        EventID: z.ZodNullable<z.ZodNumber>;
        EventDescription: z.ZodNullable<z.ZodString>;
        AdjType: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>;
        ReplacedBySchedRouteID: z.ZodNullable<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
        AdjType: 2 | 1;
        ReplacedBySchedRouteID: number | null;
    }, {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
        AdjType: 2 | 1;
        ReplacedBySchedRouteID: number | null;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    Description: string;
    RegionID: number;
    ScheduleID: number;
    RouteID: number;
    RouteAbbrev: string;
    ServiceDisruptions: {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string;
    }[];
    SeasonalRouteNotes: string | null;
    SchedRouteID: number;
    ContingencyOnly: boolean;
    ContingencyAdj: {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
        AdjType: 2 | 1;
        ReplacedBySchedRouteID: number | null;
    }[];
}, {
    Description: string;
    RegionID: number;
    ScheduleID: number;
    RouteID: number;
    RouteAbbrev: string;
    ServiceDisruptions: {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string;
    }[];
    SeasonalRouteNotes: string | null;
    SchedRouteID: number;
    ContingencyOnly: boolean;
    ContingencyAdj: {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
        AdjType: 2 | 1;
        ReplacedBySchedRouteID: number | null;
    }[];
}>;
type SchedRoute = z.infer<typeof schedRouteSchema>;
/**
 * Sched Routes List Schema - represents an list of scheduled routes
 */
declare const schedRoutesListSchema: z.ZodArray<z.ZodObject<{
    ScheduleID: z.ZodNumber;
    SchedRouteID: z.ZodNumber;
    ContingencyOnly: z.ZodBoolean;
    RouteID: z.ZodNumber;
    RouteAbbrev: z.ZodString;
    Description: z.ZodString;
    SeasonalRouteNotes: z.ZodNullable<z.ZodString>;
    RegionID: z.ZodNumber;
    ServiceDisruptions: z.ZodArray<z.ZodObject<{
        BulletinID: z.ZodNumber;
        BulletinFlag: z.ZodBoolean;
        PublishDate: z.ZodNullable<z.ZodDate>;
        DisruptionDescription: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string;
    }, {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string;
    }>, "many">;
    ContingencyAdj: z.ZodArray<z.ZodObject<{
        DateFrom: z.ZodDate;
        DateThru: z.ZodDate;
        EventID: z.ZodNullable<z.ZodNumber>;
        EventDescription: z.ZodNullable<z.ZodString>;
        AdjType: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>;
        ReplacedBySchedRouteID: z.ZodNullable<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
        AdjType: 2 | 1;
        ReplacedBySchedRouteID: number | null;
    }, {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
        AdjType: 2 | 1;
        ReplacedBySchedRouteID: number | null;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    Description: string;
    RegionID: number;
    ScheduleID: number;
    RouteID: number;
    RouteAbbrev: string;
    ServiceDisruptions: {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string;
    }[];
    SeasonalRouteNotes: string | null;
    SchedRouteID: number;
    ContingencyOnly: boolean;
    ContingencyAdj: {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
        AdjType: 2 | 1;
        ReplacedBySchedRouteID: number | null;
    }[];
}, {
    Description: string;
    RegionID: number;
    ScheduleID: number;
    RouteID: number;
    RouteAbbrev: string;
    ServiceDisruptions: {
        BulletinID: number;
        BulletinFlag: boolean;
        PublishDate: Date | null;
        DisruptionDescription: string;
    }[];
    SeasonalRouteNotes: string | null;
    SchedRouteID: number;
    ContingencyOnly: boolean;
    ContingencyAdj: {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
        AdjType: 2 | 1;
        ReplacedBySchedRouteID: number | null;
    }[];
}>, "many">;
type SchedRouteList = z.infer<typeof schedRoutesListSchema>;

/**
 * @fileoverview WSF Schedule API Input Schemas for Schedules
 *
 * This module provides Zod schemas for validating input parameters for the WSF
 * Schedule API endpoints related to schedule operations.
 */

/**
 * Schema for ScheduleByTerminalCombo input parameters
 *
 * This operation provides departure times for either a trip date and route or a trip date and terminal combination. The resultset accounts for all contingencies, sailing date ranges and time adjustments. Valid departing and arriving terminals may be found using `/terminalsandmates` while valid routes may be found using `/routes`. Similarly, a valid trip date may be determined using `/validdaterange`. Please format the trip date input as `'YYYY-MM-DD'` (eg. `'2014-04-01'` for a trip date occurring on April 1, 2014). */
declare const scheduleByTripDateAndTerminals: z.ZodObject<{
    TripDate: z.ZodString;
    DepartingTerminalID: z.ZodNumber;
    ArrivingTerminalID: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    TripDate: string;
    DepartingTerminalID: number;
    ArrivingTerminalID: number;
}, {
    TripDate: string;
    DepartingTerminalID: number;
    ArrivingTerminalID: number;
}>;
type ScheduleByTripDateAndTerminalsInput = z.infer<typeof scheduleByTripDateAndTerminals>;
/**
 * Schema for ScheduleByRoute input parameters
 *
 * This operation provides departure times for either a trip date and route or a trip date and terminal combination. The resultset accounts for all contingencies, sailing date ranges and time adjustments. Valid departing and arriving terminals may be found using `/terminalsandmates` while valid routes may be found using `/routes`. Similarly, a valid trip date may be determined using `/validdaterange`. Please format the trip date input as `'YYYY-MM-DD'` (eg. `'2014-04-01'` for a trip date occurring on April 1, 2014). */
declare const scheduleByTripDateAndRouteIdInputSchema: z.ZodObject<{
    TripDate: z.ZodString;
    RouteID: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    TripDate: string;
    RouteID: number;
}, {
    TripDate: string;
    RouteID: number;
}>;
type ScheduleByTripDateAndRouteIdInput = z.infer<typeof scheduleByTripDateAndRouteIdInputSchema>;

/**
 * @fileoverview WSF Schedule API Output Schemas for Schedules
 *
 * This module provides Zod schemas for validating responses from the WSF
 * Schedule API schedule operations.
 */

/**
 * Schema for TerminalCombo - represents terminal combination information
 */
declare const terminalComboSchema: z.ZodObject<{
    DepartingTerminalID: z.ZodNumber;
    DepartingTerminalName: z.ZodString;
    ArrivingTerminalID: z.ZodNumber;
    ArrivingTerminalName: z.ZodString;
    SailingNotes: z.ZodString;
    Annotations: z.ZodArray<z.ZodString, "many">;
    Times: z.ZodArray<z.ZodObject<{
        DepartingTime: z.ZodDate;
        ArrivingTime: z.ZodNullable<z.ZodDate>;
        LoadingRule: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
        VesselID: z.ZodNumber;
        VesselName: z.ZodString;
        VesselHandicapAccessible: z.ZodBoolean;
        VesselPositionNum: z.ZodNumber;
        Routes: z.ZodArray<z.ZodNumber, "many">;
        AnnotationIndexes: z.ZodArray<z.ZodNumber, "many">;
    }, "strip", z.ZodTypeAny, {
        VesselID: number;
        VesselName: string;
        VesselHandicapAccessible: boolean;
        VesselPositionNum: number;
        DepartingTime: Date;
        ArrivingTime: Date | null;
        LoadingRule: 2 | 1 | 3;
        Routes: number[];
        AnnotationIndexes: number[];
    }, {
        VesselID: number;
        VesselName: string;
        VesselHandicapAccessible: boolean;
        VesselPositionNum: number;
        DepartingTime: Date;
        ArrivingTime: Date | null;
        LoadingRule: 2 | 1 | 3;
        Routes: number[];
        AnnotationIndexes: number[];
    }>, "many">;
    AnnotationsIVR: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    DepartingTerminalID: number;
    ArrivingTerminalID: number;
    Annotations: string[];
    SailingNotes: string;
    DepartingTerminalName: string;
    ArrivingTerminalName: string;
    Times: {
        VesselID: number;
        VesselName: string;
        VesselHandicapAccessible: boolean;
        VesselPositionNum: number;
        DepartingTime: Date;
        ArrivingTime: Date | null;
        LoadingRule: 2 | 1 | 3;
        Routes: number[];
        AnnotationIndexes: number[];
    }[];
    AnnotationsIVR: string[];
}, {
    DepartingTerminalID: number;
    ArrivingTerminalID: number;
    Annotations: string[];
    SailingNotes: string;
    DepartingTerminalName: string;
    ArrivingTerminalName: string;
    Times: {
        VesselID: number;
        VesselName: string;
        VesselHandicapAccessible: boolean;
        VesselPositionNum: number;
        DepartingTime: Date;
        ArrivingTime: Date | null;
        LoadingRule: 2 | 1 | 3;
        Routes: number[];
        AnnotationIndexes: number[];
    }[];
    AnnotationsIVR: string[];
}>;
type TerminalCombo = z.infer<typeof terminalComboSchema>;
/**
 * Terminal Combos List Schema - represents an list of terminal combinations
 */
declare const terminalCombosListSchema: z.ZodArray<z.ZodObject<{
    DepartingTerminalID: z.ZodNumber;
    DepartingTerminalName: z.ZodString;
    ArrivingTerminalID: z.ZodNumber;
    ArrivingTerminalName: z.ZodString;
    SailingNotes: z.ZodString;
    Annotations: z.ZodArray<z.ZodString, "many">;
    Times: z.ZodArray<z.ZodObject<{
        DepartingTime: z.ZodDate;
        ArrivingTime: z.ZodNullable<z.ZodDate>;
        LoadingRule: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
        VesselID: z.ZodNumber;
        VesselName: z.ZodString;
        VesselHandicapAccessible: z.ZodBoolean;
        VesselPositionNum: z.ZodNumber;
        Routes: z.ZodArray<z.ZodNumber, "many">;
        AnnotationIndexes: z.ZodArray<z.ZodNumber, "many">;
    }, "strip", z.ZodTypeAny, {
        VesselID: number;
        VesselName: string;
        VesselHandicapAccessible: boolean;
        VesselPositionNum: number;
        DepartingTime: Date;
        ArrivingTime: Date | null;
        LoadingRule: 2 | 1 | 3;
        Routes: number[];
        AnnotationIndexes: number[];
    }, {
        VesselID: number;
        VesselName: string;
        VesselHandicapAccessible: boolean;
        VesselPositionNum: number;
        DepartingTime: Date;
        ArrivingTime: Date | null;
        LoadingRule: 2 | 1 | 3;
        Routes: number[];
        AnnotationIndexes: number[];
    }>, "many">;
    AnnotationsIVR: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    DepartingTerminalID: number;
    ArrivingTerminalID: number;
    Annotations: string[];
    SailingNotes: string;
    DepartingTerminalName: string;
    ArrivingTerminalName: string;
    Times: {
        VesselID: number;
        VesselName: string;
        VesselHandicapAccessible: boolean;
        VesselPositionNum: number;
        DepartingTime: Date;
        ArrivingTime: Date | null;
        LoadingRule: 2 | 1 | 3;
        Routes: number[];
        AnnotationIndexes: number[];
    }[];
    AnnotationsIVR: string[];
}, {
    DepartingTerminalID: number;
    ArrivingTerminalID: number;
    Annotations: string[];
    SailingNotes: string;
    DepartingTerminalName: string;
    ArrivingTerminalName: string;
    Times: {
        VesselID: number;
        VesselName: string;
        VesselHandicapAccessible: boolean;
        VesselPositionNum: number;
        DepartingTime: Date;
        ArrivingTime: Date | null;
        LoadingRule: 2 | 1 | 3;
        Routes: number[];
        AnnotationIndexes: number[];
    }[];
    AnnotationsIVR: string[];
}>, "many">;
type TerminalComboList = z.infer<typeof terminalCombosListSchema>;
/**
 * Schema for Schedule - represents schedule information
 */
declare const scheduleSchema: z.ZodObject<{
    ScheduleID: z.ZodNumber;
    ScheduleName: z.ZodString;
    ScheduleSeason: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
    SchedulePDFUrl: z.ZodString;
    ScheduleStart: z.ZodDate;
    ScheduleEnd: z.ZodDate;
    AllRoutes: z.ZodArray<z.ZodNumber, "many">;
    TerminalCombos: z.ZodArray<z.ZodObject<{
        DepartingTerminalID: z.ZodNumber;
        DepartingTerminalName: z.ZodString;
        ArrivingTerminalID: z.ZodNumber;
        ArrivingTerminalName: z.ZodString;
        SailingNotes: z.ZodString;
        Annotations: z.ZodArray<z.ZodString, "many">;
        Times: z.ZodArray<z.ZodObject<{
            DepartingTime: z.ZodDate;
            ArrivingTime: z.ZodNullable<z.ZodDate>;
            LoadingRule: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
            VesselID: z.ZodNumber;
            VesselName: z.ZodString;
            VesselHandicapAccessible: z.ZodBoolean;
            VesselPositionNum: z.ZodNumber;
            Routes: z.ZodArray<z.ZodNumber, "many">;
            AnnotationIndexes: z.ZodArray<z.ZodNumber, "many">;
        }, "strip", z.ZodTypeAny, {
            VesselID: number;
            VesselName: string;
            VesselHandicapAccessible: boolean;
            VesselPositionNum: number;
            DepartingTime: Date;
            ArrivingTime: Date | null;
            LoadingRule: 2 | 1 | 3;
            Routes: number[];
            AnnotationIndexes: number[];
        }, {
            VesselID: number;
            VesselName: string;
            VesselHandicapAccessible: boolean;
            VesselPositionNum: number;
            DepartingTime: Date;
            ArrivingTime: Date | null;
            LoadingRule: 2 | 1 | 3;
            Routes: number[];
            AnnotationIndexes: number[];
        }>, "many">;
        AnnotationsIVR: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        DepartingTerminalID: number;
        ArrivingTerminalID: number;
        Annotations: string[];
        SailingNotes: string;
        DepartingTerminalName: string;
        ArrivingTerminalName: string;
        Times: {
            VesselID: number;
            VesselName: string;
            VesselHandicapAccessible: boolean;
            VesselPositionNum: number;
            DepartingTime: Date;
            ArrivingTime: Date | null;
            LoadingRule: 2 | 1 | 3;
            Routes: number[];
            AnnotationIndexes: number[];
        }[];
        AnnotationsIVR: string[];
    }, {
        DepartingTerminalID: number;
        ArrivingTerminalID: number;
        Annotations: string[];
        SailingNotes: string;
        DepartingTerminalName: string;
        ArrivingTerminalName: string;
        Times: {
            VesselID: number;
            VesselName: string;
            VesselHandicapAccessible: boolean;
            VesselPositionNum: number;
            DepartingTime: Date;
            ArrivingTime: Date | null;
            LoadingRule: 2 | 1 | 3;
            Routes: number[];
            AnnotationIndexes: number[];
        }[];
        AnnotationsIVR: string[];
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    ScheduleID: number;
    ScheduleName: string;
    ScheduleSeason: 0 | 2 | 1 | 3;
    SchedulePDFUrl: string;
    ScheduleStart: Date;
    ScheduleEnd: Date;
    AllRoutes: number[];
    TerminalCombos: {
        DepartingTerminalID: number;
        ArrivingTerminalID: number;
        Annotations: string[];
        SailingNotes: string;
        DepartingTerminalName: string;
        ArrivingTerminalName: string;
        Times: {
            VesselID: number;
            VesselName: string;
            VesselHandicapAccessible: boolean;
            VesselPositionNum: number;
            DepartingTime: Date;
            ArrivingTime: Date | null;
            LoadingRule: 2 | 1 | 3;
            Routes: number[];
            AnnotationIndexes: number[];
        }[];
        AnnotationsIVR: string[];
    }[];
}, {
    ScheduleID: number;
    ScheduleName: string;
    ScheduleSeason: 0 | 2 | 1 | 3;
    SchedulePDFUrl: string;
    ScheduleStart: Date;
    ScheduleEnd: Date;
    AllRoutes: number[];
    TerminalCombos: {
        DepartingTerminalID: number;
        ArrivingTerminalID: number;
        Annotations: string[];
        SailingNotes: string;
        DepartingTerminalName: string;
        ArrivingTerminalName: string;
        Times: {
            VesselID: number;
            VesselName: string;
            VesselHandicapAccessible: boolean;
            VesselPositionNum: number;
            DepartingTime: Date;
            ArrivingTime: Date | null;
            LoadingRule: 2 | 1 | 3;
            Routes: number[];
            AnnotationIndexes: number[];
        }[];
        AnnotationsIVR: string[];
    }[];
}>;
type Schedule = z.infer<typeof scheduleSchema>;

/**
 * @fileoverview WSF Schedule API Input Schemas for Schedule Today
 *
 * This module provides Zod schemas for validating input parameters for the WSF
 * Schedule API endpoints related to today's schedule operations.
 */

/**
 * Schema for TodaysScheduleByTerminalCombo input parameters
 *
 * This operation provides today's departure times for either a terminal combination or a route. Valid departing and arriving terminals may be found using `/terminalsandmates` while valid routes may be found using `/routes`. For the OnlyRemainingTimes value, please indicate 'true' if departure times prior to now should not be included in the resultset and 'false' if they should be included in the resultset. */
declare const scheduleTodayByTerminalsInputSchema: z.ZodObject<{
    DepartingTerminalID: z.ZodNumber;
    ArrivingTerminalID: z.ZodNumber;
    OnlyRemainingTimes: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    DepartingTerminalID: number;
    ArrivingTerminalID: number;
    OnlyRemainingTimes: boolean;
}, {
    DepartingTerminalID: number;
    ArrivingTerminalID: number;
    OnlyRemainingTimes: boolean;
}>;
type ScheduleTodayByTerminalsInput = z.infer<typeof scheduleTodayByTerminalsInputSchema>;
/**
 * Schema for TodaysScheduleByRoute input parameters
 *
 * This operation provides today's departure times for either a terminal combination or a route. Valid departing and arriving terminals may be found using `/terminalsandmates` while valid routes may be found using `/routes`. For the OnlyRemainingTimes value, please indicate 'true' if departure times prior to now should not be included in the resultset and 'false' if they should be included in the resultset. */
declare const scheduleTodayByRouteSchema: z.ZodObject<{
    RouteID: z.ZodNumber;
    OnlyRemainingTimes: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    RouteID: number;
    OnlyRemainingTimes: boolean;
}, {
    RouteID: number;
    OnlyRemainingTimes: boolean;
}>;
type ScheduleTodayByRouteInput = z.infer<typeof scheduleTodayByRouteSchema>;

/**
 * @fileoverview WSF Schedule API Input Schemas for Terminals
 *
 * This module provides Zod schemas for validating input parameters for the WSF
 * Schedule API endpoints related to terminal operations.
 */

/**
 * Schema for TerminalsAndMates input parameters
 *
 * This operation retrieves all valid departing and arriving terminal combinations for a given trip date. A valid trip date may be determined using `/validdaterange`. Please format the trip date input as `'YYYY-MM-DD'` (eg. `'2014-04-01'` for a trip date occurring on April 1, 2014). */
declare const terminalsAndMatesInputSchema: z.ZodObject<{
    TripDate: z.ZodString;
}, "strip", z.ZodTypeAny, {
    TripDate: string;
}, {
    TripDate: string;
}>;
type TerminalsAndMatesInput = z.infer<typeof terminalsAndMatesInputSchema>;
/**
 * Schema for TerminalsAndMatesByRoute input parameters
 *
 * This operation provides valid departing and arriving terminal combinations for a given trip date and route. Valid routes may be found by using `/routes`. Similarly, a valid trip date may be determined using `/validdaterange`. Please format the trip date input as `'YYYY-MM-DD'` (eg. `'2014-04-01'` for a trip date occurring on April 1, 2014). */
declare const terminalsAndMatesByRouteInputSchema: z.ZodObject<{
    TripDate: z.ZodString;
    RouteID: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    TripDate: string;
    RouteID: number;
}, {
    TripDate: string;
    RouteID: number;
}>;
type TerminalsAndMatesByRouteInput = z.infer<typeof terminalsAndMatesByRouteInputSchema>;
/**
 * Schema for TerminalMates input parameters
 *
 * This operation provides arriving terminals for a given departing terminal and trip date. A valid departing terminal may be found by using `/terminals`. Similarly, a valid trip date may be determined using `/validdaterange`. Please format the trip date input as `'YYYY-MM-DD'` (eg. `'2014-04-01'` for a trip date occurring on April 1, 2014). */
declare const terminalMatesScheduleInputSchema: z.ZodObject<{
    TripDate: z.ZodString;
    TerminalID: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    TripDate: string;
    TerminalID: number;
}, {
    TripDate: string;
    TerminalID: number;
}>;
type TerminalMatesScheduleInput = TerminalMatesInput;

/**
 * @fileoverview WSF Schedule API Output Schemas for Terminals
 *
 * This module provides Zod schemas for validating responses from the WSF
 * Schedule API terminal operations.
 */

/**
 * Schema for TerminalMate - represents terminal mate information
 */
declare const terminalMateSchema: z.ZodObject<{
    DepartingTerminalID: z.ZodNumber;
    DepartingDescription: z.ZodString;
    ArrivingTerminalID: z.ZodNumber;
    ArrivingDescription: z.ZodString;
}, "strip", z.ZodTypeAny, {
    DepartingTerminalID: number;
    ArrivingTerminalID: number;
    DepartingDescription: string;
    ArrivingDescription: string;
}, {
    DepartingTerminalID: number;
    ArrivingTerminalID: number;
    DepartingDescription: string;
    ArrivingDescription: string;
}>;
type TerminalMate = z.infer<typeof terminalMateSchema>;
/**
 * Terminal Mates List Schema - represents an list of terminal mates
 */
declare const terminalMatesListSchema: z.ZodArray<z.ZodObject<{
    DepartingTerminalID: z.ZodNumber;
    DepartingDescription: z.ZodString;
    ArrivingTerminalID: z.ZodNumber;
    ArrivingDescription: z.ZodString;
}, "strip", z.ZodTypeAny, {
    DepartingTerminalID: number;
    ArrivingTerminalID: number;
    DepartingDescription: string;
    ArrivingDescription: string;
}, {
    DepartingTerminalID: number;
    ArrivingTerminalID: number;
    DepartingDescription: string;
    ArrivingDescription: string;
}>, "many">;
type TerminalMateList = z.infer<typeof terminalMatesListSchema>;
declare const terminalsListSchema: z.ZodArray<z.ZodObject<{
    TerminalID: z.ZodNumber;
    Description: z.ZodString;
}, "strip", z.ZodTypeAny, {
    Description: string;
    TerminalID: number;
}, {
    Description: string;
    TerminalID: number;
}>, "many">;
type TerminalsList = TerminalList;

/**
 * @fileoverview WSF Schedule API Input Schemas for Time Adjustments
 *
 * This module provides Zod schemas for validating input parameters for the WSF
 * Schedule API endpoints related to time adjustment operations.
 */

/**
 * Schema for TimeAdj input parameters
 *
 * This operation provides a listing of all additions and cancellations that deviate on specific dates from the scheduled times found in the `/sailings` resultset (eg. tidal cancellations affecting Port Townsend departures on 9/9/2014). */
declare const timeAdjustmentsInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
type TimeAdjustmentsInput = z.infer<typeof timeAdjustmentsInputSchema>;
/**
 * Schema for TimeAdjByRoute input parameters
 *
 * This operation provides a listing of all additions and cancellations for a route that deviate on specific dates from the scheduled times found in the `/sailings` resultset (eg. tidal cancellations affecting Port Townsend departures on 9/9/2014). A valid route may be determined using `/routes`. */
declare const timeAdjustmentsByRouteInputSchema: z.ZodObject<{
    RouteID: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    RouteID: number;
}, {
    RouteID: number;
}>;
type TimeAdjustmentsByRouteInput = z.infer<typeof timeAdjustmentsByRouteInputSchema>;
/**
 * Schema for TimeAdjBySchedRoute input parameters
 *
 * This operation provides a listing of all additions and cancellations for a scheduled route that deviate on specific dates from the scheduled times found in the `/sailings` resultset (eg. tidal cancellations affecting Port Townsend departures on 9/9/2014). A valid scheduled route may be determined using `/schedroutes`. */
declare const timeAdjustmentsBySchedRouteInputSchema: z.ZodObject<{
    SchedRouteID: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    SchedRouteID: number;
}, {
    SchedRouteID: number;
}>;
type TimeAdjustmentsBySchedRouteInput = z.infer<typeof timeAdjustmentsBySchedRouteInputSchema>;

/**
 * @fileoverview WSF Schedule API Output Schemas for Time Adjustments
 *
 * This module provides Zod schemas for validating responses from the WSF
 * Schedule API time adjustment operations.
 */

/**
 * Schema for TimeAdjustment - represents time adjustment information
 */
declare const timeAdjustmentSchema: z.ZodObject<{
    ScheduleID: z.ZodNumber;
    SchedRouteID: z.ZodNumber;
    RouteID: z.ZodNumber;
    RouteDescription: z.ZodNullable<z.ZodString>;
    RouteSortSeq: z.ZodNumber;
    SailingID: z.ZodNumber;
    SailingDescription: z.ZodNullable<z.ZodString>;
    ActiveSailingDateRange: z.ZodNullable<z.ZodObject<{
        DateFrom: z.ZodDate;
        DateThru: z.ZodDate;
        EventID: z.ZodNullable<z.ZodNumber>;
        EventDescription: z.ZodNullable<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
    }, {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
    }>>;
    SailingDir: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>;
    JourneyID: z.ZodNumber;
    VesselID: z.ZodNumber;
    VesselName: z.ZodNullable<z.ZodString>;
    VesselHandicapAccessible: z.ZodBoolean;
    VesselPositionNum: z.ZodNumber;
    JourneyTerminalID: z.ZodNumber;
    TerminalID: z.ZodNumber;
    TerminalDescription: z.ZodString;
    TerminalBriefDescription: z.ZodString;
    TimeToAdj: z.ZodDate;
    AdjDateFrom: z.ZodDate;
    AdjDateThru: z.ZodDate;
    TidalAdj: z.ZodBoolean;
    EventID: z.ZodNullable<z.ZodNumber>;
    EventDescription: z.ZodNullable<z.ZodString>;
    DepArrIndicator: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>;
    AdjType: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>;
    Annotations: z.ZodArray<z.ZodObject<{
        AnnotationID: z.ZodNumber;
        AnnotationText: z.ZodNullable<z.ZodString>;
        AnnotationIVRText: z.ZodNullable<z.ZodString>;
        AdjustedCrossingTime: z.ZodNullable<z.ZodNumber>;
        AnnotationImg: z.ZodNullable<z.ZodString>;
        TypeDescription: z.ZodNullable<z.ZodString>;
        SortSeq: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        AnnotationID: number;
        AnnotationText: string | null;
        AnnotationIVRText: string | null;
        AdjustedCrossingTime: number | null;
        AnnotationImg: string | null;
        TypeDescription: string | null;
        SortSeq: number;
    }, {
        AnnotationID: number;
        AnnotationText: string | null;
        AnnotationIVRText: string | null;
        AdjustedCrossingTime: number | null;
        AnnotationImg: string | null;
        TypeDescription: string | null;
        SortSeq: number;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    TerminalID: number;
    ScheduleID: number;
    RouteID: number;
    SchedRouteID: number;
    EventID: number | null;
    EventDescription: string | null;
    JourneyTerminalID: number;
    TerminalDescription: string;
    TerminalBriefDescription: string;
    DepArrIndicator: 2 | 1;
    Annotations: {
        AnnotationID: number;
        AnnotationText: string | null;
        AnnotationIVRText: string | null;
        AdjustedCrossingTime: number | null;
        AnnotationImg: string | null;
        TypeDescription: string | null;
        SortSeq: number;
    }[];
    JourneyID: number;
    VesselID: number;
    VesselName: string | null;
    VesselHandicapAccessible: boolean;
    VesselPositionNum: number;
    SailingID: number;
    SailingDescription: string | null;
    SailingDir: 2 | 1;
    AdjType: 2 | 1;
    RouteDescription: string | null;
    RouteSortSeq: number;
    ActiveSailingDateRange: {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
    } | null;
    TimeToAdj: Date;
    AdjDateFrom: Date;
    AdjDateThru: Date;
    TidalAdj: boolean;
}, {
    TerminalID: number;
    ScheduleID: number;
    RouteID: number;
    SchedRouteID: number;
    EventID: number | null;
    EventDescription: string | null;
    JourneyTerminalID: number;
    TerminalDescription: string;
    TerminalBriefDescription: string;
    DepArrIndicator: 2 | 1;
    Annotations: {
        AnnotationID: number;
        AnnotationText: string | null;
        AnnotationIVRText: string | null;
        AdjustedCrossingTime: number | null;
        AnnotationImg: string | null;
        TypeDescription: string | null;
        SortSeq: number;
    }[];
    JourneyID: number;
    VesselID: number;
    VesselName: string | null;
    VesselHandicapAccessible: boolean;
    VesselPositionNum: number;
    SailingID: number;
    SailingDescription: string | null;
    SailingDir: 2 | 1;
    AdjType: 2 | 1;
    RouteDescription: string | null;
    RouteSortSeq: number;
    ActiveSailingDateRange: {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
    } | null;
    TimeToAdj: Date;
    AdjDateFrom: Date;
    AdjDateThru: Date;
    TidalAdj: boolean;
}>;
type TimeAdjustment = z.infer<typeof timeAdjustmentSchema>;
/**
 * Time Adjustments List Schema - represents an list of time adjustments
 */
declare const timeAdjustmentsListSchema: z.ZodArray<z.ZodObject<{
    ScheduleID: z.ZodNumber;
    SchedRouteID: z.ZodNumber;
    RouteID: z.ZodNumber;
    RouteDescription: z.ZodNullable<z.ZodString>;
    RouteSortSeq: z.ZodNumber;
    SailingID: z.ZodNumber;
    SailingDescription: z.ZodNullable<z.ZodString>;
    ActiveSailingDateRange: z.ZodNullable<z.ZodObject<{
        DateFrom: z.ZodDate;
        DateThru: z.ZodDate;
        EventID: z.ZodNullable<z.ZodNumber>;
        EventDescription: z.ZodNullable<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
    }, {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
    }>>;
    SailingDir: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>;
    JourneyID: z.ZodNumber;
    VesselID: z.ZodNumber;
    VesselName: z.ZodNullable<z.ZodString>;
    VesselHandicapAccessible: z.ZodBoolean;
    VesselPositionNum: z.ZodNumber;
    JourneyTerminalID: z.ZodNumber;
    TerminalID: z.ZodNumber;
    TerminalDescription: z.ZodString;
    TerminalBriefDescription: z.ZodString;
    TimeToAdj: z.ZodDate;
    AdjDateFrom: z.ZodDate;
    AdjDateThru: z.ZodDate;
    TidalAdj: z.ZodBoolean;
    EventID: z.ZodNullable<z.ZodNumber>;
    EventDescription: z.ZodNullable<z.ZodString>;
    DepArrIndicator: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>;
    AdjType: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>;
    Annotations: z.ZodArray<z.ZodObject<{
        AnnotationID: z.ZodNumber;
        AnnotationText: z.ZodNullable<z.ZodString>;
        AnnotationIVRText: z.ZodNullable<z.ZodString>;
        AdjustedCrossingTime: z.ZodNullable<z.ZodNumber>;
        AnnotationImg: z.ZodNullable<z.ZodString>;
        TypeDescription: z.ZodNullable<z.ZodString>;
        SortSeq: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        AnnotationID: number;
        AnnotationText: string | null;
        AnnotationIVRText: string | null;
        AdjustedCrossingTime: number | null;
        AnnotationImg: string | null;
        TypeDescription: string | null;
        SortSeq: number;
    }, {
        AnnotationID: number;
        AnnotationText: string | null;
        AnnotationIVRText: string | null;
        AdjustedCrossingTime: number | null;
        AnnotationImg: string | null;
        TypeDescription: string | null;
        SortSeq: number;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    TerminalID: number;
    ScheduleID: number;
    RouteID: number;
    SchedRouteID: number;
    EventID: number | null;
    EventDescription: string | null;
    JourneyTerminalID: number;
    TerminalDescription: string;
    TerminalBriefDescription: string;
    DepArrIndicator: 2 | 1;
    Annotations: {
        AnnotationID: number;
        AnnotationText: string | null;
        AnnotationIVRText: string | null;
        AdjustedCrossingTime: number | null;
        AnnotationImg: string | null;
        TypeDescription: string | null;
        SortSeq: number;
    }[];
    JourneyID: number;
    VesselID: number;
    VesselName: string | null;
    VesselHandicapAccessible: boolean;
    VesselPositionNum: number;
    SailingID: number;
    SailingDescription: string | null;
    SailingDir: 2 | 1;
    AdjType: 2 | 1;
    RouteDescription: string | null;
    RouteSortSeq: number;
    ActiveSailingDateRange: {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
    } | null;
    TimeToAdj: Date;
    AdjDateFrom: Date;
    AdjDateThru: Date;
    TidalAdj: boolean;
}, {
    TerminalID: number;
    ScheduleID: number;
    RouteID: number;
    SchedRouteID: number;
    EventID: number | null;
    EventDescription: string | null;
    JourneyTerminalID: number;
    TerminalDescription: string;
    TerminalBriefDescription: string;
    DepArrIndicator: 2 | 1;
    Annotations: {
        AnnotationID: number;
        AnnotationText: string | null;
        AnnotationIVRText: string | null;
        AdjustedCrossingTime: number | null;
        AnnotationImg: string | null;
        TypeDescription: string | null;
        SortSeq: number;
    }[];
    JourneyID: number;
    VesselID: number;
    VesselName: string | null;
    VesselHandicapAccessible: boolean;
    VesselPositionNum: number;
    SailingID: number;
    SailingDescription: string | null;
    SailingDir: 2 | 1;
    AdjType: 2 | 1;
    RouteDescription: string | null;
    RouteSortSeq: number;
    ActiveSailingDateRange: {
        DateFrom: Date;
        DateThru: Date;
        EventID: number | null;
        EventDescription: string | null;
    } | null;
    TimeToAdj: Date;
    AdjDateFrom: Date;
    AdjDateThru: Date;
    TidalAdj: boolean;
}>, "many">;
type TimeAdjustmentList = z.infer<typeof timeAdjustmentsListSchema>;

/**
 * @fileoverview WSF Schedule API Input Schemas for Valid Date Range
 *
 * This module provides Zod schemas for validating input parameters for the WSF
 * Schedule API endpoints related to valid date range operations.
 */

/**
 * Schema for ValidDateRange input parameters
 *
 * This operation retrieves a date range for which schedule data is currently published & available. */
declare const scheduleValidDateRangeInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
type ScheduleValidDateRangeInput = z.infer<typeof scheduleValidDateRangeInputSchema>;

export { type ActiveDateRange, type ActiveDateRangeList, type ActiveSeason, type ActiveSeasonsInput, type AlertDetail, type AlertDetailList, type AlertList, type AllSailingsBySchedRouteIDInput, type Annotation, type AnnotationList, type ContingencyAdj, type ContingencyAdjList, type Journey, type JourneyList, type Route, type RouteAlert, type RouteBase, type RouteDetail, type RouteDetailsByTripDateAndRouteIdInput, type RouteDetailsByTripDateAndTerminalsInput, type RouteDetailsByTripDateInput, type RouteDetailsInput, type RouteDetailsList, type RoutesByTripDateAndTerminalsInput, type RoutesByTripDateInput, type RoutesHavingServiceDisruptionsByTripDateInput, type Sailing, type SailingList, type SailingsByRouteIDInput, type SchedRoute, type SchedRouteList, type Schedule, type ScheduleAlertsInput, type ScheduleBase, type ScheduleByTripDateAndRouteIdInput, type ScheduleByTripDateAndTerminalsInput, type ScheduleTodayByRouteInput, type ScheduleTodayByTerminalsInput, type ScheduleValidDateRangeInput, type ScheduledRoutesByIdInput, type ScheduledRoutesInput, type ServiceDisruption, type ServiceDisruptionList, type TerminalCombo, type TerminalComboList, TerminalList, type TerminalMate, type TerminalMateList, TerminalMatesInput, type TerminalMatesScheduleInput, type TerminalTime, type TerminalTimeList, type TerminalsAndMatesByRouteInput, type TerminalsAndMatesInput, type TerminalsList, type TimeAdjustment, type TimeAdjustmentList, type TimeAdjustmentsByRouteInput, type TimeAdjustmentsBySchedRouteInput, type TimeAdjustmentsInput, activeDateRangeSchema, activeDateRangesListSchema, activeSeasonSchema, activeSeasonsInputSchema, alertDetailSchema, alertDetailsListSchema, alertsListSchema, allSailingsBySchedRouteIDInputSchema, annotationSchema, annotationsListSchema, contingencyAdjSchema, contingencyAdjsListSchema, journeySchema, journeysListSchema, routeAlertSchema, routeBaseSchema, routeDetailSchema, routeDetailsByTripDateAndRouteIdInputSchema, routeDetailsByTripDateAndTerminalsInputSchema, routeDetailsByTripDateInputSchema, routeDetailsListSchema, routeDetailsSchema, routeSchema, routesByTripDateAndTerminalsInputSchema, routesByTripDateInputSchema, routesHavingServiceDisruptionsByTripDateInputSchema, sailingSchema, sailingsByRouteIDInputSchema, sailingsListSchema, schedRouteSchema, schedRoutesListSchema, scheduleAlertsInputSchema, scheduleBaseSchema, scheduleByTripDateAndRouteIdInputSchema, scheduleByTripDateAndTerminals, scheduleSchema, scheduleTodayByRouteSchema, scheduleTodayByTerminalsInputSchema, scheduleValidDateRangeInputSchema, scheduledRoutesByIdInputSchema, scheduledRoutesInputSchema, serviceDisruptionSchema, serviceDisruptionsListSchema, terminalComboSchema, terminalCombosListSchema, terminalMateSchema, terminalMatesListSchema, terminalMatesScheduleInputSchema, terminalTimeSchema, terminalTimesListSchema, terminalsAndMatesByRouteInputSchema, terminalsAndMatesInputSchema, terminalsListSchema, timeAdjustmentSchema, timeAdjustmentsByRouteInputSchema, timeAdjustmentsBySchedRouteInputSchema, timeAdjustmentsInputSchema, timeAdjustmentsListSchema };