20230217: Generate .generated.ts from gql

package.json

@@ -70,6 +70,7 @@
     "@babel/preset-typescript": "^7.18.6",
     "@graphql-codegen/cli": "^3.0.0",
     "@graphql-codegen/introspection": "^3.0.0",
+    "@graphql-codegen/near-operation-file-preset": "^2.5.0",
     "@graphql-codegen/typescript": "^3.0.0",
     "@graphql-codegen/typescript-operations": "^3.0.0",
     "@graphql-codegen/typescript-react-apollo": "^3.3.7",

src/queries/__generated__/councilMember.generated.tsx

@@ -0,0 +1,48 @@
+import * as Types from './baseTypes.generated';
+
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {} as const;
+export type GetCouncilMembersQueryVariables = Types.Exact<{ [key: string]: never; }>;
+
+
+export type GetCouncilMembersQuery = { __typename: 'Query', councilMembers: Array<{ __typename: 'CouncilMember', electedInCouncilId: string, member: { __typename: 'Membership', handle: string } }> };
+
+
+export const GetCouncilMembersDocument = gql`
+    query getCouncilMembers {
+  councilMembers {
+    electedInCouncilId
+    member {
+      handle
+    }
+  }
+}
+    `;
+
+/**
+ * __useGetCouncilMembersQuery__
+ *
+ * To run a query within a React component, call `useGetCouncilMembersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetCouncilMembersQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetCouncilMembersQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useGetCouncilMembersQuery(baseOptions?: Apollo.QueryHookOptions<GetCouncilMembersQuery, GetCouncilMembersQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetCouncilMembersQuery, GetCouncilMembersQueryVariables>(GetCouncilMembersDocument, options);
+      }
+export function useGetCouncilMembersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetCouncilMembersQuery, GetCouncilMembersQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetCouncilMembersQuery, GetCouncilMembersQueryVariables>(GetCouncilMembersDocument, options);
+        }
+export type GetCouncilMembersQueryHookResult = ReturnType<typeof useGetCouncilMembersQuery>;
+export type GetCouncilMembersLazyQueryHookResult = ReturnType<typeof useGetCouncilMembersLazyQuery>;
+export type GetCouncilMembersQueryResult = Apollo.QueryResult<GetCouncilMembersQuery, GetCouncilMembersQueryVariables>;

src/queries/__generated__/councils.generated.tsx

@@ -0,0 +1,92 @@
+import * as Types from './baseTypes.generated';
+
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {} as const;
+export type GetElectedCouncilsQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.ElectedCouncilWhereInput>;
+  orderBy?: Types.InputMaybe<Array<Types.ElectedCouncilOrderByInput> | Types.ElectedCouncilOrderByInput>;
+  offset?: Types.InputMaybe<Types.Scalars['Int']>;
+  limit?: Types.InputMaybe<Types.Scalars['Int']>;
+}>;
+
+
+export type GetElectedCouncilsQuery = { __typename: 'Query', electedCouncils: Array<{ __typename: 'ElectedCouncil', id: string, electedAtBlock: number, endedAtBlock?: number | null, electedAtTime: any, endedAtTime?: any | null, electedAtNetwork: Types.Network, endedAtNetwork?: Types.Network | null, councilElections: Array<{ __typename: 'ElectionRound', cycleId: number }>, councilMembers: Array<{ __typename: 'CouncilMember', id: string, unpaidReward: string, stake: string, member: { __typename: 'Membership', councilMembers: Array<{ __typename: 'CouncilMember' }> } }> }> };
+
+export type ElectedCouncilFieldsFragment = { __typename: 'ElectedCouncil', id: string, electedAtBlock: number, endedAtBlock?: number | null, electedAtTime: any, endedAtTime?: any | null, electedAtNetwork: Types.Network, endedAtNetwork?: Types.Network | null, councilElections: Array<{ __typename: 'ElectionRound', cycleId: number }>, councilMembers: Array<{ __typename: 'CouncilMember', id: string, unpaidReward: string, stake: string, member: { __typename: 'Membership', councilMembers: Array<{ __typename: 'CouncilMember' }> } }> };
+
+export type CouncilMemberFieldsFragment = { __typename: 'CouncilMember', id: string, unpaidReward: string, stake: string, member: { __typename: 'Membership', councilMembers: Array<{ __typename: 'CouncilMember' }> } };
+
+export const CouncilMemberFieldsFragmentDoc = gql`
+    fragment CouncilMemberFields on CouncilMember {
+  id
+  member {
+    councilMembers {
+      __typename
+    }
+  }
+  unpaidReward
+  stake
+}
+    `;
+export const ElectedCouncilFieldsFragmentDoc = gql`
+    fragment ElectedCouncilFields on ElectedCouncil {
+  id
+  electedAtBlock
+  endedAtBlock
+  electedAtTime
+  endedAtTime
+  electedAtNetwork
+  endedAtNetwork
+  councilElections {
+    cycleId
+  }
+  councilMembers {
+    ...CouncilMemberFields
+  }
+}
+    ${CouncilMemberFieldsFragmentDoc}`;
+export const GetElectedCouncilsDocument = gql`
+    query GetElectedCouncils($where: ElectedCouncilWhereInput, $orderBy: [ElectedCouncilOrderByInput!], $offset: Int, $limit: Int) {
+  electedCouncils(
+    where: $where
+    orderBy: $orderBy
+    offset: $offset
+    limit: $limit
+  ) {
+    ...ElectedCouncilFields
+    __typename
+  }
+}
+    ${ElectedCouncilFieldsFragmentDoc}`;
+
+/**
+ * __useGetElectedCouncilsQuery__
+ *
+ * To run a query within a React component, call `useGetElectedCouncilsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetElectedCouncilsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetElectedCouncilsQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *      orderBy: // value for 'orderBy'
+ *      offset: // value for 'offset'
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export function useGetElectedCouncilsQuery(baseOptions?: Apollo.QueryHookOptions<GetElectedCouncilsQuery, GetElectedCouncilsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetElectedCouncilsQuery, GetElectedCouncilsQueryVariables>(GetElectedCouncilsDocument, options);
+      }
+export function useGetElectedCouncilsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetElectedCouncilsQuery, GetElectedCouncilsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetElectedCouncilsQuery, GetElectedCouncilsQueryVariables>(GetElectedCouncilsDocument, options);
+        }
+export type GetElectedCouncilsQueryHookResult = ReturnType<typeof useGetElectedCouncilsQuery>;
+export type GetElectedCouncilsLazyQueryHookResult = ReturnType<typeof useGetElectedCouncilsLazyQuery>;
+export type GetElectedCouncilsQueryResult = Apollo.QueryResult<GetElectedCouncilsQuery, GetElectedCouncilsQueryVariables>;

src/queries/__generated__/election.generated.tsx

@@ -0,0 +1,71 @@
+import * as Types from './baseTypes.generated';
+
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {} as const;
+export type GetElectionsQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.ElectionRoundWhereInput>;
+  orderBy?: Types.InputMaybe<Array<Types.ElectionRoundOrderByInput> | Types.ElectionRoundOrderByInput>;
+  offset?: Types.InputMaybe<Types.Scalars['Int']>;
+  limit?: Types.InputMaybe<Types.Scalars['Int']>;
+}>;
+
+
+export type GetElectionsQuery = { __typename: 'Query', electionRounds: Array<{ __typename: 'ElectionRound', id: string, cycleId: number, endedAtBlock?: number | null, endedAtTime?: any | null, endedAtNetwork?: Types.Network | null, candidates: Array<{ __typename: 'Candidate', stake: string }>, castVotes: Array<{ __typename: 'CastVote', voteForId?: string | null }> }> };
+
+export type ElectionRoundFieldsFragment = { __typename: 'ElectionRound', id: string, cycleId: number, endedAtBlock?: number | null, endedAtTime?: any | null, endedAtNetwork?: Types.Network | null, candidates: Array<{ __typename: 'Candidate', stake: string }>, castVotes: Array<{ __typename: 'CastVote', voteForId?: string | null }> };
+
+export const ElectionRoundFieldsFragmentDoc = gql`
+    fragment ElectionRoundFields on ElectionRound {
+  id
+  cycleId
+  endedAtBlock
+  endedAtTime
+  endedAtNetwork
+  candidates {
+    stake
+  }
+  castVotes {
+    voteForId
+  }
+}
+    `;
+export const GetElectionsDocument = gql`
+    query GetElections($where: ElectionRoundWhereInput, $orderBy: [ElectionRoundOrderByInput!], $offset: Int, $limit: Int) {
+  electionRounds(where: $where, orderBy: $orderBy, offset: $offset, limit: $limit) {
+    ...ElectionRoundFields
+    __typename
+  }
+}
+    ${ElectionRoundFieldsFragmentDoc}`;
+
+/**
+ * __useGetElectionsQuery__
+ *
+ * To run a query within a React component, call `useGetElectionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetElectionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetElectionsQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *      orderBy: // value for 'orderBy'
+ *      offset: // value for 'offset'
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export function useGetElectionsQuery(baseOptions?: Apollo.QueryHookOptions<GetElectionsQuery, GetElectionsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetElectionsQuery, GetElectionsQueryVariables>(GetElectionsDocument, options);
+      }
+export function useGetElectionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetElectionsQuery, GetElectionsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetElectionsQuery, GetElectionsQueryVariables>(GetElectionsDocument, options);
+        }
+export type GetElectionsQueryHookResult = ReturnType<typeof useGetElectionsQuery>;
+export type GetElectionsLazyQueryHookResult = ReturnType<typeof useGetElectionsLazyQuery>;
+export type GetElectionsQueryResult = Apollo.QueryResult<GetElectionsQuery, GetElectionsQueryVariables>;

src/queries/__generated__/members.generated.tsx

@@ -0,0 +1,245 @@
+import * as Types from './baseTypes.generated';
+
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {} as const;
+export type GetMembersCountQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.MembershipWhereInput>;
+}>;
+
+
+export type GetMembersCountQuery = { __typename: 'Query', membershipsConnection: { __typename: 'MembershipConnection', totalCount: number } };
+
+export type GetMembersQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.MembershipWhereInput>;
+  orderBy?: Types.InputMaybe<Array<Types.MembershipOrderByInput> | Types.MembershipOrderByInput>;
+  offset?: Types.InputMaybe<Types.Scalars['Int']>;
+  limit?: Types.InputMaybe<Types.Scalars['Int']>;
+}>;
+
+
+export type GetMembersQuery = { __typename: 'Query', memberships: Array<{ __typename: 'Membership', id: string, rootAccount: string, controllerAccount: string, boundAccounts: Array<string>, handle: string, isVerified: boolean, isFoundingMember: boolean, isCouncilMember: boolean, inviteCount: number, createdAt: any, metadata: { __typename: 'MemberMetadata', name?: string | null, about?: string | null, avatar?: { __typename: 'AvatarObject' } | { __typename: 'AvatarUri', avatarUri: string } | null }, roles: Array<{ __typename: 'Worker', id: string, createdAt: any, isLead: boolean, group: { __typename: 'WorkingGroup', name: string } }>, stakingaccountaddedeventmember?: Array<{ __typename: 'StakingAccountAddedEvent', createdAt: any, inBlock: number, network: Types.Network, account: string }> | null }> };
+
+export type GetInvitedMembersCountQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.MemberInvitedEventWhereInput>;
+}>;
+
+
+export type GetInvitedMembersCountQuery = { __typename: 'Query', memberInvitedEventsConnection: { __typename: 'MemberInvitedEventConnection', totalCount: number } };
+
+export type GetInvitedMembersQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.MemberInvitedEventWhereInput>;
+  orderBy?: Types.InputMaybe<Array<Types.MemberInvitedEventOrderByInput> | Types.MemberInvitedEventOrderByInput>;
+  offset?: Types.InputMaybe<Types.Scalars['Int']>;
+  limit?: Types.InputMaybe<Types.Scalars['Int']>;
+}>;
+
+
+export type GetInvitedMembersQuery = { __typename: 'Query', memberInvitedEvents: Array<{ __typename: 'MemberInvitedEvent', id: string, createdAt: any, invitingMember: { __typename: 'Membership', id: string, rootAccount: string, controllerAccount: string, boundAccounts: Array<string>, handle: string, isVerified: boolean, isFoundingMember: boolean, isCouncilMember: boolean, inviteCount: number, createdAt: any, metadata: { __typename: 'MemberMetadata', name?: string | null, about?: string | null, avatar?: { __typename: 'AvatarObject' } | { __typename: 'AvatarUri', avatarUri: string } | null }, roles: Array<{ __typename: 'Worker', id: string, createdAt: any, isLead: boolean, group: { __typename: 'WorkingGroup', name: string } }>, stakingaccountaddedeventmember?: Array<{ __typename: 'StakingAccountAddedEvent', createdAt: any, inBlock: number, network: Types.Network, account: string }> | null }, newMember: { __typename: 'Membership', id: string, rootAccount: string, controllerAccount: string, boundAccounts: Array<string>, handle: string, isVerified: boolean, isFoundingMember: boolean, isCouncilMember: boolean, inviteCount: number, createdAt: any, metadata: { __typename: 'MemberMetadata', name?: string | null, about?: string | null, avatar?: { __typename: 'AvatarObject' } | { __typename: 'AvatarUri', avatarUri: string } | null }, roles: Array<{ __typename: 'Worker', id: string, createdAt: any, isLead: boolean, group: { __typename: 'WorkingGroup', name: string } }>, stakingaccountaddedeventmember?: Array<{ __typename: 'StakingAccountAddedEvent', createdAt: any, inBlock: number, network: Types.Network, account: string }> | null } }> };
+
+export type MemberFieldsFragment = { __typename: 'Membership', id: string, rootAccount: string, controllerAccount: string, boundAccounts: Array<string>, handle: string, isVerified: boolean, isFoundingMember: boolean, isCouncilMember: boolean, inviteCount: number, createdAt: any, metadata: { __typename: 'MemberMetadata', name?: string | null, about?: string | null, avatar?: { __typename: 'AvatarObject' } | { __typename: 'AvatarUri', avatarUri: string } | null }, roles: Array<{ __typename: 'Worker', id: string, createdAt: any, isLead: boolean, group: { __typename: 'WorkingGroup', name: string } }>, stakingaccountaddedeventmember?: Array<{ __typename: 'StakingAccountAddedEvent', createdAt: any, inBlock: number, network: Types.Network, account: string }> | null };
+
+export const MemberFieldsFragmentDoc = gql`
+    fragment MemberFields on Membership {
+  id
+  rootAccount
+  controllerAccount
+  boundAccounts
+  handle
+  metadata {
+    name
+    about
+    avatar {
+      __typename
+      ... on AvatarUri {
+        avatarUri
+        __typename
+      }
+    }
+    __typename
+  }
+  isVerified
+  isFoundingMember
+  isCouncilMember
+  inviteCount
+  roles {
+    id
+    group {
+      name
+      __typename
+    }
+    createdAt
+    isLead
+    __typename
+  }
+  createdAt
+  stakingaccountaddedeventmember {
+    createdAt
+    inBlock
+    network
+    account
+    __typename
+  }
+  __typename
+}
+    `;
+export const GetMembersCountDocument = gql`
+    query GetMembersCount($where: MembershipWhereInput) {
+  membershipsConnection(where: $where) {
+    totalCount
+    __typename
+  }
+}
+    `;
+
+/**
+ * __useGetMembersCountQuery__
+ *
+ * To run a query within a React component, call `useGetMembersCountQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMembersCountQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetMembersCountQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetMembersCountQuery(baseOptions?: Apollo.QueryHookOptions<GetMembersCountQuery, GetMembersCountQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetMembersCountQuery, GetMembersCountQueryVariables>(GetMembersCountDocument, options);
+      }
+export function useGetMembersCountLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetMembersCountQuery, GetMembersCountQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetMembersCountQuery, GetMembersCountQueryVariables>(GetMembersCountDocument, options);
+        }
+export type GetMembersCountQueryHookResult = ReturnType<typeof useGetMembersCountQuery>;
+export type GetMembersCountLazyQueryHookResult = ReturnType<typeof useGetMembersCountLazyQuery>;
+export type GetMembersCountQueryResult = Apollo.QueryResult<GetMembersCountQuery, GetMembersCountQueryVariables>;
+export const GetMembersDocument = gql`
+    query GetMembers($where: MembershipWhereInput, $orderBy: [MembershipOrderByInput!], $offset: Int, $limit: Int) {
+  memberships(where: $where, orderBy: $orderBy, offset: $offset, limit: $limit) {
+    ...MemberFields
+    __typename
+  }
+}
+    ${MemberFieldsFragmentDoc}`;
+
+/**
+ * __useGetMembersQuery__
+ *
+ * To run a query within a React component, call `useGetMembersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMembersQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetMembersQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *      orderBy: // value for 'orderBy'
+ *      offset: // value for 'offset'
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export function useGetMembersQuery(baseOptions?: Apollo.QueryHookOptions<GetMembersQuery, GetMembersQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetMembersQuery, GetMembersQueryVariables>(GetMembersDocument, options);
+      }
+export function useGetMembersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetMembersQuery, GetMembersQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetMembersQuery, GetMembersQueryVariables>(GetMembersDocument, options);
+        }
+export type GetMembersQueryHookResult = ReturnType<typeof useGetMembersQuery>;
+export type GetMembersLazyQueryHookResult = ReturnType<typeof useGetMembersLazyQuery>;
+export type GetMembersQueryResult = Apollo.QueryResult<GetMembersQuery, GetMembersQueryVariables>;
+export const GetInvitedMembersCountDocument = gql`
+    query GetInvitedMembersCount($where: MemberInvitedEventWhereInput) {
+  memberInvitedEventsConnection(where: $where) {
+    totalCount
+  }
+}
+    `;
+
+/**
+ * __useGetInvitedMembersCountQuery__
+ *
+ * To run a query within a React component, call `useGetInvitedMembersCountQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetInvitedMembersCountQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetInvitedMembersCountQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetInvitedMembersCountQuery(baseOptions?: Apollo.QueryHookOptions<GetInvitedMembersCountQuery, GetInvitedMembersCountQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetInvitedMembersCountQuery, GetInvitedMembersCountQueryVariables>(GetInvitedMembersCountDocument, options);
+      }
+export function useGetInvitedMembersCountLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetInvitedMembersCountQuery, GetInvitedMembersCountQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetInvitedMembersCountQuery, GetInvitedMembersCountQueryVariables>(GetInvitedMembersCountDocument, options);
+        }
+export type GetInvitedMembersCountQueryHookResult = ReturnType<typeof useGetInvitedMembersCountQuery>;
+export type GetInvitedMembersCountLazyQueryHookResult = ReturnType<typeof useGetInvitedMembersCountLazyQuery>;
+export type GetInvitedMembersCountQueryResult = Apollo.QueryResult<GetInvitedMembersCountQuery, GetInvitedMembersCountQueryVariables>;
+export const GetInvitedMembersDocument = gql`
+    query GetInvitedMembers($where: MemberInvitedEventWhereInput, $orderBy: [MemberInvitedEventOrderByInput!], $offset: Int, $limit: Int) {
+  memberInvitedEvents(
+    where: $where
+    orderBy: $orderBy
+    offset: $offset
+    limit: $limit
+  ) {
+    id
+    createdAt
+    invitingMember {
+      ...MemberFields
+    }
+    newMember {
+      ...MemberFields
+    }
+  }
+}
+    ${MemberFieldsFragmentDoc}`;
+
+/**
+ * __useGetInvitedMembersQuery__
+ *
+ * To run a query within a React component, call `useGetInvitedMembersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetInvitedMembersQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetInvitedMembersQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *      orderBy: // value for 'orderBy'
+ *      offset: // value for 'offset'
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export function useGetInvitedMembersQuery(baseOptions?: Apollo.QueryHookOptions<GetInvitedMembersQuery, GetInvitedMembersQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetInvitedMembersQuery, GetInvitedMembersQueryVariables>(GetInvitedMembersDocument, options);
+      }
+export function useGetInvitedMembersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetInvitedMembersQuery, GetInvitedMembersQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetInvitedMembersQuery, GetInvitedMembersQueryVariables>(GetInvitedMembersDocument, options);
+        }
+export type GetInvitedMembersQueryHookResult = ReturnType<typeof useGetInvitedMembersQuery>;
+export type GetInvitedMembersLazyQueryHookResult = ReturnType<typeof useGetInvitedMembersLazyQuery>;
+export type GetInvitedMembersQueryResult = Apollo.QueryResult<GetInvitedMembersQuery, GetInvitedMembersQueryVariables>;

src/queries/__generated__/nfts.generated.tsx

@@ -0,0 +1,90 @@
+import * as Types from './baseTypes.generated';
+
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {} as const;
+export type GetNftIssuedCountQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.NftIssuedEventWhereInput>;
+}>;
+
+
+export type GetNftIssuedCountQuery = { __typename: 'Query', nftIssuedEventsConnection: { __typename: 'NftIssuedEventConnection', totalCount: number } };
+
+export type GetNftSaleCountQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.NftBoughtEventWhereInput>;
+}>;
+
+
+export type GetNftSaleCountQuery = { __typename: 'Query', nftBoughtEventsConnection: { __typename: 'NftBoughtEventConnection', totalCount: number } };
+
+
+export const GetNftIssuedCountDocument = gql`
+    query GetNftIssuedCount($where: NftIssuedEventWhereInput) {
+  nftIssuedEventsConnection(where: $where) {
+    totalCount
+  }
+}
+    `;
+
+/**
+ * __useGetNftIssuedCountQuery__
+ *
+ * To run a query within a React component, call `useGetNftIssuedCountQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetNftIssuedCountQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetNftIssuedCountQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetNftIssuedCountQuery(baseOptions?: Apollo.QueryHookOptions<GetNftIssuedCountQuery, GetNftIssuedCountQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetNftIssuedCountQuery, GetNftIssuedCountQueryVariables>(GetNftIssuedCountDocument, options);
+      }
+export function useGetNftIssuedCountLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetNftIssuedCountQuery, GetNftIssuedCountQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetNftIssuedCountQuery, GetNftIssuedCountQueryVariables>(GetNftIssuedCountDocument, options);
+        }
+export type GetNftIssuedCountQueryHookResult = ReturnType<typeof useGetNftIssuedCountQuery>;
+export type GetNftIssuedCountLazyQueryHookResult = ReturnType<typeof useGetNftIssuedCountLazyQuery>;
+export type GetNftIssuedCountQueryResult = Apollo.QueryResult<GetNftIssuedCountQuery, GetNftIssuedCountQueryVariables>;
+export const GetNftSaleCountDocument = gql`
+    query GetNftSaleCount($where: NftBoughtEventWhereInput) {
+  nftBoughtEventsConnection(where: $where) {
+    totalCount
+  }
+}
+    `;
+
+/**
+ * __useGetNftSaleCountQuery__
+ *
+ * To run a query within a React component, call `useGetNftSaleCountQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetNftSaleCountQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetNftSaleCountQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetNftSaleCountQuery(baseOptions?: Apollo.QueryHookOptions<GetNftSaleCountQuery, GetNftSaleCountQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetNftSaleCountQuery, GetNftSaleCountQueryVariables>(GetNftSaleCountDocument, options);
+      }
+export function useGetNftSaleCountLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetNftSaleCountQuery, GetNftSaleCountQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetNftSaleCountQuery, GetNftSaleCountQueryVariables>(GetNftSaleCountDocument, options);
+        }
+export type GetNftSaleCountQueryHookResult = ReturnType<typeof useGetNftSaleCountQuery>;
+export type GetNftSaleCountLazyQueryHookResult = ReturnType<typeof useGetNftSaleCountLazyQuery>;
+export type GetNftSaleCountQueryResult = Apollo.QueryResult<GetNftSaleCountQuery, GetNftSaleCountQueryVariables>;

src/queries/__generated__/posts.generated.tsx

@@ -0,0 +1,55 @@
+import * as Types from './baseTypes.generated';
+
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {} as const;
+export type GetForumPostsCountQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.ForumPostWhereInput>;
+}>;
+
+
+export type GetForumPostsCountQuery = { __typename: 'Query', forumPostsConnection: { __typename: 'ForumPostConnection', totalCount: number }, forumPosts: Array<{ __typename: 'ForumPost', createdAt: any, text: string, author: { __typename: 'Membership', handle: string } }> };
+
+
+export const GetForumPostsCountDocument = gql`
+    query GetForumPostsCount($where: ForumPostWhereInput) {
+  forumPostsConnection(first: 0, where: $where) {
+    totalCount
+  }
+  forumPosts {
+    createdAt
+    author {
+      handle
+    }
+    text
+  }
+}
+    `;
+
+/**
+ * __useGetForumPostsCountQuery__
+ *
+ * To run a query within a React component, call `useGetForumPostsCountQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetForumPostsCountQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetForumPostsCountQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetForumPostsCountQuery(baseOptions?: Apollo.QueryHookOptions<GetForumPostsCountQuery, GetForumPostsCountQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetForumPostsCountQuery, GetForumPostsCountQueryVariables>(GetForumPostsCountDocument, options);
+      }
+export function useGetForumPostsCountLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetForumPostsCountQuery, GetForumPostsCountQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetForumPostsCountQuery, GetForumPostsCountQueryVariables>(GetForumPostsCountDocument, options);
+        }
+export type GetForumPostsCountQueryHookResult = ReturnType<typeof useGetForumPostsCountQuery>;
+export type GetForumPostsCountLazyQueryHookResult = ReturnType<typeof useGetForumPostsCountLazyQuery>;
+export type GetForumPostsCountQueryResult = Apollo.QueryResult<GetForumPostsCountQuery, GetForumPostsCountQueryVariables>;

src/queries/__generated__/threads.generated.tsx

@@ -0,0 +1,48 @@
+import * as Types from './baseTypes.generated';
+
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {} as const;
+export type GetForumThreadsCountQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.ForumThreadWhereInput>;
+}>;
+
+
+export type GetForumThreadsCountQuery = { __typename: 'Query', forumThreadsConnection: { __typename: 'ForumThreadConnection', totalCount: number } };
+
+
+export const GetForumThreadsCountDocument = gql`
+    query GetForumThreadsCount($where: ForumThreadWhereInput) {
+  forumThreadsConnection(first: 0, where: $where) {
+    totalCount
+  }
+}
+    `;
+
+/**
+ * __useGetForumThreadsCountQuery__
+ *
+ * To run a query within a React component, call `useGetForumThreadsCountQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetForumThreadsCountQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetForumThreadsCountQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetForumThreadsCountQuery(baseOptions?: Apollo.QueryHookOptions<GetForumThreadsCountQuery, GetForumThreadsCountQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetForumThreadsCountQuery, GetForumThreadsCountQueryVariables>(GetForumThreadsCountDocument, options);
+      }
+export function useGetForumThreadsCountLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetForumThreadsCountQuery, GetForumThreadsCountQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetForumThreadsCountQuery, GetForumThreadsCountQueryVariables>(GetForumThreadsCountDocument, options);
+        }
+export type GetForumThreadsCountQueryHookResult = ReturnType<typeof useGetForumThreadsCountQuery>;
+export type GetForumThreadsCountLazyQueryHookResult = ReturnType<typeof useGetForumThreadsCountLazyQuery>;
+export type GetForumThreadsCountQueryResult = Apollo.QueryResult<GetForumThreadsCountQuery, GetForumThreadsCountQueryVariables>;

src/queries/__generated__/tokens.generated.tsx

@@ -0,0 +1,147 @@
+import * as Types from './baseTypes.generated';
+
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {} as const;
+export type MintedTokensQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.RewardPaymentEventWhereInput>;
+}>;
+
+
+export type MintedTokensQuery = { __typename: 'Query', rewardPaymentEvents: Array<{ __typename: 'RewardPaymentEvent', inBlock: number, councilMemberId: string, id: string, paidBalance: string, missingBalance: string, councilMember: { __typename: 'CouncilMember', electedInCouncilId: string, member: { __typename: 'Membership', id: string } } }> };
+
+export type WorkingGroupTokenQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.BudgetUpdatedEventWhereInput>;
+}>;
+
+
+export type WorkingGroupTokenQuery = { __typename: 'Query', budgetUpdatedEvents: Array<{ __typename: 'BudgetUpdatedEvent', groupId: string, budgetChangeAmount: string, inBlock: number, id: string }> };
+
+export type CouncilTokensQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.BudgetRefillEventWhereInput>;
+}>;
+
+
+export type CouncilTokensQuery = { __typename: 'Query', budgetRefillEvents: Array<{ __typename: 'BudgetRefillEvent', id: string, balance: string, inBlock: number }> };
+
+
+export const MintedTokensDocument = gql`
+    query mintedTokens($where: RewardPaymentEventWhereInput) {
+  rewardPaymentEvents(where: $where) {
+    inBlock
+    councilMemberId
+    id
+    paidBalance
+    missingBalance
+    councilMember {
+      electedInCouncilId
+      member {
+        id
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __useMintedTokensQuery__
+ *
+ * To run a query within a React component, call `useMintedTokensQuery` and pass it any options that fit your needs.
+ * When your component renders, `useMintedTokensQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useMintedTokensQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useMintedTokensQuery(baseOptions?: Apollo.QueryHookOptions<MintedTokensQuery, MintedTokensQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<MintedTokensQuery, MintedTokensQueryVariables>(MintedTokensDocument, options);
+      }
+export function useMintedTokensLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<MintedTokensQuery, MintedTokensQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<MintedTokensQuery, MintedTokensQueryVariables>(MintedTokensDocument, options);
+        }
+export type MintedTokensQueryHookResult = ReturnType<typeof useMintedTokensQuery>;
+export type MintedTokensLazyQueryHookResult = ReturnType<typeof useMintedTokensLazyQuery>;
+export type MintedTokensQueryResult = Apollo.QueryResult<MintedTokensQuery, MintedTokensQueryVariables>;
+export const WorkingGroupTokenDocument = gql`
+    query workingGroupToken($where: BudgetUpdatedEventWhereInput) {
+  budgetUpdatedEvents(where: $where) {
+    groupId
+    budgetChangeAmount
+    inBlock
+    id
+  }
+}
+    `;
+
+/**
+ * __useWorkingGroupTokenQuery__
+ *
+ * To run a query within a React component, call `useWorkingGroupTokenQuery` and pass it any options that fit your needs.
+ * When your component renders, `useWorkingGroupTokenQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useWorkingGroupTokenQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useWorkingGroupTokenQuery(baseOptions?: Apollo.QueryHookOptions<WorkingGroupTokenQuery, WorkingGroupTokenQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<WorkingGroupTokenQuery, WorkingGroupTokenQueryVariables>(WorkingGroupTokenDocument, options);
+      }
+export function useWorkingGroupTokenLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<WorkingGroupTokenQuery, WorkingGroupTokenQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<WorkingGroupTokenQuery, WorkingGroupTokenQueryVariables>(WorkingGroupTokenDocument, options);
+        }
+export type WorkingGroupTokenQueryHookResult = ReturnType<typeof useWorkingGroupTokenQuery>;
+export type WorkingGroupTokenLazyQueryHookResult = ReturnType<typeof useWorkingGroupTokenLazyQuery>;
+export type WorkingGroupTokenQueryResult = Apollo.QueryResult<WorkingGroupTokenQuery, WorkingGroupTokenQueryVariables>;
+export const CouncilTokensDocument = gql`
+    query councilTokens($where: BudgetRefillEventWhereInput) {
+  budgetRefillEvents(where: $where) {
+    id
+    balance
+    inBlock
+  }
+}
+    `;
+
+/**
+ * __useCouncilTokensQuery__
+ *
+ * To run a query within a React component, call `useCouncilTokensQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCouncilTokensQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useCouncilTokensQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useCouncilTokensQuery(baseOptions?: Apollo.QueryHookOptions<CouncilTokensQuery, CouncilTokensQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<CouncilTokensQuery, CouncilTokensQueryVariables>(CouncilTokensDocument, options);
+      }
+export function useCouncilTokensLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CouncilTokensQuery, CouncilTokensQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<CouncilTokensQuery, CouncilTokensQueryVariables>(CouncilTokensDocument, options);
+        }
+export type CouncilTokensQueryHookResult = ReturnType<typeof useCouncilTokensQuery>;
+export type CouncilTokensLazyQueryHookResult = ReturnType<typeof useCouncilTokensLazyQuery>;
+export type CouncilTokensQueryResult = Apollo.QueryResult<CouncilTokensQuery, CouncilTokensQueryVariables>;

src/queries/__generated__/videos.generated.tsx

@@ -0,0 +1,123 @@
+import * as Types from './baseTypes.generated';
+
+import { gql } from '@apollo/client';
+import { BasicChannelFieldsFragmentDoc } from './channels.generated';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {} as const;
+export type GetVideoCountQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.VideoWhereInput>;
+}>;
+
+
+export type GetVideoCountQuery = { __typename: 'Query', videosConnection: { __typename: 'VideoConnection', totalCount: number } };
+
+export type GetVideosQueryVariables = Types.Exact<{
+  whereVideo?: Types.InputMaybe<Types.VideoWhereInput>;
+  whereChannel?: Types.InputMaybe<Types.ChannelWhereInput>;
+  skip?: Types.InputMaybe<Types.Scalars['Int']>;
+  limit?: Types.InputMaybe<Types.Scalars['Int']>;
+  text: Types.Scalars['String'];
+}>;
+
+
+export type GetVideosQuery = { __typename: 'Query', search: Array<{ __typename: 'SearchFTSOutput', rank: string, item: { __typename: 'Channel', id: string, title?: string | null, createdAt: any, rewardAccount: string, channelStateBloatBond: string, avatarPhoto?: { __typename: 'StorageDataObject', id: string, createdAt: any, size: string, isAccepted: boolean, ipfsHash: string, storageBag: { __typename: 'StorageBag', id: string }, type: { __typename: 'DataObjectTypeChannelAvatar' } | { __typename: 'DataObjectTypeChannelCoverPhoto' } | { __typename: 'DataObjectTypeUnknown' } | { __typename: 'DataObjectTypeVideoMedia' } | { __typename: 'DataObjectTypeVideoSubtitle' } | { __typename: 'DataObjectTypeVideoThumbnail' } } | null } | { __typename: 'Video', id: string, title?: string | null, createdAt: any } }> };
+
+export type BasicVideoFieldsFragment = { __typename: 'Video', id: string, title?: string | null, createdAt: any };
+
+export const BasicVideoFieldsFragmentDoc = gql`
+    fragment BasicVideoFields on Video {
+  id
+  title
+  createdAt
+}
+    `;
+export const GetVideoCountDocument = gql`
+    query GetVideoCount($where: VideoWhereInput) {
+  videosConnection(first: 0, where: $where) {
+    totalCount
+  }
+}
+    `;
+
+/**
+ * __useGetVideoCountQuery__
+ *
+ * To run a query within a React component, call `useGetVideoCountQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetVideoCountQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetVideoCountQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetVideoCountQuery(baseOptions?: Apollo.QueryHookOptions<GetVideoCountQuery, GetVideoCountQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetVideoCountQuery, GetVideoCountQueryVariables>(GetVideoCountDocument, options);
+      }
+export function useGetVideoCountLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetVideoCountQuery, GetVideoCountQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetVideoCountQuery, GetVideoCountQueryVariables>(GetVideoCountDocument, options);
+        }
+export type GetVideoCountQueryHookResult = ReturnType<typeof useGetVideoCountQuery>;
+export type GetVideoCountLazyQueryHookResult = ReturnType<typeof useGetVideoCountLazyQuery>;
+export type GetVideoCountQueryResult = Apollo.QueryResult<GetVideoCountQuery, GetVideoCountQueryVariables>;
+export const GetVideosDocument = gql`
+    query GetVideos($whereVideo: VideoWhereInput, $whereChannel: ChannelWhereInput, $skip: Int = 0, $limit: Int = 5, $text: String!) {
+  search(
+    whereVideo: $whereVideo
+    whereChannel: $whereChannel
+    skip: $skip
+    limit: $limit
+    text: $text
+  ) {
+    rank
+    item {
+      __typename
+      ... on Channel {
+        ...BasicChannelFields
+      }
+      ... on Video {
+        ...BasicVideoFields
+      }
+    }
+  }
+}
+    ${BasicChannelFieldsFragmentDoc}
+${BasicVideoFieldsFragmentDoc}`;
+
+/**
+ * __useGetVideosQuery__
+ *
+ * To run a query within a React component, call `useGetVideosQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetVideosQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetVideosQuery({
+ *   variables: {
+ *      whereVideo: // value for 'whereVideo'
+ *      whereChannel: // value for 'whereChannel'
+ *      skip: // value for 'skip'
+ *      limit: // value for 'limit'
+ *      text: // value for 'text'
+ *   },
+ * });
+ */
+export function useGetVideosQuery(baseOptions: Apollo.QueryHookOptions<GetVideosQuery, GetVideosQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetVideosQuery, GetVideosQueryVariables>(GetVideosDocument, options);
+      }
+export function useGetVideosLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetVideosQuery, GetVideosQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetVideosQuery, GetVideosQueryVariables>(GetVideosDocument, options);
+        }
+export type GetVideosQueryHookResult = ReturnType<typeof useGetVideosQuery>;
+export type GetVideosLazyQueryHookResult = ReturnType<typeof useGetVideosLazyQuery>;
+export type GetVideosQueryResult = Apollo.QueryResult<GetVideosQuery, GetVideosQueryVariables>;

src/queries/__generated__/workers.generated.tsx

@@ -0,0 +1,148 @@
+import * as Types from './baseTypes.generated';
+
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {} as const;
+export type GetTerminatedWorkderQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.TerminatedWorkerEventWhereInput>;
+}>;
+
+
+export type GetTerminatedWorkderQuery = { __typename: 'Query', terminatedWorkerEvents: Array<{ __typename: 'TerminatedWorkerEvent', groupId: string, workerId: string, createdAt: any, worker: { __typename: 'Worker', membershipId: string } }> };
+
+export type GetWorkerExitedQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.WorkerExitedEventWhereInput>;
+}>;
+
+
+export type GetWorkerExitedQuery = { __typename: 'Query', workerExitedEvents: Array<{ __typename: 'WorkerExitedEvent', createdAt: any, groupId: string, workerId: string, worker: { __typename: 'Worker', membershipId: string } }> };
+
+export type GetOpeningFilledQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.OpeningFilledEventWhereInput>;
+}>;
+
+
+export type GetOpeningFilledQuery = { __typename: 'Query', openingFilledEvents: Array<{ __typename: 'OpeningFilledEvent', createdAt: any, groupId: string, workersHired: Array<{ __typename: 'Worker', membershipId: string }> }> };
+
+
+export const GetTerminatedWorkderDocument = gql`
+    query getTerminatedWorkder($where: TerminatedWorkerEventWhereInput) {
+  terminatedWorkerEvents(where: $where) {
+    groupId
+    workerId
+    createdAt
+    __typename
+    worker {
+      membershipId
+    }
+  }
+}
+    `;
+
+/**
+ * __useGetTerminatedWorkderQuery__
+ *
+ * To run a query within a React component, call `useGetTerminatedWorkderQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetTerminatedWorkderQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetTerminatedWorkderQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetTerminatedWorkderQuery(baseOptions?: Apollo.QueryHookOptions<GetTerminatedWorkderQuery, GetTerminatedWorkderQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetTerminatedWorkderQuery, GetTerminatedWorkderQueryVariables>(GetTerminatedWorkderDocument, options);
+      }
+export function useGetTerminatedWorkderLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetTerminatedWorkderQuery, GetTerminatedWorkderQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetTerminatedWorkderQuery, GetTerminatedWorkderQueryVariables>(GetTerminatedWorkderDocument, options);
+        }
+export type GetTerminatedWorkderQueryHookResult = ReturnType<typeof useGetTerminatedWorkderQuery>;
+export type GetTerminatedWorkderLazyQueryHookResult = ReturnType<typeof useGetTerminatedWorkderLazyQuery>;
+export type GetTerminatedWorkderQueryResult = Apollo.QueryResult<GetTerminatedWorkderQuery, GetTerminatedWorkderQueryVariables>;
+export const GetWorkerExitedDocument = gql`
+    query getWorkerExited($where: WorkerExitedEventWhereInput) {
+  workerExitedEvents(where: $where) {
+    createdAt
+    groupId
+    workerId
+    __typename
+    worker {
+      membershipId
+    }
+  }
+}
+    `;
+
+/**
+ * __useGetWorkerExitedQuery__
+ *
+ * To run a query within a React component, call `useGetWorkerExitedQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkerExitedQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetWorkerExitedQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetWorkerExitedQuery(baseOptions?: Apollo.QueryHookOptions<GetWorkerExitedQuery, GetWorkerExitedQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetWorkerExitedQuery, GetWorkerExitedQueryVariables>(GetWorkerExitedDocument, options);
+      }
+export function useGetWorkerExitedLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetWorkerExitedQuery, GetWorkerExitedQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetWorkerExitedQuery, GetWorkerExitedQueryVariables>(GetWorkerExitedDocument, options);
+        }
+export type GetWorkerExitedQueryHookResult = ReturnType<typeof useGetWorkerExitedQuery>;
+export type GetWorkerExitedLazyQueryHookResult = ReturnType<typeof useGetWorkerExitedLazyQuery>;
+export type GetWorkerExitedQueryResult = Apollo.QueryResult<GetWorkerExitedQuery, GetWorkerExitedQueryVariables>;
+export const GetOpeningFilledDocument = gql`
+    query getOpeningFilled($where: OpeningFilledEventWhereInput) {
+  openingFilledEvents(where: $where) {
+    createdAt
+    groupId
+    workersHired {
+      membershipId
+    }
+  }
+}
+    `;
+
+/**
+ * __useGetOpeningFilledQuery__
+ *
+ * To run a query within a React component, call `useGetOpeningFilledQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetOpeningFilledQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetOpeningFilledQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetOpeningFilledQuery(baseOptions?: Apollo.QueryHookOptions<GetOpeningFilledQuery, GetOpeningFilledQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetOpeningFilledQuery, GetOpeningFilledQueryVariables>(GetOpeningFilledDocument, options);
+      }
+export function useGetOpeningFilledLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetOpeningFilledQuery, GetOpeningFilledQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetOpeningFilledQuery, GetOpeningFilledQueryVariables>(GetOpeningFilledDocument, options);
+        }
+export type GetOpeningFilledQueryHookResult = ReturnType<typeof useGetOpeningFilledQuery>;
+export type GetOpeningFilledLazyQueryHookResult = ReturnType<typeof useGetOpeningFilledLazyQuery>;
+export type GetOpeningFilledQueryResult = Apollo.QueryResult<GetOpeningFilledQuery, GetOpeningFilledQueryVariables>;

src/queries/__generated__/workingGroups.generated.tsx

@@ -0,0 +1,1541 @@
+import * as Types from './baseTypes.generated';
+
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {} as const;
+export type WorkingGroupMetadataFieldsFragment = { __typename: 'WorkingGroupMetadata', about?: string | null, description?: string | null, status?: string | null, statusMessage?: string | null };
+
+export type WorkerFieldsFragment = { __typename: 'Worker', id: string, runtimeId: number, applicationId: string, isLead: boolean, rewardPerBlock: string, missingRewardAmount?: string | null, stake: string, group: { __typename: 'WorkingGroup', id: string, name: string }, status: { __typename: 'WorkerStatusActive' } | { __typename: 'WorkerStatusLeaving' } | { __typename: 'WorkerStatusLeft' } | { __typename: 'WorkerStatusTerminated' } };
+
+export type PastWorkerFieldsFragment = { __typename: 'Worker', id: string, runtimeId: number, createdAt: any, updatedAt?: any | null, status: { __typename: 'WorkerStatusActive' } | { __typename: 'WorkerStatusLeaving' } | { __typename: 'WorkerStatusLeft', workerExitedEvent?: { __typename: 'WorkerExitedEvent', createdAt: any, inBlock: number, network: Types.Network } | null } | { __typename: 'WorkerStatusTerminated', terminatedWorkerEvent?: { __typename: 'TerminatedWorkerEvent', createdAt: any, inBlock: number, network: Types.Network } | null }, entry: { __typename: 'OpeningFilledEvent', createdAt: any, inBlock: number, network: Types.Network } };
+
+export type WorkerDetailedFieldsFragment = { __typename: 'Worker', roleAccount: string, rewardAccount: string, stakeAccount: string, id: string, runtimeId: number, applicationId: string, isLead: boolean, rewardPerBlock: string, missingRewardAmount?: string | null, stake: string, entry: { __typename: 'OpeningFilledEvent', inBlock: number, network: Types.Network, createdAt: any }, application: { __typename: 'WorkingGroupApplication', id: string, openingId: string, opening: { __typename: 'WorkingGroupOpening', stakeAmount: string } }, group: { __typename: 'WorkingGroup', id: string, name: string }, status: { __typename: 'WorkerStatusActive' } | { __typename: 'WorkerStatusLeaving' } | { __typename: 'WorkerStatusLeft' } | { __typename: 'WorkerStatusTerminated' } };
+
+export type WorkingGroupFieldsFragment = { __typename: 'WorkingGroup', id: string, name: string, budget: string, metadata?: { __typename: 'WorkingGroupMetadata', about?: string | null, description?: string | null, status?: string | null, statusMessage?: string | null } | null, workers: Array<{ __typename: 'Worker', stake: string }>, leader?: { __typename: 'Worker', membershipId: string, isActive: boolean } | null };
+
+export type WorkingGroupDetailedFieldsFragment = { __typename: 'WorkingGroup', id: string, name: string, budget: string, leader?: { __typename: 'Worker', id: string, runtimeId: number, stake: string, membershipId: string, rewardPerBlock: string, isActive: boolean } | null, metadata?: { __typename: 'WorkingGroupMetadata', about?: string | null, description?: string | null, status?: string | null, statusMessage?: string | null } | null, workers: Array<{ __typename: 'Worker', stake: string }> };
+
+export type BudgetSpendingEventFieldsFragment = { __typename: 'BudgetSpendingEvent', id: string, groupId: string, reciever: string, amount: string, rationale?: string | null };
+
+export type RewardPaidEventFieldsFragment = { __typename: 'RewardPaidEvent', id: string, amount: string, rewardAccount: string, createdAt: any };
+
+export type GetWorkingGroupsQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.WorkingGroupWhereInput>;
+  orderBy?: Types.InputMaybe<Array<Types.WorkingGroupOrderByInput> | Types.WorkingGroupOrderByInput>;
+  offset?: Types.InputMaybe<Types.Scalars['Int']>;
+  limit?: Types.InputMaybe<Types.Scalars['Int']>;
+}>;
+
+
+export type GetWorkingGroupsQuery = { __typename: 'Query', workingGroups: Array<{ __typename: 'WorkingGroup', id: string, name: string, budget: string, metadata?: { __typename: 'WorkingGroupMetadata', about?: string | null, description?: string | null, status?: string | null, statusMessage?: string | null } | null, workers: Array<{ __typename: 'Worker', stake: string }>, leader?: { __typename: 'Worker', membershipId: string, isActive: boolean } | null }> };
+
+export type GetBudgetSpendingQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.BudgetSpendingEventWhereInput>;
+}>;
+
+
+export type GetBudgetSpendingQuery = { __typename: 'Query', budgetSpendingEvents: Array<{ __typename: 'BudgetSpendingEvent', id: string, groupId: string, reciever: string, amount: string, rationale?: string | null }> };
+
+export type GetWorkersQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.WorkerWhereInput>;
+  offset?: Types.InputMaybe<Types.Scalars['Int']>;
+  limit?: Types.InputMaybe<Types.Scalars['Int']>;
+}>;
+
+
+export type GetWorkersQuery = { __typename: 'Query', workers: Array<{ __typename: 'Worker', id: string, runtimeId: number, applicationId: string, isLead: boolean, rewardPerBlock: string, missingRewardAmount?: string | null, stake: string, group: { __typename: 'WorkingGroup', id: string, name: string }, status: { __typename: 'WorkerStatusActive' } | { __typename: 'WorkerStatusLeaving' } | { __typename: 'WorkerStatusLeft' } | { __typename: 'WorkerStatusTerminated' } }> };
+
+export type GetPastWorkersQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.WorkerWhereInput>;
+  offset?: Types.InputMaybe<Types.Scalars['Int']>;
+  limit?: Types.InputMaybe<Types.Scalars['Int']>;
+  orderBy?: Types.InputMaybe<Array<Types.WorkerOrderByInput> | Types.WorkerOrderByInput>;
+}>;
+
+
+export type GetPastWorkersQuery = { __typename: 'Query', workers: Array<{ __typename: 'Worker', id: string, runtimeId: number, createdAt: any, updatedAt?: any | null, status: { __typename: 'WorkerStatusActive' } | { __typename: 'WorkerStatusLeaving' } | { __typename: 'WorkerStatusLeft', workerExitedEvent?: { __typename: 'WorkerExitedEvent', createdAt: any, inBlock: number, network: Types.Network } | null } | { __typename: 'WorkerStatusTerminated', terminatedWorkerEvent?: { __typename: 'TerminatedWorkerEvent', createdAt: any, inBlock: number, network: Types.Network } | null }, entry: { __typename: 'OpeningFilledEvent', createdAt: any, inBlock: number, network: Types.Network } }> };
+
+export type GetWorkersCountQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.WorkerWhereInput>;
+}>;
+
+
+export type GetWorkersCountQuery = { __typename: 'Query', workersConnection: { __typename: 'WorkerConnection', totalCount: number } };
+
+export type GetDetailedWorkersQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.WorkerWhereInput>;
+}>;
+
+
+export type GetDetailedWorkersQuery = { __typename: 'Query', workers: Array<{ __typename: 'Worker', roleAccount: string, rewardAccount: string, stakeAccount: string, id: string, runtimeId: number, applicationId: string, isLead: boolean, rewardPerBlock: string, missingRewardAmount?: string | null, stake: string, entry: { __typename: 'OpeningFilledEvent', inBlock: number, network: Types.Network, createdAt: any }, application: { __typename: 'WorkingGroupApplication', id: string, openingId: string, opening: { __typename: 'WorkingGroupOpening', stakeAmount: string } }, group: { __typename: 'WorkingGroup', id: string, name: string }, status: { __typename: 'WorkerStatusActive' } | { __typename: 'WorkerStatusLeaving' } | { __typename: 'WorkerStatusLeft' } | { __typename: 'WorkerStatusTerminated' } }> };
+
+export type GetWorkerQueryVariables = Types.Exact<{
+  where: Types.WorkerWhereUniqueInput;
+}>;
+
+
+export type GetWorkerQuery = { __typename: 'Query', workerByUniqueInput?: { __typename: 'Worker', roleAccount: string, rewardAccount: string, stakeAccount: string, id: string, runtimeId: number, applicationId: string, isLead: boolean, rewardPerBlock: string, missingRewardAmount?: string | null, stake: string, entry: { __typename: 'OpeningFilledEvent', inBlock: number, network: Types.Network, createdAt: any }, application: { __typename: 'WorkingGroupApplication', id: string, openingId: string, opening: { __typename: 'WorkingGroupOpening', stakeAmount: string } }, group: { __typename: 'WorkingGroup', id: string, name: string }, status: { __typename: 'WorkerStatusActive' } | { __typename: 'WorkerStatusLeaving' } | { __typename: 'WorkerStatusLeft' } | { __typename: 'WorkerStatusTerminated' } } | null };
+
+export type GetGroupDebtQueryVariables = Types.Exact<{
+  where: Types.WorkerWhereInput;
+}>;
+
+
+export type GetGroupDebtQuery = { __typename: 'Query', workers: Array<{ __typename: 'Worker', missingRewardAmount?: string | null }> };
+
+export type GetRewardsQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.RewardPaidEventWhereInput>;
+}>;
+
+
+export type GetRewardsQuery = { __typename: 'Query', rewardPaidEvents: Array<{ __typename: 'RewardPaidEvent', id: string, amount: string, rewardAccount: string, createdAt: any }> };
+
+export type WorkingGroupOpeningMetadataFieldsFragment = { __typename: 'WorkingGroupOpeningMetadata', title?: string | null, applicationDetails?: string | null, shortDescription?: string | null, description?: string | null, hiringLimit?: number | null, expectedEnding?: any | null };
+
+export type WorkingGroupOpeningFieldsFragment = { __typename: 'WorkingGroupOpening', id: string, runtimeId: number, groupId: string, type: Types.WorkingGroupOpeningType, stakeAmount: string, rewardPerBlock: string, unstakingPeriod: number, group: { __typename: 'WorkingGroup', name: string, budget: string, leaderId?: string | null }, createdInEvent: { __typename: 'OpeningAddedEvent', inBlock: number, network: Types.Network, createdAt: any }, metadata: { __typename: 'WorkingGroupOpeningMetadata', title?: string | null, applicationDetails?: string | null, shortDescription?: string | null, description?: string | null, hiringLimit?: number | null, expectedEnding?: any | null }, status: { __typename: 'OpeningStatusCancelled' } | { __typename: 'OpeningStatusFilled' } | { __typename: 'OpeningStatusOpen' }, applications: Array<{ __typename: 'WorkingGroupApplication', id: string, status: { __typename: 'ApplicationStatusAccepted' } | { __typename: 'ApplicationStatusCancelled' } | { __typename: 'ApplicationStatusPending' } | { __typename: 'ApplicationStatusRejected' } | { __typename: 'ApplicationStatusWithdrawn' } }>, openingfilledeventopening?: Array<{ __typename: 'OpeningFilledEvent', workersHired: Array<{ __typename: 'Worker', id: string }> }> | null };
+
+export type WorkingGroupOpeningDetailedFieldsFragment = { __typename: 'WorkingGroupOpening', id: string, runtimeId: number, groupId: string, type: Types.WorkingGroupOpeningType, stakeAmount: string, rewardPerBlock: string, unstakingPeriod: number, applications: Array<{ __typename: 'WorkingGroupApplication', id: string, status: { __typename: 'ApplicationStatusAccepted' } | { __typename: 'ApplicationStatusCancelled' } | { __typename: 'ApplicationStatusPending' } | { __typename: 'ApplicationStatusRejected' } | { __typename: 'ApplicationStatusWithdrawn' } }>, group: { __typename: 'WorkingGroup', name: string, budget: string, leaderId?: string | null }, createdInEvent: { __typename: 'OpeningAddedEvent', inBlock: number, network: Types.Network, createdAt: any }, metadata: { __typename: 'WorkingGroupOpeningMetadata', title?: string | null, applicationDetails?: string | null, shortDescription?: string | null, description?: string | null, hiringLimit?: number | null, expectedEnding?: any | null }, status: { __typename: 'OpeningStatusCancelled' } | { __typename: 'OpeningStatusFilled' } | { __typename: 'OpeningStatusOpen' }, openingfilledeventopening?: Array<{ __typename: 'OpeningFilledEvent', workersHired: Array<{ __typename: 'Worker', id: string }> }> | null };
+
+export type CountWorkingGroupOpeningsQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.WorkingGroupOpeningWhereInput>;
+}>;
+
+
+export type CountWorkingGroupOpeningsQuery = { __typename: 'Query', workingGroupOpeningsConnection: { __typename: 'WorkingGroupOpeningConnection', totalCount: number } };
+
+export type CountWorkingGroupWorkersQueryVariables = Types.Exact<{
+  groupId_eq?: Types.InputMaybe<Types.Scalars['ID']>;
+  status_json?: Types.InputMaybe<Types.Scalars['JSONObject']>;
+}>;
+
+
+export type CountWorkingGroupWorkersQuery = { __typename: 'Query', workersConnection: { __typename: 'WorkerConnection', totalCount: number } };
+
+export type GetWorkingGroupOpeningsQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.WorkingGroupOpeningWhereInput>;
+  order?: Types.InputMaybe<Array<Types.WorkingGroupOpeningOrderByInput> | Types.WorkingGroupOpeningOrderByInput>;
+  limit?: Types.InputMaybe<Types.Scalars['Int']>;
+  offset?: Types.InputMaybe<Types.Scalars['Int']>;
+}>;
+
+
+export type GetWorkingGroupOpeningsQuery = { __typename: 'Query', workingGroupOpenings: Array<{ __typename: 'WorkingGroupOpening', id: string, runtimeId: number, groupId: string, type: Types.WorkingGroupOpeningType, stakeAmount: string, rewardPerBlock: string, unstakingPeriod: number, group: { __typename: 'WorkingGroup', name: string, budget: string, leaderId?: string | null }, createdInEvent: { __typename: 'OpeningAddedEvent', inBlock: number, network: Types.Network, createdAt: any }, metadata: { __typename: 'WorkingGroupOpeningMetadata', title?: string | null, applicationDetails?: string | null, shortDescription?: string | null, description?: string | null, hiringLimit?: number | null, expectedEnding?: any | null }, status: { __typename: 'OpeningStatusCancelled' } | { __typename: 'OpeningStatusFilled' } | { __typename: 'OpeningStatusOpen' }, applications: Array<{ __typename: 'WorkingGroupApplication', id: string, status: { __typename: 'ApplicationStatusAccepted' } | { __typename: 'ApplicationStatusCancelled' } | { __typename: 'ApplicationStatusPending' } | { __typename: 'ApplicationStatusRejected' } | { __typename: 'ApplicationStatusWithdrawn' } }>, openingfilledeventopening?: Array<{ __typename: 'OpeningFilledEvent', workersHired: Array<{ __typename: 'Worker', id: string }> }> | null }> };
+
+export type SimpleSearchWorkingGroupOpeningsQueryVariables = Types.Exact<{
+  text: Types.Scalars['String'];
+  limit?: Types.InputMaybe<Types.Scalars['Int']>;
+}>;
+
+
+export type SimpleSearchWorkingGroupOpeningsQuery = { __typename: 'Query', workingGroupOpenings: Array<{ __typename: 'WorkingGroupOpening', id: string, metadata: { __typename: 'WorkingGroupOpeningMetadata', shortDescription?: string | null } }> };
+
+export type GetWorkingGroupOpeningQueryVariables = Types.Exact<{
+  where: Types.WorkingGroupOpeningWhereUniqueInput;
+}>;
+
+
+export type GetWorkingGroupOpeningQuery = { __typename: 'Query', workingGroupOpeningByUniqueInput?: { __typename: 'WorkingGroupOpening', id: string, runtimeId: number, groupId: string, type: Types.WorkingGroupOpeningType, stakeAmount: string, rewardPerBlock: string, unstakingPeriod: number, applications: Array<{ __typename: 'WorkingGroupApplication', id: string, status: { __typename: 'ApplicationStatusAccepted' } | { __typename: 'ApplicationStatusCancelled' } | { __typename: 'ApplicationStatusPending' } | { __typename: 'ApplicationStatusRejected' } | { __typename: 'ApplicationStatusWithdrawn' } }>, group: { __typename: 'WorkingGroup', name: string, budget: string, leaderId?: string | null }, createdInEvent: { __typename: 'OpeningAddedEvent', inBlock: number, network: Types.Network, createdAt: any }, metadata: { __typename: 'WorkingGroupOpeningMetadata', title?: string | null, applicationDetails?: string | null, shortDescription?: string | null, description?: string | null, hiringLimit?: number | null, expectedEnding?: any | null }, status: { __typename: 'OpeningStatusCancelled' } | { __typename: 'OpeningStatusFilled' } | { __typename: 'OpeningStatusOpen' }, openingfilledeventopening?: Array<{ __typename: 'OpeningFilledEvent', workersHired: Array<{ __typename: 'Worker', id: string }> }> | null } | null };
+
+export type WorkingGroupOpeningMentionFieldsFragment = { __typename: 'WorkingGroupOpening', id: string, type: Types.WorkingGroupOpeningType, rewardPerBlock: string, metadata: { __typename: 'WorkingGroupOpeningMetadata', title?: string | null, shortDescription?: string | null, description?: string | null, hiringLimit?: number | null, expectedEnding?: any | null }, applications: Array<{ __typename: 'WorkingGroupApplication', applicantId: string }>, openingfilledeventopening?: Array<{ __typename: 'OpeningFilledEvent', id: string, workersHired: Array<{ __typename: 'Worker', id: string }> }> | null };
+
+export type GetWorkingGroupOpeningMentionQueryVariables = Types.Exact<{
+  id: Types.Scalars['ID'];
+}>;
+
+
+export type GetWorkingGroupOpeningMentionQuery = { __typename: 'Query', opening?: { __typename: 'WorkingGroupOpening', id: string, type: Types.WorkingGroupOpeningType, rewardPerBlock: string, metadata: { __typename: 'WorkingGroupOpeningMetadata', title?: string | null, shortDescription?: string | null, description?: string | null, hiringLimit?: number | null, expectedEnding?: any | null }, applications: Array<{ __typename: 'WorkingGroupApplication', applicantId: string }>, openingfilledeventopening?: Array<{ __typename: 'OpeningFilledEvent', id: string, workersHired: Array<{ __typename: 'Worker', id: string }> }> | null } | null };
+
+export type WorkingGroupApplicationMentionFieldsFragment = { __typename: 'WorkingGroupApplication', id: string, createdInEvent: { __typename: 'AppliedOnOpeningEvent', createdAt: any, inBlock: number, network: Types.Network }, opening: { __typename: 'WorkingGroupOpening', type: Types.WorkingGroupOpeningType, metadata: { __typename: 'WorkingGroupOpeningMetadata', title?: string | null, shortDescription?: string | null, description?: string | null } } };
+
+export type GetWorkingGroupApplicationMentionQueryVariables = Types.Exact<{
+  id: Types.Scalars['ID'];
+}>;
+
+
+export type GetWorkingGroupApplicationMentionQuery = { __typename: 'Query', application?: { __typename: 'WorkingGroupApplication', id: string, createdInEvent: { __typename: 'AppliedOnOpeningEvent', createdAt: any, inBlock: number, network: Types.Network }, opening: { __typename: 'WorkingGroupOpening', type: Types.WorkingGroupOpeningType, metadata: { __typename: 'WorkingGroupOpeningMetadata', title?: string | null, shortDescription?: string | null, description?: string | null } } } | null };
+
+export type ApplicationQuestionFieldsFragment = { __typename: 'ApplicationFormQuestion', index: number, type: Types.ApplicationFormQuestionType, question?: string | null };
+
+export type GetWorkingGroupOpeningQuestionsQueryVariables = Types.Exact<{
+  id: Types.Scalars['ID'];
+}>;
+
+
+export type GetWorkingGroupOpeningQuestionsQuery = { __typename: 'Query', workingGroupOpeningByUniqueInput?: { __typename: 'WorkingGroupOpening', metadata: { __typename: 'WorkingGroupOpeningMetadata', applicationFormQuestions: Array<{ __typename: 'ApplicationFormQuestion', index: number, type: Types.ApplicationFormQuestionType, question?: string | null }> } } | null };
+
+export type GetWorkingGroupQueryVariables = Types.Exact<{
+  where: Types.WorkingGroupWhereUniqueInput;
+}>;
+
+
+export type GetWorkingGroupQuery = { __typename: 'Query', workingGroupByUniqueInput?: { __typename: 'WorkingGroup', id: string, name: string, budget: string, leader?: { __typename: 'Worker', id: string, runtimeId: number, stake: string, membershipId: string, rewardPerBlock: string, isActive: boolean } | null, metadata?: { __typename: 'WorkingGroupMetadata', about?: string | null, description?: string | null, status?: string | null, statusMessage?: string | null } | null, workers: Array<{ __typename: 'Worker', stake: string }> } | null };
+
+export type WorkingGroupApplicationFieldsFragment = { __typename: 'WorkingGroupApplication', id: string, runtimeId: number, stakingAccount: string, stake: string, roleAccount: string, answers: Array<{ __typename: 'ApplicationFormQuestionAnswer', answer: string, question: { __typename: 'ApplicationFormQuestion', question?: string | null } }>, opening: { __typename: 'WorkingGroupOpening', id: string, type: Types.WorkingGroupOpeningType, rewardPerBlock: string, group: { __typename: 'WorkingGroup', id: string, name: string }, metadata: { __typename: 'WorkingGroupOpeningMetadata', expectedEnding?: any | null } }, status: { __typename: 'ApplicationStatusAccepted' } | { __typename: 'ApplicationStatusCancelled' } | { __typename: 'ApplicationStatusPending' } | { __typename: 'ApplicationStatusRejected' } | { __typename: 'ApplicationStatusWithdrawn' }, createdInEvent: { __typename: 'AppliedOnOpeningEvent', createdAt: any, inBlock: number, network: Types.Network } };
+
+export type GetWorkingGroupApplicationsQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.WorkingGroupApplicationWhereInput>;
+  orderBy?: Types.InputMaybe<Array<Types.WorkingGroupApplicationOrderByInput> | Types.WorkingGroupApplicationOrderByInput>;
+  limit?: Types.InputMaybe<Types.Scalars['Int']>;
+}>;
+
+
+export type GetWorkingGroupApplicationsQuery = { __typename: 'Query', workingGroupApplications: Array<{ __typename: 'WorkingGroupApplication', id: string, runtimeId: number, stakingAccount: string, stake: string, roleAccount: string, answers: Array<{ __typename: 'ApplicationFormQuestionAnswer', answer: string, question: { __typename: 'ApplicationFormQuestion', question?: string | null } }>, opening: { __typename: 'WorkingGroupOpening', id: string, type: Types.WorkingGroupOpeningType, rewardPerBlock: string, group: { __typename: 'WorkingGroup', id: string, name: string }, metadata: { __typename: 'WorkingGroupOpeningMetadata', expectedEnding?: any | null } }, status: { __typename: 'ApplicationStatusAccepted' } | { __typename: 'ApplicationStatusCancelled' } | { __typename: 'ApplicationStatusPending' } | { __typename: 'ApplicationStatusRejected' } | { __typename: 'ApplicationStatusWithdrawn' }, createdInEvent: { __typename: 'AppliedOnOpeningEvent', createdAt: any, inBlock: number, network: Types.Network } }> };
+
+export type SimpleSearchWorkingGroupApplicationsQueryVariables = Types.Exact<{
+  text: Types.Scalars['String'];
+  limit?: Types.InputMaybe<Types.Scalars['Int']>;
+}>;
+
+
+export type SimpleSearchWorkingGroupApplicationsQuery = { __typename: 'Query', workingGroupApplications: Array<{ __typename: 'WorkingGroupApplication', id: string, applicant: { __typename: 'Membership', id: string, handle: string } }> };
+
+export type GetWorkingGroupApplicationIdsQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.WorkingGroupApplicationWhereInput>;
+}>;
+
+
+export type GetWorkingGroupApplicationIdsQuery = { __typename: 'Query', workingGroupApplications: Array<{ __typename: 'WorkingGroupApplication', id: string }> };
+
+export type GetWorkingGroupApplicationQueryVariables = Types.Exact<{
+  where: Types.WorkingGroupApplicationWhereUniqueInput;
+}>;
+
+
+export type GetWorkingGroupApplicationQuery = { __typename: 'Query', workingGroupApplicationByUniqueInput?: { __typename: 'WorkingGroupApplication', id: string, runtimeId: number, stakingAccount: string, stake: string, roleAccount: string, answers: Array<{ __typename: 'ApplicationFormQuestionAnswer', answer: string, question: { __typename: 'ApplicationFormQuestion', question?: string | null } }>, opening: { __typename: 'WorkingGroupOpening', id: string, type: Types.WorkingGroupOpeningType, rewardPerBlock: string, group: { __typename: 'WorkingGroup', id: string, name: string }, metadata: { __typename: 'WorkingGroupOpeningMetadata', expectedEnding?: any | null } }, status: { __typename: 'ApplicationStatusAccepted' } | { __typename: 'ApplicationStatusCancelled' } | { __typename: 'ApplicationStatusPending' } | { __typename: 'ApplicationStatusRejected' } | { __typename: 'ApplicationStatusWithdrawn' }, createdInEvent: { __typename: 'AppliedOnOpeningEvent', createdAt: any, inBlock: number, network: Types.Network } } | null };
+
+export type ApplicationFormQuestionAnswerFieldsFragment = { __typename: 'ApplicationFormQuestionAnswer', answer: string, question: { __typename: 'ApplicationFormQuestion', index: number, type: Types.ApplicationFormQuestionType, question?: string | null } };
+
+export type GetApplicationFormQuestionAnswerQueryVariables = Types.Exact<{
+  applicationId_eq?: Types.InputMaybe<Types.Scalars['ID']>;
+}>;
+
+
+export type GetApplicationFormQuestionAnswerQuery = { __typename: 'Query', applicationFormQuestionAnswers: Array<{ __typename: 'ApplicationFormQuestionAnswer', answer: string, question: { __typename: 'ApplicationFormQuestion', index: number, type: Types.ApplicationFormQuestionType, question?: string | null } }> };
+
+export type UpcomingWorkingGroupOpeningFieldsFragment = { __typename: 'UpcomingWorkingGroupOpening', id: string, groupId: string, expectedStart?: any | null, stakeAmount?: string | null, rewardPerBlock?: string | null, group: { __typename: 'WorkingGroup', name: string, budget: string, leaderId?: string | null }, createdInEvent: { __typename: 'StatusTextChangedEvent', createdAt: any, inBlock: number, network: Types.Network }, metadata: { __typename: 'WorkingGroupOpeningMetadata', title?: string | null, applicationDetails?: string | null, shortDescription?: string | null, description?: string | null, hiringLimit?: number | null, expectedEnding?: any | null } };
+
+export type GetUpcomingWorkingGroupOpeningQueryVariables = Types.Exact<{
+  where: Types.UpcomingWorkingGroupOpeningWhereUniqueInput;
+}>;
+
+
+export type GetUpcomingWorkingGroupOpeningQuery = { __typename: 'Query', upcomingWorkingGroupOpeningByUniqueInput?: { __typename: 'UpcomingWorkingGroupOpening', id: string, groupId: string, expectedStart?: any | null, stakeAmount?: string | null, rewardPerBlock?: string | null, group: { __typename: 'WorkingGroup', name: string, budget: string, leaderId?: string | null }, createdInEvent: { __typename: 'StatusTextChangedEvent', createdAt: any, inBlock: number, network: Types.Network }, metadata: { __typename: 'WorkingGroupOpeningMetadata', title?: string | null, applicationDetails?: string | null, shortDescription?: string | null, description?: string | null, hiringLimit?: number | null, expectedEnding?: any | null } } | null };
+
+export type GetUpcomingWorkingGroupOpeningsQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.UpcomingWorkingGroupOpeningWhereInput>;
+  limit?: Types.InputMaybe<Types.Scalars['Int']>;
+  offset?: Types.InputMaybe<Types.Scalars['Int']>;
+}>;
+
+
+export type GetUpcomingWorkingGroupOpeningsQuery = { __typename: 'Query', upcomingWorkingGroupOpenings: Array<{ __typename: 'UpcomingWorkingGroupOpening', id: string, groupId: string, expectedStart?: any | null, stakeAmount?: string | null, rewardPerBlock?: string | null, group: { __typename: 'WorkingGroup', name: string, budget: string, leaderId?: string | null }, createdInEvent: { __typename: 'StatusTextChangedEvent', createdAt: any, inBlock: number, network: Types.Network }, metadata: { __typename: 'WorkingGroupOpeningMetadata', title?: string | null, applicationDetails?: string | null, shortDescription?: string | null, description?: string | null, hiringLimit?: number | null, expectedEnding?: any | null } }> };
+
+export type GetWorkerIdsQueryVariables = Types.Exact<{
+  where?: Types.InputMaybe<Types.WorkerWhereInput>;
+}>;
+
+
+export type GetWorkerIdsQuery = { __typename: 'Query', workers: Array<{ __typename: 'Worker', id: string }> };
+
+export type GetWorkerUnstakingDetailsQueryVariables = Types.Exact<{
+  where: Types.WorkerWhereUniqueInput;
+}>;
+
+
+export type GetWorkerUnstakingDetailsQuery = { __typename: 'Query', workerByUniqueInput?: { __typename: 'Worker', status: { __typename: 'WorkerStatusActive' } | { __typename: 'WorkerStatusLeaving', workerStartedLeavingEvent?: { __typename: 'WorkerStartedLeavingEvent', createdAt: any } | null } | { __typename: 'WorkerStatusLeft' } | { __typename: 'WorkerStatusTerminated' }, application: { __typename: 'WorkingGroupApplication', opening: { __typename: 'WorkingGroupOpening', unstakingPeriod: number } } } | null };
+
+export const PastWorkerFieldsFragmentDoc = gql`
+    fragment PastWorkerFields on Worker {
+  id
+  runtimeId
+  createdAt
+  updatedAt
+  status {
+    ... on WorkerStatusLeft {
+      workerExitedEvent {
+        createdAt
+        inBlock
+        network
+      }
+    }
+    ... on WorkerStatusTerminated {
+      terminatedWorkerEvent {
+        createdAt
+        inBlock
+        network
+      }
+    }
+  }
+  entry {
+    createdAt
+    inBlock
+    network
+  }
+}
+    `;
+export const WorkerFieldsFragmentDoc = gql`
+    fragment WorkerFields on Worker {
+  id
+  runtimeId
+  group {
+    id
+    name
+  }
+  status {
+    __typename
+  }
+  applicationId
+  isLead
+  rewardPerBlock
+  missingRewardAmount
+  stake
+}
+    `;
+export const WorkerDetailedFieldsFragmentDoc = gql`
+    fragment WorkerDetailedFields on Worker {
+  ...WorkerFields
+  roleAccount
+  rewardAccount
+  stakeAccount
+  entry {
+    inBlock
+    network
+    createdAt
+  }
+  application {
+    id
+    openingId
+    opening {
+      stakeAmount
+    }
+  }
+}
+    ${WorkerFieldsFragmentDoc}`;
+export const WorkingGroupMetadataFieldsFragmentDoc = gql`
+    fragment WorkingGroupMetadataFields on WorkingGroupMetadata {
+  about
+  description
+  status
+  statusMessage
+}
+    `;
+export const WorkingGroupFieldsFragmentDoc = gql`
+    fragment WorkingGroupFields on WorkingGroup {
+  id
+  name
+  budget
+  metadata {
+    ...WorkingGroupMetadataFields
+  }
+  workers {
+    stake
+  }
+  leader {
+    membershipId
+    isActive
+  }
+}
+    ${WorkingGroupMetadataFieldsFragmentDoc}`;
+export const WorkingGroupDetailedFieldsFragmentDoc = gql`
+    fragment WorkingGroupDetailedFields on WorkingGroup {
+  ...WorkingGroupFields
+  leader {
+    id
+    runtimeId
+    stake
+    membershipId
+    rewardPerBlock
+  }
+}
+    ${WorkingGroupFieldsFragmentDoc}`;
+export const BudgetSpendingEventFieldsFragmentDoc = gql`
+    fragment BudgetSpendingEventFields on BudgetSpendingEvent {
+  id
+  groupId
+  reciever
+  amount
+  rationale
+}
+    `;
+export const RewardPaidEventFieldsFragmentDoc = gql`
+    fragment RewardPaidEventFields on RewardPaidEvent {
+  id
+  amount
+  rewardAccount
+  createdAt
+}
+    `;
+export const WorkingGroupOpeningMetadataFieldsFragmentDoc = gql`
+    fragment WorkingGroupOpeningMetadataFields on WorkingGroupOpeningMetadata {
+  title
+  applicationDetails
+  shortDescription
+  description
+  hiringLimit
+  expectedEnding
+}
+    `;
+export const WorkingGroupOpeningFieldsFragmentDoc = gql`
+    fragment WorkingGroupOpeningFields on WorkingGroupOpening {
+  id
+  runtimeId
+  groupId
+  group {
+    name
+    budget
+    leaderId
+  }
+  type
+  stakeAmount
+  rewardPerBlock
+  createdInEvent {
+    inBlock
+    network
+    createdAt
+  }
+  metadata {
+    ...WorkingGroupOpeningMetadataFields
+  }
+  status {
+    __typename
+  }
+  unstakingPeriod
+  applications {
+    id
+    status {
+      __typename
+    }
+  }
+  openingfilledeventopening {
+    workersHired {
+      id
+    }
+  }
+}
+    ${WorkingGroupOpeningMetadataFieldsFragmentDoc}`;
+export const WorkingGroupOpeningDetailedFieldsFragmentDoc = gql`
+    fragment WorkingGroupOpeningDetailedFields on WorkingGroupOpening {
+  ...WorkingGroupOpeningFields
+  applications {
+    id
+    status {
+      __typename
+    }
+    status {
+      __typename
+    }
+  }
+}
+    ${WorkingGroupOpeningFieldsFragmentDoc}`;
+export const WorkingGroupOpeningMentionFieldsFragmentDoc = gql`
+    fragment WorkingGroupOpeningMentionFields on WorkingGroupOpening {
+  id
+  type
+  rewardPerBlock
+  metadata {
+    title
+    shortDescription
+    description
+    hiringLimit
+    expectedEnding
+  }
+  applications {
+    applicantId
+  }
+  openingfilledeventopening {
+    id
+    workersHired {
+      id
+    }
+  }
+}
+    `;
+export const WorkingGroupApplicationMentionFieldsFragmentDoc = gql`
+    fragment WorkingGroupApplicationMentionFields on WorkingGroupApplication {
+  id
+  createdInEvent {
+    createdAt
+    inBlock
+    network
+  }
+  opening {
+    type
+    metadata {
+      title
+      shortDescription
+      description
+    }
+  }
+}
+    `;
+export const WorkingGroupApplicationFieldsFragmentDoc = gql`
+    fragment WorkingGroupApplicationFields on WorkingGroupApplication {
+  id
+  runtimeId
+  answers {
+    answer
+    question {
+      question
+    }
+  }
+  opening {
+    id
+    group {
+      id
+      name
+    }
+    type
+    rewardPerBlock
+    metadata {
+      expectedEnding
+    }
+  }
+  status {
+    __typename
+  }
+  stakingAccount
+  createdInEvent {
+    createdAt
+    inBlock
+    network
+  }
+  stake
+  roleAccount
+}
+    `;
+export const ApplicationQuestionFieldsFragmentDoc = gql`
+    fragment ApplicationQuestionFields on ApplicationFormQuestion {
+  index
+  type
+  question
+}
+    `;
+export const ApplicationFormQuestionAnswerFieldsFragmentDoc = gql`
+    fragment ApplicationFormQuestionAnswerFields on ApplicationFormQuestionAnswer {
+  question {
+    ...ApplicationQuestionFields
+  }
+  answer
+}
+    ${ApplicationQuestionFieldsFragmentDoc}`;
+export const UpcomingWorkingGroupOpeningFieldsFragmentDoc = gql`
+    fragment UpcomingWorkingGroupOpeningFields on UpcomingWorkingGroupOpening {
+  id
+  groupId
+  group {
+    name
+    budget
+    leaderId
+  }
+  expectedStart
+  stakeAmount
+  rewardPerBlock
+  createdInEvent {
+    createdAt
+    inBlock
+    network
+  }
+  metadata {
+    ...WorkingGroupOpeningMetadataFields
+  }
+}
+    ${WorkingGroupOpeningMetadataFieldsFragmentDoc}`;
+export const GetWorkingGroupsDocument = gql`
+    query GetWorkingGroups($where: WorkingGroupWhereInput, $orderBy: [WorkingGroupOrderByInput!], $offset: Int, $limit: Int) {
+  workingGroups(where: $where, orderBy: $orderBy, offset: $offset, limit: $limit) {
+    ...WorkingGroupFields
+  }
+}
+    ${WorkingGroupFieldsFragmentDoc}`;
+
+/**
+ * __useGetWorkingGroupsQuery__
+ *
+ * To run a query within a React component, call `useGetWorkingGroupsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkingGroupsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetWorkingGroupsQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *      orderBy: // value for 'orderBy'
+ *      offset: // value for 'offset'
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export function useGetWorkingGroupsQuery(baseOptions?: Apollo.QueryHookOptions<GetWorkingGroupsQuery, GetWorkingGroupsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetWorkingGroupsQuery, GetWorkingGroupsQueryVariables>(GetWorkingGroupsDocument, options);
+      }
+export function useGetWorkingGroupsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetWorkingGroupsQuery, GetWorkingGroupsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetWorkingGroupsQuery, GetWorkingGroupsQueryVariables>(GetWorkingGroupsDocument, options);
+        }
+export type GetWorkingGroupsQueryHookResult = ReturnType<typeof useGetWorkingGroupsQuery>;
+export type GetWorkingGroupsLazyQueryHookResult = ReturnType<typeof useGetWorkingGroupsLazyQuery>;
+export type GetWorkingGroupsQueryResult = Apollo.QueryResult<GetWorkingGroupsQuery, GetWorkingGroupsQueryVariables>;
+export const GetBudgetSpendingDocument = gql`
+    query GetBudgetSpending($where: BudgetSpendingEventWhereInput) {
+  budgetSpendingEvents(where: $where) {
+    ...BudgetSpendingEventFields
+  }
+}
+    ${BudgetSpendingEventFieldsFragmentDoc}`;
+
+/**
+ * __useGetBudgetSpendingQuery__
+ *
+ * To run a query within a React component, call `useGetBudgetSpendingQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetBudgetSpendingQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetBudgetSpendingQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetBudgetSpendingQuery(baseOptions?: Apollo.QueryHookOptions<GetBudgetSpendingQuery, GetBudgetSpendingQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetBudgetSpendingQuery, GetBudgetSpendingQueryVariables>(GetBudgetSpendingDocument, options);
+      }
+export function useGetBudgetSpendingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetBudgetSpendingQuery, GetBudgetSpendingQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetBudgetSpendingQuery, GetBudgetSpendingQueryVariables>(GetBudgetSpendingDocument, options);
+        }
+export type GetBudgetSpendingQueryHookResult = ReturnType<typeof useGetBudgetSpendingQuery>;
+export type GetBudgetSpendingLazyQueryHookResult = ReturnType<typeof useGetBudgetSpendingLazyQuery>;
+export type GetBudgetSpendingQueryResult = Apollo.QueryResult<GetBudgetSpendingQuery, GetBudgetSpendingQueryVariables>;
+export const GetWorkersDocument = gql`
+    query GetWorkers($where: WorkerWhereInput, $offset: Int, $limit: Int) {
+  workers(where: $where, offset: $offset, limit: $limit) {
+    ...WorkerFields
+  }
+}
+    ${WorkerFieldsFragmentDoc}`;
+
+/**
+ * __useGetWorkersQuery__
+ *
+ * To run a query within a React component, call `useGetWorkersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkersQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetWorkersQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *      offset: // value for 'offset'
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export function useGetWorkersQuery(baseOptions?: Apollo.QueryHookOptions<GetWorkersQuery, GetWorkersQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetWorkersQuery, GetWorkersQueryVariables>(GetWorkersDocument, options);
+      }
+export function useGetWorkersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetWorkersQuery, GetWorkersQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetWorkersQuery, GetWorkersQueryVariables>(GetWorkersDocument, options);
+        }
+export type GetWorkersQueryHookResult = ReturnType<typeof useGetWorkersQuery>;
+export type GetWorkersLazyQueryHookResult = ReturnType<typeof useGetWorkersLazyQuery>;
+export type GetWorkersQueryResult = Apollo.QueryResult<GetWorkersQuery, GetWorkersQueryVariables>;
+export const GetPastWorkersDocument = gql`
+    query GetPastWorkers($where: WorkerWhereInput, $offset: Int, $limit: Int, $orderBy: [WorkerOrderByInput!]) {
+  workers(where: $where, offset: $offset, limit: $limit, orderBy: $orderBy) {
+    ...PastWorkerFields
+  }
+}
+    ${PastWorkerFieldsFragmentDoc}`;
+
+/**
+ * __useGetPastWorkersQuery__
+ *
+ * To run a query within a React component, call `useGetPastWorkersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetPastWorkersQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetPastWorkersQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *      offset: // value for 'offset'
+ *      limit: // value for 'limit'
+ *      orderBy: // value for 'orderBy'
+ *   },
+ * });
+ */
+export function useGetPastWorkersQuery(baseOptions?: Apollo.QueryHookOptions<GetPastWorkersQuery, GetPastWorkersQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetPastWorkersQuery, GetPastWorkersQueryVariables>(GetPastWorkersDocument, options);
+      }
+export function useGetPastWorkersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPastWorkersQuery, GetPastWorkersQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetPastWorkersQuery, GetPastWorkersQueryVariables>(GetPastWorkersDocument, options);
+        }
+export type GetPastWorkersQueryHookResult = ReturnType<typeof useGetPastWorkersQuery>;
+export type GetPastWorkersLazyQueryHookResult = ReturnType<typeof useGetPastWorkersLazyQuery>;
+export type GetPastWorkersQueryResult = Apollo.QueryResult<GetPastWorkersQuery, GetPastWorkersQueryVariables>;
+export const GetWorkersCountDocument = gql`
+    query GetWorkersCount($where: WorkerWhereInput) {
+  workersConnection(where: $where) {
+    totalCount
+  }
+}
+    `;
+
+/**
+ * __useGetWorkersCountQuery__
+ *
+ * To run a query within a React component, call `useGetWorkersCountQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkersCountQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetWorkersCountQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetWorkersCountQuery(baseOptions?: Apollo.QueryHookOptions<GetWorkersCountQuery, GetWorkersCountQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetWorkersCountQuery, GetWorkersCountQueryVariables>(GetWorkersCountDocument, options);
+      }
+export function useGetWorkersCountLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetWorkersCountQuery, GetWorkersCountQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetWorkersCountQuery, GetWorkersCountQueryVariables>(GetWorkersCountDocument, options);
+        }
+export type GetWorkersCountQueryHookResult = ReturnType<typeof useGetWorkersCountQuery>;
+export type GetWorkersCountLazyQueryHookResult = ReturnType<typeof useGetWorkersCountLazyQuery>;
+export type GetWorkersCountQueryResult = Apollo.QueryResult<GetWorkersCountQuery, GetWorkersCountQueryVariables>;
+export const GetDetailedWorkersDocument = gql`
+    query GetDetailedWorkers($where: WorkerWhereInput) {
+  workers(where: $where) {
+    ...WorkerDetailedFields
+  }
+}
+    ${WorkerDetailedFieldsFragmentDoc}`;
+
+/**
+ * __useGetDetailedWorkersQuery__
+ *
+ * To run a query within a React component, call `useGetDetailedWorkersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetDetailedWorkersQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetDetailedWorkersQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetDetailedWorkersQuery(baseOptions?: Apollo.QueryHookOptions<GetDetailedWorkersQuery, GetDetailedWorkersQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetDetailedWorkersQuery, GetDetailedWorkersQueryVariables>(GetDetailedWorkersDocument, options);
+      }
+export function useGetDetailedWorkersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDetailedWorkersQuery, GetDetailedWorkersQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetDetailedWorkersQuery, GetDetailedWorkersQueryVariables>(GetDetailedWorkersDocument, options);
+        }
+export type GetDetailedWorkersQueryHookResult = ReturnType<typeof useGetDetailedWorkersQuery>;
+export type GetDetailedWorkersLazyQueryHookResult = ReturnType<typeof useGetDetailedWorkersLazyQuery>;
+export type GetDetailedWorkersQueryResult = Apollo.QueryResult<GetDetailedWorkersQuery, GetDetailedWorkersQueryVariables>;
+export const GetWorkerDocument = gql`
+    query GetWorker($where: WorkerWhereUniqueInput!) {
+  workerByUniqueInput(where: $where) {
+    ...WorkerDetailedFields
+  }
+}
+    ${WorkerDetailedFieldsFragmentDoc}`;
+
+/**
+ * __useGetWorkerQuery__
+ *
+ * To run a query within a React component, call `useGetWorkerQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkerQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetWorkerQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetWorkerQuery(baseOptions: Apollo.QueryHookOptions<GetWorkerQuery, GetWorkerQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetWorkerQuery, GetWorkerQueryVariables>(GetWorkerDocument, options);
+      }
+export function useGetWorkerLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetWorkerQuery, GetWorkerQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetWorkerQuery, GetWorkerQueryVariables>(GetWorkerDocument, options);
+        }
+export type GetWorkerQueryHookResult = ReturnType<typeof useGetWorkerQuery>;
+export type GetWorkerLazyQueryHookResult = ReturnType<typeof useGetWorkerLazyQuery>;
+export type GetWorkerQueryResult = Apollo.QueryResult<GetWorkerQuery, GetWorkerQueryVariables>;
+export const GetGroupDebtDocument = gql`
+    query GetGroupDebt($where: WorkerWhereInput!) {
+  workers(where: $where) {
+    missingRewardAmount
+  }
+}
+    `;
+
+/**
+ * __useGetGroupDebtQuery__
+ *
+ * To run a query within a React component, call `useGetGroupDebtQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetGroupDebtQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetGroupDebtQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetGroupDebtQuery(baseOptions: Apollo.QueryHookOptions<GetGroupDebtQuery, GetGroupDebtQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetGroupDebtQuery, GetGroupDebtQueryVariables>(GetGroupDebtDocument, options);
+      }
+export function useGetGroupDebtLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetGroupDebtQuery, GetGroupDebtQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetGroupDebtQuery, GetGroupDebtQueryVariables>(GetGroupDebtDocument, options);
+        }
+export type GetGroupDebtQueryHookResult = ReturnType<typeof useGetGroupDebtQuery>;
+export type GetGroupDebtLazyQueryHookResult = ReturnType<typeof useGetGroupDebtLazyQuery>;
+export type GetGroupDebtQueryResult = Apollo.QueryResult<GetGroupDebtQuery, GetGroupDebtQueryVariables>;
+export const GetRewardsDocument = gql`
+    query GetRewards($where: RewardPaidEventWhereInput) {
+  rewardPaidEvents(where: $where) {
+    ...RewardPaidEventFields
+  }
+}
+    ${RewardPaidEventFieldsFragmentDoc}`;
+
+/**
+ * __useGetRewardsQuery__
+ *
+ * To run a query within a React component, call `useGetRewardsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetRewardsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetRewardsQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetRewardsQuery(baseOptions?: Apollo.QueryHookOptions<GetRewardsQuery, GetRewardsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetRewardsQuery, GetRewardsQueryVariables>(GetRewardsDocument, options);
+      }
+export function useGetRewardsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetRewardsQuery, GetRewardsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetRewardsQuery, GetRewardsQueryVariables>(GetRewardsDocument, options);
+        }
+export type GetRewardsQueryHookResult = ReturnType<typeof useGetRewardsQuery>;
+export type GetRewardsLazyQueryHookResult = ReturnType<typeof useGetRewardsLazyQuery>;
+export type GetRewardsQueryResult = Apollo.QueryResult<GetRewardsQuery, GetRewardsQueryVariables>;
+export const CountWorkingGroupOpeningsDocument = gql`
+    query CountWorkingGroupOpenings($where: WorkingGroupOpeningWhereInput) {
+  workingGroupOpeningsConnection(where: $where) {
+    totalCount
+  }
+}
+    `;
+
+/**
+ * __useCountWorkingGroupOpeningsQuery__
+ *
+ * To run a query within a React component, call `useCountWorkingGroupOpeningsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCountWorkingGroupOpeningsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useCountWorkingGroupOpeningsQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useCountWorkingGroupOpeningsQuery(baseOptions?: Apollo.QueryHookOptions<CountWorkingGroupOpeningsQuery, CountWorkingGroupOpeningsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<CountWorkingGroupOpeningsQuery, CountWorkingGroupOpeningsQueryVariables>(CountWorkingGroupOpeningsDocument, options);
+      }
+export function useCountWorkingGroupOpeningsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CountWorkingGroupOpeningsQuery, CountWorkingGroupOpeningsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<CountWorkingGroupOpeningsQuery, CountWorkingGroupOpeningsQueryVariables>(CountWorkingGroupOpeningsDocument, options);
+        }
+export type CountWorkingGroupOpeningsQueryHookResult = ReturnType<typeof useCountWorkingGroupOpeningsQuery>;
+export type CountWorkingGroupOpeningsLazyQueryHookResult = ReturnType<typeof useCountWorkingGroupOpeningsLazyQuery>;
+export type CountWorkingGroupOpeningsQueryResult = Apollo.QueryResult<CountWorkingGroupOpeningsQuery, CountWorkingGroupOpeningsQueryVariables>;
+export const CountWorkingGroupWorkersDocument = gql`
+    query CountWorkingGroupWorkers($groupId_eq: ID, $status_json: JSONObject) {
+  workersConnection(
+    where: {group: {id_eq: $groupId_eq}, status_json: $status_json}
+  ) {
+    totalCount
+  }
+}
+    `;
+
+/**
+ * __useCountWorkingGroupWorkersQuery__
+ *
+ * To run a query within a React component, call `useCountWorkingGroupWorkersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCountWorkingGroupWorkersQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useCountWorkingGroupWorkersQuery({
+ *   variables: {
+ *      groupId_eq: // value for 'groupId_eq'
+ *      status_json: // value for 'status_json'
+ *   },
+ * });
+ */
+export function useCountWorkingGroupWorkersQuery(baseOptions?: Apollo.QueryHookOptions<CountWorkingGroupWorkersQuery, CountWorkingGroupWorkersQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<CountWorkingGroupWorkersQuery, CountWorkingGroupWorkersQueryVariables>(CountWorkingGroupWorkersDocument, options);
+      }
+export function useCountWorkingGroupWorkersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CountWorkingGroupWorkersQuery, CountWorkingGroupWorkersQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<CountWorkingGroupWorkersQuery, CountWorkingGroupWorkersQueryVariables>(CountWorkingGroupWorkersDocument, options);
+        }
+export type CountWorkingGroupWorkersQueryHookResult = ReturnType<typeof useCountWorkingGroupWorkersQuery>;
+export type CountWorkingGroupWorkersLazyQueryHookResult = ReturnType<typeof useCountWorkingGroupWorkersLazyQuery>;
+export type CountWorkingGroupWorkersQueryResult = Apollo.QueryResult<CountWorkingGroupWorkersQuery, CountWorkingGroupWorkersQueryVariables>;
+export const GetWorkingGroupOpeningsDocument = gql`
+    query GetWorkingGroupOpenings($where: WorkingGroupOpeningWhereInput, $order: [WorkingGroupOpeningOrderByInput!], $limit: Int, $offset: Int) {
+  workingGroupOpenings(
+    where: $where
+    limit: $limit
+    offset: $offset
+    orderBy: $order
+  ) {
+    ...WorkingGroupOpeningFields
+  }
+}
+    ${WorkingGroupOpeningFieldsFragmentDoc}`;
+
+/**
+ * __useGetWorkingGroupOpeningsQuery__
+ *
+ * To run a query within a React component, call `useGetWorkingGroupOpeningsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkingGroupOpeningsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetWorkingGroupOpeningsQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *      order: // value for 'order'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export function useGetWorkingGroupOpeningsQuery(baseOptions?: Apollo.QueryHookOptions<GetWorkingGroupOpeningsQuery, GetWorkingGroupOpeningsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetWorkingGroupOpeningsQuery, GetWorkingGroupOpeningsQueryVariables>(GetWorkingGroupOpeningsDocument, options);
+      }
+export function useGetWorkingGroupOpeningsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetWorkingGroupOpeningsQuery, GetWorkingGroupOpeningsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetWorkingGroupOpeningsQuery, GetWorkingGroupOpeningsQueryVariables>(GetWorkingGroupOpeningsDocument, options);
+        }
+export type GetWorkingGroupOpeningsQueryHookResult = ReturnType<typeof useGetWorkingGroupOpeningsQuery>;
+export type GetWorkingGroupOpeningsLazyQueryHookResult = ReturnType<typeof useGetWorkingGroupOpeningsLazyQuery>;
+export type GetWorkingGroupOpeningsQueryResult = Apollo.QueryResult<GetWorkingGroupOpeningsQuery, GetWorkingGroupOpeningsQueryVariables>;
+export const SimpleSearchWorkingGroupOpeningsDocument = gql`
+    query SimpleSearchWorkingGroupOpenings($text: String!, $limit: Int) {
+  workingGroupOpenings(
+    where: {metadata: {shortDescription_contains: $text}}
+    limit: $limit
+  ) {
+    id
+    metadata {
+      shortDescription
+    }
+  }
+}
+    `;
+
+/**
+ * __useSimpleSearchWorkingGroupOpeningsQuery__
+ *
+ * To run a query within a React component, call `useSimpleSearchWorkingGroupOpeningsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useSimpleSearchWorkingGroupOpeningsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useSimpleSearchWorkingGroupOpeningsQuery({
+ *   variables: {
+ *      text: // value for 'text'
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export function useSimpleSearchWorkingGroupOpeningsQuery(baseOptions: Apollo.QueryHookOptions<SimpleSearchWorkingGroupOpeningsQuery, SimpleSearchWorkingGroupOpeningsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<SimpleSearchWorkingGroupOpeningsQuery, SimpleSearchWorkingGroupOpeningsQueryVariables>(SimpleSearchWorkingGroupOpeningsDocument, options);
+      }
+export function useSimpleSearchWorkingGroupOpeningsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SimpleSearchWorkingGroupOpeningsQuery, SimpleSearchWorkingGroupOpeningsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<SimpleSearchWorkingGroupOpeningsQuery, SimpleSearchWorkingGroupOpeningsQueryVariables>(SimpleSearchWorkingGroupOpeningsDocument, options);
+        }
+export type SimpleSearchWorkingGroupOpeningsQueryHookResult = ReturnType<typeof useSimpleSearchWorkingGroupOpeningsQuery>;
+export type SimpleSearchWorkingGroupOpeningsLazyQueryHookResult = ReturnType<typeof useSimpleSearchWorkingGroupOpeningsLazyQuery>;
+export type SimpleSearchWorkingGroupOpeningsQueryResult = Apollo.QueryResult<SimpleSearchWorkingGroupOpeningsQuery, SimpleSearchWorkingGroupOpeningsQueryVariables>;
+export const GetWorkingGroupOpeningDocument = gql`
+    query GetWorkingGroupOpening($where: WorkingGroupOpeningWhereUniqueInput!) {
+  workingGroupOpeningByUniqueInput(where: $where) {
+    ...WorkingGroupOpeningDetailedFields
+  }
+}
+    ${WorkingGroupOpeningDetailedFieldsFragmentDoc}`;
+
+/**
+ * __useGetWorkingGroupOpeningQuery__
+ *
+ * To run a query within a React component, call `useGetWorkingGroupOpeningQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkingGroupOpeningQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetWorkingGroupOpeningQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetWorkingGroupOpeningQuery(baseOptions: Apollo.QueryHookOptions<GetWorkingGroupOpeningQuery, GetWorkingGroupOpeningQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetWorkingGroupOpeningQuery, GetWorkingGroupOpeningQueryVariables>(GetWorkingGroupOpeningDocument, options);
+      }
+export function useGetWorkingGroupOpeningLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetWorkingGroupOpeningQuery, GetWorkingGroupOpeningQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetWorkingGroupOpeningQuery, GetWorkingGroupOpeningQueryVariables>(GetWorkingGroupOpeningDocument, options);
+        }
+export type GetWorkingGroupOpeningQueryHookResult = ReturnType<typeof useGetWorkingGroupOpeningQuery>;
+export type GetWorkingGroupOpeningLazyQueryHookResult = ReturnType<typeof useGetWorkingGroupOpeningLazyQuery>;
+export type GetWorkingGroupOpeningQueryResult = Apollo.QueryResult<GetWorkingGroupOpeningQuery, GetWorkingGroupOpeningQueryVariables>;
+export const GetWorkingGroupOpeningMentionDocument = gql`
+    query GetWorkingGroupOpeningMention($id: ID!) {
+  opening: workingGroupOpeningByUniqueInput(where: {id: $id}) {
+    ...WorkingGroupOpeningMentionFields
+  }
+}
+    ${WorkingGroupOpeningMentionFieldsFragmentDoc}`;
+
+/**
+ * __useGetWorkingGroupOpeningMentionQuery__
+ *
+ * To run a query within a React component, call `useGetWorkingGroupOpeningMentionQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkingGroupOpeningMentionQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetWorkingGroupOpeningMentionQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useGetWorkingGroupOpeningMentionQuery(baseOptions: Apollo.QueryHookOptions<GetWorkingGroupOpeningMentionQuery, GetWorkingGroupOpeningMentionQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetWorkingGroupOpeningMentionQuery, GetWorkingGroupOpeningMentionQueryVariables>(GetWorkingGroupOpeningMentionDocument, options);
+      }
+export function useGetWorkingGroupOpeningMentionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetWorkingGroupOpeningMentionQuery, GetWorkingGroupOpeningMentionQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetWorkingGroupOpeningMentionQuery, GetWorkingGroupOpeningMentionQueryVariables>(GetWorkingGroupOpeningMentionDocument, options);
+        }
+export type GetWorkingGroupOpeningMentionQueryHookResult = ReturnType<typeof useGetWorkingGroupOpeningMentionQuery>;
+export type GetWorkingGroupOpeningMentionLazyQueryHookResult = ReturnType<typeof useGetWorkingGroupOpeningMentionLazyQuery>;
+export type GetWorkingGroupOpeningMentionQueryResult = Apollo.QueryResult<GetWorkingGroupOpeningMentionQuery, GetWorkingGroupOpeningMentionQueryVariables>;
+export const GetWorkingGroupApplicationMentionDocument = gql`
+    query GetWorkingGroupApplicationMention($id: ID!) {
+  application: workingGroupApplicationByUniqueInput(where: {id: $id}) {
+    ...WorkingGroupApplicationMentionFields
+  }
+}
+    ${WorkingGroupApplicationMentionFieldsFragmentDoc}`;
+
+/**
+ * __useGetWorkingGroupApplicationMentionQuery__
+ *
+ * To run a query within a React component, call `useGetWorkingGroupApplicationMentionQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkingGroupApplicationMentionQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetWorkingGroupApplicationMentionQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useGetWorkingGroupApplicationMentionQuery(baseOptions: Apollo.QueryHookOptions<GetWorkingGroupApplicationMentionQuery, GetWorkingGroupApplicationMentionQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetWorkingGroupApplicationMentionQuery, GetWorkingGroupApplicationMentionQueryVariables>(GetWorkingGroupApplicationMentionDocument, options);
+      }
+export function useGetWorkingGroupApplicationMentionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetWorkingGroupApplicationMentionQuery, GetWorkingGroupApplicationMentionQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetWorkingGroupApplicationMentionQuery, GetWorkingGroupApplicationMentionQueryVariables>(GetWorkingGroupApplicationMentionDocument, options);
+        }
+export type GetWorkingGroupApplicationMentionQueryHookResult = ReturnType<typeof useGetWorkingGroupApplicationMentionQuery>;
+export type GetWorkingGroupApplicationMentionLazyQueryHookResult = ReturnType<typeof useGetWorkingGroupApplicationMentionLazyQuery>;
+export type GetWorkingGroupApplicationMentionQueryResult = Apollo.QueryResult<GetWorkingGroupApplicationMentionQuery, GetWorkingGroupApplicationMentionQueryVariables>;
+export const GetWorkingGroupOpeningQuestionsDocument = gql`
+    query GetWorkingGroupOpeningQuestions($id: ID!) {
+  workingGroupOpeningByUniqueInput(where: {id: $id}) {
+    metadata {
+      applicationFormQuestions {
+        ...ApplicationQuestionFields
+      }
+    }
+  }
+}
+    ${ApplicationQuestionFieldsFragmentDoc}`;
+
+/**
+ * __useGetWorkingGroupOpeningQuestionsQuery__
+ *
+ * To run a query within a React component, call `useGetWorkingGroupOpeningQuestionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkingGroupOpeningQuestionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetWorkingGroupOpeningQuestionsQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useGetWorkingGroupOpeningQuestionsQuery(baseOptions: Apollo.QueryHookOptions<GetWorkingGroupOpeningQuestionsQuery, GetWorkingGroupOpeningQuestionsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetWorkingGroupOpeningQuestionsQuery, GetWorkingGroupOpeningQuestionsQueryVariables>(GetWorkingGroupOpeningQuestionsDocument, options);
+      }
+export function useGetWorkingGroupOpeningQuestionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetWorkingGroupOpeningQuestionsQuery, GetWorkingGroupOpeningQuestionsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetWorkingGroupOpeningQuestionsQuery, GetWorkingGroupOpeningQuestionsQueryVariables>(GetWorkingGroupOpeningQuestionsDocument, options);
+        }
+export type GetWorkingGroupOpeningQuestionsQueryHookResult = ReturnType<typeof useGetWorkingGroupOpeningQuestionsQuery>;
+export type GetWorkingGroupOpeningQuestionsLazyQueryHookResult = ReturnType<typeof useGetWorkingGroupOpeningQuestionsLazyQuery>;
+export type GetWorkingGroupOpeningQuestionsQueryResult = Apollo.QueryResult<GetWorkingGroupOpeningQuestionsQuery, GetWorkingGroupOpeningQuestionsQueryVariables>;
+export const GetWorkingGroupDocument = gql`
+    query GetWorkingGroup($where: WorkingGroupWhereUniqueInput!) {
+  workingGroupByUniqueInput(where: $where) {
+    ...WorkingGroupDetailedFields
+  }
+}
+    ${WorkingGroupDetailedFieldsFragmentDoc}`;
+
+/**
+ * __useGetWorkingGroupQuery__
+ *
+ * To run a query within a React component, call `useGetWorkingGroupQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkingGroupQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetWorkingGroupQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetWorkingGroupQuery(baseOptions: Apollo.QueryHookOptions<GetWorkingGroupQuery, GetWorkingGroupQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetWorkingGroupQuery, GetWorkingGroupQueryVariables>(GetWorkingGroupDocument, options);
+      }
+export function useGetWorkingGroupLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetWorkingGroupQuery, GetWorkingGroupQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetWorkingGroupQuery, GetWorkingGroupQueryVariables>(GetWorkingGroupDocument, options);
+        }
+export type GetWorkingGroupQueryHookResult = ReturnType<typeof useGetWorkingGroupQuery>;
+export type GetWorkingGroupLazyQueryHookResult = ReturnType<typeof useGetWorkingGroupLazyQuery>;
+export type GetWorkingGroupQueryResult = Apollo.QueryResult<GetWorkingGroupQuery, GetWorkingGroupQueryVariables>;
+export const GetWorkingGroupApplicationsDocument = gql`
+    query GetWorkingGroupApplications($where: WorkingGroupApplicationWhereInput, $orderBy: [WorkingGroupApplicationOrderByInput!], $limit: Int) {
+  workingGroupApplications(where: $where, orderBy: $orderBy, limit: $limit) {
+    ...WorkingGroupApplicationFields
+  }
+}
+    ${WorkingGroupApplicationFieldsFragmentDoc}`;
+
+/**
+ * __useGetWorkingGroupApplicationsQuery__
+ *
+ * To run a query within a React component, call `useGetWorkingGroupApplicationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkingGroupApplicationsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetWorkingGroupApplicationsQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *      orderBy: // value for 'orderBy'
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export function useGetWorkingGroupApplicationsQuery(baseOptions?: Apollo.QueryHookOptions<GetWorkingGroupApplicationsQuery, GetWorkingGroupApplicationsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetWorkingGroupApplicationsQuery, GetWorkingGroupApplicationsQueryVariables>(GetWorkingGroupApplicationsDocument, options);
+      }
+export function useGetWorkingGroupApplicationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetWorkingGroupApplicationsQuery, GetWorkingGroupApplicationsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetWorkingGroupApplicationsQuery, GetWorkingGroupApplicationsQueryVariables>(GetWorkingGroupApplicationsDocument, options);
+        }
+export type GetWorkingGroupApplicationsQueryHookResult = ReturnType<typeof useGetWorkingGroupApplicationsQuery>;
+export type GetWorkingGroupApplicationsLazyQueryHookResult = ReturnType<typeof useGetWorkingGroupApplicationsLazyQuery>;
+export type GetWorkingGroupApplicationsQueryResult = Apollo.QueryResult<GetWorkingGroupApplicationsQuery, GetWorkingGroupApplicationsQueryVariables>;
+export const SimpleSearchWorkingGroupApplicationsDocument = gql`
+    query SimpleSearchWorkingGroupApplications($text: String!, $limit: Int) {
+  workingGroupApplications(
+    where: {applicant: {handle_contains: $text}}
+    limit: $limit
+  ) {
+    id
+    applicant {
+      id
+      handle
+    }
+  }
+}
+    `;
+
+/**
+ * __useSimpleSearchWorkingGroupApplicationsQuery__
+ *
+ * To run a query within a React component, call `useSimpleSearchWorkingGroupApplicationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useSimpleSearchWorkingGroupApplicationsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useSimpleSearchWorkingGroupApplicationsQuery({
+ *   variables: {
+ *      text: // value for 'text'
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export function useSimpleSearchWorkingGroupApplicationsQuery(baseOptions: Apollo.QueryHookOptions<SimpleSearchWorkingGroupApplicationsQuery, SimpleSearchWorkingGroupApplicationsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<SimpleSearchWorkingGroupApplicationsQuery, SimpleSearchWorkingGroupApplicationsQueryVariables>(SimpleSearchWorkingGroupApplicationsDocument, options);
+      }
+export function useSimpleSearchWorkingGroupApplicationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SimpleSearchWorkingGroupApplicationsQuery, SimpleSearchWorkingGroupApplicationsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<SimpleSearchWorkingGroupApplicationsQuery, SimpleSearchWorkingGroupApplicationsQueryVariables>(SimpleSearchWorkingGroupApplicationsDocument, options);
+        }
+export type SimpleSearchWorkingGroupApplicationsQueryHookResult = ReturnType<typeof useSimpleSearchWorkingGroupApplicationsQuery>;
+export type SimpleSearchWorkingGroupApplicationsLazyQueryHookResult = ReturnType<typeof useSimpleSearchWorkingGroupApplicationsLazyQuery>;
+export type SimpleSearchWorkingGroupApplicationsQueryResult = Apollo.QueryResult<SimpleSearchWorkingGroupApplicationsQuery, SimpleSearchWorkingGroupApplicationsQueryVariables>;
+export const GetWorkingGroupApplicationIdsDocument = gql`
+    query GetWorkingGroupApplicationIds($where: WorkingGroupApplicationWhereInput) {
+  workingGroupApplications(where: $where) {
+    id
+  }
+}
+    `;
+
+/**
+ * __useGetWorkingGroupApplicationIdsQuery__
+ *
+ * To run a query within a React component, call `useGetWorkingGroupApplicationIdsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkingGroupApplicationIdsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetWorkingGroupApplicationIdsQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetWorkingGroupApplicationIdsQuery(baseOptions?: Apollo.QueryHookOptions<GetWorkingGroupApplicationIdsQuery, GetWorkingGroupApplicationIdsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetWorkingGroupApplicationIdsQuery, GetWorkingGroupApplicationIdsQueryVariables>(GetWorkingGroupApplicationIdsDocument, options);
+      }
+export function useGetWorkingGroupApplicationIdsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetWorkingGroupApplicationIdsQuery, GetWorkingGroupApplicationIdsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetWorkingGroupApplicationIdsQuery, GetWorkingGroupApplicationIdsQueryVariables>(GetWorkingGroupApplicationIdsDocument, options);
+        }
+export type GetWorkingGroupApplicationIdsQueryHookResult = ReturnType<typeof useGetWorkingGroupApplicationIdsQuery>;
+export type GetWorkingGroupApplicationIdsLazyQueryHookResult = ReturnType<typeof useGetWorkingGroupApplicationIdsLazyQuery>;
+export type GetWorkingGroupApplicationIdsQueryResult = Apollo.QueryResult<GetWorkingGroupApplicationIdsQuery, GetWorkingGroupApplicationIdsQueryVariables>;
+export const GetWorkingGroupApplicationDocument = gql`
+    query GetWorkingGroupApplication($where: WorkingGroupApplicationWhereUniqueInput!) {
+  workingGroupApplicationByUniqueInput(where: $where) {
+    ...WorkingGroupApplicationFields
+  }
+}
+    ${WorkingGroupApplicationFieldsFragmentDoc}`;
+
+/**
+ * __useGetWorkingGroupApplicationQuery__
+ *
+ * To run a query within a React component, call `useGetWorkingGroupApplicationQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkingGroupApplicationQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetWorkingGroupApplicationQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetWorkingGroupApplicationQuery(baseOptions: Apollo.QueryHookOptions<GetWorkingGroupApplicationQuery, GetWorkingGroupApplicationQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetWorkingGroupApplicationQuery, GetWorkingGroupApplicationQueryVariables>(GetWorkingGroupApplicationDocument, options);
+      }
+export function useGetWorkingGroupApplicationLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetWorkingGroupApplicationQuery, GetWorkingGroupApplicationQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetWorkingGroupApplicationQuery, GetWorkingGroupApplicationQueryVariables>(GetWorkingGroupApplicationDocument, options);
+        }
+export type GetWorkingGroupApplicationQueryHookResult = ReturnType<typeof useGetWorkingGroupApplicationQuery>;
+export type GetWorkingGroupApplicationLazyQueryHookResult = ReturnType<typeof useGetWorkingGroupApplicationLazyQuery>;
+export type GetWorkingGroupApplicationQueryResult = Apollo.QueryResult<GetWorkingGroupApplicationQuery, GetWorkingGroupApplicationQueryVariables>;
+export const GetApplicationFormQuestionAnswerDocument = gql`
+    query GetApplicationFormQuestionAnswer($applicationId_eq: ID) {
+  applicationFormQuestionAnswers(where: {application: {id_eq: $applicationId_eq}}) {
+    ...ApplicationFormQuestionAnswerFields
+  }
+}
+    ${ApplicationFormQuestionAnswerFieldsFragmentDoc}`;
+
+/**
+ * __useGetApplicationFormQuestionAnswerQuery__
+ *
+ * To run a query within a React component, call `useGetApplicationFormQuestionAnswerQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetApplicationFormQuestionAnswerQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetApplicationFormQuestionAnswerQuery({
+ *   variables: {
+ *      applicationId_eq: // value for 'applicationId_eq'
+ *   },
+ * });
+ */
+export function useGetApplicationFormQuestionAnswerQuery(baseOptions?: Apollo.QueryHookOptions<GetApplicationFormQuestionAnswerQuery, GetApplicationFormQuestionAnswerQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetApplicationFormQuestionAnswerQuery, GetApplicationFormQuestionAnswerQueryVariables>(GetApplicationFormQuestionAnswerDocument, options);
+      }
+export function useGetApplicationFormQuestionAnswerLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetApplicationFormQuestionAnswerQuery, GetApplicationFormQuestionAnswerQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetApplicationFormQuestionAnswerQuery, GetApplicationFormQuestionAnswerQueryVariables>(GetApplicationFormQuestionAnswerDocument, options);
+        }
+export type GetApplicationFormQuestionAnswerQueryHookResult = ReturnType<typeof useGetApplicationFormQuestionAnswerQuery>;
+export type GetApplicationFormQuestionAnswerLazyQueryHookResult = ReturnType<typeof useGetApplicationFormQuestionAnswerLazyQuery>;
+export type GetApplicationFormQuestionAnswerQueryResult = Apollo.QueryResult<GetApplicationFormQuestionAnswerQuery, GetApplicationFormQuestionAnswerQueryVariables>;
+export const GetUpcomingWorkingGroupOpeningDocument = gql`
+    query GetUpcomingWorkingGroupOpening($where: UpcomingWorkingGroupOpeningWhereUniqueInput!) {
+  upcomingWorkingGroupOpeningByUniqueInput(where: $where) {
+    ...UpcomingWorkingGroupOpeningFields
+  }
+}
+    ${UpcomingWorkingGroupOpeningFieldsFragmentDoc}`;
+
+/**
+ * __useGetUpcomingWorkingGroupOpeningQuery__
+ *
+ * To run a query within a React component, call `useGetUpcomingWorkingGroupOpeningQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetUpcomingWorkingGroupOpeningQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetUpcomingWorkingGroupOpeningQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetUpcomingWorkingGroupOpeningQuery(baseOptions: Apollo.QueryHookOptions<GetUpcomingWorkingGroupOpeningQuery, GetUpcomingWorkingGroupOpeningQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetUpcomingWorkingGroupOpeningQuery, GetUpcomingWorkingGroupOpeningQueryVariables>(GetUpcomingWorkingGroupOpeningDocument, options);
+      }
+export function useGetUpcomingWorkingGroupOpeningLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetUpcomingWorkingGroupOpeningQuery, GetUpcomingWorkingGroupOpeningQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetUpcomingWorkingGroupOpeningQuery, GetUpcomingWorkingGroupOpeningQueryVariables>(GetUpcomingWorkingGroupOpeningDocument, options);
+        }
+export type GetUpcomingWorkingGroupOpeningQueryHookResult = ReturnType<typeof useGetUpcomingWorkingGroupOpeningQuery>;
+export type GetUpcomingWorkingGroupOpeningLazyQueryHookResult = ReturnType<typeof useGetUpcomingWorkingGroupOpeningLazyQuery>;
+export type GetUpcomingWorkingGroupOpeningQueryResult = Apollo.QueryResult<GetUpcomingWorkingGroupOpeningQuery, GetUpcomingWorkingGroupOpeningQueryVariables>;
+export const GetUpcomingWorkingGroupOpeningsDocument = gql`
+    query GetUpcomingWorkingGroupOpenings($where: UpcomingWorkingGroupOpeningWhereInput, $limit: Int, $offset: Int) {
+  upcomingWorkingGroupOpenings(where: $where, limit: $limit, offset: $offset) {
+    ...UpcomingWorkingGroupOpeningFields
+  }
+}
+    ${UpcomingWorkingGroupOpeningFieldsFragmentDoc}`;
+
+/**
+ * __useGetUpcomingWorkingGroupOpeningsQuery__
+ *
+ * To run a query within a React component, call `useGetUpcomingWorkingGroupOpeningsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetUpcomingWorkingGroupOpeningsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetUpcomingWorkingGroupOpeningsQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export function useGetUpcomingWorkingGroupOpeningsQuery(baseOptions?: Apollo.QueryHookOptions<GetUpcomingWorkingGroupOpeningsQuery, GetUpcomingWorkingGroupOpeningsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetUpcomingWorkingGroupOpeningsQuery, GetUpcomingWorkingGroupOpeningsQueryVariables>(GetUpcomingWorkingGroupOpeningsDocument, options);
+      }
+export function useGetUpcomingWorkingGroupOpeningsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetUpcomingWorkingGroupOpeningsQuery, GetUpcomingWorkingGroupOpeningsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetUpcomingWorkingGroupOpeningsQuery, GetUpcomingWorkingGroupOpeningsQueryVariables>(GetUpcomingWorkingGroupOpeningsDocument, options);
+        }
+export type GetUpcomingWorkingGroupOpeningsQueryHookResult = ReturnType<typeof useGetUpcomingWorkingGroupOpeningsQuery>;
+export type GetUpcomingWorkingGroupOpeningsLazyQueryHookResult = ReturnType<typeof useGetUpcomingWorkingGroupOpeningsLazyQuery>;
+export type GetUpcomingWorkingGroupOpeningsQueryResult = Apollo.QueryResult<GetUpcomingWorkingGroupOpeningsQuery, GetUpcomingWorkingGroupOpeningsQueryVariables>;
+export const GetWorkerIdsDocument = gql`
+    query GetWorkerIds($where: WorkerWhereInput) {
+  workers(where: $where) {
+    id
+  }
+}
+    `;
+
+/**
+ * __useGetWorkerIdsQuery__
+ *
+ * To run a query within a React component, call `useGetWorkerIdsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkerIdsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetWorkerIdsQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetWorkerIdsQuery(baseOptions?: Apollo.QueryHookOptions<GetWorkerIdsQuery, GetWorkerIdsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetWorkerIdsQuery, GetWorkerIdsQueryVariables>(GetWorkerIdsDocument, options);
+      }
+export function useGetWorkerIdsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetWorkerIdsQuery, GetWorkerIdsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetWorkerIdsQuery, GetWorkerIdsQueryVariables>(GetWorkerIdsDocument, options);
+        }
+export type GetWorkerIdsQueryHookResult = ReturnType<typeof useGetWorkerIdsQuery>;
+export type GetWorkerIdsLazyQueryHookResult = ReturnType<typeof useGetWorkerIdsLazyQuery>;
+export type GetWorkerIdsQueryResult = Apollo.QueryResult<GetWorkerIdsQuery, GetWorkerIdsQueryVariables>;
+export const GetWorkerUnstakingDetailsDocument = gql`
+    query GetWorkerUnstakingDetails($where: WorkerWhereUniqueInput!) {
+  workerByUniqueInput(where: $where) {
+    status {
+      __typename
+      ... on WorkerStatusLeaving {
+        workerStartedLeavingEvent {
+          createdAt
+        }
+      }
+    }
+    application {
+      opening {
+        unstakingPeriod
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __useGetWorkerUnstakingDetailsQuery__
+ *
+ * To run a query within a React component, call `useGetWorkerUnstakingDetailsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkerUnstakingDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetWorkerUnstakingDetailsQuery({
+ *   variables: {
+ *      where: // value for 'where'
+ *   },
+ * });
+ */
+export function useGetWorkerUnstakingDetailsQuery(baseOptions: Apollo.QueryHookOptions<GetWorkerUnstakingDetailsQuery, GetWorkerUnstakingDetailsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetWorkerUnstakingDetailsQuery, GetWorkerUnstakingDetailsQueryVariables>(GetWorkerUnstakingDetailsDocument, options);
+      }
+export function useGetWorkerUnstakingDetailsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetWorkerUnstakingDetailsQuery, GetWorkerUnstakingDetailsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetWorkerUnstakingDetailsQuery, GetWorkerUnstakingDetailsQueryVariables>(GetWorkerUnstakingDetailsDocument, options);
+        }
+export type GetWorkerUnstakingDetailsQueryHookResult = ReturnType<typeof useGetWorkerUnstakingDetailsQuery>;
+export type GetWorkerUnstakingDetailsLazyQueryHookResult = ReturnType<typeof useGetWorkerUnstakingDetailsLazyQuery>;
+export type GetWorkerUnstakingDetailsQueryResult = Apollo.QueryResult<GetWorkerUnstakingDetailsQuery, GetWorkerUnstakingDetailsQueryVariables>;

yarn.lock

@@ -1200,6 +1200,14 @@
   resolved "https://registry.yarnpkg.com/@gar/promisify/-/promisify-1.1.3.tgz#555193ab2e3bb3b6adc3d551c9c030d9e860daf6"
   integrity sha512-k2Ty1JcVojjJFwrg/ThKi2ujJ7XNLYaFGNB/bWT9wGR+oSMJHMa5w+CUq6p/pVrKeNNgA7pCqEcjSnHVoqJQFw==
 
+"@graphql-codegen/add@^3.2.1":
+  version "3.2.3"
+  resolved "https://registry.yarnpkg.com/@graphql-codegen/add/-/add-3.2.3.tgz#f1ecee085987e7c21841edc4b1fd48877c663e1a"
+  integrity sha512-sQOnWpMko4JLeykwyjFTxnhqjd/3NOG2OyMuvK76Wnnwh8DRrNf2VEs2kmSvLl7MndMlOj7Kh5U154dVcvhmKQ==
+  dependencies:
+    "@graphql-codegen/plugin-helpers" "^3.1.1"
+    tslib "~2.4.0"
+
 "@graphql-codegen/cli@^3.0.0":
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/@graphql-codegen/cli/-/cli-3.0.0.tgz#eb367adfe51349e4822518183fc7ea7c06aea11b"
@@ -1260,6 +1268,18 @@
     "@graphql-codegen/visitor-plugin-common" "^3.0.0"
     tslib "~2.4.0"
 
+"@graphql-codegen/near-operation-file-preset@^2.5.0":
+  version "2.5.0"
+  resolved "https://registry.yarnpkg.com/@graphql-codegen/near-operation-file-preset/-/near-operation-file-preset-2.5.0.tgz#987d9bb8d0101e944b9afc406b77d098a4c1e978"
+  integrity sha512-S9PNJP5tTkUWBQ6inbviOsTREzsMxYVqJGrtPcIdMWkKLZAAItAfAb60klB1T64vt6Oru+nUf8IYUNrchJ8MYg==
+  dependencies:
+    "@graphql-codegen/add" "^3.2.1"
+    "@graphql-codegen/plugin-helpers" "^2.7.2"
+    "@graphql-codegen/visitor-plugin-common" "2.13.1"
+    "@graphql-tools/utils" "^8.8.0"
+    parse-filepath "^1.0.2"
+    tslib "~2.4.0"
+
 "@graphql-codegen/plugin-helpers@^2.7.2":
   version "2.7.2"
   resolved "https://registry.yarnpkg.com/@graphql-codegen/plugin-helpers/-/plugin-helpers-2.7.2.tgz#6544f739d725441c826a8af6a49519f588ff9bed"
@@ -1272,6 +1292,18 @@
     lodash "~4.17.0"
     tslib "~2.4.0"
 
+"@graphql-codegen/plugin-helpers@^3.1.1":
+  version "3.1.2"
+  resolved "https://registry.yarnpkg.com/@graphql-codegen/plugin-helpers/-/plugin-helpers-3.1.2.tgz#69a2e91178f478ea6849846ade0a59a844d34389"
+  integrity sha512-emOQiHyIliVOIjKVKdsI5MXj312zmRDwmHpyUTZMjfpvxq/UVAHUJIVdVf+lnjjrI+LXBTgMlTWTgHQfmICxjg==
+  dependencies:
+    "@graphql-tools/utils" "^9.0.0"
+    change-case-all "1.0.15"
+    common-tags "1.8.2"
+    import-from "4.0.0"
+    lodash "~4.17.0"
+    tslib "~2.4.0"
+
 "@graphql-codegen/plugin-helpers@^4.0.0":
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/@graphql-codegen/plugin-helpers/-/plugin-helpers-4.0.0.tgz#9c10e4700dc6efe657781dff47347d0c99674061"