@ludo.ninja/api 2.8.28 → 2.8.30

package/src/graphql_tools/__generated__/authHost/schema.ts

@@ -0,0 +1,317 @@
+/* eslint-disable */
+import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+export type Maybe<T> = T | null;
+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 RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> };
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: string;
+  String: string;
+  Boolean: boolean;
+  Int: number;
+  Float: number;
+  /** A 64-bit signed integer */
+  Long: any;
+};
+
+
+export type IGenerateCompanyTokenInput = {
+  companyName: Scalars['String'];
+  tariffPlan: Scalars['String'];
+  authorities: Array<Maybe<Scalars['String']>>;
+  ttlMin?: Maybe<Scalars['Int']>;
+  showNsfw?: Maybe<Scalars['Boolean']>;
+};
+
+export type ILogin = {
+  userId?: Maybe<Scalars['String']>;
+  loggedTime?: Maybe<Scalars['Long']>;
+  ip?: Maybe<Scalars['String']>;
+  location?: Maybe<Scalars['String']>;
+};
+
+export type ILoginsPage = {
+  logins?: Maybe<Array<Maybe<ILogin>>>;
+  nextPageToken?: Maybe<Scalars['String']>;
+};
+
+
+export type IMutation = {
+  setDummy: Scalars['String'];
+  refreshToken: ITokenPair;
+  revokeToken: Scalars['Boolean'];
+  generateCompanyToken: Scalars['String'];
+};
+
+
+export type IMutationRefreshTokenArgs = {
+  refreshToken: Scalars['String'];
+  showNsfw?: Maybe<Scalars['Boolean']>;
+};
+
+
+export type IMutationGenerateCompanyTokenArgs = {
+  input: IGenerateCompanyTokenInput;
+};
+
+/** scalar Upload */
+export type IQuery = {
+  getDummy: Scalars['String'];
+  isValidAuthToken: Scalars['Boolean'];
+  fetchLogins: ILoginsPage;
+};
+
+
+/** scalar Upload */
+export type IQueryIsValidAuthTokenArgs = {
+  authToken: Scalars['String'];
+};
+
+
+/** scalar Upload */
+export type IQueryFetchLoginsArgs = {
+  pageSize: Scalars['Int'];
+  pageToken?: Maybe<Scalars['String']>;
+};
+
+export type ITokenPair = {
+  userId?: Maybe<Scalars['String']>;
+  tokenAuth?: Maybe<Scalars['String']>;
+  tokenRefresh?: Maybe<Scalars['String']>;
+  role?: Maybe<Scalars['String']>;
+};
+
+
+
+export type ResolverTypeWrapper<T> = Promise<T> | T;
+
+
+export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
+  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
+};
+export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs>;
+
+export type ResolverFn<TResult, TParent, TContext, TArgs> = (
+  parent: TParent,
+  args: TArgs,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => Promise<TResult> | TResult;
+
+export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
+  parent: TParent,
+  args: TArgs,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;
+
+export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
+  parent: TParent,
+  args: TArgs,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => TResult | Promise<TResult>;
+
+export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
+  subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>;
+  resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>;
+}
+
+export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
+  subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
+  resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
+}
+
+export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> =
+  | SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
+  | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
+
+export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> =
+  | ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
+  | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
+
+export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
+  parent: TParent,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
+
+export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
+
+export type NextResolverFn<T> = () => Promise<T>;
+
+export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
+  next: NextResolverFn<TResult>,
+  parent: TParent,
+  args: TArgs,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => TResult | Promise<TResult>;
+
+/** Mapping between all available schema types and the resolvers types */
+export type IResolversTypes = {
+  GenerateCompanyTokenInput: IGenerateCompanyTokenInput;
+  String: ResolverTypeWrapper<Scalars['String']>;
+  Int: ResolverTypeWrapper<Scalars['Int']>;
+  Boolean: ResolverTypeWrapper<Scalars['Boolean']>;
+  Login: ResolverTypeWrapper<ILogin>;
+  LoginsPage: ResolverTypeWrapper<ILoginsPage>;
+  Long: ResolverTypeWrapper<Scalars['Long']>;
+  Mutation: ResolverTypeWrapper<{}>;
+  Query: ResolverTypeWrapper<{}>;
+  TokenPair: ResolverTypeWrapper<ITokenPair>;
+};
+
+/** Mapping between all available schema types and the resolvers parents */
+export type IResolversParentTypes = {
+  GenerateCompanyTokenInput: IGenerateCompanyTokenInput;
+  String: Scalars['String'];
+  Int: Scalars['Int'];
+  Boolean: Scalars['Boolean'];
+  Login: ILogin;
+  LoginsPage: ILoginsPage;
+  Long: Scalars['Long'];
+  Mutation: {};
+  Query: {};
+  TokenPair: ITokenPair;
+};
+
+export type IOneOfDirectiveArgs = { };
+
+export type IOneOfDirectiveResolver<Result, Parent, ContextType = any, Args = IOneOfDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type ILoginResolvers<ContextType = any, ParentType extends IResolversParentTypes['Login'] = IResolversParentTypes['Login']> = {
+  userId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  loggedTime?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  ip?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  location?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type ILoginsPageResolvers<ContextType = any, ParentType extends IResolversParentTypes['LoginsPage'] = IResolversParentTypes['LoginsPage']> = {
+  logins?: Resolver<Maybe<Array<Maybe<IResolversTypes['Login']>>>, ParentType, ContextType>;
+  nextPageToken?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export interface ILongScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['Long'], any> {
+  name: 'Long';
+}
+
+export type IMutationResolvers<ContextType = any, ParentType extends IResolversParentTypes['Mutation'] = IResolversParentTypes['Mutation']> = {
+  setDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  refreshToken?: Resolver<IResolversTypes['TokenPair'], ParentType, ContextType, RequireFields<IMutationRefreshTokenArgs, 'refreshToken'>>;
+  revokeToken?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
+  generateCompanyToken?: Resolver<IResolversTypes['String'], ParentType, ContextType, RequireFields<IMutationGenerateCompanyTokenArgs, 'input'>>;
+};
+
+export type IQueryResolvers<ContextType = any, ParentType extends IResolversParentTypes['Query'] = IResolversParentTypes['Query']> = {
+  getDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  isValidAuthToken?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IQueryIsValidAuthTokenArgs, 'authToken'>>;
+  fetchLogins?: Resolver<IResolversTypes['LoginsPage'], ParentType, ContextType, RequireFields<IQueryFetchLoginsArgs, 'pageSize'>>;
+};
+
+export type ITokenPairResolvers<ContextType = any, ParentType extends IResolversParentTypes['TokenPair'] = IResolversParentTypes['TokenPair']> = {
+  userId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  tokenAuth?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  tokenRefresh?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  role?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IResolvers<ContextType = any> = {
+  Login?: ILoginResolvers<ContextType>;
+  LoginsPage?: ILoginsPageResolvers<ContextType>;
+  Long?: GraphQLScalarType;
+  Mutation?: IMutationResolvers<ContextType>;
+  Query?: IQueryResolvers<ContextType>;
+  TokenPair?: ITokenPairResolvers<ContextType>;
+};
+
+export type IDirectiveResolvers<ContextType = any> = {
+  oneOf?: IOneOfDirectiveResolver<any, any, ContextType>;
+};
+
+export type IRefreshTokenMutationVariables = Exact<{
+  refreshToken: Scalars['String'];
+  showNsfw?: Maybe<Scalars['Boolean']>;
+}>;
+
+
+export type IRefreshTokenMutation = { refreshToken: Pick<ITokenPair, 'userId' | 'tokenAuth' | 'tokenRefresh' | 'role'> };
+
+export type IRevokeTokenMutationVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IRevokeTokenMutation = Pick<IMutation, 'revokeToken'>;
+
+
+export const RefreshTokenDocument = gql`
+    mutation RefreshToken($refreshToken: String!, $showNsfw: Boolean) {
+  refreshToken(refreshToken: $refreshToken, showNsfw: $showNsfw) {
+    userId
+    tokenAuth
+    tokenRefresh
+    role
+  }
+}
+    `;
+export type IRefreshTokenMutationFn = Apollo.MutationFunction<IRefreshTokenMutation, IRefreshTokenMutationVariables>;
+
+/**
+ * __useRefreshTokenMutation__
+ *
+ * To run a mutation, you first call `useRefreshTokenMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRefreshTokenMutation` 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 [refreshTokenMutation, { data, loading, error }] = useRefreshTokenMutation({
+ *   variables: {
+ *      refreshToken: // value for 'refreshToken'
+ *      showNsfw: // value for 'showNsfw'
+ *   },
+ * });
+ */
+export function useRefreshTokenMutation(baseOptions?: Apollo.MutationHookOptions<IRefreshTokenMutation, IRefreshTokenMutationVariables>) {
+        return Apollo.useMutation<IRefreshTokenMutation, IRefreshTokenMutationVariables>(RefreshTokenDocument, baseOptions);
+      }
+export type RefreshTokenMutationHookResult = ReturnType<typeof useRefreshTokenMutation>;
+export type RefreshTokenMutationResult = Apollo.MutationResult<IRefreshTokenMutation>;
+export type RefreshTokenMutationOptions = Apollo.BaseMutationOptions<IRefreshTokenMutation, IRefreshTokenMutationVariables>;
+export const RevokeTokenDocument = gql`
+    mutation RevokeToken {
+  revokeToken
+}
+    `;
+export type IRevokeTokenMutationFn = Apollo.MutationFunction<IRevokeTokenMutation, IRevokeTokenMutationVariables>;
+
+/**
+ * __useRevokeTokenMutation__
+ *
+ * To run a mutation, you first call `useRevokeTokenMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRevokeTokenMutation` 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 [revokeTokenMutation, { data, loading, error }] = useRevokeTokenMutation({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useRevokeTokenMutation(baseOptions?: Apollo.MutationHookOptions<IRevokeTokenMutation, IRevokeTokenMutationVariables>) {
+        return Apollo.useMutation<IRevokeTokenMutation, IRevokeTokenMutationVariables>(RevokeTokenDocument, baseOptions);
+      }
+export type RevokeTokenMutationHookResult = ReturnType<typeof useRevokeTokenMutation>;
+export type RevokeTokenMutationResult = Apollo.MutationResult<IRevokeTokenMutation>;
+export type RevokeTokenMutationOptions = Apollo.BaseMutationOptions<IRevokeTokenMutation, IRevokeTokenMutationVariables>;