@stacksjs/ts-cloud 0.2.3 → 0.2.6

package/dist/aws/polly.d.ts

@@ -0,0 +1,243 @@
+/**
+ * AWS Polly Client
+ * Text-to-Speech service
+ * No external SDK dependencies - implements AWS Signature V4 directly
+ */
+export type VoiceId = 'Aditi' | 'Amy' | 'Aria' | 'Arlet' | 'Arthur' | 'Astrid' | 'Ayanda' | 'Bianca' | 'Brian' | 'Camila' | 'Carla' | 'Carmen' | 'Celine' | 'Chantal' | 'Conchita' | 'Cristiano' | 'Daniel' | 'Dora' | 'Elin' | 'Emma' | 'Enrique' | 'Ewa' | 'Filiz' | 'Gabrielle' | 'Geraint' | 'Giorgio' | 'Gwyneth' | 'Hala' | 'Hannah' | 'Hans' | 'Hiujin' | 'Ida' | 'Ines' | 'Ivy' | 'Jacek' | 'Jan' | 'Joanna' | 'Joey' | 'Justin' | 'Kajal' | 'Karl' | 'Kazuha' | 'Kendra' | 'Kevin' | 'Kimberly' | 'Laura' | 'Lea' | 'Liam' | 'Lisa' | 'Liv' | 'Lotte' | 'Lucia' | 'Lupe' | 'Mads' | 'Maja' | 'Marlene' | 'Mathieu' | 'Matthew' | 'Maxim' | 'Mia' | 'Miguel' | 'Mizuki' | 'Naja' | 'Niamh' | 'Nicole' | 'Ola' | 'Olivia' | 'Pedro' | 'Penelope' | 'Raveena' | 'Remi' | 'Ricardo' | 'Ruben' | 'Russell' | 'Ruth' | 'Salli' | 'Seoyeon' | 'Sergio' | 'Sofie' | 'Stephen' | 'Suvi' | 'Takumi' | 'Tatyana' | 'Thiago' | 'Tomoko' | 'Vicki' | 'Vitoria' | 'Zayd' | 'Zeina' | 'Zhiyu';
+export type LanguageCode = 'arb' | 'ca-ES' | 'cmn-CN' | 'cy-GB' | 'da-DK' | 'de-AT' | 'de-DE' | 'en-AU' | 'en-GB' | 'en-GB-WLS' | 'en-IE' | 'en-IN' | 'en-NZ' | 'en-US' | 'en-ZA' | 'es-ES' | 'es-MX' | 'es-US' | 'fi-FI' | 'fr-BE' | 'fr-CA' | 'fr-FR' | 'hi-IN' | 'is-IS' | 'it-IT' | 'ja-JP' | 'ko-KR' | 'nb-NO' | 'nl-BE' | 'nl-NL' | 'pl-PL' | 'pt-BR' | 'pt-PT' | 'ro-RO' | 'ru-RU' | 'sv-SE' | 'tr-TR' | 'yue-CN';
+export type Engine = 'standard' | 'neural' | 'long-form' | 'generative';
+export type OutputFormat = 'json' | 'mp3' | 'ogg_vorbis' | 'pcm';
+export type TextType = 'ssml' | 'text';
+export type SpeechMarkType = 'sentence' | 'ssml' | 'viseme' | 'word';
+export interface Voice {
+    Gender?: 'Female' | 'Male';
+    Id?: VoiceId;
+    LanguageCode?: LanguageCode;
+    LanguageName?: string;
+    Name?: string;
+    AdditionalLanguageCodes?: LanguageCode[];
+    SupportedEngines?: Engine[];
+}
+export interface SynthesizeSpeechCommandInput {
+    Engine?: Engine;
+    LanguageCode?: LanguageCode;
+    LexiconNames?: string[];
+    OutputFormat: OutputFormat;
+    SampleRate?: string;
+    SpeechMarkTypes?: SpeechMarkType[];
+    Text: string;
+    TextType?: TextType;
+    VoiceId: VoiceId;
+}
+export interface SynthesizeSpeechCommandOutput {
+    AudioStream?: Uint8Array;
+    ContentType?: string;
+    RequestCharacters?: number;
+}
+export interface DescribeVoicesCommandInput {
+    Engine?: Engine;
+    LanguageCode?: LanguageCode;
+    IncludeAdditionalLanguageCodes?: boolean;
+    NextToken?: string;
+}
+export interface DescribeVoicesCommandOutput {
+    Voices?: Voice[];
+    NextToken?: string;
+}
+export interface StartSpeechSynthesisTaskCommandInput {
+    Engine?: Engine;
+    LanguageCode?: LanguageCode;
+    LexiconNames?: string[];
+    OutputFormat: OutputFormat;
+    OutputS3BucketName: string;
+    OutputS3KeyPrefix?: string;
+    SampleRate?: string;
+    SnsTopicArn?: string;
+    SpeechMarkTypes?: SpeechMarkType[];
+    Text: string;
+    TextType?: TextType;
+    VoiceId: VoiceId;
+}
+export interface SynthesisTask {
+    Engine?: Engine;
+    TaskId?: string;
+    TaskStatus?: 'scheduled' | 'inProgress' | 'completed' | 'failed';
+    TaskStatusReason?: string;
+    OutputUri?: string;
+    CreationTime?: string;
+    RequestCharacters?: number;
+    SnsTopicArn?: string;
+    LexiconNames?: string[];
+    OutputFormat?: OutputFormat;
+    SampleRate?: string;
+    SpeechMarkTypes?: SpeechMarkType[];
+    TextType?: TextType;
+    VoiceId?: VoiceId;
+    LanguageCode?: LanguageCode;
+}
+export interface StartSpeechSynthesisTaskCommandOutput {
+    SynthesisTask?: SynthesisTask;
+}
+export interface GetSpeechSynthesisTaskCommandInput {
+    TaskId: string;
+}
+export interface GetSpeechSynthesisTaskCommandOutput {
+    SynthesisTask?: SynthesisTask;
+}
+export interface ListSpeechSynthesisTasksCommandInput {
+    MaxResults?: number;
+    NextToken?: string;
+    Status?: 'scheduled' | 'inProgress' | 'completed' | 'failed';
+}
+export interface ListSpeechSynthesisTasksCommandOutput {
+    NextToken?: string;
+    SynthesisTasks?: SynthesisTask[];
+}
+export interface PutLexiconCommandInput {
+    Name: string;
+    Content: string;
+}
+export interface PutLexiconCommandOutput {
+}
+export interface GetLexiconCommandInput {
+    Name: string;
+}
+export interface Lexicon {
+    Content?: string;
+    Name?: string;
+}
+export interface LexiconAttributes {
+    Alphabet?: string;
+    LanguageCode?: LanguageCode;
+    LastModified?: string;
+    LexemesCount?: number;
+    LexiconArn?: string;
+    Size?: number;
+}
+export interface GetLexiconCommandOutput {
+    Lexicon?: Lexicon;
+    LexiconAttributes?: LexiconAttributes;
+}
+export interface DeleteLexiconCommandInput {
+    Name: string;
+}
+export interface DeleteLexiconCommandOutput {
+}
+export interface ListLexiconsCommandInput {
+    NextToken?: string;
+}
+export interface ListLexiconsCommandOutput {
+    Lexicons?: Array<{
+        Name?: string;
+        Attributes?: LexiconAttributes;
+    }>;
+    NextToken?: string;
+}
+export declare class PollyClient {
+    private client;
+    private region;
+    constructor(region?: string);
+    /**
+     * Synthesize speech from text (synchronous)
+     */
+    synthesizeSpeech(params: SynthesizeSpeechCommandInput): Promise<SynthesizeSpeechCommandOutput>;
+    /**
+     * Start async speech synthesis task
+     */
+    startSpeechSynthesisTask(params: StartSpeechSynthesisTaskCommandInput): Promise<StartSpeechSynthesisTaskCommandOutput>;
+    /**
+     * Get speech synthesis task status
+     */
+    getSpeechSynthesisTask(params: GetSpeechSynthesisTaskCommandInput): Promise<GetSpeechSynthesisTaskCommandOutput>;
+    /**
+     * List speech synthesis tasks
+     */
+    listSpeechSynthesisTasks(params?: ListSpeechSynthesisTasksCommandInput): Promise<ListSpeechSynthesisTasksCommandOutput>;
+    /**
+     * List available voices
+     */
+    describeVoices(params?: DescribeVoicesCommandInput): Promise<DescribeVoicesCommandOutput>;
+    /**
+     * Store a pronunciation lexicon
+     */
+    putLexicon(params: PutLexiconCommandInput): Promise<PutLexiconCommandOutput>;
+    /**
+     * Get a lexicon
+     */
+    getLexicon(params: GetLexiconCommandInput): Promise<GetLexiconCommandOutput>;
+    /**
+     * Delete a lexicon
+     */
+    deleteLexicon(params: DeleteLexiconCommandInput): Promise<DeleteLexiconCommandOutput>;
+    /**
+     * List lexicons
+     */
+    listLexicons(params?: ListLexiconsCommandInput): Promise<ListLexiconsCommandOutput>;
+    /**
+     * Simple text to speech - returns MP3 audio bytes
+     */
+    textToSpeech(text: string, options?: {
+        voiceId?: VoiceId;
+        engine?: Engine;
+        languageCode?: LanguageCode;
+    }): Promise<Uint8Array>;
+    /**
+     * Text to speech with SSML support
+     */
+    ssmlToSpeech(ssml: string, options?: {
+        voiceId?: VoiceId;
+        engine?: Engine;
+        languageCode?: LanguageCode;
+    }): Promise<Uint8Array>;
+    /**
+     * Save speech to S3 (for longer texts)
+     */
+    saveToS3(text: string, bucket: string, keyPrefix: string, options?: {
+        voiceId?: VoiceId;
+        engine?: Engine;
+        languageCode?: LanguageCode;
+        textType?: TextType;
+    }): Promise<{
+        taskId: string;
+        outputUri: string;
+    }>;
+    /**
+     * List voices for a specific language
+     */
+    listVoicesForLanguage(languageCode: LanguageCode): Promise<Voice[]>;
+    /**
+     * List neural voices
+     */
+    listNeuralVoices(): Promise<Voice[]>;
+    /**
+     * Wait for synthesis task to complete
+     */
+    waitForTask(taskId: string, options?: {
+        maxWaitMs?: number;
+        pollIntervalMs?: number;
+    }): Promise<SynthesisTask>;
+}
+/**
+ * Quick text to speech
+ */
+export declare function textToSpeech(text: string, options?: {
+    voiceId?: VoiceId;
+    engine?: Engine;
+    region?: string;
+}): Promise<Uint8Array>;
+/**
+ * List available voices
+ */
+export declare function listVoices(options?: {
+    languageCode?: LanguageCode;
+    engine?: Engine;
+    region?: string;
+}): Promise<Voice[]>;
+/**
+ * Create SSML with speech marks (pauses, emphasis, etc.)
+ */
+export declare function createSSML(text: string, options?: {
+    rate?: 'x-slow' | 'slow' | 'medium' | 'fast' | 'x-fast';
+    pitch?: 'x-low' | 'low' | 'medium' | 'high' | 'x-high';
+    volume?: 'silent' | 'x-soft' | 'soft' | 'medium' | 'loud' | 'x-loud';
+}): string;

package/dist/aws/rds.d.ts

@@ -0,0 +1,346 @@
+/**
+ * AWS RDS Operations
+ * Direct API calls without AWS CLI dependency
+ */
+export interface DBInstance {
+    DBInstanceIdentifier?: string;
+    DBInstanceClass?: string;
+    Engine?: string;
+    EngineVersion?: string;
+    DBInstanceStatus?: string;
+    MasterUsername?: string;
+    DBName?: string;
+    Endpoint?: {
+        Address?: string;
+        Port?: number;
+        HostedZoneId?: string;
+    };
+    AllocatedStorage?: number;
+    InstanceCreateTime?: string;
+    PreferredBackupWindow?: string;
+    BackupRetentionPeriod?: number;
+    DBSecurityGroups?: Array<{
+        DBSecurityGroupName?: string;
+        Status?: string;
+    }>;
+    VpcSecurityGroups?: Array<{
+        VpcSecurityGroupId?: string;
+        Status?: string;
+    }>;
+    DBParameterGroups?: Array<{
+        DBParameterGroupName?: string;
+        ParameterApplyStatus?: string;
+    }>;
+    AvailabilityZone?: string;
+    DBSubnetGroup?: {
+        DBSubnetGroupName?: string;
+        DBSubnetGroupDescription?: string;
+        VpcId?: string;
+        SubnetGroupStatus?: string;
+        Subnets?: Array<{
+            SubnetIdentifier?: string;
+            SubnetAvailabilityZone?: {
+                Name?: string;
+            };
+            SubnetStatus?: string;
+        }>;
+    };
+    PreferredMaintenanceWindow?: string;
+    PendingModifiedValues?: Record<string, any>;
+    MultiAZ?: boolean;
+    AutoMinorVersionUpgrade?: boolean;
+    ReadReplicaSourceDBInstanceIdentifier?: string;
+    ReadReplicaDBInstanceIdentifiers?: string[];
+    LicenseModel?: string;
+    OptionGroupMemberships?: Array<{
+        OptionGroupName?: string;
+        Status?: string;
+    }>;
+    PubliclyAccessible?: boolean;
+    StorageType?: string;
+    StorageEncrypted?: boolean;
+    KmsKeyId?: string;
+    DbiResourceId?: string;
+    CACertificateIdentifier?: string;
+    DeletionProtection?: boolean;
+    TagList?: Array<{
+        Key?: string;
+        Value?: string;
+    }>;
+}
+export interface DBCluster {
+    DBClusterIdentifier?: string;
+    DBClusterArn?: string;
+    Status?: string;
+    Engine?: string;
+    EngineVersion?: string;
+    Endpoint?: string;
+    ReaderEndpoint?: string;
+    Port?: number;
+    MasterUsername?: string;
+    DatabaseName?: string;
+    PreferredBackupWindow?: string;
+    PreferredMaintenanceWindow?: string;
+    MultiAZ?: boolean;
+    EngineMode?: string;
+    DBClusterMembers?: Array<{
+        DBInstanceIdentifier?: string;
+        IsClusterWriter?: boolean;
+        DBClusterParameterGroupStatus?: string;
+    }>;
+    VpcSecurityGroups?: Array<{
+        VpcSecurityGroupId?: string;
+        Status?: string;
+    }>;
+    HostedZoneId?: string;
+    StorageEncrypted?: boolean;
+    KmsKeyId?: string;
+    DeletionProtection?: boolean;
+    TagList?: Array<{
+        Key?: string;
+        Value?: string;
+    }>;
+}
+export interface DBSnapshot {
+    DBSnapshotIdentifier?: string;
+    DBInstanceIdentifier?: string;
+    SnapshotCreateTime?: string;
+    Engine?: string;
+    AllocatedStorage?: number;
+    Status?: string;
+    Port?: number;
+    AvailabilityZone?: string;
+    VpcId?: string;
+    InstanceCreateTime?: string;
+    MasterUsername?: string;
+    EngineVersion?: string;
+    LicenseModel?: string;
+    SnapshotType?: string;
+    OptionGroupName?: string;
+    PercentProgress?: number;
+    SourceRegion?: string;
+    StorageType?: string;
+    Encrypted?: boolean;
+    KmsKeyId?: string;
+    DBSnapshotArn?: string;
+}
+export interface DBSubnetGroup {
+    DBSubnetGroupName?: string;
+    DBSubnetGroupDescription?: string;
+    VpcId?: string;
+    SubnetGroupStatus?: string;
+    Subnets?: Array<{
+        SubnetIdentifier?: string;
+        SubnetAvailabilityZone?: {
+            Name?: string;
+        };
+        SubnetStatus?: string;
+    }>;
+    DBSubnetGroupArn?: string;
+}
+/**
+ * RDS service management using direct API calls
+ */
+export declare class RDSClient {
+    private client;
+    private region;
+    constructor(region?: string);
+    /**
+     * Describe all RDS DB instances
+     */
+    describeDBInstances(options?: {
+        DBInstanceIdentifier?: string;
+        Filters?: Array<{
+            Name: string;
+            Values: string[];
+        }>;
+        MaxRecords?: number;
+        Marker?: string;
+    }): Promise<{
+        DBInstances?: DBInstance[];
+        Marker?: string;
+    }>;
+    /**
+     * Describe a specific DB instance
+     */
+    describeDBInstance(dbInstanceIdentifier: string): Promise<DBInstance | undefined>;
+    /**
+     * Describe all RDS DB clusters (Aurora)
+     */
+    describeDBClusters(options?: {
+        DBClusterIdentifier?: string;
+        Filters?: Array<{
+            Name: string;
+            Values: string[];
+        }>;
+        MaxRecords?: number;
+        Marker?: string;
+    }): Promise<{
+        DBClusters?: DBCluster[];
+        Marker?: string;
+    }>;
+    /**
+     * Describe DB snapshots
+     */
+    describeDBSnapshots(options?: {
+        DBInstanceIdentifier?: string;
+        DBSnapshotIdentifier?: string;
+        SnapshotType?: 'automated' | 'manual' | 'shared' | 'public' | 'awsbackup';
+        MaxRecords?: number;
+        Marker?: string;
+    }): Promise<{
+        DBSnapshots?: DBSnapshot[];
+        Marker?: string;
+    }>;
+    /**
+     * Describe DB subnet groups
+     */
+    describeDBSubnetGroups(options?: {
+        DBSubnetGroupName?: string;
+        MaxRecords?: number;
+        Marker?: string;
+    }): Promise<{
+        DBSubnetGroups?: DBSubnetGroup[];
+        Marker?: string;
+    }>;
+    /**
+     * Create a new DB instance
+     */
+    createDBInstance(options: {
+        DBInstanceIdentifier: string;
+        DBInstanceClass: string;
+        Engine: string;
+        MasterUsername?: string;
+        MasterUserPassword?: string;
+        DBName?: string;
+        AllocatedStorage?: number;
+        VpcSecurityGroupIds?: string[];
+        DBSubnetGroupName?: string;
+        AvailabilityZone?: string;
+        PreferredMaintenanceWindow?: string;
+        PreferredBackupWindow?: string;
+        BackupRetentionPeriod?: number;
+        MultiAZ?: boolean;
+        EngineVersion?: string;
+        AutoMinorVersionUpgrade?: boolean;
+        LicenseModel?: string;
+        PubliclyAccessible?: boolean;
+        StorageType?: 'gp2' | 'gp3' | 'io1' | 'standard';
+        StorageEncrypted?: boolean;
+        KmsKeyId?: string;
+        DeletionProtection?: boolean;
+        Tags?: Array<{
+            Key: string;
+            Value: string;
+        }>;
+    }): Promise<{
+        DBInstance?: DBInstance;
+    }>;
+    /**
+     * Delete a DB instance
+     */
+    deleteDBInstance(options: {
+        DBInstanceIdentifier: string;
+        SkipFinalSnapshot?: boolean;
+        FinalDBSnapshotIdentifier?: string;
+        DeleteAutomatedBackups?: boolean;
+    }): Promise<{
+        DBInstance?: DBInstance;
+    }>;
+    /**
+     * Modify a DB instance
+     */
+    modifyDBInstance(options: {
+        DBInstanceIdentifier: string;
+        DBInstanceClass?: string;
+        AllocatedStorage?: number;
+        MasterUserPassword?: string;
+        BackupRetentionPeriod?: number;
+        PreferredBackupWindow?: string;
+        PreferredMaintenanceWindow?: string;
+        MultiAZ?: boolean;
+        EngineVersion?: string;
+        AutoMinorVersionUpgrade?: boolean;
+        PubliclyAccessible?: boolean;
+        VpcSecurityGroupIds?: string[];
+        ApplyImmediately?: boolean;
+        StorageType?: 'gp2' | 'gp3' | 'io1' | 'standard';
+        DeletionProtection?: boolean;
+    }): Promise<{
+        DBInstance?: DBInstance;
+    }>;
+    /**
+     * Start a DB instance
+     */
+    startDBInstance(dbInstanceIdentifier: string): Promise<{
+        DBInstance?: DBInstance;
+    }>;
+    /**
+     * Stop a DB instance
+     */
+    stopDBInstance(options: {
+        DBInstanceIdentifier: string;
+        DBSnapshotIdentifier?: string;
+    }): Promise<{
+        DBInstance?: DBInstance;
+    }>;
+    /**
+     * Reboot a DB instance
+     */
+    rebootDBInstance(options: {
+        DBInstanceIdentifier: string;
+        ForceFailover?: boolean;
+    }): Promise<{
+        DBInstance?: DBInstance;
+    }>;
+    /**
+     * Create a DB snapshot
+     */
+    createDBSnapshot(options: {
+        DBInstanceIdentifier: string;
+        DBSnapshotIdentifier: string;
+        Tags?: Array<{
+            Key: string;
+            Value: string;
+        }>;
+    }): Promise<{
+        DBSnapshot?: DBSnapshot;
+    }>;
+    /**
+     * Delete a DB snapshot
+     */
+    deleteDBSnapshot(dbSnapshotIdentifier: string): Promise<{
+        DBSnapshot?: DBSnapshot;
+    }>;
+    /**
+     * Restore DB instance from snapshot
+     */
+    restoreDBInstanceFromDBSnapshot(options: {
+        DBInstanceIdentifier: string;
+        DBSnapshotIdentifier: string;
+        DBInstanceClass?: string;
+        Port?: number;
+        AvailabilityZone?: string;
+        DBSubnetGroupName?: string;
+        MultiAZ?: boolean;
+        PubliclyAccessible?: boolean;
+        AutoMinorVersionUpgrade?: boolean;
+        StorageType?: 'gp2' | 'gp3' | 'io1' | 'standard';
+        VpcSecurityGroupIds?: string[];
+        DeletionProtection?: boolean;
+        Tags?: Array<{
+            Key: string;
+            Value: string;
+        }>;
+    }): Promise<{
+        DBInstance?: DBInstance;
+    }>;
+    /**
+     * Wait for DB instance to become available
+     */
+    waitForDBInstanceAvailable(dbInstanceIdentifier: string, maxAttempts?: number, delayMs?: number): Promise<DBInstance | undefined>;
+    /**
+     * Wait for DB instance to be deleted
+     */
+    waitForDBInstanceDeleted(dbInstanceIdentifier: string, maxAttempts?: number, delayMs?: number): Promise<void>;
+}