@burdenoff/microfe-files 2026.713.1 → 2026.715.1

package/dist/generated/wspace-operations.d.ts

@@ -0,0 +1,2789 @@
+import * as Types from './wspace-types';
+import * as Apollo from '@apollo/client';
+import * as ApolloReactHooks from '@apollo/client/react';
+export type FileBrowser_FileFragment = {
+    __typename?: 'File';
+    id: string;
+    workspaceId: string;
+    folderId?: string | null;
+    status: Types.FileStatus;
+    canRead?: boolean | null;
+    canUpdate?: boolean | null;
+    canDelete?: boolean | null;
+};
+export type FileBrowser_FolderFragment = {
+    __typename?: 'Folder';
+    id: string;
+    workspaceId: string;
+    parentFolderId?: string | null;
+    status: Types.FolderStatus;
+    canRead?: boolean | null;
+    canUpdate?: boolean | null;
+    canDelete?: boolean | null;
+};
+export type FileCard_FileFragment = {
+    __typename?: 'File';
+    id: string;
+    name: string;
+    description?: string | null;
+    workspaceId: string;
+    folderId?: string | null;
+    mimeType: string;
+    extension: string;
+    size: string;
+    downloadUrl?: string | null;
+    status: Types.FileStatus;
+    visibility: Types.FileVisibility;
+    starred: boolean;
+    downloadCount: number;
+    viewCount: number;
+    uploadedById: string;
+    createdAt: string;
+    updatedAt: string;
+    canRead?: boolean | null;
+    canUpdate?: boolean | null;
+    canDelete?: boolean | null;
+};
+export type FileInfoPanel_FileFragment = {
+    __typename?: 'File';
+    id: string;
+    name: string;
+    description?: string | null;
+    workspaceId: string;
+    folderId?: string | null;
+    mimeType: string;
+    extension: string;
+    size: string;
+    downloadUrl?: string | null;
+    status: Types.FileStatus;
+    visibility: Types.FileVisibility;
+    starred: boolean;
+    uploadedById: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type FileInfoPanel_FolderFragment = {
+    __typename?: 'Folder';
+    id: string;
+    name: string;
+    description?: string | null;
+    workspaceId: string;
+    parentFolderId?: string | null;
+    path: string;
+    level: number;
+    status: Types.FolderStatus;
+    visibility: Types.FileVisibility;
+    starred: boolean;
+    filesCount?: number | null;
+    subfoldersCount?: number | null;
+    createdById: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type FileListItem_FileFragment = {
+    __typename?: 'File';
+    id: string;
+    name: string;
+    description?: string | null;
+    workspaceId: string;
+    folderId?: string | null;
+    mimeType: string;
+    extension: string;
+    size: string;
+    downloadUrl?: string | null;
+    status: Types.FileStatus;
+    visibility: Types.FileVisibility;
+    starred: boolean;
+    uploadedById: string;
+    createdAt: string;
+    updatedAt: string;
+    canRead?: boolean | null;
+    canUpdate?: boolean | null;
+    canDelete?: boolean | null;
+};
+export type FilePreviewModal_FileFragment = {
+    __typename?: 'File';
+    id: string;
+    name: string;
+    workspaceId: string;
+    mimeType: string;
+    size: string;
+    s3Key: string;
+    downloadUrl?: string | null;
+    starred: boolean;
+    status: Types.FileStatus;
+    canRead?: boolean | null;
+    canUpdate?: boolean | null;
+    canDelete?: boolean | null;
+};
+export type FileVersionPanel_FileVersionFragment = {
+    __typename?: 'FileVersion';
+    id: string;
+    fileId: string;
+    versionNumber: number;
+    versionLabel?: string | null;
+    changeMessage?: string | null;
+    isCurrentVersion: boolean;
+    isMajorVersion: boolean;
+    name: string;
+    mimeType: string;
+    size: string;
+    s3Key: string;
+    sha256Hash?: string | null;
+    createdById: string;
+    createdAt: string;
+};
+export type FolderBreadcrumbItem_FolderFragment = {
+    __typename?: 'Folder';
+    id: string;
+    name: string;
+};
+export type FolderCard_FolderFragment = {
+    __typename?: 'Folder';
+    id: string;
+    name: string;
+    description?: string | null;
+    workspaceId: string;
+    parentFolderId?: string | null;
+    path: string;
+    level: number;
+    status: Types.FolderStatus;
+    visibility: Types.FileVisibility;
+    color?: string | null;
+    icon?: string | null;
+    starred: boolean;
+    filesCount?: number | null;
+    subfoldersCount?: number | null;
+    createdById: string;
+    createdAt: string;
+    updatedAt: string;
+    canRead?: boolean | null;
+    canUpdate?: boolean | null;
+    canDelete?: boolean | null;
+};
+export type ShareAccessPage_FileFragment = {
+    __typename?: 'File';
+    id: string;
+    name: string;
+    workspaceId: string;
+    mimeType: string;
+    size: string;
+    s3Key: string;
+    downloadUrl?: string | null;
+};
+export type ShareDialog_FileShareFragment = {
+    __typename?: 'FileShare';
+    id: string;
+    fileId: string;
+    shareType: Types.FileShareType;
+    accessLevel: Types.FileShareAccessLevel;
+    token?: string | null;
+    invitedEmail?: string | null;
+    requiresPassword: boolean;
+    expiresAt?: string | null;
+    maxDownloads?: number | null;
+    accessCount: number;
+    downloadCount: number;
+    lastAccessedAt?: string | null;
+    revokedAt?: string | null;
+    createdById: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type ShareDialog_FolderShareFragment = {
+    __typename?: 'FolderShare';
+    id: string;
+    folderId: string;
+    shareType: Types.FileShareType;
+    accessLevel: Types.FileShareAccessLevel;
+    token?: string | null;
+    invitedEmail?: string | null;
+    requiresPassword: boolean;
+    expiresAt?: string | null;
+    maxDownloads?: number | null;
+    accessCount: number;
+    downloadCount: number;
+    lastAccessedAt?: string | null;
+    revokedAt?: string | null;
+    revokedBy?: string | null;
+    createdById: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type AccessShareMutationVariables = Types.Exact<{
+    input: Types.AccessShareInput;
+}>;
+export type AccessShareMutation = {
+    __typename?: 'Mutation';
+    accessShare: {
+        __typename?: 'AccessShareResponse';
+        message?: string | null;
+        downloadUrl?: string | null;
+        share: {
+            __typename?: 'AccessShareResult';
+            id: string;
+            shareType: Types.FileShareType;
+            accessLevel: Types.FileShareAccessLevel;
+            requiresPassword: boolean;
+            expiresAt?: string | null;
+            maxDownloads?: number | null;
+            accessCount: number;
+            downloadCount: number;
+            createdAt: string;
+        };
+        file: {
+            __typename?: 'File';
+            id: string;
+            name: string;
+            workspaceId: string;
+            mimeType: string;
+            size: string;
+            s3Key: string;
+            downloadUrl?: string | null;
+        };
+    };
+};
+export type BulkDeleteFilesMutationVariables = Types.Exact<{
+    ids: Array<Types.Scalars['ID']['input']> | Types.Scalars['ID']['input'];
+}>;
+export type BulkDeleteFilesMutation = {
+    __typename?: 'Mutation';
+    bulkDeleteFiles: {
+        __typename?: 'FileBulkOperationResult';
+        success: boolean;
+        successCount: number;
+        failedCount: number;
+        errors?: Array<string> | null;
+    };
+};
+export type BulkMoveFilesMutationVariables = Types.Exact<{
+    ids: Array<Types.Scalars['ID']['input']> | Types.Scalars['ID']['input'];
+    targetFolderId?: Types.InputMaybe<Types.Scalars['ID']['input']>;
+}>;
+export type BulkMoveFilesMutation = {
+    __typename?: 'Mutation';
+    bulkMoveFiles: {
+        __typename?: 'FileBulkOperationResult';
+        success: boolean;
+        successCount: number;
+        failedCount: number;
+        errors?: Array<string> | null;
+    };
+};
+export type BulkPermanentlyDeleteFilesMutationVariables = Types.Exact<{
+    ids: Array<Types.Scalars['ID']['input']> | Types.Scalars['ID']['input'];
+}>;
+export type BulkPermanentlyDeleteFilesMutation = {
+    __typename?: 'Mutation';
+    bulkPermanentlyDeleteFiles: {
+        __typename?: 'FileBulkOperationResult';
+        success: boolean;
+        successCount: number;
+        failedCount: number;
+        errors?: Array<string> | null;
+    };
+};
+export type BulkPermanentlyDeleteFoldersMutationVariables = Types.Exact<{
+    ids: Array<Types.Scalars['ID']['input']> | Types.Scalars['ID']['input'];
+}>;
+export type BulkPermanentlyDeleteFoldersMutation = {
+    __typename?: 'Mutation';
+    bulkPermanentlyDeleteFolders: {
+        __typename?: 'FolderBulkOperationResult';
+        success: boolean;
+        successCount: number;
+        failedCount: number;
+        errors?: Array<string> | null;
+    };
+};
+export type BulkUpdateVisibilityMutationVariables = Types.Exact<{
+    ids: Array<Types.Scalars['ID']['input']> | Types.Scalars['ID']['input'];
+    visibility: Types.FileVisibility;
+}>;
+export type BulkUpdateVisibilityMutation = {
+    __typename?: 'Mutation';
+    bulkUpdateVisibility: {
+        __typename?: 'FileBulkOperationResult';
+        success: boolean;
+        successCount: number;
+        failedCount: number;
+        errors?: Array<string> | null;
+    };
+};
+export type CompleteUploadMutationVariables = Types.Exact<{
+    input: Types.CompleteUploadInput;
+}>;
+export type CompleteUploadMutation = {
+    __typename?: 'Mutation';
+    completeUpload: {
+        __typename?: 'CompleteUploadResponse';
+        fileId: string;
+        message?: string | null;
+        file: {
+            __typename?: 'File';
+            id: string;
+            workspaceId: string;
+            folderId?: string | null;
+            status: Types.FileStatus;
+            canRead?: boolean | null;
+            canUpdate?: boolean | null;
+            canDelete?: boolean | null;
+            name: string;
+            description?: string | null;
+            mimeType: string;
+            extension: string;
+            size: string;
+            downloadUrl?: string | null;
+            visibility: Types.FileVisibility;
+            starred: boolean;
+            downloadCount: number;
+            viewCount: number;
+            uploadedById: string;
+            createdAt: string;
+            updatedAt: string;
+            s3Key: string;
+        };
+    };
+};
+export type CopyFileMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    targetFolderId?: Types.InputMaybe<Types.Scalars['ID']['input']>;
+    newName?: Types.InputMaybe<Types.Scalars['String']['input']>;
+}>;
+export type CopyFileMutation = {
+    __typename?: 'Mutation';
+    copyFile: {
+        __typename?: 'File';
+        id: string;
+        workspaceId: string;
+        folderId?: string | null;
+        status: Types.FileStatus;
+        canRead?: boolean | null;
+        canUpdate?: boolean | null;
+        canDelete?: boolean | null;
+        name: string;
+        description?: string | null;
+        mimeType: string;
+        extension: string;
+        size: string;
+        downloadUrl?: string | null;
+        visibility: Types.FileVisibility;
+        starred: boolean;
+        downloadCount: number;
+        viewCount: number;
+        uploadedById: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type CreateFileVersionMutationVariables = Types.Exact<{
+    input: Types.CreateFileVersionInput;
+}>;
+export type CreateFileVersionMutation = {
+    __typename?: 'Mutation';
+    createFileVersion: {
+        __typename?: 'FileVersion';
+        id: string;
+        fileId: string;
+        versionNumber: number;
+        versionLabel?: string | null;
+        changeMessage?: string | null;
+        isCurrentVersion: boolean;
+        isMajorVersion: boolean;
+        createdAt: string;
+    };
+};
+export type CreateFolderMutationVariables = Types.Exact<{
+    input: Types.CreateFolderInput;
+}>;
+export type CreateFolderMutation = {
+    __typename?: 'Mutation';
+    createFolder: {
+        __typename?: 'Folder';
+        id: string;
+        workspaceId: string;
+        parentFolderId?: string | null;
+        status: Types.FolderStatus;
+        canRead?: boolean | null;
+        canUpdate?: boolean | null;
+        canDelete?: boolean | null;
+        name: string;
+        description?: string | null;
+        path: string;
+        level: number;
+        visibility: Types.FileVisibility;
+        color?: string | null;
+        icon?: string | null;
+        starred: boolean;
+        filesCount?: number | null;
+        subfoldersCount?: number | null;
+        createdById: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type CreateFolderShareMutationVariables = Types.Exact<{
+    input: Types.FolderCreateShareInput;
+}>;
+export type CreateFolderShareMutation = {
+    __typename?: 'Mutation';
+    createFolderShare: {
+        __typename?: 'FolderShare';
+        id: string;
+        folderId: string;
+        shareType: Types.FileShareType;
+        accessLevel: Types.FileShareAccessLevel;
+        token?: string | null;
+        invitedEmail?: string | null;
+        requiresPassword: boolean;
+        expiresAt?: string | null;
+        maxDownloads?: number | null;
+        accessCount: number;
+        downloadCount: number;
+        lastAccessedAt?: string | null;
+        revokedAt?: string | null;
+        revokedBy?: string | null;
+        createdById: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type CreateShareMutationVariables = Types.Exact<{
+    input: Types.FileCreateShareInput;
+}>;
+export type CreateShareMutation = {
+    __typename?: 'Mutation';
+    createShare: {
+        __typename?: 'FileShare';
+        id: string;
+        fileId: string;
+        shareType: Types.FileShareType;
+        accessLevel: Types.FileShareAccessLevel;
+        token?: string | null;
+        invitedEmail?: string | null;
+        requiresPassword: boolean;
+        expiresAt?: string | null;
+        maxDownloads?: number | null;
+        accessCount: number;
+        downloadCount: number;
+        lastAccessedAt?: string | null;
+        revokedAt?: string | null;
+        createdById: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type DeleteFileMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeleteFileMutation = {
+    __typename?: 'Mutation';
+    deleteFile: boolean;
+};
+export type DeleteFileVersionMutationVariables = Types.Exact<{
+    versionId: Types.Scalars['ID']['input'];
+}>;
+export type DeleteFileVersionMutation = {
+    __typename?: 'Mutation';
+    deleteFileVersion: boolean;
+};
+export type DeleteFolderMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    recursive?: Types.InputMaybe<Types.Scalars['Boolean']['input']>;
+}>;
+export type DeleteFolderMutation = {
+    __typename?: 'Mutation';
+    deleteFolder: boolean;
+};
+export type InitiateUploadMutationVariables = Types.Exact<{
+    input: Types.InitiateUploadInput;
+}>;
+export type InitiateUploadMutation = {
+    __typename?: 'Mutation';
+    initiateUpload: {
+        __typename?: 'UploadSessionWithUrls';
+        uploadUrl?: string | null;
+        session: {
+            __typename?: 'UploadSession';
+            id: string;
+            fileId?: string | null;
+            fileName: string;
+            fileSize: string;
+            mimeType: string;
+            status: Types.UploadStatus;
+        };
+    };
+};
+export type MoveFileMutationVariables = Types.Exact<{
+    input: Types.MoveFileInput;
+}>;
+export type MoveFileMutation = {
+    __typename?: 'Mutation';
+    moveFile: {
+        __typename?: 'File';
+        id: string;
+        workspaceId: string;
+        folderId?: string | null;
+        status: Types.FileStatus;
+        canRead?: boolean | null;
+        canUpdate?: boolean | null;
+        canDelete?: boolean | null;
+        name: string;
+        description?: string | null;
+        mimeType: string;
+        extension: string;
+        size: string;
+        downloadUrl?: string | null;
+        visibility: Types.FileVisibility;
+        starred: boolean;
+        downloadCount: number;
+        viewCount: number;
+        uploadedById: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type MoveFolderMutationVariables = Types.Exact<{
+    input: Types.MoveFolderInput;
+}>;
+export type MoveFolderMutation = {
+    __typename?: 'Mutation';
+    moveFolder: {
+        __typename?: 'Folder';
+        id: string;
+        workspaceId: string;
+        parentFolderId?: string | null;
+        status: Types.FolderStatus;
+        canRead?: boolean | null;
+        canUpdate?: boolean | null;
+        canDelete?: boolean | null;
+        name: string;
+        description?: string | null;
+        path: string;
+        level: number;
+        visibility: Types.FileVisibility;
+        color?: string | null;
+        icon?: string | null;
+        starred: boolean;
+        filesCount?: number | null;
+        subfoldersCount?: number | null;
+        createdById: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type PermanentlyDeleteFileMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type PermanentlyDeleteFileMutation = {
+    __typename?: 'Mutation';
+    permanentlyDeleteFile: boolean;
+};
+export type PermanentlyDeleteFolderMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type PermanentlyDeleteFolderMutation = {
+    __typename?: 'Mutation';
+    permanentlyDeleteFolder: boolean;
+};
+export type RestoreFileMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type RestoreFileMutation = {
+    __typename?: 'Mutation';
+    restoreFile: {
+        __typename?: 'File';
+        id: string;
+        workspaceId: string;
+        folderId?: string | null;
+        status: Types.FileStatus;
+        canRead?: boolean | null;
+        canUpdate?: boolean | null;
+        canDelete?: boolean | null;
+        name: string;
+        description?: string | null;
+        mimeType: string;
+        extension: string;
+        size: string;
+        downloadUrl?: string | null;
+        visibility: Types.FileVisibility;
+        starred: boolean;
+        downloadCount: number;
+        viewCount: number;
+        uploadedById: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type RestoreFileVersionMutationVariables = Types.Exact<{
+    input: Types.RestoreVersionInput;
+}>;
+export type RestoreFileVersionMutation = {
+    __typename?: 'Mutation';
+    restoreFileVersion: {
+        __typename?: 'FileVersion';
+        id: string;
+        fileId: string;
+        versionNumber: number;
+        isCurrentVersion: boolean;
+        createdAt: string;
+    };
+};
+export type RestoreFolderMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type RestoreFolderMutation = {
+    __typename?: 'Mutation';
+    restoreFolder: {
+        __typename?: 'Folder';
+        id: string;
+        workspaceId: string;
+        parentFolderId?: string | null;
+        status: Types.FolderStatus;
+        canRead?: boolean | null;
+        canUpdate?: boolean | null;
+        canDelete?: boolean | null;
+        name: string;
+        description?: string | null;
+        path: string;
+        level: number;
+        visibility: Types.FileVisibility;
+        color?: string | null;
+        icon?: string | null;
+        starred: boolean;
+        filesCount?: number | null;
+        subfoldersCount?: number | null;
+        createdById: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type RevokeFolderShareMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type RevokeFolderShareMutation = {
+    __typename?: 'Mutation';
+    revokeFolderShare: {
+        __typename?: 'FolderShare';
+        id: string;
+        folderId: string;
+        shareType: Types.FileShareType;
+        accessLevel: Types.FileShareAccessLevel;
+        token?: string | null;
+        invitedEmail?: string | null;
+        requiresPassword: boolean;
+        expiresAt?: string | null;
+        maxDownloads?: number | null;
+        accessCount: number;
+        downloadCount: number;
+        lastAccessedAt?: string | null;
+        revokedAt?: string | null;
+        revokedBy?: string | null;
+        createdById: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type RevokeShareMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type RevokeShareMutation = {
+    __typename?: 'Mutation';
+    revokeShare: {
+        __typename?: 'FileShare';
+        id: string;
+        fileId: string;
+        shareType: Types.FileShareType;
+        accessLevel: Types.FileShareAccessLevel;
+        token?: string | null;
+        invitedEmail?: string | null;
+        requiresPassword: boolean;
+        expiresAt?: string | null;
+        maxDownloads?: number | null;
+        accessCount: number;
+        downloadCount: number;
+        lastAccessedAt?: string | null;
+        revokedAt?: string | null;
+        createdById: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type ToggleFileStarredMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type ToggleFileStarredMutation = {
+    __typename?: 'Mutation';
+    toggleFileStarred: {
+        __typename?: 'File';
+        id: string;
+        workspaceId: string;
+        folderId?: string | null;
+        status: Types.FileStatus;
+        canRead?: boolean | null;
+        canUpdate?: boolean | null;
+        canDelete?: boolean | null;
+        name: string;
+        description?: string | null;
+        mimeType: string;
+        extension: string;
+        size: string;
+        downloadUrl?: string | null;
+        visibility: Types.FileVisibility;
+        starred: boolean;
+        downloadCount: number;
+        viewCount: number;
+        uploadedById: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type ToggleFolderStarredMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type ToggleFolderStarredMutation = {
+    __typename?: 'Mutation';
+    toggleFolderStarred: {
+        __typename?: 'Folder';
+        id: string;
+        workspaceId: string;
+        parentFolderId?: string | null;
+        status: Types.FolderStatus;
+        canRead?: boolean | null;
+        canUpdate?: boolean | null;
+        canDelete?: boolean | null;
+        name: string;
+        description?: string | null;
+        path: string;
+        level: number;
+        visibility: Types.FileVisibility;
+        color?: string | null;
+        icon?: string | null;
+        starred: boolean;
+        filesCount?: number | null;
+        subfoldersCount?: number | null;
+        createdById: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type TrackShareDownloadMutationVariables = Types.Exact<{
+    shareId: Types.Scalars['ID']['input'];
+}>;
+export type TrackShareDownloadMutation = {
+    __typename?: 'Mutation';
+    trackShareDownload: boolean;
+};
+export type UpdateFileMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.UpdateFileInput;
+}>;
+export type UpdateFileMutation = {
+    __typename?: 'Mutation';
+    updateFile: {
+        __typename?: 'File';
+        id: string;
+        workspaceId: string;
+        folderId?: string | null;
+        status: Types.FileStatus;
+        canRead?: boolean | null;
+        canUpdate?: boolean | null;
+        canDelete?: boolean | null;
+        name: string;
+        description?: string | null;
+        mimeType: string;
+        extension: string;
+        size: string;
+        downloadUrl?: string | null;
+        visibility: Types.FileVisibility;
+        starred: boolean;
+        downloadCount: number;
+        viewCount: number;
+        uploadedById: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type UpdateFolderMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.UpdateFolderInput;
+}>;
+export type UpdateFolderMutation = {
+    __typename?: 'Mutation';
+    updateFolder: {
+        __typename?: 'Folder';
+        id: string;
+        workspaceId: string;
+        parentFolderId?: string | null;
+        status: Types.FolderStatus;
+        canRead?: boolean | null;
+        canUpdate?: boolean | null;
+        canDelete?: boolean | null;
+        name: string;
+        description?: string | null;
+        path: string;
+        level: number;
+        visibility: Types.FileVisibility;
+        color?: string | null;
+        icon?: string | null;
+        starred: boolean;
+        filesCount?: number | null;
+        subfoldersCount?: number | null;
+        createdById: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type GetFilesBinPageQueryVariables = Types.Exact<{
+    filePagination?: Types.InputMaybe<Types.PaginationInput>;
+    folderPagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type GetFilesBinPageQuery = {
+    __typename?: 'Query';
+    getFiles: {
+        __typename?: 'FileList';
+        total: number;
+        page: number;
+        limit: number;
+        hasMore: boolean;
+        files: Array<{
+            __typename?: 'File';
+            id: string;
+            workspaceId: string;
+            folderId?: string | null;
+            status: Types.FileStatus;
+            canRead?: boolean | null;
+            canUpdate?: boolean | null;
+            canDelete?: boolean | null;
+            name: string;
+            description?: string | null;
+            mimeType: string;
+            extension: string;
+            size: string;
+            downloadUrl?: string | null;
+            visibility: Types.FileVisibility;
+            starred: boolean;
+            downloadCount: number;
+            viewCount: number;
+            uploadedById: string;
+            createdAt: string;
+            updatedAt: string;
+            s3Key: string;
+        }>;
+    };
+    getFolders: {
+        __typename?: 'FolderList';
+        total: number;
+        page: number;
+        limit: number;
+        hasMore: boolean;
+        folders: Array<{
+            __typename?: 'Folder';
+            id: string;
+            workspaceId: string;
+            parentFolderId?: string | null;
+            status: Types.FolderStatus;
+            canRead?: boolean | null;
+            canUpdate?: boolean | null;
+            canDelete?: boolean | null;
+            name: string;
+            description?: string | null;
+            path: string;
+            level: number;
+            visibility: Types.FileVisibility;
+            color?: string | null;
+            icon?: string | null;
+            starred: boolean;
+            filesCount?: number | null;
+            subfoldersCount?: number | null;
+            createdById: string;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export type GetFilesFolderBrowsePageQueryVariables = Types.Exact<{
+    folderId: Types.Scalars['ID']['input'];
+    filePagination?: Types.InputMaybe<Types.PaginationInput>;
+    folderPagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type GetFilesFolderBrowsePageQuery = {
+    __typename?: 'Query';
+    getFiles: {
+        __typename?: 'FileList';
+        total: number;
+        page: number;
+        limit: number;
+        hasMore: boolean;
+        files: Array<{
+            __typename?: 'File';
+            id: string;
+            workspaceId: string;
+            folderId?: string | null;
+            status: Types.FileStatus;
+            canRead?: boolean | null;
+            canUpdate?: boolean | null;
+            canDelete?: boolean | null;
+            name: string;
+            description?: string | null;
+            mimeType: string;
+            extension: string;
+            size: string;
+            downloadUrl?: string | null;
+            visibility: Types.FileVisibility;
+            starred: boolean;
+            downloadCount: number;
+            viewCount: number;
+            uploadedById: string;
+            createdAt: string;
+            updatedAt: string;
+            s3Key: string;
+        }>;
+    };
+    getFolders: {
+        __typename?: 'FolderList';
+        total: number;
+        page: number;
+        limit: number;
+        hasMore: boolean;
+        folders: Array<{
+            __typename?: 'Folder';
+            id: string;
+            workspaceId: string;
+            parentFolderId?: string | null;
+            status: Types.FolderStatus;
+            canRead?: boolean | null;
+            canUpdate?: boolean | null;
+            canDelete?: boolean | null;
+            name: string;
+            description?: string | null;
+            path: string;
+            level: number;
+            visibility: Types.FileVisibility;
+            color?: string | null;
+            icon?: string | null;
+            starred: boolean;
+            filesCount?: number | null;
+            subfoldersCount?: number | null;
+            createdById: string;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+    getFolderPath: {
+        __typename?: 'FolderPath';
+        depth: number;
+        folders: Array<{
+            __typename?: 'Folder';
+            id: string;
+            name: string;
+        }>;
+    };
+    getFolder?: {
+        __typename?: 'Folder';
+        id: string;
+        name: string;
+    } | null;
+};
+export type GetFilesRecentPageQueryVariables = Types.Exact<{
+    filePagination?: Types.InputMaybe<Types.PaginationInput>;
+    folderPagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type GetFilesRecentPageQuery = {
+    __typename?: 'Query';
+    getFiles: {
+        __typename?: 'FileList';
+        total: number;
+        page: number;
+        limit: number;
+        hasMore: boolean;
+        files: Array<{
+            __typename?: 'File';
+            id: string;
+            workspaceId: string;
+            folderId?: string | null;
+            status: Types.FileStatus;
+            canRead?: boolean | null;
+            canUpdate?: boolean | null;
+            canDelete?: boolean | null;
+            name: string;
+            description?: string | null;
+            mimeType: string;
+            extension: string;
+            size: string;
+            downloadUrl?: string | null;
+            visibility: Types.FileVisibility;
+            starred: boolean;
+            downloadCount: number;
+            viewCount: number;
+            uploadedById: string;
+            createdAt: string;
+            updatedAt: string;
+            s3Key: string;
+        }>;
+    };
+    getFolders: {
+        __typename?: 'FolderList';
+        total: number;
+        page: number;
+        limit: number;
+        hasMore: boolean;
+        folders: Array<{
+            __typename?: 'Folder';
+            id: string;
+            workspaceId: string;
+            parentFolderId?: string | null;
+            status: Types.FolderStatus;
+            canRead?: boolean | null;
+            canUpdate?: boolean | null;
+            canDelete?: boolean | null;
+            name: string;
+            description?: string | null;
+            path: string;
+            level: number;
+            visibility: Types.FileVisibility;
+            color?: string | null;
+            icon?: string | null;
+            starred: boolean;
+            filesCount?: number | null;
+            subfoldersCount?: number | null;
+            createdById: string;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export type GetFilesRootBrowsePageQueryVariables = Types.Exact<{
+    filePagination?: Types.InputMaybe<Types.PaginationInput>;
+    folderPagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type GetFilesRootBrowsePageQuery = {
+    __typename?: 'Query';
+    getFiles: {
+        __typename?: 'FileList';
+        total: number;
+        page: number;
+        limit: number;
+        hasMore: boolean;
+        files: Array<{
+            __typename?: 'File';
+            id: string;
+            workspaceId: string;
+            folderId?: string | null;
+            status: Types.FileStatus;
+            canRead?: boolean | null;
+            canUpdate?: boolean | null;
+            canDelete?: boolean | null;
+            name: string;
+            description?: string | null;
+            mimeType: string;
+            extension: string;
+            size: string;
+            downloadUrl?: string | null;
+            visibility: Types.FileVisibility;
+            starred: boolean;
+            downloadCount: number;
+            viewCount: number;
+            uploadedById: string;
+            createdAt: string;
+            updatedAt: string;
+            s3Key: string;
+        }>;
+    };
+    getFolders: {
+        __typename?: 'FolderList';
+        total: number;
+        page: number;
+        limit: number;
+        hasMore: boolean;
+        folders: Array<{
+            __typename?: 'Folder';
+            id: string;
+            workspaceId: string;
+            parentFolderId?: string | null;
+            status: Types.FolderStatus;
+            canRead?: boolean | null;
+            canUpdate?: boolean | null;
+            canDelete?: boolean | null;
+            name: string;
+            description?: string | null;
+            path: string;
+            level: number;
+            visibility: Types.FileVisibility;
+            color?: string | null;
+            icon?: string | null;
+            starred: boolean;
+            filesCount?: number | null;
+            subfoldersCount?: number | null;
+            createdById: string;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export type GetFilesStarredPageQueryVariables = Types.Exact<{
+    pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type GetFilesStarredPageQuery = {
+    __typename?: 'Query';
+    getStarredFiles: {
+        __typename?: 'FileList';
+        total: number;
+        page: number;
+        limit: number;
+        hasMore: boolean;
+        files: Array<{
+            __typename?: 'File';
+            id: string;
+            workspaceId: string;
+            folderId?: string | null;
+            status: Types.FileStatus;
+            canRead?: boolean | null;
+            canUpdate?: boolean | null;
+            canDelete?: boolean | null;
+            name: string;
+            description?: string | null;
+            mimeType: string;
+            extension: string;
+            size: string;
+            downloadUrl?: string | null;
+            visibility: Types.FileVisibility;
+            starred: boolean;
+            downloadCount: number;
+            viewCount: number;
+            uploadedById: string;
+            createdAt: string;
+            updatedAt: string;
+            s3Key: string;
+        }>;
+    };
+    getStarredFolders: {
+        __typename?: 'FolderList';
+        total: number;
+        page: number;
+        limit: number;
+        hasMore: boolean;
+        folders: Array<{
+            __typename?: 'Folder';
+            id: string;
+            workspaceId: string;
+            parentFolderId?: string | null;
+            status: Types.FolderStatus;
+            canRead?: boolean | null;
+            canUpdate?: boolean | null;
+            canDelete?: boolean | null;
+            name: string;
+            description?: string | null;
+            path: string;
+            level: number;
+            visibility: Types.FileVisibility;
+            color?: string | null;
+            icon?: string | null;
+            starred: boolean;
+            filesCount?: number | null;
+            subfoldersCount?: number | null;
+            createdById: string;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export type SearchFilesPageQueryVariables = Types.Exact<{
+    query: Types.Scalars['String']['input'];
+    fileFilter?: Types.InputMaybe<Types.FileFilterInput>;
+    folderFilter?: Types.InputMaybe<Types.FolderFilterInput>;
+    filePagination?: Types.InputMaybe<Types.PaginationInput>;
+    folderPagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type SearchFilesPageQuery = {
+    __typename?: 'Query';
+    searchFiles: {
+        __typename?: 'FileList';
+        total: number;
+        page: number;
+        limit: number;
+        hasMore: boolean;
+        files: Array<{
+            __typename?: 'File';
+            id: string;
+            workspaceId: string;
+            folderId?: string | null;
+            status: Types.FileStatus;
+            canRead?: boolean | null;
+            canUpdate?: boolean | null;
+            canDelete?: boolean | null;
+            name: string;
+            description?: string | null;
+            mimeType: string;
+            extension: string;
+            size: string;
+            downloadUrl?: string | null;
+            visibility: Types.FileVisibility;
+            starred: boolean;
+            downloadCount: number;
+            viewCount: number;
+            uploadedById: string;
+            createdAt: string;
+            updatedAt: string;
+            s3Key: string;
+        }>;
+    };
+    searchFolders: {
+        __typename?: 'FolderList';
+        total: number;
+        page: number;
+        limit: number;
+        hasMore: boolean;
+        folders: Array<{
+            __typename?: 'Folder';
+            id: string;
+            workspaceId: string;
+            parentFolderId?: string | null;
+            status: Types.FolderStatus;
+            canRead?: boolean | null;
+            canUpdate?: boolean | null;
+            canDelete?: boolean | null;
+            name: string;
+            description?: string | null;
+            path: string;
+            level: number;
+            visibility: Types.FileVisibility;
+            color?: string | null;
+            icon?: string | null;
+            starred: boolean;
+            filesCount?: number | null;
+            subfoldersCount?: number | null;
+            createdById: string;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export type GetFileQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetFileQuery = {
+    __typename?: 'Query';
+    getFile?: {
+        __typename?: 'File';
+        id: string;
+        workspaceId: string;
+        folderId?: string | null;
+        status: Types.FileStatus;
+        canRead?: boolean | null;
+        canUpdate?: boolean | null;
+        canDelete?: boolean | null;
+        name: string;
+        description?: string | null;
+        mimeType: string;
+        extension: string;
+        size: string;
+        downloadUrl?: string | null;
+        visibility: Types.FileVisibility;
+        starred: boolean;
+        downloadCount: number;
+        viewCount: number;
+        uploadedById: string;
+        createdAt: string;
+        updatedAt: string;
+        s3Key: string;
+    } | null;
+};
+export type GetFileVersionDownloadUrlQueryVariables = Types.Exact<{
+    versionId: Types.Scalars['ID']['input'];
+    expiresIn?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type GetFileVersionDownloadUrlQuery = {
+    __typename?: 'Query';
+    getFileVersionDownloadUrl: string;
+};
+export type GetFileVersionsQueryVariables = Types.Exact<{
+    fileId: Types.Scalars['ID']['input'];
+    pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type GetFileVersionsQuery = {
+    __typename?: 'Query';
+    getFileVersions: {
+        __typename?: 'FileVersionList';
+        total: number;
+        hasMore: boolean;
+        page: number;
+        limit: number;
+        versions: Array<{
+            __typename?: 'FileVersion';
+            id: string;
+            fileId: string;
+            versionNumber: number;
+            versionLabel?: string | null;
+            changeMessage?: string | null;
+            isCurrentVersion: boolean;
+            isMajorVersion: boolean;
+            name: string;
+            mimeType: string;
+            size: string;
+            s3Key: string;
+            sha256Hash?: string | null;
+            createdById: string;
+            createdAt: string;
+        }>;
+    };
+};
+export type GetFilesQueryVariables = Types.Exact<{
+    folderId?: Types.InputMaybe<Types.Scalars['ID']['input']>;
+    filter?: Types.InputMaybe<Types.FileFilterInput>;
+    sort?: Types.InputMaybe<Types.FileSortInput>;
+    pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type GetFilesQuery = {
+    __typename?: 'Query';
+    getFiles: {
+        __typename?: 'FileList';
+        total: number;
+        page: number;
+        limit: number;
+        hasMore: boolean;
+        files: Array<{
+            __typename?: 'File';
+            id: string;
+            workspaceId: string;
+            folderId?: string | null;
+            status: Types.FileStatus;
+            canRead?: boolean | null;
+            canUpdate?: boolean | null;
+            canDelete?: boolean | null;
+            name: string;
+            description?: string | null;
+            mimeType: string;
+            extension: string;
+            size: string;
+            downloadUrl?: string | null;
+            visibility: Types.FileVisibility;
+            starred: boolean;
+            downloadCount: number;
+            viewCount: number;
+            uploadedById: string;
+            createdAt: string;
+            updatedAt: string;
+            s3Key: string;
+        }>;
+    };
+};
+export type GetFolderQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetFolderQuery = {
+    __typename?: 'Query';
+    getFolder?: {
+        __typename?: 'Folder';
+        id: string;
+        name: string;
+        workspaceId: string;
+        parentFolderId?: string | null;
+        status: Types.FolderStatus;
+        canRead?: boolean | null;
+        canUpdate?: boolean | null;
+        canDelete?: boolean | null;
+        description?: string | null;
+        path: string;
+        level: number;
+        visibility: Types.FileVisibility;
+        color?: string | null;
+        icon?: string | null;
+        starred: boolean;
+        filesCount?: number | null;
+        subfoldersCount?: number | null;
+        createdById: string;
+        createdAt: string;
+        updatedAt: string;
+    } | null;
+};
+export type GetFolderPathQueryVariables = Types.Exact<{
+    folderId: Types.Scalars['ID']['input'];
+}>;
+export type GetFolderPathQuery = {
+    __typename?: 'Query';
+    getFolderPath: {
+        __typename?: 'FolderPath';
+        depth: number;
+        folders: Array<{
+            __typename?: 'Folder';
+            id: string;
+            name: string;
+        }>;
+    };
+};
+export type GetFoldersQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.FolderFilterInput>;
+    pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type GetFoldersQuery = {
+    __typename?: 'Query';
+    getFolders: {
+        __typename?: 'FolderList';
+        total: number;
+        page: number;
+        limit: number;
+        hasMore: boolean;
+        folders: Array<{
+            __typename?: 'Folder';
+            id: string;
+            workspaceId: string;
+            parentFolderId?: string | null;
+            status: Types.FolderStatus;
+            canRead?: boolean | null;
+            canUpdate?: boolean | null;
+            canDelete?: boolean | null;
+            name: string;
+            description?: string | null;
+            path: string;
+            level: number;
+            visibility: Types.FileVisibility;
+            color?: string | null;
+            icon?: string | null;
+            starred: boolean;
+            filesCount?: number | null;
+            subfoldersCount?: number | null;
+            createdById: string;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export type GetSharedWithMeQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetSharedWithMeQuery = {
+    __typename?: 'Query';
+    getUserShares: {
+        __typename?: 'FileShareList';
+        shares: Array<{
+            __typename?: 'FileShare';
+            id: string;
+            fileId: string;
+            shareType: Types.FileShareType;
+            accessLevel: Types.FileShareAccessLevel;
+            token?: string | null;
+            invitedEmail?: string | null;
+            requiresPassword: boolean;
+            expiresAt?: string | null;
+            maxDownloads?: number | null;
+            accessCount: number;
+            downloadCount: number;
+            lastAccessedAt?: string | null;
+            revokedAt?: string | null;
+            createdById: string;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export type GetSharesForFolderQueryVariables = Types.Exact<{
+    folderId: Types.Scalars['ID']['input'];
+    pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type GetSharesForFolderQuery = {
+    __typename?: 'Query';
+    getSharesForFolder: {
+        __typename?: 'FolderShareList';
+        total: number;
+        page: number;
+        limit: number;
+        hasMore: boolean;
+        shares: Array<{
+            __typename?: 'FolderShare';
+            id: string;
+            folderId: string;
+            shareType: Types.FileShareType;
+            accessLevel: Types.FileShareAccessLevel;
+            token?: string | null;
+            invitedEmail?: string | null;
+            requiresPassword: boolean;
+            expiresAt?: string | null;
+            maxDownloads?: number | null;
+            accessCount: number;
+            downloadCount: number;
+            lastAccessedAt?: string | null;
+            revokedAt?: string | null;
+            revokedBy?: string | null;
+            createdById: string;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export type GetUserSharesQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetUserSharesQuery = {
+    __typename?: 'Query';
+    getUserShares: {
+        __typename?: 'FileShareList';
+        shares: Array<{
+            __typename?: 'FileShare';
+            id: string;
+            fileId: string;
+            shareType: Types.FileShareType;
+            accessLevel: Types.FileShareAccessLevel;
+            token?: string | null;
+            invitedEmail?: string | null;
+            requiresPassword: boolean;
+            expiresAt?: string | null;
+            maxDownloads?: number | null;
+            accessCount: number;
+            downloadCount: number;
+            lastAccessedAt?: string | null;
+            revokedAt?: string | null;
+            createdById: string;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export type GetUserStorageUsageQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetUserStorageUsageQuery = {
+    __typename?: 'Query';
+    getUserStorageUsage: {
+        __typename?: 'UserStorageUsage';
+        userId: string;
+        currentBytes: string;
+        limitBytes: string;
+        planId?: string | null;
+        planName: string;
+        source: string;
+    };
+};
+export type GetWorkspaceStorageStatusQueryVariables = Types.Exact<{
+    workspaceId: Types.Scalars['ID']['input'];
+}>;
+export type GetWorkspaceStorageStatusQuery = {
+    __typename?: 'Query';
+    workspaceQuotaStatuses: Array<{
+        __typename?: 'WorkspaceQuotaStatus';
+        quotaName: string;
+        currentValue: number;
+        limit?: number | null;
+        noLimit: boolean;
+        scrapedAt: string;
+    }>;
+};
+export declare const FileBrowser_FileFragmentDoc: Apollo.DocumentNode;
+export declare const FileBrowser_FolderFragmentDoc: Apollo.DocumentNode;
+export declare const FileCard_FileFragmentDoc: Apollo.DocumentNode;
+export declare const FileInfoPanel_FileFragmentDoc: Apollo.DocumentNode;
+export declare const FileInfoPanel_FolderFragmentDoc: Apollo.DocumentNode;
+export declare const FileListItem_FileFragmentDoc: Apollo.DocumentNode;
+export declare const FilePreviewModal_FileFragmentDoc: Apollo.DocumentNode;
+export declare const FileVersionPanel_FileVersionFragmentDoc: Apollo.DocumentNode;
+export declare const FolderBreadcrumbItem_FolderFragmentDoc: Apollo.DocumentNode;
+export declare const FolderCard_FolderFragmentDoc: Apollo.DocumentNode;
+export declare const ShareAccessPage_FileFragmentDoc: Apollo.DocumentNode;
+export declare const ShareDialog_FileShareFragmentDoc: Apollo.DocumentNode;
+export declare const ShareDialog_FolderShareFragmentDoc: Apollo.DocumentNode;
+export declare const AccessShareDocument: Apollo.DocumentNode;
+export type AccessShareMutationFn = Apollo.MutationFunction<Types.AccessShareMutation, Types.AccessShareMutationVariables>;
+/**
+ * __useAccessShareMutation__
+ *
+ * To run a mutation, you first call `useAccessShareMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAccessShareMutation` 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 [accessShareMutation, { data, loading, error }] = useAccessShareMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useAccessShareMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AccessShareMutation, Types.AccessShareMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AccessShareMutation, any, Apollo.ApolloCache, undefined>;
+export type AccessShareMutationHookResult = ReturnType<typeof useAccessShareMutation>;
+export type AccessShareMutationResult = Apollo.MutationResult<Types.AccessShareMutation>;
+export type AccessShareMutationOptions = Apollo.BaseMutationOptions<Types.AccessShareMutation, Types.AccessShareMutationVariables>;
+export declare const BulkDeleteFilesDocument: Apollo.DocumentNode;
+export type BulkDeleteFilesMutationFn = Apollo.MutationFunction<Types.BulkDeleteFilesMutation, Types.BulkDeleteFilesMutationVariables>;
+/**
+ * __useBulkDeleteFilesMutation__
+ *
+ * To run a mutation, you first call `useBulkDeleteFilesMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useBulkDeleteFilesMutation` 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 [bulkDeleteFilesMutation, { data, loading, error }] = useBulkDeleteFilesMutation({
+ *   variables: {
+ *      ids: // value for 'ids'
+ *   },
+ * });
+ */
+export declare function useBulkDeleteFilesMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.BulkDeleteFilesMutation, Types.BulkDeleteFilesMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.BulkDeleteFilesMutation, any, Apollo.ApolloCache, undefined>;
+export type BulkDeleteFilesMutationHookResult = ReturnType<typeof useBulkDeleteFilesMutation>;
+export type BulkDeleteFilesMutationResult = Apollo.MutationResult<Types.BulkDeleteFilesMutation>;
+export type BulkDeleteFilesMutationOptions = Apollo.BaseMutationOptions<Types.BulkDeleteFilesMutation, Types.BulkDeleteFilesMutationVariables>;
+export declare const BulkMoveFilesDocument: Apollo.DocumentNode;
+export type BulkMoveFilesMutationFn = Apollo.MutationFunction<Types.BulkMoveFilesMutation, Types.BulkMoveFilesMutationVariables>;
+/**
+ * __useBulkMoveFilesMutation__
+ *
+ * To run a mutation, you first call `useBulkMoveFilesMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useBulkMoveFilesMutation` 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 [bulkMoveFilesMutation, { data, loading, error }] = useBulkMoveFilesMutation({
+ *   variables: {
+ *      ids: // value for 'ids'
+ *      targetFolderId: // value for 'targetFolderId'
+ *   },
+ * });
+ */
+export declare function useBulkMoveFilesMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.BulkMoveFilesMutation, Types.BulkMoveFilesMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.BulkMoveFilesMutation, any, Apollo.ApolloCache, undefined>;
+export type BulkMoveFilesMutationHookResult = ReturnType<typeof useBulkMoveFilesMutation>;
+export type BulkMoveFilesMutationResult = Apollo.MutationResult<Types.BulkMoveFilesMutation>;
+export type BulkMoveFilesMutationOptions = Apollo.BaseMutationOptions<Types.BulkMoveFilesMutation, Types.BulkMoveFilesMutationVariables>;
+export declare const BulkPermanentlyDeleteFilesDocument: Apollo.DocumentNode;
+export type BulkPermanentlyDeleteFilesMutationFn = Apollo.MutationFunction<Types.BulkPermanentlyDeleteFilesMutation, Types.BulkPermanentlyDeleteFilesMutationVariables>;
+/**
+ * __useBulkPermanentlyDeleteFilesMutation__
+ *
+ * To run a mutation, you first call `useBulkPermanentlyDeleteFilesMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useBulkPermanentlyDeleteFilesMutation` 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 [bulkPermanentlyDeleteFilesMutation, { data, loading, error }] = useBulkPermanentlyDeleteFilesMutation({
+ *   variables: {
+ *      ids: // value for 'ids'
+ *   },
+ * });
+ */
+export declare function useBulkPermanentlyDeleteFilesMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.BulkPermanentlyDeleteFilesMutation, Types.BulkPermanentlyDeleteFilesMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.BulkPermanentlyDeleteFilesMutation, any, Apollo.ApolloCache, undefined>;
+export type BulkPermanentlyDeleteFilesMutationHookResult = ReturnType<typeof useBulkPermanentlyDeleteFilesMutation>;
+export type BulkPermanentlyDeleteFilesMutationResult = Apollo.MutationResult<Types.BulkPermanentlyDeleteFilesMutation>;
+export type BulkPermanentlyDeleteFilesMutationOptions = Apollo.BaseMutationOptions<Types.BulkPermanentlyDeleteFilesMutation, Types.BulkPermanentlyDeleteFilesMutationVariables>;
+export declare const BulkPermanentlyDeleteFoldersDocument: Apollo.DocumentNode;
+export type BulkPermanentlyDeleteFoldersMutationFn = Apollo.MutationFunction<Types.BulkPermanentlyDeleteFoldersMutation, Types.BulkPermanentlyDeleteFoldersMutationVariables>;
+/**
+ * __useBulkPermanentlyDeleteFoldersMutation__
+ *
+ * To run a mutation, you first call `useBulkPermanentlyDeleteFoldersMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useBulkPermanentlyDeleteFoldersMutation` 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 [bulkPermanentlyDeleteFoldersMutation, { data, loading, error }] = useBulkPermanentlyDeleteFoldersMutation({
+ *   variables: {
+ *      ids: // value for 'ids'
+ *   },
+ * });
+ */
+export declare function useBulkPermanentlyDeleteFoldersMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.BulkPermanentlyDeleteFoldersMutation, Types.BulkPermanentlyDeleteFoldersMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.BulkPermanentlyDeleteFoldersMutation, any, Apollo.ApolloCache, undefined>;
+export type BulkPermanentlyDeleteFoldersMutationHookResult = ReturnType<typeof useBulkPermanentlyDeleteFoldersMutation>;
+export type BulkPermanentlyDeleteFoldersMutationResult = Apollo.MutationResult<Types.BulkPermanentlyDeleteFoldersMutation>;
+export type BulkPermanentlyDeleteFoldersMutationOptions = Apollo.BaseMutationOptions<Types.BulkPermanentlyDeleteFoldersMutation, Types.BulkPermanentlyDeleteFoldersMutationVariables>;
+export declare const BulkUpdateVisibilityDocument: Apollo.DocumentNode;
+export type BulkUpdateVisibilityMutationFn = Apollo.MutationFunction<Types.BulkUpdateVisibilityMutation, Types.BulkUpdateVisibilityMutationVariables>;
+/**
+ * __useBulkUpdateVisibilityMutation__
+ *
+ * To run a mutation, you first call `useBulkUpdateVisibilityMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useBulkUpdateVisibilityMutation` 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 [bulkUpdateVisibilityMutation, { data, loading, error }] = useBulkUpdateVisibilityMutation({
+ *   variables: {
+ *      ids: // value for 'ids'
+ *      visibility: // value for 'visibility'
+ *   },
+ * });
+ */
+export declare function useBulkUpdateVisibilityMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.BulkUpdateVisibilityMutation, Types.BulkUpdateVisibilityMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.BulkUpdateVisibilityMutation, any, Apollo.ApolloCache, undefined>;
+export type BulkUpdateVisibilityMutationHookResult = ReturnType<typeof useBulkUpdateVisibilityMutation>;
+export type BulkUpdateVisibilityMutationResult = Apollo.MutationResult<Types.BulkUpdateVisibilityMutation>;
+export type BulkUpdateVisibilityMutationOptions = Apollo.BaseMutationOptions<Types.BulkUpdateVisibilityMutation, Types.BulkUpdateVisibilityMutationVariables>;
+export declare const CompleteUploadDocument: Apollo.DocumentNode;
+export type CompleteUploadMutationFn = Apollo.MutationFunction<Types.CompleteUploadMutation, Types.CompleteUploadMutationVariables>;
+/**
+ * __useCompleteUploadMutation__
+ *
+ * To run a mutation, you first call `useCompleteUploadMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCompleteUploadMutation` 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 [completeUploadMutation, { data, loading, error }] = useCompleteUploadMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCompleteUploadMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CompleteUploadMutation, Types.CompleteUploadMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CompleteUploadMutation, any, Apollo.ApolloCache, undefined>;
+export type CompleteUploadMutationHookResult = ReturnType<typeof useCompleteUploadMutation>;
+export type CompleteUploadMutationResult = Apollo.MutationResult<Types.CompleteUploadMutation>;
+export type CompleteUploadMutationOptions = Apollo.BaseMutationOptions<Types.CompleteUploadMutation, Types.CompleteUploadMutationVariables>;
+export declare const CopyFileDocument: Apollo.DocumentNode;
+export type CopyFileMutationFn = Apollo.MutationFunction<Types.CopyFileMutation, Types.CopyFileMutationVariables>;
+/**
+ * __useCopyFileMutation__
+ *
+ * To run a mutation, you first call `useCopyFileMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCopyFileMutation` 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 [copyFileMutation, { data, loading, error }] = useCopyFileMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      targetFolderId: // value for 'targetFolderId'
+ *      newName: // value for 'newName'
+ *   },
+ * });
+ */
+export declare function useCopyFileMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CopyFileMutation, Types.CopyFileMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CopyFileMutation, any, Apollo.ApolloCache, undefined>;
+export type CopyFileMutationHookResult = ReturnType<typeof useCopyFileMutation>;
+export type CopyFileMutationResult = Apollo.MutationResult<Types.CopyFileMutation>;
+export type CopyFileMutationOptions = Apollo.BaseMutationOptions<Types.CopyFileMutation, Types.CopyFileMutationVariables>;
+export declare const CreateFileVersionDocument: Apollo.DocumentNode;
+export type CreateFileVersionMutationFn = Apollo.MutationFunction<Types.CreateFileVersionMutation, Types.CreateFileVersionMutationVariables>;
+/**
+ * __useCreateFileVersionMutation__
+ *
+ * To run a mutation, you first call `useCreateFileVersionMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateFileVersionMutation` 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 [createFileVersionMutation, { data, loading, error }] = useCreateFileVersionMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateFileVersionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateFileVersionMutation, Types.CreateFileVersionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateFileVersionMutation, any, Apollo.ApolloCache, undefined>;
+export type CreateFileVersionMutationHookResult = ReturnType<typeof useCreateFileVersionMutation>;
+export type CreateFileVersionMutationResult = Apollo.MutationResult<Types.CreateFileVersionMutation>;
+export type CreateFileVersionMutationOptions = Apollo.BaseMutationOptions<Types.CreateFileVersionMutation, Types.CreateFileVersionMutationVariables>;
+export declare const CreateFolderDocument: Apollo.DocumentNode;
+export type CreateFolderMutationFn = Apollo.MutationFunction<Types.CreateFolderMutation, Types.CreateFolderMutationVariables>;
+/**
+ * __useCreateFolderMutation__
+ *
+ * To run a mutation, you first call `useCreateFolderMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateFolderMutation` 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 [createFolderMutation, { data, loading, error }] = useCreateFolderMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateFolderMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateFolderMutation, Types.CreateFolderMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateFolderMutation, any, Apollo.ApolloCache, undefined>;
+export type CreateFolderMutationHookResult = ReturnType<typeof useCreateFolderMutation>;
+export type CreateFolderMutationResult = Apollo.MutationResult<Types.CreateFolderMutation>;
+export type CreateFolderMutationOptions = Apollo.BaseMutationOptions<Types.CreateFolderMutation, Types.CreateFolderMutationVariables>;
+export declare const CreateFolderShareDocument: Apollo.DocumentNode;
+export type CreateFolderShareMutationFn = Apollo.MutationFunction<Types.CreateFolderShareMutation, Types.CreateFolderShareMutationVariables>;
+/**
+ * __useCreateFolderShareMutation__
+ *
+ * To run a mutation, you first call `useCreateFolderShareMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateFolderShareMutation` 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 [createFolderShareMutation, { data, loading, error }] = useCreateFolderShareMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateFolderShareMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateFolderShareMutation, Types.CreateFolderShareMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateFolderShareMutation, any, Apollo.ApolloCache, undefined>;
+export type CreateFolderShareMutationHookResult = ReturnType<typeof useCreateFolderShareMutation>;
+export type CreateFolderShareMutationResult = Apollo.MutationResult<Types.CreateFolderShareMutation>;
+export type CreateFolderShareMutationOptions = Apollo.BaseMutationOptions<Types.CreateFolderShareMutation, Types.CreateFolderShareMutationVariables>;
+export declare const CreateShareDocument: Apollo.DocumentNode;
+export type CreateShareMutationFn = Apollo.MutationFunction<Types.CreateShareMutation, Types.CreateShareMutationVariables>;
+/**
+ * __useCreateShareMutation__
+ *
+ * To run a mutation, you first call `useCreateShareMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateShareMutation` 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 [createShareMutation, { data, loading, error }] = useCreateShareMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateShareMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateShareMutation, Types.CreateShareMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateShareMutation, any, Apollo.ApolloCache, undefined>;
+export type CreateShareMutationHookResult = ReturnType<typeof useCreateShareMutation>;
+export type CreateShareMutationResult = Apollo.MutationResult<Types.CreateShareMutation>;
+export type CreateShareMutationOptions = Apollo.BaseMutationOptions<Types.CreateShareMutation, Types.CreateShareMutationVariables>;
+export declare const DeleteFileDocument: Apollo.DocumentNode;
+export type DeleteFileMutationFn = Apollo.MutationFunction<Types.DeleteFileMutation, Types.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 declare function useDeleteFileMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteFileMutation, Types.DeleteFileMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteFileMutation, any, Apollo.ApolloCache, undefined>;
+export type DeleteFileMutationHookResult = ReturnType<typeof useDeleteFileMutation>;
+export type DeleteFileMutationResult = Apollo.MutationResult<Types.DeleteFileMutation>;
+export type DeleteFileMutationOptions = Apollo.BaseMutationOptions<Types.DeleteFileMutation, Types.DeleteFileMutationVariables>;
+export declare const DeleteFileVersionDocument: Apollo.DocumentNode;
+export type DeleteFileVersionMutationFn = Apollo.MutationFunction<Types.DeleteFileVersionMutation, Types.DeleteFileVersionMutationVariables>;
+/**
+ * __useDeleteFileVersionMutation__
+ *
+ * To run a mutation, you first call `useDeleteFileVersionMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteFileVersionMutation` 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 [deleteFileVersionMutation, { data, loading, error }] = useDeleteFileVersionMutation({
+ *   variables: {
+ *      versionId: // value for 'versionId'
+ *   },
+ * });
+ */
+export declare function useDeleteFileVersionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteFileVersionMutation, Types.DeleteFileVersionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteFileVersionMutation, any, Apollo.ApolloCache, undefined>;
+export type DeleteFileVersionMutationHookResult = ReturnType<typeof useDeleteFileVersionMutation>;
+export type DeleteFileVersionMutationResult = Apollo.MutationResult<Types.DeleteFileVersionMutation>;
+export type DeleteFileVersionMutationOptions = Apollo.BaseMutationOptions<Types.DeleteFileVersionMutation, Types.DeleteFileVersionMutationVariables>;
+export declare const DeleteFolderDocument: Apollo.DocumentNode;
+export type DeleteFolderMutationFn = Apollo.MutationFunction<Types.DeleteFolderMutation, Types.DeleteFolderMutationVariables>;
+/**
+ * __useDeleteFolderMutation__
+ *
+ * To run a mutation, you first call `useDeleteFolderMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteFolderMutation` 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 [deleteFolderMutation, { data, loading, error }] = useDeleteFolderMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      recursive: // value for 'recursive'
+ *   },
+ * });
+ */
+export declare function useDeleteFolderMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteFolderMutation, Types.DeleteFolderMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteFolderMutation, any, Apollo.ApolloCache, undefined>;
+export type DeleteFolderMutationHookResult = ReturnType<typeof useDeleteFolderMutation>;
+export type DeleteFolderMutationResult = Apollo.MutationResult<Types.DeleteFolderMutation>;
+export type DeleteFolderMutationOptions = Apollo.BaseMutationOptions<Types.DeleteFolderMutation, Types.DeleteFolderMutationVariables>;
+export declare const InitiateUploadDocument: Apollo.DocumentNode;
+export type InitiateUploadMutationFn = Apollo.MutationFunction<Types.InitiateUploadMutation, Types.InitiateUploadMutationVariables>;
+/**
+ * __useInitiateUploadMutation__
+ *
+ * To run a mutation, you first call `useInitiateUploadMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useInitiateUploadMutation` 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 [initiateUploadMutation, { data, loading, error }] = useInitiateUploadMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useInitiateUploadMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.InitiateUploadMutation, Types.InitiateUploadMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.InitiateUploadMutation, any, Apollo.ApolloCache, undefined>;
+export type InitiateUploadMutationHookResult = ReturnType<typeof useInitiateUploadMutation>;
+export type InitiateUploadMutationResult = Apollo.MutationResult<Types.InitiateUploadMutation>;
+export type InitiateUploadMutationOptions = Apollo.BaseMutationOptions<Types.InitiateUploadMutation, Types.InitiateUploadMutationVariables>;
+export declare const MoveFileDocument: Apollo.DocumentNode;
+export type MoveFileMutationFn = Apollo.MutationFunction<Types.MoveFileMutation, Types.MoveFileMutationVariables>;
+/**
+ * __useMoveFileMutation__
+ *
+ * To run a mutation, you first call `useMoveFileMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useMoveFileMutation` 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 [moveFileMutation, { data, loading, error }] = useMoveFileMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useMoveFileMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.MoveFileMutation, Types.MoveFileMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.MoveFileMutation, any, Apollo.ApolloCache, undefined>;
+export type MoveFileMutationHookResult = ReturnType<typeof useMoveFileMutation>;
+export type MoveFileMutationResult = Apollo.MutationResult<Types.MoveFileMutation>;
+export type MoveFileMutationOptions = Apollo.BaseMutationOptions<Types.MoveFileMutation, Types.MoveFileMutationVariables>;
+export declare const MoveFolderDocument: Apollo.DocumentNode;
+export type MoveFolderMutationFn = Apollo.MutationFunction<Types.MoveFolderMutation, Types.MoveFolderMutationVariables>;
+/**
+ * __useMoveFolderMutation__
+ *
+ * To run a mutation, you first call `useMoveFolderMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useMoveFolderMutation` 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 [moveFolderMutation, { data, loading, error }] = useMoveFolderMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useMoveFolderMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.MoveFolderMutation, Types.MoveFolderMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.MoveFolderMutation, any, Apollo.ApolloCache, undefined>;
+export type MoveFolderMutationHookResult = ReturnType<typeof useMoveFolderMutation>;
+export type MoveFolderMutationResult = Apollo.MutationResult<Types.MoveFolderMutation>;
+export type MoveFolderMutationOptions = Apollo.BaseMutationOptions<Types.MoveFolderMutation, Types.MoveFolderMutationVariables>;
+export declare const PermanentlyDeleteFileDocument: Apollo.DocumentNode;
+export type PermanentlyDeleteFileMutationFn = Apollo.MutationFunction<Types.PermanentlyDeleteFileMutation, Types.PermanentlyDeleteFileMutationVariables>;
+/**
+ * __usePermanentlyDeleteFileMutation__
+ *
+ * To run a mutation, you first call `usePermanentlyDeleteFileMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `usePermanentlyDeleteFileMutation` 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 [permanentlyDeleteFileMutation, { data, loading, error }] = usePermanentlyDeleteFileMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function usePermanentlyDeleteFileMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.PermanentlyDeleteFileMutation, Types.PermanentlyDeleteFileMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.PermanentlyDeleteFileMutation, any, Apollo.ApolloCache, undefined>;
+export type PermanentlyDeleteFileMutationHookResult = ReturnType<typeof usePermanentlyDeleteFileMutation>;
+export type PermanentlyDeleteFileMutationResult = Apollo.MutationResult<Types.PermanentlyDeleteFileMutation>;
+export type PermanentlyDeleteFileMutationOptions = Apollo.BaseMutationOptions<Types.PermanentlyDeleteFileMutation, Types.PermanentlyDeleteFileMutationVariables>;
+export declare const PermanentlyDeleteFolderDocument: Apollo.DocumentNode;
+export type PermanentlyDeleteFolderMutationFn = Apollo.MutationFunction<Types.PermanentlyDeleteFolderMutation, Types.PermanentlyDeleteFolderMutationVariables>;
+/**
+ * __usePermanentlyDeleteFolderMutation__
+ *
+ * To run a mutation, you first call `usePermanentlyDeleteFolderMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `usePermanentlyDeleteFolderMutation` 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 [permanentlyDeleteFolderMutation, { data, loading, error }] = usePermanentlyDeleteFolderMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function usePermanentlyDeleteFolderMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.PermanentlyDeleteFolderMutation, Types.PermanentlyDeleteFolderMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.PermanentlyDeleteFolderMutation, any, Apollo.ApolloCache, undefined>;
+export type PermanentlyDeleteFolderMutationHookResult = ReturnType<typeof usePermanentlyDeleteFolderMutation>;
+export type PermanentlyDeleteFolderMutationResult = Apollo.MutationResult<Types.PermanentlyDeleteFolderMutation>;
+export type PermanentlyDeleteFolderMutationOptions = Apollo.BaseMutationOptions<Types.PermanentlyDeleteFolderMutation, Types.PermanentlyDeleteFolderMutationVariables>;
+export declare const RestoreFileDocument: Apollo.DocumentNode;
+export type RestoreFileMutationFn = Apollo.MutationFunction<Types.RestoreFileMutation, Types.RestoreFileMutationVariables>;
+/**
+ * __useRestoreFileMutation__
+ *
+ * To run a mutation, you first call `useRestoreFileMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRestoreFileMutation` 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 [restoreFileMutation, { data, loading, error }] = useRestoreFileMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useRestoreFileMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RestoreFileMutation, Types.RestoreFileMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RestoreFileMutation, any, Apollo.ApolloCache, undefined>;
+export type RestoreFileMutationHookResult = ReturnType<typeof useRestoreFileMutation>;
+export type RestoreFileMutationResult = Apollo.MutationResult<Types.RestoreFileMutation>;
+export type RestoreFileMutationOptions = Apollo.BaseMutationOptions<Types.RestoreFileMutation, Types.RestoreFileMutationVariables>;
+export declare const RestoreFileVersionDocument: Apollo.DocumentNode;
+export type RestoreFileVersionMutationFn = Apollo.MutationFunction<Types.RestoreFileVersionMutation, Types.RestoreFileVersionMutationVariables>;
+/**
+ * __useRestoreFileVersionMutation__
+ *
+ * To run a mutation, you first call `useRestoreFileVersionMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRestoreFileVersionMutation` 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 [restoreFileVersionMutation, { data, loading, error }] = useRestoreFileVersionMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useRestoreFileVersionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RestoreFileVersionMutation, Types.RestoreFileVersionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RestoreFileVersionMutation, any, Apollo.ApolloCache, undefined>;
+export type RestoreFileVersionMutationHookResult = ReturnType<typeof useRestoreFileVersionMutation>;
+export type RestoreFileVersionMutationResult = Apollo.MutationResult<Types.RestoreFileVersionMutation>;
+export type RestoreFileVersionMutationOptions = Apollo.BaseMutationOptions<Types.RestoreFileVersionMutation, Types.RestoreFileVersionMutationVariables>;
+export declare const RestoreFolderDocument: Apollo.DocumentNode;
+export type RestoreFolderMutationFn = Apollo.MutationFunction<Types.RestoreFolderMutation, Types.RestoreFolderMutationVariables>;
+/**
+ * __useRestoreFolderMutation__
+ *
+ * To run a mutation, you first call `useRestoreFolderMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRestoreFolderMutation` 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 [restoreFolderMutation, { data, loading, error }] = useRestoreFolderMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useRestoreFolderMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RestoreFolderMutation, Types.RestoreFolderMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RestoreFolderMutation, any, Apollo.ApolloCache, undefined>;
+export type RestoreFolderMutationHookResult = ReturnType<typeof useRestoreFolderMutation>;
+export type RestoreFolderMutationResult = Apollo.MutationResult<Types.RestoreFolderMutation>;
+export type RestoreFolderMutationOptions = Apollo.BaseMutationOptions<Types.RestoreFolderMutation, Types.RestoreFolderMutationVariables>;
+export declare const RevokeFolderShareDocument: Apollo.DocumentNode;
+export type RevokeFolderShareMutationFn = Apollo.MutationFunction<Types.RevokeFolderShareMutation, Types.RevokeFolderShareMutationVariables>;
+/**
+ * __useRevokeFolderShareMutation__
+ *
+ * To run a mutation, you first call `useRevokeFolderShareMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRevokeFolderShareMutation` 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 [revokeFolderShareMutation, { data, loading, error }] = useRevokeFolderShareMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useRevokeFolderShareMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RevokeFolderShareMutation, Types.RevokeFolderShareMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RevokeFolderShareMutation, any, Apollo.ApolloCache, undefined>;
+export type RevokeFolderShareMutationHookResult = ReturnType<typeof useRevokeFolderShareMutation>;
+export type RevokeFolderShareMutationResult = Apollo.MutationResult<Types.RevokeFolderShareMutation>;
+export type RevokeFolderShareMutationOptions = Apollo.BaseMutationOptions<Types.RevokeFolderShareMutation, Types.RevokeFolderShareMutationVariables>;
+export declare const RevokeShareDocument: Apollo.DocumentNode;
+export type RevokeShareMutationFn = Apollo.MutationFunction<Types.RevokeShareMutation, Types.RevokeShareMutationVariables>;
+/**
+ * __useRevokeShareMutation__
+ *
+ * To run a mutation, you first call `useRevokeShareMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRevokeShareMutation` 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 [revokeShareMutation, { data, loading, error }] = useRevokeShareMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useRevokeShareMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RevokeShareMutation, Types.RevokeShareMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RevokeShareMutation, any, Apollo.ApolloCache, undefined>;
+export type RevokeShareMutationHookResult = ReturnType<typeof useRevokeShareMutation>;
+export type RevokeShareMutationResult = Apollo.MutationResult<Types.RevokeShareMutation>;
+export type RevokeShareMutationOptions = Apollo.BaseMutationOptions<Types.RevokeShareMutation, Types.RevokeShareMutationVariables>;
+export declare const ToggleFileStarredDocument: Apollo.DocumentNode;
+export type ToggleFileStarredMutationFn = Apollo.MutationFunction<Types.ToggleFileStarredMutation, Types.ToggleFileStarredMutationVariables>;
+/**
+ * __useToggleFileStarredMutation__
+ *
+ * To run a mutation, you first call `useToggleFileStarredMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useToggleFileStarredMutation` 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 [toggleFileStarredMutation, { data, loading, error }] = useToggleFileStarredMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useToggleFileStarredMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ToggleFileStarredMutation, Types.ToggleFileStarredMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ToggleFileStarredMutation, any, Apollo.ApolloCache, undefined>;
+export type ToggleFileStarredMutationHookResult = ReturnType<typeof useToggleFileStarredMutation>;
+export type ToggleFileStarredMutationResult = Apollo.MutationResult<Types.ToggleFileStarredMutation>;
+export type ToggleFileStarredMutationOptions = Apollo.BaseMutationOptions<Types.ToggleFileStarredMutation, Types.ToggleFileStarredMutationVariables>;
+export declare const ToggleFolderStarredDocument: Apollo.DocumentNode;
+export type ToggleFolderStarredMutationFn = Apollo.MutationFunction<Types.ToggleFolderStarredMutation, Types.ToggleFolderStarredMutationVariables>;
+/**
+ * __useToggleFolderStarredMutation__
+ *
+ * To run a mutation, you first call `useToggleFolderStarredMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useToggleFolderStarredMutation` 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 [toggleFolderStarredMutation, { data, loading, error }] = useToggleFolderStarredMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useToggleFolderStarredMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ToggleFolderStarredMutation, Types.ToggleFolderStarredMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ToggleFolderStarredMutation, any, Apollo.ApolloCache, undefined>;
+export type ToggleFolderStarredMutationHookResult = ReturnType<typeof useToggleFolderStarredMutation>;
+export type ToggleFolderStarredMutationResult = Apollo.MutationResult<Types.ToggleFolderStarredMutation>;
+export type ToggleFolderStarredMutationOptions = Apollo.BaseMutationOptions<Types.ToggleFolderStarredMutation, Types.ToggleFolderStarredMutationVariables>;
+export declare const TrackShareDownloadDocument: Apollo.DocumentNode;
+export type TrackShareDownloadMutationFn = Apollo.MutationFunction<Types.TrackShareDownloadMutation, Types.TrackShareDownloadMutationVariables>;
+/**
+ * __useTrackShareDownloadMutation__
+ *
+ * To run a mutation, you first call `useTrackShareDownloadMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useTrackShareDownloadMutation` 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 [trackShareDownloadMutation, { data, loading, error }] = useTrackShareDownloadMutation({
+ *   variables: {
+ *      shareId: // value for 'shareId'
+ *   },
+ * });
+ */
+export declare function useTrackShareDownloadMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.TrackShareDownloadMutation, Types.TrackShareDownloadMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.TrackShareDownloadMutation, any, Apollo.ApolloCache, undefined>;
+export type TrackShareDownloadMutationHookResult = ReturnType<typeof useTrackShareDownloadMutation>;
+export type TrackShareDownloadMutationResult = Apollo.MutationResult<Types.TrackShareDownloadMutation>;
+export type TrackShareDownloadMutationOptions = Apollo.BaseMutationOptions<Types.TrackShareDownloadMutation, Types.TrackShareDownloadMutationVariables>;
+export declare const UpdateFileDocument: Apollo.DocumentNode;
+export type UpdateFileMutationFn = Apollo.MutationFunction<Types.UpdateFileMutation, Types.UpdateFileMutationVariables>;
+/**
+ * __useUpdateFileMutation__
+ *
+ * To run a mutation, you first call `useUpdateFileMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateFileMutation` 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 [updateFileMutation, { data, loading, error }] = useUpdateFileMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateFileMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateFileMutation, Types.UpdateFileMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateFileMutation, any, Apollo.ApolloCache, undefined>;
+export type UpdateFileMutationHookResult = ReturnType<typeof useUpdateFileMutation>;
+export type UpdateFileMutationResult = Apollo.MutationResult<Types.UpdateFileMutation>;
+export type UpdateFileMutationOptions = Apollo.BaseMutationOptions<Types.UpdateFileMutation, Types.UpdateFileMutationVariables>;
+export declare const UpdateFolderDocument: Apollo.DocumentNode;
+export type UpdateFolderMutationFn = Apollo.MutationFunction<Types.UpdateFolderMutation, Types.UpdateFolderMutationVariables>;
+/**
+ * __useUpdateFolderMutation__
+ *
+ * To run a mutation, you first call `useUpdateFolderMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateFolderMutation` 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 [updateFolderMutation, { data, loading, error }] = useUpdateFolderMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateFolderMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateFolderMutation, Types.UpdateFolderMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateFolderMutation, any, Apollo.ApolloCache, undefined>;
+export type UpdateFolderMutationHookResult = ReturnType<typeof useUpdateFolderMutation>;
+export type UpdateFolderMutationResult = Apollo.MutationResult<Types.UpdateFolderMutation>;
+export type UpdateFolderMutationOptions = Apollo.BaseMutationOptions<Types.UpdateFolderMutation, Types.UpdateFolderMutationVariables>;
+export declare const GetFilesBinPageDocument: Apollo.DocumentNode;
+/**
+ * __useGetFilesBinPageQuery__
+ *
+ * To run a query within a React component, call `useGetFilesBinPageQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetFilesBinPageQuery` 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 } = useGetFilesBinPageQuery({
+ *   variables: {
+ *      filePagination: // value for 'filePagination'
+ *      folderPagination: // value for 'folderPagination'
+ *   },
+ * });
+ */
+export declare function useGetFilesBinPageQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetFilesBinPageQuery, Types.GetFilesBinPageQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetFilesBinPageQuery, Types.GetFilesBinPageQueryVariables, "empty" | "complete" | "streaming", Types.GetFilesBinPageQueryVariables>;
+export declare function useGetFilesBinPageLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetFilesBinPageQuery, Types.GetFilesBinPageQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetFilesBinPageQuery, Types.GetFilesBinPageQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetFilesBinPageSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFilesBinPageQuery, Types.GetFilesBinPageQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFilesBinPageQuery, Types.GetFilesBinPageQueryVariables>;
+export declare function useGetFilesBinPageSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFilesBinPageQuery, Types.GetFilesBinPageQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFilesBinPageQuery | undefined, Types.GetFilesBinPageQueryVariables>;
+export type GetFilesBinPageQueryHookResult = ReturnType<typeof useGetFilesBinPageQuery>;
+export type GetFilesBinPageLazyQueryHookResult = ReturnType<typeof useGetFilesBinPageLazyQuery>;
+export type GetFilesBinPageSuspenseQueryHookResult = ReturnType<typeof useGetFilesBinPageSuspenseQuery>;
+export type GetFilesBinPageQueryResult = Apollo.QueryResult<Types.GetFilesBinPageQuery, Types.GetFilesBinPageQueryVariables>;
+export declare const GetFilesFolderBrowsePageDocument: Apollo.DocumentNode;
+/**
+ * __useGetFilesFolderBrowsePageQuery__
+ *
+ * To run a query within a React component, call `useGetFilesFolderBrowsePageQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetFilesFolderBrowsePageQuery` 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 } = useGetFilesFolderBrowsePageQuery({
+ *   variables: {
+ *      folderId: // value for 'folderId'
+ *      filePagination: // value for 'filePagination'
+ *      folderPagination: // value for 'folderPagination'
+ *   },
+ * });
+ */
+export declare function useGetFilesFolderBrowsePageQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetFilesFolderBrowsePageQuery, Types.GetFilesFolderBrowsePageQueryVariables> & ({
+    variables: Types.GetFilesFolderBrowsePageQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetFilesFolderBrowsePageQuery, Types.GetFilesFolderBrowsePageQueryVariables, "empty" | "complete" | "streaming", Types.GetFilesFolderBrowsePageQueryVariables>;
+export declare function useGetFilesFolderBrowsePageLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetFilesFolderBrowsePageQuery, Types.GetFilesFolderBrowsePageQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetFilesFolderBrowsePageQuery, Types.GetFilesFolderBrowsePageQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetFilesFolderBrowsePageSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFilesFolderBrowsePageQuery, Types.GetFilesFolderBrowsePageQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFilesFolderBrowsePageQuery, Types.GetFilesFolderBrowsePageQueryVariables>;
+export declare function useGetFilesFolderBrowsePageSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFilesFolderBrowsePageQuery, Types.GetFilesFolderBrowsePageQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFilesFolderBrowsePageQuery | undefined, Types.GetFilesFolderBrowsePageQueryVariables>;
+export type GetFilesFolderBrowsePageQueryHookResult = ReturnType<typeof useGetFilesFolderBrowsePageQuery>;
+export type GetFilesFolderBrowsePageLazyQueryHookResult = ReturnType<typeof useGetFilesFolderBrowsePageLazyQuery>;
+export type GetFilesFolderBrowsePageSuspenseQueryHookResult = ReturnType<typeof useGetFilesFolderBrowsePageSuspenseQuery>;
+export type GetFilesFolderBrowsePageQueryResult = Apollo.QueryResult<Types.GetFilesFolderBrowsePageQuery, Types.GetFilesFolderBrowsePageQueryVariables>;
+export declare const GetFilesRecentPageDocument: Apollo.DocumentNode;
+/**
+ * __useGetFilesRecentPageQuery__
+ *
+ * To run a query within a React component, call `useGetFilesRecentPageQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetFilesRecentPageQuery` 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 } = useGetFilesRecentPageQuery({
+ *   variables: {
+ *      filePagination: // value for 'filePagination'
+ *      folderPagination: // value for 'folderPagination'
+ *   },
+ * });
+ */
+export declare function useGetFilesRecentPageQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetFilesRecentPageQuery, Types.GetFilesRecentPageQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetFilesRecentPageQuery, Types.GetFilesRecentPageQueryVariables, "empty" | "complete" | "streaming", Types.GetFilesRecentPageQueryVariables>;
+export declare function useGetFilesRecentPageLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetFilesRecentPageQuery, Types.GetFilesRecentPageQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetFilesRecentPageQuery, Types.GetFilesRecentPageQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetFilesRecentPageSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFilesRecentPageQuery, Types.GetFilesRecentPageQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFilesRecentPageQuery, Types.GetFilesRecentPageQueryVariables>;
+export declare function useGetFilesRecentPageSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFilesRecentPageQuery, Types.GetFilesRecentPageQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFilesRecentPageQuery | undefined, Types.GetFilesRecentPageQueryVariables>;
+export type GetFilesRecentPageQueryHookResult = ReturnType<typeof useGetFilesRecentPageQuery>;
+export type GetFilesRecentPageLazyQueryHookResult = ReturnType<typeof useGetFilesRecentPageLazyQuery>;
+export type GetFilesRecentPageSuspenseQueryHookResult = ReturnType<typeof useGetFilesRecentPageSuspenseQuery>;
+export type GetFilesRecentPageQueryResult = Apollo.QueryResult<Types.GetFilesRecentPageQuery, Types.GetFilesRecentPageQueryVariables>;
+export declare const GetFilesRootBrowsePageDocument: Apollo.DocumentNode;
+/**
+ * __useGetFilesRootBrowsePageQuery__
+ *
+ * To run a query within a React component, call `useGetFilesRootBrowsePageQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetFilesRootBrowsePageQuery` 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 } = useGetFilesRootBrowsePageQuery({
+ *   variables: {
+ *      filePagination: // value for 'filePagination'
+ *      folderPagination: // value for 'folderPagination'
+ *   },
+ * });
+ */
+export declare function useGetFilesRootBrowsePageQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetFilesRootBrowsePageQuery, Types.GetFilesRootBrowsePageQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetFilesRootBrowsePageQuery, Types.GetFilesRootBrowsePageQueryVariables, "empty" | "complete" | "streaming", Types.GetFilesRootBrowsePageQueryVariables>;
+export declare function useGetFilesRootBrowsePageLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetFilesRootBrowsePageQuery, Types.GetFilesRootBrowsePageQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetFilesRootBrowsePageQuery, Types.GetFilesRootBrowsePageQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetFilesRootBrowsePageSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFilesRootBrowsePageQuery, Types.GetFilesRootBrowsePageQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFilesRootBrowsePageQuery, Types.GetFilesRootBrowsePageQueryVariables>;
+export declare function useGetFilesRootBrowsePageSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFilesRootBrowsePageQuery, Types.GetFilesRootBrowsePageQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFilesRootBrowsePageQuery | undefined, Types.GetFilesRootBrowsePageQueryVariables>;
+export type GetFilesRootBrowsePageQueryHookResult = ReturnType<typeof useGetFilesRootBrowsePageQuery>;
+export type GetFilesRootBrowsePageLazyQueryHookResult = ReturnType<typeof useGetFilesRootBrowsePageLazyQuery>;
+export type GetFilesRootBrowsePageSuspenseQueryHookResult = ReturnType<typeof useGetFilesRootBrowsePageSuspenseQuery>;
+export type GetFilesRootBrowsePageQueryResult = Apollo.QueryResult<Types.GetFilesRootBrowsePageQuery, Types.GetFilesRootBrowsePageQueryVariables>;
+export declare const GetFilesStarredPageDocument: Apollo.DocumentNode;
+/**
+ * __useGetFilesStarredPageQuery__
+ *
+ * To run a query within a React component, call `useGetFilesStarredPageQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetFilesStarredPageQuery` 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 } = useGetFilesStarredPageQuery({
+ *   variables: {
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useGetFilesStarredPageQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetFilesStarredPageQuery, Types.GetFilesStarredPageQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetFilesStarredPageQuery, Types.GetFilesStarredPageQueryVariables, "empty" | "complete" | "streaming", Types.GetFilesStarredPageQueryVariables>;
+export declare function useGetFilesStarredPageLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetFilesStarredPageQuery, Types.GetFilesStarredPageQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetFilesStarredPageQuery, Types.GetFilesStarredPageQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetFilesStarredPageSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFilesStarredPageQuery, Types.GetFilesStarredPageQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFilesStarredPageQuery, Types.GetFilesStarredPageQueryVariables>;
+export declare function useGetFilesStarredPageSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFilesStarredPageQuery, Types.GetFilesStarredPageQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFilesStarredPageQuery | undefined, Types.GetFilesStarredPageQueryVariables>;
+export type GetFilesStarredPageQueryHookResult = ReturnType<typeof useGetFilesStarredPageQuery>;
+export type GetFilesStarredPageLazyQueryHookResult = ReturnType<typeof useGetFilesStarredPageLazyQuery>;
+export type GetFilesStarredPageSuspenseQueryHookResult = ReturnType<typeof useGetFilesStarredPageSuspenseQuery>;
+export type GetFilesStarredPageQueryResult = Apollo.QueryResult<Types.GetFilesStarredPageQuery, Types.GetFilesStarredPageQueryVariables>;
+export declare const SearchFilesPageDocument: Apollo.DocumentNode;
+/**
+ * __useSearchFilesPageQuery__
+ *
+ * To run a query within a React component, call `useSearchFilesPageQuery` and pass it any options that fit your needs.
+ * When your component renders, `useSearchFilesPageQuery` 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 } = useSearchFilesPageQuery({
+ *   variables: {
+ *      query: // value for 'query'
+ *      fileFilter: // value for 'fileFilter'
+ *      folderFilter: // value for 'folderFilter'
+ *      filePagination: // value for 'filePagination'
+ *      folderPagination: // value for 'folderPagination'
+ *   },
+ * });
+ */
+export declare function useSearchFilesPageQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.SearchFilesPageQuery, Types.SearchFilesPageQueryVariables> & ({
+    variables: Types.SearchFilesPageQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.SearchFilesPageQuery, Types.SearchFilesPageQueryVariables, "empty" | "complete" | "streaming", Types.SearchFilesPageQueryVariables>;
+export declare function useSearchFilesPageLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.SearchFilesPageQuery, Types.SearchFilesPageQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.SearchFilesPageQuery, Types.SearchFilesPageQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useSearchFilesPageSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.SearchFilesPageQuery, Types.SearchFilesPageQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.SearchFilesPageQuery, Types.SearchFilesPageQueryVariables>;
+export declare function useSearchFilesPageSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.SearchFilesPageQuery, Types.SearchFilesPageQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.SearchFilesPageQuery | undefined, Types.SearchFilesPageQueryVariables>;
+export type SearchFilesPageQueryHookResult = ReturnType<typeof useSearchFilesPageQuery>;
+export type SearchFilesPageLazyQueryHookResult = ReturnType<typeof useSearchFilesPageLazyQuery>;
+export type SearchFilesPageSuspenseQueryHookResult = ReturnType<typeof useSearchFilesPageSuspenseQuery>;
+export type SearchFilesPageQueryResult = Apollo.QueryResult<Types.SearchFilesPageQuery, Types.SearchFilesPageQueryVariables>;
+export declare const GetFileDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useGetFileQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetFileQuery, Types.GetFileQueryVariables> & ({
+    variables: Types.GetFileQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetFileQuery, Types.GetFileQueryVariables, "empty" | "complete" | "streaming", Types.GetFileQueryVariables>;
+export declare function useGetFileLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetFileQuery, Types.GetFileQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetFileQuery, Types.GetFileQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetFileSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFileQuery, Types.GetFileQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFileQuery, Types.GetFileQueryVariables>;
+export declare function useGetFileSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFileQuery, Types.GetFileQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFileQuery | undefined, Types.GetFileQueryVariables>;
+export type GetFileQueryHookResult = ReturnType<typeof useGetFileQuery>;
+export type GetFileLazyQueryHookResult = ReturnType<typeof useGetFileLazyQuery>;
+export type GetFileSuspenseQueryHookResult = ReturnType<typeof useGetFileSuspenseQuery>;
+export type GetFileQueryResult = Apollo.QueryResult<Types.GetFileQuery, Types.GetFileQueryVariables>;
+export declare const GetFileVersionDownloadUrlDocument: Apollo.DocumentNode;
+/**
+ * __useGetFileVersionDownloadUrlQuery__
+ *
+ * To run a query within a React component, call `useGetFileVersionDownloadUrlQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetFileVersionDownloadUrlQuery` 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 } = useGetFileVersionDownloadUrlQuery({
+ *   variables: {
+ *      versionId: // value for 'versionId'
+ *      expiresIn: // value for 'expiresIn'
+ *   },
+ * });
+ */
+export declare function useGetFileVersionDownloadUrlQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetFileVersionDownloadUrlQuery, Types.GetFileVersionDownloadUrlQueryVariables> & ({
+    variables: Types.GetFileVersionDownloadUrlQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetFileVersionDownloadUrlQuery, Types.GetFileVersionDownloadUrlQueryVariables, "empty" | "complete" | "streaming", Types.GetFileVersionDownloadUrlQueryVariables>;
+export declare function useGetFileVersionDownloadUrlLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetFileVersionDownloadUrlQuery, Types.GetFileVersionDownloadUrlQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetFileVersionDownloadUrlQuery, Types.GetFileVersionDownloadUrlQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetFileVersionDownloadUrlSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFileVersionDownloadUrlQuery, Types.GetFileVersionDownloadUrlQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFileVersionDownloadUrlQuery, Types.GetFileVersionDownloadUrlQueryVariables>;
+export declare function useGetFileVersionDownloadUrlSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFileVersionDownloadUrlQuery, Types.GetFileVersionDownloadUrlQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFileVersionDownloadUrlQuery | undefined, Types.GetFileVersionDownloadUrlQueryVariables>;
+export type GetFileVersionDownloadUrlQueryHookResult = ReturnType<typeof useGetFileVersionDownloadUrlQuery>;
+export type GetFileVersionDownloadUrlLazyQueryHookResult = ReturnType<typeof useGetFileVersionDownloadUrlLazyQuery>;
+export type GetFileVersionDownloadUrlSuspenseQueryHookResult = ReturnType<typeof useGetFileVersionDownloadUrlSuspenseQuery>;
+export type GetFileVersionDownloadUrlQueryResult = Apollo.QueryResult<Types.GetFileVersionDownloadUrlQuery, Types.GetFileVersionDownloadUrlQueryVariables>;
+export declare const GetFileVersionsDocument: Apollo.DocumentNode;
+/**
+ * __useGetFileVersionsQuery__
+ *
+ * To run a query within a React component, call `useGetFileVersionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetFileVersionsQuery` 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 } = useGetFileVersionsQuery({
+ *   variables: {
+ *      fileId: // value for 'fileId'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useGetFileVersionsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetFileVersionsQuery, Types.GetFileVersionsQueryVariables> & ({
+    variables: Types.GetFileVersionsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetFileVersionsQuery, Types.GetFileVersionsQueryVariables, "empty" | "complete" | "streaming", Types.GetFileVersionsQueryVariables>;
+export declare function useGetFileVersionsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetFileVersionsQuery, Types.GetFileVersionsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetFileVersionsQuery, Types.GetFileVersionsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetFileVersionsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFileVersionsQuery, Types.GetFileVersionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFileVersionsQuery, Types.GetFileVersionsQueryVariables>;
+export declare function useGetFileVersionsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFileVersionsQuery, Types.GetFileVersionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFileVersionsQuery | undefined, Types.GetFileVersionsQueryVariables>;
+export type GetFileVersionsQueryHookResult = ReturnType<typeof useGetFileVersionsQuery>;
+export type GetFileVersionsLazyQueryHookResult = ReturnType<typeof useGetFileVersionsLazyQuery>;
+export type GetFileVersionsSuspenseQueryHookResult = ReturnType<typeof useGetFileVersionsSuspenseQuery>;
+export type GetFileVersionsQueryResult = Apollo.QueryResult<Types.GetFileVersionsQuery, Types.GetFileVersionsQueryVariables>;
+export declare const GetFilesDocument: Apollo.DocumentNode;
+/**
+ * __useGetFilesQuery__
+ *
+ * To run a query within a React component, call `useGetFilesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetFilesQuery` 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 } = useGetFilesQuery({
+ *   variables: {
+ *      folderId: // value for 'folderId'
+ *      filter: // value for 'filter'
+ *      sort: // value for 'sort'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useGetFilesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetFilesQuery, Types.GetFilesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetFilesQuery, Types.GetFilesQueryVariables, "empty" | "complete" | "streaming", Types.GetFilesQueryVariables>;
+export declare function useGetFilesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetFilesQuery, Types.GetFilesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetFilesQuery, Types.GetFilesQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetFilesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFilesQuery, Types.GetFilesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFilesQuery, Types.GetFilesQueryVariables>;
+export declare function useGetFilesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFilesQuery, Types.GetFilesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFilesQuery | undefined, Types.GetFilesQueryVariables>;
+export type GetFilesQueryHookResult = ReturnType<typeof useGetFilesQuery>;
+export type GetFilesLazyQueryHookResult = ReturnType<typeof useGetFilesLazyQuery>;
+export type GetFilesSuspenseQueryHookResult = ReturnType<typeof useGetFilesSuspenseQuery>;
+export type GetFilesQueryResult = Apollo.QueryResult<Types.GetFilesQuery, Types.GetFilesQueryVariables>;
+export declare const GetFolderDocument: Apollo.DocumentNode;
+/**
+ * __useGetFolderQuery__
+ *
+ * To run a query within a React component, call `useGetFolderQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetFolderQuery` 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 } = useGetFolderQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetFolderQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetFolderQuery, Types.GetFolderQueryVariables> & ({
+    variables: Types.GetFolderQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetFolderQuery, Types.GetFolderQueryVariables, "empty" | "complete" | "streaming", Types.GetFolderQueryVariables>;
+export declare function useGetFolderLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetFolderQuery, Types.GetFolderQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetFolderQuery, Types.GetFolderQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetFolderSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFolderQuery, Types.GetFolderQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFolderQuery, Types.GetFolderQueryVariables>;
+export declare function useGetFolderSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFolderQuery, Types.GetFolderQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFolderQuery | undefined, Types.GetFolderQueryVariables>;
+export type GetFolderQueryHookResult = ReturnType<typeof useGetFolderQuery>;
+export type GetFolderLazyQueryHookResult = ReturnType<typeof useGetFolderLazyQuery>;
+export type GetFolderSuspenseQueryHookResult = ReturnType<typeof useGetFolderSuspenseQuery>;
+export type GetFolderQueryResult = Apollo.QueryResult<Types.GetFolderQuery, Types.GetFolderQueryVariables>;
+export declare const GetFolderPathDocument: Apollo.DocumentNode;
+/**
+ * __useGetFolderPathQuery__
+ *
+ * To run a query within a React component, call `useGetFolderPathQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetFolderPathQuery` 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 } = useGetFolderPathQuery({
+ *   variables: {
+ *      folderId: // value for 'folderId'
+ *   },
+ * });
+ */
+export declare function useGetFolderPathQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetFolderPathQuery, Types.GetFolderPathQueryVariables> & ({
+    variables: Types.GetFolderPathQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetFolderPathQuery, Types.GetFolderPathQueryVariables, "empty" | "complete" | "streaming", Types.GetFolderPathQueryVariables>;
+export declare function useGetFolderPathLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetFolderPathQuery, Types.GetFolderPathQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetFolderPathQuery, Types.GetFolderPathQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetFolderPathSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFolderPathQuery, Types.GetFolderPathQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFolderPathQuery, Types.GetFolderPathQueryVariables>;
+export declare function useGetFolderPathSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFolderPathQuery, Types.GetFolderPathQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFolderPathQuery | undefined, Types.GetFolderPathQueryVariables>;
+export type GetFolderPathQueryHookResult = ReturnType<typeof useGetFolderPathQuery>;
+export type GetFolderPathLazyQueryHookResult = ReturnType<typeof useGetFolderPathLazyQuery>;
+export type GetFolderPathSuspenseQueryHookResult = ReturnType<typeof useGetFolderPathSuspenseQuery>;
+export type GetFolderPathQueryResult = Apollo.QueryResult<Types.GetFolderPathQuery, Types.GetFolderPathQueryVariables>;
+export declare const GetFoldersDocument: Apollo.DocumentNode;
+/**
+ * __useGetFoldersQuery__
+ *
+ * To run a query within a React component, call `useGetFoldersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetFoldersQuery` 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 } = useGetFoldersQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useGetFoldersQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetFoldersQuery, Types.GetFoldersQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetFoldersQuery, Types.GetFoldersQueryVariables, "empty" | "complete" | "streaming", Types.GetFoldersQueryVariables>;
+export declare function useGetFoldersLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetFoldersQuery, Types.GetFoldersQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetFoldersQuery, Types.GetFoldersQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetFoldersSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFoldersQuery, Types.GetFoldersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFoldersQuery, Types.GetFoldersQueryVariables>;
+export declare function useGetFoldersSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFoldersQuery, Types.GetFoldersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFoldersQuery | undefined, Types.GetFoldersQueryVariables>;
+export type GetFoldersQueryHookResult = ReturnType<typeof useGetFoldersQuery>;
+export type GetFoldersLazyQueryHookResult = ReturnType<typeof useGetFoldersLazyQuery>;
+export type GetFoldersSuspenseQueryHookResult = ReturnType<typeof useGetFoldersSuspenseQuery>;
+export type GetFoldersQueryResult = Apollo.QueryResult<Types.GetFoldersQuery, Types.GetFoldersQueryVariables>;
+export declare const GetSharedWithMeDocument: Apollo.DocumentNode;
+/**
+ * __useGetSharedWithMeQuery__
+ *
+ * To run a query within a React component, call `useGetSharedWithMeQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetSharedWithMeQuery` 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 } = useGetSharedWithMeQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetSharedWithMeQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetSharedWithMeQuery, Types.GetSharedWithMeQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetSharedWithMeQuery, Types.GetSharedWithMeQueryVariables, "empty" | "complete" | "streaming", Types.GetSharedWithMeQueryVariables>;
+export declare function useGetSharedWithMeLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetSharedWithMeQuery, Types.GetSharedWithMeQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetSharedWithMeQuery, Types.GetSharedWithMeQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetSharedWithMeSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSharedWithMeQuery, Types.GetSharedWithMeQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSharedWithMeQuery, Types.GetSharedWithMeQueryVariables>;
+export declare function useGetSharedWithMeSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSharedWithMeQuery, Types.GetSharedWithMeQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSharedWithMeQuery | undefined, Types.GetSharedWithMeQueryVariables>;
+export type GetSharedWithMeQueryHookResult = ReturnType<typeof useGetSharedWithMeQuery>;
+export type GetSharedWithMeLazyQueryHookResult = ReturnType<typeof useGetSharedWithMeLazyQuery>;
+export type GetSharedWithMeSuspenseQueryHookResult = ReturnType<typeof useGetSharedWithMeSuspenseQuery>;
+export type GetSharedWithMeQueryResult = Apollo.QueryResult<Types.GetSharedWithMeQuery, Types.GetSharedWithMeQueryVariables>;
+export declare const GetSharesForFolderDocument: Apollo.DocumentNode;
+/**
+ * __useGetSharesForFolderQuery__
+ *
+ * To run a query within a React component, call `useGetSharesForFolderQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetSharesForFolderQuery` 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 } = useGetSharesForFolderQuery({
+ *   variables: {
+ *      folderId: // value for 'folderId'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useGetSharesForFolderQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetSharesForFolderQuery, Types.GetSharesForFolderQueryVariables> & ({
+    variables: Types.GetSharesForFolderQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetSharesForFolderQuery, Types.GetSharesForFolderQueryVariables, "empty" | "complete" | "streaming", Types.GetSharesForFolderQueryVariables>;
+export declare function useGetSharesForFolderLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetSharesForFolderQuery, Types.GetSharesForFolderQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetSharesForFolderQuery, Types.GetSharesForFolderQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetSharesForFolderSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSharesForFolderQuery, Types.GetSharesForFolderQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSharesForFolderQuery, Types.GetSharesForFolderQueryVariables>;
+export declare function useGetSharesForFolderSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSharesForFolderQuery, Types.GetSharesForFolderQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSharesForFolderQuery | undefined, Types.GetSharesForFolderQueryVariables>;
+export type GetSharesForFolderQueryHookResult = ReturnType<typeof useGetSharesForFolderQuery>;
+export type GetSharesForFolderLazyQueryHookResult = ReturnType<typeof useGetSharesForFolderLazyQuery>;
+export type GetSharesForFolderSuspenseQueryHookResult = ReturnType<typeof useGetSharesForFolderSuspenseQuery>;
+export type GetSharesForFolderQueryResult = Apollo.QueryResult<Types.GetSharesForFolderQuery, Types.GetSharesForFolderQueryVariables>;
+export declare const GetUserSharesDocument: Apollo.DocumentNode;
+/**
+ * __useGetUserSharesQuery__
+ *
+ * To run a query within a React component, call `useGetUserSharesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetUserSharesQuery` 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 } = useGetUserSharesQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetUserSharesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetUserSharesQuery, Types.GetUserSharesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetUserSharesQuery, Types.GetUserSharesQueryVariables, "empty" | "complete" | "streaming", Types.GetUserSharesQueryVariables>;
+export declare function useGetUserSharesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetUserSharesQuery, Types.GetUserSharesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetUserSharesQuery, Types.GetUserSharesQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetUserSharesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetUserSharesQuery, Types.GetUserSharesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetUserSharesQuery, Types.GetUserSharesQueryVariables>;
+export declare function useGetUserSharesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetUserSharesQuery, Types.GetUserSharesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetUserSharesQuery | undefined, Types.GetUserSharesQueryVariables>;
+export type GetUserSharesQueryHookResult = ReturnType<typeof useGetUserSharesQuery>;
+export type GetUserSharesLazyQueryHookResult = ReturnType<typeof useGetUserSharesLazyQuery>;
+export type GetUserSharesSuspenseQueryHookResult = ReturnType<typeof useGetUserSharesSuspenseQuery>;
+export type GetUserSharesQueryResult = Apollo.QueryResult<Types.GetUserSharesQuery, Types.GetUserSharesQueryVariables>;
+export declare const GetUserStorageUsageDocument: Apollo.DocumentNode;
+/**
+ * __useGetUserStorageUsageQuery__
+ *
+ * To run a query within a React component, call `useGetUserStorageUsageQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetUserStorageUsageQuery` 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 } = useGetUserStorageUsageQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetUserStorageUsageQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetUserStorageUsageQuery, Types.GetUserStorageUsageQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetUserStorageUsageQuery, Types.GetUserStorageUsageQueryVariables, "empty" | "complete" | "streaming", Types.GetUserStorageUsageQueryVariables>;
+export declare function useGetUserStorageUsageLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetUserStorageUsageQuery, Types.GetUserStorageUsageQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetUserStorageUsageQuery, Types.GetUserStorageUsageQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetUserStorageUsageSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetUserStorageUsageQuery, Types.GetUserStorageUsageQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetUserStorageUsageQuery, Types.GetUserStorageUsageQueryVariables>;
+export declare function useGetUserStorageUsageSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetUserStorageUsageQuery, Types.GetUserStorageUsageQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetUserStorageUsageQuery | undefined, Types.GetUserStorageUsageQueryVariables>;
+export type GetUserStorageUsageQueryHookResult = ReturnType<typeof useGetUserStorageUsageQuery>;
+export type GetUserStorageUsageLazyQueryHookResult = ReturnType<typeof useGetUserStorageUsageLazyQuery>;
+export type GetUserStorageUsageSuspenseQueryHookResult = ReturnType<typeof useGetUserStorageUsageSuspenseQuery>;
+export type GetUserStorageUsageQueryResult = Apollo.QueryResult<Types.GetUserStorageUsageQuery, Types.GetUserStorageUsageQueryVariables>;
+export declare const GetWorkspaceStorageStatusDocument: Apollo.DocumentNode;
+/**
+ * __useGetWorkspaceStorageStatusQuery__
+ *
+ * To run a query within a React component, call `useGetWorkspaceStorageStatusQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkspaceStorageStatusQuery` 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 } = useGetWorkspaceStorageStatusQuery({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *   },
+ * });
+ */
+export declare function useGetWorkspaceStorageStatusQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetWorkspaceStorageStatusQuery, Types.GetWorkspaceStorageStatusQueryVariables> & ({
+    variables: Types.GetWorkspaceStorageStatusQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetWorkspaceStorageStatusQuery, Types.GetWorkspaceStorageStatusQueryVariables, "empty" | "complete" | "streaming", Types.GetWorkspaceStorageStatusQueryVariables>;
+export declare function useGetWorkspaceStorageStatusLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetWorkspaceStorageStatusQuery, Types.GetWorkspaceStorageStatusQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetWorkspaceStorageStatusQuery, Types.GetWorkspaceStorageStatusQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetWorkspaceStorageStatusSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspaceStorageStatusQuery, Types.GetWorkspaceStorageStatusQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspaceStorageStatusQuery, Types.GetWorkspaceStorageStatusQueryVariables>;
+export declare function useGetWorkspaceStorageStatusSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspaceStorageStatusQuery, Types.GetWorkspaceStorageStatusQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspaceStorageStatusQuery | undefined, Types.GetWorkspaceStorageStatusQueryVariables>;
+export type GetWorkspaceStorageStatusQueryHookResult = ReturnType<typeof useGetWorkspaceStorageStatusQuery>;
+export type GetWorkspaceStorageStatusLazyQueryHookResult = ReturnType<typeof useGetWorkspaceStorageStatusLazyQuery>;
+export type GetWorkspaceStorageStatusSuspenseQueryHookResult = ReturnType<typeof useGetWorkspaceStorageStatusSuspenseQuery>;
+export type GetWorkspaceStorageStatusQueryResult = Apollo.QueryResult<Types.GetWorkspaceStorageStatusQuery, Types.GetWorkspaceStorageStatusQueryVariables>;
+//# sourceMappingURL=wspace-operations.d.ts.map