AutoMate/backend/database/generated/prisma-client/index.d.ts

// Code generated by Prisma (prisma@1.30.1). DO NOT EDIT.
// Please don't change this file manually but run `prisma generate` to update it.
// For more information, please read the docs: https://www.prisma.io/docs/prisma-client/

import { DocumentNode } from "graphql";
import {
  makePrismaClientClass,
  BaseClientOptions,
  Model
} from "prisma-client-lib";
import { typeDefs } from "./prisma-schema";

export type AtLeastOne<T, U = { [K in keyof T]: Pick<T, K> }> = Partial<T> &
  U[keyof U];

export interface Exists {
  characterization: (where?: CharacterizationWhereInput) => Promise<boolean>;
  comment: (where?: CommentWhereInput) => Promise<boolean>;
  dUT: (where?: DUTWhereInput) => Promise<boolean>;
  event: (where?: EventWhereInput) => Promise<boolean>;
  file: (where?: FileWhereInput) => Promise<boolean>;
  instrument: (where?: InstrumentWhereInput) => Promise<boolean>;
  instrumentCommand: (where?: InstrumentCommandWhereInput) => Promise<boolean>;
  instrumentInstance: (
    where?: InstrumentInstanceWhereInput
  ) => Promise<boolean>;
  instrumentParameter: (
    where?: InstrumentParameterWhereInput
  ) => Promise<boolean>;
  instrumentSubsystem: (
    where?: InstrumentSubsystemWhereInput
  ) => Promise<boolean>;
  measurement: (where?: MeasurementWhereInput) => Promise<boolean>;
  measurementRun: (where?: MeasurementRunWhereInput) => Promise<boolean>;
  meta: (where?: MetaWhereInput) => Promise<boolean>;
  project: (where?: ProjectWhereInput) => Promise<boolean>;
  projectVersion: (where?: ProjectVersionWhereInput) => Promise<boolean>;
  setup: (where?: SetupWhereInput) => Promise<boolean>;
  setupHardware: (where?: SetupHardwareWhereInput) => Promise<boolean>;
  setupHardwareInstance: (
    where?: SetupHardwareInstanceWhereInput
  ) => Promise<boolean>;
  user: (where?: UserWhereInput) => Promise<boolean>;
}

export interface Node {}

export type FragmentableArray<T> = Promise<Array<T>> & Fragmentable;

export interface Fragmentable {
  $fragment<T>(fragment: string | DocumentNode): Promise<T>;
}

export interface Prisma {
  $exists: Exists;
  $graphql: <T = any>(
    query: string,
    variables?: { [key: string]: any }
  ) => Promise<T>;

  /**
   * Queries
   */

  characterization: (
    where: CharacterizationWhereUniqueInput
  ) => CharacterizationPromise;
  characterizations: (
    args?: {
      where?: CharacterizationWhereInput;
      orderBy?: CharacterizationOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<Characterization>;
  characterizationsConnection: (
    args?: {
      where?: CharacterizationWhereInput;
      orderBy?: CharacterizationOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => CharacterizationConnectionPromise;
  comment: (where: CommentWhereUniqueInput) => CommentPromise;
  comments: (
    args?: {
      where?: CommentWhereInput;
      orderBy?: CommentOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<Comment>;
  commentsConnection: (
    args?: {
      where?: CommentWhereInput;
      orderBy?: CommentOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => CommentConnectionPromise;
  dUT: (where: DUTWhereUniqueInput) => DUTPromise;
  dUTs: (
    args?: {
      where?: DUTWhereInput;
      orderBy?: DUTOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<DUT>;
  dUTsConnection: (
    args?: {
      where?: DUTWhereInput;
      orderBy?: DUTOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => DUTConnectionPromise;
  event: (where: EventWhereUniqueInput) => EventPromise;
  events: (
    args?: {
      where?: EventWhereInput;
      orderBy?: EventOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<Event>;
  eventsConnection: (
    args?: {
      where?: EventWhereInput;
      orderBy?: EventOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => EventConnectionPromise;
  file: (where: FileWhereUniqueInput) => FilePromise;
  files: (
    args?: {
      where?: FileWhereInput;
      orderBy?: FileOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<File>;
  filesConnection: (
    args?: {
      where?: FileWhereInput;
      orderBy?: FileOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FileConnectionPromise;
  instrument: (where: InstrumentWhereUniqueInput) => InstrumentPromise;
  instruments: (
    args?: {
      where?: InstrumentWhereInput;
      orderBy?: InstrumentOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<Instrument>;
  instrumentsConnection: (
    args?: {
      where?: InstrumentWhereInput;
      orderBy?: InstrumentOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => InstrumentConnectionPromise;
  instrumentCommand: (
    where: InstrumentCommandWhereUniqueInput
  ) => InstrumentCommandPromise;
  instrumentCommands: (
    args?: {
      where?: InstrumentCommandWhereInput;
      orderBy?: InstrumentCommandOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<InstrumentCommand>;
  instrumentCommandsConnection: (
    args?: {
      where?: InstrumentCommandWhereInput;
      orderBy?: InstrumentCommandOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => InstrumentCommandConnectionPromise;
  instrumentInstance: (
    where: InstrumentInstanceWhereUniqueInput
  ) => InstrumentInstancePromise;
  instrumentInstances: (
    args?: {
      where?: InstrumentInstanceWhereInput;
      orderBy?: InstrumentInstanceOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<InstrumentInstance>;
  instrumentInstancesConnection: (
    args?: {
      where?: InstrumentInstanceWhereInput;
      orderBy?: InstrumentInstanceOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => InstrumentInstanceConnectionPromise;
  instrumentParameter: (
    where: InstrumentParameterWhereUniqueInput
  ) => InstrumentParameterPromise;
  instrumentParameters: (
    args?: {
      where?: InstrumentParameterWhereInput;
      orderBy?: InstrumentParameterOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<InstrumentParameter>;
  instrumentParametersConnection: (
    args?: {
      where?: InstrumentParameterWhereInput;
      orderBy?: InstrumentParameterOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => InstrumentParameterConnectionPromise;
  instrumentSubsystem: (
    where: InstrumentSubsystemWhereUniqueInput
  ) => InstrumentSubsystemPromise;
  instrumentSubsystems: (
    args?: {
      where?: InstrumentSubsystemWhereInput;
      orderBy?: InstrumentSubsystemOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<InstrumentSubsystem>;
  instrumentSubsystemsConnection: (
    args?: {
      where?: InstrumentSubsystemWhereInput;
      orderBy?: InstrumentSubsystemOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => InstrumentSubsystemConnectionPromise;
  measurement: (where: MeasurementWhereUniqueInput) => MeasurementPromise;
  measurements: (
    args?: {
      where?: MeasurementWhereInput;
      orderBy?: MeasurementOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<Measurement>;
  measurementsConnection: (
    args?: {
      where?: MeasurementWhereInput;
      orderBy?: MeasurementOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => MeasurementConnectionPromise;
  measurementRun: (
    where: MeasurementRunWhereUniqueInput
  ) => MeasurementRunPromise;
  measurementRuns: (
    args?: {
      where?: MeasurementRunWhereInput;
      orderBy?: MeasurementRunOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<MeasurementRun>;
  measurementRunsConnection: (
    args?: {
      where?: MeasurementRunWhereInput;
      orderBy?: MeasurementRunOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => MeasurementRunConnectionPromise;
  meta: (where: MetaWhereUniqueInput) => MetaPromise;
  metas: (
    args?: {
      where?: MetaWhereInput;
      orderBy?: MetaOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<Meta>;
  metasConnection: (
    args?: {
      where?: MetaWhereInput;
      orderBy?: MetaOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => MetaConnectionPromise;
  project: (where: ProjectWhereUniqueInput) => ProjectPromise;
  projects: (
    args?: {
      where?: ProjectWhereInput;
      orderBy?: ProjectOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<Project>;
  projectsConnection: (
    args?: {
      where?: ProjectWhereInput;
      orderBy?: ProjectOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => ProjectConnectionPromise;
  projectVersion: (
    where: ProjectVersionWhereUniqueInput
  ) => ProjectVersionPromise;
  projectVersions: (
    args?: {
      where?: ProjectVersionWhereInput;
      orderBy?: ProjectVersionOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<ProjectVersion>;
  projectVersionsConnection: (
    args?: {
      where?: ProjectVersionWhereInput;
      orderBy?: ProjectVersionOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => ProjectVersionConnectionPromise;
  setup: (where: SetupWhereUniqueInput) => SetupPromise;
  setups: (
    args?: {
      where?: SetupWhereInput;
      orderBy?: SetupOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<Setup>;
  setupsConnection: (
    args?: {
      where?: SetupWhereInput;
      orderBy?: SetupOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => SetupConnectionPromise;
  setupHardware: (where: SetupHardwareWhereUniqueInput) => SetupHardwarePromise;
  setupHardwares: (
    args?: {
      where?: SetupHardwareWhereInput;
      orderBy?: SetupHardwareOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<SetupHardware>;
  setupHardwaresConnection: (
    args?: {
      where?: SetupHardwareWhereInput;
      orderBy?: SetupHardwareOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => SetupHardwareConnectionPromise;
  setupHardwareInstance: (
    where: SetupHardwareInstanceWhereUniqueInput
  ) => SetupHardwareInstancePromise;
  setupHardwareInstances: (
    args?: {
      where?: SetupHardwareInstanceWhereInput;
      orderBy?: SetupHardwareInstanceOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<SetupHardwareInstance>;
  setupHardwareInstancesConnection: (
    args?: {
      where?: SetupHardwareInstanceWhereInput;
      orderBy?: SetupHardwareInstanceOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => SetupHardwareInstanceConnectionPromise;
  user: (where: UserWhereUniqueInput) => UserPromise;
  users: (
    args?: {
      where?: UserWhereInput;
      orderBy?: UserOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => FragmentableArray<User>;
  usersConnection: (
    args?: {
      where?: UserWhereInput;
      orderBy?: UserOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => UserConnectionPromise;
  node: (args: { id: ID_Output }) => Node;

  /**
   * Mutations
   */

  createCharacterization: (
    data: CharacterizationCreateInput
  ) => CharacterizationPromise;
  updateCharacterization: (
    args: {
      data: CharacterizationUpdateInput;
      where: CharacterizationWhereUniqueInput;
    }
  ) => CharacterizationPromise;
  updateManyCharacterizations: (
    args: {
      data: CharacterizationUpdateManyMutationInput;
      where?: CharacterizationWhereInput;
    }
  ) => BatchPayloadPromise;
  upsertCharacterization: (
    args: {
      where: CharacterizationWhereUniqueInput;
      create: CharacterizationCreateInput;
      update: CharacterizationUpdateInput;
    }
  ) => CharacterizationPromise;
  deleteCharacterization: (
    where: CharacterizationWhereUniqueInput
  ) => CharacterizationPromise;
  deleteManyCharacterizations: (
    where?: CharacterizationWhereInput
  ) => BatchPayloadPromise;
  createComment: (data: CommentCreateInput) => CommentPromise;
  updateComment: (
    args: { data: CommentUpdateInput; where: CommentWhereUniqueInput }
  ) => CommentPromise;
  updateManyComments: (
    args: { data: CommentUpdateManyMutationInput; where?: CommentWhereInput }
  ) => BatchPayloadPromise;
  upsertComment: (
    args: {
      where: CommentWhereUniqueInput;
      create: CommentCreateInput;
      update: CommentUpdateInput;
    }
  ) => CommentPromise;
  deleteComment: (where: CommentWhereUniqueInput) => CommentPromise;
  deleteManyComments: (where?: CommentWhereInput) => BatchPayloadPromise;
  createDUT: (data: DUTCreateInput) => DUTPromise;
  updateDUT: (
    args: { data: DUTUpdateInput; where: DUTWhereUniqueInput }
  ) => DUTPromise;
  updateManyDUTs: (
    args: { data: DUTUpdateManyMutationInput; where?: DUTWhereInput }
  ) => BatchPayloadPromise;
  upsertDUT: (
    args: {
      where: DUTWhereUniqueInput;
      create: DUTCreateInput;
      update: DUTUpdateInput;
    }
  ) => DUTPromise;
  deleteDUT: (where: DUTWhereUniqueInput) => DUTPromise;
  deleteManyDUTs: (where?: DUTWhereInput) => BatchPayloadPromise;
  createEvent: (data: EventCreateInput) => EventPromise;
  updateEvent: (
    args: { data: EventUpdateInput; where: EventWhereUniqueInput }
  ) => EventPromise;
  updateManyEvents: (
    args: { data: EventUpdateManyMutationInput; where?: EventWhereInput }
  ) => BatchPayloadPromise;
  upsertEvent: (
    args: {
      where: EventWhereUniqueInput;
      create: EventCreateInput;
      update: EventUpdateInput;
    }
  ) => EventPromise;
  deleteEvent: (where: EventWhereUniqueInput) => EventPromise;
  deleteManyEvents: (where?: EventWhereInput) => BatchPayloadPromise;
  createFile: (data: FileCreateInput) => FilePromise;
  updateFile: (
    args: { data: FileUpdateInput; where: FileWhereUniqueInput }
  ) => FilePromise;
  updateManyFiles: (
    args: { data: FileUpdateManyMutationInput; where?: FileWhereInput }
  ) => BatchPayloadPromise;
  upsertFile: (
    args: {
      where: FileWhereUniqueInput;
      create: FileCreateInput;
      update: FileUpdateInput;
    }
  ) => FilePromise;
  deleteFile: (where: FileWhereUniqueInput) => FilePromise;
  deleteManyFiles: (where?: FileWhereInput) => BatchPayloadPromise;
  createInstrument: (data: InstrumentCreateInput) => InstrumentPromise;
  updateInstrument: (
    args: { data: InstrumentUpdateInput; where: InstrumentWhereUniqueInput }
  ) => InstrumentPromise;
  updateManyInstruments: (
    args: {
      data: InstrumentUpdateManyMutationInput;
      where?: InstrumentWhereInput;
    }
  ) => BatchPayloadPromise;
  upsertInstrument: (
    args: {
      where: InstrumentWhereUniqueInput;
      create: InstrumentCreateInput;
      update: InstrumentUpdateInput;
    }
  ) => InstrumentPromise;
  deleteInstrument: (where: InstrumentWhereUniqueInput) => InstrumentPromise;
  deleteManyInstruments: (where?: InstrumentWhereInput) => BatchPayloadPromise;
  createInstrumentCommand: (
    data: InstrumentCommandCreateInput
  ) => InstrumentCommandPromise;
  updateInstrumentCommand: (
    args: {
      data: InstrumentCommandUpdateInput;
      where: InstrumentCommandWhereUniqueInput;
    }
  ) => InstrumentCommandPromise;
  updateManyInstrumentCommands: (
    args: {
      data: InstrumentCommandUpdateManyMutationInput;
      where?: InstrumentCommandWhereInput;
    }
  ) => BatchPayloadPromise;
  upsertInstrumentCommand: (
    args: {
      where: InstrumentCommandWhereUniqueInput;
      create: InstrumentCommandCreateInput;
      update: InstrumentCommandUpdateInput;
    }
  ) => InstrumentCommandPromise;
  deleteInstrumentCommand: (
    where: InstrumentCommandWhereUniqueInput
  ) => InstrumentCommandPromise;
  deleteManyInstrumentCommands: (
    where?: InstrumentCommandWhereInput
  ) => BatchPayloadPromise;
  createInstrumentInstance: (
    data: InstrumentInstanceCreateInput
  ) => InstrumentInstancePromise;
  updateInstrumentInstance: (
    args: {
      data: InstrumentInstanceUpdateInput;
      where: InstrumentInstanceWhereUniqueInput;
    }
  ) => InstrumentInstancePromise;
  updateManyInstrumentInstances: (
    args: {
      data: InstrumentInstanceUpdateManyMutationInput;
      where?: InstrumentInstanceWhereInput;
    }
  ) => BatchPayloadPromise;
  upsertInstrumentInstance: (
    args: {
      where: InstrumentInstanceWhereUniqueInput;
      create: InstrumentInstanceCreateInput;
      update: InstrumentInstanceUpdateInput;
    }
  ) => InstrumentInstancePromise;
  deleteInstrumentInstance: (
    where: InstrumentInstanceWhereUniqueInput
  ) => InstrumentInstancePromise;
  deleteManyInstrumentInstances: (
    where?: InstrumentInstanceWhereInput
  ) => BatchPayloadPromise;
  createInstrumentParameter: (
    data: InstrumentParameterCreateInput
  ) => InstrumentParameterPromise;
  updateInstrumentParameter: (
    args: {
      data: InstrumentParameterUpdateInput;
      where: InstrumentParameterWhereUniqueInput;
    }
  ) => InstrumentParameterPromise;
  updateManyInstrumentParameters: (
    args: {
      data: InstrumentParameterUpdateManyMutationInput;
      where?: InstrumentParameterWhereInput;
    }
  ) => BatchPayloadPromise;
  upsertInstrumentParameter: (
    args: {
      where: InstrumentParameterWhereUniqueInput;
      create: InstrumentParameterCreateInput;
      update: InstrumentParameterUpdateInput;
    }
  ) => InstrumentParameterPromise;
  deleteInstrumentParameter: (
    where: InstrumentParameterWhereUniqueInput
  ) => InstrumentParameterPromise;
  deleteManyInstrumentParameters: (
    where?: InstrumentParameterWhereInput
  ) => BatchPayloadPromise;
  createInstrumentSubsystem: (
    data: InstrumentSubsystemCreateInput
  ) => InstrumentSubsystemPromise;
  updateInstrumentSubsystem: (
    args: {
      data: InstrumentSubsystemUpdateInput;
      where: InstrumentSubsystemWhereUniqueInput;
    }
  ) => InstrumentSubsystemPromise;
  updateManyInstrumentSubsystems: (
    args: {
      data: InstrumentSubsystemUpdateManyMutationInput;
      where?: InstrumentSubsystemWhereInput;
    }
  ) => BatchPayloadPromise;
  upsertInstrumentSubsystem: (
    args: {
      where: InstrumentSubsystemWhereUniqueInput;
      create: InstrumentSubsystemCreateInput;
      update: InstrumentSubsystemUpdateInput;
    }
  ) => InstrumentSubsystemPromise;
  deleteInstrumentSubsystem: (
    where: InstrumentSubsystemWhereUniqueInput
  ) => InstrumentSubsystemPromise;
  deleteManyInstrumentSubsystems: (
    where?: InstrumentSubsystemWhereInput
  ) => BatchPayloadPromise;
  createMeasurement: (data: MeasurementCreateInput) => MeasurementPromise;
  updateMeasurement: (
    args: { data: MeasurementUpdateInput; where: MeasurementWhereUniqueInput }
  ) => MeasurementPromise;
  updateManyMeasurements: (
    args: {
      data: MeasurementUpdateManyMutationInput;
      where?: MeasurementWhereInput;
    }
  ) => BatchPayloadPromise;
  upsertMeasurement: (
    args: {
      where: MeasurementWhereUniqueInput;
      create: MeasurementCreateInput;
      update: MeasurementUpdateInput;
    }
  ) => MeasurementPromise;
  deleteMeasurement: (where: MeasurementWhereUniqueInput) => MeasurementPromise;
  deleteManyMeasurements: (
    where?: MeasurementWhereInput
  ) => BatchPayloadPromise;
  createMeasurementRun: (
    data: MeasurementRunCreateInput
  ) => MeasurementRunPromise;
  updateMeasurementRun: (
    args: {
      data: MeasurementRunUpdateInput;
      where: MeasurementRunWhereUniqueInput;
    }
  ) => MeasurementRunPromise;
  updateManyMeasurementRuns: (
    args: {
      data: MeasurementRunUpdateManyMutationInput;
      where?: MeasurementRunWhereInput;
    }
  ) => BatchPayloadPromise;
  upsertMeasurementRun: (
    args: {
      where: MeasurementRunWhereUniqueInput;
      create: MeasurementRunCreateInput;
      update: MeasurementRunUpdateInput;
    }
  ) => MeasurementRunPromise;
  deleteMeasurementRun: (
    where: MeasurementRunWhereUniqueInput
  ) => MeasurementRunPromise;
  deleteManyMeasurementRuns: (
    where?: MeasurementRunWhereInput
  ) => BatchPayloadPromise;
  createMeta: (data: MetaCreateInput) => MetaPromise;
  updateMeta: (
    args: { data: MetaUpdateInput; where: MetaWhereUniqueInput }
  ) => MetaPromise;
  updateManyMetas: (
    args: { data: MetaUpdateManyMutationInput; where?: MetaWhereInput }
  ) => BatchPayloadPromise;
  upsertMeta: (
    args: {
      where: MetaWhereUniqueInput;
      create: MetaCreateInput;
      update: MetaUpdateInput;
    }
  ) => MetaPromise;
  deleteMeta: (where: MetaWhereUniqueInput) => MetaPromise;
  deleteManyMetas: (where?: MetaWhereInput) => BatchPayloadPromise;
  createProject: (data: ProjectCreateInput) => ProjectPromise;
  updateProject: (
    args: { data: ProjectUpdateInput; where: ProjectWhereUniqueInput }
  ) => ProjectPromise;
  updateManyProjects: (
    args: { data: ProjectUpdateManyMutationInput; where?: ProjectWhereInput }
  ) => BatchPayloadPromise;
  upsertProject: (
    args: {
      where: ProjectWhereUniqueInput;
      create: ProjectCreateInput;
      update: ProjectUpdateInput;
    }
  ) => ProjectPromise;
  deleteProject: (where: ProjectWhereUniqueInput) => ProjectPromise;
  deleteManyProjects: (where?: ProjectWhereInput) => BatchPayloadPromise;
  createProjectVersion: (
    data: ProjectVersionCreateInput
  ) => ProjectVersionPromise;
  updateProjectVersion: (
    args: {
      data: ProjectVersionUpdateInput;
      where: ProjectVersionWhereUniqueInput;
    }
  ) => ProjectVersionPromise;
  updateManyProjectVersions: (
    args: {
      data: ProjectVersionUpdateManyMutationInput;
      where?: ProjectVersionWhereInput;
    }
  ) => BatchPayloadPromise;
  upsertProjectVersion: (
    args: {
      where: ProjectVersionWhereUniqueInput;
      create: ProjectVersionCreateInput;
      update: ProjectVersionUpdateInput;
    }
  ) => ProjectVersionPromise;
  deleteProjectVersion: (
    where: ProjectVersionWhereUniqueInput
  ) => ProjectVersionPromise;
  deleteManyProjectVersions: (
    where?: ProjectVersionWhereInput
  ) => BatchPayloadPromise;
  createSetup: (data: SetupCreateInput) => SetupPromise;
  updateSetup: (
    args: { data: SetupUpdateInput; where: SetupWhereUniqueInput }
  ) => SetupPromise;
  updateManySetups: (
    args: { data: SetupUpdateManyMutationInput; where?: SetupWhereInput }
  ) => BatchPayloadPromise;
  upsertSetup: (
    args: {
      where: SetupWhereUniqueInput;
      create: SetupCreateInput;
      update: SetupUpdateInput;
    }
  ) => SetupPromise;
  deleteSetup: (where: SetupWhereUniqueInput) => SetupPromise;
  deleteManySetups: (where?: SetupWhereInput) => BatchPayloadPromise;
  createSetupHardware: (data: SetupHardwareCreateInput) => SetupHardwarePromise;
  updateSetupHardware: (
    args: {
      data: SetupHardwareUpdateInput;
      where: SetupHardwareWhereUniqueInput;
    }
  ) => SetupHardwarePromise;
  updateManySetupHardwares: (
    args: {
      data: SetupHardwareUpdateManyMutationInput;
      where?: SetupHardwareWhereInput;
    }
  ) => BatchPayloadPromise;
  upsertSetupHardware: (
    args: {
      where: SetupHardwareWhereUniqueInput;
      create: SetupHardwareCreateInput;
      update: SetupHardwareUpdateInput;
    }
  ) => SetupHardwarePromise;
  deleteSetupHardware: (
    where: SetupHardwareWhereUniqueInput
  ) => SetupHardwarePromise;
  deleteManySetupHardwares: (
    where?: SetupHardwareWhereInput
  ) => BatchPayloadPromise;
  createSetupHardwareInstance: (
    data: SetupHardwareInstanceCreateInput
  ) => SetupHardwareInstancePromise;
  updateSetupHardwareInstance: (
    args: {
      data: SetupHardwareInstanceUpdateInput;
      where: SetupHardwareInstanceWhereUniqueInput;
    }
  ) => SetupHardwareInstancePromise;
  updateManySetupHardwareInstances: (
    args: {
      data: SetupHardwareInstanceUpdateManyMutationInput;
      where?: SetupHardwareInstanceWhereInput;
    }
  ) => BatchPayloadPromise;
  upsertSetupHardwareInstance: (
    args: {
      where: SetupHardwareInstanceWhereUniqueInput;
      create: SetupHardwareInstanceCreateInput;
      update: SetupHardwareInstanceUpdateInput;
    }
  ) => SetupHardwareInstancePromise;
  deleteSetupHardwareInstance: (
    where: SetupHardwareInstanceWhereUniqueInput
  ) => SetupHardwareInstancePromise;
  deleteManySetupHardwareInstances: (
    where?: SetupHardwareInstanceWhereInput
  ) => BatchPayloadPromise;
  createUser: (data: UserCreateInput) => UserPromise;
  updateUser: (
    args: { data: UserUpdateInput; where: UserWhereUniqueInput }
  ) => UserPromise;
  updateManyUsers: (
    args: { data: UserUpdateManyMutationInput; where?: UserWhereInput }
  ) => BatchPayloadPromise;
  upsertUser: (
    args: {
      where: UserWhereUniqueInput;
      create: UserCreateInput;
      update: UserUpdateInput;
    }
  ) => UserPromise;
  deleteUser: (where: UserWhereUniqueInput) => UserPromise;
  deleteManyUsers: (where?: UserWhereInput) => BatchPayloadPromise;

  /**
   * Subscriptions
   */

  $subscribe: Subscription;
}

export interface Subscription {
  characterization: (
    where?: CharacterizationSubscriptionWhereInput
  ) => CharacterizationSubscriptionPayloadSubscription;
  comment: (
    where?: CommentSubscriptionWhereInput
  ) => CommentSubscriptionPayloadSubscription;
  dUT: (
    where?: DUTSubscriptionWhereInput
  ) => DUTSubscriptionPayloadSubscription;
  event: (
    where?: EventSubscriptionWhereInput
  ) => EventSubscriptionPayloadSubscription;
  file: (
    where?: FileSubscriptionWhereInput
  ) => FileSubscriptionPayloadSubscription;
  instrument: (
    where?: InstrumentSubscriptionWhereInput
  ) => InstrumentSubscriptionPayloadSubscription;
  instrumentCommand: (
    where?: InstrumentCommandSubscriptionWhereInput
  ) => InstrumentCommandSubscriptionPayloadSubscription;
  instrumentInstance: (
    where?: InstrumentInstanceSubscriptionWhereInput
  ) => InstrumentInstanceSubscriptionPayloadSubscription;
  instrumentParameter: (
    where?: InstrumentParameterSubscriptionWhereInput
  ) => InstrumentParameterSubscriptionPayloadSubscription;
  instrumentSubsystem: (
    where?: InstrumentSubsystemSubscriptionWhereInput
  ) => InstrumentSubsystemSubscriptionPayloadSubscription;
  measurement: (
    where?: MeasurementSubscriptionWhereInput
  ) => MeasurementSubscriptionPayloadSubscription;
  measurementRun: (
    where?: MeasurementRunSubscriptionWhereInput
  ) => MeasurementRunSubscriptionPayloadSubscription;
  meta: (
    where?: MetaSubscriptionWhereInput
  ) => MetaSubscriptionPayloadSubscription;
  project: (
    where?: ProjectSubscriptionWhereInput
  ) => ProjectSubscriptionPayloadSubscription;
  projectVersion: (
    where?: ProjectVersionSubscriptionWhereInput
  ) => ProjectVersionSubscriptionPayloadSubscription;
  setup: (
    where?: SetupSubscriptionWhereInput
  ) => SetupSubscriptionPayloadSubscription;
  setupHardware: (
    where?: SetupHardwareSubscriptionWhereInput
  ) => SetupHardwareSubscriptionPayloadSubscription;
  setupHardwareInstance: (
    where?: SetupHardwareInstanceSubscriptionWhereInput
  ) => SetupHardwareInstanceSubscriptionPayloadSubscription;
  user: (
    where?: UserSubscriptionWhereInput
  ) => UserSubscriptionPayloadSubscription;
}

export interface ClientConstructor<T> {
  new (options?: BaseClientOptions): T;
}

/**
 * Types
 */

export type FileOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "path_ASC"
  | "path_DESC"
  | "name_ASC"
  | "name_DESC"
  | "description_ASC"
  | "description_DESC"
  | "filename_ASC"
  | "filename_DESC"
  | "mimetype_ASC"
  | "mimetype_DESC"
  | "size_ASC"
  | "size_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type ProjectVersionOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "name_ASC"
  | "name_DESC"
  | "date_ASC"
  | "date_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type MeasurementRunOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "name_ASC"
  | "name_DESC"
  | "location_ASC"
  | "location_DESC"
  | "temperature_ASC"
  | "temperature_DESC"
  | "startTime_ASC"
  | "startTime_DESC"
  | "endTime_ASC"
  | "endTime_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type UserOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "email_ASC"
  | "email_DESC"
  | "name_ASC"
  | "name_DESC"
  | "abbreviation_ASC"
  | "abbreviation_DESC"
  | "password_ASC"
  | "password_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type EventOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "json_ASC"
  | "json_DESC"
  | "when_ASC"
  | "when_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type CommentOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "text_ASC"
  | "text_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type MeasurementOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "intValue_ASC"
  | "intValue_DESC"
  | "floatValue_ASC"
  | "floatValue_DESC"
  | "stringValue_ASC"
  | "stringValue_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type SetupHardwareInstanceOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "identifier_ASC"
  | "identifier_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type InstrumentInstanceOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "identifier_ASC"
  | "identifier_DESC"
  | "label_ASC"
  | "label_DESC"
  | "location_ASC"
  | "location_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type InstrumentCommandOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "tag_ASC"
  | "tag_DESC"
  | "name_ASC"
  | "name_DESC"
  | "description_ASC"
  | "description_DESC"
  | "readString_ASC"
  | "readString_DESC"
  | "writeString_ASC"
  | "writeString_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type InstrumentParameterOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "tag_ASC"
  | "tag_DESC"
  | "name_ASC"
  | "name_DESC"
  | "description_ASC"
  | "description_DESC"
  | "type_ASC"
  | "type_DESC"
  | "values_ASC"
  | "values_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type InstrumentSubsystemOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "name_ASC"
  | "name_DESC"
  | "description_ASC"
  | "description_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type CharacterizationOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "name_ASC"
  | "name_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type DUTOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "name_ASC"
  | "name_DESC"
  | "description_ASC"
  | "description_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type InstrumentOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "name_ASC"
  | "name_DESC"
  | "description_ASC"
  | "description_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type MetaOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "key_ASC"
  | "key_DESC"
  | "value_ASC"
  | "value_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type ProjectOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "name_ASC"
  | "name_DESC"
  | "abbreviation_ASC"
  | "abbreviation_DESC"
  | "description_ASC"
  | "description_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type SetupOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "name_ASC"
  | "name_DESC"
  | "description_ASC"
  | "description_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type SetupHardwareOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "name_ASC"
  | "name_DESC"
  | "description_ASC"
  | "description_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC";

export type MutationType = "CREATED" | "UPDATED" | "DELETED";

export type CharacterizationWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
}>;

export interface FileWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  path?: String;
  path_not?: String;
  path_in?: String[] | String;
  path_not_in?: String[] | String;
  path_lt?: String;
  path_lte?: String;
  path_gt?: String;
  path_gte?: String;
  path_contains?: String;
  path_not_contains?: String;
  path_starts_with?: String;
  path_not_starts_with?: String;
  path_ends_with?: String;
  path_not_ends_with?: String;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  description?: String;
  description_not?: String;
  description_in?: String[] | String;
  description_not_in?: String[] | String;
  description_lt?: String;
  description_lte?: String;
  description_gt?: String;
  description_gte?: String;
  description_contains?: String;
  description_not_contains?: String;
  description_starts_with?: String;
  description_not_starts_with?: String;
  description_ends_with?: String;
  description_not_ends_with?: String;
  filename?: String;
  filename_not?: String;
  filename_in?: String[] | String;
  filename_not_in?: String[] | String;
  filename_lt?: String;
  filename_lte?: String;
  filename_gt?: String;
  filename_gte?: String;
  filename_contains?: String;
  filename_not_contains?: String;
  filename_starts_with?: String;
  filename_not_starts_with?: String;
  filename_ends_with?: String;
  filename_not_ends_with?: String;
  mimetype?: String;
  mimetype_not?: String;
  mimetype_in?: String[] | String;
  mimetype_not_in?: String[] | String;
  mimetype_lt?: String;
  mimetype_lte?: String;
  mimetype_gt?: String;
  mimetype_gte?: String;
  mimetype_contains?: String;
  mimetype_not_contains?: String;
  mimetype_starts_with?: String;
  mimetype_not_starts_with?: String;
  mimetype_ends_with?: String;
  mimetype_not_ends_with?: String;
  size?: Int;
  size_not?: Int;
  size_in?: Int[] | Int;
  size_not_in?: Int[] | Int;
  size_lt?: Int;
  size_lte?: Int;
  size_gt?: Int;
  size_gte?: Int;
  AND?: FileWhereInput[] | FileWhereInput;
  OR?: FileWhereInput[] | FileWhereInput;
  NOT?: FileWhereInput[] | FileWhereInput;
}

export interface ProjectVersionWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  date?: DateTimeInput;
  date_not?: DateTimeInput;
  date_in?: DateTimeInput[] | DateTimeInput;
  date_not_in?: DateTimeInput[] | DateTimeInput;
  date_lt?: DateTimeInput;
  date_lte?: DateTimeInput;
  date_gt?: DateTimeInput;
  date_gte?: DateTimeInput;
  project?: ProjectWhereInput;
  AND?: ProjectVersionWhereInput[] | ProjectVersionWhereInput;
  OR?: ProjectVersionWhereInput[] | ProjectVersionWhereInput;
  NOT?: ProjectVersionWhereInput[] | ProjectVersionWhereInput;
}

export interface ProjectWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  abbreviation?: String;
  abbreviation_not?: String;
  abbreviation_in?: String[] | String;
  abbreviation_not_in?: String[] | String;
  abbreviation_lt?: String;
  abbreviation_lte?: String;
  abbreviation_gt?: String;
  abbreviation_gte?: String;
  abbreviation_contains?: String;
  abbreviation_not_contains?: String;
  abbreviation_starts_with?: String;
  abbreviation_not_starts_with?: String;
  abbreviation_ends_with?: String;
  abbreviation_not_ends_with?: String;
  description?: String;
  description_not?: String;
  description_in?: String[] | String;
  description_not_in?: String[] | String;
  description_lt?: String;
  description_lte?: String;
  description_gt?: String;
  description_gte?: String;
  description_contains?: String;
  description_not_contains?: String;
  description_starts_with?: String;
  description_not_starts_with?: String;
  description_ends_with?: String;
  description_not_ends_with?: String;
  files_every?: FileWhereInput;
  files_some?: FileWhereInput;
  files_none?: FileWhereInput;
  versions_every?: ProjectVersionWhereInput;
  versions_some?: ProjectVersionWhereInput;
  versions_none?: ProjectVersionWhereInput;
  AND?: ProjectWhereInput[] | ProjectWhereInput;
  OR?: ProjectWhereInput[] | ProjectWhereInput;
  NOT?: ProjectWhereInput[] | ProjectWhereInput;
}

export interface MeasurementRunWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  operators_every?: UserWhereInput;
  operators_some?: UserWhereInput;
  operators_none?: UserWhereInput;
  location?: String;
  location_not?: String;
  location_in?: String[] | String;
  location_not_in?: String[] | String;
  location_lt?: String;
  location_lte?: String;
  location_gt?: String;
  location_gte?: String;
  location_contains?: String;
  location_not_contains?: String;
  location_starts_with?: String;
  location_not_starts_with?: String;
  location_ends_with?: String;
  location_not_ends_with?: String;
  temperature?: Float;
  temperature_not?: Float;
  temperature_in?: Float[] | Float;
  temperature_not_in?: Float[] | Float;
  temperature_lt?: Float;
  temperature_lte?: Float;
  temperature_gt?: Float;
  temperature_gte?: Float;
  startTime?: DateTimeInput;
  startTime_not?: DateTimeInput;
  startTime_in?: DateTimeInput[] | DateTimeInput;
  startTime_not_in?: DateTimeInput[] | DateTimeInput;
  startTime_lt?: DateTimeInput;
  startTime_lte?: DateTimeInput;
  startTime_gt?: DateTimeInput;
  startTime_gte?: DateTimeInput;
  endTime?: DateTimeInput;
  endTime_not?: DateTimeInput;
  endTime_in?: DateTimeInput[] | DateTimeInput;
  endTime_not_in?: DateTimeInput[] | DateTimeInput;
  endTime_lt?: DateTimeInput;
  endTime_lte?: DateTimeInput;
  endTime_gt?: DateTimeInput;
  endTime_gte?: DateTimeInput;
  log_every?: EventWhereInput;
  log_some?: EventWhereInput;
  log_none?: EventWhereInput;
  comments_every?: CommentWhereInput;
  comments_some?: CommentWhereInput;
  comments_none?: CommentWhereInput;
  measurements_every?: MeasurementWhereInput;
  measurements_some?: MeasurementWhereInput;
  measurements_none?: MeasurementWhereInput;
  setup?: SetupWhereInput;
  AND?: MeasurementRunWhereInput[] | MeasurementRunWhereInput;
  OR?: MeasurementRunWhereInput[] | MeasurementRunWhereInput;
  NOT?: MeasurementRunWhereInput[] | MeasurementRunWhereInput;
}

export interface UserWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  email?: String;
  email_not?: String;
  email_in?: String[] | String;
  email_not_in?: String[] | String;
  email_lt?: String;
  email_lte?: String;
  email_gt?: String;
  email_gte?: String;
  email_contains?: String;
  email_not_contains?: String;
  email_starts_with?: String;
  email_not_starts_with?: String;
  email_ends_with?: String;
  email_not_ends_with?: String;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  abbreviation?: String;
  abbreviation_not?: String;
  abbreviation_in?: String[] | String;
  abbreviation_not_in?: String[] | String;
  abbreviation_lt?: String;
  abbreviation_lte?: String;
  abbreviation_gt?: String;
  abbreviation_gte?: String;
  abbreviation_contains?: String;
  abbreviation_not_contains?: String;
  abbreviation_starts_with?: String;
  abbreviation_not_starts_with?: String;
  abbreviation_ends_with?: String;
  abbreviation_not_ends_with?: String;
  password?: String;
  password_not?: String;
  password_in?: String[] | String;
  password_not_in?: String[] | String;
  password_lt?: String;
  password_lte?: String;
  password_gt?: String;
  password_gte?: String;
  password_contains?: String;
  password_not_contains?: String;
  password_starts_with?: String;
  password_not_starts_with?: String;
  password_ends_with?: String;
  password_not_ends_with?: String;
  images_every?: FileWhereInput;
  images_some?: FileWhereInput;
  images_none?: FileWhereInput;
  AND?: UserWhereInput[] | UserWhereInput;
  OR?: UserWhereInput[] | UserWhereInput;
  NOT?: UserWhereInput[] | UserWhereInput;
}

export interface EventWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  json?: String;
  json_not?: String;
  json_in?: String[] | String;
  json_not_in?: String[] | String;
  json_lt?: String;
  json_lte?: String;
  json_gt?: String;
  json_gte?: String;
  json_contains?: String;
  json_not_contains?: String;
  json_starts_with?: String;
  json_not_starts_with?: String;
  json_ends_with?: String;
  json_not_ends_with?: String;
  when?: DateTimeInput;
  when_not?: DateTimeInput;
  when_in?: DateTimeInput[] | DateTimeInput;
  when_not_in?: DateTimeInput[] | DateTimeInput;
  when_lt?: DateTimeInput;
  when_lte?: DateTimeInput;
  when_gt?: DateTimeInput;
  when_gte?: DateTimeInput;
  AND?: EventWhereInput[] | EventWhereInput;
  OR?: EventWhereInput[] | EventWhereInput;
  NOT?: EventWhereInput[] | EventWhereInput;
}

export interface CommentWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  text?: String;
  text_not?: String;
  text_in?: String[] | String;
  text_not_in?: String[] | String;
  text_lt?: String;
  text_lte?: String;
  text_gt?: String;
  text_gte?: String;
  text_contains?: String;
  text_not_contains?: String;
  text_starts_with?: String;
  text_not_starts_with?: String;
  text_ends_with?: String;
  text_not_ends_with?: String;
  createdAt?: DateTimeInput;
  createdAt_not?: DateTimeInput;
  createdAt_in?: DateTimeInput[] | DateTimeInput;
  createdAt_not_in?: DateTimeInput[] | DateTimeInput;
  createdAt_lt?: DateTimeInput;
  createdAt_lte?: DateTimeInput;
  createdAt_gt?: DateTimeInput;
  createdAt_gte?: DateTimeInput;
  previousVersion?: CommentWhereInput;
  AND?: CommentWhereInput[] | CommentWhereInput;
  OR?: CommentWhereInput[] | CommentWhereInput;
  NOT?: CommentWhereInput[] | CommentWhereInput;
}

export interface MeasurementWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  createdAt?: DateTimeInput;
  createdAt_not?: DateTimeInput;
  createdAt_in?: DateTimeInput[] | DateTimeInput;
  createdAt_not_in?: DateTimeInput[] | DateTimeInput;
  createdAt_lt?: DateTimeInput;
  createdAt_lte?: DateTimeInput;
  createdAt_gt?: DateTimeInput;
  createdAt_gte?: DateTimeInput;
  intValue?: Int;
  intValue_not?: Int;
  intValue_in?: Int[] | Int;
  intValue_not_in?: Int[] | Int;
  intValue_lt?: Int;
  intValue_lte?: Int;
  intValue_gt?: Int;
  intValue_gte?: Int;
  floatValue?: Float;
  floatValue_not?: Float;
  floatValue_in?: Float[] | Float;
  floatValue_not_in?: Float[] | Float;
  floatValue_lt?: Float;
  floatValue_lte?: Float;
  floatValue_gt?: Float;
  floatValue_gte?: Float;
  stringValue?: String;
  stringValue_not?: String;
  stringValue_in?: String[] | String;
  stringValue_not_in?: String[] | String;
  stringValue_lt?: String;
  stringValue_lte?: String;
  stringValue_gt?: String;
  stringValue_gte?: String;
  stringValue_contains?: String;
  stringValue_not_contains?: String;
  stringValue_starts_with?: String;
  stringValue_not_starts_with?: String;
  stringValue_ends_with?: String;
  stringValue_not_ends_with?: String;
  AND?: MeasurementWhereInput[] | MeasurementWhereInput;
  OR?: MeasurementWhereInput[] | MeasurementWhereInput;
  NOT?: MeasurementWhereInput[] | MeasurementWhereInput;
}

export interface SetupWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  description?: String;
  description_not?: String;
  description_in?: String[] | String;
  description_not_in?: String[] | String;
  description_lt?: String;
  description_lte?: String;
  description_gt?: String;
  description_gte?: String;
  description_contains?: String;
  description_not_contains?: String;
  description_starts_with?: String;
  description_not_starts_with?: String;
  description_ends_with?: String;
  description_not_ends_with?: String;
  images_every?: FileWhereInput;
  images_some?: FileWhereInput;
  images_none?: FileWhereInput;
  comments_every?: CommentWhereInput;
  comments_some?: CommentWhereInput;
  comments_none?: CommentWhereInput;
  setupHardware_every?: SetupHardwareInstanceWhereInput;
  setupHardware_some?: SetupHardwareInstanceWhereInput;
  setupHardware_none?: SetupHardwareInstanceWhereInput;
  instruments_every?: InstrumentInstanceWhereInput;
  instruments_some?: InstrumentInstanceWhereInput;
  instruments_none?: InstrumentInstanceWhereInput;
  AND?: SetupWhereInput[] | SetupWhereInput;
  OR?: SetupWhereInput[] | SetupWhereInput;
  NOT?: SetupWhereInput[] | SetupWhereInput;
}

export interface SetupHardwareInstanceWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  setupHardware?: SetupHardwareWhereInput;
  identifier?: String;
  identifier_not?: String;
  identifier_in?: String[] | String;
  identifier_not_in?: String[] | String;
  identifier_lt?: String;
  identifier_lte?: String;
  identifier_gt?: String;
  identifier_gte?: String;
  identifier_contains?: String;
  identifier_not_contains?: String;
  identifier_starts_with?: String;
  identifier_not_starts_with?: String;
  identifier_ends_with?: String;
  identifier_not_ends_with?: String;
  images_every?: FileWhereInput;
  images_some?: FileWhereInput;
  images_none?: FileWhereInput;
  AND?: SetupHardwareInstanceWhereInput[] | SetupHardwareInstanceWhereInput;
  OR?: SetupHardwareInstanceWhereInput[] | SetupHardwareInstanceWhereInput;
  NOT?: SetupHardwareInstanceWhereInput[] | SetupHardwareInstanceWhereInput;
}

export interface SetupHardwareWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  description?: String;
  description_not?: String;
  description_in?: String[] | String;
  description_not_in?: String[] | String;
  description_lt?: String;
  description_lte?: String;
  description_gt?: String;
  description_gte?: String;
  description_contains?: String;
  description_not_contains?: String;
  description_starts_with?: String;
  description_not_starts_with?: String;
  description_ends_with?: String;
  description_not_ends_with?: String;
  images_every?: FileWhereInput;
  images_some?: FileWhereInput;
  images_none?: FileWhereInput;
  AND?: SetupHardwareWhereInput[] | SetupHardwareWhereInput;
  OR?: SetupHardwareWhereInput[] | SetupHardwareWhereInput;
  NOT?: SetupHardwareWhereInput[] | SetupHardwareWhereInput;
}

export interface InstrumentInstanceWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  instrument?: InstrumentWhereInput;
  identifier?: String;
  identifier_not?: String;
  identifier_in?: String[] | String;
  identifier_not_in?: String[] | String;
  identifier_lt?: String;
  identifier_lte?: String;
  identifier_gt?: String;
  identifier_gte?: String;
  identifier_contains?: String;
  identifier_not_contains?: String;
  identifier_starts_with?: String;
  identifier_not_starts_with?: String;
  identifier_ends_with?: String;
  identifier_not_ends_with?: String;
  label?: String;
  label_not?: String;
  label_in?: String[] | String;
  label_not_in?: String[] | String;
  label_lt?: String;
  label_lte?: String;
  label_gt?: String;
  label_gte?: String;
  label_contains?: String;
  label_not_contains?: String;
  label_starts_with?: String;
  label_not_starts_with?: String;
  label_ends_with?: String;
  label_not_ends_with?: String;
  location?: String;
  location_not?: String;
  location_in?: String[] | String;
  location_not_in?: String[] | String;
  location_lt?: String;
  location_lte?: String;
  location_gt?: String;
  location_gte?: String;
  location_contains?: String;
  location_not_contains?: String;
  location_starts_with?: String;
  location_not_starts_with?: String;
  location_ends_with?: String;
  location_not_ends_with?: String;
  AND?: InstrumentInstanceWhereInput[] | InstrumentInstanceWhereInput;
  OR?: InstrumentInstanceWhereInput[] | InstrumentInstanceWhereInput;
  NOT?: InstrumentInstanceWhereInput[] | InstrumentInstanceWhereInput;
}

export interface InstrumentWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  description?: String;
  description_not?: String;
  description_in?: String[] | String;
  description_not_in?: String[] | String;
  description_lt?: String;
  description_lte?: String;
  description_gt?: String;
  description_gte?: String;
  description_contains?: String;
  description_not_contains?: String;
  description_starts_with?: String;
  description_not_starts_with?: String;
  description_ends_with?: String;
  description_not_ends_with?: String;
  documents_every?: FileWhereInput;
  documents_some?: FileWhereInput;
  documents_none?: FileWhereInput;
  commands_every?: InstrumentCommandWhereInput;
  commands_some?: InstrumentCommandWhereInput;
  commands_none?: InstrumentCommandWhereInput;
  parameters_every?: InstrumentParameterWhereInput;
  parameters_some?: InstrumentParameterWhereInput;
  parameters_none?: InstrumentParameterWhereInput;
  subsystems_every?: InstrumentSubsystemWhereInput;
  subsystems_some?: InstrumentSubsystemWhereInput;
  subsystems_none?: InstrumentSubsystemWhereInput;
  AND?: InstrumentWhereInput[] | InstrumentWhereInput;
  OR?: InstrumentWhereInput[] | InstrumentWhereInput;
  NOT?: InstrumentWhereInput[] | InstrumentWhereInput;
}

export interface InstrumentCommandWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  tag?: String;
  tag_not?: String;
  tag_in?: String[] | String;
  tag_not_in?: String[] | String;
  tag_lt?: String;
  tag_lte?: String;
  tag_gt?: String;
  tag_gte?: String;
  tag_contains?: String;
  tag_not_contains?: String;
  tag_starts_with?: String;
  tag_not_starts_with?: String;
  tag_ends_with?: String;
  tag_not_ends_with?: String;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  description?: String;
  description_not?: String;
  description_in?: String[] | String;
  description_not_in?: String[] | String;
  description_lt?: String;
  description_lte?: String;
  description_gt?: String;
  description_gte?: String;
  description_contains?: String;
  description_not_contains?: String;
  description_starts_with?: String;
  description_not_starts_with?: String;
  description_ends_with?: String;
  description_not_ends_with?: String;
  instrument?: InstrumentWhereInput;
  readString?: String;
  readString_not?: String;
  readString_in?: String[] | String;
  readString_not_in?: String[] | String;
  readString_lt?: String;
  readString_lte?: String;
  readString_gt?: String;
  readString_gte?: String;
  readString_contains?: String;
  readString_not_contains?: String;
  readString_starts_with?: String;
  readString_not_starts_with?: String;
  readString_ends_with?: String;
  readString_not_ends_with?: String;
  writeString?: String;
  writeString_not?: String;
  writeString_in?: String[] | String;
  writeString_not_in?: String[] | String;
  writeString_lt?: String;
  writeString_lte?: String;
  writeString_gt?: String;
  writeString_gte?: String;
  writeString_contains?: String;
  writeString_not_contains?: String;
  writeString_starts_with?: String;
  writeString_not_starts_with?: String;
  writeString_ends_with?: String;
  writeString_not_ends_with?: String;
  parameters_every?: InstrumentParameterWhereInput;
  parameters_some?: InstrumentParameterWhereInput;
  parameters_none?: InstrumentParameterWhereInput;
  AND?: InstrumentCommandWhereInput[] | InstrumentCommandWhereInput;
  OR?: InstrumentCommandWhereInput[] | InstrumentCommandWhereInput;
  NOT?: InstrumentCommandWhereInput[] | InstrumentCommandWhereInput;
}

export interface InstrumentParameterWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  tag?: String;
  tag_not?: String;
  tag_in?: String[] | String;
  tag_not_in?: String[] | String;
  tag_lt?: String;
  tag_lte?: String;
  tag_gt?: String;
  tag_gte?: String;
  tag_contains?: String;
  tag_not_contains?: String;
  tag_starts_with?: String;
  tag_not_starts_with?: String;
  tag_ends_with?: String;
  tag_not_ends_with?: String;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  description?: String;
  description_not?: String;
  description_in?: String[] | String;
  description_not_in?: String[] | String;
  description_lt?: String;
  description_lte?: String;
  description_gt?: String;
  description_gte?: String;
  description_contains?: String;
  description_not_contains?: String;
  description_starts_with?: String;
  description_not_starts_with?: String;
  description_ends_with?: String;
  description_not_ends_with?: String;
  type?: String;
  type_not?: String;
  type_in?: String[] | String;
  type_not_in?: String[] | String;
  type_lt?: String;
  type_lte?: String;
  type_gt?: String;
  type_gte?: String;
  type_contains?: String;
  type_not_contains?: String;
  type_starts_with?: String;
  type_not_starts_with?: String;
  type_ends_with?: String;
  type_not_ends_with?: String;
  values?: String;
  values_not?: String;
  values_in?: String[] | String;
  values_not_in?: String[] | String;
  values_lt?: String;
  values_lte?: String;
  values_gt?: String;
  values_gte?: String;
  values_contains?: String;
  values_not_contains?: String;
  values_starts_with?: String;
  values_not_starts_with?: String;
  values_ends_with?: String;
  values_not_ends_with?: String;
  AND?: InstrumentParameterWhereInput[] | InstrumentParameterWhereInput;
  OR?: InstrumentParameterWhereInput[] | InstrumentParameterWhereInput;
  NOT?: InstrumentParameterWhereInput[] | InstrumentParameterWhereInput;
}

export interface InstrumentSubsystemWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  description?: String;
  description_not?: String;
  description_in?: String[] | String;
  description_not_in?: String[] | String;
  description_lt?: String;
  description_lte?: String;
  description_gt?: String;
  description_gte?: String;
  description_contains?: String;
  description_not_contains?: String;
  description_starts_with?: String;
  description_not_starts_with?: String;
  description_ends_with?: String;
  description_not_ends_with?: String;
  commands_every?: InstrumentCommandWhereInput;
  commands_some?: InstrumentCommandWhereInput;
  commands_none?: InstrumentCommandWhereInput;
  parameters_every?: InstrumentParameterWhereInput;
  parameters_some?: InstrumentParameterWhereInput;
  parameters_none?: InstrumentParameterWhereInput;
  subsystems_every?: InstrumentSubsystemWhereInput;
  subsystems_some?: InstrumentSubsystemWhereInput;
  subsystems_none?: InstrumentSubsystemWhereInput;
  AND?: InstrumentSubsystemWhereInput[] | InstrumentSubsystemWhereInput;
  OR?: InstrumentSubsystemWhereInput[] | InstrumentSubsystemWhereInput;
  NOT?: InstrumentSubsystemWhereInput[] | InstrumentSubsystemWhereInput;
}

export interface CharacterizationWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  projectVersion?: ProjectVersionWhereInput;
  measurementRuns_every?: MeasurementRunWhereInput;
  measurementRuns_some?: MeasurementRunWhereInput;
  measurementRuns_none?: MeasurementRunWhereInput;
  AND?: CharacterizationWhereInput[] | CharacterizationWhereInput;
  OR?: CharacterizationWhereInput[] | CharacterizationWhereInput;
  NOT?: CharacterizationWhereInput[] | CharacterizationWhereInput;
}

export type CommentWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
}>;

export type DUTWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
}>;

export interface DUTWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  description?: String;
  description_not?: String;
  description_in?: String[] | String;
  description_not_in?: String[] | String;
  description_lt?: String;
  description_lte?: String;
  description_gt?: String;
  description_gte?: String;
  description_contains?: String;
  description_not_contains?: String;
  description_starts_with?: String;
  description_not_starts_with?: String;
  description_ends_with?: String;
  description_not_ends_with?: String;
  project?: ProjectVersionWhereInput;
  AND?: DUTWhereInput[] | DUTWhereInput;
  OR?: DUTWhereInput[] | DUTWhereInput;
  NOT?: DUTWhereInput[] | DUTWhereInput;
}

export type EventWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
}>;

export type FileWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
}>;

export type InstrumentWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
}>;

export type InstrumentCommandWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
}>;

export type InstrumentInstanceWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
}>;

export type InstrumentParameterWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
}>;

export type InstrumentSubsystemWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
}>;

export type MeasurementWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
}>;

export type MeasurementRunWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
}>;

export type MetaWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
}>;

export interface MetaWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  key?: String;
  key_not?: String;
  key_in?: String[] | String;
  key_not_in?: String[] | String;
  key_lt?: String;
  key_lte?: String;
  key_gt?: String;
  key_gte?: String;
  key_contains?: String;
  key_not_contains?: String;
  key_starts_with?: String;
  key_not_starts_with?: String;
  key_ends_with?: String;
  key_not_ends_with?: String;
  value?: String;
  value_not?: String;
  value_in?: String[] | String;
  value_not_in?: String[] | String;
  value_lt?: String;
  value_lte?: String;
  value_gt?: String;
  value_gte?: String;
  value_contains?: String;
  value_not_contains?: String;
  value_starts_with?: String;
  value_not_starts_with?: String;
  value_ends_with?: String;
  value_not_ends_with?: String;
  AND?: MetaWhereInput[] | MetaWhereInput;
  OR?: MetaWhereInput[] | MetaWhereInput;
  NOT?: MetaWhereInput[] | MetaWhereInput;
}

export type ProjectWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
  name?: String;
  abbreviation?: String;
}>;

export type ProjectVersionWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
  name?: String;
}>;

export type SetupWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
}>;

export type SetupHardwareWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
}>;

export type SetupHardwareInstanceWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
}>;

export type UserWhereUniqueInput = AtLeastOne<{
  id: ID_Input;
  email?: String;
}>;

export interface CharacterizationCreateInput {
  name: String;
  projectVersion: ProjectVersionCreateOneInput;
  measurementRuns?: MeasurementRunCreateManyInput;
}

export interface ProjectVersionCreateOneInput {
  create?: ProjectVersionCreateInput;
  connect?: ProjectVersionWhereUniqueInput;
}

export interface ProjectVersionCreateInput {
  name: String;
  changes?: ProjectVersionCreatechangesInput;
  date: DateTimeInput;
  project: ProjectCreateOneWithoutVersionsInput;
}

export interface ProjectVersionCreatechangesInput {
  set?: String[] | String;
}

export interface ProjectCreateOneWithoutVersionsInput {
  create?: ProjectCreateWithoutVersionsInput;
  connect?: ProjectWhereUniqueInput;
}

export interface ProjectCreateWithoutVersionsInput {
  name: String;
  abbreviation: String;
  description?: String;
  files?: FileCreateManyInput;
}

export interface FileCreateManyInput {
  create?: FileCreateInput[] | FileCreateInput;
  connect?: FileWhereUniqueInput[] | FileWhereUniqueInput;
}

export interface FileCreateInput {
  path: String;
  name?: String;
  description?: String;
  filename: String;
  mimetype: String;
  size: Int;
}

export interface MeasurementRunCreateManyInput {
  create?: MeasurementRunCreateInput[] | MeasurementRunCreateInput;
  connect?: MeasurementRunWhereUniqueInput[] | MeasurementRunWhereUniqueInput;
}

export interface MeasurementRunCreateInput {
  name: String;
  operators?: UserCreateManyInput;
  location: String;
  temperature?: Float;
  startTime: DateTimeInput;
  endTime: DateTimeInput;
  log?: EventCreateManyInput;
  comments?: CommentCreateManyInput;
  measurements?: MeasurementCreateManyInput;
  setup: SetupCreateOneInput;
}

export interface UserCreateManyInput {
  create?: UserCreateInput[] | UserCreateInput;
  connect?: UserWhereUniqueInput[] | UserWhereUniqueInput;
}

export interface UserCreateInput {
  email: String;
  name: String;
  abbreviation: String;
  password: String;
  images?: FileCreateManyInput;
}

export interface EventCreateManyInput {
  create?: EventCreateInput[] | EventCreateInput;
  connect?: EventWhereUniqueInput[] | EventWhereUniqueInput;
}

export interface EventCreateInput {
  json: String;
  when: DateTimeInput;
}

export interface CommentCreateManyInput {
  create?: CommentCreateInput[] | CommentCreateInput;
  connect?: CommentWhereUniqueInput[] | CommentWhereUniqueInput;
}

export interface CommentCreateInput {
  text?: String;
  previousVersion?: CommentCreateOneInput;
}

export interface CommentCreateOneInput {
  create?: CommentCreateInput;
  connect?: CommentWhereUniqueInput;
}

export interface MeasurementCreateManyInput {
  create?: MeasurementCreateInput[] | MeasurementCreateInput;
  connect?: MeasurementWhereUniqueInput[] | MeasurementWhereUniqueInput;
}

export interface MeasurementCreateInput {
  intValue?: Int;
  floatValue?: Float;
  stringValue?: String;
}

export interface SetupCreateOneInput {
  create?: SetupCreateInput;
  connect?: SetupWhereUniqueInput;
}

export interface SetupCreateInput {
  name: String;
  description: String;
  images?: FileCreateManyInput;
  comments?: CommentCreateManyInput;
  setupHardware?: SetupHardwareInstanceCreateManyInput;
  instruments?: InstrumentInstanceCreateManyInput;
}

export interface SetupHardwareInstanceCreateManyInput {
  create?:
    | SetupHardwareInstanceCreateInput[]
    | SetupHardwareInstanceCreateInput;
  connect?:
    | SetupHardwareInstanceWhereUniqueInput[]
    | SetupHardwareInstanceWhereUniqueInput;
}

export interface SetupHardwareInstanceCreateInput {
  setupHardware: SetupHardwareCreateOneInput;
  identifier: String;
  images?: FileCreateManyInput;
}

export interface SetupHardwareCreateOneInput {
  create?: SetupHardwareCreateInput;
  connect?: SetupHardwareWhereUniqueInput;
}

export interface SetupHardwareCreateInput {
  name: String;
  description?: String;
  images?: FileCreateManyInput;
}

export interface InstrumentInstanceCreateManyInput {
  create?: InstrumentInstanceCreateInput[] | InstrumentInstanceCreateInput;
  connect?:
    | InstrumentInstanceWhereUniqueInput[]
    | InstrumentInstanceWhereUniqueInput;
}

export interface InstrumentInstanceCreateInput {
  instrument: InstrumentCreateOneInput;
  identifier: String;
  interface?: InstrumentInstanceCreateinterfaceInput;
  label?: String;
  location?: String;
}

export interface InstrumentCreateOneInput {
  create?: InstrumentCreateInput;
  connect?: InstrumentWhereUniqueInput;
}

export interface InstrumentCreateInput {
  name: String;
  description?: String;
  documents?: FileCreateManyInput;
  interfaces?: InstrumentCreateinterfacesInput;
  commands?: InstrumentCommandCreateManyWithoutInstrumentInput;
  parameters?: InstrumentParameterCreateManyInput;
  subsystems?: InstrumentSubsystemCreateManyInput;
}

export interface InstrumentCreateinterfacesInput {
  set?: String[] | String;
}

export interface InstrumentCommandCreateManyWithoutInstrumentInput {
  create?:
    | InstrumentCommandCreateWithoutInstrumentInput[]
    | InstrumentCommandCreateWithoutInstrumentInput;
  connect?:
    | InstrumentCommandWhereUniqueInput[]
    | InstrumentCommandWhereUniqueInput;
}

export interface InstrumentCommandCreateWithoutInstrumentInput {
  tag: String;
  name?: String;
  description: String;
  readString?: String;
  writeString?: String;
  parameters?: InstrumentParameterCreateManyInput;
}

export interface InstrumentParameterCreateManyInput {
  create?: InstrumentParameterCreateInput[] | InstrumentParameterCreateInput;
  connect?:
    | InstrumentParameterWhereUniqueInput[]
    | InstrumentParameterWhereUniqueInput;
}

export interface InstrumentParameterCreateInput {
  tag: String;
  name?: String;
  description?: String;
  type: String;
  values?: String;
}

export interface InstrumentSubsystemCreateManyInput {
  create?: InstrumentSubsystemCreateInput[] | InstrumentSubsystemCreateInput;
  connect?:
    | InstrumentSubsystemWhereUniqueInput[]
    | InstrumentSubsystemWhereUniqueInput;
}

export interface InstrumentSubsystemCreateInput {
  name?: String;
  description: String;
  commands?: InstrumentCommandCreateManyInput;
  parameters?: InstrumentParameterCreateManyInput;
  subsystems?: InstrumentSubsystemCreateManyInput;
}

export interface InstrumentCommandCreateManyInput {
  create?: InstrumentCommandCreateInput[] | InstrumentCommandCreateInput;
  connect?:
    | InstrumentCommandWhereUniqueInput[]
    | InstrumentCommandWhereUniqueInput;
}

export interface InstrumentCommandCreateInput {
  tag: String;
  name?: String;
  description: String;
  instrument: InstrumentCreateOneWithoutCommandsInput;
  readString?: String;
  writeString?: String;
  parameters?: InstrumentParameterCreateManyInput;
}

export interface InstrumentCreateOneWithoutCommandsInput {
  create?: InstrumentCreateWithoutCommandsInput;
  connect?: InstrumentWhereUniqueInput;
}

export interface InstrumentCreateWithoutCommandsInput {
  name: String;
  description?: String;
  documents?: FileCreateManyInput;
  interfaces?: InstrumentCreateinterfacesInput;
  parameters?: InstrumentParameterCreateManyInput;
  subsystems?: InstrumentSubsystemCreateManyInput;
}

export interface InstrumentInstanceCreateinterfaceInput {
  set?: String[] | String;
}

export interface CharacterizationUpdateInput {
  name?: String;
  projectVersion?: ProjectVersionUpdateOneRequiredInput;
  measurementRuns?: MeasurementRunUpdateManyInput;
}

export interface ProjectVersionUpdateOneRequiredInput {
  create?: ProjectVersionCreateInput;
  update?: ProjectVersionUpdateDataInput;
  upsert?: ProjectVersionUpsertNestedInput;
  connect?: ProjectVersionWhereUniqueInput;
}

export interface ProjectVersionUpdateDataInput {
  name?: String;
  changes?: ProjectVersionUpdatechangesInput;
  date?: DateTimeInput;
  project?: ProjectUpdateOneRequiredWithoutVersionsInput;
}

export interface ProjectVersionUpdatechangesInput {
  set?: String[] | String;
}

export interface ProjectUpdateOneRequiredWithoutVersionsInput {
  create?: ProjectCreateWithoutVersionsInput;
  update?: ProjectUpdateWithoutVersionsDataInput;
  upsert?: ProjectUpsertWithoutVersionsInput;
  connect?: ProjectWhereUniqueInput;
}

export interface ProjectUpdateWithoutVersionsDataInput {
  name?: String;
  abbreviation?: String;
  description?: String;
  files?: FileUpdateManyInput;
}

export interface FileUpdateManyInput {
  create?: FileCreateInput[] | FileCreateInput;
  update?:
    | FileUpdateWithWhereUniqueNestedInput[]
    | FileUpdateWithWhereUniqueNestedInput;
  upsert?:
    | FileUpsertWithWhereUniqueNestedInput[]
    | FileUpsertWithWhereUniqueNestedInput;
  delete?: FileWhereUniqueInput[] | FileWhereUniqueInput;
  connect?: FileWhereUniqueInput[] | FileWhereUniqueInput;
  set?: FileWhereUniqueInput[] | FileWhereUniqueInput;
  disconnect?: FileWhereUniqueInput[] | FileWhereUniqueInput;
  deleteMany?: FileScalarWhereInput[] | FileScalarWhereInput;
  updateMany?:
    | FileUpdateManyWithWhereNestedInput[]
    | FileUpdateManyWithWhereNestedInput;
}

export interface FileUpdateWithWhereUniqueNestedInput {
  where: FileWhereUniqueInput;
  data: FileUpdateDataInput;
}

export interface FileUpdateDataInput {
  path?: String;
  name?: String;
  description?: String;
  filename?: String;
  mimetype?: String;
  size?: Int;
}

export interface FileUpsertWithWhereUniqueNestedInput {
  where: FileWhereUniqueInput;
  update: FileUpdateDataInput;
  create: FileCreateInput;
}

export interface FileScalarWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  path?: String;
  path_not?: String;
  path_in?: String[] | String;
  path_not_in?: String[] | String;
  path_lt?: String;
  path_lte?: String;
  path_gt?: String;
  path_gte?: String;
  path_contains?: String;
  path_not_contains?: String;
  path_starts_with?: String;
  path_not_starts_with?: String;
  path_ends_with?: String;
  path_not_ends_with?: String;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  description?: String;
  description_not?: String;
  description_in?: String[] | String;
  description_not_in?: String[] | String;
  description_lt?: String;
  description_lte?: String;
  description_gt?: String;
  description_gte?: String;
  description_contains?: String;
  description_not_contains?: String;
  description_starts_with?: String;
  description_not_starts_with?: String;
  description_ends_with?: String;
  description_not_ends_with?: String;
  filename?: String;
  filename_not?: String;
  filename_in?: String[] | String;
  filename_not_in?: String[] | String;
  filename_lt?: String;
  filename_lte?: String;
  filename_gt?: String;
  filename_gte?: String;
  filename_contains?: String;
  filename_not_contains?: String;
  filename_starts_with?: String;
  filename_not_starts_with?: String;
  filename_ends_with?: String;
  filename_not_ends_with?: String;
  mimetype?: String;
  mimetype_not?: String;
  mimetype_in?: String[] | String;
  mimetype_not_in?: String[] | String;
  mimetype_lt?: String;
  mimetype_lte?: String;
  mimetype_gt?: String;
  mimetype_gte?: String;
  mimetype_contains?: String;
  mimetype_not_contains?: String;
  mimetype_starts_with?: String;
  mimetype_not_starts_with?: String;
  mimetype_ends_with?: String;
  mimetype_not_ends_with?: String;
  size?: Int;
  size_not?: Int;
  size_in?: Int[] | Int;
  size_not_in?: Int[] | Int;
  size_lt?: Int;
  size_lte?: Int;
  size_gt?: Int;
  size_gte?: Int;
  AND?: FileScalarWhereInput[] | FileScalarWhereInput;
  OR?: FileScalarWhereInput[] | FileScalarWhereInput;
  NOT?: FileScalarWhereInput[] | FileScalarWhereInput;
}

export interface FileUpdateManyWithWhereNestedInput {
  where: FileScalarWhereInput;
  data: FileUpdateManyDataInput;
}

export interface FileUpdateManyDataInput {
  path?: String;
  name?: String;
  description?: String;
  filename?: String;
  mimetype?: String;
  size?: Int;
}

export interface ProjectUpsertWithoutVersionsInput {
  update: ProjectUpdateWithoutVersionsDataInput;
  create: ProjectCreateWithoutVersionsInput;
}

export interface ProjectVersionUpsertNestedInput {
  update: ProjectVersionUpdateDataInput;
  create: ProjectVersionCreateInput;
}

export interface MeasurementRunUpdateManyInput {
  create?: MeasurementRunCreateInput[] | MeasurementRunCreateInput;
  update?:
    | MeasurementRunUpdateWithWhereUniqueNestedInput[]
    | MeasurementRunUpdateWithWhereUniqueNestedInput;
  upsert?:
    | MeasurementRunUpsertWithWhereUniqueNestedInput[]
    | MeasurementRunUpsertWithWhereUniqueNestedInput;
  delete?: MeasurementRunWhereUniqueInput[] | MeasurementRunWhereUniqueInput;
  connect?: MeasurementRunWhereUniqueInput[] | MeasurementRunWhereUniqueInput;
  set?: MeasurementRunWhereUniqueInput[] | MeasurementRunWhereUniqueInput;
  disconnect?:
    | MeasurementRunWhereUniqueInput[]
    | MeasurementRunWhereUniqueInput;
  deleteMany?:
    | MeasurementRunScalarWhereInput[]
    | MeasurementRunScalarWhereInput;
  updateMany?:
    | MeasurementRunUpdateManyWithWhereNestedInput[]
    | MeasurementRunUpdateManyWithWhereNestedInput;
}

export interface MeasurementRunUpdateWithWhereUniqueNestedInput {
  where: MeasurementRunWhereUniqueInput;
  data: MeasurementRunUpdateDataInput;
}

export interface MeasurementRunUpdateDataInput {
  name?: String;
  operators?: UserUpdateManyInput;
  location?: String;
  temperature?: Float;
  startTime?: DateTimeInput;
  endTime?: DateTimeInput;
  log?: EventUpdateManyInput;
  comments?: CommentUpdateManyInput;
  measurements?: MeasurementUpdateManyInput;
  setup?: SetupUpdateOneRequiredInput;
}

export interface UserUpdateManyInput {
  create?: UserCreateInput[] | UserCreateInput;
  update?:
    | UserUpdateWithWhereUniqueNestedInput[]
    | UserUpdateWithWhereUniqueNestedInput;
  upsert?:
    | UserUpsertWithWhereUniqueNestedInput[]
    | UserUpsertWithWhereUniqueNestedInput;
  delete?: UserWhereUniqueInput[] | UserWhereUniqueInput;
  connect?: UserWhereUniqueInput[] | UserWhereUniqueInput;
  set?: UserWhereUniqueInput[] | UserWhereUniqueInput;
  disconnect?: UserWhereUniqueInput[] | UserWhereUniqueInput;
  deleteMany?: UserScalarWhereInput[] | UserScalarWhereInput;
  updateMany?:
    | UserUpdateManyWithWhereNestedInput[]
    | UserUpdateManyWithWhereNestedInput;
}

export interface UserUpdateWithWhereUniqueNestedInput {
  where: UserWhereUniqueInput;
  data: UserUpdateDataInput;
}

export interface UserUpdateDataInput {
  email?: String;
  name?: String;
  abbreviation?: String;
  password?: String;
  images?: FileUpdateManyInput;
}

export interface UserUpsertWithWhereUniqueNestedInput {
  where: UserWhereUniqueInput;
  update: UserUpdateDataInput;
  create: UserCreateInput;
}

export interface UserScalarWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  email?: String;
  email_not?: String;
  email_in?: String[] | String;
  email_not_in?: String[] | String;
  email_lt?: String;
  email_lte?: String;
  email_gt?: String;
  email_gte?: String;
  email_contains?: String;
  email_not_contains?: String;
  email_starts_with?: String;
  email_not_starts_with?: String;
  email_ends_with?: String;
  email_not_ends_with?: String;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  abbreviation?: String;
  abbreviation_not?: String;
  abbreviation_in?: String[] | String;
  abbreviation_not_in?: String[] | String;
  abbreviation_lt?: String;
  abbreviation_lte?: String;
  abbreviation_gt?: String;
  abbreviation_gte?: String;
  abbreviation_contains?: String;
  abbreviation_not_contains?: String;
  abbreviation_starts_with?: String;
  abbreviation_not_starts_with?: String;
  abbreviation_ends_with?: String;
  abbreviation_not_ends_with?: String;
  password?: String;
  password_not?: String;
  password_in?: String[] | String;
  password_not_in?: String[] | String;
  password_lt?: String;
  password_lte?: String;
  password_gt?: String;
  password_gte?: String;
  password_contains?: String;
  password_not_contains?: String;
  password_starts_with?: String;
  password_not_starts_with?: String;
  password_ends_with?: String;
  password_not_ends_with?: String;
  AND?: UserScalarWhereInput[] | UserScalarWhereInput;
  OR?: UserScalarWhereInput[] | UserScalarWhereInput;
  NOT?: UserScalarWhereInput[] | UserScalarWhereInput;
}

export interface UserUpdateManyWithWhereNestedInput {
  where: UserScalarWhereInput;
  data: UserUpdateManyDataInput;
}

export interface UserUpdateManyDataInput {
  email?: String;
  name?: String;
  abbreviation?: String;
  password?: String;
}

export interface EventUpdateManyInput {
  create?: EventCreateInput[] | EventCreateInput;
  update?:
    | EventUpdateWithWhereUniqueNestedInput[]
    | EventUpdateWithWhereUniqueNestedInput;
  upsert?:
    | EventUpsertWithWhereUniqueNestedInput[]
    | EventUpsertWithWhereUniqueNestedInput;
  delete?: EventWhereUniqueInput[] | EventWhereUniqueInput;
  connect?: EventWhereUniqueInput[] | EventWhereUniqueInput;
  set?: EventWhereUniqueInput[] | EventWhereUniqueInput;
  disconnect?: EventWhereUniqueInput[] | EventWhereUniqueInput;
  deleteMany?: EventScalarWhereInput[] | EventScalarWhereInput;
  updateMany?:
    | EventUpdateManyWithWhereNestedInput[]
    | EventUpdateManyWithWhereNestedInput;
}

export interface EventUpdateWithWhereUniqueNestedInput {
  where: EventWhereUniqueInput;
  data: EventUpdateDataInput;
}

export interface EventUpdateDataInput {
  json?: String;
  when?: DateTimeInput;
}

export interface EventUpsertWithWhereUniqueNestedInput {
  where: EventWhereUniqueInput;
  update: EventUpdateDataInput;
  create: EventCreateInput;
}

export interface EventScalarWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  json?: String;
  json_not?: String;
  json_in?: String[] | String;
  json_not_in?: String[] | String;
  json_lt?: String;
  json_lte?: String;
  json_gt?: String;
  json_gte?: String;
  json_contains?: String;
  json_not_contains?: String;
  json_starts_with?: String;
  json_not_starts_with?: String;
  json_ends_with?: String;
  json_not_ends_with?: String;
  when?: DateTimeInput;
  when_not?: DateTimeInput;
  when_in?: DateTimeInput[] | DateTimeInput;
  when_not_in?: DateTimeInput[] | DateTimeInput;
  when_lt?: DateTimeInput;
  when_lte?: DateTimeInput;
  when_gt?: DateTimeInput;
  when_gte?: DateTimeInput;
  AND?: EventScalarWhereInput[] | EventScalarWhereInput;
  OR?: EventScalarWhereInput[] | EventScalarWhereInput;
  NOT?: EventScalarWhereInput[] | EventScalarWhereInput;
}

export interface EventUpdateManyWithWhereNestedInput {
  where: EventScalarWhereInput;
  data: EventUpdateManyDataInput;
}

export interface EventUpdateManyDataInput {
  json?: String;
  when?: DateTimeInput;
}

export interface CommentUpdateManyInput {
  create?: CommentCreateInput[] | CommentCreateInput;
  update?:
    | CommentUpdateWithWhereUniqueNestedInput[]
    | CommentUpdateWithWhereUniqueNestedInput;
  upsert?:
    | CommentUpsertWithWhereUniqueNestedInput[]
    | CommentUpsertWithWhereUniqueNestedInput;
  delete?: CommentWhereUniqueInput[] | CommentWhereUniqueInput;
  connect?: CommentWhereUniqueInput[] | CommentWhereUniqueInput;
  set?: CommentWhereUniqueInput[] | CommentWhereUniqueInput;
  disconnect?: CommentWhereUniqueInput[] | CommentWhereUniqueInput;
  deleteMany?: CommentScalarWhereInput[] | CommentScalarWhereInput;
  updateMany?:
    | CommentUpdateManyWithWhereNestedInput[]
    | CommentUpdateManyWithWhereNestedInput;
}

export interface CommentUpdateWithWhereUniqueNestedInput {
  where: CommentWhereUniqueInput;
  data: CommentUpdateDataInput;
}

export interface CommentUpdateDataInput {
  text?: String;
  previousVersion?: CommentUpdateOneInput;
}

export interface CommentUpdateOneInput {
  create?: CommentCreateInput;
  update?: CommentUpdateDataInput;
  upsert?: CommentUpsertNestedInput;
  delete?: Boolean;
  disconnect?: Boolean;
  connect?: CommentWhereUniqueInput;
}

export interface CommentUpsertNestedInput {
  update: CommentUpdateDataInput;
  create: CommentCreateInput;
}

export interface CommentUpsertWithWhereUniqueNestedInput {
  where: CommentWhereUniqueInput;
  update: CommentUpdateDataInput;
  create: CommentCreateInput;
}

export interface CommentScalarWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  text?: String;
  text_not?: String;
  text_in?: String[] | String;
  text_not_in?: String[] | String;
  text_lt?: String;
  text_lte?: String;
  text_gt?: String;
  text_gte?: String;
  text_contains?: String;
  text_not_contains?: String;
  text_starts_with?: String;
  text_not_starts_with?: String;
  text_ends_with?: String;
  text_not_ends_with?: String;
  createdAt?: DateTimeInput;
  createdAt_not?: DateTimeInput;
  createdAt_in?: DateTimeInput[] | DateTimeInput;
  createdAt_not_in?: DateTimeInput[] | DateTimeInput;
  createdAt_lt?: DateTimeInput;
  createdAt_lte?: DateTimeInput;
  createdAt_gt?: DateTimeInput;
  createdAt_gte?: DateTimeInput;
  AND?: CommentScalarWhereInput[] | CommentScalarWhereInput;
  OR?: CommentScalarWhereInput[] | CommentScalarWhereInput;
  NOT?: CommentScalarWhereInput[] | CommentScalarWhereInput;
}

export interface CommentUpdateManyWithWhereNestedInput {
  where: CommentScalarWhereInput;
  data: CommentUpdateManyDataInput;
}

export interface CommentUpdateManyDataInput {
  text?: String;
}

export interface MeasurementUpdateManyInput {
  create?: MeasurementCreateInput[] | MeasurementCreateInput;
  update?:
    | MeasurementUpdateWithWhereUniqueNestedInput[]
    | MeasurementUpdateWithWhereUniqueNestedInput;
  upsert?:
    | MeasurementUpsertWithWhereUniqueNestedInput[]
    | MeasurementUpsertWithWhereUniqueNestedInput;
  delete?: MeasurementWhereUniqueInput[] | MeasurementWhereUniqueInput;
  connect?: MeasurementWhereUniqueInput[] | MeasurementWhereUniqueInput;
  set?: MeasurementWhereUniqueInput[] | MeasurementWhereUniqueInput;
  disconnect?: MeasurementWhereUniqueInput[] | MeasurementWhereUniqueInput;
  deleteMany?: MeasurementScalarWhereInput[] | MeasurementScalarWhereInput;
  updateMany?:
    | MeasurementUpdateManyWithWhereNestedInput[]
    | MeasurementUpdateManyWithWhereNestedInput;
}

export interface MeasurementUpdateWithWhereUniqueNestedInput {
  where: MeasurementWhereUniqueInput;
  data: MeasurementUpdateDataInput;
}

export interface MeasurementUpdateDataInput {
  intValue?: Int;
  floatValue?: Float;
  stringValue?: String;
}

export interface MeasurementUpsertWithWhereUniqueNestedInput {
  where: MeasurementWhereUniqueInput;
  update: MeasurementUpdateDataInput;
  create: MeasurementCreateInput;
}

export interface MeasurementScalarWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  createdAt?: DateTimeInput;
  createdAt_not?: DateTimeInput;
  createdAt_in?: DateTimeInput[] | DateTimeInput;
  createdAt_not_in?: DateTimeInput[] | DateTimeInput;
  createdAt_lt?: DateTimeInput;
  createdAt_lte?: DateTimeInput;
  createdAt_gt?: DateTimeInput;
  createdAt_gte?: DateTimeInput;
  intValue?: Int;
  intValue_not?: Int;
  intValue_in?: Int[] | Int;
  intValue_not_in?: Int[] | Int;
  intValue_lt?: Int;
  intValue_lte?: Int;
  intValue_gt?: Int;
  intValue_gte?: Int;
  floatValue?: Float;
  floatValue_not?: Float;
  floatValue_in?: Float[] | Float;
  floatValue_not_in?: Float[] | Float;
  floatValue_lt?: Float;
  floatValue_lte?: Float;
  floatValue_gt?: Float;
  floatValue_gte?: Float;
  stringValue?: String;
  stringValue_not?: String;
  stringValue_in?: String[] | String;
  stringValue_not_in?: String[] | String;
  stringValue_lt?: String;
  stringValue_lte?: String;
  stringValue_gt?: String;
  stringValue_gte?: String;
  stringValue_contains?: String;
  stringValue_not_contains?: String;
  stringValue_starts_with?: String;
  stringValue_not_starts_with?: String;
  stringValue_ends_with?: String;
  stringValue_not_ends_with?: String;
  AND?: MeasurementScalarWhereInput[] | MeasurementScalarWhereInput;
  OR?: MeasurementScalarWhereInput[] | MeasurementScalarWhereInput;
  NOT?: MeasurementScalarWhereInput[] | MeasurementScalarWhereInput;
}

export interface MeasurementUpdateManyWithWhereNestedInput {
  where: MeasurementScalarWhereInput;
  data: MeasurementUpdateManyDataInput;
}

export interface MeasurementUpdateManyDataInput {
  intValue?: Int;
  floatValue?: Float;
  stringValue?: String;
}

export interface SetupUpdateOneRequiredInput {
  create?: SetupCreateInput;
  update?: SetupUpdateDataInput;
  upsert?: SetupUpsertNestedInput;
  connect?: SetupWhereUniqueInput;
}

export interface SetupUpdateDataInput {
  name?: String;
  description?: String;
  images?: FileUpdateManyInput;
  comments?: CommentUpdateManyInput;
  setupHardware?: SetupHardwareInstanceUpdateManyInput;
  instruments?: InstrumentInstanceUpdateManyInput;
}

export interface SetupHardwareInstanceUpdateManyInput {
  create?:
    | SetupHardwareInstanceCreateInput[]
    | SetupHardwareInstanceCreateInput;
  update?:
    | SetupHardwareInstanceUpdateWithWhereUniqueNestedInput[]
    | SetupHardwareInstanceUpdateWithWhereUniqueNestedInput;
  upsert?:
    | SetupHardwareInstanceUpsertWithWhereUniqueNestedInput[]
    | SetupHardwareInstanceUpsertWithWhereUniqueNestedInput;
  delete?:
    | SetupHardwareInstanceWhereUniqueInput[]
    | SetupHardwareInstanceWhereUniqueInput;
  connect?:
    | SetupHardwareInstanceWhereUniqueInput[]
    | SetupHardwareInstanceWhereUniqueInput;
  set?:
    | SetupHardwareInstanceWhereUniqueInput[]
    | SetupHardwareInstanceWhereUniqueInput;
  disconnect?:
    | SetupHardwareInstanceWhereUniqueInput[]
    | SetupHardwareInstanceWhereUniqueInput;
  deleteMany?:
    | SetupHardwareInstanceScalarWhereInput[]
    | SetupHardwareInstanceScalarWhereInput;
  updateMany?:
    | SetupHardwareInstanceUpdateManyWithWhereNestedInput[]
    | SetupHardwareInstanceUpdateManyWithWhereNestedInput;
}

export interface SetupHardwareInstanceUpdateWithWhereUniqueNestedInput {
  where: SetupHardwareInstanceWhereUniqueInput;
  data: SetupHardwareInstanceUpdateDataInput;
}

export interface SetupHardwareInstanceUpdateDataInput {
  setupHardware?: SetupHardwareUpdateOneRequiredInput;
  identifier?: String;
  images?: FileUpdateManyInput;
}

export interface SetupHardwareUpdateOneRequiredInput {
  create?: SetupHardwareCreateInput;
  update?: SetupHardwareUpdateDataInput;
  upsert?: SetupHardwareUpsertNestedInput;
  connect?: SetupHardwareWhereUniqueInput;
}

export interface SetupHardwareUpdateDataInput {
  name?: String;
  description?: String;
  images?: FileUpdateManyInput;
}

export interface SetupHardwareUpsertNestedInput {
  update: SetupHardwareUpdateDataInput;
  create: SetupHardwareCreateInput;
}

export interface SetupHardwareInstanceUpsertWithWhereUniqueNestedInput {
  where: SetupHardwareInstanceWhereUniqueInput;
  update: SetupHardwareInstanceUpdateDataInput;
  create: SetupHardwareInstanceCreateInput;
}

export interface SetupHardwareInstanceScalarWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  identifier?: String;
  identifier_not?: String;
  identifier_in?: String[] | String;
  identifier_not_in?: String[] | String;
  identifier_lt?: String;
  identifier_lte?: String;
  identifier_gt?: String;
  identifier_gte?: String;
  identifier_contains?: String;
  identifier_not_contains?: String;
  identifier_starts_with?: String;
  identifier_not_starts_with?: String;
  identifier_ends_with?: String;
  identifier_not_ends_with?: String;
  AND?:
    | SetupHardwareInstanceScalarWhereInput[]
    | SetupHardwareInstanceScalarWhereInput;
  OR?:
    | SetupHardwareInstanceScalarWhereInput[]
    | SetupHardwareInstanceScalarWhereInput;
  NOT?:
    | SetupHardwareInstanceScalarWhereInput[]
    | SetupHardwareInstanceScalarWhereInput;
}

export interface SetupHardwareInstanceUpdateManyWithWhereNestedInput {
  where: SetupHardwareInstanceScalarWhereInput;
  data: SetupHardwareInstanceUpdateManyDataInput;
}

export interface SetupHardwareInstanceUpdateManyDataInput {
  identifier?: String;
}

export interface InstrumentInstanceUpdateManyInput {
  create?: InstrumentInstanceCreateInput[] | InstrumentInstanceCreateInput;
  update?:
    | InstrumentInstanceUpdateWithWhereUniqueNestedInput[]
    | InstrumentInstanceUpdateWithWhereUniqueNestedInput;
  upsert?:
    | InstrumentInstanceUpsertWithWhereUniqueNestedInput[]
    | InstrumentInstanceUpsertWithWhereUniqueNestedInput;
  delete?:
    | InstrumentInstanceWhereUniqueInput[]
    | InstrumentInstanceWhereUniqueInput;
  connect?:
    | InstrumentInstanceWhereUniqueInput[]
    | InstrumentInstanceWhereUniqueInput;
  set?:
    | InstrumentInstanceWhereUniqueInput[]
    | InstrumentInstanceWhereUniqueInput;
  disconnect?:
    | InstrumentInstanceWhereUniqueInput[]
    | InstrumentInstanceWhereUniqueInput;
  deleteMany?:
    | InstrumentInstanceScalarWhereInput[]
    | InstrumentInstanceScalarWhereInput;
  updateMany?:
    | InstrumentInstanceUpdateManyWithWhereNestedInput[]
    | InstrumentInstanceUpdateManyWithWhereNestedInput;
}

export interface InstrumentInstanceUpdateWithWhereUniqueNestedInput {
  where: InstrumentInstanceWhereUniqueInput;
  data: InstrumentInstanceUpdateDataInput;
}

export interface InstrumentInstanceUpdateDataInput {
  instrument?: InstrumentUpdateOneRequiredInput;
  identifier?: String;
  interface?: InstrumentInstanceUpdateinterfaceInput;
  label?: String;
  location?: String;
}

export interface InstrumentUpdateOneRequiredInput {
  create?: InstrumentCreateInput;
  update?: InstrumentUpdateDataInput;
  upsert?: InstrumentUpsertNestedInput;
  connect?: InstrumentWhereUniqueInput;
}

export interface InstrumentUpdateDataInput {
  name?: String;
  description?: String;
  documents?: FileUpdateManyInput;
  interfaces?: InstrumentUpdateinterfacesInput;
  commands?: InstrumentCommandUpdateManyWithoutInstrumentInput;
  parameters?: InstrumentParameterUpdateManyInput;
  subsystems?: InstrumentSubsystemUpdateManyInput;
}

export interface InstrumentUpdateinterfacesInput {
  set?: String[] | String;
}

export interface InstrumentCommandUpdateManyWithoutInstrumentInput {
  create?:
    | InstrumentCommandCreateWithoutInstrumentInput[]
    | InstrumentCommandCreateWithoutInstrumentInput;
  delete?:
    | InstrumentCommandWhereUniqueInput[]
    | InstrumentCommandWhereUniqueInput;
  connect?:
    | InstrumentCommandWhereUniqueInput[]
    | InstrumentCommandWhereUniqueInput;
  set?: InstrumentCommandWhereUniqueInput[] | InstrumentCommandWhereUniqueInput;
  disconnect?:
    | InstrumentCommandWhereUniqueInput[]
    | InstrumentCommandWhereUniqueInput;
  update?:
    | InstrumentCommandUpdateWithWhereUniqueWithoutInstrumentInput[]
    | InstrumentCommandUpdateWithWhereUniqueWithoutInstrumentInput;
  upsert?:
    | InstrumentCommandUpsertWithWhereUniqueWithoutInstrumentInput[]
    | InstrumentCommandUpsertWithWhereUniqueWithoutInstrumentInput;
  deleteMany?:
    | InstrumentCommandScalarWhereInput[]
    | InstrumentCommandScalarWhereInput;
  updateMany?:
    | InstrumentCommandUpdateManyWithWhereNestedInput[]
    | InstrumentCommandUpdateManyWithWhereNestedInput;
}

export interface InstrumentCommandUpdateWithWhereUniqueWithoutInstrumentInput {
  where: InstrumentCommandWhereUniqueInput;
  data: InstrumentCommandUpdateWithoutInstrumentDataInput;
}

export interface InstrumentCommandUpdateWithoutInstrumentDataInput {
  tag?: String;
  name?: String;
  description?: String;
  readString?: String;
  writeString?: String;
  parameters?: InstrumentParameterUpdateManyInput;
}

export interface InstrumentParameterUpdateManyInput {
  create?: InstrumentParameterCreateInput[] | InstrumentParameterCreateInput;
  update?:
    | InstrumentParameterUpdateWithWhereUniqueNestedInput[]
    | InstrumentParameterUpdateWithWhereUniqueNestedInput;
  upsert?:
    | InstrumentParameterUpsertWithWhereUniqueNestedInput[]
    | InstrumentParameterUpsertWithWhereUniqueNestedInput;
  delete?:
    | InstrumentParameterWhereUniqueInput[]
    | InstrumentParameterWhereUniqueInput;
  connect?:
    | InstrumentParameterWhereUniqueInput[]
    | InstrumentParameterWhereUniqueInput;
  set?:
    | InstrumentParameterWhereUniqueInput[]
    | InstrumentParameterWhereUniqueInput;
  disconnect?:
    | InstrumentParameterWhereUniqueInput[]
    | InstrumentParameterWhereUniqueInput;
  deleteMany?:
    | InstrumentParameterScalarWhereInput[]
    | InstrumentParameterScalarWhereInput;
  updateMany?:
    | InstrumentParameterUpdateManyWithWhereNestedInput[]
    | InstrumentParameterUpdateManyWithWhereNestedInput;
}

export interface InstrumentParameterUpdateWithWhereUniqueNestedInput {
  where: InstrumentParameterWhereUniqueInput;
  data: InstrumentParameterUpdateDataInput;
}

export interface InstrumentParameterUpdateDataInput {
  tag?: String;
  name?: String;
  description?: String;
  type?: String;
  values?: String;
}

export interface InstrumentParameterUpsertWithWhereUniqueNestedInput {
  where: InstrumentParameterWhereUniqueInput;
  update: InstrumentParameterUpdateDataInput;
  create: InstrumentParameterCreateInput;
}

export interface InstrumentParameterScalarWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  tag?: String;
  tag_not?: String;
  tag_in?: String[] | String;
  tag_not_in?: String[] | String;
  tag_lt?: String;
  tag_lte?: String;
  tag_gt?: String;
  tag_gte?: String;
  tag_contains?: String;
  tag_not_contains?: String;
  tag_starts_with?: String;
  tag_not_starts_with?: String;
  tag_ends_with?: String;
  tag_not_ends_with?: String;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  description?: String;
  description_not?: String;
  description_in?: String[] | String;
  description_not_in?: String[] | String;
  description_lt?: String;
  description_lte?: String;
  description_gt?: String;
  description_gte?: String;
  description_contains?: String;
  description_not_contains?: String;
  description_starts_with?: String;
  description_not_starts_with?: String;
  description_ends_with?: String;
  description_not_ends_with?: String;
  type?: String;
  type_not?: String;
  type_in?: String[] | String;
  type_not_in?: String[] | String;
  type_lt?: String;
  type_lte?: String;
  type_gt?: String;
  type_gte?: String;
  type_contains?: String;
  type_not_contains?: String;
  type_starts_with?: String;
  type_not_starts_with?: String;
  type_ends_with?: String;
  type_not_ends_with?: String;
  values?: String;
  values_not?: String;
  values_in?: String[] | String;
  values_not_in?: String[] | String;
  values_lt?: String;
  values_lte?: String;
  values_gt?: String;
  values_gte?: String;
  values_contains?: String;
  values_not_contains?: String;
  values_starts_with?: String;
  values_not_starts_with?: String;
  values_ends_with?: String;
  values_not_ends_with?: String;
  AND?:
    | InstrumentParameterScalarWhereInput[]
    | InstrumentParameterScalarWhereInput;
  OR?:
    | InstrumentParameterScalarWhereInput[]
    | InstrumentParameterScalarWhereInput;
  NOT?:
    | InstrumentParameterScalarWhereInput[]
    | InstrumentParameterScalarWhereInput;
}

export interface InstrumentParameterUpdateManyWithWhereNestedInput {
  where: InstrumentParameterScalarWhereInput;
  data: InstrumentParameterUpdateManyDataInput;
}

export interface InstrumentParameterUpdateManyDataInput {
  tag?: String;
  name?: String;
  description?: String;
  type?: String;
  values?: String;
}

export interface InstrumentCommandUpsertWithWhereUniqueWithoutInstrumentInput {
  where: InstrumentCommandWhereUniqueInput;
  update: InstrumentCommandUpdateWithoutInstrumentDataInput;
  create: InstrumentCommandCreateWithoutInstrumentInput;
}

export interface InstrumentCommandScalarWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  tag?: String;
  tag_not?: String;
  tag_in?: String[] | String;
  tag_not_in?: String[] | String;
  tag_lt?: String;
  tag_lte?: String;
  tag_gt?: String;
  tag_gte?: String;
  tag_contains?: String;
  tag_not_contains?: String;
  tag_starts_with?: String;
  tag_not_starts_with?: String;
  tag_ends_with?: String;
  tag_not_ends_with?: String;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  description?: String;
  description_not?: String;
  description_in?: String[] | String;
  description_not_in?: String[] | String;
  description_lt?: String;
  description_lte?: String;
  description_gt?: String;
  description_gte?: String;
  description_contains?: String;
  description_not_contains?: String;
  description_starts_with?: String;
  description_not_starts_with?: String;
  description_ends_with?: String;
  description_not_ends_with?: String;
  readString?: String;
  readString_not?: String;
  readString_in?: String[] | String;
  readString_not_in?: String[] | String;
  readString_lt?: String;
  readString_lte?: String;
  readString_gt?: String;
  readString_gte?: String;
  readString_contains?: String;
  readString_not_contains?: String;
  readString_starts_with?: String;
  readString_not_starts_with?: String;
  readString_ends_with?: String;
  readString_not_ends_with?: String;
  writeString?: String;
  writeString_not?: String;
  writeString_in?: String[] | String;
  writeString_not_in?: String[] | String;
  writeString_lt?: String;
  writeString_lte?: String;
  writeString_gt?: String;
  writeString_gte?: String;
  writeString_contains?: String;
  writeString_not_contains?: String;
  writeString_starts_with?: String;
  writeString_not_starts_with?: String;
  writeString_ends_with?: String;
  writeString_not_ends_with?: String;
  AND?: InstrumentCommandScalarWhereInput[] | InstrumentCommandScalarWhereInput;
  OR?: InstrumentCommandScalarWhereInput[] | InstrumentCommandScalarWhereInput;
  NOT?: InstrumentCommandScalarWhereInput[] | InstrumentCommandScalarWhereInput;
}

export interface InstrumentCommandUpdateManyWithWhereNestedInput {
  where: InstrumentCommandScalarWhereInput;
  data: InstrumentCommandUpdateManyDataInput;
}

export interface InstrumentCommandUpdateManyDataInput {
  tag?: String;
  name?: String;
  description?: String;
  readString?: String;
  writeString?: String;
}

export interface InstrumentSubsystemUpdateManyInput {
  create?: InstrumentSubsystemCreateInput[] | InstrumentSubsystemCreateInput;
  update?:
    | InstrumentSubsystemUpdateWithWhereUniqueNestedInput[]
    | InstrumentSubsystemUpdateWithWhereUniqueNestedInput;
  upsert?:
    | InstrumentSubsystemUpsertWithWhereUniqueNestedInput[]
    | InstrumentSubsystemUpsertWithWhereUniqueNestedInput;
  delete?:
    | InstrumentSubsystemWhereUniqueInput[]
    | InstrumentSubsystemWhereUniqueInput;
  connect?:
    | InstrumentSubsystemWhereUniqueInput[]
    | InstrumentSubsystemWhereUniqueInput;
  set?:
    | InstrumentSubsystemWhereUniqueInput[]
    | InstrumentSubsystemWhereUniqueInput;
  disconnect?:
    | InstrumentSubsystemWhereUniqueInput[]
    | InstrumentSubsystemWhereUniqueInput;
  deleteMany?:
    | InstrumentSubsystemScalarWhereInput[]
    | InstrumentSubsystemScalarWhereInput;
  updateMany?:
    | InstrumentSubsystemUpdateManyWithWhereNestedInput[]
    | InstrumentSubsystemUpdateManyWithWhereNestedInput;
}

export interface InstrumentSubsystemUpdateWithWhereUniqueNestedInput {
  where: InstrumentSubsystemWhereUniqueInput;
  data: InstrumentSubsystemUpdateDataInput;
}

export interface InstrumentSubsystemUpdateDataInput {
  name?: String;
  description?: String;
  commands?: InstrumentCommandUpdateManyInput;
  parameters?: InstrumentParameterUpdateManyInput;
  subsystems?: InstrumentSubsystemUpdateManyInput;
}

export interface InstrumentCommandUpdateManyInput {
  create?: InstrumentCommandCreateInput[] | InstrumentCommandCreateInput;
  update?:
    | InstrumentCommandUpdateWithWhereUniqueNestedInput[]
    | InstrumentCommandUpdateWithWhereUniqueNestedInput;
  upsert?:
    | InstrumentCommandUpsertWithWhereUniqueNestedInput[]
    | InstrumentCommandUpsertWithWhereUniqueNestedInput;
  delete?:
    | InstrumentCommandWhereUniqueInput[]
    | InstrumentCommandWhereUniqueInput;
  connect?:
    | InstrumentCommandWhereUniqueInput[]
    | InstrumentCommandWhereUniqueInput;
  set?: InstrumentCommandWhereUniqueInput[] | InstrumentCommandWhereUniqueInput;
  disconnect?:
    | InstrumentCommandWhereUniqueInput[]
    | InstrumentCommandWhereUniqueInput;
  deleteMany?:
    | InstrumentCommandScalarWhereInput[]
    | InstrumentCommandScalarWhereInput;
  updateMany?:
    | InstrumentCommandUpdateManyWithWhereNestedInput[]
    | InstrumentCommandUpdateManyWithWhereNestedInput;
}

export interface InstrumentCommandUpdateWithWhereUniqueNestedInput {
  where: InstrumentCommandWhereUniqueInput;
  data: InstrumentCommandUpdateDataInput;
}

export interface InstrumentCommandUpdateDataInput {
  tag?: String;
  name?: String;
  description?: String;
  instrument?: InstrumentUpdateOneRequiredWithoutCommandsInput;
  readString?: String;
  writeString?: String;
  parameters?: InstrumentParameterUpdateManyInput;
}

export interface InstrumentUpdateOneRequiredWithoutCommandsInput {
  create?: InstrumentCreateWithoutCommandsInput;
  update?: InstrumentUpdateWithoutCommandsDataInput;
  upsert?: InstrumentUpsertWithoutCommandsInput;
  connect?: InstrumentWhereUniqueInput;
}

export interface InstrumentUpdateWithoutCommandsDataInput {
  name?: String;
  description?: String;
  documents?: FileUpdateManyInput;
  interfaces?: InstrumentUpdateinterfacesInput;
  parameters?: InstrumentParameterUpdateManyInput;
  subsystems?: InstrumentSubsystemUpdateManyInput;
}

export interface InstrumentUpsertWithoutCommandsInput {
  update: InstrumentUpdateWithoutCommandsDataInput;
  create: InstrumentCreateWithoutCommandsInput;
}

export interface InstrumentCommandUpsertWithWhereUniqueNestedInput {
  where: InstrumentCommandWhereUniqueInput;
  update: InstrumentCommandUpdateDataInput;
  create: InstrumentCommandCreateInput;
}

export interface InstrumentSubsystemUpsertWithWhereUniqueNestedInput {
  where: InstrumentSubsystemWhereUniqueInput;
  update: InstrumentSubsystemUpdateDataInput;
  create: InstrumentSubsystemCreateInput;
}

export interface InstrumentSubsystemScalarWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  description?: String;
  description_not?: String;
  description_in?: String[] | String;
  description_not_in?: String[] | String;
  description_lt?: String;
  description_lte?: String;
  description_gt?: String;
  description_gte?: String;
  description_contains?: String;
  description_not_contains?: String;
  description_starts_with?: String;
  description_not_starts_with?: String;
  description_ends_with?: String;
  description_not_ends_with?: String;
  AND?:
    | InstrumentSubsystemScalarWhereInput[]
    | InstrumentSubsystemScalarWhereInput;
  OR?:
    | InstrumentSubsystemScalarWhereInput[]
    | InstrumentSubsystemScalarWhereInput;
  NOT?:
    | InstrumentSubsystemScalarWhereInput[]
    | InstrumentSubsystemScalarWhereInput;
}

export interface InstrumentSubsystemUpdateManyWithWhereNestedInput {
  where: InstrumentSubsystemScalarWhereInput;
  data: InstrumentSubsystemUpdateManyDataInput;
}

export interface InstrumentSubsystemUpdateManyDataInput {
  name?: String;
  description?: String;
}

export interface InstrumentUpsertNestedInput {
  update: InstrumentUpdateDataInput;
  create: InstrumentCreateInput;
}

export interface InstrumentInstanceUpdateinterfaceInput {
  set?: String[] | String;
}

export interface InstrumentInstanceUpsertWithWhereUniqueNestedInput {
  where: InstrumentInstanceWhereUniqueInput;
  update: InstrumentInstanceUpdateDataInput;
  create: InstrumentInstanceCreateInput;
}

export interface InstrumentInstanceScalarWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  identifier?: String;
  identifier_not?: String;
  identifier_in?: String[] | String;
  identifier_not_in?: String[] | String;
  identifier_lt?: String;
  identifier_lte?: String;
  identifier_gt?: String;
  identifier_gte?: String;
  identifier_contains?: String;
  identifier_not_contains?: String;
  identifier_starts_with?: String;
  identifier_not_starts_with?: String;
  identifier_ends_with?: String;
  identifier_not_ends_with?: String;
  label?: String;
  label_not?: String;
  label_in?: String[] | String;
  label_not_in?: String[] | String;
  label_lt?: String;
  label_lte?: String;
  label_gt?: String;
  label_gte?: String;
  label_contains?: String;
  label_not_contains?: String;
  label_starts_with?: String;
  label_not_starts_with?: String;
  label_ends_with?: String;
  label_not_ends_with?: String;
  location?: String;
  location_not?: String;
  location_in?: String[] | String;
  location_not_in?: String[] | String;
  location_lt?: String;
  location_lte?: String;
  location_gt?: String;
  location_gte?: String;
  location_contains?: String;
  location_not_contains?: String;
  location_starts_with?: String;
  location_not_starts_with?: String;
  location_ends_with?: String;
  location_not_ends_with?: String;
  AND?:
    | InstrumentInstanceScalarWhereInput[]
    | InstrumentInstanceScalarWhereInput;
  OR?:
    | InstrumentInstanceScalarWhereInput[]
    | InstrumentInstanceScalarWhereInput;
  NOT?:
    | InstrumentInstanceScalarWhereInput[]
    | InstrumentInstanceScalarWhereInput;
}

export interface InstrumentInstanceUpdateManyWithWhereNestedInput {
  where: InstrumentInstanceScalarWhereInput;
  data: InstrumentInstanceUpdateManyDataInput;
}

export interface InstrumentInstanceUpdateManyDataInput {
  identifier?: String;
  interface?: InstrumentInstanceUpdateinterfaceInput;
  label?: String;
  location?: String;
}

export interface SetupUpsertNestedInput {
  update: SetupUpdateDataInput;
  create: SetupCreateInput;
}

export interface MeasurementRunUpsertWithWhereUniqueNestedInput {
  where: MeasurementRunWhereUniqueInput;
  update: MeasurementRunUpdateDataInput;
  create: MeasurementRunCreateInput;
}

export interface MeasurementRunScalarWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  location?: String;
  location_not?: String;
  location_in?: String[] | String;
  location_not_in?: String[] | String;
  location_lt?: String;
  location_lte?: String;
  location_gt?: String;
  location_gte?: String;
  location_contains?: String;
  location_not_contains?: String;
  location_starts_with?: String;
  location_not_starts_with?: String;
  location_ends_with?: String;
  location_not_ends_with?: String;
  temperature?: Float;
  temperature_not?: Float;
  temperature_in?: Float[] | Float;
  temperature_not_in?: Float[] | Float;
  temperature_lt?: Float;
  temperature_lte?: Float;
  temperature_gt?: Float;
  temperature_gte?: Float;
  startTime?: DateTimeInput;
  startTime_not?: DateTimeInput;
  startTime_in?: DateTimeInput[] | DateTimeInput;
  startTime_not_in?: DateTimeInput[] | DateTimeInput;
  startTime_lt?: DateTimeInput;
  startTime_lte?: DateTimeInput;
  startTime_gt?: DateTimeInput;
  startTime_gte?: DateTimeInput;
  endTime?: DateTimeInput;
  endTime_not?: DateTimeInput;
  endTime_in?: DateTimeInput[] | DateTimeInput;
  endTime_not_in?: DateTimeInput[] | DateTimeInput;
  endTime_lt?: DateTimeInput;
  endTime_lte?: DateTimeInput;
  endTime_gt?: DateTimeInput;
  endTime_gte?: DateTimeInput;
  AND?: MeasurementRunScalarWhereInput[] | MeasurementRunScalarWhereInput;
  OR?: MeasurementRunScalarWhereInput[] | MeasurementRunScalarWhereInput;
  NOT?: MeasurementRunScalarWhereInput[] | MeasurementRunScalarWhereInput;
}

export interface MeasurementRunUpdateManyWithWhereNestedInput {
  where: MeasurementRunScalarWhereInput;
  data: MeasurementRunUpdateManyDataInput;
}

export interface MeasurementRunUpdateManyDataInput {
  name?: String;
  location?: String;
  temperature?: Float;
  startTime?: DateTimeInput;
  endTime?: DateTimeInput;
}

export interface CharacterizationUpdateManyMutationInput {
  name?: String;
}

export interface CommentUpdateInput {
  text?: String;
  previousVersion?: CommentUpdateOneInput;
}

export interface CommentUpdateManyMutationInput {
  text?: String;
}

export interface DUTCreateInput {
  name: String;
  description?: String;
  project: ProjectVersionCreateOneInput;
  modifications?: DUTCreatemodificationsInput;
}

export interface DUTCreatemodificationsInput {
  set?: String[] | String;
}

export interface DUTUpdateInput {
  name?: String;
  description?: String;
  project?: ProjectVersionUpdateOneRequiredInput;
  modifications?: DUTUpdatemodificationsInput;
}

export interface DUTUpdatemodificationsInput {
  set?: String[] | String;
}

export interface DUTUpdateManyMutationInput {
  name?: String;
  description?: String;
  modifications?: DUTUpdatemodificationsInput;
}

export interface EventUpdateInput {
  json?: String;
  when?: DateTimeInput;
}

export interface EventUpdateManyMutationInput {
  json?: String;
  when?: DateTimeInput;
}

export interface FileUpdateInput {
  path?: String;
  name?: String;
  description?: String;
  filename?: String;
  mimetype?: String;
  size?: Int;
}

export interface FileUpdateManyMutationInput {
  path?: String;
  name?: String;
  description?: String;
  filename?: String;
  mimetype?: String;
  size?: Int;
}

export interface InstrumentUpdateInput {
  name?: String;
  description?: String;
  documents?: FileUpdateManyInput;
  interfaces?: InstrumentUpdateinterfacesInput;
  commands?: InstrumentCommandUpdateManyWithoutInstrumentInput;
  parameters?: InstrumentParameterUpdateManyInput;
  subsystems?: InstrumentSubsystemUpdateManyInput;
}

export interface InstrumentUpdateManyMutationInput {
  name?: String;
  description?: String;
  interfaces?: InstrumentUpdateinterfacesInput;
}

export interface InstrumentCommandUpdateInput {
  tag?: String;
  name?: String;
  description?: String;
  instrument?: InstrumentUpdateOneRequiredWithoutCommandsInput;
  readString?: String;
  writeString?: String;
  parameters?: InstrumentParameterUpdateManyInput;
}

export interface InstrumentCommandUpdateManyMutationInput {
  tag?: String;
  name?: String;
  description?: String;
  readString?: String;
  writeString?: String;
}

export interface InstrumentInstanceUpdateInput {
  instrument?: InstrumentUpdateOneRequiredInput;
  identifier?: String;
  interface?: InstrumentInstanceUpdateinterfaceInput;
  label?: String;
  location?: String;
}

export interface InstrumentInstanceUpdateManyMutationInput {
  identifier?: String;
  interface?: InstrumentInstanceUpdateinterfaceInput;
  label?: String;
  location?: String;
}

export interface InstrumentParameterUpdateInput {
  tag?: String;
  name?: String;
  description?: String;
  type?: String;
  values?: String;
}

export interface InstrumentParameterUpdateManyMutationInput {
  tag?: String;
  name?: String;
  description?: String;
  type?: String;
  values?: String;
}

export interface InstrumentSubsystemUpdateInput {
  name?: String;
  description?: String;
  commands?: InstrumentCommandUpdateManyInput;
  parameters?: InstrumentParameterUpdateManyInput;
  subsystems?: InstrumentSubsystemUpdateManyInput;
}

export interface InstrumentSubsystemUpdateManyMutationInput {
  name?: String;
  description?: String;
}

export interface MeasurementUpdateInput {
  intValue?: Int;
  floatValue?: Float;
  stringValue?: String;
}

export interface MeasurementUpdateManyMutationInput {
  intValue?: Int;
  floatValue?: Float;
  stringValue?: String;
}

export interface MeasurementRunUpdateInput {
  name?: String;
  operators?: UserUpdateManyInput;
  location?: String;
  temperature?: Float;
  startTime?: DateTimeInput;
  endTime?: DateTimeInput;
  log?: EventUpdateManyInput;
  comments?: CommentUpdateManyInput;
  measurements?: MeasurementUpdateManyInput;
  setup?: SetupUpdateOneRequiredInput;
}

export interface MeasurementRunUpdateManyMutationInput {
  name?: String;
  location?: String;
  temperature?: Float;
  startTime?: DateTimeInput;
  endTime?: DateTimeInput;
}

export interface MetaCreateInput {
  key: String;
  value: String;
}

export interface MetaUpdateInput {
  key?: String;
  value?: String;
}

export interface MetaUpdateManyMutationInput {
  key?: String;
  value?: String;
}

export interface ProjectCreateInput {
  name: String;
  abbreviation: String;
  description?: String;
  files?: FileCreateManyInput;
  versions?: ProjectVersionCreateManyWithoutProjectInput;
}

export interface ProjectVersionCreateManyWithoutProjectInput {
  create?:
    | ProjectVersionCreateWithoutProjectInput[]
    | ProjectVersionCreateWithoutProjectInput;
  connect?: ProjectVersionWhereUniqueInput[] | ProjectVersionWhereUniqueInput;
}

export interface ProjectVersionCreateWithoutProjectInput {
  name: String;
  changes?: ProjectVersionCreatechangesInput;
  date: DateTimeInput;
}

export interface ProjectUpdateInput {
  name?: String;
  abbreviation?: String;
  description?: String;
  files?: FileUpdateManyInput;
  versions?: ProjectVersionUpdateManyWithoutProjectInput;
}

export interface ProjectVersionUpdateManyWithoutProjectInput {
  create?:
    | ProjectVersionCreateWithoutProjectInput[]
    | ProjectVersionCreateWithoutProjectInput;
  delete?: ProjectVersionWhereUniqueInput[] | ProjectVersionWhereUniqueInput;
  connect?: ProjectVersionWhereUniqueInput[] | ProjectVersionWhereUniqueInput;
  set?: ProjectVersionWhereUniqueInput[] | ProjectVersionWhereUniqueInput;
  disconnect?:
    | ProjectVersionWhereUniqueInput[]
    | ProjectVersionWhereUniqueInput;
  update?:
    | ProjectVersionUpdateWithWhereUniqueWithoutProjectInput[]
    | ProjectVersionUpdateWithWhereUniqueWithoutProjectInput;
  upsert?:
    | ProjectVersionUpsertWithWhereUniqueWithoutProjectInput[]
    | ProjectVersionUpsertWithWhereUniqueWithoutProjectInput;
  deleteMany?:
    | ProjectVersionScalarWhereInput[]
    | ProjectVersionScalarWhereInput;
  updateMany?:
    | ProjectVersionUpdateManyWithWhereNestedInput[]
    | ProjectVersionUpdateManyWithWhereNestedInput;
}

export interface ProjectVersionUpdateWithWhereUniqueWithoutProjectInput {
  where: ProjectVersionWhereUniqueInput;
  data: ProjectVersionUpdateWithoutProjectDataInput;
}

export interface ProjectVersionUpdateWithoutProjectDataInput {
  name?: String;
  changes?: ProjectVersionUpdatechangesInput;
  date?: DateTimeInput;
}

export interface ProjectVersionUpsertWithWhereUniqueWithoutProjectInput {
  where: ProjectVersionWhereUniqueInput;
  update: ProjectVersionUpdateWithoutProjectDataInput;
  create: ProjectVersionCreateWithoutProjectInput;
}

export interface ProjectVersionScalarWhereInput {
  id?: ID_Input;
  id_not?: ID_Input;
  id_in?: ID_Input[] | ID_Input;
  id_not_in?: ID_Input[] | ID_Input;
  id_lt?: ID_Input;
  id_lte?: ID_Input;
  id_gt?: ID_Input;
  id_gte?: ID_Input;
  id_contains?: ID_Input;
  id_not_contains?: ID_Input;
  id_starts_with?: ID_Input;
  id_not_starts_with?: ID_Input;
  id_ends_with?: ID_Input;
  id_not_ends_with?: ID_Input;
  name?: String;
  name_not?: String;
  name_in?: String[] | String;
  name_not_in?: String[] | String;
  name_lt?: String;
  name_lte?: String;
  name_gt?: String;
  name_gte?: String;
  name_contains?: String;
  name_not_contains?: String;
  name_starts_with?: String;
  name_not_starts_with?: String;
  name_ends_with?: String;
  name_not_ends_with?: String;
  date?: DateTimeInput;
  date_not?: DateTimeInput;
  date_in?: DateTimeInput[] | DateTimeInput;
  date_not_in?: DateTimeInput[] | DateTimeInput;
  date_lt?: DateTimeInput;
  date_lte?: DateTimeInput;
  date_gt?: DateTimeInput;
  date_gte?: DateTimeInput;
  AND?: ProjectVersionScalarWhereInput[] | ProjectVersionScalarWhereInput;
  OR?: ProjectVersionScalarWhereInput[] | ProjectVersionScalarWhereInput;
  NOT?: ProjectVersionScalarWhereInput[] | ProjectVersionScalarWhereInput;
}

export interface ProjectVersionUpdateManyWithWhereNestedInput {
  where: ProjectVersionScalarWhereInput;
  data: ProjectVersionUpdateManyDataInput;
}

export interface ProjectVersionUpdateManyDataInput {
  name?: String;
  changes?: ProjectVersionUpdatechangesInput;
  date?: DateTimeInput;
}

export interface ProjectUpdateManyMutationInput {
  name?: String;
  abbreviation?: String;
  description?: String;
}

export interface ProjectVersionUpdateInput {
  name?: String;
  changes?: ProjectVersionUpdatechangesInput;
  date?: DateTimeInput;
  project?: ProjectUpdateOneRequiredWithoutVersionsInput;
}

export interface ProjectVersionUpdateManyMutationInput {
  name?: String;
  changes?: ProjectVersionUpdatechangesInput;
  date?: DateTimeInput;
}

export interface SetupUpdateInput {
  name?: String;
  description?: String;
  images?: FileUpdateManyInput;
  comments?: CommentUpdateManyInput;
  setupHardware?: SetupHardwareInstanceUpdateManyInput;
  instruments?: InstrumentInstanceUpdateManyInput;
}

export interface SetupUpdateManyMutationInput {
  name?: String;
  description?: String;
}

export interface SetupHardwareUpdateInput {
  name?: String;
  description?: String;
  images?: FileUpdateManyInput;
}

export interface SetupHardwareUpdateManyMutationInput {
  name?: String;
  description?: String;
}

export interface SetupHardwareInstanceUpdateInput {
  setupHardware?: SetupHardwareUpdateOneRequiredInput;
  identifier?: String;
  images?: FileUpdateManyInput;
}

export interface SetupHardwareInstanceUpdateManyMutationInput {
  identifier?: String;
}

export interface UserUpdateInput {
  email?: String;
  name?: String;
  abbreviation?: String;
  password?: String;
  images?: FileUpdateManyInput;
}

export interface UserUpdateManyMutationInput {
  email?: String;
  name?: String;
  abbreviation?: String;
  password?: String;
}

export interface CharacterizationSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: CharacterizationWhereInput;
  AND?:
    | CharacterizationSubscriptionWhereInput[]
    | CharacterizationSubscriptionWhereInput;
  OR?:
    | CharacterizationSubscriptionWhereInput[]
    | CharacterizationSubscriptionWhereInput;
  NOT?:
    | CharacterizationSubscriptionWhereInput[]
    | CharacterizationSubscriptionWhereInput;
}

export interface CommentSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: CommentWhereInput;
  AND?: CommentSubscriptionWhereInput[] | CommentSubscriptionWhereInput;
  OR?: CommentSubscriptionWhereInput[] | CommentSubscriptionWhereInput;
  NOT?: CommentSubscriptionWhereInput[] | CommentSubscriptionWhereInput;
}

export interface DUTSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: DUTWhereInput;
  AND?: DUTSubscriptionWhereInput[] | DUTSubscriptionWhereInput;
  OR?: DUTSubscriptionWhereInput[] | DUTSubscriptionWhereInput;
  NOT?: DUTSubscriptionWhereInput[] | DUTSubscriptionWhereInput;
}

export interface EventSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: EventWhereInput;
  AND?: EventSubscriptionWhereInput[] | EventSubscriptionWhereInput;
  OR?: EventSubscriptionWhereInput[] | EventSubscriptionWhereInput;
  NOT?: EventSubscriptionWhereInput[] | EventSubscriptionWhereInput;
}

export interface FileSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: FileWhereInput;
  AND?: FileSubscriptionWhereInput[] | FileSubscriptionWhereInput;
  OR?: FileSubscriptionWhereInput[] | FileSubscriptionWhereInput;
  NOT?: FileSubscriptionWhereInput[] | FileSubscriptionWhereInput;
}

export interface InstrumentSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: InstrumentWhereInput;
  AND?: InstrumentSubscriptionWhereInput[] | InstrumentSubscriptionWhereInput;
  OR?: InstrumentSubscriptionWhereInput[] | InstrumentSubscriptionWhereInput;
  NOT?: InstrumentSubscriptionWhereInput[] | InstrumentSubscriptionWhereInput;
}

export interface InstrumentCommandSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: InstrumentCommandWhereInput;
  AND?:
    | InstrumentCommandSubscriptionWhereInput[]
    | InstrumentCommandSubscriptionWhereInput;
  OR?:
    | InstrumentCommandSubscriptionWhereInput[]
    | InstrumentCommandSubscriptionWhereInput;
  NOT?:
    | InstrumentCommandSubscriptionWhereInput[]
    | InstrumentCommandSubscriptionWhereInput;
}

export interface InstrumentInstanceSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: InstrumentInstanceWhereInput;
  AND?:
    | InstrumentInstanceSubscriptionWhereInput[]
    | InstrumentInstanceSubscriptionWhereInput;
  OR?:
    | InstrumentInstanceSubscriptionWhereInput[]
    | InstrumentInstanceSubscriptionWhereInput;
  NOT?:
    | InstrumentInstanceSubscriptionWhereInput[]
    | InstrumentInstanceSubscriptionWhereInput;
}

export interface InstrumentParameterSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: InstrumentParameterWhereInput;
  AND?:
    | InstrumentParameterSubscriptionWhereInput[]
    | InstrumentParameterSubscriptionWhereInput;
  OR?:
    | InstrumentParameterSubscriptionWhereInput[]
    | InstrumentParameterSubscriptionWhereInput;
  NOT?:
    | InstrumentParameterSubscriptionWhereInput[]
    | InstrumentParameterSubscriptionWhereInput;
}

export interface InstrumentSubsystemSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: InstrumentSubsystemWhereInput;
  AND?:
    | InstrumentSubsystemSubscriptionWhereInput[]
    | InstrumentSubsystemSubscriptionWhereInput;
  OR?:
    | InstrumentSubsystemSubscriptionWhereInput[]
    | InstrumentSubsystemSubscriptionWhereInput;
  NOT?:
    | InstrumentSubsystemSubscriptionWhereInput[]
    | InstrumentSubsystemSubscriptionWhereInput;
}

export interface MeasurementSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: MeasurementWhereInput;
  AND?: MeasurementSubscriptionWhereInput[] | MeasurementSubscriptionWhereInput;
  OR?: MeasurementSubscriptionWhereInput[] | MeasurementSubscriptionWhereInput;
  NOT?: MeasurementSubscriptionWhereInput[] | MeasurementSubscriptionWhereInput;
}

export interface MeasurementRunSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: MeasurementRunWhereInput;
  AND?:
    | MeasurementRunSubscriptionWhereInput[]
    | MeasurementRunSubscriptionWhereInput;
  OR?:
    | MeasurementRunSubscriptionWhereInput[]
    | MeasurementRunSubscriptionWhereInput;
  NOT?:
    | MeasurementRunSubscriptionWhereInput[]
    | MeasurementRunSubscriptionWhereInput;
}

export interface MetaSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: MetaWhereInput;
  AND?: MetaSubscriptionWhereInput[] | MetaSubscriptionWhereInput;
  OR?: MetaSubscriptionWhereInput[] | MetaSubscriptionWhereInput;
  NOT?: MetaSubscriptionWhereInput[] | MetaSubscriptionWhereInput;
}

export interface ProjectSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: ProjectWhereInput;
  AND?: ProjectSubscriptionWhereInput[] | ProjectSubscriptionWhereInput;
  OR?: ProjectSubscriptionWhereInput[] | ProjectSubscriptionWhereInput;
  NOT?: ProjectSubscriptionWhereInput[] | ProjectSubscriptionWhereInput;
}

export interface ProjectVersionSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: ProjectVersionWhereInput;
  AND?:
    | ProjectVersionSubscriptionWhereInput[]
    | ProjectVersionSubscriptionWhereInput;
  OR?:
    | ProjectVersionSubscriptionWhereInput[]
    | ProjectVersionSubscriptionWhereInput;
  NOT?:
    | ProjectVersionSubscriptionWhereInput[]
    | ProjectVersionSubscriptionWhereInput;
}

export interface SetupSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: SetupWhereInput;
  AND?: SetupSubscriptionWhereInput[] | SetupSubscriptionWhereInput;
  OR?: SetupSubscriptionWhereInput[] | SetupSubscriptionWhereInput;
  NOT?: SetupSubscriptionWhereInput[] | SetupSubscriptionWhereInput;
}

export interface SetupHardwareSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: SetupHardwareWhereInput;
  AND?:
    | SetupHardwareSubscriptionWhereInput[]
    | SetupHardwareSubscriptionWhereInput;
  OR?:
    | SetupHardwareSubscriptionWhereInput[]
    | SetupHardwareSubscriptionWhereInput;
  NOT?:
    | SetupHardwareSubscriptionWhereInput[]
    | SetupHardwareSubscriptionWhereInput;
}

export interface SetupHardwareInstanceSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: SetupHardwareInstanceWhereInput;
  AND?:
    | SetupHardwareInstanceSubscriptionWhereInput[]
    | SetupHardwareInstanceSubscriptionWhereInput;
  OR?:
    | SetupHardwareInstanceSubscriptionWhereInput[]
    | SetupHardwareInstanceSubscriptionWhereInput;
  NOT?:
    | SetupHardwareInstanceSubscriptionWhereInput[]
    | SetupHardwareInstanceSubscriptionWhereInput;
}

export interface UserSubscriptionWhereInput {
  mutation_in?: MutationType[] | MutationType;
  updatedFields_contains?: String;
  updatedFields_contains_every?: String[] | String;
  updatedFields_contains_some?: String[] | String;
  node?: UserWhereInput;
  AND?: UserSubscriptionWhereInput[] | UserSubscriptionWhereInput;
  OR?: UserSubscriptionWhereInput[] | UserSubscriptionWhereInput;
  NOT?: UserSubscriptionWhereInput[] | UserSubscriptionWhereInput;
}

export interface NodeNode {
  id: ID_Output;
}

export interface Characterization {
  id: ID_Output;
  name: String;
}

export interface CharacterizationPromise
  extends Promise<Characterization>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  projectVersion: <T = ProjectVersionPromise>() => T;
  measurementRuns: <T = FragmentableArray<MeasurementRun>>(
    args?: {
      where?: MeasurementRunWhereInput;
      orderBy?: MeasurementRunOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
}

export interface CharacterizationSubscription
  extends Promise<AsyncIterator<Characterization>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  projectVersion: <T = ProjectVersionSubscription>() => T;
  measurementRuns: <T = Promise<AsyncIterator<MeasurementRunSubscription>>>(
    args?: {
      where?: MeasurementRunWhereInput;
      orderBy?: MeasurementRunOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
}

export interface ProjectVersion {
  id: ID_Output;
  name: String;
  changes: String[];
  date: DateTimeOutput;
}

export interface ProjectVersionPromise
  extends Promise<ProjectVersion>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  changes: () => Promise<String[]>;
  date: () => Promise<DateTimeOutput>;
  project: <T = ProjectPromise>() => T;
}

export interface ProjectVersionSubscription
  extends Promise<AsyncIterator<ProjectVersion>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  changes: () => Promise<AsyncIterator<String[]>>;
  date: () => Promise<AsyncIterator<DateTimeOutput>>;
  project: <T = ProjectSubscription>() => T;
}

export interface Project {
  id: ID_Output;
  name: String;
  abbreviation: String;
  description?: String;
}

export interface ProjectPromise extends Promise<Project>, Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  abbreviation: () => Promise<String>;
  description: () => Promise<String>;
  files: <T = FragmentableArray<File>>(
    args?: {
      where?: FileWhereInput;
      orderBy?: FileOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  versions: <T = FragmentableArray<ProjectVersion>>(
    args?: {
      where?: ProjectVersionWhereInput;
      orderBy?: ProjectVersionOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
}

export interface ProjectSubscription
  extends Promise<AsyncIterator<Project>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  abbreviation: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  files: <T = Promise<AsyncIterator<FileSubscription>>>(
    args?: {
      where?: FileWhereInput;
      orderBy?: FileOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  versions: <T = Promise<AsyncIterator<ProjectVersionSubscription>>>(
    args?: {
      where?: ProjectVersionWhereInput;
      orderBy?: ProjectVersionOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
}

export interface File {
  id: ID_Output;
  path: String;
  name?: String;
  description?: String;
  filename: String;
  mimetype: String;
  size: Int;
}

export interface FilePromise extends Promise<File>, Fragmentable {
  id: () => Promise<ID_Output>;
  path: () => Promise<String>;
  name: () => Promise<String>;
  description: () => Promise<String>;
  filename: () => Promise<String>;
  mimetype: () => Promise<String>;
  size: () => Promise<Int>;
}

export interface FileSubscription
  extends Promise<AsyncIterator<File>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  path: () => Promise<AsyncIterator<String>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  filename: () => Promise<AsyncIterator<String>>;
  mimetype: () => Promise<AsyncIterator<String>>;
  size: () => Promise<AsyncIterator<Int>>;
}

export interface MeasurementRun {
  id: ID_Output;
  name: String;
  location: String;
  temperature?: Float;
  startTime: DateTimeOutput;
  endTime: DateTimeOutput;
}

export interface MeasurementRunPromise
  extends Promise<MeasurementRun>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  operators: <T = FragmentableArray<User>>(
    args?: {
      where?: UserWhereInput;
      orderBy?: UserOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  location: () => Promise<String>;
  temperature: () => Promise<Float>;
  startTime: () => Promise<DateTimeOutput>;
  endTime: () => Promise<DateTimeOutput>;
  log: <T = FragmentableArray<Event>>(
    args?: {
      where?: EventWhereInput;
      orderBy?: EventOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  comments: <T = FragmentableArray<Comment>>(
    args?: {
      where?: CommentWhereInput;
      orderBy?: CommentOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  measurements: <T = FragmentableArray<Measurement>>(
    args?: {
      where?: MeasurementWhereInput;
      orderBy?: MeasurementOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  setup: <T = SetupPromise>() => T;
}

export interface MeasurementRunSubscription
  extends Promise<AsyncIterator<MeasurementRun>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  operators: <T = Promise<AsyncIterator<UserSubscription>>>(
    args?: {
      where?: UserWhereInput;
      orderBy?: UserOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  location: () => Promise<AsyncIterator<String>>;
  temperature: () => Promise<AsyncIterator<Float>>;
  startTime: () => Promise<AsyncIterator<DateTimeOutput>>;
  endTime: () => Promise<AsyncIterator<DateTimeOutput>>;
  log: <T = Promise<AsyncIterator<EventSubscription>>>(
    args?: {
      where?: EventWhereInput;
      orderBy?: EventOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  comments: <T = Promise<AsyncIterator<CommentSubscription>>>(
    args?: {
      where?: CommentWhereInput;
      orderBy?: CommentOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  measurements: <T = Promise<AsyncIterator<MeasurementSubscription>>>(
    args?: {
      where?: MeasurementWhereInput;
      orderBy?: MeasurementOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  setup: <T = SetupSubscription>() => T;
}

export interface User {
  id: ID_Output;
  email: String;
  name: String;
  abbreviation: String;
  password: String;
}

export interface UserPromise extends Promise<User>, Fragmentable {
  id: () => Promise<ID_Output>;
  email: () => Promise<String>;
  name: () => Promise<String>;
  abbreviation: () => Promise<String>;
  password: () => Promise<String>;
  images: <T = FragmentableArray<File>>(
    args?: {
      where?: FileWhereInput;
      orderBy?: FileOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
}

export interface UserSubscription
  extends Promise<AsyncIterator<User>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  email: () => Promise<AsyncIterator<String>>;
  name: () => Promise<AsyncIterator<String>>;
  abbreviation: () => Promise<AsyncIterator<String>>;
  password: () => Promise<AsyncIterator<String>>;
  images: <T = Promise<AsyncIterator<FileSubscription>>>(
    args?: {
      where?: FileWhereInput;
      orderBy?: FileOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
}

export interface Event {
  id: ID_Output;
  json: String;
  when: DateTimeOutput;
}

export interface EventPromise extends Promise<Event>, Fragmentable {
  id: () => Promise<ID_Output>;
  json: () => Promise<String>;
  when: () => Promise<DateTimeOutput>;
}

export interface EventSubscription
  extends Promise<AsyncIterator<Event>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  json: () => Promise<AsyncIterator<String>>;
  when: () => Promise<AsyncIterator<DateTimeOutput>>;
}

export interface Comment {
  id: ID_Output;
  text?: String;
  createdAt: DateTimeOutput;
}

export interface CommentPromise extends Promise<Comment>, Fragmentable {
  id: () => Promise<ID_Output>;
  text: () => Promise<String>;
  createdAt: () => Promise<DateTimeOutput>;
  previousVersion: <T = CommentPromise>() => T;
}

export interface CommentSubscription
  extends Promise<AsyncIterator<Comment>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  text: () => Promise<AsyncIterator<String>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  previousVersion: <T = CommentSubscription>() => T;
}

export interface Measurement {
  id: ID_Output;
  createdAt: DateTimeOutput;
  intValue?: Int;
  floatValue?: Float;
  stringValue?: String;
}

export interface MeasurementPromise extends Promise<Measurement>, Fragmentable {
  id: () => Promise<ID_Output>;
  createdAt: () => Promise<DateTimeOutput>;
  intValue: () => Promise<Int>;
  floatValue: () => Promise<Float>;
  stringValue: () => Promise<String>;
}

export interface MeasurementSubscription
  extends Promise<AsyncIterator<Measurement>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  intValue: () => Promise<AsyncIterator<Int>>;
  floatValue: () => Promise<AsyncIterator<Float>>;
  stringValue: () => Promise<AsyncIterator<String>>;
}

export interface Setup {
  id: ID_Output;
  name: String;
  description: String;
}

export interface SetupPromise extends Promise<Setup>, Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
  images: <T = FragmentableArray<File>>(
    args?: {
      where?: FileWhereInput;
      orderBy?: FileOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  comments: <T = FragmentableArray<Comment>>(
    args?: {
      where?: CommentWhereInput;
      orderBy?: CommentOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  setupHardware: <T = FragmentableArray<SetupHardwareInstance>>(
    args?: {
      where?: SetupHardwareInstanceWhereInput;
      orderBy?: SetupHardwareInstanceOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  instruments: <T = FragmentableArray<InstrumentInstance>>(
    args?: {
      where?: InstrumentInstanceWhereInput;
      orderBy?: InstrumentInstanceOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
}

export interface SetupSubscription
  extends Promise<AsyncIterator<Setup>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  images: <T = Promise<AsyncIterator<FileSubscription>>>(
    args?: {
      where?: FileWhereInput;
      orderBy?: FileOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  comments: <T = Promise<AsyncIterator<CommentSubscription>>>(
    args?: {
      where?: CommentWhereInput;
      orderBy?: CommentOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  setupHardware: <
    T = Promise<AsyncIterator<SetupHardwareInstanceSubscription>>
  >(
    args?: {
      where?: SetupHardwareInstanceWhereInput;
      orderBy?: SetupHardwareInstanceOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  instruments: <T = Promise<AsyncIterator<InstrumentInstanceSubscription>>>(
    args?: {
      where?: InstrumentInstanceWhereInput;
      orderBy?: InstrumentInstanceOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
}

export interface SetupHardwareInstance {
  id: ID_Output;
  identifier: String;
}

export interface SetupHardwareInstancePromise
  extends Promise<SetupHardwareInstance>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  setupHardware: <T = SetupHardwarePromise>() => T;
  identifier: () => Promise<String>;
  images: <T = FragmentableArray<File>>(
    args?: {
      where?: FileWhereInput;
      orderBy?: FileOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
}

export interface SetupHardwareInstanceSubscription
  extends Promise<AsyncIterator<SetupHardwareInstance>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  setupHardware: <T = SetupHardwareSubscription>() => T;
  identifier: () => Promise<AsyncIterator<String>>;
  images: <T = Promise<AsyncIterator<FileSubscription>>>(
    args?: {
      where?: FileWhereInput;
      orderBy?: FileOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
}

export interface SetupHardware {
  id: ID_Output;
  name: String;
  description?: String;
}

export interface SetupHardwarePromise
  extends Promise<SetupHardware>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
  images: <T = FragmentableArray<File>>(
    args?: {
      where?: FileWhereInput;
      orderBy?: FileOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
}

export interface SetupHardwareSubscription
  extends Promise<AsyncIterator<SetupHardware>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  images: <T = Promise<AsyncIterator<FileSubscription>>>(
    args?: {
      where?: FileWhereInput;
      orderBy?: FileOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
}

export interface InstrumentInstance {
  id: ID_Output;
  identifier: String;
  interface: String[];
  label?: String;
  location?: String;
}

export interface InstrumentInstancePromise
  extends Promise<InstrumentInstance>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  instrument: <T = InstrumentPromise>() => T;
  identifier: () => Promise<String>;
  interface: () => Promise<String[]>;
  label: () => Promise<String>;
  location: () => Promise<String>;
}

export interface InstrumentInstanceSubscription
  extends Promise<AsyncIterator<InstrumentInstance>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  instrument: <T = InstrumentSubscription>() => T;
  identifier: () => Promise<AsyncIterator<String>>;
  interface: () => Promise<AsyncIterator<String[]>>;
  label: () => Promise<AsyncIterator<String>>;
  location: () => Promise<AsyncIterator<String>>;
}

export interface Instrument {
  id: ID_Output;
  name: String;
  description?: String;
  interfaces: String[];
}

export interface InstrumentPromise extends Promise<Instrument>, Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
  documents: <T = FragmentableArray<File>>(
    args?: {
      where?: FileWhereInput;
      orderBy?: FileOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  interfaces: () => Promise<String[]>;
  commands: <T = FragmentableArray<InstrumentCommand>>(
    args?: {
      where?: InstrumentCommandWhereInput;
      orderBy?: InstrumentCommandOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  parameters: <T = FragmentableArray<InstrumentParameter>>(
    args?: {
      where?: InstrumentParameterWhereInput;
      orderBy?: InstrumentParameterOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  subsystems: <T = FragmentableArray<InstrumentSubsystem>>(
    args?: {
      where?: InstrumentSubsystemWhereInput;
      orderBy?: InstrumentSubsystemOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
}

export interface InstrumentSubscription
  extends Promise<AsyncIterator<Instrument>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  documents: <T = Promise<AsyncIterator<FileSubscription>>>(
    args?: {
      where?: FileWhereInput;
      orderBy?: FileOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  interfaces: () => Promise<AsyncIterator<String[]>>;
  commands: <T = Promise<AsyncIterator<InstrumentCommandSubscription>>>(
    args?: {
      where?: InstrumentCommandWhereInput;
      orderBy?: InstrumentCommandOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  parameters: <T = Promise<AsyncIterator<InstrumentParameterSubscription>>>(
    args?: {
      where?: InstrumentParameterWhereInput;
      orderBy?: InstrumentParameterOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  subsystems: <T = Promise<AsyncIterator<InstrumentSubsystemSubscription>>>(
    args?: {
      where?: InstrumentSubsystemWhereInput;
      orderBy?: InstrumentSubsystemOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
}

export interface InstrumentCommand {
  id: ID_Output;
  tag: String;
  name?: String;
  description: String;
  readString?: String;
  writeString?: String;
}

export interface InstrumentCommandPromise
  extends Promise<InstrumentCommand>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  tag: () => Promise<String>;
  name: () => Promise<String>;
  description: () => Promise<String>;
  instrument: <T = InstrumentPromise>() => T;
  readString: () => Promise<String>;
  writeString: () => Promise<String>;
  parameters: <T = FragmentableArray<InstrumentParameter>>(
    args?: {
      where?: InstrumentParameterWhereInput;
      orderBy?: InstrumentParameterOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
}

export interface InstrumentCommandSubscription
  extends Promise<AsyncIterator<InstrumentCommand>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  tag: () => Promise<AsyncIterator<String>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  instrument: <T = InstrumentSubscription>() => T;
  readString: () => Promise<AsyncIterator<String>>;
  writeString: () => Promise<AsyncIterator<String>>;
  parameters: <T = Promise<AsyncIterator<InstrumentParameterSubscription>>>(
    args?: {
      where?: InstrumentParameterWhereInput;
      orderBy?: InstrumentParameterOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
}

export interface InstrumentParameter {
  id: ID_Output;
  tag: String;
  name?: String;
  description?: String;
  type: String;
  values?: String;
}

export interface InstrumentParameterPromise
  extends Promise<InstrumentParameter>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  tag: () => Promise<String>;
  name: () => Promise<String>;
  description: () => Promise<String>;
  type: () => Promise<String>;
  values: () => Promise<String>;
}

export interface InstrumentParameterSubscription
  extends Promise<AsyncIterator<InstrumentParameter>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  tag: () => Promise<AsyncIterator<String>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  type: () => Promise<AsyncIterator<String>>;
  values: () => Promise<AsyncIterator<String>>;
}

export interface InstrumentSubsystem {
  id: ID_Output;
  name?: String;
  description: String;
}

export interface InstrumentSubsystemPromise
  extends Promise<InstrumentSubsystem>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
  commands: <T = FragmentableArray<InstrumentCommand>>(
    args?: {
      where?: InstrumentCommandWhereInput;
      orderBy?: InstrumentCommandOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  parameters: <T = FragmentableArray<InstrumentParameter>>(
    args?: {
      where?: InstrumentParameterWhereInput;
      orderBy?: InstrumentParameterOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  subsystems: <T = FragmentableArray<InstrumentSubsystem>>(
    args?: {
      where?: InstrumentSubsystemWhereInput;
      orderBy?: InstrumentSubsystemOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
}

export interface InstrumentSubsystemSubscription
  extends Promise<AsyncIterator<InstrumentSubsystem>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  commands: <T = Promise<AsyncIterator<InstrumentCommandSubscription>>>(
    args?: {
      where?: InstrumentCommandWhereInput;
      orderBy?: InstrumentCommandOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  parameters: <T = Promise<AsyncIterator<InstrumentParameterSubscription>>>(
    args?: {
      where?: InstrumentParameterWhereInput;
      orderBy?: InstrumentParameterOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
  subsystems: <T = Promise<AsyncIterator<InstrumentSubsystemSubscription>>>(
    args?: {
      where?: InstrumentSubsystemWhereInput;
      orderBy?: InstrumentSubsystemOrderByInput;
      skip?: Int;
      after?: String;
      before?: String;
      first?: Int;
      last?: Int;
    }
  ) => T;
}

export interface CharacterizationConnection {
  pageInfo: PageInfo;
  edges: CharacterizationEdge[];
}

export interface CharacterizationConnectionPromise
  extends Promise<CharacterizationConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<CharacterizationEdge>>() => T;
  aggregate: <T = AggregateCharacterizationPromise>() => T;
}

export interface CharacterizationConnectionSubscription
  extends Promise<AsyncIterator<CharacterizationConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<CharacterizationEdgeSubscription>>>() => T;
  aggregate: <T = AggregateCharacterizationSubscription>() => T;
}

export interface PageInfo {
  hasNextPage: Boolean;
  hasPreviousPage: Boolean;
  startCursor?: String;
  endCursor?: String;
}

export interface PageInfoPromise extends Promise<PageInfo>, Fragmentable {
  hasNextPage: () => Promise<Boolean>;
  hasPreviousPage: () => Promise<Boolean>;
  startCursor: () => Promise<String>;
  endCursor: () => Promise<String>;
}

export interface PageInfoSubscription
  extends Promise<AsyncIterator<PageInfo>>,
    Fragmentable {
  hasNextPage: () => Promise<AsyncIterator<Boolean>>;
  hasPreviousPage: () => Promise<AsyncIterator<Boolean>>;
  startCursor: () => Promise<AsyncIterator<String>>;
  endCursor: () => Promise<AsyncIterator<String>>;
}

export interface CharacterizationEdge {
  node: Characterization;
  cursor: String;
}

export interface CharacterizationEdgePromise
  extends Promise<CharacterizationEdge>,
    Fragmentable {
  node: <T = CharacterizationPromise>() => T;
  cursor: () => Promise<String>;
}

export interface CharacterizationEdgeSubscription
  extends Promise<AsyncIterator<CharacterizationEdge>>,
    Fragmentable {
  node: <T = CharacterizationSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateCharacterization {
  count: Int;
}

export interface AggregateCharacterizationPromise
  extends Promise<AggregateCharacterization>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateCharacterizationSubscription
  extends Promise<AsyncIterator<AggregateCharacterization>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface CommentConnection {
  pageInfo: PageInfo;
  edges: CommentEdge[];
}

export interface CommentConnectionPromise
  extends Promise<CommentConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<CommentEdge>>() => T;
  aggregate: <T = AggregateCommentPromise>() => T;
}

export interface CommentConnectionSubscription
  extends Promise<AsyncIterator<CommentConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<CommentEdgeSubscription>>>() => T;
  aggregate: <T = AggregateCommentSubscription>() => T;
}

export interface CommentEdge {
  node: Comment;
  cursor: String;
}

export interface CommentEdgePromise extends Promise<CommentEdge>, Fragmentable {
  node: <T = CommentPromise>() => T;
  cursor: () => Promise<String>;
}

export interface CommentEdgeSubscription
  extends Promise<AsyncIterator<CommentEdge>>,
    Fragmentable {
  node: <T = CommentSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateComment {
  count: Int;
}

export interface AggregateCommentPromise
  extends Promise<AggregateComment>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateCommentSubscription
  extends Promise<AsyncIterator<AggregateComment>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface DUT {
  id: ID_Output;
  name: String;
  description?: String;
  modifications: String[];
}

export interface DUTPromise extends Promise<DUT>, Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
  project: <T = ProjectVersionPromise>() => T;
  modifications: () => Promise<String[]>;
}

export interface DUTSubscription
  extends Promise<AsyncIterator<DUT>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  project: <T = ProjectVersionSubscription>() => T;
  modifications: () => Promise<AsyncIterator<String[]>>;
}

export interface DUTConnection {
  pageInfo: PageInfo;
  edges: DUTEdge[];
}

export interface DUTConnectionPromise
  extends Promise<DUTConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<DUTEdge>>() => T;
  aggregate: <T = AggregateDUTPromise>() => T;
}

export interface DUTConnectionSubscription
  extends Promise<AsyncIterator<DUTConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<DUTEdgeSubscription>>>() => T;
  aggregate: <T = AggregateDUTSubscription>() => T;
}

export interface DUTEdge {
  node: DUT;
  cursor: String;
}

export interface DUTEdgePromise extends Promise<DUTEdge>, Fragmentable {
  node: <T = DUTPromise>() => T;
  cursor: () => Promise<String>;
}

export interface DUTEdgeSubscription
  extends Promise<AsyncIterator<DUTEdge>>,
    Fragmentable {
  node: <T = DUTSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateDUT {
  count: Int;
}

export interface AggregateDUTPromise
  extends Promise<AggregateDUT>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateDUTSubscription
  extends Promise<AsyncIterator<AggregateDUT>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface EventConnection {
  pageInfo: PageInfo;
  edges: EventEdge[];
}

export interface EventConnectionPromise
  extends Promise<EventConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<EventEdge>>() => T;
  aggregate: <T = AggregateEventPromise>() => T;
}

export interface EventConnectionSubscription
  extends Promise<AsyncIterator<EventConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<EventEdgeSubscription>>>() => T;
  aggregate: <T = AggregateEventSubscription>() => T;
}

export interface EventEdge {
  node: Event;
  cursor: String;
}

export interface EventEdgePromise extends Promise<EventEdge>, Fragmentable {
  node: <T = EventPromise>() => T;
  cursor: () => Promise<String>;
}

export interface EventEdgeSubscription
  extends Promise<AsyncIterator<EventEdge>>,
    Fragmentable {
  node: <T = EventSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateEvent {
  count: Int;
}

export interface AggregateEventPromise
  extends Promise<AggregateEvent>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateEventSubscription
  extends Promise<AsyncIterator<AggregateEvent>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface FileConnection {
  pageInfo: PageInfo;
  edges: FileEdge[];
}

export interface FileConnectionPromise
  extends Promise<FileConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<FileEdge>>() => T;
  aggregate: <T = AggregateFilePromise>() => T;
}

export interface FileConnectionSubscription
  extends Promise<AsyncIterator<FileConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<FileEdgeSubscription>>>() => T;
  aggregate: <T = AggregateFileSubscription>() => T;
}

export interface FileEdge {
  node: File;
  cursor: String;
}

export interface FileEdgePromise extends Promise<FileEdge>, Fragmentable {
  node: <T = FilePromise>() => T;
  cursor: () => Promise<String>;
}

export interface FileEdgeSubscription
  extends Promise<AsyncIterator<FileEdge>>,
    Fragmentable {
  node: <T = FileSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateFile {
  count: Int;
}

export interface AggregateFilePromise
  extends Promise<AggregateFile>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateFileSubscription
  extends Promise<AsyncIterator<AggregateFile>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface InstrumentConnection {
  pageInfo: PageInfo;
  edges: InstrumentEdge[];
}

export interface InstrumentConnectionPromise
  extends Promise<InstrumentConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<InstrumentEdge>>() => T;
  aggregate: <T = AggregateInstrumentPromise>() => T;
}

export interface InstrumentConnectionSubscription
  extends Promise<AsyncIterator<InstrumentConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<InstrumentEdgeSubscription>>>() => T;
  aggregate: <T = AggregateInstrumentSubscription>() => T;
}

export interface InstrumentEdge {
  node: Instrument;
  cursor: String;
}

export interface InstrumentEdgePromise
  extends Promise<InstrumentEdge>,
    Fragmentable {
  node: <T = InstrumentPromise>() => T;
  cursor: () => Promise<String>;
}

export interface InstrumentEdgeSubscription
  extends Promise<AsyncIterator<InstrumentEdge>>,
    Fragmentable {
  node: <T = InstrumentSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateInstrument {
  count: Int;
}

export interface AggregateInstrumentPromise
  extends Promise<AggregateInstrument>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateInstrumentSubscription
  extends Promise<AsyncIterator<AggregateInstrument>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface InstrumentCommandConnection {
  pageInfo: PageInfo;
  edges: InstrumentCommandEdge[];
}

export interface InstrumentCommandConnectionPromise
  extends Promise<InstrumentCommandConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<InstrumentCommandEdge>>() => T;
  aggregate: <T = AggregateInstrumentCommandPromise>() => T;
}

export interface InstrumentCommandConnectionSubscription
  extends Promise<AsyncIterator<InstrumentCommandConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<InstrumentCommandEdgeSubscription>>>() => T;
  aggregate: <T = AggregateInstrumentCommandSubscription>() => T;
}

export interface InstrumentCommandEdge {
  node: InstrumentCommand;
  cursor: String;
}

export interface InstrumentCommandEdgePromise
  extends Promise<InstrumentCommandEdge>,
    Fragmentable {
  node: <T = InstrumentCommandPromise>() => T;
  cursor: () => Promise<String>;
}

export interface InstrumentCommandEdgeSubscription
  extends Promise<AsyncIterator<InstrumentCommandEdge>>,
    Fragmentable {
  node: <T = InstrumentCommandSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateInstrumentCommand {
  count: Int;
}

export interface AggregateInstrumentCommandPromise
  extends Promise<AggregateInstrumentCommand>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateInstrumentCommandSubscription
  extends Promise<AsyncIterator<AggregateInstrumentCommand>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface InstrumentInstanceConnection {
  pageInfo: PageInfo;
  edges: InstrumentInstanceEdge[];
}

export interface InstrumentInstanceConnectionPromise
  extends Promise<InstrumentInstanceConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<InstrumentInstanceEdge>>() => T;
  aggregate: <T = AggregateInstrumentInstancePromise>() => T;
}

export interface InstrumentInstanceConnectionSubscription
  extends Promise<AsyncIterator<InstrumentInstanceConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <
    T = Promise<AsyncIterator<InstrumentInstanceEdgeSubscription>>
  >() => T;
  aggregate: <T = AggregateInstrumentInstanceSubscription>() => T;
}

export interface InstrumentInstanceEdge {
  node: InstrumentInstance;
  cursor: String;
}

export interface InstrumentInstanceEdgePromise
  extends Promise<InstrumentInstanceEdge>,
    Fragmentable {
  node: <T = InstrumentInstancePromise>() => T;
  cursor: () => Promise<String>;
}

export interface InstrumentInstanceEdgeSubscription
  extends Promise<AsyncIterator<InstrumentInstanceEdge>>,
    Fragmentable {
  node: <T = InstrumentInstanceSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateInstrumentInstance {
  count: Int;
}

export interface AggregateInstrumentInstancePromise
  extends Promise<AggregateInstrumentInstance>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateInstrumentInstanceSubscription
  extends Promise<AsyncIterator<AggregateInstrumentInstance>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface InstrumentParameterConnection {
  pageInfo: PageInfo;
  edges: InstrumentParameterEdge[];
}

export interface InstrumentParameterConnectionPromise
  extends Promise<InstrumentParameterConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<InstrumentParameterEdge>>() => T;
  aggregate: <T = AggregateInstrumentParameterPromise>() => T;
}

export interface InstrumentParameterConnectionSubscription
  extends Promise<AsyncIterator<InstrumentParameterConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <
    T = Promise<AsyncIterator<InstrumentParameterEdgeSubscription>>
  >() => T;
  aggregate: <T = AggregateInstrumentParameterSubscription>() => T;
}

export interface InstrumentParameterEdge {
  node: InstrumentParameter;
  cursor: String;
}

export interface InstrumentParameterEdgePromise
  extends Promise<InstrumentParameterEdge>,
    Fragmentable {
  node: <T = InstrumentParameterPromise>() => T;
  cursor: () => Promise<String>;
}

export interface InstrumentParameterEdgeSubscription
  extends Promise<AsyncIterator<InstrumentParameterEdge>>,
    Fragmentable {
  node: <T = InstrumentParameterSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateInstrumentParameter {
  count: Int;
}

export interface AggregateInstrumentParameterPromise
  extends Promise<AggregateInstrumentParameter>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateInstrumentParameterSubscription
  extends Promise<AsyncIterator<AggregateInstrumentParameter>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface InstrumentSubsystemConnection {
  pageInfo: PageInfo;
  edges: InstrumentSubsystemEdge[];
}

export interface InstrumentSubsystemConnectionPromise
  extends Promise<InstrumentSubsystemConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<InstrumentSubsystemEdge>>() => T;
  aggregate: <T = AggregateInstrumentSubsystemPromise>() => T;
}

export interface InstrumentSubsystemConnectionSubscription
  extends Promise<AsyncIterator<InstrumentSubsystemConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <
    T = Promise<AsyncIterator<InstrumentSubsystemEdgeSubscription>>
  >() => T;
  aggregate: <T = AggregateInstrumentSubsystemSubscription>() => T;
}

export interface InstrumentSubsystemEdge {
  node: InstrumentSubsystem;
  cursor: String;
}

export interface InstrumentSubsystemEdgePromise
  extends Promise<InstrumentSubsystemEdge>,
    Fragmentable {
  node: <T = InstrumentSubsystemPromise>() => T;
  cursor: () => Promise<String>;
}

export interface InstrumentSubsystemEdgeSubscription
  extends Promise<AsyncIterator<InstrumentSubsystemEdge>>,
    Fragmentable {
  node: <T = InstrumentSubsystemSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateInstrumentSubsystem {
  count: Int;
}

export interface AggregateInstrumentSubsystemPromise
  extends Promise<AggregateInstrumentSubsystem>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateInstrumentSubsystemSubscription
  extends Promise<AsyncIterator<AggregateInstrumentSubsystem>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface MeasurementConnection {
  pageInfo: PageInfo;
  edges: MeasurementEdge[];
}

export interface MeasurementConnectionPromise
  extends Promise<MeasurementConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<MeasurementEdge>>() => T;
  aggregate: <T = AggregateMeasurementPromise>() => T;
}

export interface MeasurementConnectionSubscription
  extends Promise<AsyncIterator<MeasurementConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<MeasurementEdgeSubscription>>>() => T;
  aggregate: <T = AggregateMeasurementSubscription>() => T;
}

export interface MeasurementEdge {
  node: Measurement;
  cursor: String;
}

export interface MeasurementEdgePromise
  extends Promise<MeasurementEdge>,
    Fragmentable {
  node: <T = MeasurementPromise>() => T;
  cursor: () => Promise<String>;
}

export interface MeasurementEdgeSubscription
  extends Promise<AsyncIterator<MeasurementEdge>>,
    Fragmentable {
  node: <T = MeasurementSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateMeasurement {
  count: Int;
}

export interface AggregateMeasurementPromise
  extends Promise<AggregateMeasurement>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateMeasurementSubscription
  extends Promise<AsyncIterator<AggregateMeasurement>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface MeasurementRunConnection {
  pageInfo: PageInfo;
  edges: MeasurementRunEdge[];
}

export interface MeasurementRunConnectionPromise
  extends Promise<MeasurementRunConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<MeasurementRunEdge>>() => T;
  aggregate: <T = AggregateMeasurementRunPromise>() => T;
}

export interface MeasurementRunConnectionSubscription
  extends Promise<AsyncIterator<MeasurementRunConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<MeasurementRunEdgeSubscription>>>() => T;
  aggregate: <T = AggregateMeasurementRunSubscription>() => T;
}

export interface MeasurementRunEdge {
  node: MeasurementRun;
  cursor: String;
}

export interface MeasurementRunEdgePromise
  extends Promise<MeasurementRunEdge>,
    Fragmentable {
  node: <T = MeasurementRunPromise>() => T;
  cursor: () => Promise<String>;
}

export interface MeasurementRunEdgeSubscription
  extends Promise<AsyncIterator<MeasurementRunEdge>>,
    Fragmentable {
  node: <T = MeasurementRunSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateMeasurementRun {
  count: Int;
}

export interface AggregateMeasurementRunPromise
  extends Promise<AggregateMeasurementRun>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateMeasurementRunSubscription
  extends Promise<AsyncIterator<AggregateMeasurementRun>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface Meta {
  id: ID_Output;
  key: String;
  value: String;
}

export interface MetaPromise extends Promise<Meta>, Fragmentable {
  id: () => Promise<ID_Output>;
  key: () => Promise<String>;
  value: () => Promise<String>;
}

export interface MetaSubscription
  extends Promise<AsyncIterator<Meta>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  key: () => Promise<AsyncIterator<String>>;
  value: () => Promise<AsyncIterator<String>>;
}

export interface MetaConnection {
  pageInfo: PageInfo;
  edges: MetaEdge[];
}

export interface MetaConnectionPromise
  extends Promise<MetaConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<MetaEdge>>() => T;
  aggregate: <T = AggregateMetaPromise>() => T;
}

export interface MetaConnectionSubscription
  extends Promise<AsyncIterator<MetaConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<MetaEdgeSubscription>>>() => T;
  aggregate: <T = AggregateMetaSubscription>() => T;
}

export interface MetaEdge {
  node: Meta;
  cursor: String;
}

export interface MetaEdgePromise extends Promise<MetaEdge>, Fragmentable {
  node: <T = MetaPromise>() => T;
  cursor: () => Promise<String>;
}

export interface MetaEdgeSubscription
  extends Promise<AsyncIterator<MetaEdge>>,
    Fragmentable {
  node: <T = MetaSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateMeta {
  count: Int;
}

export interface AggregateMetaPromise
  extends Promise<AggregateMeta>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateMetaSubscription
  extends Promise<AsyncIterator<AggregateMeta>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface ProjectConnection {
  pageInfo: PageInfo;
  edges: ProjectEdge[];
}

export interface ProjectConnectionPromise
  extends Promise<ProjectConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<ProjectEdge>>() => T;
  aggregate: <T = AggregateProjectPromise>() => T;
}

export interface ProjectConnectionSubscription
  extends Promise<AsyncIterator<ProjectConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<ProjectEdgeSubscription>>>() => T;
  aggregate: <T = AggregateProjectSubscription>() => T;
}

export interface ProjectEdge {
  node: Project;
  cursor: String;
}

export interface ProjectEdgePromise extends Promise<ProjectEdge>, Fragmentable {
  node: <T = ProjectPromise>() => T;
  cursor: () => Promise<String>;
}

export interface ProjectEdgeSubscription
  extends Promise<AsyncIterator<ProjectEdge>>,
    Fragmentable {
  node: <T = ProjectSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateProject {
  count: Int;
}

export interface AggregateProjectPromise
  extends Promise<AggregateProject>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateProjectSubscription
  extends Promise<AsyncIterator<AggregateProject>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface ProjectVersionConnection {
  pageInfo: PageInfo;
  edges: ProjectVersionEdge[];
}

export interface ProjectVersionConnectionPromise
  extends Promise<ProjectVersionConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<ProjectVersionEdge>>() => T;
  aggregate: <T = AggregateProjectVersionPromise>() => T;
}

export interface ProjectVersionConnectionSubscription
  extends Promise<AsyncIterator<ProjectVersionConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<ProjectVersionEdgeSubscription>>>() => T;
  aggregate: <T = AggregateProjectVersionSubscription>() => T;
}

export interface ProjectVersionEdge {
  node: ProjectVersion;
  cursor: String;
}

export interface ProjectVersionEdgePromise
  extends Promise<ProjectVersionEdge>,
    Fragmentable {
  node: <T = ProjectVersionPromise>() => T;
  cursor: () => Promise<String>;
}

export interface ProjectVersionEdgeSubscription
  extends Promise<AsyncIterator<ProjectVersionEdge>>,
    Fragmentable {
  node: <T = ProjectVersionSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateProjectVersion {
  count: Int;
}

export interface AggregateProjectVersionPromise
  extends Promise<AggregateProjectVersion>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateProjectVersionSubscription
  extends Promise<AsyncIterator<AggregateProjectVersion>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface SetupConnection {
  pageInfo: PageInfo;
  edges: SetupEdge[];
}

export interface SetupConnectionPromise
  extends Promise<SetupConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<SetupEdge>>() => T;
  aggregate: <T = AggregateSetupPromise>() => T;
}

export interface SetupConnectionSubscription
  extends Promise<AsyncIterator<SetupConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<SetupEdgeSubscription>>>() => T;
  aggregate: <T = AggregateSetupSubscription>() => T;
}

export interface SetupEdge {
  node: Setup;
  cursor: String;
}

export interface SetupEdgePromise extends Promise<SetupEdge>, Fragmentable {
  node: <T = SetupPromise>() => T;
  cursor: () => Promise<String>;
}

export interface SetupEdgeSubscription
  extends Promise<AsyncIterator<SetupEdge>>,
    Fragmentable {
  node: <T = SetupSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateSetup {
  count: Int;
}

export interface AggregateSetupPromise
  extends Promise<AggregateSetup>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateSetupSubscription
  extends Promise<AsyncIterator<AggregateSetup>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface SetupHardwareConnection {
  pageInfo: PageInfo;
  edges: SetupHardwareEdge[];
}

export interface SetupHardwareConnectionPromise
  extends Promise<SetupHardwareConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<SetupHardwareEdge>>() => T;
  aggregate: <T = AggregateSetupHardwarePromise>() => T;
}

export interface SetupHardwareConnectionSubscription
  extends Promise<AsyncIterator<SetupHardwareConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<SetupHardwareEdgeSubscription>>>() => T;
  aggregate: <T = AggregateSetupHardwareSubscription>() => T;
}

export interface SetupHardwareEdge {
  node: SetupHardware;
  cursor: String;
}

export interface SetupHardwareEdgePromise
  extends Promise<SetupHardwareEdge>,
    Fragmentable {
  node: <T = SetupHardwarePromise>() => T;
  cursor: () => Promise<String>;
}

export interface SetupHardwareEdgeSubscription
  extends Promise<AsyncIterator<SetupHardwareEdge>>,
    Fragmentable {
  node: <T = SetupHardwareSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateSetupHardware {
  count: Int;
}

export interface AggregateSetupHardwarePromise
  extends Promise<AggregateSetupHardware>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateSetupHardwareSubscription
  extends Promise<AsyncIterator<AggregateSetupHardware>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface SetupHardwareInstanceConnection {
  pageInfo: PageInfo;
  edges: SetupHardwareInstanceEdge[];
}

export interface SetupHardwareInstanceConnectionPromise
  extends Promise<SetupHardwareInstanceConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<SetupHardwareInstanceEdge>>() => T;
  aggregate: <T = AggregateSetupHardwareInstancePromise>() => T;
}

export interface SetupHardwareInstanceConnectionSubscription
  extends Promise<AsyncIterator<SetupHardwareInstanceConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <
    T = Promise<AsyncIterator<SetupHardwareInstanceEdgeSubscription>>
  >() => T;
  aggregate: <T = AggregateSetupHardwareInstanceSubscription>() => T;
}

export interface SetupHardwareInstanceEdge {
  node: SetupHardwareInstance;
  cursor: String;
}

export interface SetupHardwareInstanceEdgePromise
  extends Promise<SetupHardwareInstanceEdge>,
    Fragmentable {
  node: <T = SetupHardwareInstancePromise>() => T;
  cursor: () => Promise<String>;
}

export interface SetupHardwareInstanceEdgeSubscription
  extends Promise<AsyncIterator<SetupHardwareInstanceEdge>>,
    Fragmentable {
  node: <T = SetupHardwareInstanceSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateSetupHardwareInstance {
  count: Int;
}

export interface AggregateSetupHardwareInstancePromise
  extends Promise<AggregateSetupHardwareInstance>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateSetupHardwareInstanceSubscription
  extends Promise<AsyncIterator<AggregateSetupHardwareInstance>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface UserConnection {
  pageInfo: PageInfo;
  edges: UserEdge[];
}

export interface UserConnectionPromise
  extends Promise<UserConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<UserEdge>>() => T;
  aggregate: <T = AggregateUserPromise>() => T;
}

export interface UserConnectionSubscription
  extends Promise<AsyncIterator<UserConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<UserEdgeSubscription>>>() => T;
  aggregate: <T = AggregateUserSubscription>() => T;
}

export interface UserEdge {
  node: User;
  cursor: String;
}

export interface UserEdgePromise extends Promise<UserEdge>, Fragmentable {
  node: <T = UserPromise>() => T;
  cursor: () => Promise<String>;
}

export interface UserEdgeSubscription
  extends Promise<AsyncIterator<UserEdge>>,
    Fragmentable {
  node: <T = UserSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateUser {
  count: Int;
}

export interface AggregateUserPromise
  extends Promise<AggregateUser>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateUserSubscription
  extends Promise<AsyncIterator<AggregateUser>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface BatchPayload {
  count: Long;
}

export interface BatchPayloadPromise
  extends Promise<BatchPayload>,
    Fragmentable {
  count: () => Promise<Long>;
}

export interface BatchPayloadSubscription
  extends Promise<AsyncIterator<BatchPayload>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Long>>;
}

export interface CharacterizationSubscriptionPayload {
  mutation: MutationType;
  node: Characterization;
  updatedFields: String[];
  previousValues: CharacterizationPreviousValues;
}

export interface CharacterizationSubscriptionPayloadPromise
  extends Promise<CharacterizationSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = CharacterizationPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = CharacterizationPreviousValuesPromise>() => T;
}

export interface CharacterizationSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<CharacterizationSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = CharacterizationSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = CharacterizationPreviousValuesSubscription>() => T;
}

export interface CharacterizationPreviousValues {
  id: ID_Output;
  name: String;
}

export interface CharacterizationPreviousValuesPromise
  extends Promise<CharacterizationPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
}

export interface CharacterizationPreviousValuesSubscription
  extends Promise<AsyncIterator<CharacterizationPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
}

export interface CommentSubscriptionPayload {
  mutation: MutationType;
  node: Comment;
  updatedFields: String[];
  previousValues: CommentPreviousValues;
}

export interface CommentSubscriptionPayloadPromise
  extends Promise<CommentSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = CommentPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = CommentPreviousValuesPromise>() => T;
}

export interface CommentSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<CommentSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = CommentSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = CommentPreviousValuesSubscription>() => T;
}

export interface CommentPreviousValues {
  id: ID_Output;
  text?: String;
  createdAt: DateTimeOutput;
}

export interface CommentPreviousValuesPromise
  extends Promise<CommentPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  text: () => Promise<String>;
  createdAt: () => Promise<DateTimeOutput>;
}

export interface CommentPreviousValuesSubscription
  extends Promise<AsyncIterator<CommentPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  text: () => Promise<AsyncIterator<String>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
}

export interface DUTSubscriptionPayload {
  mutation: MutationType;
  node: DUT;
  updatedFields: String[];
  previousValues: DUTPreviousValues;
}

export interface DUTSubscriptionPayloadPromise
  extends Promise<DUTSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = DUTPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = DUTPreviousValuesPromise>() => T;
}

export interface DUTSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<DUTSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = DUTSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = DUTPreviousValuesSubscription>() => T;
}

export interface DUTPreviousValues {
  id: ID_Output;
  name: String;
  description?: String;
  modifications: String[];
}

export interface DUTPreviousValuesPromise
  extends Promise<DUTPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
  modifications: () => Promise<String[]>;
}

export interface DUTPreviousValuesSubscription
  extends Promise<AsyncIterator<DUTPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  modifications: () => Promise<AsyncIterator<String[]>>;
}

export interface EventSubscriptionPayload {
  mutation: MutationType;
  node: Event;
  updatedFields: String[];
  previousValues: EventPreviousValues;
}

export interface EventSubscriptionPayloadPromise
  extends Promise<EventSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = EventPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = EventPreviousValuesPromise>() => T;
}

export interface EventSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<EventSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = EventSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = EventPreviousValuesSubscription>() => T;
}

export interface EventPreviousValues {
  id: ID_Output;
  json: String;
  when: DateTimeOutput;
}

export interface EventPreviousValuesPromise
  extends Promise<EventPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  json: () => Promise<String>;
  when: () => Promise<DateTimeOutput>;
}

export interface EventPreviousValuesSubscription
  extends Promise<AsyncIterator<EventPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  json: () => Promise<AsyncIterator<String>>;
  when: () => Promise<AsyncIterator<DateTimeOutput>>;
}

export interface FileSubscriptionPayload {
  mutation: MutationType;
  node: File;
  updatedFields: String[];
  previousValues: FilePreviousValues;
}

export interface FileSubscriptionPayloadPromise
  extends Promise<FileSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = FilePromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = FilePreviousValuesPromise>() => T;
}

export interface FileSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<FileSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = FileSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = FilePreviousValuesSubscription>() => T;
}

export interface FilePreviousValues {
  id: ID_Output;
  path: String;
  name?: String;
  description?: String;
  filename: String;
  mimetype: String;
  size: Int;
}

export interface FilePreviousValuesPromise
  extends Promise<FilePreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  path: () => Promise<String>;
  name: () => Promise<String>;
  description: () => Promise<String>;
  filename: () => Promise<String>;
  mimetype: () => Promise<String>;
  size: () => Promise<Int>;
}

export interface FilePreviousValuesSubscription
  extends Promise<AsyncIterator<FilePreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  path: () => Promise<AsyncIterator<String>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  filename: () => Promise<AsyncIterator<String>>;
  mimetype: () => Promise<AsyncIterator<String>>;
  size: () => Promise<AsyncIterator<Int>>;
}

export interface InstrumentSubscriptionPayload {
  mutation: MutationType;
  node: Instrument;
  updatedFields: String[];
  previousValues: InstrumentPreviousValues;
}

export interface InstrumentSubscriptionPayloadPromise
  extends Promise<InstrumentSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = InstrumentPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = InstrumentPreviousValuesPromise>() => T;
}

export interface InstrumentSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<InstrumentSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = InstrumentSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = InstrumentPreviousValuesSubscription>() => T;
}

export interface InstrumentPreviousValues {
  id: ID_Output;
  name: String;
  description?: String;
  interfaces: String[];
}

export interface InstrumentPreviousValuesPromise
  extends Promise<InstrumentPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
  interfaces: () => Promise<String[]>;
}

export interface InstrumentPreviousValuesSubscription
  extends Promise<AsyncIterator<InstrumentPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  interfaces: () => Promise<AsyncIterator<String[]>>;
}

export interface InstrumentCommandSubscriptionPayload {
  mutation: MutationType;
  node: InstrumentCommand;
  updatedFields: String[];
  previousValues: InstrumentCommandPreviousValues;
}

export interface InstrumentCommandSubscriptionPayloadPromise
  extends Promise<InstrumentCommandSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = InstrumentCommandPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = InstrumentCommandPreviousValuesPromise>() => T;
}

export interface InstrumentCommandSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<InstrumentCommandSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = InstrumentCommandSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = InstrumentCommandPreviousValuesSubscription>() => T;
}

export interface InstrumentCommandPreviousValues {
  id: ID_Output;
  tag: String;
  name?: String;
  description: String;
  readString?: String;
  writeString?: String;
}

export interface InstrumentCommandPreviousValuesPromise
  extends Promise<InstrumentCommandPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  tag: () => Promise<String>;
  name: () => Promise<String>;
  description: () => Promise<String>;
  readString: () => Promise<String>;
  writeString: () => Promise<String>;
}

export interface InstrumentCommandPreviousValuesSubscription
  extends Promise<AsyncIterator<InstrumentCommandPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  tag: () => Promise<AsyncIterator<String>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  readString: () => Promise<AsyncIterator<String>>;
  writeString: () => Promise<AsyncIterator<String>>;
}

export interface InstrumentInstanceSubscriptionPayload {
  mutation: MutationType;
  node: InstrumentInstance;
  updatedFields: String[];
  previousValues: InstrumentInstancePreviousValues;
}

export interface InstrumentInstanceSubscriptionPayloadPromise
  extends Promise<InstrumentInstanceSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = InstrumentInstancePromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = InstrumentInstancePreviousValuesPromise>() => T;
}

export interface InstrumentInstanceSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<InstrumentInstanceSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = InstrumentInstanceSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = InstrumentInstancePreviousValuesSubscription>() => T;
}

export interface InstrumentInstancePreviousValues {
  id: ID_Output;
  identifier: String;
  interface: String[];
  label?: String;
  location?: String;
}

export interface InstrumentInstancePreviousValuesPromise
  extends Promise<InstrumentInstancePreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  identifier: () => Promise<String>;
  interface: () => Promise<String[]>;
  label: () => Promise<String>;
  location: () => Promise<String>;
}

export interface InstrumentInstancePreviousValuesSubscription
  extends Promise<AsyncIterator<InstrumentInstancePreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  identifier: () => Promise<AsyncIterator<String>>;
  interface: () => Promise<AsyncIterator<String[]>>;
  label: () => Promise<AsyncIterator<String>>;
  location: () => Promise<AsyncIterator<String>>;
}

export interface InstrumentParameterSubscriptionPayload {
  mutation: MutationType;
  node: InstrumentParameter;
  updatedFields: String[];
  previousValues: InstrumentParameterPreviousValues;
}

export interface InstrumentParameterSubscriptionPayloadPromise
  extends Promise<InstrumentParameterSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = InstrumentParameterPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = InstrumentParameterPreviousValuesPromise>() => T;
}

export interface InstrumentParameterSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<InstrumentParameterSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = InstrumentParameterSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = InstrumentParameterPreviousValuesSubscription>() => T;
}

export interface InstrumentParameterPreviousValues {
  id: ID_Output;
  tag: String;
  name?: String;
  description?: String;
  type: String;
  values?: String;
}

export interface InstrumentParameterPreviousValuesPromise
  extends Promise<InstrumentParameterPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  tag: () => Promise<String>;
  name: () => Promise<String>;
  description: () => Promise<String>;
  type: () => Promise<String>;
  values: () => Promise<String>;
}

export interface InstrumentParameterPreviousValuesSubscription
  extends Promise<AsyncIterator<InstrumentParameterPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  tag: () => Promise<AsyncIterator<String>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  type: () => Promise<AsyncIterator<String>>;
  values: () => Promise<AsyncIterator<String>>;
}

export interface InstrumentSubsystemSubscriptionPayload {
  mutation: MutationType;
  node: InstrumentSubsystem;
  updatedFields: String[];
  previousValues: InstrumentSubsystemPreviousValues;
}

export interface InstrumentSubsystemSubscriptionPayloadPromise
  extends Promise<InstrumentSubsystemSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = InstrumentSubsystemPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = InstrumentSubsystemPreviousValuesPromise>() => T;
}

export interface InstrumentSubsystemSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<InstrumentSubsystemSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = InstrumentSubsystemSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = InstrumentSubsystemPreviousValuesSubscription>() => T;
}

export interface InstrumentSubsystemPreviousValues {
  id: ID_Output;
  name?: String;
  description: String;
}

export interface InstrumentSubsystemPreviousValuesPromise
  extends Promise<InstrumentSubsystemPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
}

export interface InstrumentSubsystemPreviousValuesSubscription
  extends Promise<AsyncIterator<InstrumentSubsystemPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
}

export interface MeasurementSubscriptionPayload {
  mutation: MutationType;
  node: Measurement;
  updatedFields: String[];
  previousValues: MeasurementPreviousValues;
}

export interface MeasurementSubscriptionPayloadPromise
  extends Promise<MeasurementSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = MeasurementPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = MeasurementPreviousValuesPromise>() => T;
}

export interface MeasurementSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<MeasurementSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = MeasurementSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = MeasurementPreviousValuesSubscription>() => T;
}

export interface MeasurementPreviousValues {
  id: ID_Output;
  createdAt: DateTimeOutput;
  intValue?: Int;
  floatValue?: Float;
  stringValue?: String;
}

export interface MeasurementPreviousValuesPromise
  extends Promise<MeasurementPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  createdAt: () => Promise<DateTimeOutput>;
  intValue: () => Promise<Int>;
  floatValue: () => Promise<Float>;
  stringValue: () => Promise<String>;
}

export interface MeasurementPreviousValuesSubscription
  extends Promise<AsyncIterator<MeasurementPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  intValue: () => Promise<AsyncIterator<Int>>;
  floatValue: () => Promise<AsyncIterator<Float>>;
  stringValue: () => Promise<AsyncIterator<String>>;
}

export interface MeasurementRunSubscriptionPayload {
  mutation: MutationType;
  node: MeasurementRun;
  updatedFields: String[];
  previousValues: MeasurementRunPreviousValues;
}

export interface MeasurementRunSubscriptionPayloadPromise
  extends Promise<MeasurementRunSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = MeasurementRunPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = MeasurementRunPreviousValuesPromise>() => T;
}

export interface MeasurementRunSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<MeasurementRunSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = MeasurementRunSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = MeasurementRunPreviousValuesSubscription>() => T;
}

export interface MeasurementRunPreviousValues {
  id: ID_Output;
  name: String;
  location: String;
  temperature?: Float;
  startTime: DateTimeOutput;
  endTime: DateTimeOutput;
}

export interface MeasurementRunPreviousValuesPromise
  extends Promise<MeasurementRunPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  location: () => Promise<String>;
  temperature: () => Promise<Float>;
  startTime: () => Promise<DateTimeOutput>;
  endTime: () => Promise<DateTimeOutput>;
}

export interface MeasurementRunPreviousValuesSubscription
  extends Promise<AsyncIterator<MeasurementRunPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  location: () => Promise<AsyncIterator<String>>;
  temperature: () => Promise<AsyncIterator<Float>>;
  startTime: () => Promise<AsyncIterator<DateTimeOutput>>;
  endTime: () => Promise<AsyncIterator<DateTimeOutput>>;
}

export interface MetaSubscriptionPayload {
  mutation: MutationType;
  node: Meta;
  updatedFields: String[];
  previousValues: MetaPreviousValues;
}

export interface MetaSubscriptionPayloadPromise
  extends Promise<MetaSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = MetaPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = MetaPreviousValuesPromise>() => T;
}

export interface MetaSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<MetaSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = MetaSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = MetaPreviousValuesSubscription>() => T;
}

export interface MetaPreviousValues {
  id: ID_Output;
  key: String;
  value: String;
}

export interface MetaPreviousValuesPromise
  extends Promise<MetaPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  key: () => Promise<String>;
  value: () => Promise<String>;
}

export interface MetaPreviousValuesSubscription
  extends Promise<AsyncIterator<MetaPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  key: () => Promise<AsyncIterator<String>>;
  value: () => Promise<AsyncIterator<String>>;
}

export interface ProjectSubscriptionPayload {
  mutation: MutationType;
  node: Project;
  updatedFields: String[];
  previousValues: ProjectPreviousValues;
}

export interface ProjectSubscriptionPayloadPromise
  extends Promise<ProjectSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = ProjectPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = ProjectPreviousValuesPromise>() => T;
}

export interface ProjectSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<ProjectSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = ProjectSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = ProjectPreviousValuesSubscription>() => T;
}

export interface ProjectPreviousValues {
  id: ID_Output;
  name: String;
  abbreviation: String;
  description?: String;
}

export interface ProjectPreviousValuesPromise
  extends Promise<ProjectPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  abbreviation: () => Promise<String>;
  description: () => Promise<String>;
}

export interface ProjectPreviousValuesSubscription
  extends Promise<AsyncIterator<ProjectPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  abbreviation: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
}

export interface ProjectVersionSubscriptionPayload {
  mutation: MutationType;
  node: ProjectVersion;
  updatedFields: String[];
  previousValues: ProjectVersionPreviousValues;
}

export interface ProjectVersionSubscriptionPayloadPromise
  extends Promise<ProjectVersionSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = ProjectVersionPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = ProjectVersionPreviousValuesPromise>() => T;
}

export interface ProjectVersionSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<ProjectVersionSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = ProjectVersionSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = ProjectVersionPreviousValuesSubscription>() => T;
}

export interface ProjectVersionPreviousValues {
  id: ID_Output;
  name: String;
  changes: String[];
  date: DateTimeOutput;
}

export interface ProjectVersionPreviousValuesPromise
  extends Promise<ProjectVersionPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  changes: () => Promise<String[]>;
  date: () => Promise<DateTimeOutput>;
}

export interface ProjectVersionPreviousValuesSubscription
  extends Promise<AsyncIterator<ProjectVersionPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  changes: () => Promise<AsyncIterator<String[]>>;
  date: () => Promise<AsyncIterator<DateTimeOutput>>;
}

export interface SetupSubscriptionPayload {
  mutation: MutationType;
  node: Setup;
  updatedFields: String[];
  previousValues: SetupPreviousValues;
}

export interface SetupSubscriptionPayloadPromise
  extends Promise<SetupSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = SetupPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = SetupPreviousValuesPromise>() => T;
}

export interface SetupSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<SetupSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = SetupSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = SetupPreviousValuesSubscription>() => T;
}

export interface SetupPreviousValues {
  id: ID_Output;
  name: String;
  description: String;
}

export interface SetupPreviousValuesPromise
  extends Promise<SetupPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
}

export interface SetupPreviousValuesSubscription
  extends Promise<AsyncIterator<SetupPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
}

export interface SetupHardwareSubscriptionPayload {
  mutation: MutationType;
  node: SetupHardware;
  updatedFields: String[];
  previousValues: SetupHardwarePreviousValues;
}

export interface SetupHardwareSubscriptionPayloadPromise
  extends Promise<SetupHardwareSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = SetupHardwarePromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = SetupHardwarePreviousValuesPromise>() => T;
}

export interface SetupHardwareSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<SetupHardwareSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = SetupHardwareSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = SetupHardwarePreviousValuesSubscription>() => T;
}

export interface SetupHardwarePreviousValues {
  id: ID_Output;
  name: String;
  description?: String;
}

export interface SetupHardwarePreviousValuesPromise
  extends Promise<SetupHardwarePreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
}

export interface SetupHardwarePreviousValuesSubscription
  extends Promise<AsyncIterator<SetupHardwarePreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
}

export interface SetupHardwareInstanceSubscriptionPayload {
  mutation: MutationType;
  node: SetupHardwareInstance;
  updatedFields: String[];
  previousValues: SetupHardwareInstancePreviousValues;
}

export interface SetupHardwareInstanceSubscriptionPayloadPromise
  extends Promise<SetupHardwareInstanceSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = SetupHardwareInstancePromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = SetupHardwareInstancePreviousValuesPromise>() => T;
}

export interface SetupHardwareInstanceSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<SetupHardwareInstanceSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = SetupHardwareInstanceSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = SetupHardwareInstancePreviousValuesSubscription>() => T;
}

export interface SetupHardwareInstancePreviousValues {
  id: ID_Output;
  identifier: String;
}

export interface SetupHardwareInstancePreviousValuesPromise
  extends Promise<SetupHardwareInstancePreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  identifier: () => Promise<String>;
}

export interface SetupHardwareInstancePreviousValuesSubscription
  extends Promise<AsyncIterator<SetupHardwareInstancePreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  identifier: () => Promise<AsyncIterator<String>>;
}

export interface UserSubscriptionPayload {
  mutation: MutationType;
  node: User;
  updatedFields: String[];
  previousValues: UserPreviousValues;
}

export interface UserSubscriptionPayloadPromise
  extends Promise<UserSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = UserPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = UserPreviousValuesPromise>() => T;
}

export interface UserSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<UserSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = UserSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = UserPreviousValuesSubscription>() => T;
}

export interface UserPreviousValues {
  id: ID_Output;
  email: String;
  name: String;
  abbreviation: String;
  password: String;
}

export interface UserPreviousValuesPromise
  extends Promise<UserPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  email: () => Promise<String>;
  name: () => Promise<String>;
  abbreviation: () => Promise<String>;
  password: () => Promise<String>;
}

export interface UserPreviousValuesSubscription
  extends Promise<AsyncIterator<UserPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  email: () => Promise<AsyncIterator<String>>;
  name: () => Promise<AsyncIterator<String>>;
  abbreviation: () => Promise<AsyncIterator<String>>;
  password: () => Promise<AsyncIterator<String>>;
}

/*
The `ID` scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `"4"`) or integer (such as `4`) input value will be accepted as an ID.
*/
export type ID_Input = string | number;
export type ID_Output = string;

/*
The `String` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.
*/
export type String = string;

/*
DateTime scalar input type, allowing Date
*/
export type DateTimeInput = Date | string;

/*
DateTime scalar output type, which is always a string
*/
export type DateTimeOutput = string;

/*
The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1. 
*/
export type Int = number;

/*
The `Float` scalar type represents signed double-precision fractional values as specified by [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point). 
*/
export type Float = number;

/*
The `Boolean` scalar type represents `true` or `false`.
*/
export type Boolean = boolean;

export type Long = string;

/**
 * Model Metadata
 */

export const models: Model[] = [
  {
    name: "Meta",
    embedded: false
  },
  {
    name: "User",
    embedded: false
  },
  {
    name: "File",
    embedded: false
  },
  {
    name: "Comment",
    embedded: false
  },
  {
    name: "Event",
    embedded: false
  },
  {
    name: "Project",
    embedded: false
  },
  {
    name: "ProjectVersion",
    embedded: false
  },
  {
    name: "InstrumentParameter",
    embedded: false
  },
  {
    name: "InstrumentCommand",
    embedded: false
  },
  {
    name: "InstrumentSubsystem",
    embedded: false
  },
  {
    name: "Instrument",
    embedded: false
  },
  {
    name: "InstrumentInstance",
    embedded: false
  },
  {
    name: "DUT",
    embedded: false
  },
  {
    name: "SetupHardware",
    embedded: false
  },
  {
    name: "SetupHardwareInstance",
    embedded: false
  },
  {
    name: "Setup",
    embedded: false
  },
  {
    name: "Measurement",
    embedded: false
  },
  {
    name: "MeasurementRun",
    embedded: false
  },
  {
    name: "Characterization",
    embedded: false
  }
];

/**
 * Type Defs
 */

export const prisma: Prisma;