@iota-big3/sdk-gateway/dist/packages/sdk-types/src/common.d.ts

Universal API Gateway with protocol translation, intelligent routing, rate limiting, health checking, and caching

/**
 * Common Type Definitions
 * Shared types to eliminate 'any' usage across the SDK
 */
import { NextFunction, Request, Response } from 'express';
/**
 * Express Request with typed body and user
 */
export interface TypedRequest<TBody = unknown, TQuery = Record<string, unknown>, TParams = Record<string, string>> extends Request {
    body: TBody;
    query: TQuery & Request['query'];
    params: TParams & Request['params'];
    user?: AuthUser;
    correlationId?: string;
    span?: TracingSpan;
    featureFlags?: FeatureFlagClient;
}
/**
 * Express Response with typed json method
 */
export interface TypedResponse<TData = unknown> extends Response {
    json: (data: TData) => this;
}
/**
 * Express middleware signature
 */
export type ExpressMiddleware = (req: Request, res: Response, next: NextFunction) => void | Promise<void>;
/**
 * Typed Express middleware
 */
export type TypedMiddleware<TReq = Request, TRes = Response> = (req: TReq, res: TRes, next: NextFunction) => void | Promise<void>;
export interface AuthUser {
    id: string;
    email?: string;
    name?: string;
    roles?: string[];
    permissions?: string[];
    organizationId?: string;
    metadata?: Record<string, unknown>;
}
export interface RedisClient {
    get(key: string): Promise<string | null>;
    set(key: string, value: string, mode?: 'EX' | 'PX', duration?: number): Promise<string | null>;
    setex(key: string, seconds: number, value: string): Promise<string>;
    psetex(key: string, milliseconds: number, value: string): Promise<string>;
    del(key: string | string[]): Promise<number>;
    exists(key: string | string[]): Promise<number>;
    expire(key: string, seconds: number): Promise<number>;
    ttl(key: string): Promise<number>;
    pttl(key: string): Promise<number>;
    incr(key: string): Promise<number>;
    decr(key: string): Promise<number>;
    incrby(key: string, increment: number): Promise<number>;
    decrby(key: string, decrement: number): Promise<number>;
    hget(key: string, field: string): Promise<string | null>;
    hset(key: string, field: string, value: string): Promise<number>;
    hdel(key: string, field: string | string[]): Promise<number>;
    hgetall(key: string): Promise<Record<string, string>>;
    lpush(key: string, ...values: string[]): Promise<number>;
    rpush(key: string, ...values: string[]): Promise<number>;
    lpop(key: string): Promise<string | null>;
    rpop(key: string): Promise<string | null>;
    llen(key: string): Promise<number>;
    sadd(key: string, ...members: string[]): Promise<number>;
    srem(key: string, ...members: string[]): Promise<number>;
    smembers(key: string): Promise<string[]>;
    sismember(key: string, member: string): Promise<number>;
    zadd(key: string, score: number, member: string): Promise<number>;
    zrem(key: string, member: string | string[]): Promise<number>;
    zrange(key: string, start: number, stop: number, withScores?: 'WITHSCORES'): Promise<string[]>;
    zrevrange(key: string, start: number, stop: number, withScores?: 'WITHSCORES'): Promise<string[]>;
    zcard(key: string): Promise<number>;
    zremrangebyscore(key: string, min: string | number, max: string | number): Promise<number>;
    keys(pattern: string): Promise<string[]>;
    scan(cursor: string, options?: {
        match?: string;
        count?: number;
    }): Promise<[string, string[]]>;
    mget(...keys: string[]): Promise<(string | null)[]>;
    mset(...keysAndValues: string[]): Promise<string>;
    multi(): RedisMulti;
    pipeline(): RedisPipeline;
    subscribe(channel: string | string[]): Promise<void>;
    unsubscribe(channel: string | string[]): Promise<void>;
    publish(channel: string, message: string): Promise<number>;
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    quit(): Promise<void>;
    on(event: string, listener: (...args: unknown[]) => void): this;
    off(event: string, listener: (...args: unknown[]) => void): this;
}
export interface RedisMulti {
    get(key: string): RedisMulti;
    set(key: string, value: string): RedisMulti;
    del(key: string | string[]): RedisMulti;
    incr(key: string): RedisMulti;
    incrby(key: string, increment: number): RedisMulti;
    expire(key: string, seconds: number): RedisMulti;
    pexpire(key: string, milliseconds: number): RedisMulti;
    ttl(key: string): RedisMulti;
    pttl(key: string): RedisMulti;
    zadd(key: string, score: number, member: string): RedisMulti;
    zrem(key: string, member: string): RedisMulti;
    zremrangebyscore(key: string, min: string | number, max: string | number): RedisMulti;
    exec(): Promise<unknown[]>;
}
export interface RedisPipeline {
    get(key: string): RedisPipeline;
    set(key: string, value: string, mode?: 'EX', duration?: number): RedisPipeline;
    setex(key: string, seconds: number, value: string): RedisPipeline;
    del(key: string | string[]): RedisPipeline;
    expire(key: string, seconds: number): RedisPipeline;
    exec(): Promise<unknown[]>;
}
/**
 * Class decorator
 */
export type ClassDecorator<T = unknown> = (target: new (...args: unknown[]) => T) => void;
/**
 * Method decorator
 */
export type MethodDecorator = (target: unknown, propertyKey: string | symbol, descriptor: PropertyDescriptor) => PropertyDescriptor | void;
/**
 * Property decorator
 */
export type PropertyDecorator = (target: unknown, propertyKey: string | symbol) => void;
/**
 * Parameter decorator
 */
export type ParameterDecorator = (target: unknown, propertyKey: string | symbol, parameterIndex: number) => void;
export interface CacheEntry<T = unknown> {
    value: T;
    ttl?: number;
    metadata?: Record<string, unknown>;
}
export interface CacheSerializer {
    serialize(value: unknown): string | Buffer;
    deserialize(data: string | Buffer): unknown;
}
export interface FeatureFlagClient {
    isEnabled(flag: string, userId?: string, attributes?: Record<string, unknown>): Promise<boolean>;
    getVariant(flag: string, userId?: string, attributes?: Record<string, unknown>): Promise<string>;
}
export interface FeatureFlagConfig {
    enabled: boolean;
    percentage?: number;
    userOverrides?: string[];
    groupOverrides?: string[];
    metadata?: Record<string, unknown>;
    variants?: Array<{
        name: string;
        weight: number;
        metadata?: Record<string, unknown>;
    }>;
}
export interface TracingSpan {
    end(): void;
    setAttributes(attributes: Record<string, unknown>): void;
    setStatus(status: {
        code: number;
        message?: string;
    }): void;
    addEvent(name: string, attributes?: Record<string, unknown>): void;
}
export interface TracingContext {
    traceparent?: string;
    tracestate?: string;
}
export interface DomainEvent<T = unknown> {
    id: string;
    type: string;
    streamId: string;
    version: number;
    data: T;
    metadata?: Record<string, unknown>;
    timestamp: Date;
    correlationId?: string;
    causationId?: string;
}
export interface ErrorDetails {
    code: string;
    message: string;
    details?: unknown;
    stack?: string;
    cause?: Error;
}
export interface CircuitBreakerStats {
    state: 'CLOSED' | 'OPEN' | 'HALF_OPEN';
    failures: number;
    successes: number;
    lastFailureTime?: Date;
    nextRetryTime?: Date;
}
export interface RateLimitResult {
    allowed: boolean;
    remaining: number;
    resetAt: Date;
    retryAfter?: number;
}
/**
 * Deep partial type
 */
export type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};
/**
 * Async function type
 */
export type AsyncFunction<TArgs extends unknown[] = unknown[], TReturn = unknown> = (...args: TArgs) => Promise<TReturn>;
/**
 * Sync function type
 */
export type SyncFunction<TArgs extends unknown[] = unknown[], TReturn = unknown> = (...args: TArgs) => TReturn;
/**
 * Any function type
 */
export type AnyFunction<TArgs extends unknown[] = unknown[], TReturn = unknown> = SyncFunction<TArgs, TReturn> | AsyncFunction<TArgs, TReturn>;
/**
 * Constructor type
 */
export type Constructor<T = unknown> = new (...args: unknown[]) => T;
/**
 * Key-value object
 */
export type KeyValue<T = unknown> = Record<string, T>;
/**
 * JSON serializable types
 */
export type JsonPrimitive = string | number | boolean | null;
export type JsonObject = {
    [key: string]: JsonValue;
};
export type JsonArray = JsonValue[];
export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
/**
 * Extract promise type
 */
export type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
/**
 * Make specific keys optional
 */
export type OptionalKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
//# sourceMappingURL=common.d.ts.map