import { VertexQuery as VertexQuery$1 } from "./util/vertex-query/index.js";
import { AssertNoInvalidExpandKeys } from "./util/custom-vertex-export/assert-no-invalid-expand-keys.js";
import { CustomVertexExport } from "./util/custom-vertex-export/index.js";
import { CompanyVertex } from "./companies.js";
import { PeriodVertex } from "./periods.js";
import { RootIntervalVertex } from "./root-intervals.js";
import { DivisionSettingsVertex } from "./division-settings.js";
import { GenerationVertex } from "./generations.js";
import { DivisionVertex } 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 { ExceptionVertex } from "./exceptions.js";
import { GroupVertex } from "./groups.js";
import { LockedTimeVertex } from "./locked-times.js";
import { TeacherVertex } from "./teachers.js";
import { ConfigurationVertex } from "./configurations.js";
import { MessageVertex } from "./messages.js";
import { ConversationVertex } from "./conversations.js";

//#region src/core/interfaces/vertices/vertex-query.d.ts
type VertexRecord = {
  divisions: DivisionVertex;
  divisionSettings: DivisionSettingsVertex;
  settings: DivisionSettingsVertex;
  teachers: TeacherVertex;
  exceptions: ExceptionVertex;
  events: EventVertex;
  scheduleEvents: ScheduleEventVertex;
  calendarEvents: CalendarEventVertex;
  courses: CourseVertex;
  generations: GenerationVertex;
  groups: GroupVertex;
  locations: LocationVertex;
  lockedTimes: LockedTimeVertex;
  linkedEventsSets: LinkedEventsSetVertex;
  periods: PeriodVertex;
  persons: PersonVertex;
  students: PersonVertex;
  rootIntervals: RootIntervalVertex;
  syllabuses: SyllabusVertex;
  configurations: ConfigurationVertex;
  companies: CompanyVertex;
  users: UserVertex;
  threads: ThreadVertex;
  conversations: ConversationVertex;
  messages: MessageVertex;
};
type BaseQueryRecord<C extends keyof VertexRecord> = VertexQuery$1<VertexRecord[C]>;
/**
 * See {@link createVertexQuery}
 */
declare class VertexQuery<C extends keyof VertexRecord, Q extends BaseQueryRecord<C> & AssertNoInvalidExpandKeys<VertexRecord[C], Q>> {
  private readonly _collection;
  private readonly _query;
  constructor(_collection: C, _query: Q);
  get collection(): C;
  get query(): Q;
}
/**
 * Infers the result type for a query created via createVertexQuery.
 *
 * @example
 * const personQuery = createVertexQuery('persons', { select: ['id', 'firstName'] });
 * type PersonType = Infer<typeof personQuery>;
 */
type Infer<T extends VertexQuery<any, any>> = T extends VertexQuery<infer C, infer Q> ? CustomVertexExport<VertexRecord[C], Q> : never;
/**
 * Builds a typed vertex query for a given vertex type using a select/expand shape.
 *
 * Use together with Infer<T> to obtain the serialized result type.
 *
 * @typeParam Q - The select/expand query shape for that vertex.
 *
 * @example
 * const groupQuery = createVertexQuery.group({
 *   select: ['id', 'displayName'],
 *   expand: { members: { select: ['id'] } }
 * });
 * type GroupType = Infer<typeof groupQuery>;
 */
declare namespace createVertexQuery {
  function division<Q extends VertexQuery$1<DivisionVertex> & AssertNoInvalidExpandKeys<DivisionVertex, Q>>(query: Q): VertexQuery<"divisions", Q>;
  function settings<Q extends VertexQuery$1<DivisionSettingsVertex> & AssertNoInvalidExpandKeys<DivisionSettingsVertex, Q>>(query: Q): VertexQuery<"settings", Q>;
  function exception<Q extends VertexQuery$1<ExceptionVertex> & AssertNoInvalidExpandKeys<ExceptionVertex, Q>>(query: Q): VertexQuery<"exceptions", Q>;
  function event<Q extends VertexQuery$1<EventVertex> & AssertNoInvalidExpandKeys<EventVertex, Q>>(query: Q): VertexQuery<"events", Q>;
  function scheduleEvent<Q extends VertexQuery$1<ScheduleEventVertex> & AssertNoInvalidExpandKeys<ScheduleEventVertex, Q>>(query: Q): VertexQuery<"scheduleEvents", Q>;
  function calendarEvent<Q extends VertexQuery$1<CalendarEventVertex> & AssertNoInvalidExpandKeys<CalendarEventVertex, Q>>(query: Q): VertexQuery<"calendarEvents", Q>;
  function course<Q extends VertexQuery$1<CourseVertex> & AssertNoInvalidExpandKeys<CourseVertex, Q>>(query: Q): VertexQuery<"courses", Q>;
  function generation<Q extends VertexQuery$1<GenerationVertex> & AssertNoInvalidExpandKeys<GenerationVertex, Q>>(query: Q): VertexQuery<"generations", Q>;
  function location<Q extends VertexQuery$1<LocationVertex> & AssertNoInvalidExpandKeys<LocationVertex, Q>>(query: Q): VertexQuery<"locations", Q>;
  function lockedTime<Q extends VertexQuery$1<LockedTimeVertex> & AssertNoInvalidExpandKeys<LockedTimeVertex, Q>>(query: Q): VertexQuery<"lockedTimes", Q>;
  function linkedEventsSet<Q extends VertexQuery$1<LinkedEventsSetVertex> & AssertNoInvalidExpandKeys<LinkedEventsSetVertex, Q>>(query: Q): VertexQuery<"linkedEventsSets", Q>;
  function period<Q extends VertexQuery$1<PeriodVertex> & AssertNoInvalidExpandKeys<PeriodVertex, Q>>(query: Q): VertexQuery<"periods", Q>;
  function person<Q extends VertexQuery$1<PersonVertex> & AssertNoInvalidExpandKeys<PersonVertex, Q>>(query: Q): VertexQuery<"persons", Q>;
  function student<Q extends VertexQuery$1<PersonVertex> & AssertNoInvalidExpandKeys<PersonVertex, Q>>(query: Q): VertexQuery<"students", Q>;
  function rootInterval<Q extends VertexQuery$1<RootIntervalVertex> & AssertNoInvalidExpandKeys<RootIntervalVertex, Q>>(query: Q): VertexQuery<"rootIntervals", Q>;
  function syllabus<Q extends VertexQuery$1<SyllabusVertex> & AssertNoInvalidExpandKeys<SyllabusVertex, Q>>(query: Q): VertexQuery<"syllabuses", Q>;
  function group<Q extends VertexQuery$1<GroupVertex> & AssertNoInvalidExpandKeys<GroupVertex, Q>>(query: Q): VertexQuery<"groups", Q>;
  function teacher<Q extends VertexQuery$1<TeacherVertex> & AssertNoInvalidExpandKeys<TeacherVertex, Q>>(query: Q): VertexQuery<"teachers", Q>;
  function configuration<Q extends VertexQuery$1<ConfigurationVertex> & AssertNoInvalidExpandKeys<ConfigurationVertex, Q>>(query: Q): VertexQuery<"configurations", Q>;
  function thread<Q extends VertexQuery$1<ThreadVertex> & AssertNoInvalidExpandKeys<ThreadVertex, Q>>(query: Q): VertexQuery<"threads", Q>;
  function user<Q extends VertexQuery$1<UserVertex> & AssertNoInvalidExpandKeys<UserVertex, Q>>(query: Q): VertexQuery<"users", Q>;
  function conversation<Q extends VertexQuery$1<ConversationVertex> & AssertNoInvalidExpandKeys<ConversationVertex, Q>>(query: Q): VertexQuery<"conversations", Q>;
  function message<Q extends VertexQuery$1<MessageVertex> & AssertNoInvalidExpandKeys<MessageVertex, Q>>(query: Q): VertexQuery<"messages", Q>;
}
//#endregion
export { Infer, VertexQuery, createVertexQuery };
//# sourceMappingURL=vertex-query.d.ts.map