/**
 * Centralized dependency imports for Onebox.
 */
import * as path from 'node:path';
import * as nodeFs from 'node:fs';
import * as nodeHttps from 'node:https';
import * as nodeHttp from 'node:http';
import * as nodeNet from 'node:net';
import * as nodeOs from 'node:os';
import * as nodeCrypto from 'node:crypto';
import * as nodeStream from 'node:stream';
import * as nodeUrl from 'node:url';
export { path, nodeFs, nodeHttps, nodeHttp, nodeNet, nodeOs, nodeCrypto, nodeStream, nodeUrl };
export declare const fs: {
    mkdir: typeof nodeFs.promises.mkdir;
    mkdtemp: typeof nodeFs.promises.mkdtemp;
    readFile: typeof nodeFs.promises.readFile;
    writeFile: typeof nodeFs.promises.writeFile;
    rename: typeof nodeFs.promises.rename;
    stat: (filePathArg: string) => Promise<{
        size: number;
        isFile: boolean;
        isDirectory: boolean;
        isSymlink: boolean;
        isBlockDevice(): boolean;
        isCharacterDevice(): boolean;
        isSymbolicLink(): boolean;
        isFIFO(): boolean;
        isSocket(): boolean;
        dev: number;
        ino: number;
        mode: number;
        nlink: number;
        uid: number;
        gid: number;
        rdev: number;
        blksize: number;
        blocks: number;
        atimeMs: number;
        mtimeMs: number;
        ctimeMs: number;
        birthtimeMs: number;
        atime: Date;
        mtime: Date;
        ctime: Date;
        birthtime: Date;
    }>;
    remove: (filePathArg: string, optionsArg?: {
        recursive?: boolean;
    }) => Promise<void>;
    readTextFile: (filePathArg: string) => Promise<string>;
    writeTextFile: (filePathArg: string, dataArg: string) => Promise<void>;
    readDir: (dirPathArg: string) => AsyncGenerator<{
        name: string;
        isFile: boolean;
        isDirectory: boolean;
        isSymlink: boolean;
    }, void, unknown>;
};
export declare const encoding: {
    encodeBase64: (dataArg: Uint8Array | string) => string;
    decodeBase64: (dataArg: string) => Uint8Array<ArrayBuffer>;
};
export declare const crypto: Crypto;
export declare const isNotFoundError: (errorArg: unknown) => boolean;
export declare const isAlreadyExistsError: (errorArg: unknown) => boolean;
export interface ICommandOptions {
    args?: string[];
    stdin?: 'null' | 'piped' | 'inherit';
    stdout?: 'piped' | 'inherit' | 'null';
    stderr?: 'piped' | 'inherit' | 'null';
    input?: Uint8Array | string;
}
export interface ICommandOutput {
    code: number;
    success: boolean;
    stdout: Uint8Array;
    stderr: Uint8Array;
}
export declare const runCommand: (commandArg: string, optionsArg?: ICommandOptions) => Promise<ICommandOutput>;
import * as smartdb from '@push.rocks/smartdb';
import * as smartdata from '@push.rocks/smartdata';
import * as smartacme from '@push.rocks/smartacme';
import * as smartregistry from '@push.rocks/smartregistry';
import * as smartstorage from '@push.rocks/smartstorage';
import * as taskbuffer from '@push.rocks/taskbuffer';
import * as smartguard from '@push.rocks/smartguard';
import * as smartjwt from '@push.rocks/smartjwt';
import * as smartmcp from '@push.rocks/smartmcp';
export { smartdb, smartdata, smartacme, smartregistry, smartstorage, taskbuffer, smartguard, smartjwt, smartmcp };
import * as typedrequest from '@api.global/typedrequest';
import * as typedrequestInterfaces from '@api.global/typedrequest-interfaces';
import * as typedserver from '@api.global/typedserver';
export { typedrequest, typedrequestInterfaces, typedserver };
import * as simplewebauthnServer from '@simplewebauthn/server';
export { simplewebauthnServer };
import { DockerHost } from '@apiclient.xyz/docker';
export declare const docker: {
    Docker: typeof DockerHost;
};
import * as cloudflare from '@apiclient.xyz/cloudflare';
export { cloudflare };
import { S3Client, ListObjectsV2Command, GetObjectCommand, PutObjectCommand } from '@aws-sdk/client-s3';
export declare const awsS3: {
    S3Client: typeof S3Client;
    ListObjectsV2Command: typeof ListObjectsV2Command;
    GetObjectCommand: typeof GetObjectCommand;
    PutObjectCommand: typeof PutObjectCommand;
};
import { ContainerArchive } from '@serve.zone/containerarchive';
export { ContainerArchive };
import * as servezoneInterfaces from '@serve.zone/interfaces';
import * as servezoneAppstore from '@serve.zone/appstore';
export { servezoneInterfaces, servezoneAppstore };
