@plyaz/types 1.36.0 → 1.36.2

package/dist/campaign/schemas.d.ts

@@ -17,7 +17,7 @@ export declare const formCampaignSchema: ({ maxFunding }: {
 }) => z.ZodObject<{
     title: z.ZodString;
     subtitle: z.ZodString;
-    campaignImage: z.ZodAny;
+    campaignImage: z.ZodAny & z.ZodType<File, any, z.core.$ZodTypeInternals<File, any>>;
     startDate: z.ZodDate;
     duration: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<30>, z.ZodLiteral<60>, z.ZodLiteral<90>]>>;
     story: z.ZodString;

package/dist/core/domain/files/enums.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Files Domain Enums and Constants
+ *
+ * Runtime constants for files/media operations.
+ */
+/**
+ * System user UUID for uploads without user context.
+ * Used for:
+ * - Generated documents (no auth context)
+ * - System-initiated uploads
+ * - Background jobs
+ *
+ * Must be a valid UUID as media.user_id has FK constraint to users table.
+ * This UUID should exist in the users table or FK checks should be disabled.
+ */
+export declare const SYSTEM_USER_ID = "00000000-0000-0000-0000-000000000000";
+/**
+ * File types supported by the DB ENUM
+ * Use these when creating records - 'OTHER' is NOT in the DB ENUM
+ */
+export declare const FILE_TYPES: {
+    readonly IMAGE: "IMAGE";
+    readonly VIDEO: "VIDEO";
+    readonly AUDIO: "AUDIO";
+    readonly DOCUMENT: "DOCUMENT";
+};
+export type FileTypeValue = (typeof FILE_TYPES)[keyof typeof FILE_TYPES];
+/**
+ * Access levels for files
+ */
+export declare const FILE_ACCESS_LEVELS: {
+    readonly PUBLIC: "public";
+    readonly PRIVATE: "private";
+    readonly PROTECTED: "protected";
+};
+export type FileAccessLevelValue = (typeof FILE_ACCESS_LEVELS)[keyof typeof FILE_ACCESS_LEVELS];

package/dist/core/domain/files/index.d.ts

@@ -4,5 +4,8 @@
  * Core domain types for files/media service.
  * Schemas are the single source of truth for DB types.
  */
-export { SYSTEM_USER_ID, MediaTypeSchema, type MediaType, FileTypeSchema, type FileType, MediaAccessLevelSchema, type MediaAccessLevel, FilesDatabaseRowSchema, type FilesDatabaseRow, MediaVariantsDatabaseRowSchema, type MediaVariantsDatabaseRow, CreateMediaSchema, type CreateMediaInput, type CreateMediaOutput, type FilesCreateInput, CreateMediaVariantSchema, type MediaVariantsCreateInput, PatchMediaSchema, type PatchMediaInput, type PatchMediaOutput, } from './schemas';
+export { SYSTEM_USER_ID, FILE_TYPES, type FileTypeValue, FILE_ACCESS_LEVELS, type FileAccessLevelValue, } from './enums';
+export { FILES_STREAM_MESSAGE_TYPE, FILES_STREAM_SUBTYPE, FILES_STREAM_PROGRESS_STATUS, FILES_STREAM_EVENT, FILES_STREAM_CHANNEL_PREFIX, FILES_STREAM_BROADCAST_CHANNEL, FILES_STREAM_CHANNEL, } from './streaming';
+export type { FilesStreamMessageType, FilesStreamSubtype, FilesStreamProgressStatus, FilesStreamEventName, FilesStreamChannelPrefix, FilesStreamBroadcastChannel, FilesStreamChannel, FilesUploadStreamProgress, FilesDownloadStreamProgress, FilesGenerateStreamProgress, FilesStreamProgressData, } from './streaming';
+export { MediaTypeSchema, type MediaType, FileTypeSchema, type FileType, MediaAccessLevelSchema, type MediaAccessLevel, FilesDatabaseRowSchema, type FilesDatabaseRow, MediaVariantsDatabaseRowSchema, type MediaVariantsDatabaseRow, CreateFilesSchema, type FilesCreateInput, type FilesCreateOutput, CreateMediaVariantSchema, type MediaVariantsCreateInput, PatchFilesSchema, type FilesPatchInput, type FilesPatchOutput, } from './schemas';
 export { type FilesEntity, type FilesFrontendServiceConfig, type FilesDomainServiceConfig, type SingleUploadEventPayload, type BulkUploadEventPayload, type FileUploadedEventPayload, type FileBulkUploadedEventPayload, type FilesUploadEventPayload, type FileDocumentGeneratedEventPayload, } from './types';

package/dist/core/domain/files/schemas.d.ts

@@ -10,8 +10,6 @@
  * - FilesMapper for transformations
  */
 import { z } from 'zod';
-/** System user UUID for uploads without user context */
-export declare const SYSTEM_USER_ID = "00000000-0000-0000-0000-000000000000";
 /**
  * Media type enum - matches media.type DB ENUM
  * Note: DB only has IMAGE, VIDEO, AUDIO, DOCUMENT (no OTHER)
@@ -26,8 +24,8 @@ export declare const MediaTypeSchema: z.ZodEnum<{
 export type MediaType = z.infer<typeof MediaTypeSchema>;
 /**
  * File type enum - for domain layer (includes OTHER for unknown types)
- * Use this for domain entities and frontend display
- * @deprecated Prefer MediaTypeSchema for new code - OTHER not in DB
+ * Use this for domain entities and frontend display.
+ * Note: OTHER is not in the DB ENUM, mapper should convert to DOCUMENT for DB ops.
  */
 export declare const FileTypeSchema: z.ZodEnum<{
     IMAGE: "IMAGE";
@@ -81,13 +79,13 @@ export declare const FilesDatabaseRowSchema: z.ZodObject<{
  */
 export type FilesDatabaseRow = z.infer<typeof FilesDatabaseRowSchema>;
 /**
- * Schema for creating a media record in the database
+ * Schema for creating a file/media record in the database
  * Validates data before repository.create()
  *
  * Auto-generated fields (id, created_at, updated_at, deleted_at)
  * are handled by the repository.
  */
-export declare const CreateMediaSchema: z.ZodObject<{
+export declare const CreateFilesSchema: z.ZodObject<{
     user_id: z.ZodDefault<z.ZodString>;
     type: z.ZodDefault<z.ZodEnum<{
         IMAGE: "IMAGE";
@@ -116,20 +114,15 @@ export declare const CreateMediaSchema: z.ZodObject<{
         protected: "protected";
     }>>>;
 }, z.core.$strip>;
-/** Input type for creating media (before defaults applied) */
-export type CreateMediaInput = z.input<typeof CreateMediaSchema>;
-/** Output type for creating media (after defaults applied) */
-export type CreateMediaOutput = z.output<typeof CreateMediaSchema>;
+/** Input type for creating files (before defaults applied) */
+export type FilesCreateInput = z.input<typeof CreateFilesSchema>;
+/** Output type for creating files (after defaults applied) */
+export type FilesCreateOutput = z.output<typeof CreateFilesSchema>;
 /**
- * Alias for backward compatibility
- * @deprecated Use CreateMediaInput instead
- */
-export type FilesCreateInput = CreateMediaInput;
-/**
- * Schema for partial update of a media record
+ * Schema for partial update of a file/media record
  * All fields optional
  */
-export declare const PatchMediaSchema: z.ZodObject<{
+export declare const PatchFilesSchema: z.ZodObject<{
     user_id: z.ZodOptional<z.ZodDefault<z.ZodString>>;
     type: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
         IMAGE: "IMAGE";
@@ -158,8 +151,8 @@ export declare const PatchMediaSchema: z.ZodObject<{
         protected: "protected";
     }>>>>;
 }, z.core.$strip>;
-export type PatchMediaInput = z.input<typeof PatchMediaSchema>;
-export type PatchMediaOutput = z.output<typeof PatchMediaSchema>;
+export type FilesPatchInput = z.input<typeof PatchFilesSchema>;
+export type FilesPatchOutput = z.output<typeof PatchFilesSchema>;
 /**
  * Full media_variants database row schema
  */
@@ -179,10 +172,10 @@ export type MediaVariantsDatabaseRow = z.infer<typeof MediaVariantsDatabaseRowSc
  * Schema for creating a media variant record
  */
 export declare const CreateMediaVariantSchema: z.ZodObject<{
-    file_size: z.ZodNullable<z.ZodNumber>;
-    cdn_url: z.ZodNullable<z.ZodString>;
     width: z.ZodNullable<z.ZodNumber>;
     height: z.ZodNullable<z.ZodNumber>;
+    file_size: z.ZodNullable<z.ZodNumber>;
+    cdn_url: z.ZodNullable<z.ZodString>;
     media_id: z.ZodString;
     variant_name: z.ZodString;
     file_path: z.ZodString;

package/dist/core/domain/files/streaming.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Files Domain Streaming Types
+ *
+ * Stream message types specific to the files domain.
+ * These extend from existing storage types and are merged into global streaming types.
+ *
+ * Architecture:
+ * - FilesStreamProgressData extends UploadProgressEvent (from storage)
+ * - Constants (FILES_STREAM_*) are domain-specific
+ * - Global types in @plyaz/types/core/events/streaming merge these with other domains
+ */
+import type { UploadProgressEvent } from '../../../storage';
+/**
+ * Message type categories specific to files domain.
+ * These get merged into global STREAM_MESSAGE_TYPE.
+ */
+export declare const FILES_STREAM_MESSAGE_TYPE: {
+    readonly PROGRESS: "progress";
+    readonly STATUS: "status";
+    readonly ERROR: "error";
+};
+export type FilesStreamMessageType = (typeof FILES_STREAM_MESSAGE_TYPE)[keyof typeof FILES_STREAM_MESSAGE_TYPE];
+/**
+ * Stream message subtypes for files domain.
+ * Defines the specific operations that can be streamed.
+ */
+export declare const FILES_STREAM_SUBTYPE: {
+    readonly UPLOAD: "upload";
+    readonly DOWNLOAD: "download";
+    readonly GENERATE: "generate";
+};
+export type FilesStreamSubtype = (typeof FILES_STREAM_SUBTYPE)[keyof typeof FILES_STREAM_SUBTYPE];
+/**
+ * Progress status values for files streaming operations.
+ * Aligned with storage UPLOAD_STATUS enum values.
+ */
+export declare const FILES_STREAM_PROGRESS_STATUS: {
+    readonly PENDING: "pending";
+    readonly UPLOADING: "uploading";
+    readonly DOWNLOADING: "downloading";
+    readonly PROCESSING: "processing";
+    readonly GENERATING: "generating";
+    readonly COMPLETED: "completed";
+    readonly FAILED: "failed";
+    readonly CANCELLED: "cancelled";
+};
+export type FilesStreamProgressStatus = (typeof FILES_STREAM_PROGRESS_STATUS)[keyof typeof FILES_STREAM_PROGRESS_STATUS];
+/**
+ * SSE/WebSocket event names for files domain.
+ * These map to the `event` field in StreamMessage.
+ */
+export declare const FILES_STREAM_EVENT: {
+    readonly UPLOAD_PROGRESS: "upload:progress";
+    readonly UPLOAD_COMPLETED: "upload:completed";
+    readonly UPLOAD_FAILED: "upload:failed";
+    readonly UPLOAD_CANCELLED: "upload:cancelled";
+    readonly DOWNLOAD_PROGRESS: "download:progress";
+    readonly DOWNLOAD_COMPLETED: "download:completed";
+    readonly DOWNLOAD_FAILED: "download:failed";
+    readonly DOWNLOAD_CANCELLED: "download:cancelled";
+    readonly GENERATE_PROGRESS: "generate:progress";
+    readonly GENERATE_COMPLETED: "generate:completed";
+    readonly GENERATE_FAILED: "generate:failed";
+};
+export type FilesStreamEventName = (typeof FILES_STREAM_EVENT)[keyof typeof FILES_STREAM_EVENT];
+/**
+ * Channel prefixes for files domain subscriptions.
+ * Used for per-resource channels (upload:fileId, download:fileId, etc.)
+ */
+export declare const FILES_STREAM_CHANNEL_PREFIX: {
+    readonly UPLOAD: "upload:";
+    readonly DOWNLOAD: "download:";
+    readonly GENERATE: "generate:";
+};
+export type FilesStreamChannelPrefix = (typeof FILES_STREAM_CHANNEL_PREFIX)[keyof typeof FILES_STREAM_CHANNEL_PREFIX];
+/**
+ * Broadcast channels for files domain (user-scoped).
+ * Used for subscribing to all events of a type.
+ */
+export declare const FILES_STREAM_BROADCAST_CHANNEL: {
+    readonly UPLOADS: "uploads";
+    readonly DOWNLOADS: "downloads";
+    readonly GENERATIONS: "generations";
+};
+export type FilesStreamBroadcastChannel = (typeof FILES_STREAM_BROADCAST_CHANNEL)[keyof typeof FILES_STREAM_BROADCAST_CHANNEL];
+/**
+ * All files stream channels (prefixes + broadcast).
+ */
+export declare const FILES_STREAM_CHANNEL: {
+    readonly PREFIX: {
+        readonly UPLOAD: "upload:";
+        readonly DOWNLOAD: "download:";
+        readonly GENERATE: "generate:";
+    };
+    readonly BROADCAST: {
+        readonly UPLOADS: "uploads";
+        readonly DOWNLOADS: "downloads";
+        readonly GENERATIONS: "generations";
+    };
+};
+/**
+ * Channel patterns for files domain subscriptions.
+ *
+ * - `upload:{fileId}` - Per-file upload progress
+ * - `download:{fileId}` - Per-file download progress
+ * - `generate:{templateId}` - Per-template generation progress
+ * - `uploads` - All uploads for current user
+ * - `downloads` - All downloads for current user
+ * - `generations` - All generations for current user
+ */
+export type FilesStreamChannel = `upload:${string}` | `download:${string}` | `generate:${string}` | FilesStreamBroadcastChannel;
+/**
+ * Base progress data extending storage's UploadProgressEvent.
+ * Used for upload progress streaming.
+ */
+export interface FilesUploadStreamProgress extends UploadProgressEvent {
+    /** Current status */
+    status: FilesStreamProgressStatus;
+    /** Error message (if status is 'failed') */
+    error?: string;
+}
+/**
+ * Download progress data.
+ * Similar to upload but for downloads.
+ */
+export interface FilesDownloadStreamProgress {
+    /** File ID */
+    fileId: string;
+    /** Filename */
+    filename: string;
+    /** Bytes downloaded */
+    loaded: number;
+    /** Total bytes */
+    total: number;
+    /** Progress percentage (0-100) */
+    percentage: number;
+    /** Download speed in bytes/second */
+    speed?: number;
+    /** Estimated time remaining in seconds */
+    estimatedTimeRemaining?: number;
+    /** Current status */
+    status: FilesStreamProgressStatus;
+    /** Error message (if status is 'failed') */
+    error?: string;
+}
+/**
+ * Document generation progress data.
+ */
+export interface FilesGenerateStreamProgress {
+    /** Template ID being generated */
+    templateId: string;
+    /** Progress percentage (0-100) */
+    percentage: number;
+    /** Current status */
+    status: FilesStreamProgressStatus;
+    /** Error message (if status is 'failed') */
+    error?: string;
+    /** Output filename (when completed) */
+    outputFilename?: string;
+    /** Output file ID (when completed) */
+    outputFileId?: string;
+}
+/**
+ * Union of all files stream progress data types.
+ * Use this for generic handling of any files progress message.
+ */
+export type FilesStreamProgressData = FilesUploadStreamProgress | FilesDownloadStreamProgress | FilesGenerateStreamProgress;

package/dist/core/events/index.d.ts

@@ -20,3 +20,5 @@
 export { CoreEventScope, SystemEventAction, EntityEventAction, ValidationEventAction, SanitizationEventAction, ApiEventAction, CacheEventAction, AuthEventAction, DatabaseEventAction, FeatureFlagEventAction, StoreEventAction, StorageEventAction, NotificationEventAction, CORE_EVENTS, } from './enums';
 export type { CoreEventScopeType, SystemEventType, EntityEventType, ValidationEventType, SanitizationEventType, ApiEventType, CacheEventType, AuthEventType, DatabaseEventType, FeatureFlagEventType, StoreEventType, CoreEventType, } from './enums';
 export type { CoreEvent, CoreCrudOperation, CoreValidationStartedPayload, CoreValidationSuccessPayload, CoreValidationFailedPayload, CoreSanitizationStartedPayload, CoreSanitizationSuccessPayload, CoreSanitizationFailedPayload, CoreEntityCreatedPayload, CoreEntityUpdatedPayload, CoreEntityPatchedPayload, CoreEntityDeletedPayload, CoreEntityCreatingPayload, CoreEntityUpdatingPayload, CoreEntityPatchingPayload, CoreEntityDeletingPayload, CoreEntityErrorPayload, CoreEntityCompletePayload, CoreBulkCreatedPayload, CoreBulkDeletedPayload, CoreSystemInitializedPayload, CoreSystemReadyPayload, CoreSystemShutdownPayload, CoreSystemErrorPayload, CoreSystemWarningPayload, CoreApiRequestStartPayload, CoreApiRequestSuccessPayload, CoreApiRequestErrorPayload, CoreApiRetryPayload, CoreApiTimeoutPayload, CoreCacheHitPayload, CoreCacheMissPayload, CoreCacheSetPayload, CoreCacheDeletePayload, CoreCacheClearPayload, CoreCacheExpiredPayload, CoreCacheErrorPayload, CoreDatabaseConnectedPayload, CoreDatabaseDisconnectedPayload, CoreDatabaseQueryPayload, CoreDatabaseErrorPayload, CoreDatabaseTransactionStartPayload, CoreDatabaseTransactionCommitPayload, CoreDatabaseTransactionRollbackPayload, CoreAuthLoginPayload, CoreAuthLogoutPayload, CoreAuthTokenRefreshPayload, CoreAuthSessionExpiredPayload, CoreAuthUnauthorizedPayload, CoreFeatureFlagChangedPayload, CoreFeatureFlagEvaluatedPayload, CoreFeatureFlagRefreshedPayload, CoreStoreUpdatedPayload, CoreStoreResetPayload, CoreStoreHydratedPayload, CoreOperationRequestPayload, CoreOperationResultPayload, CoreOperationErrorPayload, CoreStorageUploadedPayload, CoreStorageDownloadedPayload, CoreStorageDeletedPayload, CoreStorageErrorPayload, CoreStorageHealthCheckPayload, CoreNotificationSentPayload, CoreNotificationFailedPayload, CoreNotificationDeliveredPayload, CoreNotificationOpenedPayload, CoreNotificationClickedPayload, CoreNotificationErrorPayload, CoreNotificationHealthCheckPayload, CoreEventPayloadMap, EventPersistenceConfig, DomainPersistenceConfig, PersistOperationConfig, FrontendEventHandlerConfig, DomainFrontendEventConfig, } from './payloads';
+export { STREAM_TRANSPORT, SYSTEM_STREAM_MESSAGE_TYPE, SYSTEM_STREAM_SUBTYPE, SYSTEM_STREAM_CHANNEL, SYSTEM_STREAM_EVENT, STREAM_MESSAGE_TYPE, STREAM_SUBTYPE, STREAM_SCOPE, STREAM_EVENT, STREAM_CHANNEL_PREFIX, STREAM_BROADCAST_CHANNEL, STREAM_PROGRESS_STATUS, FILES_STREAM_MESSAGE_TYPE, FILES_STREAM_SUBTYPE, FILES_STREAM_PROGRESS_STATUS, FILES_STREAM_EVENT, FILES_STREAM_CHANNEL_PREFIX, FILES_STREAM_BROADCAST_CHANNEL, FILES_STREAM_CHANNEL, } from './streaming';
+export type { StreamTransportType, StreamConnection, StreamConnectionInfo, SystemStreamMessageType, SystemStreamSubtype, SystemStreamChannel, StreamMessage, StreamMessageType, StreamMessageSubtype, StreamMessageScope, StreamProgressData, StreamProgressStatus, FilesUploadStreamProgress, FilesDownloadStreamProgress, FilesGenerateStreamProgress, StreamChannel, ChannelSubscription, StreamAuthResult, StreamAuthAdapterConfig, TokenAuthAdapterConfig, StreamTransportAdapterConfig, StreamBroadcasterConfig, StreamManagerStats, UseStreamConnectionOptions, UseStreamConnectionResult, UseStreamManagerOptions, UseStreamManagerResult, StreamResponse, StreamErrorEvent, PaginatedStreamResponse, StreamEndpointConfig, StreamEndpointCreateOptions, StreamBroadcasterInterface, ChannelControllerConfig, StreamMiddlewareContext, StreamMiddlewareResult, StreamMiddleware, RateLimitConfig, StreamEndpointEntry, StreamRegistryConfig, FilesStreamMessageType, FilesStreamSubtype, FilesStreamProgressStatus, FilesStreamProgressData, FilesStreamEventName, FilesStreamChannelPrefix, FilesStreamBroadcastChannel, FilesStreamChannel, } from './streaming';

package/dist/core/events/streaming/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Streaming Types
+ *
+ * Types for real-time event streaming via SSE/WebSocket.
+ *
+ * Architecture:
+ * - Domain services define their own streaming constants (e.g., FILES_STREAM_SUBTYPE)
+ * - Global constants here MERGE domain-specific constants
+ * - System constants (heartbeat, connection) are defined here as base
+ *
+ * Domain-specific streaming types are defined in their domains:
+ * - Files: @plyaz/types/core/domain/files (FILES_STREAM_*, FilesStreamSubtype, etc.)
+ */
+export { STREAM_TRANSPORT, SYSTEM_STREAM_MESSAGE_TYPE, SYSTEM_STREAM_SUBTYPE, SYSTEM_STREAM_CHANNEL, SYSTEM_STREAM_EVENT, STREAM_MESSAGE_TYPE, STREAM_SUBTYPE, STREAM_SCOPE, STREAM_EVENT, STREAM_CHANNEL_PREFIX, STREAM_BROADCAST_CHANNEL, STREAM_PROGRESS_STATUS, } from './types';
+export type { StreamTransportType, StreamConnection, StreamConnectionInfo, SystemStreamMessageType, SystemStreamSubtype, SystemStreamChannel, StreamMessage, StreamMessageType, StreamMessageSubtype, StreamMessageScope, StreamProgressData, StreamProgressStatus, FilesUploadStreamProgress, FilesDownloadStreamProgress, FilesGenerateStreamProgress, StreamChannel, ChannelSubscription, StreamAuthResult, StreamAuthAdapterConfig, TokenAuthAdapterConfig, StreamTransportAdapterConfig, StreamBroadcasterConfig, StreamManagerStats, UseStreamConnectionOptions, UseStreamConnectionResult, UseStreamManagerOptions, UseStreamManagerResult, } from './types';
+export type { StreamResponse, StreamErrorEvent, PaginatedStreamResponse, StreamEndpointConfig, StreamEndpointCreateOptions, StreamBroadcasterInterface, ChannelControllerConfig, StreamMiddlewareContext, StreamMiddlewareResult, StreamMiddleware, RateLimitConfig, StreamEndpointEntry, StreamRegistryConfig, } from './responses';
+export { FILES_STREAM_MESSAGE_TYPE, FILES_STREAM_SUBTYPE, FILES_STREAM_PROGRESS_STATUS, FILES_STREAM_EVENT, FILES_STREAM_CHANNEL_PREFIX, FILES_STREAM_BROADCAST_CHANNEL, FILES_STREAM_CHANNEL, } from '../../domain/files';
+export type { FilesStreamMessageType, FilesStreamSubtype, FilesStreamProgressStatus, FilesStreamProgressData, FilesStreamEventName, FilesStreamChannelPrefix, FilesStreamBroadcastChannel, FilesStreamChannel, } from '../../domain/files';

package/dist/core/events/streaming/responses.d.ts

@@ -0,0 +1,164 @@
+/**
+ * Stream Response Types
+ *
+ * Response types for real-time streaming that follow the API patterns.
+ * Uses standard ErrorResponse from @plyaz/types/errors.
+ */
+import type { ErrorResponse, PackageErrorLike } from '../../../errors/types';
+import type { StreamAuthResult, StreamConnection, StreamMessage } from './types';
+/**
+ * Stream response wrapper - consistent with API ReturnResponseType
+ */
+export interface StreamResponse<T = unknown> {
+    /** Whether the operation succeeded */
+    success: boolean;
+    /** Human-readable message */
+    message: string;
+    /** Response data payload */
+    data?: T;
+    /** Channel this response is for */
+    channel: string;
+    /** Unix timestamp when response was created */
+    timestamp: number;
+    /** Correlation ID for tracing */
+    correlationId?: string;
+}
+/**
+ * Stream error event - uses standard ErrorResponse
+ */
+export interface StreamErrorEvent {
+    /** Always false for errors */
+    success: false;
+    /** Standard ErrorResponse array from @plyaz/types/errors */
+    errors: ErrorResponse;
+    /** Channel this error occurred on */
+    channel: string;
+    /** Unix timestamp when error occurred */
+    timestamp: number;
+    /** Correlation ID for tracing */
+    correlationId?: string;
+}
+/**
+ * Paginated stream response for large datasets
+ */
+export interface PaginatedStreamResponse<T = unknown> extends StreamResponse<T[]> {
+    /** Pagination metadata */
+    pagination: {
+        /** Total items available */
+        total: number;
+        /** Current page number */
+        page: number;
+        /** Items per page */
+        pageSize: number;
+        /** Whether more items exist */
+        hasMore: boolean;
+    };
+}
+/**
+ * Configuration for stream endpoints
+ */
+export interface StreamEndpointConfig {
+    /** Unique endpoint key (like serviceKey in domain services) */
+    endpointKey: string;
+    /** Human-readable name */
+    name?: string;
+    /** Channels this endpoint manages */
+    channels: string[];
+    /** Whether endpoint is enabled */
+    enabled?: boolean;
+    /** Supported runtimes */
+    supportedRuntimes?: Array<'node' | 'bun' | 'deno' | 'edge'>;
+}
+/**
+ * Options for creating stream endpoints
+ */
+export interface StreamEndpointCreateOptions {
+    /** Broadcaster interface */
+    broadcaster: StreamBroadcasterInterface;
+    /** Optional auth adapter */
+    auth?: unknown;
+}
+/**
+ * Interface for StreamBroadcaster (for dependency injection)
+ */
+export interface StreamBroadcasterInterface {
+    /** Initialize event subscriptions and cleanup timer */
+    initialize(): void;
+    /** Broadcast message to a channel (fire-and-forget) */
+    broadcastToChannel(channel: string, message: unknown): void;
+    /** Send message to a specific connection */
+    sendToConnection(connectionId: string, message: unknown): Promise<void>;
+    /** Broadcast to all connections (system-wide) */
+    broadcastToAll(message: unknown): void;
+}
+/**
+ * Configuration for channel controllers
+ */
+export interface ChannelControllerConfig {
+    /** Channel scope (e.g., 'upload', 'generate', 'system') */
+    scope: string;
+    /** Channel patterns this controller handles */
+    patterns: string[];
+    /** Whether controller is enabled */
+    enabled?: boolean;
+}
+/**
+ * Context passed to stream middleware
+ */
+export interface StreamMiddlewareContext {
+    /** Active connection */
+    connection: StreamConnection;
+    /** Auth result for the connection */
+    authResult: StreamAuthResult;
+    /** Message being processed (if any) */
+    message?: StreamMessage;
+    /** Target channel (if any) */
+    channel?: string;
+}
+/**
+ * Result returned by stream middleware
+ */
+export interface StreamMiddlewareResult {
+    /** Whether to continue to next middleware */
+    continue: boolean;
+    /** Updated context (merged with current) */
+    context?: Partial<StreamMiddlewareContext>;
+    /** Error to return (if continue is false) */
+    error?: PackageErrorLike;
+}
+/**
+ * Stream middleware function signature
+ */
+export type StreamMiddleware = (context: StreamMiddlewareContext) => Promise<StreamMiddlewareResult>;
+/**
+ * Rate limit middleware configuration
+ */
+export interface RateLimitConfig {
+    /** Max connections per IP */
+    maxConnectionsPerIp?: number;
+    /** Max messages per second per connection */
+    maxMessagesPerSecond?: number;
+    /** Window size in ms */
+    windowMs?: number;
+}
+/**
+ * Entry for registering stream endpoints
+ */
+export interface StreamEndpointEntry {
+    /** Endpoint class with static create() */
+    endpoint: {
+        endpointKey: string;
+        create(config: StreamEndpointConfig, options: StreamEndpointCreateOptions): Promise<unknown>;
+    };
+    /** Endpoint configuration overrides */
+    config: Partial<StreamEndpointConfig>;
+}
+/**
+ * Configuration for StreamRegistry initialization
+ */
+export interface StreamRegistryConfig {
+    /** Stream endpoints to register */
+    endpoints: StreamEndpointEntry[];
+    /** Broadcaster instance */
+    broadcaster: StreamBroadcasterInterface;
+}