Types ​

export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: string;
  String: string;
  Boolean: boolean;
  Int: number;
  Float: number;
};

export type Countries = Errable & Pageable & {
  __typename?: 'Countries';
  data?: Maybe<Array<Maybe<Country>>>;
  errors: Array<Maybe<Error>>;
  limit?: Maybe<Scalars['Int']>;
  nextToken?: Maybe<Scalars['String']>;
  previousToken?: Maybe<Scalars['String']>;
};

export type CountriesInput = {
  limit?: InputMaybe<Scalars['Int']>;
  locales?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
  nextToken?: InputMaybe<Scalars['String']>;
  previousToken?: InputMaybe<Scalars['String']>;
};

export type Country = Errable & {
  __typename?: 'Country';
  errors: Array<Maybe<Error>>;
  /**
   * The two-letter country code for the location’s country. For a list of
   * country codes, see ISO 3166-1 alpha-2.
   */
  iso?: Maybe<Scalars['String']>;
  /** Name of the location’s Country. */
  name?: Maybe<Array<Maybe<LocaleString>>>;
};

export type CountryInput = {
  iso: Scalars['String'];
  locales?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
};

export type Discipline = Errable & {
  __typename?: 'Discipline';
  errors: Array<Maybe<Error>>;
  /** Unique Identifier for this record. */
  id?: Maybe<Scalars['ID']>;
  medias?: Maybe<Medias>;
  name?: Maybe<Array<Maybe<LocaleString>>>;
};

export type DisciplineInput = {
  id: Scalars['ID'];
  locales?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
};

export type Disciplines = Errable & Pageable & {
  __typename?: 'Disciplines';
  data?: Maybe<Array<Maybe<Discipline>>>;
  errors: Array<Maybe<Error>>;
  limit?: Maybe<Scalars['Int']>;
  nextToken?: Maybe<Scalars['String']>;
  previousToken?: Maybe<Scalars['String']>;
};

export type DisciplinesInput = {
  limit?: InputMaybe<Scalars['Int']>;
  locales?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
  nextToken?: InputMaybe<Scalars['String']>;
  previousToken?: InputMaybe<Scalars['String']>;
};

export type Errable = {
  errors?: Maybe<Array<Maybe<Error>>>;
};

export type Error = {
  __typename?: 'Error';
  /** Error code */
  errorCode?: Maybe<Scalars['String']>;
  /** More specific detail about the error */
  errorDetail?: Maybe<Scalars['String']>;
  /** Short error message */
  errorMessage?: Maybe<Scalars['String']>;
};

export type Event = Errable & {
  __typename?: 'Event';
  /** Attendance mode for this event. */
  attendance?: Maybe<EventAttendance>;
  disciplines?: Maybe<Disciplines>;
  errors: Array<Maybe<Error>>;
  /** Collections this event belongs to */
  eventCollections?: Maybe<EventCollections>;
  /** Event duration - iso 8601 duration */
  eventDuration?: Maybe<Scalars['String']>;
  /** End date-time for event - iso 8601 datetime in UTC */
  eventEnd?: Maybe<Scalars['String']>;
  /** Start date-time for event - iso 8601 datetime in UTC */
  eventStart?: Maybe<Scalars['String']>;
  /** Unique Identifier for this record. */
  id?: Maybe<Scalars['ID']>;
  medias?: Maybe<Medias>;
  metaDatas?: Maybe<MetaDatas>;
  /** Event name */
  name?: Maybe<Array<Maybe<LocaleString>>>;
  organization?: Maybe<Organization>;
  primaryVenue?: Maybe<Venue>;
  /** End date-time for registration - iso 8601 datetime in UTC */
  registrationEnd?: Maybe<Scalars['String']>;
  /** Start date-time for registration - iso 8601 datetime in UTC */
  registrationStart?: Maybe<Scalars['String']>;
  segments?: Maybe<Segments>;
  /** State of event. */
  state?: Maybe<EventState>;
  /** Status of event. */
  status?: Maybe<EventStatus>;
  /** Full URL to event details page */
  url?: Maybe<Scalars['String']>;
  venues?: Maybe<Array<Maybe<Venue>>>;
};

export enum EventAttendance {
  Mixed = 'MIXED',
  Offline = 'OFFLINE',
  Online = 'ONLINE'
}

export type EventCollection = Errable & {
  __typename?: 'EventCollection';
  /** ISO 3166-1 alpha-2 country codes this collection is restricted to. (eg: US, CA) */
  countries?: Maybe<Array<Maybe<Scalars['String']>>>;
  /** Restrict Collection to these Disciplines */
  disciplineInclude?: Maybe<Array<Maybe<Discipline>>>;
  errors: Array<Maybe<Error>>;
  /** End date used to find events for this collection. */
  eventEnd?: Maybe<Scalars['String']>;
  /** Duration from the current datetime to end looking for events. Positive = future, negative = past */
  eventEndDuration?: Maybe<Scalars['String']>;
  /** The computed event search used to return event data */
  eventSearch?: Maybe<EventSearch>;
  /** Start date used to find events for this collection. */
  eventStart?: Maybe<Scalars['String']>;
  /** Duration from the current datetime to start looking for events. Positive = future, negative = past */
  eventStartDuration?: Maybe<Scalars['String']>;
  /**
   * List of event statuses which should be excluded from this search
   * Default: EventState.CANCELLED
   */
  eventStateExclude?: Maybe<Array<Maybe<EventState>>>;
  /**
   * List of event statuses which should be excluded from this search
   * Default: undefined
   */
  eventStatusExclude?: Maybe<Array<Maybe<EventStatus>>>;
  /** Matching events found in this collection */
  events?: Maybe<Events>;
  /** If true, events returned for this collection are based on geolocation. */
  geoLocate?: Maybe<Scalars['Boolean']>;
  /** GeoPoint center for collection. Autodetected if not supplied. */
  geoPoint?: Maybe<GeoPoint>;
  /** Unique Identifier for this record. */
  id?: Maybe<Scalars['ID']>;
  /** Shorter title, appropriate for navigation or control elements. */
  name?: Maybe<Array<Maybe<LocaleString>>>;
  /** Restrict collection to these organization */
  organizationInclude?: Maybe<Array<Maybe<Organization>>>;
  /** Longer title, appropriate for cards and page titles. */
  title?: Maybe<Array<Maybe<LocaleString>>>;
};

export type EventCollectionInput = {
  id: Scalars['ID'];
  locales?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
};

export type EventCollections = Errable & Pageable & {
  __typename?: 'EventCollections';
  data?: Maybe<Array<Maybe<EventCollection>>>;
  errors: Array<Maybe<Error>>;
  limit?: Maybe<Scalars['Int']>;
  nextToken?: Maybe<Scalars['String']>;
  previousToken?: Maybe<Scalars['String']>;
};

export type EventCollectionsInput = {
  limit?: InputMaybe<Scalars['Int']>;
  locales?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
  nextToken?: InputMaybe<Scalars['String']>;
  previousToken?: InputMaybe<Scalars['String']>;
};

export type EventInput = {
  id: Scalars['ID'];
  locales?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
};

export type EventSearch = Errable & {
  __typename?: 'EventSearch';
  /** ISO 3166-1 alpha-2 country codes this search is restricted to. (eg: US, CA) */
  countries: Array<Maybe<Country>>;
  /** Search restricted  to these Disciplines */
  disciplineInclude: Array<Maybe<Discipline>>;
  errors: Array<Maybe<Error>>;
  /** Search restricted to these Collections  */
  eventCollectionInclude: Array<Maybe<EventCollection>>;
  /** Searched for events before this date  */
  eventEnd: Scalars['String'];
  /** Searched for events after this date  */
  eventStart: Scalars['String'];
  /** List of event statuses which were excluded from this search */
  eventStateExclude: Array<Maybe<EventState>>;
  /** List of event statuses which were excluded from this search */
  eventStatusExclude: Array<Maybe<EventStatus>>;
  /** User Geolocation was used in this search.  */
  geoLocate: Scalars['Boolean'];
  /** GeoLocation used in the search. */
  geoLocation: GeoLocation;
  /** Max results per page */
  limit: Scalars['Int'];
  locales?: Maybe<Array<Maybe<Scalars['String']>>>;
  /** Search restricted to these Organizations */
  organizationInclude: Array<Maybe<Organization>>;
};

export type EventSearchInput = {
  /** ISO 3166-1 alpha-2 country codes this search is restricted to. (eg: US, CA) */
  countries?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
  /** Restrict search to these Disciplines */
  disciplineInclude?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
  /** Collections to include in the search. */
  eventCollections?: InputMaybe<Array<InputMaybe<EventCollectionInput>>>;
  /**
   * Find events before this date using half-closed intervals with exclusive
   * end dates, e.g. [start, end)
   */
  eventEnd?: InputMaybe<Scalars['String']>;
  /**
   * Find events after this date using half-closed intervals with inclusive
   * start dates, e.g. [start, end)
   */
  eventStart?: InputMaybe<Scalars['String']>;
  /**
   * List of event statuses which should be excluded from this search
   * Default: EventState.CANCELLED
   */
  eventStateExclude?: InputMaybe<Array<InputMaybe<EventState>>>;
  /**
   * List of event statuses which should be excluded from this search
   * Default: undefined
   */
  eventStatusExclude?: InputMaybe<Array<InputMaybe<EventStatus>>>;
  /**
   * User Geolocation this search. if true, geoPoint will be autodetected if
   * not supplied.
   */
  geoLocate?: InputMaybe<Scalars['Boolean']>;
  /** Geopoint center for this search. Autodetected if not supplied. */
  geoPoint?: InputMaybe<GeoPointInput>;
  limit?: InputMaybe<Scalars['Int']>;
  locales?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
  nextToken?: InputMaybe<Scalars['String']>;
  /** Restrict search to these organization Ids */
  organizationInclude?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
  previousToken?: InputMaybe<Scalars['String']>;
};

export enum EventState {
  Cancelled = 'CANCELLED',
  Scheduled = 'SCHEDULED',
  Suspended = 'SUSPENDED'
}

export enum EventStatus {
  EventCancelled = 'EVENT_CANCELLED',
  EventEnded = 'EVENT_ENDED',
  RegistrationClosed = 'REGISTRATION_CLOSED',
  RegistrationOpen = 'REGISTRATION_OPEN',
  RegistrationWillOpen = 'REGISTRATION_WILL_OPEN'
}

export type Events = Errable & Pageable & {
  __typename?: 'Events';
  data?: Maybe<Array<Maybe<Event>>>;
  errors: Array<Maybe<Error>>;
  /** The computed event search used to return event data */
  eventSearch?: Maybe<EventSearch>;
  limit?: Maybe<Scalars['Int']>;
  nextToken?: Maybe<Scalars['String']>;
  previousToken?: Maybe<Scalars['String']>;
};

export type GeoLocation = Errable & {
  __typename?: 'GeoLocation';
  /** City name for this location */
  city?: Maybe<Array<Maybe<LocaleString>>>;
  /** Country for this location */
  country?: Maybe<Country>;
  errors: Array<Maybe<Error>>;
  /** GeoPoint used to identify this lcoation */
  geoPoint?: Maybe<GeoPoint>;
  /** Metro code for this location */
  metroCode?: Maybe<Scalars['String']>;
  /** Postal code for this location */
  postalCode?: Maybe<Scalars['String']>;
  /**
   * Contains a code (up to three characters) that represent the location’s region.
   * The region is the first-level subdivision (the broadest or least specific) of the ISO 3166-2 code.
   */
  regionCode?: Maybe<Scalars['String']>;
  /**
   * Contains the name of the location’s region. The region is the first-level
   * subdivision (the broadest or least specific) of the ISO 3166-2 code.
   */
  regionName?: Maybe<Array<Maybe<LocaleString>>>;
  /** Contains the location’s time zone, in IANA time zone database format. */
  timeZone?: Maybe<Scalars['String']>;
  /** Contains the location’s UTC offset. */
  utcOffset?: Maybe<Scalars['String']>;
};

export type GeoPoint = {
  __typename?: 'GeoPoint';
  /** Location latitude */
  lat: Scalars['Float'];
  /** Location longitude */
  lon: Scalars['Float'];
  /** Radius used when identifying a location. */
  radius?: Maybe<Scalars['Float']>;
  /** Unit used for Radius when identifying a location. */
  unit?: Maybe<GeoPointUnit>;
};

export type GeoPointInput = {
  /** Location latitude */
  lat: Scalars['Float'];
  locales?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
  /** Location longitude */
  lon: Scalars['Float'];
  maxRadius?: InputMaybe<Scalars['Float']>;
  /** Radius used when identifying a location. */
  minRadius?: InputMaybe<Scalars['Float']>;
  /**
   * Unit used for Radius when identifying a location.
   * Default: GeoPointUnit.MI
   */
  unit?: InputMaybe<GeoPointUnit>;
};

export enum GeoPointUnit {
  /** Kilometers */
  Km = 'KM',
  /** Miles */
  Mi = 'MI'
}

export type LocaleString = {
  __typename?: 'LocaleString';
  content: Scalars['String'];
  iso: Scalars['String'];
};

export type Localizable = {
  /** List of locale ISO codes to (eg: en-us) */
  locales?: Maybe<Array<Maybe<Scalars['String']>>>;
};

export type Media = Errable & {
  __typename?: 'Media';
  altText?: Maybe<Array<Maybe<LocaleString>>>;
  errors: Array<Maybe<Error>>;
  height?: Maybe<Scalars['Int']>;
  id?: Maybe<Scalars['ID']>;
  /** What type of media is this? */
  type?: Maybe<MediaType>;
  url?: Maybe<Scalars['String']>;
  /** Tags to indicate which use cases this media is suitable for. */
  usage?: Maybe<Array<Maybe<MediaUsage>>>;
  width?: Maybe<Scalars['Int']>;
};

export enum MediaType {
  Image = 'IMAGE',
  Video = 'VIDEO'
}

export enum MediaUsage {
  Hero = 'HERO',
  Tile = 'TILE'
}

export type Medias = Errable & Pageable & {
  __typename?: 'Medias';
  data?: Maybe<Array<Maybe<Media>>>;
  errors: Array<Maybe<Error>>;
  limit?: Maybe<Scalars['Int']>;
  nextToken?: Maybe<Scalars['String']>;
  previousToken?: Maybe<Scalars['String']>;
};

export type MetaData = Errable & {
  __typename?: 'MetaData';
  errors: Array<Maybe<Error>>;
  key?: Maybe<Scalars['String']>;
  value?: Maybe<Array<Maybe<LocaleString>>>;
};

export type MetaDatas = Errable & Pageable & {
  __typename?: 'MetaDatas';
  data?: Maybe<Array<Maybe<MetaData>>>;
  errors: Array<Maybe<Error>>;
  limit?: Maybe<Scalars['Int']>;
  nextToken?: Maybe<Scalars['String']>;
  previousToken?: Maybe<Scalars['String']>;
};

export type Organization = Errable & {
  __typename?: 'Organization';
  errors: Array<Maybe<Error>>;
  /** Unique Identifier for this record. */
  id?: Maybe<Scalars['ID']>;
  medias?: Maybe<Medias>;
  name?: Maybe<Array<Maybe<LocaleString>>>;
};

export type OrganizationInput = {
  id: Scalars['ID'];
  locales?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
};

export type Organizations = Errable & Pageable & {
  __typename?: 'Organizations';
  data?: Maybe<Array<Maybe<Organization>>>;
  errors: Array<Maybe<Error>>;
  limit?: Maybe<Scalars['Int']>;
  nextToken?: Maybe<Scalars['String']>;
  previousToken?: Maybe<Scalars['String']>;
};

export type OrganizationsInput = {
  limit?: InputMaybe<Scalars['Int']>;
  locales?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
  nextToken?: InputMaybe<Scalars['String']>;
  previousToken?: InputMaybe<Scalars['String']>;
};

export type Pageable = {
  limit?: Maybe<Scalars['Int']>;
  nextToken?: Maybe<Scalars['String']>;
  previousToken?: Maybe<Scalars['String']>;
};

export type Query = {
  __typename?: 'Query';
  countries?: Maybe<Countries>;
  country?: Maybe<Country>;
  discipline?: Maybe<Discipline>;
  disciplines?: Maybe<Disciplines>;
  event?: Maybe<Event>;
  eventCollection?: Maybe<EventCollection>;
  eventCollections?: Maybe<EventCollections>;
  events?: Maybe<Events>;
  /** Return a location based on GeoPoint input */
  geoLocation?: Maybe<GeoLocation>;
  organization?: Maybe<Organization>;
  organizations?: Maybe<Organizations>;
  venue?: Maybe<Venue>;
  venues?: Maybe<Venues>;
  widget?: Maybe<Widget>;
  widgets?: Maybe<Widgets>;
};


export type QueryCountriesArgs = {
  input?: InputMaybe<CountriesInput>;
};


export type QueryCountryArgs = {
  input?: InputMaybe<CountryInput>;
};


export type QueryDisciplineArgs = {
  input?: InputMaybe<DisciplineInput>;
};


export type QueryDisciplinesArgs = {
  input?: InputMaybe<DisciplinesInput>;
};


export type QueryEventArgs = {
  input?: InputMaybe<EventInput>;
};


export type QueryEventCollectionArgs = {
  input?: InputMaybe<EventCollectionInput>;
};


export type QueryEventCollectionsArgs = {
  input?: InputMaybe<EventCollectionsInput>;
};


export type QueryEventsArgs = {
  input?: InputMaybe<EventSearchInput>;
};


export type QueryGeoLocationArgs = {
  input?: InputMaybe<GeoPointInput>;
};


export type QueryOrganizationArgs = {
  input?: InputMaybe<OrganizationInput>;
};


export type QueryOrganizationsArgs = {
  input?: InputMaybe<OrganizationsInput>;
};


export type QueryVenueArgs = {
  input?: InputMaybe<VenueInput>;
};


export type QueryVenuesArgs = {
  input?: InputMaybe<VenuesInput>;
};


export type QueryWidgetArgs = {
  input?: InputMaybe<WidgetInput>;
};


export type QueryWidgetsArgs = {
  input?: InputMaybe<WidgetsInput>;
};

export type Segment = Errable & {
  __typename?: 'Segment';
  disciplines?: Maybe<Disciplines>;
  errors: Array<Maybe<Error>>;
  id?: Maybe<Scalars['ID']>;
  name?: Maybe<Array<Maybe<LocaleString>>>;
  segmentEnd?: Maybe<Scalars['String']>;
  segmentStart?: Maybe<Scalars['String']>;
  venues?: Maybe<Venues>;
};

export type Segments = Errable & Pageable & {
  __typename?: 'Segments';
  data?: Maybe<Array<Maybe<Segment>>>;
  errors: Array<Maybe<Error>>;
  limit?: Maybe<Scalars['Int']>;
  nextToken?: Maybe<Scalars['String']>;
  previousToken?: Maybe<Scalars['String']>;
};

export type Venue = Errable & {
  __typename?: 'Venue';
  errors: Array<Maybe<Error>>;
  geoLocation?: Maybe<GeoLocation>;
  /** Unique Identifier for this record. */
  id: Scalars['ID'];
  medias?: Maybe<Medias>;
  name?: Maybe<Array<Maybe<LocaleString>>>;
};

export type VenueInput = {
  id: Scalars['ID'];
  locales?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
};

export type Venues = Errable & Pageable & {
  __typename?: 'Venues';
  data?: Maybe<Array<Maybe<Venue>>>;
  errors: Array<Maybe<Error>>;
  limit?: Maybe<Scalars['Int']>;
  nextToken?: Maybe<Scalars['String']>;
  previousToken?: Maybe<Scalars['String']>;
};

export type VenuesInput = {
  limit?: InputMaybe<Scalars['Int']>;
  locales?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
  nextToken?: InputMaybe<Scalars['String']>;
  previousToken?: InputMaybe<Scalars['String']>;
};

export type Widget = Errable & {
  __typename?: 'Widget';
  /** Bag of strings used in the widget UI. */
  content?: Maybe<Array<Maybe<MetaData>>>;
  /** The default colelction to display in the widget */
  defaultEventCollection?: Maybe<EventCollection>;
  errors: Array<Maybe<Error>>;
  /** Other collections avaialble in the widget */
  eventCollections?: Maybe<EventCollections>;
  /** The computed event search used to return event data */
  eventSearch?: Maybe<EventSearch>;
  /** Events matching the widget search criteria and/or detected geo location */
  events?: Maybe<Events>;
  /** The location used to return this widget data */
  geoLocation?: Maybe<GeoLocation>;
  /** Unique Identifier for this record. */
  id: Scalars['ID'];
};

export type WidgetInput = {
  eventSearch?: InputMaybe<EventSearchInput>;
  id: Scalars['ID'];
  locales?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
};

export type Widgets = Errable & Pageable & {
  __typename?: 'Widgets';
  data?: Maybe<Array<Maybe<Widget>>>;
  errors: Array<Maybe<Error>>;
  limit?: Maybe<Scalars['Int']>;
  nextToken?: Maybe<Scalars['String']>;
  previousToken?: Maybe<Scalars['String']>;
};

export type WidgetsInput = {
  limit?: InputMaybe<Scalars['Int']>;
  locales?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
  nextToken?: InputMaybe<Scalars['String']>;
  previousToken?: InputMaybe<Scalars['String']>;
};