@stacksjs/ts-cloud 0.1.11 → 0.1.14

package/dist/deploy/static-site.d.ts

@@ -1,71 +0,0 @@
-import type { DnsProviderConfig } from '../dns/types';
-/**
- * Generate CloudFormation template for static site infrastructure
- */
-export declare function generateStaticSiteTemplate(config: {
-  bucketName: string
-  domain?: string
-  certificateArn?: string
-  hostedZoneId?: string
-  defaultRootObject?: string
-  errorDocument?: string
-}): object;
-/**
- * Deploy a static site to AWS
- * Automatically routes to external DNS deployment when a non-Route53 dnsProvider is configured
- */
-export declare function deployStaticSite(config: StaticSiteConfig): Promise<DeployResult>;
-/**
- * Upload files to S3 bucket (only uploads changed files)
- */
-export declare function uploadStaticFiles(options: UploadOptions): Promise<{ uploaded: number; skipped: number; errors: string[] }>;
-/**
- * Invalidate CloudFront cache
- */
-export declare function invalidateCache(distributionId: string): Promise<{ invalidationId: string }>;
-/**
- * Delete static site infrastructure
- */
-export declare function deleteStaticSite(stackName: string, region?: string): Promise<{ success: boolean; message: string }>;
-/**
- * Full deployment: infrastructure + files + cache invalidation
- */
-export declare function deployStaticSiteFull(config: StaticSiteConfig & {
-  sourceDir: string
-  cleanBucket?: boolean
-  onProgress?: (stage: string, detail?: string) => void
-}): Promise<DeployResult & { filesUploaded?: number; filesSkipped?: number }>;
-export declare interface StaticSiteConfig {
-  siteName: string
-  region?: string
-  domain?: string
-  subdomain?: string
-  baseDomain?: string
-  bucket?: string
-  hostedZoneId?: string
-  certificateArn?: string
-  stackName?: string
-  defaultRootObject?: string
-  errorDocument?: string
-  cacheControl?: string
-  tags?: Record<string, string>
-  dnsProvider?: DnsProviderConfig
-}
-export declare interface DeployResult {
-  success: boolean
-  stackId?: string
-  stackName: string
-  bucket: string
-  distributionId?: string
-  distributionDomain?: string
-  domain?: string
-  certificateArn?: string
-  message: string
-}
-export declare interface UploadOptions {
-  sourceDir: string
-  bucket: string
-  region: string
-  cacheControl?: string
-  onProgress?: (uploaded: number, total: number, file: string) => void
-}

package/dist/dns/cloudflare.d.ts

@@ -1,52 +0,0 @@
-import type { CreateRecordResult, DeleteRecordResult, DnsProvider, DnsRecord, DnsRecordResult, DnsRecordType, ListRecordsResult,  } from './types';
-declare interface CloudflareRecord {
-  id: string
-  zone_id: string
-  zone_name: string
-  name: string
-  type: string
-  content: string
-  proxiable: boolean
-  proxied: boolean
-  ttl: number
-  locked: boolean
-  meta: Record<string, any>
-  comment?: string
-  tags?: string[]
-  created_on: string
-  modified_on: string
-  priority?: number
-}
-export declare class CloudflareProvider implements DnsProvider {
-  readonly name: any;
-  private apiToken: string;
-  private zoneCache: Map<string, string>;
-  constructor(apiToken: string);
-  private request<T>(method: string, endpoint: string, body?: any): Promise<CloudflareApiResponse<T>>;
-  private getRootDomain(domain: string): string;
-  private getZoneId(domain: string): Promise<string>;
-  private getFullRecordName(name: string, domain: string): string;
-  private toCloudflareRecord(record: DnsRecord, domain: string): Partial<CloudflareRecord>;
-  private fromCloudflareRecord(record: CloudflareRecord): DnsRecordResult;
-  createRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>;
-  upsertRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>;
-  deleteRecord(domain: string, record: DnsRecord): Promise<DeleteRecordResult>;
-  listRecords(domain: string, type?: DnsRecordType): Promise<ListRecordsResult>;
-  canManageDomain(domain: string): Promise<boolean>;
-  listDomains(): Promise<string[]>;
-  getZoneDetails(domain: string): Promise<{
-    id: string
-    name: string
-    status: string
-    nameServers: string[]
-    paused: boolean
-  } | null>;
-  purgeCache(domain: string, options?: {
-    purgeEverything?: boolean
-    files?: string[]
-    tags?: string[]
-    hosts?: string[]
-  }): Promise<boolean>;
-  getRecordProxyStatus(domain: string, record: DnsRecord): Promise<boolean | null>;
-  setRecordProxyStatus(domain: string, record: DnsRecord, proxied: boolean): Promise<boolean>;
-}

package/dist/dns/godaddy.d.ts

@@ -1,38 +0,0 @@
-import type { CreateRecordResult, DeleteRecordResult, DnsProvider, DnsRecord, DnsRecordResult, DnsRecordType, ListRecordsResult,  } from './types';
-declare interface GoDaddyRecord {
-  type: string
-  name: string
-  data: string
-  ttl: number
-  priority?: number
-}
-export declare class GoDaddyProvider implements DnsProvider {
-  readonly name: any;
-  private apiKey: string;
-  private apiSecret: string;
-  private baseUrl: string;
-  constructor(apiKey: string, apiSecret: string, environment?: 'production' | 'ote');
-  private request<T>(method: string, endpoint: string, body?: any): Promise<T>;
-  private getSubdomain(recordName: string, domain: string): string;
-  private getRootDomain(domain: string): string;
-  private toGoDaddyRecord(record: DnsRecord, domain: string): GoDaddyRecord;
-  private fromGoDaddyRecord(record: GoDaddyRecord, domain: string): DnsRecordResult;
-  createRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>;
-  upsertRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>;
-  deleteRecord(domain: string, record: DnsRecord): Promise<DeleteRecordResult>;
-  listRecords(domain: string, type?: DnsRecordType): Promise<ListRecordsResult>;
-  canManageDomain(domain: string): Promise<boolean>;
-  listDomains(): Promise<string[]>;
-  getDomainDetails(domain: string): Promise<{
-    domain: string
-    status: string
-    nameServers?: string[]
-    expires?: string
-  } | null>;
-  updateNameServers(domain: string, nameservers: string[]): Promise<boolean>;
-  checkDomainAvailability(domain: string): Promise<{
-    available: boolean
-    price?: number
-    currency?: string
-  }>;
-}

package/dist/dns/index.d.ts

@@ -1,45 +0,0 @@
-import { CloudflareProvider } from './cloudflare';
-import { GoDaddyProvider } from './godaddy';
-import { PorkbunProvider } from './porkbun';
-import { Route53Provider } from './route53-adapter';
-import type { DnsProvider, DnsProviderConfig } from './types';
-/**
- * Create a DNS provider from configuration
- */
-export declare function createDnsProvider(config: DnsProviderConfig): DnsProvider;
-/**
- * Auto-detect DNS provider for a domain
- * Tries each provider to see which one can manage the domain
- */
-export declare function detectDnsProvider(domain: string, configs: DnsProviderConfig[]): Promise<DnsProvider | null>;
-/**
- * Default factory instance (can be configured globally)
- */
-export declare const dnsProviders: DnsProviderFactory;
-/**
- * DNS Provider factory with environment variable support
- */
-export declare class DnsProviderFactory {
-  private providers: Map<string, DnsProvider>;
-  private configs: DnsProviderConfig[];
-  addConfig(config: DnsProviderConfig): this;
-  addRoute53(region?: string, hostedZoneId?: string): this;
-  addPorkbun(apiKey: string, secretKey: string): this;
-  addGoDaddy(apiKey: string, apiSecret: string, environment?: 'production' | 'ote'): this;
-  addCloudflare(apiToken: string): this;
-  loadFromEnv(): this;
-  getProvider(name: 'route53' | 'porkbun' | 'godaddy' | 'cloudflare'): DnsProvider | null;
-  getProviderForDomain(domain: string): Promise<DnsProvider | null>;
-  getAllProviders(): DnsProvider[];
-}
-export * from './types';
-export { PorkbunProvider } from './porkbun';
-export { GoDaddyProvider } from './godaddy';
-export { CloudflareProvider } from './cloudflare';
-export { Route53Provider } from './route53-adapter';
-export {
-  UnifiedDnsValidator,
-  createPorkbunValidator,
-  createGoDaddyValidator,
-  createRoute53Validator,
-} from './validator';

package/dist/dns/porkbun.d.ts

@@ -1,18 +0,0 @@
-import type { CreateRecordResult, DeleteRecordResult, DnsProvider, DnsRecord, DnsRecordType, ListRecordsResult,  } from './types';
-export declare class PorkbunProvider implements DnsProvider {
-  readonly name: any;
-  private apiKey: string;
-  private secretKey: string;
-  constructor(apiKey: string, secretKey: string);
-  private request<T extends PorkbunApiResponse>(endpoint: string, additionalBody?: Record<string, any>): Promise<T>;
-  private getSubdomain(recordName: string, domain: string): string;
-  private getRootDomain(domain: string): string;
-  createRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>;
-  upsertRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>;
-  deleteRecord(domain: string, record: DnsRecord): Promise<DeleteRecordResult>;
-  listRecords(domain: string, type?: DnsRecordType): Promise<ListRecordsResult>;
-  canManageDomain(domain: string): Promise<boolean>;
-  listDomains(): Promise<string[]>;
-  getNameServers(domain: string): Promise<string[]>;
-  updateNameServers(domain: string, nameservers: string[]): Promise<boolean>;
-}

package/dist/dns/route53-adapter.d.ts

@@ -1,38 +0,0 @@
-import { Route53Client } from '../aws/route53';
-import type { CreateRecordResult, DeleteRecordResult, DnsProvider, DnsRecord, DnsRecordType, ListRecordsResult,  } from './types';
-export declare class Route53Provider implements DnsProvider {
-  readonly name: any;
-  private client: Route53Client;
-  private hostedZoneCache: Map<string, string>;
-  private providedHostedZoneId?: string;
-  constructor(region?: string, hostedZoneId?: string);
-  private getRootDomain(domain: string): string;
-  private getHostedZoneId(domain: string): Promise<string | null>;
-  private normalizeName(name: string): string;
-  createRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>;
-  upsertRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>;
-  deleteRecord(domain: string, record: DnsRecord): Promise<DeleteRecordResult>;
-  listRecords(domain: string, type?: DnsRecordType): Promise<ListRecordsResult>;
-  canManageDomain(domain: string): Promise<boolean>;
-  listDomains(): Promise<string[]>;
-  getRoute53Client(): Route53Client;
-  createAliasRecord(params: {
-    domain: string
-    name: string
-    targetHostedZoneId: string
-    targetDnsName: string
-    evaluateTargetHealth?: boolean
-    type?: 'A' | 'AAAA'
-  }): Promise<CreateRecordResult>;
-  createCloudFrontAlias(params: {
-    domain: string
-    name: string
-    cloudFrontDomainName: string
-  }): Promise<CreateRecordResult>;
-  createAlbAlias(params: {
-    domain: string
-    name: string
-    albDnsName: string
-    region: string
-  }): Promise<CreateRecordResult>;
-}

package/dist/dns/types.d.ts

@@ -1,77 +0,0 @@
-export declare interface DnsRecord {
-  name: string
-  type: DnsRecordType
-  content: string
-  value?: string
-  ttl?: number
-  priority?: number
-  weight?: number
-  port?: number
-}
-export declare interface DnsRecordResult extends DnsRecord {
-  id?: string
-}
-export declare interface CreateRecordResult {
-  success: boolean
-  id?: string
-  message?: string
-}
-export declare interface DeleteRecordResult {
-  success: boolean
-  message?: string
-}
-export declare interface ListRecordsResult {
-  success: boolean
-  records: DnsRecordResult[]
-  message?: string
-}
-/**
- * Common DNS Provider interface
- * All DNS providers (Route53, Porkbun, GoDaddy, etc.) implement this
- */
-export declare interface DnsProvider {
-  name: string
-  createRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>
-  upsertRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>
-  deleteRecord(domain: string, record: DnsRecord): Promise<DeleteRecordResult>
-  listRecords(domain: string, type?: DnsRecordType): Promise<ListRecordsResult>
-  canManageDomain(domain: string): Promise<boolean>
-  listDomains(): Promise<string[]>
-}
-/**
- * DNS Provider configuration types
- */
-export declare interface Route53ProviderConfig {
-  provider: 'route53'
-  region?: string
-  hostedZoneId?: string
-}
-export declare interface PorkbunProviderConfig {
-  provider: 'porkbun'
-  apiKey: string
-  secretKey: string
-}
-export declare interface GoDaddyProviderConfig {
-  provider: 'godaddy'
-  apiKey: string
-  apiSecret: string
-  environment?: 'production' | 'ote'
-}
-export declare interface CloudflareProviderConfig {
-  provider: 'cloudflare'
-  apiToken: string
-}
-/**
- * Extended configuration for certificate validation
- */
-export declare interface CertificateValidationConfig {
-  provider: DnsProviderConfig
-  waitForValidation?: boolean
-  maxWaitMinutes?: number
-}
-/**
- * DNS Provider Types
- * Common interfaces for DNS provider abstraction
- */
-export type DnsRecordType = 'A' | 'AAAA' | 'CNAME' | 'TXT' | 'MX' | 'NS' | 'SRV' | 'CAA'
-export type DnsProviderConfig = Route53ProviderConfig | PorkbunProviderConfig | GoDaddyProviderConfig | CloudflareProviderConfig

package/dist/dns/validator.d.ts

@@ -1,78 +0,0 @@
-import { ACMClient } from '../aws/acm';
-import type { DnsProvider, DnsProviderConfig } from './types';
-/**
- * Helper function to create a validator with Porkbun
- */
-export declare function createPorkbunValidator(apiKey: string, secretKey: string, acmRegion?: string): UnifiedDnsValidator;
-/**
- * Helper function to create a validator with GoDaddy
- */
-export declare function createGoDaddyValidator(apiKey: string, apiSecret: string, acmRegion?: string, environment?: 'production' | 'ote'): UnifiedDnsValidator;
-/**
- * Helper function to create a validator with Route53
- */
-export declare function createRoute53Validator(region?: string, hostedZoneId?: string, acmRegion?: string): UnifiedDnsValidator;
-export declare interface ValidationRecord {
-  domainName: string
-  recordName: string
-  recordType: string
-  recordValue: string
-}
-export declare interface CertificateValidationResult {
-  certificateArn: string
-  validationRecords: ValidationRecord[]
-  isNew: boolean
-  status: 'pending' | 'issued' | 'failed'
-}
-/**
- * Unified DNS Validator
- * Handles ACM certificate validation with any DNS provider
- */
-export declare class UnifiedDnsValidator {
-  private acm: ACMClient;
-  private dnsProvider: DnsProvider;
-  constructor(dnsProvider: DnsProvider | DnsProviderConfig, acmRegion?: string);
-  getProvider(): DnsProvider;
-  requestAndValidate(params: {
-    domainName: string
-    subjectAlternativeNames?: string[]
-    waitForValidation?: boolean
-    maxWaitMinutes?: number
-  }): Promise<CertificateValidationResult>;
-  createValidationRecords(params: {
-    certificateArn: string
-    domain: string
-  }): Promise<{
-    success: boolean
-    records: ValidationRecord[]
-    errors: string[]
-  }>;
-  deleteValidationRecords(params: {
-    certificateArn: string
-    domain: string
-  }): Promise<{
-    success: boolean
-    errors: string[]
-  }>;
-  findOrCreateCertificate(params: {
-    domainName: string
-    subjectAlternativeNames?: string[]
-    waitForValidation?: boolean
-    maxWaitMinutes?: number
-  }): Promise<CertificateValidationResult>;
-  requestCertificateWithCommonSans(params: {
-    domainName: string
-    includeWww?: boolean
-    includeWildcard?: boolean
-    additionalSans?: string[]
-    waitForValidation?: boolean
-  }): Promise<CertificateValidationResult>;
-  private waitForValidationOptions(certificateArn: string, maxAttempts?: any): Promise<void>;
-  getCertificateStatus(certificateArn: string): Promise<{
-    status: string
-    domainValidations: Array<{
-      domain: string
-      status: string
-    }>
-  }>;
-}

package/dist/generators/index.d.ts

@@ -1 +0,0 @@
-export * from './infrastructure';

package/dist/generators/infrastructure.d.ts

@@ -1,30 +0,0 @@
-import { TemplateBuilder,  } from 'ts-cloud-core';
-import type { CloudConfig } from 'ts-cloud-types';
-export declare interface GenerationOptions {
-  config: CloudConfig
-  environment: 'production' | 'staging' | 'development'
-  modules?: string[]
-}
-export declare class InfrastructureGenerator {
-  private builder: TemplateBuilder;
-  private config: CloudConfig;
-  private environment: 'production' | 'staging' | 'development';
-  private mergedConfig: CloudConfig;
-  constructor(options: GenerationOptions);
-  private mergeEnvironmentConfig(): CloudConfig;
-  private shouldDeploy(resource: any): boolean;
-  generate(): this;
-  private applyGlobalTags(tags: Record<string, string>): void;
-  private generateServerless(slug: string, env: typeof this.environment): void;
-  private generateServer(slug: string, env: typeof this.environment): void;
-  private generateSharedInfrastructure(slug: string, env: typeof this.environment): void;
-  private generateRealtimeResources(slug: string, env: typeof this.environment): void;
-  private generateConnectHandlerCode(): string;
-  private generateDisconnectHandlerCode(): string;
-  private generateMessageHandlerCode(): string;
-  private generateRealtimeServerResources(slug: string, env: typeof this.environment): void;
-  generateBroadcastConfig(): string;
-  toYAML(): string;
-  toJSON(): string;
-  getBuilder(): TemplateBuilder;
-}

package/dist/push/apns.d.ts

@@ -1,60 +0,0 @@
-export declare interface APNsConfig {
-  keyId: string
-  teamId: string
-  privateKey: string
-  bundleId: string
-  production?: boolean
-}
-export declare interface APNsNotification {
-  deviceToken: string
-  title?: string
-  subtitle?: string
-  body?: string
-  badge?: number
-  sound?: string | { name: string; critical?: number; volume?: number }
-  category?: string
-  threadId?: string
-  data?: Record<string, any>
-  contentAvailable?: boolean
-  mutableContent?: boolean
-  pushType?: 'alert' | 'background' | 'voip' | 'complication' | 'fileprovider' | 'mdm' | 'liveactivity'
-  priority?: 5 | 10
-  expiration?: number
-  collapseId?: string
-  targetContentId?: string
-}
-export declare interface APNsSendResult {
-  success: boolean
-  deviceToken: string
-  apnsId?: string
-  statusCode?: number
-  error?: string
-  reason?: string
-  timestamp?: number
-}
-export declare interface APNsBatchResult {
-  sent: number
-  failed: number
-  results: APNsSendResult[]
-}
-/**
- * Apple Push Notification Service client
- */
-export declare class APNsClient {
-  private config: APNsConfig;
-  private token: string | null;
-  private tokenGeneratedAt: number;
-  private client: http2.ClientHttp2Session | null;
-  private host: string;
-  constructor(config: APNsConfig);
-  private generateToken(): string;
-  private derToRaw(derSignature: Buffer): Buffer;
-  private getClient(): Promise<http2.ClientHttp2Session>;
-  private buildPayload(notification: APNsNotification): object;
-  send(notification: APNsNotification): Promise<APNsSendResult>;
-  sendBatch(notifications: APNsNotification[], options?: { concurrency?: number }): Promise<APNsBatchResult>;
-  sendSimple(deviceToken: string, title: string, body: string, data?: Record<string, any>): Promise<APNsSendResult>;
-  sendSilent(deviceToken: string, data?: Record<string, any>): Promise<APNsSendResult>;
-  close(): void;
-}
-export default APNsClient;

package/dist/push/fcm.d.ts

@@ -1,117 +0,0 @@
-export declare interface FCMConfig {
-  projectId: string
-  clientEmail: string
-  privateKey: string
-}
-export declare interface FCMNotification {
-  token?: string
-  topic?: string
-  condition?: string
-  title?: string
-  body?: string
-  imageUrl?: string
-  data?: Record<string, string>
-  android?: {
-    /** Channel ID for Android O+ */
-    channelId?: string
-    /** Notification priority */
-    priority?: 'normal' | 'high'
-    /** Time to live in seconds */
-    ttl?: number
-    /** Collapse key for message deduplication */
-    collapseKey?: string
-    /** Notification icon */
-    icon?: string
-    /** Notification icon color (hex) */
-    color?: string
-    /** Sound to play */
-    sound?: string
-    /** Click action */
-    clickAction?: string
-    /** Tag for notification replacement */
-    tag?: string
-    /** Direct boot aware */
-    directBootOk?: boolean
-    /** Visibility: private, public, secret */
-    visibility?: 'private' | 'public' | 'secret'
-    /** Notification count */
-    notificationCount?: number
-  }
-  webpush?: {
-    /** Web notification options */
-    notification?: {
-      title?: string
-      body?: string
-      icon?: string
-      badge?: string
-      image?: string
-      requireInteraction?: boolean
-      silent?: boolean
-      tag?: string
-      actions?: Array<{ action: string; title: string; icon?: string }>
-    }
-    /** FCM options for web */
-    fcmOptions?: {
-      link?: string
-      analyticsLabel?: string
-    }
-    /** Custom headers */
-    headers?: Record<string, string>
-    /** Custom data */
-    data?: Record<string, string>
-  }
-  apns?: {
-    /** APNs headers */
-    headers?: Record<string, string>
-    /** APNs payload */
-    payload?: {
-      aps?: Record<string, any>
-      [key: string]: any
-    }
-    /** FCM options */
-    fcmOptions?: {
-      analyticsLabel?: string
-      image?: string
-    }
-  }
-  fcmOptions?: {
-    analyticsLabel?: string
-  }
-}
-export declare interface FCMSendResult {
-  success: boolean
-  messageId?: string
-  error?: string
-  errorCode?: string
-}
-export declare interface FCMBatchResult {
-  sent: number
-  failed: number
-  results: Array<FCMSendResult & { token?: string }>
-}
-/**
- * Firebase Cloud Messaging client
- */
-export declare class FCMClient {
-  private config: FCMConfig;
-  private accessToken: string | null;
-  private tokenExpiresAt: number;
-  constructor(config: FCMConfig);
-  static fromServiceAccount(serviceAccount: {
-    project_id: string
-    client_email: string
-    private_key: string
-  }): FCMClient;
-  private generateJWT(): string;
-  private getAccessToken(): Promise<string>;
-  private buildMessage(notification: FCMNotification): object;
-  send(notification: FCMNotification): Promise<FCMSendResult>;
-  sendBatch(tokens: string[], notification: Omit<FCMNotification, 'token' | 'topic' | 'condition'>, options?: { concurrency?: number }): Promise<FCMBatchResult>;
-  sendToTopic(topic: string, notification: Omit<FCMNotification, 'token' | 'topic' | 'condition'>): Promise<FCMSendResult>;
-  sendToCondition(condition: string, notification: Omit<FCMNotification, 'token' | 'topic' | 'condition'>): Promise<FCMSendResult>;
-  sendSimple(token: string, title: string, body: string, data?: Record<string, string>): Promise<FCMSendResult>;
-  sendSilent(token: string, data: Record<string, string>): Promise<FCMSendResult>;
-  subscribeToTopic(tokens: string[], topic: string): Promise<{ success: boolean; error?: string }>;
-  unsubscribeFromTopic(tokens: string[], topic: string): Promise<{ success: boolean; error?: string }>;
-}
-export default FCMClient;

package/dist/push/index.d.ts

@@ -1,14 +0,0 @@
-export type {
-  APNsConfig,
-  APNsNotification,
-  APNsSendResult,
-  APNsBatchResult,
-} from './apns';
-export type {
-  FCMConfig,
-  FCMNotification,
-  FCMSendResult,
-  FCMBatchResult,
-} from './fcm';
-export * from './apns';
-export * from './fcm';