@lossless.org/objectstorage 9.0.0

package/dist_ts/index.d.ts

@@ -0,0 +1,741 @@
+import * as plugins from './plugins.js';
+/**
+ * Authentication configuration
+ */
+export interface IStorageCredential {
+    accessKeyId: string;
+    secretAccessKey: string;
+    bucketName?: string;
+    region?: string;
+}
+export interface IStorageCredentialMetadata {
+    accessKeyId: string;
+    bucketName?: string;
+    region?: string;
+}
+/**
+ * Authentication configuration
+ */
+export interface IAuthConfig {
+    enabled: boolean;
+    credentials: IStorageCredential[];
+}
+/**
+ * CORS configuration
+ */
+export interface ICorsConfig {
+    enabled: boolean;
+    allowedOrigins?: string[];
+    allowedMethods?: string[];
+    allowedHeaders?: string[];
+    exposedHeaders?: string[];
+    maxAge?: number;
+    allowCredentials?: boolean;
+}
+/**
+ * Logging configuration
+ */
+export interface ILoggingConfig {
+    level?: 'error' | 'warn' | 'info' | 'debug';
+    format?: 'text' | 'json';
+    enabled?: boolean;
+}
+/**
+ * Request limits configuration
+ */
+export interface ILimitsConfig {
+    maxObjectSize?: number;
+    maxMetadataSize?: number;
+    requestTimeout?: number;
+}
+/**
+ * Multipart upload configuration
+ */
+export interface IMultipartConfig {
+    expirationDays?: number;
+    cleanupIntervalMinutes?: number;
+}
+/**
+ * Server configuration
+ */
+export interface IServerConfig {
+    port?: number;
+    address?: string;
+    silent?: boolean;
+    region?: string;
+}
+/**
+ * Storage configuration
+ */
+export interface ILocalFilesystemStoragePoolBackend {
+    kind: 'localFs';
+}
+export interface IMountedFilesystemStoragePoolBackend {
+    kind: 'mountedFs';
+    expectedFilesystemType: 'nfs' | 'smb';
+    expectedSource: string;
+}
+export type TStoragePoolBackend = ILocalFilesystemStoragePoolBackend | IMountedFilesystemStoragePoolBackend;
+export interface IStoragePoolConfig {
+    id: string;
+    directory: string;
+    backend: TStoragePoolBackend;
+}
+export interface IMountedStoragePoolConfig extends IStoragePoolConfig {
+    backend: IMountedFilesystemStoragePoolBackend;
+}
+export interface IStorageConfig {
+    directory?: string;
+    cleanSlate?: boolean;
+    /**
+     * One ObjectStorage process serves one pool. `directory` remains as a
+     * compatibility alias and must resolve to the same path when both are set.
+     */
+    pool?: IStoragePoolConfig;
+}
+/**
+ * Erasure coding configuration
+ */
+export interface IErasureConfig {
+    dataShards?: number;
+    parityShards?: number;
+    chunkSizeBytes?: number;
+}
+/**
+ * Drive configuration for multi-drive support
+ */
+export interface IDriveConfig {
+    paths: string[];
+}
+/**
+ * Cluster configuration for distributed mode
+ */
+export interface IClusterConfig {
+    enabled: boolean;
+    nodeId?: string;
+    quicPort?: number;
+    seedNodes?: string[];
+    erasure?: IErasureConfig;
+    drives?: IDriveConfig;
+    heartbeatIntervalMs?: number;
+    heartbeatTimeoutMs?: number;
+}
+/**
+ * Complete objectstorage configuration
+ */
+export interface IObjectStorageConfig {
+    server?: IServerConfig;
+    storage?: IStorageConfig;
+    auth?: IAuthConfig;
+    cors?: ICorsConfig;
+    logging?: ILoggingConfig;
+    limits?: ILimitsConfig;
+    multipart?: IMultipartConfig;
+    cluster?: IClusterConfig;
+}
+/**
+ * Logical bucket stats maintained by the Rust runtime.
+ * Values are initialized from native storage on startup and updated on objectstorage mutations.
+ */
+export interface IBucketSummary {
+    name: string;
+    objectCount: number;
+    totalSizeBytes: number;
+    creationDate?: number;
+}
+/**
+ * Filesystem-level capacity snapshot for the storage directory or configured drive path.
+ */
+export interface IStorageLocationSummary {
+    path: string;
+    totalBytes?: number;
+    availableBytes?: number;
+    usedBytes?: number;
+    pool?: IStoragePoolObservation;
+}
+export type TStoragePoolCheckStatus = 'passed' | 'failed' | 'notRun' | 'notApplicable';
+export interface IStoragePoolCheck {
+    status: TStoragePoolCheckStatus;
+    reason?: string;
+}
+export interface IStoragePoolChecks {
+    directoryExists: IStoragePoolCheck;
+    exactMount: IStoragePoolCheck;
+    filesystemType: IStoragePoolCheck;
+    source: IStoragePoolCheck;
+    symlinkConfinement: IStoragePoolCheck;
+    remoteLocking: IStoragePoolCheck;
+    rootOwnership: IStoragePoolCheck;
+    sameFilesystem: IStoragePoolCheck;
+    lockContention: IStoragePoolCheck;
+    atomicDirectoryExchange: IStoragePoolCheck;
+    directoryFsync: IStoragePoolCheck;
+    providerIdentity: IStoragePoolCheck;
+    mountStable: IStoragePoolCheck;
+}
+export interface IStoragePoolFilesystemObservation {
+    filesystemType?: string;
+    source?: string;
+    mountPoint?: string;
+    mountId?: number;
+    device?: string;
+    networkBacked: boolean;
+    blockSizeBytes?: number;
+    readSizeBytes?: number;
+    writeSizeBytes?: number;
+    symlinkFollowingDisabled?: boolean;
+    remoteLockingMode?: 'serverCoordinated' | 'disabled' | 'localOnly' | 'unrecognized' | 'notApplicable';
+}
+export type TStoragePoolFailureCode = 'pathUnavailable' | 'mountInfoInvalid' | 'exactMountRequired' | 'filesystemTypeMismatch' | 'sourceMismatch' | 'mountChanged' | 'descriptorMismatch' | 'filesystemMagicMismatch' | 'symlinkFollowingAllowed' | 'lockingModeUnsafe' | 'activationPoisoned';
+export interface IStoragePoolObservation {
+    schemaVersion: 1;
+    poolId: string;
+    directory: string;
+    role: 'controlAndBlob';
+    backendKind: 'localFs' | 'mountedFs';
+    filesystem: IStoragePoolFilesystemObservation;
+    checks: IStoragePoolChecks;
+    supported: boolean | null;
+    productionEligible: boolean;
+    activationValid?: boolean;
+    poisoned?: boolean;
+    poisonReason?: string;
+    failure?: {
+        code: TStoragePoolFailureCode;
+        message: string;
+    };
+}
+/**
+ * Runtime storage stats served by the Rust core without issuing S3 list calls.
+ */
+export interface IStorageStats {
+    bucketCount: number;
+    totalObjectCount: number;
+    totalStorageBytes: number;
+    buckets: IBucketSummary[];
+    storageDirectory: string;
+    storageLocations?: IStorageLocationSummary[];
+}
+export interface IStorageStopResult {
+    complete: true;
+    terminalError?: string;
+}
+export interface IBucketTenantInput {
+    bucketName: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    region?: string;
+    retention?: IBucketRetentionPolicyInput;
+}
+export interface IEnsureBucketTenantInput {
+    bucketName: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    region?: string;
+    retention?: IBucketRetentionPolicyInput;
+    fence?: IObjectStorageResourceFence;
+}
+export interface IDeleteBucketTenantInput {
+    bucketName: string;
+    accessKeyId?: string;
+}
+export interface IBucketTenantMetadata {
+    bucketName: string;
+    accessKeyId: string;
+    region?: string;
+    retention?: IBucketRetentionReceipt;
+}
+export interface IBucketRetentionPolicyInput {
+    mode: 'compliance';
+    policyId: string;
+    retentionDurationSeconds: number;
+}
+export interface IObjectRetentionReceipt {
+    mode: 'compliance';
+    policyId: string;
+    retentionDurationSeconds: number;
+    createdAt: number;
+    retainUntil: number;
+    payloadSha256: string;
+    metadataSha256: string;
+    etag: string;
+}
+export interface IBucketRetentionReceipt extends IBucketRetentionPolicyInput {
+    bucketName: string;
+    configuredAt: number;
+    sentinelKey: string;
+    sentinel: IObjectRetentionReceipt;
+}
+export interface IBucketRetentionCapability {
+    version: 1;
+    supported: boolean;
+    backend: 'standalone' | 'clustered';
+    modes: 'compliance'[];
+    atomicCreateOnly: boolean;
+    retainedMultipartSupported: false;
+}
+export interface IObjectStorageMigrationBinding {
+    migrationId: string;
+    authorityId: string;
+    logicalBucket: string;
+    sourceProviderIdentitySha256: string;
+    destinationProviderIdentitySha256: string;
+    destinationReceiptPublicKeyEd25519: string;
+}
+export type TObjectStorageSourceMigrationPhase = 'active' | 'sealed' | 'cutoverCommitted' | 'retired' | 'released';
+export type TObjectStorageDestinationMigrationPhase = 'holding' | 'verified' | 'cutoverAuthorized' | 'published' | 'aborted';
+export type TObjectStorageMigrationPhase = {
+    role: 'source';
+    phase: TObjectStorageSourceMigrationPhase;
+} | {
+    role: 'destination';
+    phase: TObjectStorageDestinationMigrationPhase;
+};
+export interface IObjectStorageMigrationCreateInput {
+    binding: IObjectStorageMigrationBinding;
+    fenceToken: number;
+    opaqueCapability: string;
+    /** Required for source creation; omitted for destination creation. */
+    sourceCleanupAccessKeyId?: string;
+}
+export interface IObjectStorageMigrationTerminalReceipt {
+    version: 1;
+    kind: 'smartstorage.bucket-migration.terminal-receipt.standalone-v1';
+    binding: IObjectStorageMigrationBinding;
+    providerIdentitySha256: string;
+    fenceToken: number;
+    requestDigestSha256: string;
+    phase: TObjectStorageMigrationPhase;
+    manifestDigestSha256?: string;
+    counterpartTerminalReceiptSha256?: string;
+    signingPublicKeyEd25519: string;
+    signatureEd25519: string;
+    receiptSha256: string;
+}
+export interface IObjectStorageMigrationTransitionReceipt {
+    version: 1;
+    kind: 'smartstorage.bucket-migration.transition-receipt.standalone-v1';
+    binding: IObjectStorageMigrationBinding;
+    providerIdentitySha256: string;
+    fenceToken: number;
+    requestDigestSha256: string;
+    phase: TObjectStorageMigrationPhase;
+    manifestDigestSha256?: string;
+    terminalReceiptSha256?: string;
+    receiptSha256: string;
+}
+export interface IObjectStorageSourceMigrationTransitionInput {
+    binding: IObjectStorageMigrationBinding;
+    fenceToken: number;
+    opaqueCapability: string;
+    targetPhase: Exclude<TObjectStorageSourceMigrationPhase, 'active'>;
+    manifestDigestSha256?: string;
+    destinationAbortReceipt?: IObjectStorageMigrationTerminalReceipt;
+}
+export interface IObjectStorageDestinationMigrationTransitionInput {
+    binding: IObjectStorageMigrationBinding;
+    fenceToken: number;
+    opaqueCapability: string;
+    targetPhase: Exclude<TObjectStorageDestinationMigrationPhase, 'holding'>;
+    manifestDigestSha256?: string;
+}
+export interface IObjectStorageSourceMigrationCleanupInput {
+    binding: IObjectStorageMigrationBinding;
+    cleanupFenceToken: number;
+    opaqueCapability: string;
+    sourceRetiredReceiptSha256: string;
+    destinationPublishedReceipt: IObjectStorageMigrationTerminalReceipt;
+    resourceFence: IObjectStorageResourceFence;
+    accessKeyId: string;
+}
+export interface IObjectStorageSourceMigrationCleanupReceipt {
+    version: 1;
+    kind: 'smartstorage.bucket-migration.source-cleanup-receipt.standalone-v1';
+    binding: IObjectStorageMigrationBinding;
+    providerIdentitySha256: string;
+    cleanupFenceToken: number;
+    requestDigestSha256: string;
+    sourceRetiredReceiptSha256: string;
+    destinationPublishedReceiptSha256: string;
+    resourceFenceScopeId: string;
+    resourceFenceToken: number;
+    resourceFenceMutationId: string;
+    resourceFencePayloadSha256: string;
+    accessKeyIdSha256: string;
+    deleteResultSha256: string;
+    receiptSha256: string;
+}
+export interface IObjectStorageSourceMigrationCleanupInspection {
+    phase: 'requested' | 'completed';
+    cleanupFenceToken: number;
+    requestDigestSha256: string;
+    sourceRetiredReceiptSha256: string;
+    destinationPublishedReceipt: IObjectStorageMigrationTerminalReceipt;
+    resourceFence: IObjectStorageResourceFence;
+    accessKeyIdSha256: string;
+    deleteResultSha256?: string;
+    receipt?: IObjectStorageSourceMigrationCleanupReceipt;
+}
+export interface IObjectStorageMigrationInspection {
+    binding: IObjectStorageMigrationBinding;
+    providerIdentitySha256: string;
+    highestFenceToken: number;
+    requestDigestSha256: string;
+    phase: TObjectStorageMigrationPhase;
+    manifestDigestSha256?: string;
+    boundDestinationAbortReceipt?: IObjectStorageMigrationTerminalReceipt;
+    terminalReceipt?: IObjectStorageMigrationTerminalReceipt;
+    lastReceipt: IObjectStorageMigrationTransitionReceipt;
+    sourceCleanupAccessKeyIdSha256?: string;
+    sourceCleanup?: IObjectStorageSourceMigrationCleanupInspection;
+}
+export interface IObjectStorageBucketMigrationCapability {
+    version: 1;
+    supported: boolean;
+    backend: 'standalone' | 'clustered';
+    providerIdentitySha256?: string;
+    receiptPublicKeyEd25519?: string;
+    sourceSealDrainsMutations: boolean;
+    sourceReadsRemainAvailableWhileSealed: boolean;
+    destinationPublicationRequiresControllerCredentialHold: true;
+    sourceRetirementCleanupSupported: boolean;
+    sourceRetirementCleanupControllerRetryRequired: true;
+    sourceRetirementCleanupAutomaticStartupDeletion: false;
+    reason?: string;
+}
+export interface IBucketTenantDescriptor extends plugins.tsclass.storage.IS3Descriptor {
+    endpoint: string;
+    port: number;
+    region: string;
+    bucket: string;
+    bucketName: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    accessKey: string;
+    accessSecret: string;
+    useSsl: boolean;
+    ssl: boolean;
+    env: Record<string, string>;
+    /** Present when ensureBucketTenant completed under a resource fence. */
+    resourceFence?: IObjectStorageResourceFenceReceipt;
+    /** Engine-verified immutable-retention evidence when configured for the bucket. */
+    retention?: IBucketRetentionReceipt;
+}
+export interface IBucketExportObject {
+    key: string;
+    size: number;
+    md5: string;
+    metadata: Record<string, string>;
+    dataHex: string;
+}
+export interface IBucketExport {
+    format: 'smartstorage.bucket.v1';
+    bucketName: string;
+    exportedAt: number;
+    objects: IBucketExportObject[];
+}
+export interface IObjectStorageReplaceEffectivePayloadV1 {
+    version: 1;
+    kind: 'smartstorage.bucket.replace.v1';
+    bucketName: string;
+    accessKeyId?: string;
+    /** Request a durable write-publication barrier after provider replacement. */
+    holdPublication?: boolean;
+    source: IBucketExport;
+}
+export interface IObjectStorageExactDeleteEffectivePayloadV1 {
+    version: 1;
+    kind: 'smartstorage.bucket.delete.v1';
+    bucketName: string;
+    accessKeyId: string;
+    /** Request a durable write-publication barrier after provider deletion. */
+    holdPublication?: boolean;
+}
+export interface IObjectStorageEnsureEffectivePayloadV1 {
+    version: 1;
+    kind: 'smartstorage.bucket.ensure.v1';
+    bucketName: string;
+    accessKeyId: string;
+    /** Hashed before it is incorporated into the effective payload digest. */
+    secretAccessKey: string;
+    /** The effective region applied by the provider. */
+    region: string;
+    /** Optional immutable-retention intent applied as part of the fenced ensure. */
+    retention?: IBucketRetentionPolicyInput;
+}
+export type TObjectStorageResourceFenceEffectivePayloadV1 = IObjectStorageReplaceEffectivePayloadV1 | IObjectStorageExactDeleteEffectivePayloadV1 | IObjectStorageEnsureEffectivePayloadV1;
+/**
+ * Computes the canonical provider-side effective payload digest for resource
+ * fencing v1. This intentionally excludes backup timestamps and source bucket
+ * names, matching the Rust engine's replacement and exact-delete profiles.
+ */
+export declare const computeObjectStorageResourceFenceEffectivePayloadSha256V1: (payloadArg: TObjectStorageResourceFenceEffectivePayloadV1) => string;
+export interface IExportBucketInput {
+    bucketName: string;
+}
+export interface IImportBucketInput {
+    bucketName: string;
+    source: IBucketExport;
+    /** Exact exclusive bucket credential required by the fenced replacement. */
+    accessKeyId?: string;
+    fence?: IObjectStorageResourceFence;
+    /** Keep target writes closed until commitResourcePublication succeeds. */
+    holdPublication?: boolean;
+}
+export interface IDeleteBucketInput {
+    bucketName: string;
+    /**
+     * Exact bucket-scoped credential to revoke. When supplied, the access key
+     * is included in the durable mutation identity and retries treat an already
+     * absent key as a successful idempotent revocation. Omitting it retains the
+     * legacy data-only deletion behavior that preserves credentials and policy.
+     */
+    accessKeyId?: string;
+    fence: IObjectStorageResourceFence;
+    /** Keep target writes closed until commitResourcePublication succeeds. */
+    holdPublication?: boolean;
+}
+export interface IObjectStorageResourceFence {
+    version: 1;
+    scopeId: string;
+    token: number;
+    mutationId: string;
+    payloadSha256: string;
+}
+export interface IObjectStorageResourceFenceReceipt extends IObjectStorageResourceFence {
+    kind: 'smartstorage.bucket.replace.v1' | 'smartstorage.bucket.delete.v1' | 'smartstorage.bucket.ensure.v1';
+    effectivePayloadSha256: string;
+}
+export interface IObjectStorageResourcePublicationBarrier {
+    version: 1;
+    kind: 'smartstorage.bucket.write-publication.v1';
+    providerRootIdentitySha256: string;
+    bucketName: string;
+    resourceIdSha256: string;
+    scopeId: string;
+    token: number;
+    mutationId: string;
+    mutationKind: 'smartstorage.bucket.replace.v1' | 'smartstorage.bucket.delete.v1';
+    payloadSha256: string;
+    effectivePayloadSha256: string;
+    mutationReceiptSha256: string;
+    /** Opaque CSPRNG capability. Never log or persist outside protected control state. */
+    commitCapability: string;
+}
+export interface IObjectStorageResourcePublicationReleaseReceipt {
+    version: 1;
+    kind: 'smartstorage.bucket.write-publication.release.v1';
+    providerRootIdentitySha256: string;
+    bucketName: string;
+    resourceIdSha256: string;
+    scopeId: string;
+    token: number;
+    mutationId: string;
+    mutationKind: 'smartstorage.bucket.replace.v1' | 'smartstorage.bucket.delete.v1';
+    payloadSha256: string;
+    effectivePayloadSha256: string;
+    mutationReceiptSha256: string;
+    barrierSha256: string;
+}
+export interface ICommitObjectStorageResourcePublicationInput {
+    barrier: IObjectStorageResourcePublicationBarrier;
+    resourceFenceReceipt: IObjectStorageResourceFenceReceipt;
+}
+export interface IObjectStorageBucketMutationResult {
+    bucketName: string;
+    objects?: number;
+    totalBytes?: number;
+    bucketDeleted?: boolean;
+    /**
+     * Credentials removed during the completing attempt. A crash-recovery
+     * retry can report zero after the exact credential was already persisted
+     * as absent.
+     */
+    deletedCredentials?: number;
+    credentialsPreserved?: boolean;
+    policyPreserved?: boolean;
+    resourceFence?: IObjectStorageResourceFenceReceipt;
+    resourcePublicationBarrier?: IObjectStorageResourcePublicationBarrier;
+    resourcePublicationRelease?: IObjectStorageResourcePublicationReleaseReceipt;
+}
+export interface IObjectStorageResourceFencingCapability {
+    version: 1;
+    supported: boolean;
+    requiresDrain: true;
+    publicationHoldVersion: 1;
+    publicationHoldSupported: boolean;
+    publicationHoldRequiresExternalDrain: false;
+    reason?: string;
+}
+export interface IObjectStorageHealth {
+    ok: boolean;
+    running: boolean;
+    storageDirectory: string;
+    storageLocations?: IStorageLocationSummary[];
+    auth: {
+        enabled: boolean;
+        credentialCount: number;
+        tenantCredentialCount: number;
+    };
+    bucketCount: number;
+    objectCount: number;
+    totalBytes: number;
+    cluster: IClusterHealth;
+    resourceFencingVersion: 1;
+    resourceFencingSupported: boolean;
+    resourceFencingRequiresDrain: true;
+    resourcePublicationHoldVersion: 1;
+    resourcePublicationHoldSupported: boolean;
+    resourcePublicationHoldRequiresExternalDrain: false;
+    resourceFencingReason?: string;
+}
+export declare const objectStorageResourceFenceErrorCodes: readonly ["EFENCE_REQUIRED", "EFENCE_STALE", "EFENCE_SCOPE_MISMATCH", "EFENCE_UNSUPPORTED", "EFENCE_MUTATION_MISMATCH", "EFENCE_STATE_CORRUPT", "EFENCE_RECEIPT_LIMIT", "EFENCE_BUSY", "EFENCE_OWNERSHIP_MISMATCH", "EFENCE_PUBLICATION_HELD", "EFENCE_PUBLICATION_MISMATCH", "EFENCE_PUBLICATION_CAPABILITY"];
+export type TObjectStorageResourceFenceErrorCode = (typeof objectStorageResourceFenceErrorCodes)[number];
+export declare class ObjectStorageResourceFenceError extends Error {
+    readonly code: TObjectStorageResourceFenceErrorCode;
+    constructor(codeArg: TObjectStorageResourceFenceErrorCode, messageArg: string, causeArg?: unknown);
+}
+export interface IObjectStorageMetrics {
+    bucketCount: number;
+    objectCount: number;
+    totalBytes: number;
+    authCredentialCount: number;
+    tenantCredentialCount: number;
+    clusterEnabled: boolean;
+    prometheusText: string;
+}
+/**
+ * Known peer status from the local node's current cluster view.
+ */
+export interface IClusterPeerHealth {
+    nodeId: string;
+    status: 'online' | 'suspect' | 'offline';
+    quicAddress?: string;
+    s3Address?: string;
+    driveCount?: number;
+    lastHeartbeat?: number;
+    missedHeartbeats?: number;
+}
+/**
+ * Local drive health as measured by objectstorage's runtime probes.
+ */
+export interface IClusterDriveHealth {
+    index: number;
+    path: string;
+    status: 'online' | 'degraded' | 'offline' | 'healing';
+    totalBytes?: number;
+    usedBytes?: number;
+    availableBytes?: number;
+    errorCount?: number;
+    lastError?: string;
+    lastCheck?: number;
+    erasureSetId?: number;
+}
+export interface IClusterErasureHealth {
+    dataShards: number;
+    parityShards: number;
+    chunkSizeBytes: number;
+    totalShards: number;
+    readQuorum: number;
+    writeQuorum: number;
+    erasureSetCount: number;
+}
+export interface IClusterRepairHealth {
+    active: boolean;
+    scanIntervalMs?: number;
+    lastRunStartedAt?: number;
+    lastRunCompletedAt?: number;
+    lastDurationMs?: number;
+    shardsChecked?: number;
+    shardsHealed?: number;
+    failed?: number;
+    lastError?: string;
+}
+/**
+ * Cluster runtime health from the Rust core.
+ * When clustering is disabled, the response is `{ enabled: false }`.
+ */
+export interface IClusterHealth {
+    enabled: boolean;
+    nodeId?: string;
+    quorumHealthy?: boolean;
+    majorityHealthy?: boolean;
+    peers?: IClusterPeerHealth[];
+    drives?: IClusterDriveHealth[];
+    erasure?: IClusterErasureHealth;
+    repairs?: IClusterRepairHealth;
+}
+/**
+ * Main ObjectStorage class - production-ready S3-compatible storage server
+ */
+export declare class ObjectStorage {
+    static createAndStart(configArg?: IObjectStorageConfig): Promise<ObjectStorage>;
+    static probeStoragePool(poolArg: IMountedStoragePoolConfig): Promise<IStoragePoolObservation>;
+    config: Required<IObjectStorageConfig>;
+    private localBinaryPaths;
+    private bridge;
+    private running;
+    private completedStopResult;
+    private startPromise;
+    private stopPromise;
+    private bridgeOwned;
+    private stopRequested;
+    private stopCompleted;
+    constructor(configArg?: IObjectStorageConfig);
+    private ensureLocalBinariesExecutable;
+    start(): Promise<void>;
+    private startInternal;
+    getStorageDescriptor(optionsArg?: Partial<plugins.tsclass.storage.IS3Descriptor>): Promise<plugins.tsclass.storage.IS3Descriptor>;
+    private getEndpoint;
+    private buildBucketTenantDescriptor;
+    private assertTenantAuthEnabled;
+    createBucket(bucketNameArg: string): Promise<{
+        name: string;
+    }>;
+    createBucketTenant(tenantArg: IBucketTenantInput): Promise<IBucketTenantDescriptor>;
+    ensureBucketTenant(tenantArg: IEnsureBucketTenantInput): Promise<IBucketTenantDescriptor>;
+    deleteBucketTenant(tenantArg: IDeleteBucketTenantInput): Promise<void>;
+    rotateBucketTenantCredentials(tenantArg: IBucketTenantInput): Promise<IBucketTenantDescriptor>;
+    listBucketTenants(): Promise<IBucketTenantMetadata[]>;
+    getBucketTenantDescriptor(optionsArg: {
+        bucketName: string;
+    }): Promise<IBucketTenantDescriptor>;
+    getBucketRetentionCapability(): Promise<IBucketRetentionCapability>;
+    getBucketRetentionReceipt(optionsArg: {
+        bucketName: string;
+    }): Promise<IBucketRetentionReceipt | null>;
+    getBucketMigrationCapability(): Promise<IObjectStorageBucketMigrationCapability>;
+    createSourceMigration(optionsArg: IObjectStorageMigrationCreateInput): Promise<IObjectStorageMigrationTransitionReceipt>;
+    createDestinationMigration(optionsArg: IObjectStorageMigrationCreateInput): Promise<IObjectStorageMigrationTransitionReceipt>;
+    transitionSourceMigration(optionsArg: IObjectStorageSourceMigrationTransitionInput): Promise<IObjectStorageMigrationTransitionReceipt>;
+    transitionDestinationMigration(optionsArg: IObjectStorageDestinationMigrationTransitionInput): Promise<IObjectStorageMigrationTransitionReceipt>;
+    cleanupSourceMigration(optionsArg: IObjectStorageSourceMigrationCleanupInput): Promise<IObjectStorageSourceMigrationCleanupReceipt>;
+    inspectBucketMigration(optionsArg: {
+        migrationId: string;
+    }): Promise<IObjectStorageMigrationInspection | null>;
+    exportBucket(optionsArg: IExportBucketInput): Promise<IBucketExport>;
+    importBucket(optionsArg: IImportBucketInput): Promise<IObjectStorageBucketMutationResult>;
+    deleteBucket(optionsArg: IDeleteBucketInput): Promise<IObjectStorageBucketMutationResult>;
+    commitResourcePublication(optionsArg: ICommitObjectStorageResourcePublicationInput): Promise<IObjectStorageResourcePublicationReleaseReceipt>;
+    getResourceFencingCapability(): Promise<IObjectStorageResourceFencingCapability>;
+    getStorageStats(): Promise<IStorageStats>;
+    getStoragePoolDiagnostic(): Promise<IStoragePoolObservation | null>;
+    listBucketSummaries(): Promise<IBucketSummary[]>;
+    listCredentials(): Promise<IStorageCredentialMetadata[]>;
+    /**
+     * Trusted process-local administrative override. Resource lifecycle code
+     * must use fenced ensure/delete instead; completed exact receipts fail closed
+     * if this override introduces ownership or credential-material drift.
+     */
+    replaceCredentials(credentials: IStorageCredential[]): Promise<void>;
+    getClusterHealth(): Promise<IClusterHealth>;
+    getHealth(): Promise<IObjectStorageHealth>;
+    getMetrics(): Promise<IObjectStorageMetrics>;
+    /**
+     * Retains the Rust bridge when shutdown is incomplete so a later call can
+     * retry ownership draining. Completed terminal errors kill the bridge before
+     * they are rethrown.
+     */
+    stop(): Promise<void>;
+    private stopInternal;
+}