@plyaz/types 1.36.0 → 1.36.1

package/dist/errors/codes.d.ts

@@ -513,6 +513,26 @@ export declare const ERROR_CODES: {
     readonly NONCE_ALREADY_USED: "AUTH_NONCE_ALREADY_USED";
     readonly ACCOUNT_LOCKED: "AUTH_ACCOUNT_LOCKED";
     readonly ACCOUNT_SUSPENDED: "AUTH_ACCOUNT_SUSPENDED";
+    readonly STREAM_CONNECTION_FAILED: "stream.connection.failed";
+    readonly STREAM_CONNECTION_TIMEOUT: "stream.connection.timeout";
+    readonly STREAM_CONNECTION_CLOSED: "stream.connection.closed";
+    readonly STREAM_CHANNEL_NOT_FOUND: "stream.channel.not_found";
+    readonly STREAM_CHANNEL_FORBIDDEN: "stream.channel.forbidden";
+    readonly STREAM_SUBSCRIPTION_FAILED: "stream.subscription.failed";
+    readonly STREAM_UNSUBSCRIBE_FAILED: "stream.unsubscribe.failed";
+    readonly STREAM_BROADCAST_FAILED: "stream.broadcast.failed";
+    readonly STREAM_INVALID_MESSAGE: "stream.invalid.message";
+    readonly STREAM_MESSAGE_TOO_LARGE: "stream.message.too_large";
+    readonly STREAM_TRANSPORT_ERROR: "stream.transport.error";
+    readonly STREAM_TRANSPORT_NOT_SUPPORTED: "stream.transport.not_supported";
+    readonly STREAM_AUTH_REQUIRED: "stream.auth.required";
+    readonly STREAM_AUTH_FAILED: "stream.auth.failed";
+    readonly STREAM_TOKEN_EXPIRED: "stream.token.expired";
+    readonly STREAM_RATE_LIMITED: "stream.rate_limited";
+    readonly STREAM_ENDPOINT_NOT_FOUND: "stream.endpoint.not_found";
+    readonly STREAM_ENDPOINT_DISABLED: "stream.endpoint.disabled";
+    readonly STREAM_UNKNOWN_ERROR: "stream.unknown.error";
+    readonly STREAM_INITIALIZATION_FAILED: "stream.initialization.failed";
 };
 /**
  * Type for all error code values
@@ -1056,12 +1076,39 @@ export declare const DATABASE_ERROR_CODES: {
     readonly NOT_FOUND: "db.record_not_found";
     readonly UNKNOWN_ERROR: "db.unknown_error";
 };
+/**
+ * Streaming-specific error codes
+ * Subset of ERROR_CODES for real-time streaming (SSE/WebSocket)
+ */
+export declare const STREAM_ERROR_CODES: {
+    readonly CONNECTION_FAILED: "stream.connection.failed";
+    readonly CONNECTION_TIMEOUT: "stream.connection.timeout";
+    readonly CONNECTION_CLOSED: "stream.connection.closed";
+    readonly CHANNEL_NOT_FOUND: "stream.channel.not_found";
+    readonly CHANNEL_FORBIDDEN: "stream.channel.forbidden";
+    readonly SUBSCRIPTION_FAILED: "stream.subscription.failed";
+    readonly UNSUBSCRIBE_FAILED: "stream.unsubscribe.failed";
+    readonly BROADCAST_FAILED: "stream.broadcast.failed";
+    readonly INVALID_MESSAGE: "stream.invalid.message";
+    readonly MESSAGE_TOO_LARGE: "stream.message.too_large";
+    readonly TRANSPORT_ERROR: "stream.transport.error";
+    readonly TRANSPORT_NOT_SUPPORTED: "stream.transport.not_supported";
+    readonly AUTH_REQUIRED: "stream.auth.required";
+    readonly AUTH_FAILED: "stream.auth.failed";
+    readonly TOKEN_EXPIRED: "stream.token.expired";
+    readonly RATE_LIMITED: "stream.rate_limited";
+    readonly ENDPOINT_NOT_FOUND: "stream.endpoint.not_found";
+    readonly ENDPOINT_DISABLED: "stream.endpoint.disabled";
+    readonly UNKNOWN_ERROR: "stream.unknown.error";
+    readonly INITIALIZATION_FAILED: "stream.initialization.failed";
+};
 export type ApiErrorCodeValue = (typeof API_ERROR_CODES)[keyof typeof API_ERROR_CODES] | `HTTP_${number}`;
 export type NotificationErrorCodeValue = (typeof NOTIFICATION_ERROR_CODES)[keyof typeof NOTIFICATION_ERROR_CODES];
 export type StorageErrorCode = (typeof STORAGE_ERROR_CODES)[keyof typeof STORAGE_ERROR_CODES];
 export type DatabaseErrorCodeValue = (typeof DATABASE_ERROR_CODES)[keyof typeof DATABASE_ERROR_CODES];
 export type CoreErrorCodeValue = (typeof CORE_ERROR_CODES)[keyof typeof CORE_ERROR_CODES];
 export type PaymentErrorCodeValue = (typeof PAYMENT_ERROR_CODES)[keyof typeof PAYMENT_ERROR_CODES];
+export type StreamErrorCodeValue = (typeof STREAM_ERROR_CODES)[keyof typeof STREAM_ERROR_CODES];
 /**
  * Unified ERROR_DEFINITIONS
  * Single source of truth for ALL error definitions across all @plyaz packages

package/dist/errors/enums.d.ts

@@ -356,6 +356,7 @@ export declare const ERROR_EXCEPTIONS_NAMESPACES: {
     TESTING: string;
     CORE: string;
     STORE: string;
+    STREAM: string;
     WEB3: string;
     MONITORING: string;
     HOOKS: string;

package/dist/errors/index.cjs

@@ -274,6 +274,7 @@ var ERROR_EXCEPTIONS_NAMESPACES = {
   TESTING: "testing",
   CORE: "core",
   STORE: "store",
+  STREAM: "stream",
   WEB3: "web3",
   MONITORING: "monitoring",
   HOOKS: "hooks",
@@ -994,7 +995,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,
@@ -1575,6 +1605,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]: {
@@ -5651,6 +5711,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
   }
 };
 
@@ -5671,5 +5900,6 @@ exports.INTERNAL_STATUS_CODES = INTERNAL_STATUS_CODES;
 exports.NOTIFICATION_ERROR_CODES = NOTIFICATION_ERROR_CODES;
 exports.PAYMENT_ERROR_CODES = PAYMENT_ERROR_CODES;
 exports.STORAGE_ERROR_CODES = STORAGE_ERROR_CODES;
+exports.STREAM_ERROR_CODES = STREAM_ERROR_CODES;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map