@plyaz/types 1.36.0 → 1.36.2

package/dist/errors/types.d.ts

@@ -736,3 +736,18 @@ export interface SanitizeConfig {
      */
     limitComplexTypes?: boolean;
 }
+/**
+ * Options for creating stream errors (SSE/WebSocket)
+ */
+export interface StreamErrorOptions {
+    /** Error context */
+    context?: BaseErrorContext;
+    /** Original error */
+    cause?: Error;
+    /** Additional metadata */
+    metadata?: Record<string, string | number | boolean | null>;
+    /** Correlation ID */
+    correlationId?: string;
+    /** HTTP status code override */
+    statusCode?: number;
+}

package/dist/index.cjs

@@ -278,6 +278,7 @@ var ERROR_EXCEPTIONS_NAMESPACES = {
   TESTING: "testing",
   CORE: "core",
   STORE: "store",
+  STREAM: "stream",
   WEB3: "web3",
   MONITORING: "monitoring",
   HOOKS: "hooks",
@@ -1160,7 +1161,36 @@ var ERROR_CODES = {
   NONCE_EXPIRED: "AUTH_NONCE_EXPIRED",
   NONCE_ALREADY_USED: "AUTH_NONCE_ALREADY_USED",
   ACCOUNT_LOCKED: "AUTH_ACCOUNT_LOCKED",
-  ACCOUNT_SUSPENDED: "AUTH_ACCOUNT_SUSPENDED"
+  ACCOUNT_SUSPENDED: "AUTH_ACCOUNT_SUSPENDED",
+  // ===== Streaming Errors =====
+  // Connection
+  STREAM_CONNECTION_FAILED: "stream.connection.failed",
+  STREAM_CONNECTION_TIMEOUT: "stream.connection.timeout",
+  STREAM_CONNECTION_CLOSED: "stream.connection.closed",
+  // Channel
+  STREAM_CHANNEL_NOT_FOUND: "stream.channel.not_found",
+  STREAM_CHANNEL_FORBIDDEN: "stream.channel.forbidden",
+  STREAM_SUBSCRIPTION_FAILED: "stream.subscription.failed",
+  STREAM_UNSUBSCRIBE_FAILED: "stream.unsubscribe.failed",
+  // Broadcasting
+  STREAM_BROADCAST_FAILED: "stream.broadcast.failed",
+  STREAM_INVALID_MESSAGE: "stream.invalid.message",
+  STREAM_MESSAGE_TOO_LARGE: "stream.message.too_large",
+  // Transport
+  STREAM_TRANSPORT_ERROR: "stream.transport.error",
+  STREAM_TRANSPORT_NOT_SUPPORTED: "stream.transport.not_supported",
+  // Authentication
+  STREAM_AUTH_REQUIRED: "stream.auth.required",
+  STREAM_AUTH_FAILED: "stream.auth.failed",
+  STREAM_TOKEN_EXPIRED: "stream.token.expired",
+  // Rate Limiting
+  STREAM_RATE_LIMITED: "stream.rate_limited",
+  // Endpoint
+  STREAM_ENDPOINT_NOT_FOUND: "stream.endpoint.not_found",
+  STREAM_ENDPOINT_DISABLED: "stream.endpoint.disabled",
+  // General
+  STREAM_UNKNOWN_ERROR: "stream.unknown.error",
+  STREAM_INITIALIZATION_FAILED: "stream.initialization.failed"
 };
 var API_ERROR_CODES = {
   CLIENT_INITIALIZATION_FAILED: ERROR_CODES.CLIENT_INITIALIZATION_FAILED,
@@ -1741,6 +1771,36 @@ var DATABASE_ERROR_CODES = {
   NOT_FOUND: ERROR_CODES.DB_RECORD_NOT_FOUND,
   UNKNOWN_ERROR: ERROR_CODES.DB_UNKNOWN_ERROR
 };
+var STREAM_ERROR_CODES = {
+  // Connection
+  CONNECTION_FAILED: ERROR_CODES.STREAM_CONNECTION_FAILED,
+  CONNECTION_TIMEOUT: ERROR_CODES.STREAM_CONNECTION_TIMEOUT,
+  CONNECTION_CLOSED: ERROR_CODES.STREAM_CONNECTION_CLOSED,
+  // Channel
+  CHANNEL_NOT_FOUND: ERROR_CODES.STREAM_CHANNEL_NOT_FOUND,
+  CHANNEL_FORBIDDEN: ERROR_CODES.STREAM_CHANNEL_FORBIDDEN,
+  SUBSCRIPTION_FAILED: ERROR_CODES.STREAM_SUBSCRIPTION_FAILED,
+  UNSUBSCRIBE_FAILED: ERROR_CODES.STREAM_UNSUBSCRIBE_FAILED,
+  // Broadcasting
+  BROADCAST_FAILED: ERROR_CODES.STREAM_BROADCAST_FAILED,
+  INVALID_MESSAGE: ERROR_CODES.STREAM_INVALID_MESSAGE,
+  MESSAGE_TOO_LARGE: ERROR_CODES.STREAM_MESSAGE_TOO_LARGE,
+  // Transport
+  TRANSPORT_ERROR: ERROR_CODES.STREAM_TRANSPORT_ERROR,
+  TRANSPORT_NOT_SUPPORTED: ERROR_CODES.STREAM_TRANSPORT_NOT_SUPPORTED,
+  // Authentication
+  AUTH_REQUIRED: ERROR_CODES.STREAM_AUTH_REQUIRED,
+  AUTH_FAILED: ERROR_CODES.STREAM_AUTH_FAILED,
+  TOKEN_EXPIRED: ERROR_CODES.STREAM_TOKEN_EXPIRED,
+  // Rate Limiting
+  RATE_LIMITED: ERROR_CODES.STREAM_RATE_LIMITED,
+  // Endpoint
+  ENDPOINT_NOT_FOUND: ERROR_CODES.STREAM_ENDPOINT_NOT_FOUND,
+  ENDPOINT_DISABLED: ERROR_CODES.STREAM_ENDPOINT_DISABLED,
+  // General
+  UNKNOWN_ERROR: ERROR_CODES.STREAM_UNKNOWN_ERROR,
+  INITIALIZATION_FAILED: ERROR_CODES.STREAM_INITIALIZATION_FAILED
+};
 var ERROR_DEFINITIONS = {
   // ===== Generic/Common Error Definitions =====
   [ERROR_CODES.NOT_IMPLEMENTED]: {
@@ -5817,6 +5877,175 @@ var ERROR_DEFINITIONS = {
     userMessage: "errors.auth.account_suspended",
     severity: ERROR_SEVERITY.High,
     retryable: false
+  },
+  // ===== Streaming Error Definitions =====
+  // Connection
+  [ERROR_CODES.STREAM_CONNECTION_FAILED]: {
+    code: ERROR_CODES.STREAM_CONNECTION_FAILED,
+    status: HTTP_STATUS.SERVICE_UNAVAILABLE,
+    category: ERROR_CATEGORY.Network,
+    userMessage: "errors.stream.connection_failed",
+    severity: ERROR_SEVERITY.High,
+    retryable: true
+  },
+  [ERROR_CODES.STREAM_CONNECTION_TIMEOUT]: {
+    code: ERROR_CODES.STREAM_CONNECTION_TIMEOUT,
+    status: HTTP_STATUS.REQUEST_TIMEOUT,
+    category: ERROR_CATEGORY.Network,
+    userMessage: "errors.stream.connection_timeout",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: true
+  },
+  [ERROR_CODES.STREAM_CONNECTION_CLOSED]: {
+    code: ERROR_CODES.STREAM_CONNECTION_CLOSED,
+    status: HTTP_STATUS.OK,
+    category: ERROR_CATEGORY.Network,
+    userMessage: "errors.stream.connection_closed",
+    severity: ERROR_SEVERITY.Low,
+    retryable: true
+  },
+  // Channel
+  [ERROR_CODES.STREAM_CHANNEL_NOT_FOUND]: {
+    code: ERROR_CODES.STREAM_CHANNEL_NOT_FOUND,
+    status: HTTP_STATUS.NOT_FOUND,
+    category: ERROR_CATEGORY.Validation,
+    userMessage: "errors.stream.channel_not_found",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
+  [ERROR_CODES.STREAM_CHANNEL_FORBIDDEN]: {
+    code: ERROR_CODES.STREAM_CHANNEL_FORBIDDEN,
+    status: HTTP_STATUS.FORBIDDEN,
+    category: ERROR_CATEGORY.Authorization,
+    userMessage: "errors.stream.channel_forbidden",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
+  [ERROR_CODES.STREAM_SUBSCRIPTION_FAILED]: {
+    code: ERROR_CODES.STREAM_SUBSCRIPTION_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.System,
+    userMessage: "errors.stream.subscription_failed",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: true
+  },
+  [ERROR_CODES.STREAM_UNSUBSCRIBE_FAILED]: {
+    code: ERROR_CODES.STREAM_UNSUBSCRIBE_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.System,
+    userMessage: "errors.stream.unsubscribe_failed",
+    severity: ERROR_SEVERITY.Low,
+    retryable: true
+  },
+  // Broadcasting
+  [ERROR_CODES.STREAM_BROADCAST_FAILED]: {
+    code: ERROR_CODES.STREAM_BROADCAST_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.System,
+    userMessage: "errors.stream.broadcast_failed",
+    severity: ERROR_SEVERITY.High,
+    retryable: true
+  },
+  [ERROR_CODES.STREAM_INVALID_MESSAGE]: {
+    code: ERROR_CODES.STREAM_INVALID_MESSAGE,
+    status: HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    userMessage: "errors.stream.invalid_message",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
+  [ERROR_CODES.STREAM_MESSAGE_TOO_LARGE]: {
+    code: ERROR_CODES.STREAM_MESSAGE_TOO_LARGE,
+    status: HTTP_STATUS.PAYLOAD_TOO_LARGE,
+    category: ERROR_CATEGORY.Validation,
+    userMessage: "errors.stream.message_too_large",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
+  // Transport
+  [ERROR_CODES.STREAM_TRANSPORT_ERROR]: {
+    code: ERROR_CODES.STREAM_TRANSPORT_ERROR,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.System,
+    userMessage: "errors.stream.transport_error",
+    severity: ERROR_SEVERITY.High,
+    retryable: true
+  },
+  [ERROR_CODES.STREAM_TRANSPORT_NOT_SUPPORTED]: {
+    code: ERROR_CODES.STREAM_TRANSPORT_NOT_SUPPORTED,
+    status: HTTP_STATUS.NOT_IMPLEMENTED,
+    category: ERROR_CATEGORY.System,
+    userMessage: "errors.stream.transport_not_supported",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
+  // Authentication
+  [ERROR_CODES.STREAM_AUTH_REQUIRED]: {
+    code: ERROR_CODES.STREAM_AUTH_REQUIRED,
+    status: HTTP_STATUS.UNAUTHORIZED,
+    category: ERROR_CATEGORY.Authentication,
+    userMessage: "errors.stream.auth_required",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
+  [ERROR_CODES.STREAM_AUTH_FAILED]: {
+    code: ERROR_CODES.STREAM_AUTH_FAILED,
+    status: HTTP_STATUS.UNAUTHORIZED,
+    category: ERROR_CATEGORY.Authentication,
+    userMessage: "errors.stream.auth_failed",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
+  [ERROR_CODES.STREAM_TOKEN_EXPIRED]: {
+    code: ERROR_CODES.STREAM_TOKEN_EXPIRED,
+    status: HTTP_STATUS.UNAUTHORIZED,
+    category: ERROR_CATEGORY.Authentication,
+    userMessage: "errors.stream.token_expired",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: true
+  },
+  // Rate Limiting
+  [ERROR_CODES.STREAM_RATE_LIMITED]: {
+    code: ERROR_CODES.STREAM_RATE_LIMITED,
+    status: HTTP_STATUS.TOO_MANY_REQUESTS,
+    category: ERROR_CATEGORY.RateLimit,
+    userMessage: "errors.stream.rate_limited",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: true
+  },
+  // Endpoint
+  [ERROR_CODES.STREAM_ENDPOINT_NOT_FOUND]: {
+    code: ERROR_CODES.STREAM_ENDPOINT_NOT_FOUND,
+    status: HTTP_STATUS.NOT_FOUND,
+    category: ERROR_CATEGORY.System,
+    userMessage: "errors.stream.endpoint_not_found",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
+  [ERROR_CODES.STREAM_ENDPOINT_DISABLED]: {
+    code: ERROR_CODES.STREAM_ENDPOINT_DISABLED,
+    status: HTTP_STATUS.SERVICE_UNAVAILABLE,
+    category: ERROR_CATEGORY.System,
+    userMessage: "errors.stream.endpoint_disabled",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
+  // General
+  [ERROR_CODES.STREAM_UNKNOWN_ERROR]: {
+    code: ERROR_CODES.STREAM_UNKNOWN_ERROR,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.System,
+    userMessage: "errors.stream.unknown_error",
+    severity: ERROR_SEVERITY.High,
+    retryable: true
+  },
+  [ERROR_CODES.STREAM_INITIALIZATION_FAILED]: {
+    code: ERROR_CODES.STREAM_INITIALIZATION_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.System,
+    userMessage: "errors.stream.initialization_failed",
+    severity: ERROR_SEVERITY.Critical,
+    retryable: true
   }
 };
 
@@ -6465,6 +6694,195 @@ var CORE_EVENTS = {
   }
 };
 
+// src/core/domain/files/enums.ts
+var SYSTEM_USER_ID = "00000000-0000-0000-0000-000000000000";
+var FILE_TYPES = {
+  IMAGE: "IMAGE",
+  VIDEO: "VIDEO",
+  AUDIO: "AUDIO",
+  DOCUMENT: "DOCUMENT"
+};
+var FILE_ACCESS_LEVELS = {
+  PUBLIC: "public",
+  PRIVATE: "private",
+  PROTECTED: "protected"
+};
+
+// src/core/domain/files/streaming.ts
+var FILES_STREAM_MESSAGE_TYPE = {
+  PROGRESS: "progress",
+  STATUS: "status",
+  ERROR: "error"
+};
+var FILES_STREAM_SUBTYPE = {
+  UPLOAD: "upload",
+  DOWNLOAD: "download",
+  GENERATE: "generate"
+};
+var FILES_STREAM_PROGRESS_STATUS = {
+  PENDING: "pending",
+  UPLOADING: "uploading",
+  DOWNLOADING: "downloading",
+  PROCESSING: "processing",
+  GENERATING: "generating",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  CANCELLED: "cancelled"
+};
+var FILES_STREAM_EVENT = {
+  // Upload events
+  UPLOAD_PROGRESS: "upload:progress",
+  UPLOAD_COMPLETED: "upload:completed",
+  UPLOAD_FAILED: "upload:failed",
+  UPLOAD_CANCELLED: "upload:cancelled",
+  // Download events
+  DOWNLOAD_PROGRESS: "download:progress",
+  DOWNLOAD_COMPLETED: "download:completed",
+  DOWNLOAD_FAILED: "download:failed",
+  DOWNLOAD_CANCELLED: "download:cancelled",
+  // Generation events
+  GENERATE_PROGRESS: "generate:progress",
+  GENERATE_COMPLETED: "generate:completed",
+  GENERATE_FAILED: "generate:failed"
+};
+var FILES_STREAM_CHANNEL_PREFIX = {
+  UPLOAD: "upload:",
+  DOWNLOAD: "download:",
+  GENERATE: "generate:"
+};
+var FILES_STREAM_BROADCAST_CHANNEL = {
+  UPLOADS: "uploads",
+  DOWNLOADS: "downloads",
+  GENERATIONS: "generations"
+};
+var FILES_STREAM_CHANNEL = {
+  // Prefixes (for building per-resource channels)
+  PREFIX: FILES_STREAM_CHANNEL_PREFIX,
+  // Broadcast channels
+  BROADCAST: FILES_STREAM_BROADCAST_CHANNEL
+};
+var MediaTypeSchema = zod.z.enum(["IMAGE", "VIDEO", "AUDIO", "DOCUMENT"]);
+var FileTypeSchema = zod.z.enum(["IMAGE", "VIDEO", "DOCUMENT", "AUDIO", "OTHER"]);
+var MediaAccessLevelSchema = zod.z.enum(["public", "private", "protected"]).nullable();
+var FilesDatabaseRowSchema = zod.z.object({
+  // Auto-generated fields
+  id: zod.z.string().uuid(),
+  created_at: zod.z.string(),
+  updated_at: zod.z.string(),
+  deleted_at: zod.z.string().nullable(),
+  // Required fields
+  user_id: zod.z.string().uuid(),
+  type: zod.z.string(),
+  // String in DB, validated as MediaType on create
+  filename: zod.z.string(),
+  original_filename: zod.z.string(),
+  mime_type: zod.z.string(),
+  file_size: zod.z.union([zod.z.bigint(), zod.z.number()]),
+  storage_path: zod.z.string(),
+  // Optional fields
+  cdn_url: zod.z.string().nullable(),
+  width: zod.z.number().nullable(),
+  height: zod.z.number().nullable(),
+  duration: zod.z.number().nullable(),
+  is_virus_scanned: zod.z.boolean(),
+  virus_scan_result: zod.z.string().nullable(),
+  metadata: zod.z.record(zod.z.string(), zod.z.unknown()).nullable(),
+  variants: zod.z.record(zod.z.string(), zod.z.unknown()).nullable(),
+  entity_type: zod.z.string().nullable(),
+  entity_id: zod.z.string().nullable(),
+  access_level: zod.z.string().nullable()
+});
+var CreateFilesSchema = zod.z.object({
+  // Required fields with defaults for optional scenarios
+  user_id: zod.z.string().uuid().default(SYSTEM_USER_ID),
+  type: MediaTypeSchema.default("DOCUMENT"),
+  filename: zod.z.string().min(1, "Filename is required"),
+  original_filename: zod.z.string().min(1, "Original filename is required"),
+  mime_type: zod.z.string().min(1, "MIME type is required"),
+  file_size: zod.z.union([zod.z.bigint(), zod.z.number()]).refine((val) => Number(val) >= 0, "File size must be non-negative"),
+  storage_path: zod.z.string().min(1, "Storage path is required"),
+  // Optional fields with defaults
+  cdn_url: zod.z.string().url().nullable().default(null),
+  width: zod.z.number().positive().nullable().default(null),
+  height: zod.z.number().positive().nullable().default(null),
+  duration: zod.z.number().positive().nullable().default(null),
+  is_virus_scanned: zod.z.boolean().default(false),
+  virus_scan_result: zod.z.string().nullable().default(null),
+  metadata: zod.z.record(zod.z.string(), zod.z.unknown()).nullable().default(null),
+  variants: zod.z.record(zod.z.string(), zod.z.unknown()).nullable().default(null),
+  entity_type: zod.z.string().nullable().default(null),
+  entity_id: zod.z.string().nullable().default(null),
+  access_level: MediaAccessLevelSchema.default(null)
+});
+var PatchFilesSchema = CreateFilesSchema.partial();
+var MediaVariantsDatabaseRowSchema = zod.z.object({
+  id: zod.z.string().uuid(),
+  media_id: zod.z.string().uuid(),
+  variant_name: zod.z.string(),
+  file_path: zod.z.string(),
+  cdn_url: zod.z.string().nullable(),
+  width: zod.z.number().nullable(),
+  height: zod.z.number().nullable(),
+  file_size: zod.z.number().nullable(),
+  created_at: zod.z.string()
+});
+var CreateMediaVariantSchema = MediaVariantsDatabaseRowSchema.omit({
+  id: true,
+  created_at: true
+});
+
+// src/core/events/streaming/types.ts
+var STREAM_TRANSPORT = {
+  SSE: "sse",
+  WEBSOCKET: "websocket"
+};
+var SYSTEM_STREAM_MESSAGE_TYPE = {
+  SYSTEM: "system",
+  NOTIFICATION: "notification",
+  DATA: "data"
+};
+var SYSTEM_STREAM_SUBTYPE = {
+  HEARTBEAT: "heartbeat",
+  CONNECTED: "connected",
+  DISCONNECTED: "disconnected",
+  RECONNECTING: "reconnecting"
+};
+var SYSTEM_STREAM_CHANNEL = {
+  SYSTEM: "system"
+};
+var STREAM_MESSAGE_TYPE = {
+  ...SYSTEM_STREAM_MESSAGE_TYPE,
+  ...FILES_STREAM_MESSAGE_TYPE
+};
+var STREAM_SUBTYPE = {
+  ...SYSTEM_STREAM_SUBTYPE,
+  ...FILES_STREAM_SUBTYPE
+};
+var STREAM_SCOPE = {
+  FILES: "files",
+  SYSTEM: "system"
+};
+var SYSTEM_STREAM_EVENT = {
+  CONNECTED: "connected",
+  DISCONNECTED: "disconnected",
+  HEARTBEAT: "heartbeat",
+  ERROR: "error"
+};
+var STREAM_EVENT = {
+  ...SYSTEM_STREAM_EVENT,
+  ...FILES_STREAM_EVENT
+};
+var STREAM_CHANNEL_PREFIX = {
+  ...FILES_STREAM_CHANNEL_PREFIX
+};
+var STREAM_BROADCAST_CHANNEL = {
+  ...SYSTEM_STREAM_CHANNEL,
+  ...FILES_STREAM_BROADCAST_CHANNEL
+};
+var STREAM_PROGRESS_STATUS = {
+  ...FILES_STREAM_PROGRESS_STATUS
+};
+
 // src/core/services/keys.ts
 var SERVICE_KEYS = {
   /** Example domain service (backend) */
@@ -9297,6 +9715,8 @@ exports.ContactUsFormSchema = ContactUsFormSchema;
 exports.CoreEventScope = CoreEventScope;
 exports.CorrelationIdSchema = CorrelationIdSchema;
 exports.CreateCampaignSchema = CreateCampaignSchema;
+exports.CreateFilesSchema = CreateFilesSchema;
+exports.CreateMediaVariantSchema = CreateMediaVariantSchema;
 exports.DATABASE_ERROR_CODES = DATABASE_ERROR_CODES;
 exports.DATABASE_EVENT_TYPE = DATABASE_EVENT_TYPE;
 exports.DATABASE_FIELDS = DATABASE_FIELDS;
@@ -9348,12 +9768,23 @@ exports.FEATURE_FLAG_TABLE = FEATURE_FLAG_TABLE;
 exports.FEATURE_FLAG_TYPES = FEATURE_FLAG_TYPES;
 exports.FEE_CONTEXT = FEE_CONTEXT;
 exports.FEE_TYPE = FEE_TYPE;
+exports.FILES_STREAM_BROADCAST_CHANNEL = FILES_STREAM_BROADCAST_CHANNEL;
+exports.FILES_STREAM_CHANNEL = FILES_STREAM_CHANNEL;
+exports.FILES_STREAM_CHANNEL_PREFIX = FILES_STREAM_CHANNEL_PREFIX;
+exports.FILES_STREAM_EVENT = FILES_STREAM_EVENT;
+exports.FILES_STREAM_MESSAGE_TYPE = FILES_STREAM_MESSAGE_TYPE;
+exports.FILES_STREAM_PROGRESS_STATUS = FILES_STREAM_PROGRESS_STATUS;
+exports.FILES_STREAM_SUBTYPE = FILES_STREAM_SUBTYPE;
 exports.FILE_ACCESS_LEVEL = FILE_ACCESS_LEVEL;
+exports.FILE_ACCESS_LEVELS = FILE_ACCESS_LEVELS;
 exports.FILE_CATEGORY = FILE_CATEGORY;
 exports.FILE_EXTENSIONS = FILE_EXTENSIONS;
+exports.FILE_TYPES = FILE_TYPES;
 exports.FILE_VALIDATION_ERROR = FILE_VALIDATION_ERROR;
 exports.FRONTEND_RUNTIMES = FRONTEND_RUNTIMES;
 exports.FeatureFlagEventAction = FeatureFlagEventAction;
+exports.FileTypeSchema = FileTypeSchema;
+exports.FilesDatabaseRowSchema = FilesDatabaseRowSchema;
 exports.HANDLER_SCOPES = HANDLER_SCOPES;
 exports.HEADER_EVENTS = HEADER_EVENTS;
 exports.HEADER_STAGES = HEADER_STAGES;
@@ -9387,6 +9818,9 @@ exports.MFATYPE = MFATYPE;
 exports.MILESTONE_STATUS = MILESTONE_STATUS;
 exports.MILESTONE_TRIGGER_TYPE = MILESTONE_TRIGGER_TYPE;
 exports.MIME_TYPES = MIME_TYPES;
+exports.MediaAccessLevelSchema = MediaAccessLevelSchema;
+exports.MediaTypeSchema = MediaTypeSchema;
+exports.MediaVariantsDatabaseRowSchema = MediaVariantsDatabaseRowSchema;
 exports.NETWORK_CONFIDENCE_LEVELS = NETWORK_CONFIDENCE_LEVELS;
 exports.NETWORK_EVENTS = NETWORK_EVENTS;
 exports.NETWORK_QUALITY = NETWORK_QUALITY;
@@ -9427,6 +9861,7 @@ exports.PROVIDERTYPE = PROVIDERTYPE;
 exports.PROVIDER_PRODUCT_STATUS = PROVIDER_PRODUCT_STATUS;
 exports.PUB_SUB_EVENT = PUB_SUB_EVENT;
 exports.PatchCampaignSchema = PatchCampaignSchema;
+exports.PatchFilesSchema = PatchFilesSchema;
 exports.PhoneSchema = PhoneSchema;
 exports.QUEUE_OPERATIONS = QUEUE_OPERATIONS;
 exports.QueryCampaignSchema = QueryCampaignSchema;
@@ -9470,7 +9905,21 @@ exports.STORAGE_TYPES = COMMON_STORAGE_TYPES;
 exports.STORAGE_VARIANT_NAME = STORAGE_VARIANT_NAME;
 exports.STORAGE_VISIBILITY = STORAGE_VISIBILITY;
 exports.STORAGE_WEBHOOK_EVENT_TYPE = STORAGE_WEBHOOK_EVENT_TYPE;
+exports.STREAM_BROADCAST_CHANNEL = STREAM_BROADCAST_CHANNEL;
+exports.STREAM_CHANNEL_PREFIX = STREAM_CHANNEL_PREFIX;
+exports.STREAM_ERROR_CODES = STREAM_ERROR_CODES;
+exports.STREAM_EVENT = STREAM_EVENT;
+exports.STREAM_MESSAGE_TYPE = STREAM_MESSAGE_TYPE;
+exports.STREAM_PROGRESS_STATUS = STREAM_PROGRESS_STATUS;
+exports.STREAM_SCOPE = STREAM_SCOPE;
+exports.STREAM_SUBTYPE = STREAM_SUBTYPE;
+exports.STREAM_TRANSPORT = STREAM_TRANSPORT;
+exports.SYSTEM_STREAM_CHANNEL = SYSTEM_STREAM_CHANNEL;
+exports.SYSTEM_STREAM_EVENT = SYSTEM_STREAM_EVENT;
+exports.SYSTEM_STREAM_MESSAGE_TYPE = SYSTEM_STREAM_MESSAGE_TYPE;
+exports.SYSTEM_STREAM_SUBTYPE = SYSTEM_STREAM_SUBTYPE;
 exports.SYSTEM_USERS = SYSTEM_USERS;
+exports.SYSTEM_USER_ID = SYSTEM_USER_ID;
 exports.SanitizationEventAction = SanitizationEventAction;
 exports.SendGridEventSchema = SendGridEventSchema;
 exports.SendGridWebhookSchema = SendGridWebhookSchema;