@burdenoff/be-sdk 2026.510.79

package/dist/index-CyVEg86m.d.ts

@@ -0,0 +1,309 @@
+import { B as BurdenoffGraphQLClient } from './graphql-BAVrUgBF.js';
+import { S as SDKContext } from './index-CHbVw5M7.js';
+
+declare enum NotificationChannel$1 {
+    EMAIL = "EMAIL",
+    SMS = "SMS",
+    PUSH = "PUSH",
+    IN_APP = "IN_APP",
+    WEBHOOK = "WEBHOOK",
+    WHATSAPP = "WHATSAPP",
+    TEAMS = "TEAMS",
+    SLACK = "SLACK",
+    TELEGRAM = "TELEGRAM",
+    DISCORD = "DISCORD"
+}
+declare enum NotificationPriority {
+    LOW = "LOW",
+    MEDIUM = "MEDIUM",
+    HIGH = "HIGH",
+    URGENT = "URGENT"
+}
+declare enum NotificationType$1 {
+    TRANSACTIONAL = "TRANSACTIONAL",
+    MARKETING = "MARKETING",
+    SYSTEM = "SYSTEM",
+    ALERT = "ALERT"
+}
+interface RecipientInput$1 {
+    userId?: string;
+    email?: string;
+    phoneNumber?: string;
+    pushToken?: string;
+    whatsappNumber?: string;
+    teamsUserId?: string;
+    slackUserId?: string;
+    webhookUrl?: string;
+    name?: string;
+    locale?: string;
+    timezone?: string;
+}
+interface SendNotificationInput {
+    recipient: RecipientInput$1;
+    channel: NotificationChannel$1;
+    type?: NotificationType$1;
+    priority?: NotificationPriority;
+    subject?: string;
+    body: string;
+    htmlBody?: string;
+    data?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    scheduledFor?: Date;
+    expiresAt?: Date;
+    trackOpens?: boolean;
+    trackClicks?: boolean;
+}
+interface SendWithTemplateInput {
+    templateSlug: string;
+    variables: Record<string, unknown>;
+    recipient: RecipientInput$1;
+    priority?: NotificationPriority;
+    scheduledFor?: Date;
+    expiresAt?: Date;
+    trackOpens?: boolean;
+    trackClicks?: boolean;
+    channelId?: string;
+    platform?: NotificationChannel$1;
+    timezone?: string;
+}
+interface BatchNotificationInput {
+    notifications: SendNotificationInput[];
+    batchSize?: number;
+    delayBetweenBatches?: number;
+    priority?: NotificationPriority;
+}
+interface Notification$1 {
+    id: string;
+    userId: string;
+    channel: NotificationChannel$1;
+    type: NotificationType$1;
+    priority: NotificationPriority;
+    status: string;
+    deliveryStatus?: string;
+    title: string;
+    message: string;
+    htmlMessage?: string;
+    subject?: string;
+    recipientEmail?: string;
+    recipientPhone?: string;
+    trackOpens: boolean;
+    trackClicks: boolean;
+    openedAt?: string;
+    clickedAt?: string;
+    sentAt?: string;
+    deliveredAt?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface NotificationTemplate {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    channel: NotificationChannel$1;
+    type: NotificationType$1;
+    locale: string;
+    subject?: string;
+    bodyTemplate: string;
+    htmlTemplate?: string;
+    variables: Array<{
+        name: string;
+        type: string;
+        required: boolean;
+        defaultValue?: unknown;
+        description?: string;
+        example?: unknown;
+    }>;
+    enabled: boolean;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface NotificationStats {
+    total: number;
+    pending: number;
+    queued: number;
+    processing: number;
+    sent: number;
+    delivered: number;
+    failed: number;
+    byChannel: Record<string, number>;
+    byType: Record<string, number>;
+}
+declare class TenantNotificationsModule {
+    private client;
+    private context;
+    constructor(client: BurdenoffGraphQLClient, context: SDKContext);
+    send(input: SendNotificationInput): Promise<string>;
+    sendWithTemplate(input: SendWithTemplateInput): Promise<string>;
+    sendBatch(input: BatchNotificationInput): Promise<{
+        totalRequested: number;
+        totalQueued: number;
+        totalFailed: number;
+        batchId: string;
+    }>;
+    getNotification(id: string): Promise<Notification$1 | null>;
+    getNotifications(filter?: {
+        userId?: string;
+        channel?: NotificationChannel$1;
+        type?: NotificationType$1;
+        status?: string;
+        priority?: NotificationPriority;
+        startDate?: Date;
+        endDate?: Date;
+        limit?: number;
+        offset?: number;
+    }): Promise<Notification$1[]>;
+    getTemplate(slug: string, locale?: string): Promise<NotificationTemplate | null>;
+    getTemplates(filter?: {
+        channel?: NotificationChannel$1;
+        type?: NotificationType$1;
+        enabled?: boolean;
+    }): Promise<NotificationTemplate[]>;
+    getStats(filter?: {
+        userId?: string;
+        startDate?: Date;
+        endDate?: Date;
+    }): Promise<NotificationStats>;
+    markAsRead(notificationIds: string[]): Promise<boolean>;
+    markAllAsRead(): Promise<boolean>;
+    deleteNotifications(notificationIds: string[]): Promise<boolean>;
+    deleteAllReadNotifications(): Promise<boolean>;
+    private validateSendInput;
+}
+
+type tenantNotifications_BatchNotificationInput = BatchNotificationInput;
+type tenantNotifications_NotificationPriority = NotificationPriority;
+declare const tenantNotifications_NotificationPriority: typeof NotificationPriority;
+type tenantNotifications_NotificationStats = NotificationStats;
+type tenantNotifications_NotificationTemplate = NotificationTemplate;
+type tenantNotifications_SendNotificationInput = SendNotificationInput;
+type tenantNotifications_SendWithTemplateInput = SendWithTemplateInput;
+type tenantNotifications_TenantNotificationsModule = TenantNotificationsModule;
+declare const tenantNotifications_TenantNotificationsModule: typeof TenantNotificationsModule;
+declare namespace tenantNotifications {
+  export { type tenantNotifications_BatchNotificationInput as BatchNotificationInput, type Notification$1 as Notification, NotificationChannel$1 as NotificationChannel, tenantNotifications_NotificationPriority as NotificationPriority, type tenantNotifications_NotificationStats as NotificationStats, type tenantNotifications_NotificationTemplate as NotificationTemplate, NotificationType$1 as NotificationType, type RecipientInput$1 as RecipientInput, type tenantNotifications_SendNotificationInput as SendNotificationInput, type tenantNotifications_SendWithTemplateInput as SendWithTemplateInput, tenantNotifications_TenantNotificationsModule as TenantNotificationsModule };
+}
+
+declare enum NotificationType {
+    INFO = "info",
+    SUCCESS = "success",
+    WARNING = "warning",
+    ERROR = "error"
+}
+declare enum NotificationChannel {
+    EMAIL = "EMAIL",
+    SMS = "SMS",
+    WHATSAPP = "WHATSAPP",
+    PUSH = "PUSH",
+    SLACK = "SLACK",
+    TEAMS = "TEAMS",
+    WEBHOOK = "WEBHOOK"
+}
+
+interface SendNotificationOptions {
+    title: string;
+    message: string;
+    type?: NotificationType;
+    userIds: string[];
+    redirectUrl?: string;
+    appName?: string;
+    email?: boolean;
+    sms?: boolean;
+}
+interface NotificationResponse {
+    successCount: number;
+    failureCount: number;
+    errors: string[];
+    notificationIds?: string[];
+}
+interface GetNotificationsOptions {
+    userId: string;
+    status?: 'unread' | 'read' | 'all';
+    type?: NotificationType;
+    appName?: string;
+    search?: string;
+    limit?: number;
+    offset?: number;
+}
+interface Notification {
+    id: string;
+    userId: string;
+    title: string;
+    message: string;
+    type: NotificationType;
+    status: 'unread' | 'read';
+    redirectUrl?: string;
+    appName?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface RecipientInput {
+    email?: string;
+    locale?: string;
+    name?: string;
+    phoneNumber?: string;
+    pushToken?: string;
+    slackUserId?: string;
+    teamsUserId?: string;
+    timezone?: string;
+    userId?: string;
+    webhookUrl?: string;
+    whatsappNumber?: string;
+}
+interface SendChannelNotificationOptions {
+    platform: NotificationChannel;
+    recipient: RecipientInput;
+    recipients?: RecipientInput[];
+    subject?: string;
+    body: string;
+    htmlBody?: string;
+    type?: NotificationType;
+    appName?: string;
+    redirectUrl?: string;
+    includeInApp?: boolean;
+    userIds?: string[];
+    metadata?: Record<string, unknown>;
+    trackOpens?: boolean;
+    trackClicks?: boolean;
+    expiresAt?: Date;
+    channelId?: string;
+}
+interface SendTemplateNotificationOptions {
+    platform: NotificationChannel;
+    templateSlug: string;
+    variables: Record<string, unknown>;
+    recipient?: RecipientInput;
+    recipients?: RecipientInput[];
+    includeInApp?: boolean;
+    userIds?: string[];
+    appName?: string;
+    trackOpens?: boolean;
+    trackClicks?: boolean;
+    expiresAt?: Date;
+    scheduledFor?: Date;
+    timezone?: string;
+    channelId?: string;
+}
+declare class NotificationsModule {
+    private client;
+    private context;
+    constructor(client: BurdenoffGraphQLClient, context: SDKContext);
+    send(options: SendNotificationOptions): Promise<NotificationResponse>;
+    sendToUser(userId: string, title: string, message: string, options?: Omit<SendNotificationOptions, 'userIds' | 'title' | 'message'>): Promise<NotificationResponse>;
+    getNotifications(options: GetNotificationsOptions): Promise<{
+        notifications: Notification[];
+        total: number;
+        unreadCount: number;
+    }>;
+    markAsRead(notificationId: string): Promise<boolean>;
+    markMultipleAsRead(notificationIds: string[]): Promise<number>;
+    markAllAsRead(): Promise<number>;
+    deleteNotification(notificationId: string): Promise<boolean>;
+    deleteMultiple(notificationIds: string[]): Promise<number>;
+    getUnreadCount(userId: string): Promise<number>;
+    sendChannelNotification(options: SendChannelNotificationOptions): Promise<NotificationResponse>;
+    sendTemplateNotification(options: SendTemplateNotificationOptions): Promise<NotificationResponse>;
+}
+
+export { type GetNotificationsOptions as G, NotificationType as N, type RecipientInput as R, type SendChannelNotificationOptions as S, TenantNotificationsModule as T, NotificationsModule as a, type Notification as b, NotificationChannel as c, NotificationPriority as d, type NotificationResponse as e, type SendNotificationOptions as f, type SendTemplateNotificationOptions as g, tenantNotifications as t };

package/dist/index-DOcBnmMe.d.ts

@@ -0,0 +1,166 @@
+import { S as ServiceLayer } from './layer-DDip18KY.js';
+
+interface DatabaseConfig {
+    url: string;
+    maxConnections?: number;
+    idleTimeoutMillis?: number;
+    connectionTimeoutMillis?: number;
+    enableQueryLogging?: boolean;
+    slowQueryThreshold?: number;
+    migrationsPath?: string;
+}
+interface LoggingConfig {
+    level?: 'debug' | 'info' | 'warn' | 'error';
+    format?: 'json' | 'pretty';
+    console?: boolean;
+    structured?: boolean;
+}
+interface GraphSyncConfig {
+    enabled: boolean;
+    eventsEnabled?: boolean;
+    syncInterval?: number;
+    batchSize?: number;
+    consumerGroup?: string;
+    productSource?: string;
+    streamName?: string;
+}
+interface SDKValkeyCacheConfig {
+    url: string;
+    password?: string;
+    defaultTTL?: number;
+    db?: number;
+    keyPrefix?: string;
+    maxMemoryPolicy?: string;
+}
+interface ClickHouseConfig {
+    url: string;
+    database: string;
+    username?: string;
+    password?: string;
+    requestTimeout?: number;
+    maxConnections?: number;
+    compression?: boolean;
+}
+interface NATSConfig {
+    url?: string;
+    servers?: string | string[];
+    user?: string;
+    password?: string;
+    token?: string;
+    maxReconnectAttempts?: number;
+    reconnectTimeWait?: number;
+    tls?: {
+        certFile?: string;
+        keyFile?: string;
+        caFile?: string;
+    };
+}
+interface MetricsConfig {
+    enabled?: boolean;
+    port?: number;
+    endpoint?: string;
+    defaultMetrics?: boolean;
+    collectInterval?: number;
+}
+interface OpenTelemetryConfig {
+    enabled?: boolean;
+    serviceName?: string;
+    exporterEndpoint?: string;
+    samplingRate?: number;
+    consoleExporter?: boolean;
+}
+interface ObservabilityConfig {
+    metrics?: MetricsConfig;
+    openTelemetry?: OpenTelemetryConfig;
+}
+interface SDKCacheConfig {
+    valkey?: SDKValkeyCacheConfig;
+    localMaxSize?: number;
+    localTTL?: number;
+}
+interface AnalyticsConfig {
+    clickhouse?: ClickHouseConfig;
+    valkeyDb?: number;
+    eventMaxPropertiesSize?: number;
+    eventMaxBatchSize?: number;
+    rateLimitEnabled?: boolean;
+    rateLimitPerMinute?: number;
+    rateLimitPerHour?: number;
+    samplingEnabled?: boolean;
+    samplingRate?: number;
+}
+interface EventQueueConfig {
+    nats?: NATSConfig;
+    useNATSPubSub?: boolean;
+    defaultStreams?: {
+        name: string;
+        subjects: string[];
+        retention?: 'limits' | 'interest' | 'workqueue';
+        storage?: 'file' | 'memory';
+        maxAge?: number;
+        maxBytes?: number;
+    }[];
+}
+interface LayerInitConfig {
+    type: ServiceLayer;
+    serviceName: string;
+    serviceIdentity?: string;
+    autoCreateStreams?: boolean;
+}
+interface BurdenoffSDKInitConfig {
+    database: DatabaseConfig;
+    layer?: LayerInitConfig;
+    logging?: LoggingConfig;
+    graph?: GraphSyncConfig;
+    cache?: SDKCacheConfig;
+    analytics?: AnalyticsConfig;
+    eventQueue?: EventQueueConfig;
+    observability?: ObservabilityConfig;
+    app?: {
+        nodeEnv?: string;
+        serviceName?: string;
+        version?: string;
+    };
+}
+interface InitializedSDKState {
+    prisma?: unknown;
+    valkey?: unknown;
+    clickhouse?: unknown;
+    nats?: unknown;
+    layerManager?: unknown;
+    gatewayClient?: unknown;
+    graphSyncEnabled: boolean;
+    analyticsEnabled: boolean;
+    observabilityEnabled: boolean;
+    layerAwareEnabled: boolean;
+}
+
+declare function initializeBurdenoffSDK(config: BurdenoffSDKInitConfig): Promise<InitializedSDKState>;
+declare function getSDKState(): InitializedSDKState;
+declare function isSDKInitialized(): boolean;
+declare function resetSDK(): Promise<void>;
+
+type index_AnalyticsConfig = AnalyticsConfig;
+type index_BurdenoffSDKInitConfig = BurdenoffSDKInitConfig;
+type index_ClickHouseConfig = ClickHouseConfig;
+type index_DatabaseConfig = DatabaseConfig;
+type index_EventQueueConfig = EventQueueConfig;
+type index_GraphSyncConfig = GraphSyncConfig;
+type index_InitializedSDKState = InitializedSDKState;
+type index_LayerInitConfig = LayerInitConfig;
+type index_LoggingConfig = LoggingConfig;
+type index_MetricsConfig = MetricsConfig;
+type index_NATSConfig = NATSConfig;
+type index_ObservabilityConfig = ObservabilityConfig;
+type index_OpenTelemetryConfig = OpenTelemetryConfig;
+type index_SDKCacheConfig = SDKCacheConfig;
+type index_SDKValkeyCacheConfig = SDKValkeyCacheConfig;
+declare const index_getSDKState: typeof getSDKState;
+declare const index_initializeBurdenoffSDK: typeof initializeBurdenoffSDK;
+declare const index_isSDKInitialized: typeof isSDKInitialized;
+declare const index_resetSDK: typeof resetSDK;
+declare namespace index {
+  export { type index_AnalyticsConfig as AnalyticsConfig, type index_BurdenoffSDKInitConfig as BurdenoffSDKInitConfig, type index_ClickHouseConfig as ClickHouseConfig, type index_DatabaseConfig as DatabaseConfig, type index_EventQueueConfig as EventQueueConfig, type index_GraphSyncConfig as GraphSyncConfig, type index_InitializedSDKState as InitializedSDKState, type index_LayerInitConfig as LayerInitConfig, type index_LoggingConfig as LoggingConfig, type index_MetricsConfig as MetricsConfig, type index_NATSConfig as NATSConfig, type index_ObservabilityConfig as ObservabilityConfig, type index_OpenTelemetryConfig as OpenTelemetryConfig, type index_SDKCacheConfig as SDKCacheConfig, type index_SDKValkeyCacheConfig as SDKValkeyCacheConfig, index_getSDKState as getSDKState, index_initializeBurdenoffSDK as initializeBurdenoffSDK, index_isSDKInitialized as isSDKInitialized, index_resetSDK as resetSDK };
+}
+
+export { type AnalyticsConfig as A, type BurdenoffSDKInitConfig as B, type ClickHouseConfig as C, type DatabaseConfig as D, type EventQueueConfig as E, type GraphSyncConfig as G, type InitializedSDKState as I, type LayerInitConfig as L, type MetricsConfig as M, type NATSConfig as N, type ObservabilityConfig as O, type SDKCacheConfig as S, type LoggingConfig as a, type OpenTelemetryConfig as b, type SDKValkeyCacheConfig as c, initializeBurdenoffSDK as d, isSDKInitialized as e, getSDKState as g, index as i, resetSDK as r };

package/dist/index-DSOpj8DI.d.ts

@@ -0,0 +1,17 @@
+import { AnyElysia } from 'elysia';
+import { S as SecurityMiddlewareConfig, C as CSPDirectives, M as MetricsMiddlewareConfig, a as MiddlewareConfig } from './types-Bo2wkjSP.js';
+
+declare function createSecurityPlugin(config?: SecurityMiddlewareConfig): AnyElysia;
+declare function cleanupExpiredTokens(): void;
+
+declare const index_CSPDirectives: typeof CSPDirectives;
+declare const index_MetricsMiddlewareConfig: typeof MetricsMiddlewareConfig;
+declare const index_MiddlewareConfig: typeof MiddlewareConfig;
+declare const index_SecurityMiddlewareConfig: typeof SecurityMiddlewareConfig;
+declare const index_cleanupExpiredTokens: typeof cleanupExpiredTokens;
+declare const index_createSecurityPlugin: typeof createSecurityPlugin;
+declare namespace index {
+  export { index_CSPDirectives as CSPDirectives, index_MetricsMiddlewareConfig as MetricsMiddlewareConfig, index_MiddlewareConfig as MiddlewareConfig, index_SecurityMiddlewareConfig as SecurityMiddlewareConfig, index_cleanupExpiredTokens as cleanupExpiredTokens, index_createSecurityPlugin as createSecurityPlugin };
+}
+
+export { createSecurityPlugin as a, cleanupExpiredTokens as c, index as i };

package/dist/index-DW9q22GH.d.ts

@@ -0,0 +1,75 @@
+type BatchFunction<K, V> = (keys: readonly K[]) => Promise<(V | Error | null)[]>;
+type SimpleBatchFunction<K, V> = (keys: readonly K[]) => Promise<V[]>;
+interface EntityLoaderOptions<T, K extends string | number = string> {
+    batchFn: SimpleBatchFunction<K, T>;
+    getKey: (entity: T) => K;
+    cacheKeyFn?: (key: K) => string;
+}
+interface RelationLoaderOptions<T, K extends string | number = string> {
+    batchFn: SimpleBatchFunction<K, T>;
+    getKey: (entity: T) => K | null | undefined;
+    cacheKeyFn?: (key: K) => string;
+}
+interface CompositeKeyLoaderOptions<T> {
+    batchFn: SimpleBatchFunction<string, T>;
+    getKey: (entity: T) => string;
+    cacheKeyFn?: (key: string) => string;
+}
+interface DataLoaderConfig<K, V> {
+    batchLoadFn: BatchFunction<K, V>;
+    maxBatchSize?: number;
+    cache?: boolean;
+    cacheKeyFn?: (key: K) => string;
+}
+declare class SimpleDataLoader<K, V> {
+    private config;
+    private cache;
+    private pendingBatch;
+    private pendingPromises;
+    private batchScheduled;
+    constructor(config: DataLoaderConfig<K, V>);
+    load(key: K): Promise<V | null>;
+    loadMany(keys: K[]): Promise<(V | null)[]>;
+    clear(key: K): this;
+    clearAll(): this;
+    prime(key: K, value: V | Error | null): this;
+    private getCacheKey;
+    private scheduleBatch;
+    private deduplicateKeys;
+    private resolvePromisesForKey;
+    private processResults;
+    private rejectAllPromises;
+    private executeBatch;
+}
+declare function createEntityLoader<T, K extends string | number = string>(options: EntityLoaderOptions<T, K>): SimpleDataLoader<K, T>;
+declare function createRelationLoader<T, K extends string | number = string>(options: RelationLoaderOptions<T, K>): SimpleDataLoader<K, T[]>;
+declare function createCompositeKeyLoader<T>(options: CompositeKeyLoaderOptions<T>): SimpleDataLoader<string, T[]>;
+declare class DataLoaderFactory {
+    private loaders;
+    registerEntityLoader<T, K extends string | number = string>(name: string, options: EntityLoaderOptions<T, K>): SimpleDataLoader<K, T>;
+    registerRelationLoader<T, K extends string | number = string>(name: string, options: RelationLoaderOptions<T, K>): SimpleDataLoader<K, T[]>;
+    registerCompositeKeyLoader<T>(name: string, options: CompositeKeyLoaderOptions<T>): SimpleDataLoader<string, T[]>;
+    get<K, V>(name: string): SimpleDataLoader<K, V> | undefined;
+    clearAll(): void;
+}
+declare function createDataLoaderFactory(): DataLoaderFactory;
+
+type index_BatchFunction<K, V> = BatchFunction<K, V>;
+type index_CompositeKeyLoaderOptions<T> = CompositeKeyLoaderOptions<T>;
+type index_DataLoaderConfig<K, V> = DataLoaderConfig<K, V>;
+type index_DataLoaderFactory = DataLoaderFactory;
+declare const index_DataLoaderFactory: typeof DataLoaderFactory;
+type index_EntityLoaderOptions<T, K extends string | number = string> = EntityLoaderOptions<T, K>;
+type index_RelationLoaderOptions<T, K extends string | number = string> = RelationLoaderOptions<T, K>;
+type index_SimpleBatchFunction<K, V> = SimpleBatchFunction<K, V>;
+type index_SimpleDataLoader<K, V> = SimpleDataLoader<K, V>;
+declare const index_SimpleDataLoader: typeof SimpleDataLoader;
+declare const index_createCompositeKeyLoader: typeof createCompositeKeyLoader;
+declare const index_createDataLoaderFactory: typeof createDataLoaderFactory;
+declare const index_createEntityLoader: typeof createEntityLoader;
+declare const index_createRelationLoader: typeof createRelationLoader;
+declare namespace index {
+  export { type index_BatchFunction as BatchFunction, type index_CompositeKeyLoaderOptions as CompositeKeyLoaderOptions, type index_DataLoaderConfig as DataLoaderConfig, index_DataLoaderFactory as DataLoaderFactory, type index_EntityLoaderOptions as EntityLoaderOptions, type index_RelationLoaderOptions as RelationLoaderOptions, type index_SimpleBatchFunction as SimpleBatchFunction, index_SimpleDataLoader as SimpleDataLoader, index_createCompositeKeyLoader as createCompositeKeyLoader, index_createDataLoaderFactory as createDataLoaderFactory, index_createEntityLoader as createEntityLoader, index_createRelationLoader as createRelationLoader };
+}
+
+export { type BatchFunction as B, type CompositeKeyLoaderOptions as C, type DataLoaderConfig as D, type EntityLoaderOptions as E, type RelationLoaderOptions as R, type SimpleBatchFunction as S, DataLoaderFactory as a, SimpleDataLoader as b, createCompositeKeyLoader as c, createDataLoaderFactory as d, createEntityLoader as e, createRelationLoader as f, index as i };

package/dist/index-DlFDFyWD.d.ts

@@ -0,0 +1,55 @@
+import { L as LayerConfig, S as ServiceLayer, a as LayerFullConfig, D as DEFAULT_GATEWAY_ROUTING, b as DEFAULT_LAYER_RESOURCES, c as DEFAULT_LAYER_STREAMS, G as GatewayRoutingConfig, d as LayerGatewayConfig, e as LayerResourceUrls } from './layer-DDip18KY.js';
+
+declare class LayerManager {
+    private config;
+    private gatewayConfig;
+    private resourceConfig;
+    private routingConfig;
+    constructor(config: LayerConfig);
+    private resolveGatewayConfig;
+    private resolveResourceConfig;
+    getLayer(): ServiceLayer;
+    getServiceName(): string;
+    getServiceIdentity(): string;
+    getInternalGatewayUrl(): string;
+    getCrossLayerGatewayUrl(): string;
+    getNatsUrl(): string;
+    getValkeyUrl(): string;
+    getTemporalAddress(): string;
+    getTemporalNamespace(): string;
+    getRbacGatewayUrl(): string;
+    getDefaultStreams(): Array<{
+        name: string;
+        subjects: string[];
+        description?: string;
+    }>;
+    getFullConfig(): LayerFullConfig;
+    isWspaceLayer(): boolean;
+    isGlobalLayer(): boolean;
+    getOppositeLayer(): ServiceLayer;
+}
+declare function createLayerManagerFromEnv(): LayerManager;
+declare function detectLayerFromServiceName(serviceName: string): ServiceLayer | undefined;
+declare function getGatewayUrlForLayer(sourceLayer: ServiceLayer, targetLayer: ServiceLayer, sourceManager?: LayerManager): string;
+declare function validateLayerConfig(config: LayerConfig): void;
+
+declare const index_DEFAULT_GATEWAY_ROUTING: typeof DEFAULT_GATEWAY_ROUTING;
+declare const index_DEFAULT_LAYER_RESOURCES: typeof DEFAULT_LAYER_RESOURCES;
+declare const index_DEFAULT_LAYER_STREAMS: typeof DEFAULT_LAYER_STREAMS;
+declare const index_GatewayRoutingConfig: typeof GatewayRoutingConfig;
+declare const index_LayerConfig: typeof LayerConfig;
+declare const index_LayerFullConfig: typeof LayerFullConfig;
+declare const index_LayerGatewayConfig: typeof LayerGatewayConfig;
+type index_LayerManager = LayerManager;
+declare const index_LayerManager: typeof LayerManager;
+declare const index_LayerResourceUrls: typeof LayerResourceUrls;
+declare const index_ServiceLayer: typeof ServiceLayer;
+declare const index_createLayerManagerFromEnv: typeof createLayerManagerFromEnv;
+declare const index_detectLayerFromServiceName: typeof detectLayerFromServiceName;
+declare const index_getGatewayUrlForLayer: typeof getGatewayUrlForLayer;
+declare const index_validateLayerConfig: typeof validateLayerConfig;
+declare namespace index {
+  export { index_DEFAULT_GATEWAY_ROUTING as DEFAULT_GATEWAY_ROUTING, index_DEFAULT_LAYER_RESOURCES as DEFAULT_LAYER_RESOURCES, index_DEFAULT_LAYER_STREAMS as DEFAULT_LAYER_STREAMS, index_GatewayRoutingConfig as GatewayRoutingConfig, index_LayerConfig as LayerConfig, index_LayerFullConfig as LayerFullConfig, index_LayerGatewayConfig as LayerGatewayConfig, index_LayerManager as LayerManager, index_LayerResourceUrls as LayerResourceUrls, index_ServiceLayer as ServiceLayer, index_createLayerManagerFromEnv as createLayerManagerFromEnv, index_detectLayerFromServiceName as detectLayerFromServiceName, index_getGatewayUrlForLayer as getGatewayUrlForLayer, index_validateLayerConfig as validateLayerConfig };
+}
+
+export { LayerManager as L, createLayerManagerFromEnv as c, detectLayerFromServiceName as d, getGatewayUrlForLayer as g, index as i, validateLayerConfig as v };