Class SecrecyCloudClient

new SecrecyCloudClient(client: SecrecyClient): SecrecyCloudClient

addDataToHistory(
    __namedParameters: { dataId: string; nodeId: string },
): Promise<NodeFull>

checkAccesses(
    input: Omit<
        RouterInputs["cloud"]["checkAccesses"],
        "fromIdentityPubKey",
    >,
): Promise<{} | {}>

createFolder(
    __namedParameters: { name: string; parentFolderId?: string | null },
): Promise<NodeFull>

createPublicDataLink(input: {} & {}): Promise<{}>

dataContent(
    __namedParameters: {
        dataId: string;
        onDownloadProgress?: (progress: Progress) => void;
        progressDecrypt?: ProgressCallback;
        signal?: AbortSignal;
    },
): Promise<LocalData>

dataContents(
    __namedParameters: {
        dataIds: string[];
        onDownloadProgress?: (progress: Progress) => void;
        progressDecrypt?: ProgressCallback;
        signal?: AbortSignal;
    },
): Promise<LocalData[]>

dataMetadata(__namedParameters: { id: string }): Promise<DataMetadata>

deleteData(
    __namedParameters: { dataId: string; nodeId: string },
): Promise<boolean>

deletedNodes(): Promise<Node<NodeBreadcrumbItem, Record<string, unknown>>[]>

deleteNode(__namedParameters: { nodeId: string }): Promise<boolean>

deleteNodeCloudTrash(__namedParameters: { ids: string[] }): Promise<boolean>

deleteNodes(
    __namedParameters: { nodeIds: string[] },
): Promise<{ count: number }>

deleteNodeSharing(
    __namedParameters: { destPubKey: string; nodeId: string },
): Promise<boolean>

deletePublicDataLink(input: {}): Promise<{}>

downloadDataFromLink(
    input: DownloadDataFromLinkOptions,
): Promise<Uint8Array<ArrayBuffer>>

duplicateNode(
    __namedParameters: {
        folderId?: string | null;
        name?: string | null;
        nodeId: string;
    },
): Promise<boolean>

emptyTrash(): Promise<boolean>

getPublicDataLink(input: {}): Promise<{}>

getPublicDataLinks(input: {}): Promise<{}[]>

leaveNodeSharing(
    __namedParameters: { nodeId: string; sharedByPubKey: string },
): Promise<boolean>

moveNodes(
    __namedParameters: { nodeIds: string[]; parentNodeId?: string | null },
): Promise<boolean>

node(
    __namedParameters?: { deleted?: boolean | null; id?: string | null },
): Promise<Node<NodeBreadcrumbItem, Record<string, unknown>>>

nodeFull(
    __namedParameters?: { deleted?: boolean | null; id?: string | null },
): Promise<NodeFull>

nodes(
    __namedParameters: { deleted?: boolean | null; ids: string[] },
): Promise<
    {
        errors: { message: string; nodeId: string }[];
        nodes: Node<NodeBreadcrumbItem, Record<string, unknown>>[];
    },
>

nodesFull(
    __namedParameters: { deleted?: boolean | null; ids: string[] },
): Promise<
    { errors: { message: string; nodeId: string }[]; nodes: NodeFull[] },
>

nodesSharedWithMe(
    type?: "FILE" | "FOLDER",
): Promise<Node<NodeBreadcrumbItem, Record<string, unknown>>[]>

recoverNode(id: string): Promise<boolean>

reportData(
    __namedParameters: Omit<
        RouterInputs["cloud"]["reportData"],
        "encryptedDataKey",
    >,
): Promise<{}>

saveInCloud(
    __namedParameters: { dataId: string; name: string; nodeId?: string },
): Promise<NodeFull>

sharedNodes(): Promise<Node<NodeBreadcrumbItem, Record<string, unknown>>[]>

shareNode(
    accesses: ({} & {} & {})[] | {} & {} & {} | {} & {} & {} | {} & {} & {},
    progress?: ProgressCallback,
): Promise<{} | {}>

updateDataStorageType(input: {}): Promise<{}>

updateNode(
    __namedParameters: {
        deletedAt?: Date | null;
        isFavorite?: boolean | null;
        name?: string | null;
        nodeId: string;
    },
): Promise<NodeFull>

updatePublicDataLink(input: {} & {}): Promise<{}>

uploadData(
    opts: UploadDataOptions,
): Promise<
    LocalData & {
        sharing: { encryptedDataKey: string; password: string }
        | null;
    },
>

uploadDataInCloud(
    __namedParameters: {
        data: Uint8Array<ArrayBuffer> | File;
        encryptProgress?: ProgressCallback;
        name: string;
        nodeId?: string;
        signal?: AbortSignal;
        storageType?: "s3" | "cold" | "lite";
        uploadProgress?: ProgressCallback;
    },
): Promise<NodeFull>