import { Collection, Vertex } from "./util/vertex.js";
import { IdKey, InternalIdKey } from "../../types/common/index.js";
import { DeepVertexExport, DeepVertexExportOmitPrivateId, MixedVertexExport, MixedWithOptionalIdVertexExport } from "./util/deep-vertex-export/index.js";
import { SerializedVertexExport } from "./util/serialized-vertex-export.js";
import { PeriodVertex } from "./periods.js";
import { RootIntervalVertex } from "./root-intervals.js";
import { CalendarException, DivisionSettingsVertex } from "./division-settings.js";
import { GenerationVertex } from "./generations.js";
import { DivisionVertex, StepGuideProgress } from "./divisions.js";
import { PersonVertex } from "./persons.js";
import { LocationVertex } from "./locations.js";
import { LinkedEventsSetVertex } from "./linked-events-sets.js";
import { UserVertex } from "./users.js";
import { ThreadVertex } from "./threads.js";
import { SyllabusVertex } from "./syllabuses.js";
import { CalendarEventVertex, EventVertex, ScheduleEventVertex } from "./events.js";
import { CourseVertex } from "./courses.js";
import { CalendarExceptionAction, ExceptionStatus, ExceptionVertex } from "./exceptions.js";
import { GroupVertex } from "./groups.js";
import { LockedTimeType, LockedTimeVertex } from "./locked-times.js";
import { TeacherVertex } from "./teachers.js";
import { ConfigurationFilterVertex, ConfigurationRuleVertex, ConfigurationTemplateVertex, ConfigurationVertex } from "./configurations.js";
import { MessageVertex } from "./messages.js";
import { ConversationVertex } from "./conversations.js";
import { Infer, VertexQuery, createVertexQuery } from "./vertex-query.js";

//#region src/core/interfaces/vertices/index.d.ts
type Is<C extends Collection> = Pick<Vertex<C>, 'is'>;
type ScheduleOf<TDivision extends Is<'divisions'>, TSettings extends Is<'settings'>, TException extends Is<'exceptions'>, TGroup extends Is<'groups'>, TTeacher extends Is<'teachers'>, TLocation extends Is<'locations'>, TCourse extends Is<'courses'>, TEvent extends Is<'events'>, TPeriod extends Is<'periods'>, TPerson extends Is<'persons'>, TLockedTime extends Is<'lockedTimes'>, TRootInterval extends Is<'rootIntervals'>, TSyllabus extends Is<'syllabuses'>, TConfiguration extends Is<'configurations'>, TLinkedEventsSet extends Is<'linkedEventsSets'>> = {
  divisions: TDivision;
  settings: TSettings;
  exceptions: TException[];
  groups: TGroup[];
  teachers: TTeacher[];
  locations: TLocation[];
  courses: TCourse[];
  events: TEvent[];
  periods: TPeriod[];
  persons: TPerson[];
  lockedTimes: TLockedTime[];
  rootIntervals: TRootInterval[];
  syllabuses: TSyllabus[];
  configurations: TConfiguration[];
  linkedEventsSets: TLinkedEventsSet[];
};
declare namespace Serialized {
  type Teacher = SerializedVertexExport<TeacherVertex>;
  type Exception = SerializedVertexExport<ExceptionVertex>;
  type Event = SerializedVertexExport<EventVertex>;
  type ScheduleEvent = SerializedVertexExport<ScheduleEventVertex>;
  type CalendarEvent = SerializedVertexExport<CalendarEventVertex>;
  type Course = SerializedVertexExport<CourseVertex>;
  type Settings = SerializedVertexExport<DivisionSettingsVertex>;
  type Division = SerializedVertexExport<DivisionVertex>;
  type Generation = SerializedVertexExport<GenerationVertex>;
  type Group = SerializedVertexExport<GroupVertex>;
  type Location = SerializedVertexExport<LocationVertex>;
  type LockedTime = SerializedVertexExport<LockedTimeVertex>;
  type LinkedEventsSet = SerializedVertexExport<LinkedEventsSetVertex>;
  type Period = SerializedVertexExport<PeriodVertex>;
  type Person = SerializedVertexExport<PersonVertex>;
  type RootInterval = SerializedVertexExport<RootIntervalVertex>;
  type Syllabus = SerializedVertexExport<SyllabusVertex>;
  type Thread = SerializedVertexExport<ThreadVertex>;
  type User = SerializedVertexExport<UserVertex>;
  type Conversation = SerializedVertexExport<ConversationVertex>;
  type Message = SerializedVertexExport<MessageVertex>;
  namespace Configuration {
    type Base = SerializedVertexExport<ConfigurationVertex>;
    type Filter = SerializedVertexExport<ConfigurationFilterVertex>;
    type Template = SerializedVertexExport<ConfigurationTemplateVertex>;
    type Rule = SerializedVertexExport<ConfigurationRuleVertex>;
    type Mixed = Filter | Template | Rule;
  }
  type Schedule = ScheduleOf<Division, Settings, Exception, Group, Teacher, Location, Course, Event, Period, Person, LockedTime, RootInterval, Syllabus, Configuration.Base, LinkedEventsSet>;
}
declare namespace Deep {
  type Teacher = DeepVertexExport<TeacherVertex>;
  type Exception = DeepVertexExport<ExceptionVertex>;
  type Event = DeepVertexExport<EventVertex>;
  type ScheduleEvent = DeepVertexExport<ScheduleEventVertex>;
  type CalendarEvent = DeepVertexExport<CalendarEventVertex>;
  type Course = DeepVertexExport<CourseVertex>;
  type Settings = DeepVertexExport<DivisionSettingsVertex>;
  type Division = DeepVertexExport<DivisionVertex>;
  type Generation = DeepVertexExport<GenerationVertex>;
  type Group = DeepVertexExport<GroupVertex>;
  type Location = DeepVertexExport<LocationVertex>;
  type LockedTime = DeepVertexExport<LockedTimeVertex>;
  type LinkedEventsSet = DeepVertexExport<LinkedEventsSetVertex>;
  type Period = DeepVertexExport<PeriodVertex>;
  type Person = DeepVertexExport<PersonVertex>;
  type RootInterval = DeepVertexExport<RootIntervalVertex>;
  type Syllabus = DeepVertexExport<SyllabusVertex>;
  type Thread = DeepVertexExport<ThreadVertex>;
  type User = DeepVertexExport<UserVertex>;
  type Conversation = DeepVertexExport<ConversationVertex>;
  type Message = DeepVertexExport<MessageVertex>;
  namespace Configuration {
    type Base = DeepVertexExport<ConfigurationVertex>;
    type Filter = DeepVertexExport<ConfigurationFilterVertex>;
    type Template = DeepVertexExport<ConfigurationTemplateVertex>;
    type Rule = DeepVertexExport<ConfigurationRuleVertex>;
    type Mixed = Filter | Template | Rule;
  }
  type Schedule = ScheduleOf<Division, Settings, Exception, Group, Teacher, Location, Course, Event, Period, Person, LockedTime, RootInterval, Syllabus, Configuration.Base, LinkedEventsSet>;
}
declare namespace DeepWithoutPrivateId {
  type Teacher = DeepVertexExportOmitPrivateId<TeacherVertex>;
  type Exception = DeepVertexExportOmitPrivateId<ExceptionVertex>;
  type Event = DeepVertexExportOmitPrivateId<EventVertex>;
  type ScheduleEvent = DeepVertexExportOmitPrivateId<ScheduleEventVertex>;
  type CalendarEvent = DeepVertexExportOmitPrivateId<CalendarEventVertex>;
  type Course = DeepVertexExportOmitPrivateId<CourseVertex>;
  type Settings = DeepVertexExportOmitPrivateId<DivisionSettingsVertex>;
  type Division = DeepVertexExportOmitPrivateId<DivisionVertex>;
  type Generation = DeepVertexExportOmitPrivateId<GenerationVertex>;
  type Group = DeepVertexExportOmitPrivateId<GroupVertex>;
  type Location = DeepVertexExportOmitPrivateId<LocationVertex>;
  type LockedTime = DeepVertexExportOmitPrivateId<LockedTimeVertex>;
  type LinkedEventsSet = DeepVertexExportOmitPrivateId<LinkedEventsSetVertex>;
  type Period = DeepVertexExportOmitPrivateId<PeriodVertex>;
  type Person = DeepVertexExportOmitPrivateId<PersonVertex>;
  type RootInterval = DeepVertexExportOmitPrivateId<RootIntervalVertex>;
  type Syllabus = DeepVertexExportOmitPrivateId<SyllabusVertex>;
  type Thread = DeepVertexExportOmitPrivateId<ThreadVertex>;
  type User = DeepVertexExportOmitPrivateId<UserVertex>;
  type Conversation = DeepVertexExportOmitPrivateId<ConversationVertex>;
  type Message = DeepVertexExportOmitPrivateId<MessageVertex>;
  namespace Configuration {
    type Base = DeepVertexExport<ConfigurationVertex>;
    type Filter = DeepVertexExport<ConfigurationFilterVertex>;
    type Template = DeepVertexExport<ConfigurationTemplateVertex>;
    type Rule = DeepVertexExport<ConfigurationRuleVertex>;
    type Mixed = Filter | Template | Rule;
  }
  type Schedule = ScheduleOf<Division, Settings, Exception, Group, Teacher, Location, Course, Event, Period, Person, LockedTime, RootInterval, Syllabus, Configuration.Base, LinkedEventsSet>;
}
declare namespace Mixed {
  type Teacher = MixedVertexExport<TeacherVertex>;
  type Exception = MixedVertexExport<ExceptionVertex>;
  type Event = MixedVertexExport<EventVertex>;
  type ScheduleEvent = MixedVertexExport<ScheduleEventVertex>;
  type CalendarEvent = MixedVertexExport<CalendarEventVertex>;
  type Course = MixedVertexExport<CourseVertex>;
  type Settings = MixedVertexExport<DivisionSettingsVertex>;
  type Division = MixedVertexExport<DivisionVertex>;
  type Generation = MixedVertexExport<GenerationVertex>;
  type Group = MixedVertexExport<GroupVertex>;
  type Location = MixedVertexExport<LocationVertex>;
  type LockedTime = MixedVertexExport<LockedTimeVertex>;
  type LinkedEventsSet = MixedVertexExport<LinkedEventsSetVertex>;
  type Period = MixedVertexExport<PeriodVertex>;
  type Person = MixedVertexExport<PersonVertex>;
  type RootInterval = MixedVertexExport<RootIntervalVertex>;
  type Syllabus = MixedVertexExport<SyllabusVertex>;
  type Thread = MixedVertexExport<ThreadVertex>;
  type User = MixedVertexExport<UserVertex>;
  type Conversation = MixedVertexExport<ConversationVertex>;
  type Message = MixedVertexExport<MessageVertex>;
  namespace Configuration {
    type Base = MixedVertexExport<ConfigurationVertex>;
    type Filter = MixedVertexExport<ConfigurationFilterVertex>;
    type Template = MixedVertexExport<ConfigurationTemplateVertex>;
    type Rule = MixedVertexExport<ConfigurationRuleVertex>;
    type Mixed = Filter | Template | Rule;
  }
  type Schedule = ScheduleOf<Division, Settings, Exception, Group, Teacher, Location, Course, Event, Period, Person, LockedTime, RootInterval, Syllabus, Configuration.Base, LinkedEventsSet>;
}
declare namespace MixedWithOptionalId {
  type Teacher = MixedWithOptionalIdVertexExport<TeacherVertex>;
  type Exception = MixedWithOptionalIdVertexExport<ExceptionVertex>;
  type Event = MixedWithOptionalIdVertexExport<EventVertex>;
  type ScheduleEvent = MixedWithOptionalIdVertexExport<ScheduleEventVertex>;
  type CalendarEvent = MixedWithOptionalIdVertexExport<CalendarEventVertex>;
  type Course = MixedWithOptionalIdVertexExport<CourseVertex>;
  type Settings = MixedWithOptionalIdVertexExport<DivisionSettingsVertex>;
  type Division = MixedWithOptionalIdVertexExport<DivisionVertex>;
  type Generation = MixedWithOptionalIdVertexExport<GenerationVertex>;
  type Group = MixedWithOptionalIdVertexExport<GroupVertex>;
  type Location = MixedWithOptionalIdVertexExport<LocationVertex>;
  type LockedTime = MixedWithOptionalIdVertexExport<LockedTimeVertex>;
  type LinkedEventsSet = MixedWithOptionalIdVertexExport<LinkedEventsSetVertex>;
  type Period = MixedWithOptionalIdVertexExport<PeriodVertex>;
  type Person = MixedWithOptionalIdVertexExport<PersonVertex>;
  type RootInterval = MixedWithOptionalIdVertexExport<RootIntervalVertex>;
  type Syllabus = MixedWithOptionalIdVertexExport<SyllabusVertex>;
  type Thread = MixedWithOptionalIdVertexExport<ThreadVertex>;
  type User = MixedWithOptionalIdVertexExport<UserVertex>;
  type Conversation = MixedWithOptionalIdVertexExport<ConversationVertex>;
  type Message = MixedWithOptionalIdVertexExport<MessageVertex>;
  namespace Configuration {
    type Base = MixedWithOptionalIdVertexExport<ConfigurationVertex>;
    type Filter = MixedWithOptionalIdVertexExport<ConfigurationFilterVertex>;
    type Template = MixedWithOptionalIdVertexExport<ConfigurationTemplateVertex>;
    type Rule = MixedWithOptionalIdVertexExport<ConfigurationRuleVertex>;
    type Mixed = Filter | Template | Rule;
  }
  type Schedule = ScheduleOf<Division, Settings, Exception, Group, Teacher, Location, Course, Event, Period, Person, LockedTime, RootInterval, Syllabus, Configuration.Base, LinkedEventsSet>;
}
declare namespace SerializedWithOptionalId {
  type MakeIdsOptional<T extends Pick<Vertex<Collection>, IdKey | InternalIdKey>> = Omit<T, IdKey | InternalIdKey> & Partial<Pick<T, IdKey | InternalIdKey>>;
  export type Teacher = MakeIdsOptional<Serialized.Teacher>;
  export type Exception = MakeIdsOptional<Serialized.Exception>;
  export type Event = MakeIdsOptional<Serialized.Event>;
  export type ScheduleEvent = MakeIdsOptional<Serialized.ScheduleEvent>;
  export type CalendarEvent = MakeIdsOptional<Serialized.CalendarEvent>;
  export type Course = MakeIdsOptional<Serialized.Course>;
  export type Settings = MakeIdsOptional<Serialized.Settings>;
  export type Division = MakeIdsOptional<Serialized.Division>;
  export type Generation = MakeIdsOptional<Serialized.Generation>;
  export type Group = MakeIdsOptional<Serialized.Group>;
  export type Location = MakeIdsOptional<Serialized.Location>;
  export type LockedTime = MakeIdsOptional<Serialized.LockedTime>;
  export type LinkedEventsSet = MakeIdsOptional<Serialized.LinkedEventsSet>;
  export type Period = MakeIdsOptional<Serialized.Period>;
  export type Person = MakeIdsOptional<Serialized.Person>;
  export type RootInterval = MakeIdsOptional<Serialized.RootInterval>;
  export type Syllabus = MakeIdsOptional<Serialized.Syllabus>;
  export type Thread = MakeIdsOptional<Serialized.Thread>;
  export type User = MakeIdsOptional<Serialized.User>;
  export type Conversation = MakeIdsOptional<Serialized.Conversation>;
  export type Message = MakeIdsOptional<Serialized.Message>;
  export namespace Configuration {
    type Base = MakeIdsOptional<Serialized.Configuration.Base>;
    type Filter = MakeIdsOptional<Serialized.Configuration.Filter>;
    type Template = MakeIdsOptional<Serialized.Configuration.Template>;
    type Rule = MakeIdsOptional<Serialized.Configuration.Rule>;
    type Mixed = Filter | Template | Rule;
  }
  export type Schedule = ScheduleOf<Division, Settings, Exception, Group, Teacher, Location, Course, Event, Period, Person, LockedTime, RootInterval, Syllabus, Configuration.Base, LinkedEventsSet>;
  export {};
}
//#endregion
export { Deep, DeepWithoutPrivateId, Mixed, MixedWithOptionalId, Serialized, SerializedWithOptionalId };
//# sourceMappingURL=index.d.ts.map