import * as Apollo from '@apollo/client';
export declare type Maybe<T> = T | null;
export declare type InputMaybe<T> = Maybe<T>;
export declare type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
/** All built-in and custom scalars, mapped to their actual values */
export declare type Scalars = {
    ID: string;
    String: string;
    Boolean: boolean;
    Int: number;
    Float: number;
};
export declare type App = {
    __typename?: 'App';
    logo?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    privacyPolicyUrl?: Maybe<Scalars['String']>;
    termsOfServiceUrl?: Maybe<Scalars['String']>;
    uiUrl?: Maybe<Scalars['String']>;
    websiteUrl?: Maybe<Scalars['String']>;
};
export declare type CreateTenantInput = {
    email: Scalars['String'];
    logo?: InputMaybe<Scalars['String']>;
    name?: InputMaybe<Scalars['String']>;
    plan: Scalars['String'];
};
export declare type Mutation = {
    __typename?: 'Mutation';
    createTenantAnonymous: Tenant;
    /** This will create a new user for a tenant. */
    createUsers: Array<User>;
    deleteUser: Scalars['Boolean'];
    sendPasswordResetLink: Scalars['Boolean'];
    updateTenant: Tenant;
    /** Update the user. You can change role, teams and also enable or disable the user from logging in. */
    updateUser: User;
};
export declare type MutationCreateTenantAnonymousArgs = {
    tenant: CreateTenantInput;
};
export declare type MutationCreateUsersArgs = {
    userNames: Array<Scalars['String']>;
};
export declare type MutationDeleteUserArgs = {
    userId: Scalars['String'];
};
export declare type MutationSendPasswordResetLinkArgs = {
    userId: Scalars['String'];
};
export declare type MutationUpdateTenantArgs = {
    tenant: TenantInput;
};
export declare type MutationUpdateUserArgs = {
    user: UserInput;
};
export declare type Query = {
    __typename?: 'Query';
    /** Gets useful App configs for the UI to consume */
    getAppAnonymous: App;
    /** Obtain an short lived session url to redirect or present the user its Stripe subscription panel for updating payment or subscription data. */
    getCustomerPortal: Scalars['String'];
    /** Gets a single tenant */
    getTenant: Tenant;
    getTenantAnonymous: TenantAnonymous;
    /** Lists all tenants */
    listTenants: Array<Tenant>;
    /** List all available user roles that the current user can assign others */
    listUserRoles: Array<Scalars['String']>;
    /** List all users in this tenant. */
    listUsers: Array<User>;
};
export declare type Tenant = {
    __typename?: 'Tenant';
    createdAt?: Maybe<Scalars['String']>;
    id: Scalars['String'];
    locale?: Maybe<Scalars['String']>;
    logo: Scalars['String'];
    mfa?: Maybe<Scalars['Boolean']>;
    name: Scalars['String'];
    plan?: Maybe<Scalars['String']>;
};
export declare type TenantAnonymous = {
    __typename?: 'TenantAnonymous';
    id: Scalars['String'];
    locale?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
};
export declare type TenantInput = {
    locale?: InputMaybe<Scalars['String']>;
    mfa?: InputMaybe<Scalars['Boolean']>;
    name?: InputMaybe<Scalars['String']>;
};
export declare type User = {
    __typename?: 'User';
    createdAt?: Maybe<Scalars['String']>;
    email?: Maybe<Scalars['String']>;
    enabled?: Maybe<Scalars['Boolean']>;
    fullName?: Maybe<Scalars['String']>;
    id: Scalars['String'];
    onboarded?: Maybe<Scalars['Boolean']>;
    role?: Maybe<Scalars['String']>;
    teams?: Maybe<Array<Scalars['String']>>;
    username?: Maybe<Scalars['String']>;
};
export declare type UserInput = {
    enabled?: InputMaybe<Scalars['Boolean']>;
    id: Scalars['String'];
    role?: InputMaybe<Scalars['String']>;
};
export declare type GetCustomerPortalQueryVariables = Exact<{
    [key: string]: never;
}>;
export declare type GetCustomerPortalQuery = {
    __typename?: 'Query';
    getCustomerPortal: string;
};
export declare type GetTenantQueryVariables = Exact<{
    [key: string]: never;
}>;
export declare type GetTenantQuery = {
    __typename?: 'Query';
    getTenant: {
        __typename?: 'Tenant';
        id: string;
        name: string;
        locale?: string | null;
        logo: string;
        plan?: string | null;
        mfa?: boolean | null;
        createdAt?: string | null;
    };
};
export declare type UpdateTenantMutationVariables = Exact<{
    tenant: TenantInput;
}>;
export declare type UpdateTenantMutation = {
    __typename?: 'Mutation';
    updateTenant: {
        __typename?: 'Tenant';
        id: string;
        name: string;
        locale?: string | null;
        logo: string;
        plan?: string | null;
        mfa?: boolean | null;
        createdAt?: string | null;
    };
};
export declare type CreateUsersMutationVariables = Exact<{
    userNames: Array<Scalars['String']> | Scalars['String'];
}>;
export declare type CreateUsersMutation = {
    __typename?: 'Mutation';
    createUsers: Array<{
        __typename?: 'User';
        id: string;
        fullName?: string | null;
        email?: string | null;
        username?: string | null;
        createdAt?: string | null;
        onboarded?: boolean | null;
        enabled?: boolean | null;
        role?: string | null;
        teams?: Array<string> | null;
    }>;
};
export declare type DeleteUserMutationVariables = Exact<{
    userId: Scalars['String'];
}>;
export declare type DeleteUserMutation = {
    __typename?: 'Mutation';
    deleteUser: boolean;
};
export declare type ListUserRolesQueryVariables = Exact<{
    [key: string]: never;
}>;
export declare type ListUserRolesQuery = {
    __typename?: 'Query';
    listUserRoles: Array<string>;
};
export declare type ListUsersQueryVariables = Exact<{
    [key: string]: never;
}>;
export declare type ListUsersQuery = {
    __typename?: 'Query';
    listUsers: Array<{
        __typename?: 'User';
        id: string;
        fullName?: string | null;
        email?: string | null;
        username?: string | null;
        createdAt?: string | null;
        onboarded?: boolean | null;
        enabled?: boolean | null;
        role?: string | null;
        teams?: Array<string> | null;
    }>;
};
export declare type SendPasswordResetLinkMutationVariables = Exact<{
    userId: Scalars['String'];
}>;
export declare type SendPasswordResetLinkMutation = {
    __typename?: 'Mutation';
    sendPasswordResetLink: boolean;
};
export declare type UpdateUserMutationVariables = Exact<{
    user: UserInput;
}>;
export declare type UpdateUserMutation = {
    __typename?: 'Mutation';
    updateUser: {
        __typename?: 'User';
        id: string;
        fullName?: string | null;
        email?: string | null;
        username?: string | null;
        createdAt?: string | null;
        onboarded?: boolean | null;
        enabled?: boolean | null;
        role?: string | null;
        teams?: Array<string> | null;
    };
};
export declare type GetAppAnonymousQueryVariables = Exact<{
    [key: string]: never;
}>;
export declare type GetAppAnonymousQuery = {
    __typename?: 'Query';
    getAppAnonymous: {
        __typename?: 'App';
        name?: string | null;
        logo?: string | null;
        privacyPolicyUrl?: string | null;
        termsOfServiceUrl?: string | null;
    };
};
export declare const GetCustomerPortalDocument: Apollo.DocumentNode;
/**
 * __useGetCustomerPortalQuery__
 *
 * To run a query within a React component, call `useGetCustomerPortalQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetCustomerPortalQuery` 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 } = useGetCustomerPortalQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useGetCustomerPortalQuery(baseOptions?: Apollo.QueryHookOptions<GetCustomerPortalQuery, GetCustomerPortalQueryVariables>): Apollo.QueryResult<GetCustomerPortalQuery, Exact<{
    [key: string]: never;
}>>;
export declare function useGetCustomerPortalLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetCustomerPortalQuery, GetCustomerPortalQueryVariables>): Apollo.LazyQueryResultTuple<GetCustomerPortalQuery, Exact<{
    [key: string]: never;
}>>;
export declare type GetCustomerPortalQueryHookResult = ReturnType<typeof useGetCustomerPortalQuery>;
export declare type GetCustomerPortalLazyQueryHookResult = ReturnType<typeof useGetCustomerPortalLazyQuery>;
export declare type GetCustomerPortalQueryResult = Apollo.QueryResult<GetCustomerPortalQuery, GetCustomerPortalQueryVariables>;
export declare const GetTenantDocument: Apollo.DocumentNode;
/**
 * __useGetTenantQuery__
 *
 * To run a query within a React component, call `useGetTenantQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetTenantQuery` 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 } = useGetTenantQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useGetTenantQuery(baseOptions?: Apollo.QueryHookOptions<GetTenantQuery, GetTenantQueryVariables>): Apollo.QueryResult<GetTenantQuery, Exact<{
    [key: string]: never;
}>>;
export declare function useGetTenantLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetTenantQuery, GetTenantQueryVariables>): Apollo.LazyQueryResultTuple<GetTenantQuery, Exact<{
    [key: string]: never;
}>>;
export declare type GetTenantQueryHookResult = ReturnType<typeof useGetTenantQuery>;
export declare type GetTenantLazyQueryHookResult = ReturnType<typeof useGetTenantLazyQuery>;
export declare type GetTenantQueryResult = Apollo.QueryResult<GetTenantQuery, GetTenantQueryVariables>;
export declare const UpdateTenantDocument: Apollo.DocumentNode;
export declare type UpdateTenantMutationFn = Apollo.MutationFunction<UpdateTenantMutation, UpdateTenantMutationVariables>;
/**
 * __useUpdateTenantMutation__
 *
 * To run a mutation, you first call `useUpdateTenantMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateTenantMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateTenantMutation, { data, loading, error }] = useUpdateTenantMutation({
 *   variables: {
 *      tenant: // value for 'tenant'
 *   },
 * });
 */
export declare function useUpdateTenantMutation(baseOptions?: Apollo.MutationHookOptions<UpdateTenantMutation, UpdateTenantMutationVariables>): Apollo.MutationTuple<UpdateTenantMutation, Exact<{
    tenant: TenantInput;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type UpdateTenantMutationHookResult = ReturnType<typeof useUpdateTenantMutation>;
export declare type UpdateTenantMutationResult = Apollo.MutationResult<UpdateTenantMutation>;
export declare type UpdateTenantMutationOptions = Apollo.BaseMutationOptions<UpdateTenantMutation, UpdateTenantMutationVariables>;
export declare const CreateUsersDocument: Apollo.DocumentNode;
export declare type CreateUsersMutationFn = Apollo.MutationFunction<CreateUsersMutation, CreateUsersMutationVariables>;
/**
 * __useCreateUsersMutation__
 *
 * To run a mutation, you first call `useCreateUsersMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateUsersMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [createUsersMutation, { data, loading, error }] = useCreateUsersMutation({
 *   variables: {
 *      userNames: // value for 'userNames'
 *   },
 * });
 */
export declare function useCreateUsersMutation(baseOptions?: Apollo.MutationHookOptions<CreateUsersMutation, CreateUsersMutationVariables>): Apollo.MutationTuple<CreateUsersMutation, Exact<{
    userNames: string | string[];
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type CreateUsersMutationHookResult = ReturnType<typeof useCreateUsersMutation>;
export declare type CreateUsersMutationResult = Apollo.MutationResult<CreateUsersMutation>;
export declare type CreateUsersMutationOptions = Apollo.BaseMutationOptions<CreateUsersMutation, CreateUsersMutationVariables>;
export declare const DeleteUserDocument: Apollo.DocumentNode;
export declare type DeleteUserMutationFn = Apollo.MutationFunction<DeleteUserMutation, DeleteUserMutationVariables>;
/**
 * __useDeleteUserMutation__
 *
 * To run a mutation, you first call `useDeleteUserMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteUserMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [deleteUserMutation, { data, loading, error }] = useDeleteUserMutation({
 *   variables: {
 *      userId: // value for 'userId'
 *   },
 * });
 */
export declare function useDeleteUserMutation(baseOptions?: Apollo.MutationHookOptions<DeleteUserMutation, DeleteUserMutationVariables>): Apollo.MutationTuple<DeleteUserMutation, Exact<{
    userId: string;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type DeleteUserMutationHookResult = ReturnType<typeof useDeleteUserMutation>;
export declare type DeleteUserMutationResult = Apollo.MutationResult<DeleteUserMutation>;
export declare type DeleteUserMutationOptions = Apollo.BaseMutationOptions<DeleteUserMutation, DeleteUserMutationVariables>;
export declare const ListUserRolesDocument: Apollo.DocumentNode;
/**
 * __useListUserRolesQuery__
 *
 * To run a query within a React component, call `useListUserRolesQuery` and pass it any options that fit your needs.
 * When your component renders, `useListUserRolesQuery` 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 } = useListUserRolesQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useListUserRolesQuery(baseOptions?: Apollo.QueryHookOptions<ListUserRolesQuery, ListUserRolesQueryVariables>): Apollo.QueryResult<ListUserRolesQuery, Exact<{
    [key: string]: never;
}>>;
export declare function useListUserRolesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ListUserRolesQuery, ListUserRolesQueryVariables>): Apollo.LazyQueryResultTuple<ListUserRolesQuery, Exact<{
    [key: string]: never;
}>>;
export declare type ListUserRolesQueryHookResult = ReturnType<typeof useListUserRolesQuery>;
export declare type ListUserRolesLazyQueryHookResult = ReturnType<typeof useListUserRolesLazyQuery>;
export declare type ListUserRolesQueryResult = Apollo.QueryResult<ListUserRolesQuery, ListUserRolesQueryVariables>;
export declare const ListUsersDocument: Apollo.DocumentNode;
/**
 * __useListUsersQuery__
 *
 * To run a query within a React component, call `useListUsersQuery` and pass it any options that fit your needs.
 * When your component renders, `useListUsersQuery` 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 } = useListUsersQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useListUsersQuery(baseOptions?: Apollo.QueryHookOptions<ListUsersQuery, ListUsersQueryVariables>): Apollo.QueryResult<ListUsersQuery, Exact<{
    [key: string]: never;
}>>;
export declare function useListUsersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ListUsersQuery, ListUsersQueryVariables>): Apollo.LazyQueryResultTuple<ListUsersQuery, Exact<{
    [key: string]: never;
}>>;
export declare type ListUsersQueryHookResult = ReturnType<typeof useListUsersQuery>;
export declare type ListUsersLazyQueryHookResult = ReturnType<typeof useListUsersLazyQuery>;
export declare type ListUsersQueryResult = Apollo.QueryResult<ListUsersQuery, ListUsersQueryVariables>;
export declare const SendPasswordResetLinkDocument: Apollo.DocumentNode;
export declare type SendPasswordResetLinkMutationFn = Apollo.MutationFunction<SendPasswordResetLinkMutation, SendPasswordResetLinkMutationVariables>;
/**
 * __useSendPasswordResetLinkMutation__
 *
 * To run a mutation, you first call `useSendPasswordResetLinkMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSendPasswordResetLinkMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [sendPasswordResetLinkMutation, { data, loading, error }] = useSendPasswordResetLinkMutation({
 *   variables: {
 *      userId: // value for 'userId'
 *   },
 * });
 */
export declare function useSendPasswordResetLinkMutation(baseOptions?: Apollo.MutationHookOptions<SendPasswordResetLinkMutation, SendPasswordResetLinkMutationVariables>): Apollo.MutationTuple<SendPasswordResetLinkMutation, Exact<{
    userId: string;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type SendPasswordResetLinkMutationHookResult = ReturnType<typeof useSendPasswordResetLinkMutation>;
export declare type SendPasswordResetLinkMutationResult = Apollo.MutationResult<SendPasswordResetLinkMutation>;
export declare type SendPasswordResetLinkMutationOptions = Apollo.BaseMutationOptions<SendPasswordResetLinkMutation, SendPasswordResetLinkMutationVariables>;
export declare const UpdateUserDocument: Apollo.DocumentNode;
export declare type UpdateUserMutationFn = Apollo.MutationFunction<UpdateUserMutation, UpdateUserMutationVariables>;
/**
 * __useUpdateUserMutation__
 *
 * To run a mutation, you first call `useUpdateUserMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateUserMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateUserMutation, { data, loading, error }] = useUpdateUserMutation({
 *   variables: {
 *      user: // value for 'user'
 *   },
 * });
 */
export declare function useUpdateUserMutation(baseOptions?: Apollo.MutationHookOptions<UpdateUserMutation, UpdateUserMutationVariables>): Apollo.MutationTuple<UpdateUserMutation, Exact<{
    user: UserInput;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type UpdateUserMutationHookResult = ReturnType<typeof useUpdateUserMutation>;
export declare type UpdateUserMutationResult = Apollo.MutationResult<UpdateUserMutation>;
export declare type UpdateUserMutationOptions = Apollo.BaseMutationOptions<UpdateUserMutation, UpdateUserMutationVariables>;
export declare const GetAppAnonymousDocument: Apollo.DocumentNode;
/**
 * __useGetAppAnonymousQuery__
 *
 * To run a query within a React component, call `useGetAppAnonymousQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetAppAnonymousQuery` 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 } = useGetAppAnonymousQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useGetAppAnonymousQuery(baseOptions?: Apollo.QueryHookOptions<GetAppAnonymousQuery, GetAppAnonymousQueryVariables>): Apollo.QueryResult<GetAppAnonymousQuery, Exact<{
    [key: string]: never;
}>>;
export declare function useGetAppAnonymousLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetAppAnonymousQuery, GetAppAnonymousQueryVariables>): Apollo.LazyQueryResultTuple<GetAppAnonymousQuery, Exact<{
    [key: string]: never;
}>>;
export declare type GetAppAnonymousQueryHookResult = ReturnType<typeof useGetAppAnonymousQuery>;
export declare type GetAppAnonymousLazyQueryHookResult = ReturnType<typeof useGetAppAnonymousLazyQuery>;
export declare type GetAppAnonymousQueryResult = Apollo.QueryResult<GetAppAnonymousQuery, GetAppAnonymousQueryVariables>;