@stacksjs/ts-cloud-core 0.1.6 → 0.1.8

package/dist/dns/dnssec.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Global DNSSEC manager instance
+ */
+export declare const dnssecManager: DNSSECManager;
+/**
+ * DNSSEC Configuration
+ * DNS Security Extensions for Route53
+ */
+export declare interface DNSSECConfig {
+  id: string
+  hostedZoneId: string
+  status: 'SIGNING' | 'SIGNED' | 'NOT_SIGNING' | 'DELETING' | 'ACTION_NEEDED'
+  signingStatus?: string
+  statusMessage?: string
+}
+export declare interface KSK {
+  id: string
+  name: string
+  hostedZoneId: string
+  status: 'ACTIVE' | 'INACTIVE' | 'DELETING' | 'ACTION_NEEDED'
+  keyManagementServiceArn: string
+  dnskeyRecord?: string
+  dsRecord?: string
+  digestAlgorithm: number
+  digestValue?: string
+  flag: number
+  keyTag?: number
+  publicKey?: string
+}
+export declare interface DNSSECValidation {
+  id: string
+  domain: string
+  validationStatus: 'VALID' | 'INVALID' | 'INSECURE' | 'BOGUS'
+  dnskeyPresent: boolean
+  rrsigPresent: boolean
+  validSignature: boolean
+  errors: string[]
+}
+/**
+ * DNSSEC manager
+ */
+export declare class DNSSECManager {
+  private configs: Map<string, DNSSECConfig>;
+  private ksks: Map<string, KSK>;
+  private validations: Map<string, DNSSECValidation>;
+  private configCounter: any;
+  private kskCounter: any;
+  private validationCounter: any;
+  enableDNSSEC(options: {
+    hostedZoneId: string
+    kmsKeyArn?: string
+  }): DNSSECConfig;
+  disableDNSSEC(configId: string): DNSSECConfig;
+  createKSK(options: {
+    name: string
+    hostedZoneId: string
+    kmsKeyArn: string
+  }): KSK;
+  deactivateKSK(kskId: string): KSK;
+  validateDNSSEC(options: {
+    domain: string
+    checkDNSKEY?: boolean
+    checkRRSIG?: boolean
+  }): DNSSECValidation;
+  getDNSSECConfig(id: string): DNSSECConfig | undefined;
+  listDNSSECConfigs(): DNSSECConfig[];
+  getKSK(id: string): KSK | undefined;
+  listKSKs(hostedZoneId?: string): KSK[];
+  getDSRecord(kskId: string): string;
+  private generatePublicKey(): string;
+  private generateDigest(dnskeyRecord: string): string;
+  generateDNSSECCF(config: DNSSECConfig): any;
+  generateKSKCF(ksk: KSK): any;
+  clear(): void;
+}

package/dist/dns/index.d.ts

@@ -0,0 +1,3 @@
+export * from './routing';
+export * from './dnssec';
+export * from './resolver';

package/dist/dns/resolver.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Global Route53 Resolver manager instance
+ */
+export declare const route53ResolverManager: Route53ResolverManager;
+/**
+ * Route53 Resolver
+ * DNS firewall, resolver rules, and endpoints
+ */
+export declare interface ResolverEndpoint {
+  id: string
+  name: string
+  direction: 'INBOUND' | 'OUTBOUND'
+  ipAddresses: ResolverIP[]
+  securityGroupIds: string[]
+  status: 'CREATING' | 'OPERATIONAL' | 'UPDATING' | 'DELETING' | 'ACTION_NEEDED'
+}
+export declare interface ResolverIP {
+  subnetId: string
+  ip?: string
+  ipv6?: string
+}
+export declare interface ResolverRule {
+  id: string
+  name: string
+  ruleType: 'FORWARD' | 'SYSTEM' | 'RECURSIVE'
+  domainName: string
+  targetIps?: TargetIP[]
+  resolverEndpointId?: string
+  status: 'COMPLETE' | 'CREATING' | 'UPDATING' | 'DELETING' | 'FAILED'
+}
+export declare interface TargetIP {
+  ip: string
+  port?: number
+}
+export declare interface DNSFirewall {
+  id: string
+  name: string
+  firewallRuleGroupAssociations: FirewallRuleGroupAssociation[]
+}
+export declare interface FirewallRuleGroupAssociation {
+  id: string
+  vpcId: string
+  firewallRuleGroupId: string
+  priority: number
+  mutationProtection: 'ENABLED' | 'DISABLED'
+  status: 'COMPLETE' | 'CREATING' | 'UPDATING' | 'DELETING'
+}
+export declare interface FirewallRuleGroup {
+  id: string
+  name: string
+  rules: FirewallRule[]
+  shareStatus: 'NOT_SHARED' | 'SHARED_WITH_ME' | 'SHARED_BY_ME'
+}
+export declare interface FirewallRule {
+  id: string
+  name: string
+  priority: number
+  action: 'ALLOW' | 'BLOCK' | 'ALERT'
+  blockResponse?: 'NODATA' | 'NXDOMAIN' | 'OVERRIDE'
+  blockOverrideDomain?: string
+  blockOverrideTTL?: number
+  firewallDomainListId: string
+}
+export declare interface FirewallDomainList {
+  id: string
+  name: string
+  domains: string[]
+  status: 'COMPLETE' | 'CREATING' | 'UPDATING' | 'DELETING'
+}
+/**
+ * Route53 Resolver manager
+ */
+export declare class Route53ResolverManager {
+  private endpoints: Map<string, ResolverEndpoint>;
+  private rules: Map<string, ResolverRule>;
+  private firewalls: Map<string, DNSFirewall>;
+  private ruleGroups: Map<string, FirewallRuleGroup>;
+  private domainLists: Map<string, FirewallDomainList>;
+  private endpointCounter: any;
+  private ruleCounter: any;
+  private firewallCounter: any;
+  private ruleGroupCounter: any;
+  private domainListCounter: any;
+  createResolverEndpoint(endpoint: Omit<ResolverEndpoint, 'id' | 'status'>): ResolverEndpoint;
+  createInboundEndpoint(options: {
+    name: string
+    subnetIds: string[]
+    securityGroupIds: string[]
+  }): ResolverEndpoint;
+  createOutboundEndpoint(options: {
+    name: string
+    subnetIds: string[]
+    securityGroupIds: string[]
+  }): ResolverEndpoint;
+  createResolverRule(rule: Omit<ResolverRule, 'id' | 'status'>): ResolverRule;
+  createForwardRule(options: {
+    name: string
+    domainName: string
+    targetIps: TargetIP[]
+    resolverEndpointId: string
+  }): ResolverRule;
+  createSystemRule(options: {
+    name: string
+    domainName: string
+  }): ResolverRule;
+  createFirewallDomainList(options: {
+    name: string
+    domains: string[]
+  }): FirewallDomainList;
+  createFirewallRuleGroup(options: {
+    name: string
+    rules: Omit<FirewallRule, 'id'>[]
+  }): FirewallRuleGroup;
+  createBlockRule(options: {
+    name: string
+    priority: number
+    domainListId: string
+    blockResponse?: 'NODATA' | 'NXDOMAIN' | 'OVERRIDE'
+    blockOverrideDomain?: string
+  }): FirewallRuleGroup;
+  createAllowRule(options: {
+    name: string
+    priority: number
+    domainListId: string
+  }): FirewallRuleGroup;
+  createDNSFirewall(options: {
+    name: string
+    vpcId: string
+    ruleGroupAssociations: Array<{
+      firewallRuleGroupId: string
+      priority: number
+      mutationProtection?: 'ENABLED' | 'DISABLED'
+    }>
+  }): DNSFirewall;
+  createMalwareProtectionFirewall(options: {
+    name: string
+    vpcId: string
+    maliciousDomains: string[]
+  }): DNSFirewall;
+  getEndpoint(id: string): ResolverEndpoint | undefined;
+  listEndpoints(direction?: 'INBOUND' | 'OUTBOUND'): ResolverEndpoint[];
+  getRule(id: string): ResolverRule | undefined;
+  listRules(): ResolverRule[];
+  getFirewall(id: string): DNSFirewall | undefined;
+  listFirewalls(): DNSFirewall[];
+  generateResolverEndpointCF(endpoint: ResolverEndpoint): any;
+  generateResolverRuleCF(rule: ResolverRule): any;
+  generateFirewallRuleGroupCF(ruleGroup: FirewallRuleGroup): any;
+  clear(): void;
+}

package/dist/dns/routing.d.ts

@@ -0,0 +1,217 @@
+/**
+ * Global Route53 routing manager instance
+ */
+export declare const route53RoutingManager: Route53RoutingManager;
+/**
+ * Route53 Advanced Routing
+ * Health-based, geolocation, weighted, failover, and latency-based routing
+ */
+export declare interface RoutingPolicy {
+  id: string
+  name: string
+  type: 'simple' | 'weighted' | 'latency' | 'failover' | 'geolocation' | 'geoproximity' | 'multivalue'
+  recordSetId?: string
+}
+export declare interface WeightedRoutingPolicy extends RoutingPolicy {
+  type: 'weighted'
+  weight: number
+  setIdentifier: string
+  healthCheckId?: string
+}
+export declare interface LatencyRoutingPolicy extends RoutingPolicy {
+  type: 'latency'
+  region: string
+  setIdentifier: string
+  healthCheckId?: string
+}
+export declare interface FailoverRoutingPolicy extends RoutingPolicy {
+  type: 'failover'
+  failoverType: 'PRIMARY' | 'SECONDARY'
+  setIdentifier: string
+  healthCheckId: string
+}
+export declare interface GeolocationRoutingPolicy extends RoutingPolicy {
+  type: 'geolocation'
+  continent?: string
+  country?: string
+  subdivision?: string
+  setIdentifier: string
+  healthCheckId?: string
+}
+export declare interface GeoproximityRoutingPolicy extends RoutingPolicy {
+  type: 'geoproximity'
+  coordinates?: {
+    latitude: number
+    longitude: number
+  }
+  awsRegion?: string
+  bias?: number
+  setIdentifier: string
+  healthCheckId?: string
+}
+export declare interface HealthCheck {
+  id: string
+  name: string
+  type: 'http' | 'https' | 'tcp' | 'calculated' | 'cloudwatch_metric'
+  resourcePath?: string
+  fullyQualifiedDomainName?: string
+  ipAddress?: string
+  port?: number
+  requestInterval: number
+  failureThreshold: number
+  healthCheckStatus: 'Healthy' | 'Unhealthy' | 'Unknown'
+  measureLatency?: boolean
+  enableSNI?: boolean
+}
+export declare interface CalculatedHealthCheck extends HealthCheck {
+  type: 'calculated'
+  childHealthChecks: string[]
+  healthThreshold: number
+}
+export declare interface TrafficPolicy {
+  id: string
+  name: string
+  version: number
+  document: TrafficPolicyDocument
+}
+export declare interface TrafficPolicyDocument {
+  recordType: 'A' | 'AAAA' | 'CNAME'
+  startRule: string
+  endpoints: Record<string, TrafficPolicyEndpoint>
+  rules: Record<string, TrafficPolicyRule>
+}
+export declare interface TrafficPolicyEndpoint {
+  type: 'value' | 'cloudfront' | 'elastic_load_balancer' | 's3_website'
+  value?: string
+  region?: string
+}
+export declare interface TrafficPolicyRule {
+  ruleType: 'failover' | 'geoproximity' | 'latency' | 'weighted' | 'multivalue'
+  primary?: string
+  secondary?: string
+  locations?: Array<{
+    endpointReference: string
+    region?: string
+    latitude?: number
+    longitude?: number
+    bias?: number
+  }>
+  items?: Array<{
+    endpointReference: string
+    weight?: number
+  }>
+}
+/**
+ * Route53 routing policy manager
+ */
+export declare class Route53RoutingManager {
+  private policies: Map<string, RoutingPolicy>;
+  private healthChecks: Map<string, HealthCheck>;
+  private trafficPolicies: Map<string, TrafficPolicy>;
+  private policyCounter: any;
+  private healthCheckCounter: any;
+  private trafficPolicyCounter: any;
+  createWeightedPolicy(options: {
+    name: string
+    weight: number
+    setIdentifier: string
+    healthCheckId?: string
+  }): WeightedRoutingPolicy;
+  createLatencyPolicy(options: {
+    name: string
+    region: string
+    setIdentifier: string
+    healthCheckId?: string
+  }): LatencyRoutingPolicy;
+  createFailoverPolicy(options: {
+    name: string
+    failoverType: 'PRIMARY' | 'SECONDARY'
+    setIdentifier: string
+    healthCheckId: string
+  }): FailoverRoutingPolicy;
+  createGeolocationPolicy(options: {
+    name: string
+    continent?: string
+    country?: string
+    subdivision?: string
+    setIdentifier: string
+    healthCheckId?: string
+  }): GeolocationRoutingPolicy;
+  createGeoproximityPolicy(options: {
+    name: string
+    coordinates?: {
+      latitude: number
+      longitude: number
+    }
+    awsRegion?: string
+    bias?: number
+    setIdentifier: string
+    healthCheckId?: string
+  }): GeoproximityRoutingPolicy;
+  createHTTPHealthCheck(options: {
+    name: string
+    resourcePath: string
+    fullyQualifiedDomainName?: string
+    ipAddress?: string
+    port?: number
+    requestInterval?: number
+    failureThreshold?: number
+    enableSNI?: boolean
+  }): HealthCheck;
+  createTCPHealthCheck(options: {
+    name: string
+    ipAddress: string
+    port: number
+    requestInterval?: number
+    failureThreshold?: number
+  }): HealthCheck;
+  createCalculatedHealthCheck(options: {
+    name: string
+    childHealthChecks: string[]
+    healthThreshold: number
+  }): CalculatedHealthCheck;
+  createTrafficPolicy(policy: Omit<TrafficPolicy, 'id' | 'version'>): TrafficPolicy;
+  createFailoverTrafficPolicy(options: {
+    name: string
+    primaryEndpoint: string
+    secondaryEndpoint: string
+    recordType?: 'A' | 'AAAA' | 'CNAME'
+  }): TrafficPolicy;
+  createGeoproximityTrafficPolicy(options: {
+    name: string
+    locations: Array<{
+      endpoint: string
+      region?: string
+      latitude?: number
+      longitude?: number
+      bias?: number
+    }>
+  }): TrafficPolicy;
+  getPolicy(id: string): RoutingPolicy | undefined;
+  listPolicies(): RoutingPolicy[];
+  getHealthCheck(id: string): HealthCheck | undefined;
+  listHealthChecks(): HealthCheck[];
+  getHealthCheckStatus(id: string): 'Healthy' | 'Unhealthy' | 'Unknown';
+  generateHealthCheckCF(healthCheck: HealthCheck): any;
+  generateWeightedRecordSetCF(options: {
+    hostedZoneId: string
+    name: string
+    type: 'A' | 'AAAA' | 'CNAME'
+    ttl: number
+    resourceRecords: string[]
+    weight: number
+    setIdentifier: string
+    healthCheckId?: string
+  }): any;
+  generateFailoverRecordSetCF(options: {
+    hostedZoneId: string
+    name: string
+    type: 'A' | 'AAAA' | 'CNAME'
+    ttl: number
+    resourceRecords: string[]
+    failover: 'PRIMARY' | 'SECONDARY'
+    setIdentifier: string
+    healthCheckId?: string
+  }): any;
+  clear(): void;
+}

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

@@ -0,0 +1,78 @@
+/**
+ * Email Analytics
+ *
+ * Provides open tracking, click tracking, and email metrics
+ */
+export declare interface EmailAnalytics {
+  messageId: string
+  sent: boolean
+  sentAt?: string
+  delivered: boolean
+  deliveredAt?: string
+  opened: boolean
+  openedAt?: string
+  openCount: number
+  clicked: boolean
+  clickedAt?: string
+  clickCount: number
+  clicks: ClickEvent[]
+  bounced: boolean
+  bouncedAt?: string
+  bounceType?: string
+  complained: boolean
+  complainedAt?: string
+  unsubscribed: boolean
+  unsubscribedAt?: string
+}
+export declare interface ClickEvent {
+  url: string
+  clickedAt: string
+  userAgent?: string
+  ipAddress?: string
+}
+export declare interface EmailMetrics {
+  period: string
+  sent: number
+  delivered: number
+  opened: number
+  clicked: number
+  bounced: number
+  complained: number
+  unsubscribed: number
+  deliveryRate: number
+  openRate: number
+  clickRate: number
+  bounceRate: number
+  complaintRate: number
+}
+/**
+ * Email Analytics Module
+ */
+export declare class EmailAnalyticsModule {
+  static TrackingPixelLambdaCode: any;
+  static ClickTrackingLambdaCode: any;
+  static SesEventProcessorCode: any;
+  static createAnalyticsTable(config: { slug: string }): Record<string, any>;
+  static createTrackingPixelLambda(config: {
+    slug: string
+    roleArn: string
+    analyticsTable: string
+  }): Record<string, any>;
+  static createClickTrackingLambda(config: {
+    slug: string
+    roleArn: string
+    analyticsTable: string
+  }): Record<string, any>;
+  static createSesEventProcessorLambda(config: {
+    slug: string
+    roleArn: string
+    analyticsTable: string
+  }): Record<string, any>;
+  static injectTracking(params: {
+    html: string
+    messageId: string
+    trackingDomain: string
+  }): string;
+  static calculateMetrics(analytics: EmailAnalytics[]): EmailMetrics;
+}
+export default EmailAnalyticsModule;

package/dist/email/advanced/index.d.ts

@@ -0,0 +1,7 @@
+export * from './search';
+export * from './threading';
+export * from './scheduling';
+export * from './analytics';
+export * from './templates';
+export * from './shared-mailboxes';
+export * from './rules';

package/dist/email/advanced/rules.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Email Rules and Automation
+ *
+ * Provides email filtering, routing, and automation
+ */
+export declare interface EmailRule {
+  id: string
+  name: string
+  enabled: boolean
+  priority: number
+  conditions: RuleCondition[]
+  conditionOperator: 'and' | 'or'
+  actions: RuleAction[]
+  createdAt: string
+  updatedAt: string
+}
+export declare interface RuleCondition {
+  field: 'from' | 'to' | 'subject' | 'body' | 'headers' | 'attachments' | 'size'
+  operator: 'contains' | 'not-contains' | 'equals' | 'not-equals' | 'starts-with' | 'ends-with' | 'regex' | 'greater-than' | 'less-than'
+  value: string
+  caseSensitive?: boolean
+}
+export declare interface RuleAction {
+  type: 'move' | 'copy' | 'delete' | 'label' | 'forward' | 'reply' | 'mark-read' | 'mark-starred' | 'webhook' | 'lambda'
+  params: Record<string, any>
+}
+export declare interface AutomationWorkflow {
+  id: string
+  name: string
+  trigger: WorkflowTrigger
+  steps: WorkflowStep[]
+  enabled: boolean
+}
+export declare interface WorkflowTrigger {
+  type: 'email-received' | 'email-sent' | 'schedule' | 'webhook'
+  conditions?: RuleCondition[]
+}
+export declare interface WorkflowStep {
+  id: string
+  type: 'delay' | 'condition' | 'action' | 'loop'
+  config: Record<string, any>
+  next?: string
+  onTrue?: string
+  onFalse?: string
+}
+/**
+ * Email Rules Module
+ */
+export declare class EmailRules {
+  static RuleProcessorCode: any;
+  static createRulesTable(config: { slug: string }): Record<string, any>;
+  static createRuleProcessorLambda(config: {
+    slug: string
+    roleArn: string
+    emailBucket: string
+    rulesTable: string
+  }): Record<string, any>;
+  static readonly RuleTemplates: any;
+}
+export default EmailRules;

package/dist/email/advanced/scheduling.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Email Scheduling (Send Later)
+ *
+ * Provides scheduled email sending functionality
+ */
+export declare interface ScheduledEmail {
+  id: string
+  email: {
+    from: string
+    to: string | string[]
+    cc?: string[]
+    bcc?: string[]
+    subject: string
+    html?: string
+    text?: string
+    attachments?: Array<{
+      filename: string
+      content: string
+      contentType?: string
+    }>
+  }
+  scheduledFor: string
+  timezone?: string
+  status: 'pending' | 'sent' | 'failed' | 'cancelled'
+  createdAt: string
+  sentAt?: string
+  error?: string
+  retryCount?: number
+}
+/**
+ * Email Scheduling Module
+ */
+export declare class EmailScheduling {
+  static SchedulerLambdaCode: any;
+  static createSchedulerLambda(config: {
+    slug: string
+    roleArn: string
+    emailBucket: string
+  }): Record<string, any>;
+  static createSchedulerRule(config: {
+    slug: string
+    lambdaArn: string
+    scheduleExpression?: string
+  }): Record<string, any>;
+  static scheduleEmail(params: {
+    s3Client: any
+    bucket: string
+    email: ScheduledEmail['email']
+    scheduledFor: Date | string
+    timezone?: string
+  }): Promise<ScheduledEmail>;
+  static cancelScheduledEmail(params: {
+    s3Client: any
+    bucket: string
+    id: string
+  }): Promise<boolean>;
+  static listScheduledEmails(params: {
+    s3Client: any
+    bucket: string
+    status?: ScheduledEmail['status']
+  }): Promise<ScheduledEmail[]>;
+}
+export default EmailScheduling;