import { ActionProcedureDescriptor } from '@voltro/protocol';
import { MutationProcedureDescriptor } from '@voltro/protocol';
import { PluginRpcClientDescriptor } from '@voltro/protocol';
import { QueryProcedureDescriptor } from '@voltro/protocol';
import { Schema } from 'effect';

export declare const abortMultipartUploadDescriptor: ActionProcedureDescriptor<"storage.abortMultipartUpload", Schema.Struct<{
    multipartToken: typeof Schema.String;
}>, Schema.Struct<{
    ok: typeof Schema.Boolean;
}>, typeof StorageError>;

export declare const beginMultipartUploadDescriptor: ActionProcedureDescriptor<"storage.beginMultipartUpload", Schema.Struct<{
    contentType: typeof Schema.String;
    size: typeof Schema.Number;
    visibility: Schema.optional<Schema.Literal<["public", "private"]>>;
    folder: Schema.optional<typeof Schema.String>;
    tags: Schema.optional<Schema.Array$<typeof Schema.String>>;
    alt: Schema.optional<typeof Schema.String>;
    caption: Schema.optional<typeof Schema.String>;
    partSize: Schema.optional<typeof Schema.Number>;
    expiresInSec: Schema.optional<typeof Schema.Number>;
}>, Schema.Struct<{
    multipartToken: typeof Schema.String;
    partSize: typeof Schema.Number;
    expiresInSec: typeof Schema.Number;
}>, typeof StorageError>;

export declare const beginResumableUploadDescriptor: ActionProcedureDescriptor<"storage.beginResumableUpload", Schema.Struct<{
    contentType: typeof Schema.String;
    size: typeof Schema.Number;
    visibility: Schema.optional<Schema.Literal<["public", "private"]>>;
    folder: Schema.optional<typeof Schema.String>;
    tags: Schema.optional<Schema.Array$<typeof Schema.String>>;
    alt: Schema.optional<typeof Schema.String>;
    caption: Schema.optional<typeof Schema.String>;
    chunkSize: Schema.optional<typeof Schema.Number>;
    expiresInSec: Schema.optional<typeof Schema.Number>;
}>, Schema.Struct<{
    uploadId: typeof Schema.String;
    resumableToken: typeof Schema.String;
    uploadUrl: typeof Schema.String;
    chunkSize: typeof Schema.Number;
    expiresInSec: typeof Schema.Number;
}>, typeof StorageError>;

export declare const completeMultipartUploadDescriptor: ActionProcedureDescriptor<"storage.completeMultipartUpload", Schema.Struct<{
    multipartToken: typeof Schema.String;
    parts: Schema.Array$<Schema.Struct<{
        partNumber: typeof Schema.Number;
        etag: typeof Schema.String;
    }>>;
}>, Schema.Struct<{
    id: typeof Schema.String;
    url: typeof Schema.String;
    size: typeof Schema.Number;
}>, Schema.Union<[typeof StorageError, typeof StorageRejected]>>;

export declare const finalizeUploadDescriptor: ActionProcedureDescriptor<"storage.finalizeUpload", Schema.Struct<{
    finalizeToken: typeof Schema.String;
}>, Schema.Struct<{
    id: typeof Schema.String;
    url: typeof Schema.String;
    contentType: typeof Schema.String;
    size: typeof Schema.Number;
    width: Schema.optional<typeof Schema.Number>;
    height: Schema.optional<typeof Schema.Number>;
}>, Schema.Union<[typeof StorageError, typeof StorageRejected, typeof StorageScanRejected]>>;

export declare const ingestUrlDescriptor: ActionProcedureDescriptor<"storage.ingestUrl", Schema.Struct<{
    url: typeof Schema.String;
    visibility: Schema.optional<Schema.Literal<["public", "private"]>>;
    folder: Schema.optional<typeof Schema.String>;
    tags: Schema.optional<Schema.Array$<typeof Schema.String>>;
    alt: Schema.optional<typeof Schema.String>;
    caption: Schema.optional<typeof Schema.String>;
    key: Schema.optional<typeof Schema.String>;
}>, Schema.Struct<{
    id: typeof Schema.String;
    url: typeof Schema.String;
}>, Schema.Union<[typeof StorageError, typeof StorageRejected, typeof StorageScanRejected]>>;

export declare const listGrantsDescriptor: QueryProcedureDescriptor<"storage.listGrants", Schema.Struct<{
    refId: typeof Schema.String;
}>, Schema.Struct<{
    grants: Schema.Array$<Schema.Struct<{
        id: typeof Schema.String;
        refId: typeof Schema.String;
        principalType: Schema.Literal<["user", "group", "apiKey"]>;
        principalId: typeof Schema.String;
        permission: Schema.Literal<["read", "write"]>;
        createdAt: typeof Schema.String;
        expiresAt: Schema.NullOr<typeof Schema.String>;
        createdBy: Schema.NullOr<typeof Schema.String>;
    }>>;
}>, typeof StorageError>;

/** Browse / search the stored refs by folder-prefix / tags / ownerId, paged.
 *  The media-library / file-manager read (F6). Tenant is taken from the caller
 *  subject server-side — a client can't list another tenant's objects. */
export declare const listRefsDescriptor: QueryProcedureDescriptor<"storage.listRefs", Schema.Struct<{
    folder: Schema.optional<typeof Schema.String>;
    tags: Schema.optional<Schema.Array$<typeof Schema.String>>;
    ownerId: Schema.optional<typeof Schema.String>;
    includeDerived: Schema.optional<typeof Schema.Boolean>;
    limit: Schema.optional<typeof Schema.Number>;
    offset: Schema.optional<typeof Schema.Number>;
}>, Schema.Struct<{
    refs: Schema.Array$<Schema.Struct<{
        id: typeof Schema.String;
        tenantId: Schema.NullOr<typeof Schema.String>;
        ownerId: Schema.NullOr<typeof Schema.String>;
        bucket: typeof Schema.String;
        key: typeof Schema.String;
        contentType: typeof Schema.String;
        size: typeof Schema.Number;
        checksum: typeof Schema.String;
        visibility: Schema.Literal<["public", "private"]>;
        hasPassword: typeof Schema.Boolean;
        createdAt: typeof Schema.String;
        width: Schema.NullOr<typeof Schema.Number>;
        height: Schema.NullOr<typeof Schema.Number>;
        duration: Schema.NullOr<typeof Schema.Number>;
        placeholder: Schema.NullOr<typeof Schema.String>;
        folder: Schema.NullOr<typeof Schema.String>;
        tags: Schema.NullOr<Schema.Array$<typeof Schema.String>>;
        alt: Schema.NullOr<typeof Schema.String>;
        caption: Schema.NullOr<typeof Schema.String>;
        derivedFrom: Schema.NullOr<typeof Schema.String>;
        kind: Schema.NullOr<typeof Schema.String>;
    }>>;
    nextOffset: Schema.NullOr<typeof Schema.Number>;
}>, typeof StorageError>;

export declare const mintPresignedUploadDescriptor: ActionProcedureDescriptor<"storage.mintPresignedUpload", Schema.Struct<{
    contentType: typeof Schema.String;
    visibility: Schema.optional<Schema.Literal<["public", "private"]>>;
    folder: Schema.optional<typeof Schema.String>;
    tags: Schema.optional<Schema.Array$<typeof Schema.String>>;
    alt: Schema.optional<typeof Schema.String>;
    caption: Schema.optional<typeof Schema.String>;
    expiresInSec: Schema.optional<typeof Schema.Number>;
}>, Schema.Struct<{
    uploadUrl: typeof Schema.String;
    finalizeToken: typeof Schema.String;
    expiresInSec: typeof Schema.Number;
}>, typeof StorageError>;

export declare const mintUploadTicketDescriptor: ActionProcedureDescriptor<"storage.mintUploadTicket", Schema.Struct<{
    contentType: typeof Schema.String;
    visibility: Schema.optional<Schema.Literal<["public", "private"]>>;
    key: Schema.optional<typeof Schema.String>;
    folder: Schema.optional<typeof Schema.String>;
    tags: Schema.optional<Schema.Array$<typeof Schema.String>>;
    alt: Schema.optional<typeof Schema.String>;
    caption: Schema.optional<typeof Schema.String>;
    expiresInSec: Schema.optional<typeof Schema.Number>;
}>, Schema.Struct<{
    uploadUrl: typeof Schema.String;
    expiresInSec: typeof Schema.Number;
}>, typeof StorageError>;

export declare const mintUploadUrlDescriptor: ActionProcedureDescriptor<"storage.mintUploadUrl", Schema.Struct<{
    key: typeof Schema.String;
    contentType: typeof Schema.String;
    expiresInSec: Schema.optional<typeof Schema.Number>;
}>, Schema.Struct<{
    url: typeof Schema.String;
}>, typeof StorageError>;

export declare const mintUrlDescriptor: ActionProcedureDescriptor<"storage.mintUrl", Schema.Struct<{
    id: typeof Schema.String;
    password: Schema.optional<typeof Schema.String>;
    expiresInSec: Schema.optional<typeof Schema.Number>;
}>, Schema.Struct<{
    url: typeof Schema.String;
}>, Schema.Union<[typeof StorageError, typeof StorageAccessDenied]>>;

export declare const revokeDescriptor: MutationProcedureDescriptor<"storage.revoke", Schema.Struct<{
    grantId: typeof Schema.String;
}>, Schema.Struct<{
    ok: typeof Schema.Boolean;
}>, typeof StorageError>;

export declare const shareDescriptor: MutationProcedureDescriptor<"storage.share", Schema.Struct<{
    refId: typeof Schema.String;
    principalType: Schema.Literal<["user", "group", "apiKey"]>;
    principalId: typeof Schema.String;
    permission: Schema.optional<Schema.Literal<["read", "write"]>>;
    expiresInDays: Schema.optional<typeof Schema.Number>;
}>, Schema.Struct<{
    grantId: typeof Schema.String;
}>, typeof StorageError>;

export declare const signMultipartPartDescriptor: ActionProcedureDescriptor<"storage.signMultipartPart", Schema.Struct<{
    multipartToken: typeof Schema.String;
    partNumber: typeof Schema.Number;
}>, Schema.Struct<{
    url: typeof Schema.String;
}>, typeof StorageError>;

/**
 * Access to a private object was refused. Distinct from `StorageError` so
 * handlers can tell "not allowed" (403) from "backend blew up" (5xx) and
 * the wire-error union carries it typed.
 */
declare class StorageAccessDenied extends StorageAccessDenied_base {
}

declare const StorageAccessDenied_base: Schema.TaggedErrorClass<StorageAccessDenied, "StorageAccessDenied", {
    readonly _tag: Schema.tag<"StorageAccessDenied">;
} & {
    refId: typeof Schema.String;
    reason: typeof Schema.String;
}>;

/**
 * Storage failure. `transient` drives retry — `true` for 429 / 5xx /
 * network blips, `false` for 4xx / config / not-found. Surfaced typed so
 * handlers can `Effect.catchTag('StorageError', …)`.
 */
declare class StorageError extends StorageError_base {
}

declare const StorageError_base: Schema.TaggedErrorClass<StorageError, "StorageError", {
    readonly _tag: Schema.tag<"StorageError">;
} & {
    provider: typeof Schema.String;
    message: typeof Schema.String;
    transient: typeof Schema.Boolean;
    status: Schema.optional<typeof Schema.Number>;
}>;

/** An upload was rejected by a constraint (size / content-type / magic-byte
 *  mismatch). `reason` is a stable code; `detail` is human-readable. */
declare class StorageRejected extends StorageRejected_base {
}

declare const StorageRejected_base: Schema.TaggedErrorClass<StorageRejected, "StorageRejected", {
    readonly _tag: Schema.tag<"StorageRejected">;
} & {
    /** `'too-large' | 'content-type-not-allowed' | 'content-mismatch'` */
    reason: typeof Schema.String;
    detail: typeof Schema.String;
}>;

/** Declared for the codegen (`VoltroPlugin.rpcClientDescriptors`) so each tag is
 *  emitted into the generated client group. Kept in lockstep with the exports. */
export declare const storageRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;

/** An upload was rejected by the virus scanner. */
declare class StorageScanRejected extends StorageScanRejected_base {
}

declare const StorageScanRejected_base: Schema.TaggedErrorClass<StorageScanRejected, "StorageScanRejected", {
    readonly _tag: Schema.tag<"StorageScanRejected">;
} & {
    threat: typeof Schema.String;
}>;

export declare const uploadDescriptor: ActionProcedureDescriptor<"storage.upload", Schema.Struct<{
    bytesBase64: typeof Schema.String;
    contentType: typeof Schema.String;
    visibility: Schema.optional<Schema.Literal<["public", "private"]>>;
    key: Schema.optional<typeof Schema.String>;
    password: Schema.optional<typeof Schema.String>;
}>, Schema.Struct<{
    id: typeof Schema.String;
    url: typeof Schema.String;
}>, Schema.Union<[typeof StorageError, typeof StorageRejected, typeof StorageScanRejected]>>;

export { }