interface BasicFileStore {
  /**
   *Clear all content on the given folder
   */
  clearFolder: MonadFunction<FolderWhereUniqueInput, void>
  /**
   *Get a container detail
   */
  container: MonadFunction<ContainerWhereUniqueInput, ContainerData>
  /**
   *Lists all containers
   */
  containers: () => MonadNode<Array<ContainerQueryData>>
  /**
   *Creates a container
   */
  createContainer: MonadFunction<ContainerCreateInput, ContainerData>
  /**
   *Create a file
   */
  createFile: MonadFunction<FileCreateInput, FileData>
  /**
   *Removes a container
   */
  deleteContainer: MonadFunction<ContainerWhereUniqueInput, void>
  /**
   *Removes an file
   */
  deleteFile: MonadFunction<FileWhereUniqueInput, void>
  /**
   *Checks if a container exists.
   */
  existContainer: MonadFunction<ContainerWhereUniqueInput, boolean>
  /**
   *Check a file exist
   */
  existFile: MonadFunction<FileWhereUniqueInput, boolean>
  /**
   *Get a file info
   */
  file: MonadFunction<FileWhereUniqueInput, FileData>
  /**
   *Requests an object. The method returns a Promise that resolves to a Readable Stream containing the data.
   */
  fileStream: MonadFunction<FileWhereUniqueInput, Stream>
  /**
   *Get files and folders in a given folder
   */
  folders: MonadFunction<FolderWhereUniqueInput, FolderData>
  /**
   *Query file with `glob`
   */
  glob: MonadFunction<GlobWhereInput, Array<FileData>>
  /**
   *Update a container.
   */
  updateContainer: MonadFunction<ContainerUpdateInputParam, ContainerData>
  /**
   *Update a file content and path
   */
  updateFile: MonadFunction<FileUpdateInputParam, FileData>
}

interface Container extends ContainerWhereUniqueInput {
  /**
   *Option
   */
  option?: Record<string, any>
}

interface ContainerCreateInput extends Container {}

interface ContainerData extends ContainerWhereUniqueInput {}

interface ContainerQueryData extends ContainerWhereUniqueInput {}

interface ContainerUpdateInput extends ContainerWhereUniqueInput {}

interface ContainerUpdateInputParam {
  data: ContainerUpdateInput
  where: ContainerWhereUniqueInput
}

interface ContainerUpsertInputParam {
  create: ContainerCreateInput
  update: ContainerUpdateInput
  where: ContainerWhereUniqueInput
}

interface ContainerWhereUniqueInput {
  /**
   *Name of the container
   */
  name: string
}

interface ExtendFileStore {
  /**
   *query file
   */
  files: MonadFunction<FileWhereInput, Array<FileQueryData>>
  /**
   *Get a file text content.
   */
  readTextFile: MonadFunction<FileWhereUniqueInput & { encoding?: string }, TextFile>
  /**
   *Get some file text content.
   */
  readTextFiles: MonadFunction<FileWhereUniqueInput[] & { encoding?: string }, TextFile[]>
  /**
   *upsert a container
   */
  upsertContainer: MonadFunction<ContainerUpsertInputParam, ContainerData>
  /**
   *upsert a file
   */
  upsertFile: MonadFunction<FileUpsertInputParam, FileData>
}

interface File {
  container: string
  data: Stream | string | Buffer
  encoding?: string
  folders?: Array<string>
  lastModified: string
  name: string
  size: number
}

interface FileCreateInput extends FileWhereUniqueInput {
  /**
   *content
   */
  data: string | Buffer | Stream
  /**
   *encoding
   */
  encoding?: string
}

interface FileData extends FileWhereUniqueInput {
  /**
   *Date when the file was last modified
   */
  lastModified: string
  /**
   *Size in bytes of the file
   */
  size: number
}

interface FileQueryData extends FileData {}

interface FileUpdateInput {
  container: string
  data?: Stream | string | Buffer
  encoding?: string
  folders?: Array<string>
  name: string
}

interface FileUpdateInputParam {
  data: FileUpdateInput
  where: FileWhereUniqueInput
}

interface FileUpsertInput {
  create: FileCreateInput
  update: FileUpdateInput
  where: FileWhereUniqueInput
}

interface FileUpsertInputParam {
  create: FileCreateInput
  update: FileUpdateInput
  where: FileWhereUniqueInput
}

interface FileWhereInput {
  AND?: Array<FileWhereInput>
  NOT?: Array<FileWhereInput>
  OR?: Array<FileWhereInput>
  container?: string
  container_between?: string
  container_contains?: string
  container_ends_with?: string
  container_gt?: string
  container_gte?: string
  container_in?: string
  container_lt?: string
  container_lte?: string
  container_not?: string
  container_not_contains?: string
  container_not_ends_with?: string
  container_not_in?: string
  container_not_starts_with?: string
  container_starts_with?: string
  lastModified?: string
  lastModified_between?: string
  lastModified_gt?: string
  lastModified_gte?: string
  lastModified_lt?: string
  lastModified_lte?: string
  lastModified_not?: string
  name?: string
  name_between?: string
  name_contains?: string
  name_ends_with?: string
  name_gt?: string
  name_gte?: string
  name_in?: string
  name_lt?: string
  name_lte?: string
  name_not?: string
  name_not_contains?: string
  name_not_ends_with?: string
  name_not_in?: string
  name_not_starts_with?: string
  name_starts_with?: string
  size?: number
  size_between?: number
  size_gt?: number
  size_gte?: number
  size_lt?: number
  size_lte?: number
  size_not?: number
}

interface FileWhereUniqueInput {
  /**
   *the container
   */
  container: string
  /**
   *folders
   */
  folders: string[]
  /**
   *name
   */
  name: string
}

interface FolderData {
  files: FileData[]
  folders: string[]
}

interface FolderWhereUniqueInput {
  container: string
  folders: string[]
}

interface GlobWhereInput {
  container: string
  folders?: string[]
  pattern: string[] | string
}

interface MonadFileStore extends BasicFileStore, ExtendFileStore {}

interface PresignedUrl {
  /**
   *Returns a URL that clients (e.g. browsers) can use to request an object
   *from the server with a GET request, even if the object is private.
   */
  presignedGetUrl: MonadFunction<FileWhereUniqueInput & { ttl?: number }, string>
  /**
   *Returns a URL that clients (e.g. browsers) can use for PUT operations on an object in the server, even if the object is private.
   */
  presignedPutUrl: MonadFunction<FileWhereUniqueInput & { ttl?: number; metadata?: object }, string>
}

interface TextFile extends FileCreateInput {
  data: string
}

export const monadFileStore = (C: BasicFileStore): MonadFileStore => ...