text: export const FoodEstablishmentReservation = {
    label: "FoodEstablishmentReservation",
    description: `A reservation to dine at a food-related business.
  
  Note: This type is for information about actual reservations, e.g. in
  confirmation emails or HTML pages with individual confirmations of reservations.`,
    _id: {
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: String,
      optional: true,
    },
    createdAt: {
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: Date,
      optional: true,
      viewableBy: ["guests"],
      onInsert: (document, context) => {
        return new Date()
      },
    },
    userId: {
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: String,
      optional: true,
      resolveAs: {
        fieldName: "user",
        type: "User",
        resolver: (document, args, context) => {
          return context.Users.findOne(
            { _id: document.userId },
            {
              fields: context.Users.getViewableFields(
                context.currentUser,
                context.Users
              ),
            }
          )
        },
        optional: true,
      },
    },
    sameAs: {
      label: "sameAs",
      description: `URL of a reference Web page that unambiguously indicates the item's identity.
  E.g. the URL of the item's Wikipedia page, Wikidata entry, or official website.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: String,
      input: "url",
    },
    alternateName: {
      label: "alternateName",
      description: `An alias for the item.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: String,
    },
    image: {
      label: "image",
      description: `An image of the item. This can be a URL or a fully described ImageObject.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      resolveAs: {
        fieldName: "ImageObjectResolved",
        type: "ImageObject",
        resolver: (document, args, context) => {
          return context.ImageObject.findOne(
            { _id: document.ImageObject },
            {
              fields: context.ImageObject.getViewableFields(
                context.currentUser,
                context.ImageObject
              ),
            }
          )
        },
        optional: true,
      },
    },
    additionalType: {
      label: "additionalType",
      description: `An additional type for the item, typically used for adding more specific types
  from external vocabularies in microdata syntax. This is a relationship between
  something and a class that the thing is in. In RDFa syntax, it is better to use
  the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org
  tools may have only weaker understanding of extra types, in particular those
  defined externally.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: String,
      input: "url",
    },
    name: {
      label: "name",
      description: `The name of the item.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: String,
    },
    identifier: {
      label: "identifier",
      description: `The identifier property represents any kind of identifier for any kind of Thing,
  such as ISBNs, GTIN codes, UUIDs etc. Schema.org provides dedicated properties
  for representing many of these, either as textual strings or as URL (URI) links.
  See background notes for more details.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: String,
      input: "url",
    },
    mainEntityOfPage: {
      label: "mainEntityOfPage",
      description: `Indicates a page (or other CreativeWork) for which this thing is the main entity
  being described. See background notes for details.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: String,
      input: "url",
    },
    url: {
      label: "url",
      description: `URL of the item.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: String,
      input: "url",
    },
    potentialAction: {
      label: "potentialAction",
      description: `Indicates a potential Action, which describes an idealized action in which this
  thing would play an 'object' role.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      resolveAs: {
        fieldName: "ActionResolved",
        type: "Action",
        resolver: (document, args, context) => {
          return context.Action.findOne(
            { _id: document.Action },
            {
              fields: context.Action.getViewableFields(
                context.currentUser,
                context.Action
              ),
            }
          )
        },
        optional: true,
      },
    },
    description: {
      label: "description",
      description: `A description of the item.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: String,
    },
    disambiguatingDescription: {
      label: "disambiguatingDescription",
      description: `A sub property of description. A short description of the item used to
  disambiguate from other, similar items. Information from other properties (in
  particular, name) may be necessary for the description to be useful for
  disambiguation.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: String,
    },
    reservationStatus: {
      label: "reservationStatus",
      description: `The current status of the reservation.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      resolveAs: {
        fieldName: "ReservationStatusTypeResolved",
        type: "ReservationStatusType",
        resolver: (document, args, context) => {
          return context.ReservationStatusType.findOne(
            { _id: document.ReservationStatusType },
            {
              fields: context.ReservationStatusType.getViewableFields(
                context.currentUser,
                context.ReservationStatusType
              ),
            }
          )
        },
        optional: true,
      },
    },
    provider: {
      label: "provider",
      description: `The service provider, service operator, or service performer; the goods
  producer. Another party (a seller) may offer those services or goods on behalf
  of the provider. A provider may also serve as the seller.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      resolveAs: {
        fieldName: "PersonResolved",
        type: "Person",
        resolver: (document, args, context) => {
          return context.Person.findOne(
            { _id: document.Person },
            {
              fields: context.Person.getViewableFields(
                context.currentUser,
                context.Person
              ),
            }
          )
        },
        optional: true,
      },
    },
    programMembershipUsed: {
      label: "programMembershipUsed",
      description: `Any membership in a frequent flyer, hotel loyalty program, etc. being applied to
  the reservation.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      resolveAs: {
        fieldName: "ProgramMembershipResolved",
        type: "ProgramMembership",
        resolver: (document, args, context) => {
          return context.ProgramMembership.findOne(
            { _id: document.ProgramMembership },
            {
              fields: context.ProgramMembership.getViewableFields(
                context.currentUser,
                context.ProgramMembership
              ),
            }
          )
        },
        optional: true,
      },
    },
    underName: {
      label: "underName",
      description: `The person or organization the reservation or ticket is for.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      resolveAs: {
        fieldName: "PersonResolved",
        type: "Person",
        resolver: (document, args, context) => {
          return context.Person.findOne(
            { _id: document.Person },
            {
              fields: context.Person.getViewableFields(
                context.currentUser,
                context.Person
              ),
            }
          )
        },
        optional: true,
      },
    },
    bookingAgent: {
      label: "bookingAgent",
      description: `'bookingAgent' is an out-dated term indicating a 'broker' that serves as a
  booking agent.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      resolveAs: {
        fieldName: "PersonResolved",
        type: "Person",
        resolver: (document, args, context) => {
          return context.Person.findOne(
            { _id: document.Person },
            {
              fields: context.Person.getViewableFields(
                context.currentUser,
                context.Person
              ),
            }
          )
        },
        optional: true,
      },
    },
    totalPrice: {
      label: "totalPrice",
      description: `The total price for the reservation or ticket, including applicable taxes,
  shipping, etc.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: String,
    },
    reservationFor: {
      label: "reservationFor",
      description: `The thing -- flight, event, restaurant,etc. being reserved.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      resolveAs: {
        fieldName: "ThingResolved",
        type: "Thing",
        resolver: (document, args, context) => {
          return context.Thing.findOne(
            { _id: document.Thing },
            {
              fields: context.Thing.getViewableFields(
                context.currentUser,
                context.Thing
              ),
            }
          )
        },
        optional: true,
      },
    },
    priceCurrency: {
      label: "priceCurrency",
      description: `The currency of the price, or a price component when attached to 
  PriceSpecification and its subtypes.
  
  Use standard formats: ISO 4217 currency format e.g. "USD"; Ticker symbol for
  cryptocurrencies e.g. "BTC"; well known names for Local Exchange Tradings
  Systems (LETS) and other currency types e.g. "Ithaca HOUR".`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: String,
    },
    broker: {
      label: "broker",
      description: `An entity that arranges for an exchange between a buyer and a seller. In most
  cases a broker never acquires or releases ownership of a product or service
  involved in an exchange. If it is not clear whether an entity is a broker,
  seller, or buyer, the latter two terms are preferred.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      resolveAs: {
        fieldName: "PersonResolved",
        type: "Person",
        resolver: (document, args, context) => {
          return context.Person.findOne(
            { _id: document.Person },
            {
              fields: context.Person.getViewableFields(
                context.currentUser,
                context.Person
              ),
            }
          )
        },
        optional: true,
      },
    },
    modifiedTime: {
      label: "modifiedTime",
      description: `The date and time the reservation was modified.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: Date,
      input: "datetime",
    },
    bookingTime: {
      label: "bookingTime",
      description: `The date and time the reservation was booked.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: Date,
      input: "datetime",
    },
    reservationId: {
      label: "reservationId",
      description: `A unique identifier for the reservation.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: String,
    },
    reservedTicket: {
      label: "reservedTicket",
      description: `A ticket associated with the reservation.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      resolveAs: {
        fieldName: "TicketResolved",
        type: "Ticket",
        resolver: (document, args, context) => {
          return context.Ticket.findOne(
            { _id: document.Ticket },
            {
              fields: context.Ticket.getViewableFields(
                context.currentUser,
                context.Ticket
              ),
            }
          )
        },
        optional: true,
      },
    },
    startTime: {
      label: "startTime",
      description: `The startTime of something. For a reserved event or service (e.g.
  FoodEstablishmentReservation), the time that it is expected to start. For
  actions that span a period of time, when the action was performed. e.g. John
  wrote a book from January to December.
  
  Note that Event uses startDate/endDate instead of startTime/endTime, even when
  describing dates with times. This situation may be clarified in future
  revisions.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: Date,
      input: "datetime",
    },
    endTime: {
      label: "endTime",
      description: `The endTime of something. For a reserved event or service (e.g.
  FoodEstablishmentReservation), the time that it is expected to end. For actions
  that span a period of time, when the action was performed. e.g. John wrote a
  book from January to December.
  
  Note that Event uses startDate/endDate instead of startTime/endTime, even when
  describing dates with times. This situation may be clarified in future
  revisions.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      type: Date,
      input: "datetime",
    },
    partySize: {
      label: "partySize",
      description: `Number of people the reservation should accommodate.`,
      viewableBy: ["guests"],
      editableBy: ["members"],
      insertableBy: ["members"],
      resolveAs: {
        fieldName: "IntegerResolved",
        type: "Integer",
        resolver: (document, args, context) => {
          return context.Integer.findOne(
            { _id: document.Integer },
            {
              fields: context.Integer.getViewableFields(
                context.currentUser,
                context.Integer
              ),
            }
          )
        },
        optional: true,
      },
    },
  }
  export default FoodEstablishmentReservation
  