@stacksjs/ts-cloud-core 0.1.3 → 0.1.7

package/dist/network-security/index.d.ts

@@ -0,0 +1,39 @@
+export declare const networkSecurityManager: NetworkSecurityManager;
+/**
+ * Network Security - WAF, Shield, security groups, NACLs
+ */
+export declare interface WAFRule {
+  id: string
+  name: string
+  priority: number
+  action: 'allow' | 'block' | 'count'
+  conditions: string[]
+}
+export declare interface ShieldProtection {
+  id: string
+  resourceArn: string
+  protectionType: 'standard' | 'advanced'
+}
+export declare interface SecurityGroup {
+  id: string
+  name: string
+  vpcId: string
+  rules: Array<{ protocol: string; port: number; source: string }>
+}
+export declare interface NACL {
+  id: string
+  vpcId: string
+  rules: Array<{ ruleNumber: number; protocol: string; action: 'allow' | 'deny' }>
+}
+export declare class NetworkSecurityManager {
+  private wafRules: any;
+  private shieldProtections: any;
+  private securityGroups: any;
+  private nacls: any;
+  private counter: any;
+  createWAFRule(name: string, priority: number, action: 'allow' | 'block' | 'count', conditions: string[]): WAFRule;
+  enableShield(resourceArn: string, protectionType?: 'standard' | 'advanced'): ShieldProtection;
+  createSecurityGroup(name: string, vpcId: string, rules: Array<{ protocol: string; port: number; source: string }>): SecurityGroup;
+  createNACL(vpcId: string, rules: Array<{ ruleNumber: number; protocol: string; action: 'allow' | 'deny' }>): NACL;
+  clear(): void;
+}

package/dist/observability/index.d.ts

@@ -0,0 +1,4 @@
+export * from './xray';
+export * from './metrics';
+export * from './logs';
+export * from './synthetics';

package/dist/observability/logs.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Global logs manager instance
+ */
+export declare const logsManager: LogsManager;
+/**
+ * Log Aggregation
+ * Centralized logging across services with CloudWatch Logs
+ */
+export declare interface LogGroup {
+  id: string
+  name: string
+  retentionDays?: number
+  kmsKeyId?: string
+  logStreams?: LogStream[]
+  metricFilters?: MetricFilter[]
+  subscriptionFilters?: SubscriptionFilter[]
+}
+export declare interface LogStream {
+  id: string
+  name: string
+  logGroupName: string
+  creationTime: Date
+  lastEventTime?: Date
+}
+export declare interface MetricFilter {
+  id: string
+  name: string
+  filterPattern: string
+  metricTransformations: MetricTransformation[]
+}
+export declare interface MetricTransformation {
+  metricName: string
+  metricNamespace: string
+  metricValue: string
+  defaultValue?: number
+  unit?: string
+  dimensions?: Record<string, string>
+}
+export declare interface SubscriptionFilter {
+  id: string
+  name: string
+  logGroupName: string
+  filterPattern: string
+  destinationArn: string
+  roleArn?: string
+  distribution?: 'Random' | 'ByLogStream'
+}
+export declare interface LogQuery {
+  id: string
+  name: string
+  queryString: string
+  logGroupNames: string[]
+  startTime?: Date
+  endTime?: Date
+}
+export declare interface LogInsightsQuery {
+  id: string
+  name: string
+  description?: string
+  query: string
+  logGroupNames: string[]
+  schedule?: string
+}
+/**
+ * Logs manager
+ */
+export declare class LogsManager {
+  private logGroups: Map<string, LogGroup>;
+  private queries: Map<string, LogQuery>;
+  private insightsQueries: Map<string, LogInsightsQuery>;
+  private logGroupCounter: any;
+  private filterCounter: any;
+  private queryCounter: any;
+  createLogGroup(group: Omit<LogGroup, 'id'>): LogGroup;
+  createLambdaLogGroup(functionName: string, retentionDays?: number): LogGroup;
+  createECSLogGroup(options: {
+    clusterName: string
+    serviceName: string
+    retentionDays?: number
+  }): LogGroup;
+  createAPIGatewayLogGroup(apiName: string, stage: string, retentionDays?: number): LogGroup;
+  createApplicationLogGroup(options: {
+    appName: string
+    environment: string
+    retentionDays?: number
+    kmsKeyId?: string
+  }): LogGroup;
+  createMetricFilter(logGroupId: string, filter: Omit<MetricFilter, 'id'>): MetricFilter;
+  createErrorCountFilter(logGroupId: string, namespace: string): MetricFilter;
+  createLatencyFilter(logGroupId: string, namespace: string): MetricFilter;
+  createCustomPatternFilter(options: {
+    logGroupId: string
+    name: string
+    pattern: string
+    metricName: string
+    namespace: string
+  }): MetricFilter;
+  createSubscriptionFilter(logGroupId: string, filter: Omit<SubscriptionFilter, 'id'>): SubscriptionFilter;
+  createKinesisSubscription(options: {
+    logGroupId: string
+    kinesisStreamArn: string
+    roleArn: string
+    filterPattern?: string
+  }): SubscriptionFilter;
+  createLambdaSubscription(options: {
+    logGroupId: string
+    lambdaFunctionArn: string
+    filterPattern?: string
+  }): SubscriptionFilter;
+  createInsightsQuery(query: Omit<LogInsightsQuery, 'id'>): LogInsightsQuery;
+  createErrorAnalysisQuery(logGroupNames: string[]): LogInsightsQuery;
+  createLatencyAnalysisQuery(logGroupNames: string[]): LogInsightsQuery;
+  createTopErrorsQuery(logGroupNames: string[]): LogInsightsQuery;
+  getLogGroup(id: string): LogGroup | undefined;
+  listLogGroups(): LogGroup[];
+  getInsightsQuery(id: string): LogInsightsQuery | undefined;
+  listInsightsQueries(): LogInsightsQuery[];
+  generateLogGroupCF(group: LogGroup): any;
+  generateMetricFilterCF(logGroup: LogGroup, filter: MetricFilter): any;
+  generateSubscriptionFilterCF(filter: SubscriptionFilter): any;
+  generateQueryDefinitionCF(query: LogInsightsQuery): any;
+  createLogAggregation(logGroup: string, filters: Array<{ pattern: string; metric: string }>, retention?: any): {
+    id: string
+    logGroup: string
+    filters: Array<{ pattern: string; metric: string }>
+    retention: number
+  };
+  clear(): void;
+}

package/dist/observability/metrics.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Global metrics manager instance
+ */
+export declare const metricsManager: MetricsManager;
+/**
+ * Custom CloudWatch Metrics
+ * Application and business metrics collection
+ */
+export declare interface MetricNamespace {
+  id: string
+  name: string
+  description?: string
+  metrics: CustomMetric[]
+}
+export declare interface CustomMetric {
+  id: string
+  name: string
+  namespace: string
+  unit: MetricUnit
+  dimensions?: MetricDimension[]
+  statisticValues?: MetricStatistic[]
+  alarms?: MetricAlarm[]
+}
+export declare interface MetricDimension {
+  name: string
+  value: string
+}
+export declare interface MetricStatistic {
+  sampleCount: number
+  sum: number
+  minimum: number
+  maximum: number
+  timestamp: Date
+}
+export declare interface MetricAlarm {
+  id: string
+  name: string
+  description?: string
+  comparisonOperator: 'GreaterThanThreshold' | 'GreaterThanOrEqualToThreshold' | 'LessThanThreshold' | 'LessThanOrEqualToThreshold'
+  evaluationPeriods: number
+  threshold: number
+  period: number
+  statistic: 'Average' | 'Sum' | 'Minimum' | 'Maximum' | 'SampleCount'
+  treatMissingData?: 'notBreaching' | 'breaching' | 'ignore' | 'missing'
+  actionsEnabled?: boolean
+  alarmActions?: string[]
+  okActions?: string[]
+  insufficientDataActions?: string[]
+}
+export type MetricUnit = | 'Seconds'
+  | 'Microseconds'
+  | 'Milliseconds'
+  | 'Bytes'
+  | 'Kilobytes'
+  | 'Megabytes'
+  | 'Gigabytes'
+  | 'Terabytes'
+  | 'Bits'
+  | 'Kilobits'
+  | 'Megabits'
+  | 'Gigabits'
+  | 'Terabits'
+  | 'Percent'
+  | 'Count'
+  | 'Bytes/Second'
+  | 'Kilobytes/Second'
+  | 'Megabytes/Second'
+  | 'Gigabytes/Second'
+  | 'Terabytes/Second'
+  | 'Bits/Second'
+  | 'Kilobits/Second'
+  | 'Megabits/Second'
+  | 'Gigabits/Second'
+  | 'Terabits/Second'
+  | 'Count/Second'
+  | 'None'
+/**
+ * Metrics manager
+ */
+export declare class MetricsManager {
+  private namespaces: Map<string, MetricNamespace>;
+  private metrics: Map<string, CustomMetric>;
+  private namespaceCounter: any;
+  private metricCounter: any;
+  private alarmCounter: any;
+  createNamespace(namespace: Omit<MetricNamespace, 'id'>): MetricNamespace;
+  createMetric(metric: Omit<CustomMetric, 'id'>): CustomMetric;
+  createBusinessMetric(options: {
+    name: string
+    namespace: string
+    unit: MetricUnit
+    description?: string
+  }): CustomMetric;
+  createApplicationMetric(options: {
+    name: string
+    namespace: string
+    unit: MetricUnit
+    serviceName: string
+  }): CustomMetric;
+  createPerformanceMetric(options: {
+    name: string
+    namespace: string
+    operation: string
+  }): CustomMetric;
+  createErrorMetric(options: {
+    name: string
+    namespace: string
+    errorType: string
+  }): CustomMetric;
+  createAlarm(metricId: string, alarm: Omit<MetricAlarm, 'id'>): MetricAlarm;
+  createErrorRateAlarm(options: {
+    metricId: string
+    name: string
+    threshold: number // errors per minute
+    snsTopicArn?: string
+  }): MetricAlarm;
+  createLatencyAlarm(options: {
+    metricId: string
+    name: string
+    thresholdMs: number
+    snsTopicArn?: string
+  }): MetricAlarm;
+  createThroughputAlarm(options: {
+    metricId: string
+    name: string
+    minimumThreshold: number
+    snsTopicArn?: string
+  }): MetricAlarm;
+  createCompositeAlarm(options: {
+    name: string
+    description?: string
+    alarmRule: string
+    actionsEnabled?: boolean
+    alarmActions?: string[]
+  }): any;
+  getNamespace(id: string): MetricNamespace | undefined;
+  listNamespaces(): MetricNamespace[];
+  getMetric(id: string): CustomMetric | undefined;
+  listMetrics(): CustomMetric[];
+  generateAlarmCF(metric: CustomMetric, alarm: MetricAlarm): any;
+  generateCompositeAlarmCF(alarm: any): any;
+  generateDashboardWidget(metric: CustomMetric): any;
+  publishCustomMetric(namespace: string, name: string, value: number, dimensions?: Record<string, string>, unit?: string): {
+    id: string
+    namespace: string
+    name: string
+    dimensions: Record<string, string>
+    value: number
+    unit: string
+    timestamp: Date
+  };
+  clear(): void;
+}

package/dist/observability/synthetics.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Global synthetics manager instance
+ */
+export declare const syntheticsManager: SyntheticsManager;
+/**
+ * Synthetic Monitoring
+ * CloudWatch Synthetics Canaries for proactive monitoring
+ */
+export declare interface SyntheticCanary {
+  id: string
+  name: string
+  description?: string
+  runtimeVersion: string
+  handler: string
+  code: CanaryCode
+  schedule: CanarySchedule
+  runConfig?: CanaryRunConfig
+  vpcConfig?: VpcConfig
+  artifactS3Location: string
+  successRetentionPeriod?: number
+  failureRetentionPeriod?: number
+  alarms?: CanaryAlarm[]
+}
+export declare interface CanaryCode {
+  type: 'script' | 's3'
+  script?: string
+  s3Bucket?: string
+  s3Key?: string
+  s3Version?: string
+}
+export declare interface CanarySchedule {
+  expression: string
+  durationInSeconds?: number
+}
+export declare interface CanaryRunConfig {
+  timeoutInSeconds: number
+  memoryInMB: number
+  environmentVariables?: Record<string, string>
+  activeTracing?: boolean
+}
+export declare interface VpcConfig {
+  subnetIds: string[]
+  securityGroupIds: string[]
+}
+export declare interface CanaryAlarm {
+  id: string
+  name: string
+  metric: 'SuccessPercent' | 'Duration' | 'Failed'
+  threshold: number
+  evaluationPeriods: number
+  snsTopicArn?: string
+}
+export declare interface HeartbeatMonitor {
+  id: string
+  name: string
+  url: string
+  interval: number
+  timeout: number
+  expectedStatus?: number
+}
+export declare interface ApiMonitor {
+  id: string
+  name: string
+  baseUrl: string
+  endpoints: ApiEndpoint[]
+  headers?: Record<string, string>
+  interval: number
+}
+export declare interface ApiEndpoint {
+  path: string
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH'
+  expectedStatus: number
+  body?: any
+  assertions?: ApiAssertion[]
+}
+export declare interface ApiAssertion {
+  type: 'status' | 'header' | 'body' | 'latency'
+  field?: string
+  operator: 'equals' | 'contains' | 'lessThan' | 'greaterThan'
+  value: any
+}
+/**
+ * Workflow step interface
+ */
+export declare interface WorkflowStep {
+  description: string
+  url: string
+  actions?: WorkflowAction[]
+}
+/**
+ * Workflow action interface
+ */
+export declare interface WorkflowAction {
+  type: 'click' | 'type' | 'wait' | 'waitForSelector'
+  selector?: string
+  value?: string
+  duration?: number
+}
+/**
+ * Synthetics manager
+ */
+export declare class SyntheticsManager {
+  private canaries: Map<string, SyntheticCanary>;
+  private heartbeats: Map<string, HeartbeatMonitor>;
+  private apiMonitors: Map<string, ApiMonitor>;
+  private canaryCounter: any;
+  private heartbeatCounter: any;
+  private apiMonitorCounter: any;
+  private alarmCounter: any;
+  static readonly RuntimeVersions: any;
+  createCanary(canary: Omit<SyntheticCanary, 'id'>): SyntheticCanary;
+  createHeartbeatCanary(options: {
+    name: string
+    url: string
+    interval: number // minutes
+    s3Bucket: string
+  }): SyntheticCanary;
+  createAPICanary(options: {
+    name: string
+    baseUrl: string
+    endpoints: ApiEndpoint[]
+    interval: number
+    s3Bucket: string
+  }): SyntheticCanary;
+  createVisualRegressionCanary(options: {
+    name: string
+    url: string
+    screenshotName: string
+    interval: number
+    s3Bucket: string
+  }): SyntheticCanary;
+  createWorkflowCanary(options: {
+    name: string
+    description: string
+    steps: WorkflowStep[]
+    interval: number
+    s3Bucket: string
+  }): SyntheticCanary;
+  private generateActionScript(action: WorkflowAction): string;
+  createAlarm(canaryId: string, alarm: Omit<CanaryAlarm, 'id'>): CanaryAlarm;
+  getCanary(id: string): SyntheticCanary | undefined;
+  listCanaries(): SyntheticCanary[];
+  generateCanaryCF(canary: SyntheticCanary): any;
+  generateCanaryRoleCF(): any;
+  clear(): void;
+}

package/dist/observability/xray.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Global X-Ray manager instance
+ */
+export declare const xrayManager: XRayManager;
+/**
+ * AWS X-Ray Integration
+ * Distributed tracing for microservices and serverless applications
+ */
+export declare interface XRayConfig {
+  id: string
+  name: string
+  serviceName: string
+  samplingRate: number
+  enableActiveTracing: boolean
+  segmentDocuments?: SegmentDocument[]
+}
+export declare interface SegmentDocument {
+  id: string
+  name: string
+  startTime: number
+  endTime?: number
+  subsegments?: SubSegment[]
+  annotations?: Record<string, string | number | boolean>
+  metadata?: Record<string, any>
+  http?: HttpData
+  aws?: AWSData
+  error?: boolean
+  fault?: boolean
+  throttle?: boolean
+}
+export declare interface SubSegment {
+  id: string
+  name: string
+  startTime: number
+  endTime?: number
+  namespace?: 'aws' | 'remote'
+  http?: HttpData
+  sql?: SqlData
+  annotations?: Record<string, string | number | boolean>
+  metadata?: Record<string, any>
+}
+export declare interface HttpData {
+  request?: {
+    method?: string
+    url?: string
+    userAgent?: string
+    clientIp?: string
+  }
+  response?: {
+    status?: number
+    contentLength?: number
+  }
+}
+export declare interface AWSData {
+  accountId?: string
+  operation?: string
+  region?: string
+  requestId?: string
+  queueUrl?: string
+  tableName?: string
+}
+export declare interface SqlData {
+  url?: string
+  preparation?: 'statement' | 'call'
+  databaseType?: string
+  databaseVersion?: string
+  driverVersion?: string
+  user?: string
+  sanitizedQuery?: string
+}
+export declare interface SamplingRule {
+  id: string
+  ruleName: string
+  priority: number
+  fixedRate: number
+  reservoirSize: number
+  serviceName: string
+  serviceType: string
+  host: string
+  httpMethod: string
+  urlPath: string
+  version: number
+}
+/**
+ * X-Ray manager
+ */
+export declare class XRayManager {
+  private configs: Map<string, XRayConfig>;
+  private samplingRules: Map<string, SamplingRule>;
+  private configCounter: any;
+  private ruleCounter: any;
+  createConfig(config: Omit<XRayConfig, 'id'>): XRayConfig;
+  createLambdaConfig(options: {
+    functionName: string
+    samplingRate?: number
+  }): XRayConfig;
+  createECSConfig(options: {
+    serviceName: string
+    clusterName: string
+    samplingRate?: number
+  }): XRayConfig;
+  createAPIGatewayConfig(options: {
+    apiName: string
+    stage: string
+    samplingRate?: number
+  }): XRayConfig;
+  createSamplingRule(rule: Omit<SamplingRule, 'id'>): SamplingRule;
+  createHighPrioritySamplingRule(options: {
+    ruleName: string
+    serviceName: string
+    urlPath: string
+  }): SamplingRule;
+  createErrorSamplingRule(serviceName: string): SamplingRule;
+  createDefaultSamplingRule(serviceName: string, samplingRate?: number): SamplingRule;
+  getConfig(id: string): XRayConfig | undefined;
+  listConfigs(): XRayConfig[];
+  getSamplingRule(id: string): SamplingRule | undefined;
+  listSamplingRules(): SamplingRule[];
+  generateLambdaXRayCF(config: XRayConfig): any;
+  generateAPIGatewayXRayCF(config: XRayConfig): any;
+  generateECSXRaySidecarCF(): any;
+  generateSamplingRuleCF(rule: SamplingRule): any;
+  createTrace(traceId: string, spans: Array<{ spanId: string; name: string; duration: number; tags: Record<string, any> }>): {
+    id: string
+    traceId: string
+    spans: Array<{ spanId: string; name: string; duration: number; tags: Record<string, any> }>
+  };
+  clear(): void;
+}

package/dist/phone/advanced/analytics.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Call Analytics and Reporting
+ *
+ * Provides call metrics, reporting, and insights
+ */
+export declare interface CallMetrics {
+  period: string
+  totalCalls: number
+  answeredCalls: number
+  missedCalls: number
+  abandonedCalls: number
+  voicemails: number
+  averageWaitTime: number
+  averageHandleTime: number
+  averageTalkTime: number
+  serviceLevel: number
+  abandonRate: number
+  answerRate: number
+}
+export declare interface AgentMetrics {
+  agentId: string
+  agentName: string
+  callsHandled: number
+  averageHandleTime: number
+  averageTalkTime: number
+  averageHoldTime: number
+  occupancy: number
+  availability: number
+}
+export declare interface QueueMetrics {
+  queueId: string
+  queueName: string
+  callsInQueue: number
+  oldestCallWaitTime: number
+  averageWaitTime: number
+  agentsAvailable: number
+  agentsOnCall: number
+}
+export declare interface CallInsight {
+  callId: string
+  sentiment: 'positive' | 'neutral' | 'negative'
+  topics: string[]
+  keywords: string[]
+  issues: string[]
+  resolution: boolean
+  customerSatisfaction?: number
+}
+/**
+ * Call Analytics Module
+ */
+export declare class CallAnalytics {
+  static MetricsAggregatorCode: any;
+  static QueueMetricsCode: any;
+  static createMetricsTable(config: { slug: string }): Record<string, any>;
+  static createMetricsAggregatorLambda(config: {
+    slug: string
+    roleArn: string
+    callLogTable: string
+    metricsTable: string
+  }): Record<string, any>;
+  static createMetricsSchedule(config: {
+    slug: string
+    lambdaArn: string
+  }): Record<string, any>;
+}
+export default CallAnalytics;