dancefinder-app/graphql/generated/operations.ts

import * as VueApolloComposable from '@vue/apollo-composable'
import type * 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