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]> };
const defaultOptions =  {}
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: string;
  String: string;
  Boolean: boolean;
  Int: number;
  Float: number;
  /** DateTime is a DateTime in ISO 8601 format */
  DateTime: string;
};


/** Represents a directory */
export type Directory = {
  __typename?: "Directory";
  directorys?: Maybe<Array<Maybe<Directory>>>;
  files?: Maybe<Array<Maybe<File>>>;
  id: Scalars["ID"];
  name?: Maybe<Scalars["String"]>;
  parent?: Maybe<Directory>;
};

/** Represents a file, not a directory */
export type File = {
  __typename?: "File";
  contentType?: Maybe<Scalars["String"]>;
  etag?: Maybe<Scalars["String"]>;
  /** The uniqe ID of the file. Represents the path and the s3 key. */
  id: Scalars["ID"];
  lastModified?: Maybe<Scalars["DateTime"]>;
  name?: Maybe<Scalars["String"]>;
  parent?: Maybe<Directory>;
  size: Scalars["Int"];
};

export type RootMutation = {
  __typename?: "RootMutation";
  copy?: Maybe<File>;
  createDir: Directory;
  delete?: Maybe<Scalars["String"]>;
  deleteDir: Scalars["String"];
  move?: Maybe<File>;
};


export type RootMutationCopyArgs = {
  src: Scalars["ID"];
  dest: Scalars["ID"];
};


export type RootMutationCreateDirArgs = {
  path: Scalars["ID"];
};


export type RootMutationDeleteArgs = {
  id: Scalars["ID"];
};


export type RootMutationDeleteDirArgs = {
  path: Scalars["ID"];
};


export type RootMutationMoveArgs = {
  src: Scalars["ID"];
  dest: Scalars["ID"];
};

export type RootQuery = {
  __typename?: "RootQuery";
  directorys: Array<Directory>;
  file?: Maybe<File>;
  files: Array<File>;
};


export type RootQueryDirectorysArgs = {
  path: Scalars["String"];
};


export type RootQueryFileArgs = {
  id: Scalars["ID"];
};


export type RootQueryFilesArgs = {
  path: Scalars["String"];
};

export type CopyMutationVariables = Exact<{
  src: Scalars["ID"];
  dest: Scalars["ID"];
}>;


export type CopyMutation = (
  { __typename?: "RootMutation" }
  & { copy?: Maybe<(
    { __typename?: "File" }
    & Pick<File, "id">
  )> }
);

export type CreateDirMutationVariables = Exact<{
  path: Scalars["ID"];
}>;


export type CreateDirMutation = (
  { __typename?: "RootMutation" }
  & { createDir: (
    { __typename?: "Directory" }
    & Pick<Directory, "id">
  ) }
);

export type DeleteDirMutationVariables = Exact<{
  path: Scalars["ID"];
}>;


export type DeleteDirMutation = (
  { __typename?: "RootMutation" }
  & Pick<RootMutation, "deleteDir">
);

export type DeleteFileMutationVariables = Exact<{
  id: Scalars["ID"];
}>;


export type DeleteFileMutation = (
  { __typename?: "RootMutation" }
  & Pick<RootMutation, "delete">
);

export type GetFileQueryVariables = Exact<{
  id: Scalars["ID"];
}>;


export type GetFileQuery = (
  { __typename?: "RootQuery" }
  & { file?: Maybe<(
    { __typename?: "File" }
    & Pick<File, "id" | "name" | "size" | "contentType" | "etag">
  )> }
);

export type MoveMutationVariables = Exact<{
  src: Scalars["ID"];
  dest: Scalars["ID"];
}>;


export type MoveMutation = (
  { __typename?: "RootMutation" }
  & { move?: Maybe<(
    { __typename?: "File" }
    & Pick<File, "id">
  )> }
);

export type OpenDirQueryVariables = Exact<{
  path: Scalars["String"];
}>;


export type OpenDirQuery = (
  { __typename?: "RootQuery" }
  & { files: Array<(
    { __typename?: "File" }
    & Pick<File, "id" | "name" | "size" | "lastModified">
  )>, directorys: Array<(
    { __typename?: "Directory" }
    & Pick<Directory, "id" | "name">
  )> }
);


export const CopyDocument = gql`
    mutation copy($src: ID!, $dest: ID!) {
  copy(src: $src, dest: $dest) {
    id
  }
}
    `
export type CopyMutationFn = Apollo.MutationFunction<CopyMutation, CopyMutationVariables>;

/**
 * __useCopyMutation__
 *
 * To run a mutation, you first call `useCopyMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCopyMutation` 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 [copyMutation, { data, loading, error }] = useCopyMutation({
 *   variables: {
 *      src: // value for 'src'
 *      dest: // value for 'dest'
 *   },
 * });
 */
export function useCopyMutation(baseOptions?: Apollo.MutationHookOptions<CopyMutation, CopyMutationVariables>) {
	const options = {...defaultOptions, ...baseOptions}
	return Apollo.useMutation<CopyMutation, CopyMutationVariables>(CopyDocument, options)
}
export type CopyMutationHookResult = ReturnType<typeof useCopyMutation>;
export type CopyMutationResult = Apollo.MutationResult<CopyMutation>;
export type CopyMutationOptions = Apollo.BaseMutationOptions<CopyMutation, CopyMutationVariables>;
export const CreateDirDocument = gql`
    mutation createDir($path: ID!) {
  createDir(path: $path) {
    id
  }
}
    `
export type CreateDirMutationFn = Apollo.MutationFunction<CreateDirMutation, CreateDirMutationVariables>;

/**
 * __useCreateDirMutation__
 *
 * To run a mutation, you first call `useCreateDirMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateDirMutation` 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 [createDirMutation, { data, loading, error }] = useCreateDirMutation({
 *   variables: {
 *      path: // value for 'path'
 *   },
 * });
 */
export function useCreateDirMutation(baseOptions?: Apollo.MutationHookOptions<CreateDirMutation, CreateDirMutationVariables>) {
	const options = {...defaultOptions, ...baseOptions}
	return Apollo.useMutation<CreateDirMutation, CreateDirMutationVariables>(CreateDirDocument, options)
}
export type CreateDirMutationHookResult = ReturnType<typeof useCreateDirMutation>;
export type CreateDirMutationResult = Apollo.MutationResult<CreateDirMutation>;
export type CreateDirMutationOptions = Apollo.BaseMutationOptions<CreateDirMutation, CreateDirMutationVariables>;
export const DeleteDirDocument = gql`
    mutation deleteDir($path: ID!) {
  deleteDir(path: $path)
}
    `
export type DeleteDirMutationFn = Apollo.MutationFunction<DeleteDirMutation, DeleteDirMutationVariables>;

/**
 * __useDeleteDirMutation__
 *
 * To run a mutation, you first call `useDeleteDirMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteDirMutation` 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 [deleteDirMutation, { data, loading, error }] = useDeleteDirMutation({
 *   variables: {
 *      path: // value for 'path'
 *   },
 * });
 */
export function useDeleteDirMutation(baseOptions?: Apollo.MutationHookOptions<DeleteDirMutation, DeleteDirMutationVariables>) {
	const options = {...defaultOptions, ...baseOptions}
	return Apollo.useMutation<DeleteDirMutation, DeleteDirMutationVariables>(DeleteDirDocument, options)
}
export type DeleteDirMutationHookResult = ReturnType<typeof useDeleteDirMutation>;
export type DeleteDirMutationResult = Apollo.MutationResult<DeleteDirMutation>;
export type DeleteDirMutationOptions = Apollo.BaseMutationOptions<DeleteDirMutation, DeleteDirMutationVariables>;
export const DeleteFileDocument = gql`
    mutation deleteFile($id: ID!) {
  delete(id: $id)
}
    `
export type DeleteFileMutationFn = Apollo.MutationFunction<DeleteFileMutation, DeleteFileMutationVariables>;

/**
 * __useDeleteFileMutation__
 *
 * To run a mutation, you first call `useDeleteFileMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteFileMutation` 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 [deleteFileMutation, { data, loading, error }] = useDeleteFileMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export function useDeleteFileMutation(baseOptions?: Apollo.MutationHookOptions<DeleteFileMutation, DeleteFileMutationVariables>) {
	const options = {...defaultOptions, ...baseOptions}
	return Apollo.useMutation<DeleteFileMutation, DeleteFileMutationVariables>(DeleteFileDocument, options)
}
export type DeleteFileMutationHookResult = ReturnType<typeof useDeleteFileMutation>;
export type DeleteFileMutationResult = Apollo.MutationResult<DeleteFileMutation>;
export type DeleteFileMutationOptions = Apollo.BaseMutationOptions<DeleteFileMutation, DeleteFileMutationVariables>;
export const GetFileDocument = gql`
    query getFile($id: ID!) {
  file(id: $id) {
    id
    name
    size
    contentType
    etag
  }
}
    `

/**
 * __useGetFileQuery__
 *
 * To run a query within a React component, call `useGetFileQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetFileQuery` 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 } = useGetFileQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export function useGetFileQuery(baseOptions: Apollo.QueryHookOptions<GetFileQuery, GetFileQueryVariables>) {
	const options = {...defaultOptions, ...baseOptions}
	return Apollo.useQuery<GetFileQuery, GetFileQueryVariables>(GetFileDocument, options)
}
export function useGetFileLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetFileQuery, GetFileQueryVariables>) {
	const options = {...defaultOptions, ...baseOptions}
	return Apollo.useLazyQuery<GetFileQuery, GetFileQueryVariables>(GetFileDocument, options)
}
export type GetFileQueryHookResult = ReturnType<typeof useGetFileQuery>;
export type GetFileLazyQueryHookResult = ReturnType<typeof useGetFileLazyQuery>;
export type GetFileQueryResult = Apollo.QueryResult<GetFileQuery, GetFileQueryVariables>;
export const MoveDocument = gql`
    mutation move($src: ID!, $dest: ID!) {
  move(src: $src, dest: $dest) {
    id
  }
}
    `
export type MoveMutationFn = Apollo.MutationFunction<MoveMutation, MoveMutationVariables>;

/**
 * __useMoveMutation__
 *
 * To run a mutation, you first call `useMoveMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useMoveMutation` 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 [moveMutation, { data, loading, error }] = useMoveMutation({
 *   variables: {
 *      src: // value for 'src'
 *      dest: // value for 'dest'
 *   },
 * });
 */
export function useMoveMutation(baseOptions?: Apollo.MutationHookOptions<MoveMutation, MoveMutationVariables>) {
	const options = {...defaultOptions, ...baseOptions}
	return Apollo.useMutation<MoveMutation, MoveMutationVariables>(MoveDocument, options)
}
export type MoveMutationHookResult = ReturnType<typeof useMoveMutation>;
export type MoveMutationResult = Apollo.MutationResult<MoveMutation>;
export type MoveMutationOptions = Apollo.BaseMutationOptions<MoveMutation, MoveMutationVariables>;
export const OpenDirDocument = gql`
    query openDir($path: String!) {
  files(path: $path) {
    id
    name
    size
    lastModified
  }
  directorys(path: $path) {
    id
    name
  }
}
    `

/**
 * __useOpenDirQuery__
 *
 * To run a query within a React component, call `useOpenDirQuery` and pass it any options that fit your needs.
 * When your component renders, `useOpenDirQuery` 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 } = useOpenDirQuery({
 *   variables: {
 *      path: // value for 'path'
 *   },
 * });
 */
export function useOpenDirQuery(baseOptions: Apollo.QueryHookOptions<OpenDirQuery, OpenDirQueryVariables>) {
	const options = {...defaultOptions, ...baseOptions}
	return Apollo.useQuery<OpenDirQuery, OpenDirQueryVariables>(OpenDirDocument, options)
}
export function useOpenDirLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OpenDirQuery, OpenDirQueryVariables>) {
	const options = {...defaultOptions, ...baseOptions}
	return Apollo.useLazyQuery<OpenDirQuery, OpenDirQueryVariables>(OpenDirDocument, options)
}
export type OpenDirQueryHookResult = ReturnType<typeof useOpenDirQuery>;
export type OpenDirLazyQueryHookResult = ReturnType<typeof useOpenDirLazyQuery>;
export type OpenDirQueryResult = Apollo.QueryResult<OpenDirQuery, OpenDirQueryVariables>;