@auth/hasura-adapter/lib/generated/graphql.d.ts

Hasura adapter for Auth.js.

import type { DocumentTypeDecoration } from '@graphql-typed-document-node/core';
export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
export type MakeEmpty<T extends {
    [key: string]: unknown;
}, K extends keyof T> = {
    [_ in K]?: never;
};
export type Incremental<T> = T | {
    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
};
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
    ID: {
        input: string;
        output: string;
    };
    String: {
        input: string;
        output: string;
    };
    Boolean: {
        input: boolean;
        output: boolean;
    };
    Int: {
        input: number;
        output: number;
    };
    Float: {
        input: number;
        output: number;
    };
    timestamptz: {
        input: string;
        output: string;
    };
    uuid: {
        input: string;
        output: string;
    };
};
/** Boolean expression to compare columns of type "Int". All fields are combined with logical 'AND'. */
export type Int_Comparison_Exp = {
    _eq?: InputMaybe<Scalars['Int']['input']>;
    _gt?: InputMaybe<Scalars['Int']['input']>;
    _gte?: InputMaybe<Scalars['Int']['input']>;
    _in?: InputMaybe<Array<Scalars['Int']['input']>>;
    _is_null?: InputMaybe<Scalars['Boolean']['input']>;
    _lt?: InputMaybe<Scalars['Int']['input']>;
    _lte?: InputMaybe<Scalars['Int']['input']>;
    _neq?: InputMaybe<Scalars['Int']['input']>;
    _nin?: InputMaybe<Array<Scalars['Int']['input']>>;
};
/** Boolean expression to compare columns of type "String". All fields are combined with logical 'AND'. */
export type String_Comparison_Exp = {
    _eq?: InputMaybe<Scalars['String']['input']>;
    _gt?: InputMaybe<Scalars['String']['input']>;
    _gte?: InputMaybe<Scalars['String']['input']>;
    /** does the column match the given case-insensitive pattern */
    _ilike?: InputMaybe<Scalars['String']['input']>;
    _in?: InputMaybe<Array<Scalars['String']['input']>>;
    /** does the column match the given POSIX regular expression, case insensitive */
    _iregex?: InputMaybe<Scalars['String']['input']>;
    _is_null?: InputMaybe<Scalars['Boolean']['input']>;
    /** does the column match the given pattern */
    _like?: InputMaybe<Scalars['String']['input']>;
    _lt?: InputMaybe<Scalars['String']['input']>;
    _lte?: InputMaybe<Scalars['String']['input']>;
    _neq?: InputMaybe<Scalars['String']['input']>;
    /** does the column NOT match the given case-insensitive pattern */
    _nilike?: InputMaybe<Scalars['String']['input']>;
    _nin?: InputMaybe<Array<Scalars['String']['input']>>;
    /** does the column NOT match the given POSIX regular expression, case insensitive */
    _niregex?: InputMaybe<Scalars['String']['input']>;
    /** does the column NOT match the given pattern */
    _nlike?: InputMaybe<Scalars['String']['input']>;
    /** does the column NOT match the given POSIX regular expression, case sensitive */
    _nregex?: InputMaybe<Scalars['String']['input']>;
    /** does the column NOT match the given SQL regular expression */
    _nsimilar?: InputMaybe<Scalars['String']['input']>;
    /** does the column match the given POSIX regular expression, case sensitive */
    _regex?: InputMaybe<Scalars['String']['input']>;
    /** does the column match the given SQL regular expression */
    _similar?: InputMaybe<Scalars['String']['input']>;
};
/** columns and relationships of "accounts" */
export type Accounts = {
    access_token?: Maybe<Scalars['String']['output']>;
    expires_at?: Maybe<Scalars['Int']['output']>;
    id: Scalars['uuid']['output'];
    id_token?: Maybe<Scalars['String']['output']>;
    provider: Scalars['String']['output'];
    providerAccountId: Scalars['String']['output'];
    refresh_token?: Maybe<Scalars['String']['output']>;
    scope?: Maybe<Scalars['String']['output']>;
    session_state?: Maybe<Scalars['String']['output']>;
    token_type?: Maybe<Scalars['String']['output']>;
    type: Provider_Type_Enum;
    /** An object relationship */
    user: Users;
    userId: Scalars['uuid']['output'];
};
/** aggregated selection of "accounts" */
export type Accounts_Aggregate = {
    aggregate?: Maybe<Accounts_Aggregate_Fields>;
    nodes: Array<Accounts>;
};
export type Accounts_Aggregate_Bool_Exp = {
    count?: InputMaybe<Accounts_Aggregate_Bool_Exp_Count>;
};
export type Accounts_Aggregate_Bool_Exp_Count = {
    arguments?: InputMaybe<Array<Accounts_Select_Column>>;
    distinct?: InputMaybe<Scalars['Boolean']['input']>;
    filter?: InputMaybe<Accounts_Bool_Exp>;
    predicate: Int_Comparison_Exp;
};
/** aggregate fields of "accounts" */
export type Accounts_Aggregate_Fields = {
    avg?: Maybe<Accounts_Avg_Fields>;
    count: Scalars['Int']['output'];
    max?: Maybe<Accounts_Max_Fields>;
    min?: Maybe<Accounts_Min_Fields>;
    stddev?: Maybe<Accounts_Stddev_Fields>;
    stddev_pop?: Maybe<Accounts_Stddev_Pop_Fields>;
    stddev_samp?: Maybe<Accounts_Stddev_Samp_Fields>;
    sum?: Maybe<Accounts_Sum_Fields>;
    var_pop?: Maybe<Accounts_Var_Pop_Fields>;
    var_samp?: Maybe<Accounts_Var_Samp_Fields>;
    variance?: Maybe<Accounts_Variance_Fields>;
};
/** aggregate fields of "accounts" */
export type Accounts_Aggregate_FieldsCountArgs = {
    columns?: InputMaybe<Array<Accounts_Select_Column>>;
    distinct?: InputMaybe<Scalars['Boolean']['input']>;
};
/** order by aggregate values of table "accounts" */
export type Accounts_Aggregate_Order_By = {
    avg?: InputMaybe<Accounts_Avg_Order_By>;
    count?: InputMaybe<Order_By>;
    max?: InputMaybe<Accounts_Max_Order_By>;
    min?: InputMaybe<Accounts_Min_Order_By>;
    stddev?: InputMaybe<Accounts_Stddev_Order_By>;
    stddev_pop?: InputMaybe<Accounts_Stddev_Pop_Order_By>;
    stddev_samp?: InputMaybe<Accounts_Stddev_Samp_Order_By>;
    sum?: InputMaybe<Accounts_Sum_Order_By>;
    var_pop?: InputMaybe<Accounts_Var_Pop_Order_By>;
    var_samp?: InputMaybe<Accounts_Var_Samp_Order_By>;
    variance?: InputMaybe<Accounts_Variance_Order_By>;
};
/** input type for inserting array relation for remote table "accounts" */
export type Accounts_Arr_Rel_Insert_Input = {
    data: Array<Accounts_Insert_Input>;
    /** upsert condition */
    on_conflict?: InputMaybe<Accounts_On_Conflict>;
};
/** aggregate avg on columns */
export type Accounts_Avg_Fields = {
    expires_at?: Maybe<Scalars['Float']['output']>;
};
/** order by avg() on columns of table "accounts" */
export type Accounts_Avg_Order_By = {
    expires_at?: InputMaybe<Order_By>;
};
/** Boolean expression to filter rows from the table "accounts". All fields are combined with a logical 'AND'. */
export type Accounts_Bool_Exp = {
    _and?: InputMaybe<Array<Accounts_Bool_Exp>>;
    _not?: InputMaybe<Accounts_Bool_Exp>;
    _or?: InputMaybe<Array<Accounts_Bool_Exp>>;
    access_token?: InputMaybe<String_Comparison_Exp>;
    expires_at?: InputMaybe<Int_Comparison_Exp>;
    id?: InputMaybe<Uuid_Comparison_Exp>;
    id_token?: InputMaybe<String_Comparison_Exp>;
    provider?: InputMaybe<String_Comparison_Exp>;
    providerAccountId?: InputMaybe<String_Comparison_Exp>;
    refresh_token?: InputMaybe<String_Comparison_Exp>;
    scope?: InputMaybe<String_Comparison_Exp>;
    session_state?: InputMaybe<String_Comparison_Exp>;
    token_type?: InputMaybe<String_Comparison_Exp>;
    type?: InputMaybe<Provider_Type_Enum_Comparison_Exp>;
    user?: InputMaybe<Users_Bool_Exp>;
    userId?: InputMaybe<Uuid_Comparison_Exp>;
};
/** unique or primary key constraints on table "accounts" */
export type Accounts_Constraint = 
/** unique or primary key constraint on columns "id" */
'accounts_pkey';
/** input type for incrementing numeric columns in table "accounts" */
export type Accounts_Inc_Input = {
    expires_at?: InputMaybe<Scalars['Int']['input']>;
};
/** input type for inserting data into table "accounts" */
export type Accounts_Insert_Input = {
    access_token?: InputMaybe<Scalars['String']['input']>;
    expires_at?: InputMaybe<Scalars['Int']['input']>;
    id?: InputMaybe<Scalars['uuid']['input']>;
    id_token?: InputMaybe<Scalars['String']['input']>;
    provider?: InputMaybe<Scalars['String']['input']>;
    providerAccountId?: InputMaybe<Scalars['String']['input']>;
    refresh_token?: InputMaybe<Scalars['String']['input']>;
    scope?: InputMaybe<Scalars['String']['input']>;
    session_state?: InputMaybe<Scalars['String']['input']>;
    token_type?: InputMaybe<Scalars['String']['input']>;
    type?: InputMaybe<Provider_Type_Enum>;
    user?: InputMaybe<Users_Obj_Rel_Insert_Input>;
    userId?: InputMaybe<Scalars['uuid']['input']>;
};
/** aggregate max on columns */
export type Accounts_Max_Fields = {
    access_token?: Maybe<Scalars['String']['output']>;
    expires_at?: Maybe<Scalars['Int']['output']>;
    id?: Maybe<Scalars['uuid']['output']>;
    id_token?: Maybe<Scalars['String']['output']>;
    provider?: Maybe<Scalars['String']['output']>;
    providerAccountId?: Maybe<Scalars['String']['output']>;
    refresh_token?: Maybe<Scalars['String']['output']>;
    scope?: Maybe<Scalars['String']['output']>;
    session_state?: Maybe<Scalars['String']['output']>;
    token_type?: Maybe<Scalars['String']['output']>;
    userId?: Maybe<Scalars['uuid']['output']>;
};
/** order by max() on columns of table "accounts" */
export type Accounts_Max_Order_By = {
    access_token?: InputMaybe<Order_By>;
    expires_at?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    id_token?: InputMaybe<Order_By>;
    provider?: InputMaybe<Order_By>;
    providerAccountId?: InputMaybe<Order_By>;
    refresh_token?: InputMaybe<Order_By>;
    scope?: InputMaybe<Order_By>;
    session_state?: InputMaybe<Order_By>;
    token_type?: InputMaybe<Order_By>;
    userId?: InputMaybe<Order_By>;
};
/** aggregate min on columns */
export type Accounts_Min_Fields = {
    access_token?: Maybe<Scalars['String']['output']>;
    expires_at?: Maybe<Scalars['Int']['output']>;
    id?: Maybe<Scalars['uuid']['output']>;
    id_token?: Maybe<Scalars['String']['output']>;
    provider?: Maybe<Scalars['String']['output']>;
    providerAccountId?: Maybe<Scalars['String']['output']>;
    refresh_token?: Maybe<Scalars['String']['output']>;
    scope?: Maybe<Scalars['String']['output']>;
    session_state?: Maybe<Scalars['String']['output']>;
    token_type?: Maybe<Scalars['String']['output']>;
    userId?: Maybe<Scalars['uuid']['output']>;
};
/** order by min() on columns of table "accounts" */
export type Accounts_Min_Order_By = {
    access_token?: InputMaybe<Order_By>;
    expires_at?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    id_token?: InputMaybe<Order_By>;
    provider?: InputMaybe<Order_By>;
    providerAccountId?: InputMaybe<Order_By>;
    refresh_token?: InputMaybe<Order_By>;
    scope?: InputMaybe<Order_By>;
    session_state?: InputMaybe<Order_By>;
    token_type?: InputMaybe<Order_By>;
    userId?: InputMaybe<Order_By>;
};
/** response of any mutation on the table "accounts" */
export type Accounts_Mutation_Response = {
    /** number of rows affected by the mutation */
    affected_rows: Scalars['Int']['output'];
    /** data from the rows affected by the mutation */
    returning: Array<Accounts>;
};
/** on_conflict condition type for table "accounts" */
export type Accounts_On_Conflict = {
    constraint: Accounts_Constraint;
    update_columns?: Array<Accounts_Update_Column>;
    where?: InputMaybe<Accounts_Bool_Exp>;
};
/** Ordering options when selecting data from "accounts". */
export type Accounts_Order_By = {
    access_token?: InputMaybe<Order_By>;
    expires_at?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    id_token?: InputMaybe<Order_By>;
    provider?: InputMaybe<Order_By>;
    providerAccountId?: InputMaybe<Order_By>;
    refresh_token?: InputMaybe<Order_By>;
    scope?: InputMaybe<Order_By>;
    session_state?: InputMaybe<Order_By>;
    token_type?: InputMaybe<Order_By>;
    type?: InputMaybe<Order_By>;
    user?: InputMaybe<Users_Order_By>;
    userId?: InputMaybe<Order_By>;
};
/** primary key columns input for table: accounts */
export type Accounts_Pk_Columns_Input = {
    id: Scalars['uuid']['input'];
};
/** select columns of table "accounts" */
export type Accounts_Select_Column = 
/** column name */
'access_token'
/** column name */
 | 'expires_at'
/** column name */
 | 'id'
/** column name */
 | 'id_token'
/** column name */
 | 'provider'
/** column name */
 | 'providerAccountId'
/** column name */
 | 'refresh_token'
/** column name */
 | 'scope'
/** column name */
 | 'session_state'
/** column name */
 | 'token_type'
/** column name */
 | 'type'
/** column name */
 | 'userId';
/** input type for updating data in table "accounts" */
export type Accounts_Set_Input = {
    access_token?: InputMaybe<Scalars['String']['input']>;
    expires_at?: InputMaybe<Scalars['Int']['input']>;
    id?: InputMaybe<Scalars['uuid']['input']>;
    id_token?: InputMaybe<Scalars['String']['input']>;
    provider?: InputMaybe<Scalars['String']['input']>;
    providerAccountId?: InputMaybe<Scalars['String']['input']>;
    refresh_token?: InputMaybe<Scalars['String']['input']>;
    scope?: InputMaybe<Scalars['String']['input']>;
    session_state?: InputMaybe<Scalars['String']['input']>;
    token_type?: InputMaybe<Scalars['String']['input']>;
    type?: InputMaybe<Provider_Type_Enum>;
    userId?: InputMaybe<Scalars['uuid']['input']>;
};
/** aggregate stddev on columns */
export type Accounts_Stddev_Fields = {
    expires_at?: Maybe<Scalars['Float']['output']>;
};
/** order by stddev() on columns of table "accounts" */
export type Accounts_Stddev_Order_By = {
    expires_at?: InputMaybe<Order_By>;
};
/** aggregate stddev_pop on columns */
export type Accounts_Stddev_Pop_Fields = {
    expires_at?: Maybe<Scalars['Float']['output']>;
};
/** order by stddev_pop() on columns of table "accounts" */
export type Accounts_Stddev_Pop_Order_By = {
    expires_at?: InputMaybe<Order_By>;
};
/** aggregate stddev_samp on columns */
export type Accounts_Stddev_Samp_Fields = {
    expires_at?: Maybe<Scalars['Float']['output']>;
};
/** order by stddev_samp() on columns of table "accounts" */
export type Accounts_Stddev_Samp_Order_By = {
    expires_at?: InputMaybe<Order_By>;
};
/** Streaming cursor of the table "accounts" */
export type Accounts_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: Accounts_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
export type Accounts_Stream_Cursor_Value_Input = {
    access_token?: InputMaybe<Scalars['String']['input']>;
    expires_at?: InputMaybe<Scalars['Int']['input']>;
    id?: InputMaybe<Scalars['uuid']['input']>;
    id_token?: InputMaybe<Scalars['String']['input']>;
    provider?: InputMaybe<Scalars['String']['input']>;
    providerAccountId?: InputMaybe<Scalars['String']['input']>;
    refresh_token?: InputMaybe<Scalars['String']['input']>;
    scope?: InputMaybe<Scalars['String']['input']>;
    session_state?: InputMaybe<Scalars['String']['input']>;
    token_type?: InputMaybe<Scalars['String']['input']>;
    type?: InputMaybe<Provider_Type_Enum>;
    userId?: InputMaybe<Scalars['uuid']['input']>;
};
/** aggregate sum on columns */
export type Accounts_Sum_Fields = {
    expires_at?: Maybe<Scalars['Int']['output']>;
};
/** order by sum() on columns of table "accounts" */
export type Accounts_Sum_Order_By = {
    expires_at?: InputMaybe<Order_By>;
};
/** update columns of table "accounts" */
export type Accounts_Update_Column = 
/** column name */
'access_token'
/** column name */
 | 'expires_at'
/** column name */
 | 'id'
/** column name */
 | 'id_token'
/** column name */
 | 'provider'
/** column name */
 | 'providerAccountId'
/** column name */
 | 'refresh_token'
/** column name */
 | 'scope'
/** column name */
 | 'session_state'
/** column name */
 | 'token_type'
/** column name */
 | 'type'
/** column name */
 | 'userId';
export type Accounts_Updates = {
    /** increments the numeric columns with given value of the filtered values */
    _inc?: InputMaybe<Accounts_Inc_Input>;
    /** sets the columns of the filtered rows to the given values */
    _set?: InputMaybe<Accounts_Set_Input>;
    /** filter the rows which have to be updated */
    where: Accounts_Bool_Exp;
};
/** aggregate var_pop on columns */
export type Accounts_Var_Pop_Fields = {
    expires_at?: Maybe<Scalars['Float']['output']>;
};
/** order by var_pop() on columns of table "accounts" */
export type Accounts_Var_Pop_Order_By = {
    expires_at?: InputMaybe<Order_By>;
};
/** aggregate var_samp on columns */
export type Accounts_Var_Samp_Fields = {
    expires_at?: Maybe<Scalars['Float']['output']>;
};
/** order by var_samp() on columns of table "accounts" */
export type Accounts_Var_Samp_Order_By = {
    expires_at?: InputMaybe<Order_By>;
};
/** aggregate variance on columns */
export type Accounts_Variance_Fields = {
    expires_at?: Maybe<Scalars['Float']['output']>;
};
/** order by variance() on columns of table "accounts" */
export type Accounts_Variance_Order_By = {
    expires_at?: InputMaybe<Order_By>;
};
/** ordering argument of a cursor */
export type Cursor_Ordering = 
/** ascending ordering of the cursor */
'ASC'
/** descending ordering of the cursor */
 | 'DESC';
/** mutation root */
export type Mutation_Root = {
    /** delete data from the table: "accounts" */
    delete_accounts?: Maybe<Accounts_Mutation_Response>;
    /** delete single row from the table: "accounts" */
    delete_accounts_by_pk?: Maybe<Accounts>;
    /** delete data from the table: "provider_type" */
    delete_provider_type?: Maybe<Provider_Type_Mutation_Response>;
    /** delete single row from the table: "provider_type" */
    delete_provider_type_by_pk?: Maybe<Provider_Type>;
    /** delete data from the table: "sessions" */
    delete_sessions?: Maybe<Sessions_Mutation_Response>;
    /** delete single row from the table: "sessions" */
    delete_sessions_by_pk?: Maybe<Sessions>;
    /** delete data from the table: "users" */
    delete_users?: Maybe<Users_Mutation_Response>;
    /** delete single row from the table: "users" */
    delete_users_by_pk?: Maybe<Users>;
    /** delete data from the table: "verification_tokens" */
    delete_verification_tokens?: Maybe<Verification_Tokens_Mutation_Response>;
    /** delete single row from the table: "verification_tokens" */
    delete_verification_tokens_by_pk?: Maybe<Verification_Tokens>;
    /** insert data into the table: "accounts" */
    insert_accounts?: Maybe<Accounts_Mutation_Response>;
    /** insert a single row into the table: "accounts" */
    insert_accounts_one?: Maybe<Accounts>;
    /** insert data into the table: "provider_type" */
    insert_provider_type?: Maybe<Provider_Type_Mutation_Response>;
    /** insert a single row into the table: "provider_type" */
    insert_provider_type_one?: Maybe<Provider_Type>;
    /** insert data into the table: "sessions" */
    insert_sessions?: Maybe<Sessions_Mutation_Response>;
    /** insert a single row into the table: "sessions" */
    insert_sessions_one?: Maybe<Sessions>;
    /** insert data into the table: "users" */
    insert_users?: Maybe<Users_Mutation_Response>;
    /** insert a single row into the table: "users" */
    insert_users_one?: Maybe<Users>;
    /** insert data into the table: "verification_tokens" */
    insert_verification_tokens?: Maybe<Verification_Tokens_Mutation_Response>;
    /** insert a single row into the table: "verification_tokens" */
    insert_verification_tokens_one?: Maybe<Verification_Tokens>;
    /** update data of the table: "accounts" */
    update_accounts?: Maybe<Accounts_Mutation_Response>;
    /** update single row of the table: "accounts" */
    update_accounts_by_pk?: Maybe<Accounts>;
    /** update multiples rows of table: "accounts" */
    update_accounts_many?: Maybe<Array<Maybe<Accounts_Mutation_Response>>>;
    /** update data of the table: "provider_type" */
    update_provider_type?: Maybe<Provider_Type_Mutation_Response>;
    /** update single row of the table: "provider_type" */
    update_provider_type_by_pk?: Maybe<Provider_Type>;
    /** update multiples rows of table: "provider_type" */
    update_provider_type_many?: Maybe<Array<Maybe<Provider_Type_Mutation_Response>>>;
    /** update data of the table: "sessions" */
    update_sessions?: Maybe<Sessions_Mutation_Response>;
    /** update single row of the table: "sessions" */
    update_sessions_by_pk?: Maybe<Sessions>;
    /** update multiples rows of table: "sessions" */
    update_sessions_many?: Maybe<Array<Maybe<Sessions_Mutation_Response>>>;
    /** update data of the table: "users" */
    update_users?: Maybe<Users_Mutation_Response>;
    /** update single row of the table: "users" */
    update_users_by_pk?: Maybe<Users>;
    /** update multiples rows of table: "users" */
    update_users_many?: Maybe<Array<Maybe<Users_Mutation_Response>>>;
    /** update data of the table: "verification_tokens" */
    update_verification_tokens?: Maybe<Verification_Tokens_Mutation_Response>;
    /** update single row of the table: "verification_tokens" */
    update_verification_tokens_by_pk?: Maybe<Verification_Tokens>;
    /** update multiples rows of table: "verification_tokens" */
    update_verification_tokens_many?: Maybe<Array<Maybe<Verification_Tokens_Mutation_Response>>>;
};
/** mutation root */
export type Mutation_RootDelete_AccountsArgs = {
    where: Accounts_Bool_Exp;
};
/** mutation root */
export type Mutation_RootDelete_Accounts_By_PkArgs = {
    id: Scalars['uuid']['input'];
};
/** mutation root */
export type Mutation_RootDelete_Provider_TypeArgs = {
    where: Provider_Type_Bool_Exp;
};
/** mutation root */
export type Mutation_RootDelete_Provider_Type_By_PkArgs = {
    value: Scalars['String']['input'];
};
/** mutation root */
export type Mutation_RootDelete_SessionsArgs = {
    where: Sessions_Bool_Exp;
};
/** mutation root */
export type Mutation_RootDelete_Sessions_By_PkArgs = {
    sessionToken: Scalars['String']['input'];
};
/** mutation root */
export type Mutation_RootDelete_UsersArgs = {
    where: Users_Bool_Exp;
};
/** mutation root */
export type Mutation_RootDelete_Users_By_PkArgs = {
    id: Scalars['uuid']['input'];
};
/** mutation root */
export type Mutation_RootDelete_Verification_TokensArgs = {
    where: Verification_Tokens_Bool_Exp;
};
/** mutation root */
export type Mutation_RootDelete_Verification_Tokens_By_PkArgs = {
    token: Scalars['String']['input'];
};
/** mutation root */
export type Mutation_RootInsert_AccountsArgs = {
    objects: Array<Accounts_Insert_Input>;
    on_conflict?: InputMaybe<Accounts_On_Conflict>;
};
/** mutation root */
export type Mutation_RootInsert_Accounts_OneArgs = {
    object: Accounts_Insert_Input;
    on_conflict?: InputMaybe<Accounts_On_Conflict>;
};
/** mutation root */
export type Mutation_RootInsert_Provider_TypeArgs = {
    objects: Array<Provider_Type_Insert_Input>;
    on_conflict?: InputMaybe<Provider_Type_On_Conflict>;
};
/** mutation root */
export type Mutation_RootInsert_Provider_Type_OneArgs = {
    object: Provider_Type_Insert_Input;
    on_conflict?: InputMaybe<Provider_Type_On_Conflict>;
};
/** mutation root */
export type Mutation_RootInsert_SessionsArgs = {
    objects: Array<Sessions_Insert_Input>;
    on_conflict?: InputMaybe<Sessions_On_Conflict>;
};
/** mutation root */
export type Mutation_RootInsert_Sessions_OneArgs = {
    object: Sessions_Insert_Input;
    on_conflict?: InputMaybe<Sessions_On_Conflict>;
};
/** mutation root */
export type Mutation_RootInsert_UsersArgs = {
    objects: Array<Users_Insert_Input>;
    on_conflict?: InputMaybe<Users_On_Conflict>;
};
/** mutation root */
export type Mutation_RootInsert_Users_OneArgs = {
    object: Users_Insert_Input;
    on_conflict?: InputMaybe<Users_On_Conflict>;
};
/** mutation root */
export type Mutation_RootInsert_Verification_TokensArgs = {
    objects: Array<Verification_Tokens_Insert_Input>;
    on_conflict?: InputMaybe<Verification_Tokens_On_Conflict>;
};
/** mutation root */
export type Mutation_RootInsert_Verification_Tokens_OneArgs = {
    object: Verification_Tokens_Insert_Input;
    on_conflict?: InputMaybe<Verification_Tokens_On_Conflict>;
};
/** mutation root */
export type Mutation_RootUpdate_AccountsArgs = {
    _inc?: InputMaybe<Accounts_Inc_Input>;
    _set?: InputMaybe<Accounts_Set_Input>;
    where: Accounts_Bool_Exp;
};
/** mutation root */
export type Mutation_RootUpdate_Accounts_By_PkArgs = {
    _inc?: InputMaybe<Accounts_Inc_Input>;
    _set?: InputMaybe<Accounts_Set_Input>;
    pk_columns: Accounts_Pk_Columns_Input;
};
/** mutation root */
export type Mutation_RootUpdate_Accounts_ManyArgs = {
    updates: Array<Accounts_Updates>;
};
/** mutation root */
export type Mutation_RootUpdate_Provider_TypeArgs = {
    _set?: InputMaybe<Provider_Type_Set_Input>;
    where: Provider_Type_Bool_Exp;
};
/** mutation root */
export type Mutation_RootUpdate_Provider_Type_By_PkArgs = {
    _set?: InputMaybe<Provider_Type_Set_Input>;
    pk_columns: Provider_Type_Pk_Columns_Input;
};
/** mutation root */
export type Mutation_RootUpdate_Provider_Type_ManyArgs = {
    updates: Array<Provider_Type_Updates>;
};
/** mutation root */
export type Mutation_RootUpdate_SessionsArgs = {
    _set?: InputMaybe<Sessions_Set_Input>;
    where: Sessions_Bool_Exp;
};
/** mutation root */
export type Mutation_RootUpdate_Sessions_By_PkArgs = {
    _set?: InputMaybe<Sessions_Set_Input>;
    pk_columns: Sessions_Pk_Columns_Input;
};
/** mutation root */
export type Mutation_RootUpdate_Sessions_ManyArgs = {
    updates: Array<Sessions_Updates>;
};
/** mutation root */
export type Mutation_RootUpdate_UsersArgs = {
    _set?: InputMaybe<Users_Set_Input>;
    where: Users_Bool_Exp;
};
/** mutation root */
export type Mutation_RootUpdate_Users_By_PkArgs = {
    _set?: InputMaybe<Users_Set_Input>;
    pk_columns: Users_Pk_Columns_Input;
};
/** mutation root */
export type Mutation_RootUpdate_Users_ManyArgs = {
    updates: Array<Users_Updates>;
};
/** mutation root */
export type Mutation_RootUpdate_Verification_TokensArgs = {
    _set?: InputMaybe<Verification_Tokens_Set_Input>;
    where: Verification_Tokens_Bool_Exp;
};
/** mutation root */
export type Mutation_RootUpdate_Verification_Tokens_By_PkArgs = {
    _set?: InputMaybe<Verification_Tokens_Set_Input>;
    pk_columns: Verification_Tokens_Pk_Columns_Input;
};
/** mutation root */
export type Mutation_RootUpdate_Verification_Tokens_ManyArgs = {
    updates: Array<Verification_Tokens_Updates>;
};
/** column ordering options */
export type Order_By = 
/** in ascending order, nulls last */
'asc'
/** in ascending order, nulls first */
 | 'asc_nulls_first'
/** in ascending order, nulls last */
 | 'asc_nulls_last'
/** in descending order, nulls first */
 | 'desc'
/** in descending order, nulls first */
 | 'desc_nulls_first'
/** in descending order, nulls last */
 | 'desc_nulls_last';
/** columns and relationships of "provider_type" */
export type Provider_Type = {
    value: Scalars['String']['output'];
};
/** aggregated selection of "provider_type" */
export type Provider_Type_Aggregate = {
    aggregate?: Maybe<Provider_Type_Aggregate_Fields>;
    nodes: Array<Provider_Type>;
};
/** aggregate fields of "provider_type" */
export type Provider_Type_Aggregate_Fields = {
    count: Scalars['Int']['output'];
    max?: Maybe<Provider_Type_Max_Fields>;
    min?: Maybe<Provider_Type_Min_Fields>;
};
/** aggregate fields of "provider_type" */
export type Provider_Type_Aggregate_FieldsCountArgs = {
    columns?: InputMaybe<Array<Provider_Type_Select_Column>>;
    distinct?: InputMaybe<Scalars['Boolean']['input']>;
};
/** Boolean expression to filter rows from the table "provider_type". All fields are combined with a logical 'AND'. */
export type Provider_Type_Bool_Exp = {
    _and?: InputMaybe<Array<Provider_Type_Bool_Exp>>;
    _not?: InputMaybe<Provider_Type_Bool_Exp>;
    _or?: InputMaybe<Array<Provider_Type_Bool_Exp>>;
    value?: InputMaybe<String_Comparison_Exp>;
};
/** unique or primary key constraints on table "provider_type" */
export type Provider_Type_Constraint = 
/** unique or primary key constraint on columns "value" */
'provider_type_pkey';
export type Provider_Type_Enum = 'credentials' | 'email' | 'oauth' | 'oidc' | 'webauthn';
/** Boolean expression to compare columns of type "provider_type_enum". All fields are combined with logical 'AND'. */
export type Provider_Type_Enum_Comparison_Exp = {
    _eq?: InputMaybe<Provider_Type_Enum>;
    _in?: InputMaybe<Array<Provider_Type_Enum>>;
    _is_null?: InputMaybe<Scalars['Boolean']['input']>;
    _neq?: InputMaybe<Provider_Type_Enum>;
    _nin?: InputMaybe<Array<Provider_Type_Enum>>;
};
/** input type for inserting data into table "provider_type" */
export type Provider_Type_Insert_Input = {
    value?: InputMaybe<Scalars['String']['input']>;
};
/** aggregate max on columns */
export type Provider_Type_Max_Fields = {
    value?: Maybe<Scalars['String']['output']>;
};
/** aggregate min on columns */
export type Provider_Type_Min_Fields = {
    value?: Maybe<Scalars['String']['output']>;
};
/** response of any mutation on the table "provider_type" */
export type Provider_Type_Mutation_Response = {
    /** number of rows affected by the mutation */
    affected_rows: Scalars['Int']['output'];
    /** data from the rows affected by the mutation */
    returning: Array<Provider_Type>;
};
/** on_conflict condition type for table "provider_type" */
export type Provider_Type_On_Conflict = {
    constraint: Provider_Type_Constraint;
    update_columns?: Array<Provider_Type_Update_Column>;
    where?: InputMaybe<Provider_Type_Bool_Exp>;
};
/** Ordering options when selecting data from "provider_type". */
export type Provider_Type_Order_By = {
    value?: InputMaybe<Order_By>;
};
/** primary key columns input for table: provider_type */
export type Provider_Type_Pk_Columns_Input = {
    value: Scalars['String']['input'];
};
/** select columns of table "provider_type" */
export type Provider_Type_Select_Column = 
/** column name */
'value';
/** input type for updating data in table "provider_type" */
export type Provider_Type_Set_Input = {
    value?: InputMaybe<Scalars['String']['input']>;
};
/** Streaming cursor of the table "provider_type" */
export type Provider_Type_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: Provider_Type_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
export type Provider_Type_Stream_Cursor_Value_Input = {
    value?: InputMaybe<Scalars['String']['input']>;
};
/** update columns of table "provider_type" */
export type Provider_Type_Update_Column = 
/** column name */
'value';
export type Provider_Type_Updates = {
    /** sets the columns of the filtered rows to the given values */
    _set?: InputMaybe<Provider_Type_Set_Input>;
    /** filter the rows which have to be updated */
    where: Provider_Type_Bool_Exp;
};
export type Query_Root = {
    /** An array relationship */
    accounts: Array<Accounts>;
    /** An aggregate relationship */
    accounts_aggregate: Accounts_Aggregate;
    /** fetch data from the table: "accounts" using primary key columns */
    accounts_by_pk?: Maybe<Accounts>;
    /** fetch data from the table: "provider_type" */
    provider_type: Array<Provider_Type>;
    /** fetch aggregated fields from the table: "provider_type" */
    provider_type_aggregate: Provider_Type_Aggregate;
    /** fetch data from the table: "provider_type" using primary key columns */
    provider_type_by_pk?: Maybe<Provider_Type>;
    /** An array relationship */
    sessions: Array<Sessions>;
    /** An aggregate relationship */
    sessions_aggregate: Sessions_Aggregate;
    /** fetch data from the table: "sessions" using primary key columns */
    sessions_by_pk?: Maybe<Sessions>;
    /** fetch data from the table: "users" */
    users: Array<Users>;
    /** fetch aggregated fields from the table: "users" */
    users_aggregate: Users_Aggregate;
    /** fetch data from the table: "users" using primary key columns */
    users_by_pk?: Maybe<Users>;
    /** fetch data from the table: "verification_tokens" */
    verification_tokens: Array<Verification_Tokens>;
    /** fetch aggregated fields from the table: "verification_tokens" */
    verification_tokens_aggregate: Verification_Tokens_Aggregate;
    /** fetch data from the table: "verification_tokens" using primary key columns */
    verification_tokens_by_pk?: Maybe<Verification_Tokens>;
};
export type Query_RootAccountsArgs = {
    distinct_on?: InputMaybe<Array<Accounts_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Accounts_Order_By>>;
    where?: InputMaybe<Accounts_Bool_Exp>;
};
export type Query_RootAccounts_AggregateArgs = {
    distinct_on?: InputMaybe<Array<Accounts_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Accounts_Order_By>>;
    where?: InputMaybe<Accounts_Bool_Exp>;
};
export type Query_RootAccounts_By_PkArgs = {
    id: Scalars['uuid']['input'];
};
export type Query_RootProvider_TypeArgs = {
    distinct_on?: InputMaybe<Array<Provider_Type_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Provider_Type_Order_By>>;
    where?: InputMaybe<Provider_Type_Bool_Exp>;
};
export type Query_RootProvider_Type_AggregateArgs = {
    distinct_on?: InputMaybe<Array<Provider_Type_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Provider_Type_Order_By>>;
    where?: InputMaybe<Provider_Type_Bool_Exp>;
};
export type Query_RootProvider_Type_By_PkArgs = {
    value: Scalars['String']['input'];
};
export type Query_RootSessionsArgs = {
    distinct_on?: InputMaybe<Array<Sessions_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Sessions_Order_By>>;
    where?: InputMaybe<Sessions_Bool_Exp>;
};
export type Query_RootSessions_AggregateArgs = {
    distinct_on?: InputMaybe<Array<Sessions_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Sessions_Order_By>>;
    where?: InputMaybe<Sessions_Bool_Exp>;
};
export type Query_RootSessions_By_PkArgs = {
    sessionToken: Scalars['String']['input'];
};
export type Query_RootUsersArgs = {
    distinct_on?: InputMaybe<Array<Users_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Users_Order_By>>;
    where?: InputMaybe<Users_Bool_Exp>;
};
export type Query_RootUsers_AggregateArgs = {
    distinct_on?: InputMaybe<Array<Users_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Users_Order_By>>;
    where?: InputMaybe<Users_Bool_Exp>;
};
export type Query_RootUsers_By_PkArgs = {
    id: Scalars['uuid']['input'];
};
export type Query_RootVerification_TokensArgs = {
    distinct_on?: InputMaybe<Array<Verification_Tokens_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Verification_Tokens_Order_By>>;
    where?: InputMaybe<Verification_Tokens_Bool_Exp>;
};
export type Query_RootVerification_Tokens_AggregateArgs = {
    distinct_on?: InputMaybe<Array<Verification_Tokens_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Verification_Tokens_Order_By>>;
    where?: InputMaybe<Verification_Tokens_Bool_Exp>;
};
export type Query_RootVerification_Tokens_By_PkArgs = {
    token: Scalars['String']['input'];
};
/** columns and relationships of "sessions" */
export type Sessions = {
    expires: Scalars['timestamptz']['output'];
    id: Scalars['uuid']['output'];
    sessionToken: Scalars['String']['output'];
    /** An object relationship */
    user: Users;
    userId: Scalars['uuid']['output'];
};
/** aggregated selection of "sessions" */
export type Sessions_Aggregate = {
    aggregate?: Maybe<Sessions_Aggregate_Fields>;
    nodes: Array<Sessions>;
};
export type Sessions_Aggregate_Bool_Exp = {
    count?: InputMaybe<Sessions_Aggregate_Bool_Exp_Count>;
};
export type Sessions_Aggregate_Bool_Exp_Count = {
    arguments?: InputMaybe<Array<Sessions_Select_Column>>;
    distinct?: InputMaybe<Scalars['Boolean']['input']>;
    filter?: InputMaybe<Sessions_Bool_Exp>;
    predicate: Int_Comparison_Exp;
};
/** aggregate fields of "sessions" */
export type Sessions_Aggregate_Fields = {
    count: Scalars['Int']['output'];
    max?: Maybe<Sessions_Max_Fields>;
    min?: Maybe<Sessions_Min_Fields>;
};
/** aggregate fields of "sessions" */
export type Sessions_Aggregate_FieldsCountArgs = {
    columns?: InputMaybe<Array<Sessions_Select_Column>>;
    distinct?: InputMaybe<Scalars['Boolean']['input']>;
};
/** order by aggregate values of table "sessions" */
export type Sessions_Aggregate_Order_By = {
    count?: InputMaybe<Order_By>;
    max?: InputMaybe<Sessions_Max_Order_By>;
    min?: InputMaybe<Sessions_Min_Order_By>;
};
/** input type for inserting array relation for remote table "sessions" */
export type Sessions_Arr_Rel_Insert_Input = {
    data: Array<Sessions_Insert_Input>;
    /** upsert condition */
    on_conflict?: InputMaybe<Sessions_On_Conflict>;
};
/** Boolean expression to filter rows from the table "sessions". All fields are combined with a logical 'AND'. */
export type Sessions_Bool_Exp = {
    _and?: InputMaybe<Array<Sessions_Bool_Exp>>;
    _not?: InputMaybe<Sessions_Bool_Exp>;
    _or?: InputMaybe<Array<Sessions_Bool_Exp>>;
    expires?: InputMaybe<Timestamptz_Comparison_Exp>;
    id?: InputMaybe<Uuid_Comparison_Exp>;
    sessionToken?: InputMaybe<String_Comparison_Exp>;
    user?: InputMaybe<Users_Bool_Exp>;
    userId?: InputMaybe<Uuid_Comparison_Exp>;
};
/** unique or primary key constraints on table "sessions" */
export type Sessions_Constraint = 
/** unique or primary key constraint on columns "sessionToken" */
'sessions_pkey';
/** input type for inserting data into table "sessions" */
export type Sessions_Insert_Input = {
    expires?: InputMaybe<Scalars['timestamptz']['input']>;
    id?: InputMaybe<Scalars['uuid']['input']>;
    sessionToken?: InputMaybe<Scalars['String']['input']>;
    user?: InputMaybe<Users_Obj_Rel_Insert_Input>;
    userId?: InputMaybe<Scalars['uuid']['input']>;
};
/** aggregate max on columns */
export type Sessions_Max_Fields = {
    expires?: Maybe<Scalars['timestamptz']['output']>;
    id?: Maybe<Scalars['uuid']['output']>;
    sessionToken?: Maybe<Scalars['String']['output']>;
    userId?: Maybe<Scalars['uuid']['output']>;
};
/** order by max() on columns of table "sessions" */
export type Sessions_Max_Order_By = {
    expires?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    sessionToken?: InputMaybe<Order_By>;
    userId?: InputMaybe<Order_By>;
};
/** aggregate min on columns */
export type Sessions_Min_Fields = {
    expires?: Maybe<Scalars['timestamptz']['output']>;
    id?: Maybe<Scalars['uuid']['output']>;
    sessionToken?: Maybe<Scalars['String']['output']>;
    userId?: Maybe<Scalars['uuid']['output']>;
};
/** order by min() on columns of table "sessions" */
export type Sessions_Min_Order_By = {
    expires?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    sessionToken?: InputMaybe<Order_By>;
    userId?: InputMaybe<Order_By>;
};
/** response of any mutation on the table "sessions" */
export type Sessions_Mutation_Response = {
    /** number of rows affected by the mutation */
    affected_rows: Scalars['Int']['output'];
    /** data from the rows affected by the mutation */
    returning: Array<Sessions>;
};
/** on_conflict condition type for table "sessions" */
export type Sessions_On_Conflict = {
    constraint: Sessions_Constraint;
    update_columns?: Array<Sessions_Update_Column>;
    where?: InputMaybe<Sessions_Bool_Exp>;
};
/** Ordering options when selecting data from "sessions". */
export type Sessions_Order_By = {
    expires?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    sessionToken?: InputMaybe<Order_By>;
    user?: InputMaybe<Users_Order_By>;
    userId?: InputMaybe<Order_By>;
};
/** primary key columns input for table: sessions */
export type Sessions_Pk_Columns_Input = {
    sessionToken: Scalars['String']['input'];
};
/** select columns of table "sessions" */
export type Sessions_Select_Column = 
/** column name */
'expires'
/** column name */
 | 'id'
/** column name */
 | 'sessionToken'
/** column name */
 | 'userId';
/** input type for updating data in table "sessions" */
export type Sessions_Set_Input = {
    expires?: InputMaybe<Scalars['timestamptz']['input']>;
    id?: InputMaybe<Scalars['uuid']['input']>;
    sessionToken?: InputMaybe<Scalars['String']['input']>;
    userId?: InputMaybe<Scalars['uuid']['input']>;
};
/** Streaming cursor of the table "sessions" */
export type Sessions_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: Sessions_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
export type Sessions_Stream_Cursor_Value_Input = {
    expires?: InputMaybe<Scalars['timestamptz']['input']>;
    id?: InputMaybe<Scalars['uuid']['input']>;
    sessionToken?: InputMaybe<Scalars['String']['input']>;
    userId?: InputMaybe<Scalars['uuid']['input']>;
};
/** update columns of table "sessions" */
export type Sessions_Update_Column = 
/** column name */
'expires'
/** column name */
 | 'id'
/** column name */
 | 'sessionToken'
/** column name */
 | 'userId';
export type Sessions_Updates = {
    /** sets the columns of the filtered rows to the given values */
    _set?: InputMaybe<Sessions_Set_Input>;
    /** filter the rows which have to be updated */
    where: Sessions_Bool_Exp;
};
export type Subscription_Root = {
    /** An array relationship */
    accounts: Array<Accounts>;
    /** An aggregate relationship */
    accounts_aggregate: Accounts_Aggregate;
    /** fetch data from the table: "accounts" using primary key columns */
    accounts_by_pk?: Maybe<Accounts>;
    /** fetch data from the table in a streaming manner: "accounts" */
    accounts_stream: Array<Accounts>;
    /** fetch data from the table: "provider_type" */
    provider_type: Array<Provider_Type>;
    /** fetch aggregated fields from the table: "provider_type" */
    provider_type_aggregate: Provider_Type_Aggregate;
    /** fetch data from the table: "provider_type" using primary key columns */
    provider_type_by_pk?: Maybe<Provider_Type>;
    /** fetch data from the table in a streaming manner: "provider_type" */
    provider_type_stream: Array<Provider_Type>;
    /** An array relationship */
    sessions: Array<Sessions>;
    /** An aggregate relationship */
    sessions_aggregate: Sessions_Aggregate;
    /** fetch data from the table: "sessions" using primary key columns */
    sessions_by_pk?: Maybe<Sessions>;
    /** fetch data from the table in a streaming manner: "sessions" */
    sessions_stream: Array<Sessions>;
    /** fetch data from the table: "users" */
    users: Array<Users>;
    /** fetch aggregated fields from the table: "users" */
    users_aggregate: Users_Aggregate;
    /** fetch data from the table: "users" using primary key columns */
    users_by_pk?: Maybe<Users>;
    /** fetch data from the table in a streaming manner: "users" */
    users_stream: Array<Users>;
    /** fetch data from the table: "verification_tokens" */
    verification_tokens: Array<Verification_Tokens>;
    /** fetch aggregated fields from the table: "verification_tokens" */
    verification_tokens_aggregate: Verification_Tokens_Aggregate;
    /** fetch data from the table: "verification_tokens" using primary key columns */
    verification_tokens_by_pk?: Maybe<Verification_Tokens>;
    /** fetch data from the table in a streaming manner: "verification_tokens" */
    verification_tokens_stream: Array<Verification_Tokens>;
};
export type Subscription_RootAccountsArgs = {
    distinct_on?: InputMaybe<Array<Accounts_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Accounts_Order_By>>;
    where?: InputMaybe<Accounts_Bool_Exp>;
};
export type Subscription_RootAccounts_AggregateArgs = {
    distinct_on?: InputMaybe<Array<Accounts_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Accounts_Order_By>>;
    where?: InputMaybe<Accounts_Bool_Exp>;
};
export type Subscription_RootAccounts_By_PkArgs = {
    id: Scalars['uuid']['input'];
};
export type Subscription_RootAccounts_StreamArgs = {
    batch_size: Scalars['Int']['input'];
    cursor: Array<InputMaybe<Accounts_Stream_Cursor_Input>>;
    where?: InputMaybe<Accounts_Bool_Exp>;
};
export type Subscription_RootProvider_TypeArgs = {
    distinct_on?: InputMaybe<Array<Provider_Type_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Provider_Type_Order_By>>;
    where?: InputMaybe<Provider_Type_Bool_Exp>;
};
export type Subscription_RootProvider_Type_AggregateArgs = {
    distinct_on?: InputMaybe<Array<Provider_Type_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Provider_Type_Order_By>>;
    where?: InputMaybe<Provider_Type_Bool_Exp>;
};
export type Subscription_RootProvider_Type_By_PkArgs = {
    value: Scalars['String']['input'];
};
export type Subscription_RootProvider_Type_StreamArgs = {
    batch_size: Scalars['Int']['input'];
    cursor: Array<InputMaybe<Provider_Type_Stream_Cursor_Input>>;
    where?: InputMaybe<Provider_Type_Bool_Exp>;
};
export type Subscription_RootSessionsArgs = {
    distinct_on?: InputMaybe<Array<Sessions_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Sessions_Order_By>>;
    where?: InputMaybe<Sessions_Bool_Exp>;
};
export type Subscription_RootSessions_AggregateArgs = {
    distinct_on?: InputMaybe<Array<Sessions_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Sessions_Order_By>>;
    where?: InputMaybe<Sessions_Bool_Exp>;
};
export type Subscription_RootSessions_By_PkArgs = {
    sessionToken: Scalars['String']['input'];
};
export type Subscription_RootSessions_StreamArgs = {
    batch_size: Scalars['Int']['input'];
    cursor: Array<InputMaybe<Sessions_Stream_Cursor_Input>>;
    where?: InputMaybe<Sessions_Bool_Exp>;
};
export type Subscription_RootUsersArgs = {
    distinct_on?: InputMaybe<Array<Users_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Users_Order_By>>;
    where?: InputMaybe<Users_Bool_Exp>;
};
export type Subscription_RootUsers_AggregateArgs = {
    distinct_on?: InputMaybe<Array<Users_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Users_Order_By>>;
    where?: InputMaybe<Users_Bool_Exp>;
};
export type Subscription_RootUsers_By_PkArgs = {
    id: Scalars['uuid']['input'];
};
export type Subscription_RootUsers_StreamArgs = {
    batch_size: Scalars['Int']['input'];
    cursor: Array<InputMaybe<Users_Stream_Cursor_Input>>;
    where?: InputMaybe<Users_Bool_Exp>;
};
export type Subscription_RootVerification_TokensArgs = {
    distinct_on?: InputMaybe<Array<Verification_Tokens_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Verification_Tokens_Order_By>>;
    where?: InputMaybe<Verification_Tokens_Bool_Exp>;
};
export type Subscription_RootVerification_Tokens_AggregateArgs = {
    distinct_on?: InputMaybe<Array<Verification_Tokens_Select_Column>>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    order_by?: InputMaybe<Array<Verification_Tokens_Order_By>>;
    where?: InputMaybe<Verification_Tokens_Bool_Exp>;
};
export type Subscription_RootVerification_Tokens_By_PkArgs = {
    token: Scalars['String']['input'];
};
export type Subscription_RootVerification_Tokens_StreamArgs = {
    batch_size: Scalars['Int']['input'];
    cursor: Array<InputMaybe<Verification_Tokens_Stream_Cursor_Input>>;
    where?: InputMaybe<Verification_Tokens_Bool_Exp>;
};
/** Boolean expression to compare columns of type "timestamptz". All fields are combined with logical 'AND'. */
export type Timestamptz_Comparison_Exp = {
    _eq?: InputMaybe<Scalars['