chore: refactor a lot, add codegen and upgrade vue

graphql/generated/operations.ts

@@ -0,0 +1,571 @@
+import gql from 'graphql-tag';
+import * as VueApolloComposable from '@vue/apollo-composable';
+import * as VueCompositionApi from 'vue';
+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 ReactiveFunction<TParam> = () => TParam;
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: string;
+  String: string;
+  Boolean: boolean;
+  Int: number;
+  Float: number;
+  LocalDate: string;
+  LocalDateTime: string;
+};
+
+/** Band */
+export type Band = {
+  __typename?: 'Band';
+  created: Scalars['LocalDateTime'];
+  id: Maybe<Scalars['Int']>;
+  name: Scalars['String'];
+};
+
+/** DanceHall */
+export type DanceHall = {
+  __typename?: 'DanceHall';
+  city: Maybe<Scalars['String']>;
+  created: Scalars['LocalDateTime'];
+  id: Maybe<Scalars['Int']>;
+  latitude: Maybe<Scalars['Float']>;
+  longitude: Maybe<Scalars['Float']>;
+  municipality: Maybe<Scalars['String']>;
+  name: Maybe<Scalars['String']>;
+  state: Maybe<Scalars['String']>;
+};
+
+/** DanceHallDistance */
+export type DanceHallDistance = {
+  __typename?: 'DanceHallDistance';
+  distance: Scalars['Int'];
+  duration: Scalars['String'];
+  origin: Scalars['String'];
+};
+
+/** Event */
+export type Event = {
+  __typename?: 'Event';
+  /** The band of the event */
+  band: Maybe<Band>;
+  created: Scalars['LocalDateTime'];
+  /** The place of the event */
+  danceHall: Maybe<DanceHall>;
+  /** The date of the event */
+  date: Scalars['LocalDate'];
+  /** 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']>;
+  id: Maybe<Scalars['Int']>;
+  /** The time of the event */
+  time: Maybe<Scalars['String']>;
+};
+
+export type Mutation = {
+  __typename?: 'Mutation';
+  /** Remove provided origin from authenticated user */
+  RemoveOrigin: Scalars['Boolean'];
+  /** Save provided origin for authenticated user */
+  SaveOrigin: Scalars['Boolean'];
+  /** Toggle band in ignore list */
+  ToggleIgnoreBand: Scalars['Boolean'];
+  /** Toggle city in ignore list */
+  ToggleIgnoreCity: Scalars['Boolean'];
+  /** Toggle dance hall in ignore list */
+  ToggleIgnoreDanceHall: Scalars['Boolean'];
+  /** Toggle municipality in ignore list */
+  ToggleIgnoreMunicipality: Scalars['Boolean'];
+  /** Toggle state in ignore list */
+  ToggleIgnoreState: Scalars['Boolean'];
+};
+
+
+export type MutationRemoveOriginArgs = {
+  origin: Scalars['String'];
+};
+
+
+export type MutationSaveOriginArgs = {
+  origin: Scalars['String'];
+};
+
+
+export type MutationToggleIgnoreBandArgs = {
+  name: Scalars['String'];
+};
+
+
+export type MutationToggleIgnoreCityArgs = {
+  name: Scalars['String'];
+};
+
+
+export type MutationToggleIgnoreDanceHallArgs = {
+  name: Scalars['String'];
+};
+
+
+export type MutationToggleIgnoreMunicipalityArgs = {
+  name: Scalars['String'];
+};
+
+
+export type MutationToggleIgnoreStateArgs = {
+  name: Scalars['String'];
+};
+
+export type Query = {
+  __typename?: 'Query';
+  /** Fetch address for provided lat/long */
+  AddressFromLatLng: Scalars['String'];
+  /** 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']>;
+  /** Fetch ignored cities for authenticated user */
+  IgnoredCities: Array<Scalars['String']>;
+  /** Fetch ignored dance halls for authenticated user */
+  IgnoredDanceHalls: Array<Scalars['String']>;
+  /** Fetch ignored municipalities for authenticated user */
+  IgnoredMunicipalities: Array<Scalars['String']>;
+  /** Fetch ignored states for authenticated user */
+  IgnoredStates: Array<Scalars['String']>;
+  /** Fetch origins for authenticated user */
+  Origins: Array<Scalars['String']>;
+};
+
+
+export type QueryAddressFromLatLngArgs = {
+  latlng: Scalars['String'];
+};
+
+
+export type QueryEventsArgs = {
+  origins?: InputMaybe<Array<Scalars['String']>>;
+  range?: InputMaybe<Range>;
+};
+
+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'];
+}>;
+
+
+export type RemoveOriginMutation = { __typename?: 'Mutation', removed: boolean };
+
+export type SaveOriginMutationVariables = Exact<{
+  origin: Scalars['String'];
+}>;
+
+
+export type SaveOriginMutation = { __typename?: 'Mutation', saved: boolean };
+
+export type ToggleIgnoreBandMutationVariables = Exact<{
+  name: Scalars['String'];
+}>;
+
+
+export type ToggleIgnoreBandMutation = { __typename?: 'Mutation', ignore: boolean };
+
+export type ToggleIgnoreCityMutationVariables = Exact<{
+  name: Scalars['String'];
+}>;
+
+
+export type ToggleIgnoreCityMutation = { __typename?: 'Mutation', ignore: boolean };
+
+export type ToggleIgnoreDanceHallMutationVariables = Exact<{
+  name: Scalars['String'];
+}>;
+
+
+export type ToggleIgnoreDanceHallMutation = { __typename?: 'Mutation', ignore: boolean };
+
+export type ToggleIgnoreMunicipalityMutationVariables = Exact<{
+  name: Scalars['String'];
+}>;
+
+
+export type ToggleIgnoreMunicipalityMutation = { __typename?: 'Mutation', ignore: boolean };
+
+export type ToggleIgnoreStateMutationVariables = Exact<{
+  name: Scalars['String'];
+}>;
+
+
+export type ToggleIgnoreStateMutation = { __typename?: 'Mutation', ignore: boolean };
+
+export type FetchAddressQueryVariables = Exact<{
+  latlng: Scalars['String'];
+}>;
+
+
+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']> | Scalars['String']>;
+  includeOrigins: Scalars['Boolean'];
+}>;
+
+
+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!) {
+  events: Events(range: $range, origins: $origins) {
+    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'
+ * });
+ */
+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;
+    

graphql/mutations/RemoveOrigin.graphql

@@ -0,0 +1,3 @@
+mutation RemoveOrigin($origin: String!) {
+  removed: RemoveOrigin(origin: $origin)
+}

graphql/mutations/SaveOrigin.graphql

@@ -0,0 +1,3 @@
+mutation SaveOrigin($origin: String!) {
+  saved: SaveOrigin(origin: $origin)
+}

graphql/mutations/ToggleIgnoreBand.graphql

@@ -0,0 +1,3 @@
+mutation ToggleIgnoreBand($name: String!) {
+  ignore: ToggleIgnoreBand(name: $name)
+}

graphql/mutations/ToggleIgnoreCity.graphql

@@ -0,0 +1,3 @@
+mutation ToggleIgnoreCity($name: String!) {
+  ignore: ToggleIgnoreCity(name: $name)
+}

graphql/mutations/ToggleIgnoreDanceHall.graphql

@@ -0,0 +1,3 @@
+mutation ToggleIgnoreDanceHall($name: String!) {
+  ignore: ToggleIgnoreDanceHall(name: $name)
+}

graphql/mutations/ToggleIgnoreMunicipality.graphql

@@ -0,0 +1,3 @@
+mutation ToggleIgnoreMunicipality($name: String!) {
+  ignore: ToggleIgnoreMunicipality(name: $name)
+}

graphql/mutations/ToggleIgnoreState.graphql

@@ -0,0 +1,3 @@
+mutation ToggleIgnoreState($name: String!) {
+  ignore: ToggleIgnoreState(name: $name)
+}

graphql/queries/FetchAddress.graphql

@@ -0,0 +1,3 @@
+query FetchAddress($latlng: String!) {
+  address: AddressFromLatLng(latlng: $latlng)
+}

graphql/queries/FetchFilters.graphql

@@ -0,0 +1,7 @@
+query FetchFilters {
+  bands: IgnoredBands
+  cities: IgnoredCities
+  states: IgnoredStates
+  danceHalls: IgnoredDanceHalls
+  municipalities: IgnoredMunicipalities
+}

graphql/queries/FindEvents.graphql

@@ -0,0 +1,22 @@
+query FindEvents($range: Range, $origins: [String!], $includeOrigins: Boolean!) {
+  events: Events(range: $range, origins: $origins) {
+    date
+    time
+    band {
+      name
+    }
+    danceHall {
+      name
+      city
+      municipality
+      state
+    }
+    extraInfo
+    distances {
+      origin
+      distance
+      duration
+    }
+  }
+  origins: Origins @include(if: $includeOrigins)
+}

graphql/queries/FindOrigins.graphql

@@ -0,0 +1,3 @@
+query FindOrigins {
+  origins: Origins
+}

graphql/schema.graphql

@@ -0,0 +1,121 @@
+# source: https://dancefinder.unbound.se/graph/
+# timestamp: Wed Jul 03 2019 13:36:10 GMT+0200 (Central European Summer Time)
+
+"""Band"""
+type Band {
+  id: Int
+  name: String!
+  created: LocalDateTime!
+}
+
+"""DanceHall"""
+type DanceHall {
+  id: Int
+  name: String
+  city: String
+  municipality: String
+  state: String
+  latitude: Float
+  longitude: Float
+  created: LocalDateTime!
+}
+
+"""DanceHallDistance"""
+type DanceHallDistance {
+  origin: String!
+  distance: Int!
+  duration: String!
+}
+
+"""Event"""
+type Event {
+  id: Int
+
+  """The date of the event"""
+  date: LocalDate!
+
+  """The time of the event"""
+  time: String
+
+  """Additional information regarding the event"""
+  extraInfo: String
+  created: LocalDateTime!
+
+  """The band of the event"""
+  band: Band
+
+  """The place of the event"""
+  danceHall: DanceHall
+
+  """
+  The driving distances and driving durations to the event from the provided origins
+  """
+  distances: [DanceHallDistance!]!
+}
+
+scalar LocalDate
+
+scalar LocalDateTime
+
+type Mutation {
+  """Toggle band in ignore list"""
+  ToggleIgnoreBand(name: String!): Boolean!
+
+  """Toggle dance hall in ignore list"""
+  ToggleIgnoreDanceHall(name: String!): Boolean!
+
+  """Toggle city in ignore list"""
+  ToggleIgnoreCity(name: String!): Boolean!
+
+  """Toggle municipality in ignore list"""
+  ToggleIgnoreMunicipality(name: String!): Boolean!
+
+  """Toggle state in ignore list"""
+  ToggleIgnoreState(name: String!): Boolean!
+
+  """Save provided origin for authenticated user"""
+  SaveOrigin(origin: String!): Boolean!
+
+  """Remove provided origin from authenticated user"""
+  RemoveOrigin(origin: String!): Boolean!
+}
+
+type Query {
+  """Find events given provided criteria"""
+  Events(range: Range, origins: [String!]): [Event!]!
+
+  """Find bands given provided criteria"""
+  Bands: [Band!]!
+
+  """Find dance halls given provided criteria"""
+  DanceHalls: [DanceHall!]!
+
+  """Fetch origins for authenticated user"""
+  Origins: [String!]!
+
+  """Fetch address for provided lat/long"""
+  AddressFromLatLng(latlng: String!): String!
+
+  """Fetch ignored bands for authenticated user"""
+  IgnoredBands: [String!]!
+
+  """Fetch ignored dance halls for authenticated user"""
+  IgnoredDanceHalls: [String!]!
+
+  """Fetch ignored cities for authenticated user"""
+  IgnoredCities: [String!]!
+
+  """Fetch ignored municipalities for authenticated user"""
+  IgnoredMunicipalities: [String!]!
+
+  """Fetch ignored states for authenticated user"""
+  IgnoredStates: [String!]!
+}
+
+enum Range {
+  ONE_MONTH
+  ONE_YEAR
+  TWO_WEEKS
+  ONE_QUARTER
+  ONE_WEEK
+}