import * as VueApolloComposable from '@vue/apollo-composable'
import * as VueCompositionApi from 'vue'
import { gql } from '@/utils/gql'
export type Maybe<T> = T | null | undefined;
export type InputMaybe<T> = T | null | undefined;
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]> };
export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
export type ReactiveFunction<TParam> = () => TParam;
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: { input: string; output: string; }
  String: { input: string; output: string; }
  Boolean: { input: boolean; output: boolean; }
  Int: { input: number; output: number; }
  Float: { input: number; output: number; }
  LocalDate: { input: string; output: string; }
  LocalDateTime: { input: string; output: string; }
};

/** Band */
export type Band = {
  __typename?: 'Band';
  created: Scalars['LocalDateTime']['output'];
  id: Maybe<Scalars['Int']['output']>;
  name: Scalars['String']['output'];
};

/** DanceHall */
export type DanceHall = {
  __typename?: 'DanceHall';
  city: Maybe<Scalars['String']['output']>;
  created: Scalars['LocalDateTime']['output'];
  id: Maybe<Scalars['Int']['output']>;
  latitude: Maybe<Scalars['Float']['output']>;
  longitude: Maybe<Scalars['Float']['output']>;
  municipality: Maybe<Scalars['String']['output']>;
  name: Maybe<Scalars['String']['output']>;
  state: Maybe<Scalars['String']['output']>;
};

/** DanceHallDistance */
export type DanceHallDistance = {
  __typename?: 'DanceHallDistance';
  distance: Scalars['Int']['output'];
  duration: Scalars['String']['output'];
  origin: Scalars['String']['output'];
};

/** Event */
export type Event = {
  __typename?: 'Event';
  /** The band of the event */
  band: Maybe<Band>;
  created: Scalars['LocalDateTime']['output'];
  /** The place of the event */
  danceHall: Maybe<DanceHall>;
  /** The date of the event */
  date: Scalars['LocalDate']['output'];
  /** The driving distances and driving durations to the event from the provided origins */
  distances: Array<DanceHallDistance>;
  /** Additional information regarding the event */
  extraInfo: Maybe<Scalars['String']['output']>;
  id: Maybe<Scalars['Int']['output']>;
  /** The time of the event */
  time: Maybe<Scalars['String']['output']>;
};

export type Mutation = {
  __typename?: 'Mutation';
  /** Remove provided origin from authenticated user */
  RemoveOrigin: Scalars['Boolean']['output'];
  /** Save provided origin for authenticated user */
  SaveOrigin: Scalars['Boolean']['output'];
  /** Toggle band in ignore list */
  ToggleIgnoreBand: Scalars['Boolean']['output'];
  /** Toggle city in ignore list */
  ToggleIgnoreCity: Scalars['Boolean']['output'];
  /** Toggle dance hall in ignore list */
  ToggleIgnoreDanceHall: Scalars['Boolean']['output'];
  /** Toggle municipality in ignore list */
  ToggleIgnoreMunicipality: Scalars['Boolean']['output'];
  /** Toggle state in ignore list */
  ToggleIgnoreState: Scalars['Boolean']['output'];
};

export type MutationRemoveOriginArgs = {
  origin: Scalars['String']['input'];
};

export type MutationSaveOriginArgs = {
  origin: Scalars['String']['input'];
};

export type MutationToggleIgnoreBandArgs = {
  name: Scalars['String']['input'];
};

export type MutationToggleIgnoreCityArgs = {
  name: Scalars['String']['input'];
};

export type MutationToggleIgnoreDanceHallArgs = {
  name: Scalars['String']['input'];
};

export type MutationToggleIgnoreMunicipalityArgs = {
  name: Scalars['String']['input'];
};

export type MutationToggleIgnoreStateArgs = {
  name: Scalars['String']['input'];
};

export type Query = {
  __typename?: 'Query';
  /** Fetch address for provided lat/long */
  AddressFromLatLng: Scalars['String']['output'];
  /** Find bands given provided criteria */
  Bands: Array<Band>;
  /** Find dance halls given provided criteria */
  DanceHalls: Array<DanceHall>;
  /** Find events given provided criteria */
  Events: Array<Event>;
  /** Fetch ignored bands for authenticated user */
  IgnoredBands: Array<Scalars['String']['output']>;
  /** Fetch ignored cities for authenticated user */
  IgnoredCities: Array<Scalars['String']['output']>;
  /** Fetch ignored dance halls for authenticated user */
  IgnoredDanceHalls: Array<Scalars['String']['output']>;
  /** Fetch ignored municipalities for authenticated user */
  IgnoredMunicipalities: Array<Scalars['String']['output']>;
  /** Fetch ignored states for authenticated user */
  IgnoredStates: Array<Scalars['String']['output']>;
  /** Fetch origins for authenticated user */
  Origins: Array<Scalars['String']['output']>;
};

export type QueryAddressFromLatLngArgs = {
  latlng: Scalars['String']['input'];
};

export type QueryEventsArgs = {
  includeHidden?: InputMaybe<Scalars['Boolean']['input']>;
  origins?: InputMaybe<Array<Scalars['String']['input']>>;
  range?: InputMaybe<Range>;
  search?: InputMaybe<Scalars['String']['input']>;
};

export enum Range {
  OneMonth = 'ONE_MONTH',
  OneQuarter = 'ONE_QUARTER',
  OneWeek = 'ONE_WEEK',
  OneYear = 'ONE_YEAR',
  TwoWeeks = 'TWO_WEEKS'
}

export type RemoveOriginMutationVariables = Exact<{
  origin: Scalars['String']['input'];
}>;

export type RemoveOriginMutation = { __typename?: 'Mutation', removed: boolean };

export type SaveOriginMutationVariables = Exact<{
  origin: Scalars['String']['input'];
}>;

export type SaveOriginMutation = { __typename?: 'Mutation', saved: boolean };

export type ToggleIgnoreBandMutationVariables = Exact<{
  name: Scalars['String']['input'];
}>;

export type ToggleIgnoreBandMutation = { __typename?: 'Mutation', ignore: boolean };

export type ToggleIgnoreCityMutationVariables = Exact<{
  name: Scalars['String']['input'];
}>;

export type ToggleIgnoreCityMutation = { __typename?: 'Mutation', ignore: boolean };

export type ToggleIgnoreDanceHallMutationVariables = Exact<{
  name: Scalars['String']['input'];
}>;

export type ToggleIgnoreDanceHallMutation = { __typename?: 'Mutation', ignore: boolean };

export type ToggleIgnoreMunicipalityMutationVariables = Exact<{
  name: Scalars['String']['input'];
}>;

export type ToggleIgnoreMunicipalityMutation = { __typename?: 'Mutation', ignore: boolean };

export type ToggleIgnoreStateMutationVariables = Exact<{
  name: Scalars['String']['input'];
}>;

export type ToggleIgnoreStateMutation = { __typename?: 'Mutation', ignore: boolean };

export type FetchAddressQueryVariables = Exact<{
  latlng: Scalars['String']['input'];
}>;

export type FetchAddressQuery = { __typename?: 'Query', address: string };

export type FetchFiltersQueryVariables = Exact<{ [key: string]: never; }>;

export type FetchFiltersQuery = { __typename?: 'Query', bands: Array<string>, cities: Array<string>, states: Array<string>, danceHalls: Array<string>, municipalities: Array<string> };

export type FindEventsQueryVariables = Exact<{
  range?: InputMaybe<Range>;
  origins?: InputMaybe<Array<Scalars['String']['input']> | Scalars['String']['input']>;
  includeOrigins: Scalars['Boolean']['input'];
  search?: InputMaybe<Scalars['String']['input']>;
  includeHidden?: InputMaybe<Scalars['Boolean']['input']>;
}>;

export type FindEventsQuery = { __typename?: 'Query', origins: Array<string>, events: Array<{ __typename?: 'Event', date: string, time: string | null | undefined, extraInfo: string | null | undefined, band: { __typename?: 'Band', name: string } | null | undefined, danceHall: { __typename?: 'DanceHall', name: string | null | undefined, city: string | null | undefined, municipality: string | null | undefined, state: string | null | undefined } | null | undefined, distances: Array<{ __typename?: 'DanceHallDistance', origin: string, distance: number, duration: string }> }> };

export type FindOriginsQueryVariables = Exact<{ [key: string]: never; }>;

export type FindOriginsQuery = { __typename?: 'Query', origins: Array<string> };

export const RemoveOriginDocument = gql`
    mutation RemoveOrigin($origin: String!) {
  removed: RemoveOrigin(origin: $origin)
}
    `

/**
 * __useRemoveOriginMutation__
 *
 * To run a mutation, you first call `useRemoveOriginMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useRemoveOriginMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useRemoveOriginMutation({
 *   variables: {
 *     origin: // value for 'origin'
 *   },
 * });
 */
export function useRemoveOriginMutation (options: VueApolloComposable.UseMutationOptions<RemoveOriginMutation, RemoveOriginMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<RemoveOriginMutation, RemoveOriginMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<RemoveOriginMutation, RemoveOriginMutationVariables>(RemoveOriginDocument, options)
}
export type RemoveOriginMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<RemoveOriginMutation, RemoveOriginMutationVariables>;
export const SaveOriginDocument = gql`
    mutation SaveOrigin($origin: String!) {
  saved: SaveOrigin(origin: $origin)
}
    `

/**
 * __useSaveOriginMutation__
 *
 * To run a mutation, you first call `useSaveOriginMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useSaveOriginMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useSaveOriginMutation({
 *   variables: {
 *     origin: // value for 'origin'
 *   },
 * });
 */
export function useSaveOriginMutation (options: VueApolloComposable.UseMutationOptions<SaveOriginMutation, SaveOriginMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<SaveOriginMutation, SaveOriginMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<SaveOriginMutation, SaveOriginMutationVariables>(SaveOriginDocument, options)
}
export type SaveOriginMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<SaveOriginMutation, SaveOriginMutationVariables>;
export const ToggleIgnoreBandDocument = gql`
    mutation ToggleIgnoreBand($name: String!) {
  ignore: ToggleIgnoreBand(name: $name)
}
    `

/**
 * __useToggleIgnoreBandMutation__
 *
 * To run a mutation, you first call `useToggleIgnoreBandMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useToggleIgnoreBandMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useToggleIgnoreBandMutation({
 *   variables: {
 *     name: // value for 'name'
 *   },
 * });
 */
export function useToggleIgnoreBandMutation (options: VueApolloComposable.UseMutationOptions<ToggleIgnoreBandMutation, ToggleIgnoreBandMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<ToggleIgnoreBandMutation, ToggleIgnoreBandMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<ToggleIgnoreBandMutation, ToggleIgnoreBandMutationVariables>(ToggleIgnoreBandDocument, options)
}
export type ToggleIgnoreBandMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<ToggleIgnoreBandMutation, ToggleIgnoreBandMutationVariables>;
export const ToggleIgnoreCityDocument = gql`
    mutation ToggleIgnoreCity($name: String!) {
  ignore: ToggleIgnoreCity(name: $name)
}
    `

/**
 * __useToggleIgnoreCityMutation__
 *
 * To run a mutation, you first call `useToggleIgnoreCityMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useToggleIgnoreCityMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useToggleIgnoreCityMutation({
 *   variables: {
 *     name: // value for 'name'
 *   },
 * });
 */
export function useToggleIgnoreCityMutation (options: VueApolloComposable.UseMutationOptions<ToggleIgnoreCityMutation, ToggleIgnoreCityMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<ToggleIgnoreCityMutation, ToggleIgnoreCityMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<ToggleIgnoreCityMutation, ToggleIgnoreCityMutationVariables>(ToggleIgnoreCityDocument, options)
}
export type ToggleIgnoreCityMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<ToggleIgnoreCityMutation, ToggleIgnoreCityMutationVariables>;
export const ToggleIgnoreDanceHallDocument = gql`
    mutation ToggleIgnoreDanceHall($name: String!) {
  ignore: ToggleIgnoreDanceHall(name: $name)
}
    `

/**
 * __useToggleIgnoreDanceHallMutation__
 *
 * To run a mutation, you first call `useToggleIgnoreDanceHallMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useToggleIgnoreDanceHallMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useToggleIgnoreDanceHallMutation({
 *   variables: {
 *     name: // value for 'name'
 *   },
 * });
 */
export function useToggleIgnoreDanceHallMutation (options: VueApolloComposable.UseMutationOptions<ToggleIgnoreDanceHallMutation, ToggleIgnoreDanceHallMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<ToggleIgnoreDanceHallMutation, ToggleIgnoreDanceHallMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<ToggleIgnoreDanceHallMutation, ToggleIgnoreDanceHallMutationVariables>(ToggleIgnoreDanceHallDocument, options)
}
export type ToggleIgnoreDanceHallMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<ToggleIgnoreDanceHallMutation, ToggleIgnoreDanceHallMutationVariables>;
export const ToggleIgnoreMunicipalityDocument = gql`
    mutation ToggleIgnoreMunicipality($name: String!) {
  ignore: ToggleIgnoreMunicipality(name: $name)
}
    `

/**
 * __useToggleIgnoreMunicipalityMutation__
 *
 * To run a mutation, you first call `useToggleIgnoreMunicipalityMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useToggleIgnoreMunicipalityMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useToggleIgnoreMunicipalityMutation({
 *   variables: {
 *     name: // value for 'name'
 *   },
 * });
 */
export function useToggleIgnoreMunicipalityMutation (options: VueApolloComposable.UseMutationOptions<ToggleIgnoreMunicipalityMutation, ToggleIgnoreMunicipalityMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<ToggleIgnoreMunicipalityMutation, ToggleIgnoreMunicipalityMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<ToggleIgnoreMunicipalityMutation, ToggleIgnoreMunicipalityMutationVariables>(ToggleIgnoreMunicipalityDocument, options)
}
export type ToggleIgnoreMunicipalityMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<ToggleIgnoreMunicipalityMutation, ToggleIgnoreMunicipalityMutationVariables>;
export const ToggleIgnoreStateDocument = gql`
    mutation ToggleIgnoreState($name: String!) {
  ignore: ToggleIgnoreState(name: $name)
}
    `

/**
 * __useToggleIgnoreStateMutation__
 *
 * To run a mutation, you first call `useToggleIgnoreStateMutation` within a Vue component and pass it any options that fit your needs.
 * When your component renders, `useToggleIgnoreStateMutation` returns an object that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
 *
 * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
 *
 * @example
 * const { mutate, loading, error, onDone } = useToggleIgnoreStateMutation({
 *   variables: {
 *     name: // value for 'name'
 *   },
 * });
 */
export function useToggleIgnoreStateMutation (options: VueApolloComposable.UseMutationOptions<ToggleIgnoreStateMutation, ToggleIgnoreStateMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<ToggleIgnoreStateMutation, ToggleIgnoreStateMutationVariables>> = {}) {
  return VueApolloComposable.useMutation<ToggleIgnoreStateMutation, ToggleIgnoreStateMutationVariables>(ToggleIgnoreStateDocument, options)
}
export type ToggleIgnoreStateMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<ToggleIgnoreStateMutation, ToggleIgnoreStateMutationVariables>;
export const FetchAddressDocument = gql`
    query FetchAddress($latlng: String!) {
  address: AddressFromLatLng(latlng: $latlng)
}
    `

/**
 * __useFetchAddressQuery__
 *
 * To run a query within a Vue component, call `useFetchAddressQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchAddressQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param variables that will be passed into the query
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useFetchAddressQuery({
 *   latlng: // value for 'latlng'
 * });
 */
export function useFetchAddressQuery (variables: FetchAddressQueryVariables | VueCompositionApi.Ref<FetchAddressQueryVariables> | ReactiveFunction<FetchAddressQueryVariables>, options: VueApolloComposable.UseQueryOptions<FetchAddressQuery, FetchAddressQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<FetchAddressQuery, FetchAddressQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<FetchAddressQuery, FetchAddressQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<FetchAddressQuery, FetchAddressQueryVariables>(FetchAddressDocument, variables, options)
}
export function useFetchAddressLazyQuery (variables: FetchAddressQueryVariables | VueCompositionApi.Ref<FetchAddressQueryVariables> | ReactiveFunction<FetchAddressQueryVariables>, options: VueApolloComposable.UseQueryOptions<FetchAddressQuery, FetchAddressQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<FetchAddressQuery, FetchAddressQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<FetchAddressQuery, FetchAddressQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<FetchAddressQuery, FetchAddressQueryVariables>(FetchAddressDocument, variables, options)
}
export type FetchAddressQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<FetchAddressQuery, FetchAddressQueryVariables>;
export const FetchFiltersDocument = gql`
    query FetchFilters {
  bands: IgnoredBands
  cities: IgnoredCities
  states: IgnoredStates
  danceHalls: IgnoredDanceHalls
  municipalities: IgnoredMunicipalities
}
    `

/**
 * __useFetchFiltersQuery__
 *
 * To run a query within a Vue component, call `useFetchFiltersQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchFiltersQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useFetchFiltersQuery();
 */
export function useFetchFiltersQuery (options: VueApolloComposable.UseQueryOptions<FetchFiltersQuery, FetchFiltersQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<FetchFiltersQuery, FetchFiltersQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<FetchFiltersQuery, FetchFiltersQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<FetchFiltersQuery, FetchFiltersQueryVariables>(FetchFiltersDocument, {}, options)
}
export function useFetchFiltersLazyQuery (options: VueApolloComposable.UseQueryOptions<FetchFiltersQuery, FetchFiltersQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<FetchFiltersQuery, FetchFiltersQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<FetchFiltersQuery, FetchFiltersQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<FetchFiltersQuery, FetchFiltersQueryVariables>(FetchFiltersDocument, {}, options)
}
export type FetchFiltersQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<FetchFiltersQuery, FetchFiltersQueryVariables>;
export const FindEventsDocument = gql`
    query FindEvents($range: Range, $origins: [String!], $includeOrigins: Boolean!, $search: String, $includeHidden: Boolean) {
  events: Events(
    range: $range
    origins: $origins
    search: $search
    includeHidden: $includeHidden
  ) {
    date
    time
    band {
      name
    }
    danceHall {
      name
      city
      municipality
      state
    }
    extraInfo
    distances {
      origin
      distance
      duration
    }
  }
  origins: Origins @include(if: $includeOrigins)
}
    `

/**
 * __useFindEventsQuery__
 *
 * To run a query within a Vue component, call `useFindEventsQuery` and pass it any options that fit your needs.
 * When your component renders, `useFindEventsQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param variables that will be passed into the query
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useFindEventsQuery({
 *   range: // value for 'range'
 *   origins: // value for 'origins'
 *   includeOrigins: // value for 'includeOrigins'
 *   search: // value for 'search'
 *   includeHidden: // value for 'includeHidden'
 * });
 */
export function useFindEventsQuery (variables: FindEventsQueryVariables | VueCompositionApi.Ref<FindEventsQueryVariables> | ReactiveFunction<FindEventsQueryVariables>, options: VueApolloComposable.UseQueryOptions<FindEventsQuery, FindEventsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<FindEventsQuery, FindEventsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<FindEventsQuery, FindEventsQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<FindEventsQuery, FindEventsQueryVariables>(FindEventsDocument, variables, options)
}
export function useFindEventsLazyQuery (variables: FindEventsQueryVariables | VueCompositionApi.Ref<FindEventsQueryVariables> | ReactiveFunction<FindEventsQueryVariables>, options: VueApolloComposable.UseQueryOptions<FindEventsQuery, FindEventsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<FindEventsQuery, FindEventsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<FindEventsQuery, FindEventsQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<FindEventsQuery, FindEventsQueryVariables>(FindEventsDocument, variables, options)
}
export type FindEventsQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<FindEventsQuery, FindEventsQueryVariables>;
export const FindOriginsDocument = gql`
    query FindOrigins {
  origins: Origins
}
    `

/**
 * __useFindOriginsQuery__
 *
 * To run a query within a Vue component, call `useFindOriginsQuery` and pass it any options that fit your needs.
 * When your component renders, `useFindOriginsQuery` returns an object from Apollo Client that contains result, loading and error properties
 * you can use to render your UI.
 *
 * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
 *
 * @example
 * const { result, loading, error } = useFindOriginsQuery();
 */
export function useFindOriginsQuery (options: VueApolloComposable.UseQueryOptions<FindOriginsQuery, FindOriginsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<FindOriginsQuery, FindOriginsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<FindOriginsQuery, FindOriginsQueryVariables>> = {}) {
  return VueApolloComposable.useQuery<FindOriginsQuery, FindOriginsQueryVariables>(FindOriginsDocument, {}, options)
}
export function useFindOriginsLazyQuery (options: VueApolloComposable.UseQueryOptions<FindOriginsQuery, FindOriginsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<FindOriginsQuery, FindOriginsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<FindOriginsQuery, FindOriginsQueryVariables>> = {}) {
  return VueApolloComposable.useLazyQuery<FindOriginsQuery, FindOriginsQueryVariables>(FindOriginsDocument, {}, options)
}
export type FindOriginsQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<FindOriginsQuery, FindOriginsQueryVariables>;

export interface PossibleTypesResultData {
        possibleTypes: {
          [key: string]: string[]
        }
      }
const result: PossibleTypesResultData = {
  possibleTypes: {}
}
export default result