import type { AssetReference, ResourceIntegrity, ResourceLocator } from "@skenora/contracts";
export interface ResourceTechnicalMetadata {
    format?: string;
    size?: number;
    dimensions?: {
        x: number;
        y: number;
        z: number;
    };
    polygonCount?: number;
    animations?: readonly string[];
    textureResolution?: number;
    upAxis?: "x" | "y" | "z";
    unit?: "m" | "cm" | "mm";
}
export interface ResourceLicenseMetadata {
    id: string;
    attributionRequired: boolean;
    attribution?: string;
}
export interface ResourceDescriptor {
    id: string;
    label: string;
    kind: AssetReference["kind"];
    source: ResourceLocator;
    description?: string;
    tags?: readonly string[];
    thumbnail?: ResourceLocator;
    mediaType?: string;
    integrity?: ResourceIntegrity;
    technical?: ResourceTechnicalMetadata;
    license?: ResourceLicenseMetadata;
}
export interface ResourceSearchQuery {
    query?: string;
    kind?: AssetReference["kind"];
    tags?: readonly string[];
    providerTypes?: readonly string[];
    limit?: number;
    cursor?: string;
}
export interface ResourceSearchPage {
    items: readonly ResourceDescriptor[];
    nextCursor?: string;
}
export interface ResourceRequestContext {
    signal: AbortSignal;
    assetId?: string;
    expectedKind?: AssetReference["kind"];
}
export interface ResourceResponse {
    blob: Blob;
    name: string;
    mediaType?: string;
    /** Effective locator after provider-level canonicalization or redirects. */
    resolvedLocator?: ResourceLocator;
}
export interface ResourceProvider {
    readonly type: string;
    canonicalize(locator: ResourceLocator): string;
    open(locator: ResourceLocator, context: ResourceRequestContext): Promise<ResourceResponse>;
    resolveRelative(base: ResourceLocator, relativeUri: string): ResourceLocator;
    search?(query: ResourceSearchQuery, context: ResourceRequestContext): Promise<ResourceSearchPage>;
    describe?(locator: ResourceLocator, context: ResourceRequestContext): Promise<ResourceDescriptor>;
}
export type ResourcePolicyOperation = "acquire" | "describe" | "search";
export interface ResourcePolicyRequest {
    operation: ResourcePolicyOperation;
    providerType: string;
    locator?: ResourceLocator;
    assetId?: string;
    expectedKind?: AssetReference["kind"];
}
export interface ResourcePolicy {
    authorize(request: Readonly<ResourcePolicyRequest>): void | Promise<void>;
}
export interface ResourceEventMap {
    "resource.request.started": {
        key: string;
        locator: ResourceLocator;
    };
    "resource.request.succeeded": {
        key: string;
        locator: ResourceLocator;
        size: number;
        mediaType: string | null;
    };
    "resource.request.failed": {
        key: string;
        locator: ResourceLocator;
        error: unknown;
    };
    "resource.cache.hit": {
        key: string;
        locator: ResourceLocator;
    };
}
export interface ResolvedResource {
    readonly locator: ResourceLocator;
    readonly canonicalKey: string;
    readonly name: string;
    readonly mediaType: string | null;
    readonly size: number;
    readonly blob: Blob;
    readonly objectUrl: string;
    /** Expected integrity when the resolver verified the acquired bytes. */
    readonly integrity: ResourceIntegrity | null;
}
export interface ResourceScopeOptions {
    signal?: AbortSignal;
}
export interface ResourceAcquireOptions {
    expectedKind?: AssetReference["kind"];
    /** Optional response media type guard. Existing callers may omit it. */
    expectedMediaType?: string;
}
export interface ResourceScope {
    /** Implementations must honor AssetReference.integrity before resolving. */
    acquire(asset: Readonly<AssetReference>, options?: ResourceAcquireOptions): Promise<ResolvedResource>;
    acquireLocator(locator: ResourceLocator, options?: ResourceAcquireOptions): Promise<ResolvedResource>;
    acquireRelative(base: Readonly<ResolvedResource>, relativeUri: string, options?: ResourceAcquireOptions): Promise<ResolvedResource>;
    dispose(): void;
}
export interface ResourceResolver {
    createScope(options?: ResourceScopeOptions): ResourceScope;
}
export interface ResourceDiscovery {
    search(query?: ResourceSearchQuery): Promise<ResourceSearchPage>;
    describe(locator: ResourceLocator): Promise<ResourceDescriptor>;
    preflight(assets: readonly Readonly<AssetReference>[]): Promise<ResourcePreflightResult>;
}
export interface ResourcePreflightItem {
    assetId: string;
    ready: boolean;
    canonicalKey: string | null;
    error: unknown | null;
}
export interface ResourcePreflightResult {
    ready: boolean;
    items: readonly ResourcePreflightItem[];
}
export declare function assetReferenceFromDescriptor(descriptor: Readonly<ResourceDescriptor>, assetId: string): AssetReference;
export declare function supportsResourceDiscovery(value: ResourceResolver): value is ResourceResolver & ResourceDiscovery;
//# sourceMappingURL=types.d.ts.map