briyah 1.0.0

package/dist/server/src/auth/jwt-auth.guard.js

@@ -0,0 +1,143 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtAuthGuard = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const public_decorator_1 = require("./public.decorator");
+const jwt_1 = require("@nestjs/jwt");
+const published_agents_service_1 = require("../ai/published-agents.service");
+const published_rooms_service_1 = require("../room/published-rooms.service");
+let JwtAuthGuard = class JwtAuthGuard {
+    reflector;
+    jwtService;
+    publishedAgentsService;
+    publishedRoomsService;
+    constructor(reflector, jwtService, publishedAgentsService, publishedRoomsService) {
+        this.reflector = reflector;
+        this.jwtService = jwtService;
+        this.publishedAgentsService = publishedAgentsService;
+        this.publishedRoomsService = publishedRoomsService;
+    }
+    async canActivate(context) {
+        const isPublic = this.reflector.getAllAndOverride(public_decorator_1.IS_PUBLIC_KEY, [
+            context.getHandler(),
+            context.getClass(),
+        ]);
+        if (isPublic) {
+            return true;
+        }
+        const request = context.switchToHttp().getRequest();
+        const agentIdHeader = request.headers['x-briyah-agent-id'];
+        if (agentIdHeader) {
+            const userId = this.publishedAgentsService.getUserId(agentIdHeader);
+            if (!userId) {
+                console.log(`[AUTH] Invalid or unpublished agent ID in header: ${agentIdHeader}`);
+                return false;
+            }
+            request.user = {
+                sub: userId,
+                userId: userId,
+                type: 'agent-access',
+                scope: ['agent:read', 'agent:interact'],
+                agentId: agentIdHeader,
+                authSource: 'header',
+            };
+            return true;
+        }
+        const roomIdHeader = request.headers['x-briyah-room-id'];
+        if (roomIdHeader) {
+            const userId = this.publishedRoomsService.getUserId(roomIdHeader);
+            if (!userId) {
+                console.log(`[AUTH] Invalid or unpublished room ID in header: ${roomIdHeader}`);
+                return false;
+            }
+            request.user = {
+                sub: userId,
+                userId: userId,
+                type: 'room-access',
+                scope: ['room:read', 'room:interact'],
+                roomId: roomIdHeader,
+                authSource: 'header',
+            };
+            return true;
+        }
+        const url = request.url;
+        const agentSseMatch = url.match(/\/agents\/([^\/\?]+)\/messages/);
+        if (agentSseMatch) {
+            const agentId = agentSseMatch[1];
+            const userId = this.publishedAgentsService.getUserId(agentId);
+            if (userId) {
+                request.user = {
+                    sub: userId,
+                    userId: userId,
+                    type: 'agent-access',
+                    scope: ['agent:read', 'agent:interact'],
+                    agentId: agentId,
+                    authSource: 'sse-url',
+                };
+                return true;
+            }
+        }
+        const roomSseMatch = url.match(/\/rooms\/([^\/\?]+)\/messages/);
+        if (roomSseMatch) {
+            const roomId = roomSseMatch[1];
+            const userId = this.publishedRoomsService.getUserId(roomId);
+            if (userId) {
+                request.user = {
+                    sub: userId,
+                    userId: userId,
+                    type: 'room-access',
+                    scope: ['room:read', 'room:interact'],
+                    roomId: roomId,
+                    authSource: 'sse-url',
+                };
+                return true;
+            }
+        }
+        let token = request.cookies?.briyah_jwt;
+        if (!token) {
+            const authHeader = request.headers.authorization;
+            if (authHeader && authHeader.startsWith('Bearer ')) {
+                token = authHeader.substring(7);
+            }
+        }
+        if (!token) {
+            return false;
+        }
+        try {
+            const payload = await this.jwtService.verifyAsync(token);
+            request.user = {
+                sub: payload.sub,
+                userId: payload.sub,
+                phoneNumber: payload.phoneNumber,
+                type: payload.type || 'user',
+                scope: payload.scope || ['user:full'],
+                mode: payload.mode,
+                agentId: payload.agentId,
+                roomId: payload.roomId,
+            };
+            return true;
+        }
+        catch (error) {
+            console.log('[AUTH] Invalid JWT token:', error.message);
+            return false;
+        }
+    }
+};
+exports.JwtAuthGuard = JwtAuthGuard;
+exports.JwtAuthGuard = JwtAuthGuard = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.Reflector,
+        jwt_1.JwtService,
+        published_agents_service_1.PublishedAgentsService,
+        published_rooms_service_1.PublishedRoomsService])
+], JwtAuthGuard);

package/dist/server/src/auth/jwt.strategy.d.ts

@@ -0,0 +1,17 @@
+import { Strategy } from 'passport-jwt';
+import { ConfigService } from '@nestjs/config';
+declare const JwtStrategy_base: new (...args: [opt: import("passport-jwt").StrategyOptionsWithRequest] | [opt: import("passport-jwt").StrategyOptionsWithoutRequest]) => Strategy & {
+    validate(...args: any[]): unknown;
+};
+export declare class JwtStrategy extends JwtStrategy_base {
+    private configService;
+    constructor(configService: ConfigService);
+    validate(payload: any): Promise<{
+        username: any;
+        sub: any;
+        type: any;
+        agentId: any;
+        scope: any;
+    }>;
+}
+export {};

package/dist/server/src/auth/jwt.strategy.js

@@ -0,0 +1,45 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtStrategy = void 0;
+const passport_jwt_1 = require("passport-jwt");
+const passport_1 = require("@nestjs/passport");
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+let JwtStrategy = class JwtStrategy extends (0, passport_1.PassportStrategy)(passport_jwt_1.Strategy) {
+    configService;
+    constructor(configService) {
+        const jwtSecret = configService.get('JWT_SECRET');
+        if (!jwtSecret) {
+            throw new Error('JWT_SECRET environment variable not set');
+        }
+        super({
+            jwtFromRequest: passport_jwt_1.ExtractJwt.fromAuthHeaderAsBearerToken(),
+            ignoreExpiration: false,
+            secretOrKey: jwtSecret,
+        });
+        this.configService = configService;
+    }
+    async validate(payload) {
+        return {
+            username: payload.username,
+            sub: payload.sub,
+            type: payload.type || 'user',
+            agentId: payload.agentId,
+            scope: payload.scope || ['user:full'],
+        };
+    }
+};
+exports.JwtStrategy = JwtStrategy;
+exports.JwtStrategy = JwtStrategy = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_1.ConfigService])
+], JwtStrategy);

package/dist/server/src/auth/phone-validation.service.d.ts

@@ -0,0 +1,7 @@
+export declare class PhoneValidationService {
+    normalizePhone(input: string): string;
+    validatePhoneFormat(input: string): boolean;
+    formatPhoneForDisplay(phone: string): string;
+    isTestPhoneNumber(input: string): boolean;
+    validateNotTestNumber(input: string): boolean;
+}

package/dist/server/src/auth/phone-validation.service.js

@@ -0,0 +1,50 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhoneValidationService = void 0;
+const common_1 = require("@nestjs/common");
+let PhoneValidationService = class PhoneValidationService {
+    normalizePhone(input) {
+        if (!input)
+            return '';
+        const digits = input.replace(/\D/g, '');
+        if (digits.length === 11 && digits.startsWith('1')) {
+            return digits.substring(1);
+        }
+        return digits.length === 10 ? digits : '';
+    }
+    validatePhoneFormat(input) {
+        const normalized = this.normalizePhone(input);
+        if (normalized.length !== 10)
+            return false;
+        const firstDigit = parseInt(normalized[0]);
+        if (firstDigit === 0 || firstDigit === 1)
+            return false;
+        return true;
+    }
+    formatPhoneForDisplay(phone) {
+        const normalized = this.normalizePhone(phone);
+        if (normalized.length !== 10)
+            return phone;
+        return `(${normalized.substring(0, 3)}) ${normalized.substring(3, 6)}-${normalized.substring(6)}`;
+    }
+    isTestPhoneNumber(input) {
+        const normalized = this.normalizePhone(input);
+        return normalized.startsWith('555');
+    }
+    validateNotTestNumber(input) {
+        if (process.env.NODE_ENV === 'production' && this.isTestPhoneNumber(input)) {
+            return false;
+        }
+        return true;
+    }
+};
+exports.PhoneValidationService = PhoneValidationService;
+exports.PhoneValidationService = PhoneValidationService = __decorate([
+    (0, common_1.Injectable)()
+], PhoneValidationService);

package/dist/server/src/auth/public.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare const IS_PUBLIC_KEY = "isPublic";
+export declare const Public: () => import("@nestjs/common").CustomDecorator<string>;

package/dist/server/src/auth/public.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Public = exports.IS_PUBLIC_KEY = void 0;
+const common_1 = require("@nestjs/common");
+exports.IS_PUBLIC_KEY = 'isPublic';
+const Public = () => (0, common_1.SetMetadata)(exports.IS_PUBLIC_KEY, true);
+exports.Public = Public;

package/dist/server/src/auth/rate-limit.service.d.ts

@@ -0,0 +1,16 @@
+export declare class RateLimitService {
+    private readonly logger;
+    private readonly attemptMap;
+    private readonly MAX_ATTEMPTS;
+    private readonly WINDOW_MINUTES;
+    private cleanupInterval;
+    constructor();
+    checkRateLimit(phone: string): {
+        allowed: boolean;
+        remainingAttempts?: number;
+    };
+    recordAttempt(phone: string): void;
+    clearAttempts(phone: string): void;
+    private cleanup;
+    onModuleDestroy(): void;
+}

package/dist/server/src/auth/rate-limit.service.js

@@ -0,0 +1,84 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var RateLimitService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitService = void 0;
+const common_1 = require("@nestjs/common");
+let RateLimitService = RateLimitService_1 = class RateLimitService {
+    logger = new common_1.Logger(RateLimitService_1.name);
+    attemptMap = new Map();
+    MAX_ATTEMPTS = 3;
+    WINDOW_MINUTES = 15;
+    cleanupInterval;
+    constructor() {
+        this.cleanupInterval = setInterval(() => {
+            this.cleanup();
+        }, 60 * 60 * 1000);
+    }
+    checkRateLimit(phone) {
+        const entry = this.attemptMap.get(phone);
+        if (!entry) {
+            return { allowed: true, remainingAttempts: this.MAX_ATTEMPTS };
+        }
+        if (new Date() > entry.resetAt) {
+            this.attemptMap.delete(phone);
+            return { allowed: true, remainingAttempts: this.MAX_ATTEMPTS };
+        }
+        if (entry.count >= this.MAX_ATTEMPTS) {
+            return { allowed: false, remainingAttempts: 0 };
+        }
+        return {
+            allowed: true,
+            remainingAttempts: this.MAX_ATTEMPTS - entry.count,
+        };
+    }
+    recordAttempt(phone) {
+        const entry = this.attemptMap.get(phone);
+        const now = new Date();
+        if (!entry || now > entry.resetAt) {
+            this.attemptMap.set(phone, {
+                count: 1,
+                resetAt: new Date(now.getTime() + this.WINDOW_MINUTES * 60 * 1000),
+            });
+        }
+        else {
+            entry.count++;
+        }
+        this.logger.debug(`Rate limit recorded for ${phone}: ${this.attemptMap.get(phone)?.count}/${this.MAX_ATTEMPTS}`);
+    }
+    clearAttempts(phone) {
+        this.attemptMap.delete(phone);
+        this.logger.debug(`Rate limit cleared for ${phone}`);
+    }
+    cleanup() {
+        const now = new Date();
+        let cleaned = 0;
+        for (const [phone, entry] of this.attemptMap.entries()) {
+            if (now > entry.resetAt) {
+                this.attemptMap.delete(phone);
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            this.logger.debug(`Cleaned up ${cleaned} expired rate limit entries`);
+        }
+    }
+    onModuleDestroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+        }
+    }
+};
+exports.RateLimitService = RateLimitService;
+exports.RateLimitService = RateLimitService = RateLimitService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], RateLimitService);

package/dist/server/src/auth/room-access.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare const RoomReadAccess: () => <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;
+export declare const RoomAccess: () => <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/dist/server/src/auth/room-access.decorator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomAccess = exports.RoomReadAccess = void 0;
+const common_1 = require("@nestjs/common");
+const scopes_guard_1 = require("./scopes.guard");
+const scopes_decorator_1 = require("./scopes.decorator");
+const RoomReadAccess = () => (0, common_1.applyDecorators)((0, common_1.UseGuards)(scopes_guard_1.ScopesGuard), (0, scopes_decorator_1.RequireScopes)('room:read'));
+exports.RoomReadAccess = RoomReadAccess;
+const RoomAccess = () => (0, common_1.applyDecorators)((0, common_1.UseGuards)(scopes_guard_1.ScopesGuard), (0, scopes_decorator_1.RequireScopes)('room:read', 'room:interact'));
+exports.RoomAccess = RoomAccess;

package/dist/server/src/auth/scopes.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare const SCOPES_KEY = "scopes";
+export declare const RequireScopes: (...scopes: string[]) => import("@nestjs/common").CustomDecorator<string>;

package/dist/server/src/auth/scopes.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequireScopes = exports.SCOPES_KEY = void 0;
+const common_1 = require("@nestjs/common");
+exports.SCOPES_KEY = 'scopes';
+const RequireScopes = (...scopes) => (0, common_1.SetMetadata)(exports.SCOPES_KEY, scopes);
+exports.RequireScopes = RequireScopes;

package/dist/server/src/auth/scopes.guard.d.ts

@@ -0,0 +1,9 @@
+import { ExecutionContext, CanActivate } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+export declare class ScopesGuard implements CanActivate {
+    private reflector;
+    constructor(reflector: Reflector);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+    private extractAgentIdFromRequest;
+    private extractRoomIdFromRequest;
+}

package/dist/server/src/auth/scopes.guard.js

@@ -0,0 +1,82 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScopesGuard = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const scopes_decorator_1 = require("./scopes.decorator");
+let ScopesGuard = class ScopesGuard {
+    reflector;
+    constructor(reflector) {
+        this.reflector = reflector;
+    }
+    async canActivate(context) {
+        const request = context.switchToHttp().getRequest();
+        if (!request.user) {
+            return false;
+        }
+        const requiredScopes = this.reflector.getAllAndOverride(scopes_decorator_1.SCOPES_KEY, [
+            context.getHandler(),
+            context.getClass(),
+        ]);
+        if (!requiredScopes || requiredScopes.length === 0) {
+            return true;
+        }
+        const user = request.user;
+        const userScopes = user.scope || [];
+        if (userScopes.includes('user:full')) {
+            return true;
+        }
+        const hasAllScopes = requiredScopes.every((scope) => userScopes.includes(scope));
+        if (!hasAllScopes) {
+            throw new common_1.ForbiddenException('Insufficient permissions');
+        }
+        if (user.type === 'agent-access' && user.agentId) {
+            const agentId = this.extractAgentIdFromRequest(request);
+            if (agentId && agentId !== user.agentId) {
+                throw new common_1.ForbiddenException('Token not valid for this agent');
+            }
+        }
+        if (user.type === 'room-access' && user.roomId) {
+            const roomId = this.extractRoomIdFromRequest(request);
+            if (roomId && roomId !== user.roomId) {
+                throw new common_1.ForbiddenException('Token not valid for this room');
+            }
+        }
+        return true;
+    }
+    extractAgentIdFromRequest(request) {
+        if (request.params?.agentId) {
+            return request.params.agentId;
+        }
+        if (request.body?.agentId) {
+            return request.body.agentId;
+        }
+        return null;
+    }
+    extractRoomIdFromRequest(request) {
+        if (request.params?.roomId) {
+            return request.params.roomId;
+        }
+        if (request.query?.roomId) {
+            return request.query.roomId;
+        }
+        if (request.body?.roomId) {
+            return request.body.roomId;
+        }
+        return null;
+    }
+};
+exports.ScopesGuard = ScopesGuard;
+exports.ScopesGuard = ScopesGuard = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.Reflector])
+], ScopesGuard);

package/dist/server/src/auth/session.guard.d.ts

@@ -0,0 +1,7 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+export declare class SessionGuard implements CanActivate {
+    private jwtService;
+    constructor(jwtService: JwtService);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+}

package/dist/server/src/auth/session.guard.js

@@ -0,0 +1,55 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionGuard = void 0;
+const common_1 = require("@nestjs/common");
+const jwt_1 = require("@nestjs/jwt");
+let SessionGuard = class SessionGuard {
+    jwtService;
+    constructor(jwtService) {
+        this.jwtService = jwtService;
+    }
+    async canActivate(context) {
+        const request = context.switchToHttp().getRequest();
+        let token = request.cookies?.briyah_jwt;
+        if (!token) {
+            const authHeader = request.headers.authorization;
+            if (authHeader && authHeader.startsWith('Bearer ')) {
+                token = authHeader.substring(7);
+            }
+        }
+        if (!token) {
+            return false;
+        }
+        try {
+            const payload = await this.jwtService.verifyAsync(token);
+            request.user = {
+                sub: payload.sub,
+                userId: payload.sub,
+                phoneNumber: payload.phoneNumber,
+                type: payload.type || 'user',
+                scope: payload.scope || ['user:full'],
+                mode: payload.mode,
+                agentId: payload.agentId,
+                roomId: payload.roomId,
+            };
+            return true;
+        }
+        catch (_error) {
+            return false;
+        }
+    }
+};
+exports.SessionGuard = SessionGuard;
+exports.SessionGuard = SessionGuard = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [jwt_1.JwtService])
+], SessionGuard);

package/dist/server/src/auth/twilio.service.d.ts

@@ -0,0 +1,15 @@
+import { ConfigService } from '@nestjs/config';
+export declare class TwilioService {
+    private configService;
+    private readonly TWILIO_ACCOUNT_SID;
+    private readonly TWILIO_AUTH_TOKEN;
+    private readonly TWILIO_API_URL;
+    private readonly TWILIO_PHONE;
+    private readonly TWILIO_VERIFY_SID;
+    constructor(configService: ConfigService);
+    sendVerification(to: string, channel?: 'sms' | 'call'): Promise<any>;
+    checkVerification(to: string, code: string): Promise<any>;
+    sendSms(to: string, body: string): Promise<any>;
+    private isTestMode;
+    private isTestPhoneNumber;
+}