@stacksjs/ts-cloud 0.2.2 → 0.2.5

package/dist/aws/sns.d.ts

@@ -0,0 +1,224 @@
+/**
+ * AWS SNS (Simple Notification Service) Operations
+ * Direct API calls without AWS SDK dependency
+ */
+export interface SNSTopicAttributes {
+    TopicArn?: string;
+    DisplayName?: string;
+    Policy?: string;
+    Owner?: string;
+    SubscriptionsPending?: string;
+    SubscriptionsConfirmed?: string;
+    SubscriptionsDeleted?: string;
+    DeliveryPolicy?: string;
+    EffectiveDeliveryPolicy?: string;
+    KmsMasterKeyId?: string;
+}
+export interface SNSSubscriptionAttributes {
+    SubscriptionArn?: string;
+    TopicArn?: string;
+    Protocol?: string;
+    Endpoint?: string;
+    Owner?: string;
+    ConfirmationWasAuthenticated?: string;
+    RawMessageDelivery?: string;
+    FilterPolicy?: string;
+}
+export type SNSProtocol = 'http' | 'https' | 'email' | 'email-json' | 'sms' | 'sqs' | 'application' | 'lambda';
+/**
+ * SNS service management using direct API calls
+ */
+export declare class SNSClient {
+    private client;
+    private region;
+    constructor(region?: string);
+    /**
+     * Build form-encoded body for SNS API
+     */
+    private buildFormBody;
+    /**
+     * Create a new SNS topic
+     */
+    createTopic(params: {
+        Name: string;
+        DisplayName?: string;
+        Tags?: Array<{
+            Key: string;
+            Value: string;
+        }>;
+        Attributes?: Record<string, string>;
+    }): Promise<{
+        TopicArn?: string;
+    }>;
+    /**
+     * Delete an SNS topic
+     */
+    deleteTopic(topicArn: string): Promise<void>;
+    /**
+     * List all SNS topics
+     */
+    listTopics(nextToken?: string): Promise<{
+        Topics?: Array<{
+            TopicArn?: string;
+        }>;
+        NextToken?: string;
+    }>;
+    /**
+     * Get topic attributes
+     */
+    getTopicAttributes(topicArn: string): Promise<SNSTopicAttributes>;
+    /**
+     * Set topic attributes
+     */
+    setTopicAttributes(params: {
+        TopicArn: string;
+        AttributeName: string;
+        AttributeValue: string;
+    }): Promise<void>;
+    /**
+     * Subscribe to a topic
+     */
+    subscribe(params: {
+        TopicArn: string;
+        Protocol: SNSProtocol;
+        Endpoint: string;
+        Attributes?: Record<string, string>;
+        ReturnSubscriptionArn?: boolean;
+    }): Promise<{
+        SubscriptionArn?: string;
+    }>;
+    /**
+     * Unsubscribe from a topic
+     */
+    unsubscribe(subscriptionArn: string): Promise<void>;
+    /**
+     * List subscriptions for a topic
+     */
+    listSubscriptionsByTopic(topicArn: string, nextToken?: string): Promise<{
+        Subscriptions?: SNSSubscriptionAttributes[];
+        NextToken?: string;
+    }>;
+    /**
+     * Publish a message to a topic
+     */
+    publish(params: {
+        TopicArn?: string;
+        TargetArn?: string;
+        PhoneNumber?: string;
+        Message: string;
+        Subject?: string;
+        MessageStructure?: 'json';
+        MessageAttributes?: Record<string, {
+            DataType: 'String' | 'Number' | 'Binary';
+            StringValue?: string;
+            BinaryValue?: string;
+        }>;
+    }): Promise<{
+        MessageId?: string;
+    }>;
+    /**
+     * Publish SMS message directly (without topic)
+     */
+    publishSMS(phoneNumber: string, message: string, senderId?: string): Promise<{
+        MessageId?: string;
+    }>;
+    /**
+     * Subscribe an email address to a topic
+     */
+    subscribeEmail(topicArn: string, email: string): Promise<{
+        SubscriptionArn?: string;
+    }>;
+    /**
+     * Subscribe a Lambda function to a topic
+     */
+    subscribeLambda(topicArn: string, lambdaArn: string): Promise<{
+        SubscriptionArn?: string;
+    }>;
+    /**
+     * Subscribe an SQS queue to a topic
+     */
+    subscribeSqs(topicArn: string, queueArn: string, rawMessageDelivery?: boolean): Promise<{
+        SubscriptionArn?: string;
+    }>;
+    /**
+     * Subscribe an HTTP/HTTPS endpoint to a topic
+     */
+    subscribeHttp(topicArn: string, url: string, rawMessageDelivery?: boolean): Promise<{
+        SubscriptionArn?: string;
+    }>;
+    /**
+     * Subscribe an SMS number to a topic
+     */
+    subscribeSms(topicArn: string, phoneNumber: string): Promise<{
+        SubscriptionArn?: string;
+    }>;
+    /**
+     * Check if topic exists
+     */
+    topicExists(topicArn: string): Promise<boolean>;
+    /**
+     * Get SMS attributes (sandbox status, spending limits, etc.)
+     */
+    getSMSAttributes(): Promise<{
+        MonthlySpendLimit?: string;
+        DeliveryStatusIAMRole?: string;
+        DeliveryStatusSuccessSamplingRate?: string;
+        DefaultSenderID?: string;
+        DefaultSMSType?: 'Promotional' | 'Transactional';
+        UsageReportS3Bucket?: string;
+    }>;
+    /**
+     * Set SMS attributes (sender ID, message type, etc.)
+     */
+    setSMSAttributes(attributes: {
+        MonthlySpendLimit?: string;
+        DeliveryStatusIAMRole?: string;
+        DeliveryStatusSuccessSamplingRate?: string;
+        DefaultSenderID?: string;
+        DefaultSMSType?: 'Promotional' | 'Transactional';
+        UsageReportS3Bucket?: string;
+    }): Promise<void>;
+    /**
+     * Check if phone number is opted out
+     */
+    checkIfPhoneNumberIsOptedOut(phoneNumber: string): Promise<boolean>;
+    /**
+     * List phone numbers that have opted out of receiving SMS
+     */
+    listPhoneNumbersOptedOut(nextToken?: string): Promise<{
+        phoneNumbers?: string[];
+        nextToken?: string;
+    }>;
+    /**
+     * Opt a phone number back in to receive SMS (requires user consent)
+     */
+    optInPhoneNumber(phoneNumber: string): Promise<void>;
+    /**
+     * List sandbox phone numbers (for SMS sandbox mode)
+     */
+    listSMSSandboxPhoneNumbers(nextToken?: string): Promise<{
+        PhoneNumbers?: Array<{
+            PhoneNumber?: string;
+            Status?: 'Pending' | 'Verified';
+        }>;
+        NextToken?: string;
+    }>;
+    /**
+     * Create a sandbox phone number for testing
+     */
+    createSMSSandboxPhoneNumber(phoneNumber: string, languageCode?: string): Promise<void>;
+    /**
+     * Verify a sandbox phone number with OTP
+     */
+    verifySMSSandboxPhoneNumber(phoneNumber: string, oneTimePassword: string): Promise<void>;
+    /**
+     * Delete a sandbox phone number
+     */
+    deleteSMSSandboxPhoneNumber(phoneNumber: string): Promise<void>;
+    /**
+     * Get SMS sandbox account status
+     */
+    getSMSSandboxAccountStatus(): Promise<{
+        IsInSandbox: boolean;
+    }>;
+}

package/dist/aws/sqs.d.ts

@@ -0,0 +1,107 @@
+/**
+ * AWS SQS Operations
+ * Direct API calls without AWS CLI dependency
+ */
+export interface QueueAttributes {
+    QueueUrl: string;
+    QueueArn?: string;
+    ApproximateNumberOfMessages?: string;
+    ApproximateNumberOfMessagesNotVisible?: string;
+    ApproximateNumberOfMessagesDelayed?: string;
+    CreatedTimestamp?: string;
+    LastModifiedTimestamp?: string;
+    VisibilityTimeout?: string;
+    MaximumMessageSize?: string;
+    MessageRetentionPeriod?: string;
+    DelaySeconds?: string;
+    ReceiveMessageWaitTimeSeconds?: string;
+    FifoQueue?: string;
+    ContentBasedDeduplication?: string;
+}
+export interface CreateQueueOptions {
+    queueName: string;
+    fifo?: boolean;
+    visibilityTimeout?: number;
+    messageRetentionPeriod?: number;
+    delaySeconds?: number;
+    maxMessageSize?: number;
+    receiveMessageWaitTime?: number;
+    deadLetterTargetArn?: string;
+    maxReceiveCount?: number;
+    contentBasedDeduplication?: boolean;
+    tags?: Record<string, string>;
+}
+export interface Message {
+    MessageId: string;
+    ReceiptHandle: string;
+    Body: string;
+    Attributes?: Record<string, string>;
+    MessageAttributes?: Record<string, any>;
+}
+/**
+ * SQS queue management using direct API calls
+ */
+export declare class SQSClient {
+    private client;
+    private region;
+    constructor(region?: string, profile?: string);
+    /**
+     * Create a new SQS queue
+     */
+    createQueue(options: CreateQueueOptions): Promise<{
+        QueueUrl: string;
+    }>;
+    /**
+     * List all queues
+     */
+    listQueues(prefix?: string): Promise<{
+        QueueUrls: string[];
+    }>;
+    /**
+     * Get queue attributes
+     */
+    getQueueAttributes(queueUrl: string): Promise<{
+        Attributes: Record<string, string>;
+    }>;
+    /**
+     * Get queue URL by name
+     */
+    getQueueUrl(queueName: string): Promise<{
+        QueueUrl: string;
+    }>;
+    /**
+     * Delete a queue
+     */
+    deleteQueue(queueUrl: string): Promise<void>;
+    /**
+     * Purge queue (delete all messages)
+     */
+    purgeQueue(queueUrl: string): Promise<void>;
+    /**
+     * Send message to queue
+     */
+    sendMessage(options: {
+        queueUrl: string;
+        messageBody: string;
+        delaySeconds?: number;
+        messageGroupId?: string;
+        messageDeduplicationId?: string;
+    }): Promise<{
+        MessageId: string;
+    }>;
+    /**
+     * Receive messages from queue
+     */
+    receiveMessages(options: {
+        queueUrl: string;
+        maxMessages?: number;
+        visibilityTimeout?: number;
+        waitTimeSeconds?: number;
+    }): Promise<{
+        Messages: Message[];
+    }>;
+    /**
+     * Delete message from queue
+     */
+    deleteMessage(queueUrl: string, receiptHandle: string): Promise<void>;
+}

package/dist/aws/ssm.d.ts

@@ -0,0 +1,311 @@
+/**
+ * AWS SSM (Systems Manager) Parameter Store Client
+ * Manages parameters and secrets using direct API calls
+ */
+export interface Parameter {
+    Name?: string;
+    Type?: 'String' | 'StringList' | 'SecureString';
+    Value?: string;
+    Version?: number;
+    LastModifiedDate?: string;
+    ARN?: string;
+    DataType?: string;
+    Description?: string;
+    AllowedPattern?: string;
+    KeyId?: string;
+    Tier?: 'Standard' | 'Advanced' | 'Intelligent-Tiering';
+}
+export interface ParameterHistory {
+    Name?: string;
+    Type?: 'String' | 'StringList' | 'SecureString';
+    KeyId?: string;
+    LastModifiedDate?: string;
+    LastModifiedUser?: string;
+    Description?: string;
+    Value?: string;
+    Version?: number;
+    Labels?: string[];
+    Tier?: string;
+}
+export interface PutParameterOptions {
+    Name: string;
+    Value: string;
+    Type?: 'String' | 'StringList' | 'SecureString';
+    Description?: string;
+    KeyId?: string;
+    Overwrite?: boolean;
+    AllowedPattern?: string;
+    Tags?: {
+        Key: string;
+        Value: string;
+    }[];
+    Tier?: 'Standard' | 'Advanced' | 'Intelligent-Tiering';
+    DataType?: string;
+}
+export interface GetParameterOptions {
+    Name: string;
+    WithDecryption?: boolean;
+}
+export interface GetParametersOptions {
+    Names: string[];
+    WithDecryption?: boolean;
+}
+export interface GetParametersByPathOptions {
+    Path: string;
+    Recursive?: boolean;
+    WithDecryption?: boolean;
+    MaxResults?: number;
+    NextToken?: string;
+    ParameterFilters?: {
+        Key: string;
+        Option?: string;
+        Values?: string[];
+    }[];
+}
+export interface DeleteParameterOptions {
+    Name: string;
+}
+/**
+ * SSM Parameter Store client using direct API calls
+ */
+export declare class SSMClient {
+    private client;
+    private region;
+    constructor(region?: string, profile?: string);
+    /**
+     * Put a parameter to Parameter Store
+     */
+    putParameter(options: PutParameterOptions): Promise<{
+        Version?: number;
+        Tier?: string;
+    }>;
+    /**
+     * Get a parameter from Parameter Store
+     */
+    getParameter(options: GetParameterOptions): Promise<{
+        Parameter?: Parameter;
+    }>;
+    /**
+     * Get multiple parameters from Parameter Store
+     */
+    getParameters(options: GetParametersOptions): Promise<{
+        Parameters?: Parameter[];
+        InvalidParameters?: string[];
+    }>;
+    /**
+     * Get parameters by path (hierarchical)
+     */
+    getParametersByPath(options: GetParametersByPathOptions): Promise<{
+        Parameters?: Parameter[];
+        NextToken?: string;
+    }>;
+    /**
+     * Delete a parameter from Parameter Store
+     */
+    deleteParameter(options: DeleteParameterOptions): Promise<void>;
+    /**
+     * Delete multiple parameters from Parameter Store
+     */
+    deleteParameters(names: string[]): Promise<{
+        DeletedParameters?: string[];
+        InvalidParameters?: string[];
+    }>;
+    /**
+     * Describe parameters (metadata only, no values)
+     */
+    describeParameters(options?: {
+        Filters?: {
+            Key: string;
+            Values: string[];
+        }[];
+        ParameterFilters?: {
+            Key: string;
+            Option?: string;
+            Values?: string[];
+        }[];
+        MaxResults?: number;
+        NextToken?: string;
+    }): Promise<{
+        Parameters?: Parameter[];
+        NextToken?: string;
+    }>;
+    /**
+     * Get parameter history
+     */
+    getParameterHistory(options: {
+        Name: string;
+        WithDecryption?: boolean;
+        MaxResults?: number;
+        NextToken?: string;
+    }): Promise<{
+        Parameters?: ParameterHistory[];
+        NextToken?: string;
+    }>;
+    /**
+     * Label a parameter version
+     */
+    labelParameterVersion(options: {
+        Name: string;
+        ParameterVersion?: number;
+        Labels: string[];
+    }): Promise<{
+        InvalidLabels?: string[];
+        ParameterVersion?: number;
+    }>;
+    /**
+     * Add tags to a parameter
+     */
+    addTagsToResource(options: {
+        ResourceType: 'Parameter';
+        ResourceId: string;
+        Tags: {
+            Key: string;
+            Value: string;
+        }[];
+    }): Promise<void>;
+    /**
+     * Remove tags from a parameter
+     */
+    removeTagsFromResource(options: {
+        ResourceType: 'Parameter';
+        ResourceId: string;
+        TagKeys: string[];
+    }): Promise<void>;
+    /**
+     * List tags for a parameter
+     */
+    listTagsForResource(options: {
+        ResourceType: 'Parameter';
+        ResourceId: string;
+    }): Promise<{
+        TagList?: {
+            Key: string;
+            Value: string;
+        }[];
+    }>;
+    /**
+     * Helper: Set a string parameter
+     */
+    setString(name: string, value: string, options?: {
+        description?: string;
+        overwrite?: boolean;
+        tags?: {
+            Key: string;
+            Value: string;
+        }[];
+    }): Promise<{
+        Version?: number;
+    }>;
+    /**
+     * Helper: Set a secure string parameter (encrypted)
+     */
+    setSecureString(name: string, value: string, options?: {
+        description?: string;
+        overwrite?: boolean;
+        kmsKeyId?: string;
+        tags?: {
+            Key: string;
+            Value: string;
+        }[];
+    }): Promise<{
+        Version?: number;
+    }>;
+    /**
+     * Helper: Get a parameter value (decrypted)
+     */
+    getValue(name: string): Promise<string | undefined>;
+    /**
+     * Helper: Get all parameters under a path
+     */
+    getAllByPath(path: string, recursive?: boolean): Promise<Parameter[]>;
+    /**
+     * Parse parameter response
+     */
+    private parseParameter;
+    /**
+     * Send a command to EC2 instances via SSM. Accepts either explicit
+     * `InstanceIds` or tag-based `Targets` (one is required).
+     */
+    sendCommand(options: {
+        InstanceIds?: string[];
+        Targets?: Array<{
+            Key: string;
+            Values: string[];
+        }>;
+        DocumentName: string;
+        Parameters?: Record<string, string[]>;
+        TimeoutSeconds?: number;
+        Comment?: string;
+        OutputS3BucketName?: string;
+        OutputS3KeyPrefix?: string;
+    }): Promise<{
+        CommandId?: string;
+        Status?: string;
+        StatusDetails?: string;
+    }>;
+    /**
+     * Get command invocation result
+     */
+    getCommandInvocation(options: {
+        CommandId: string;
+        InstanceId: string;
+    }): Promise<{
+        Status?: string;
+        StatusDetails?: string;
+        StandardOutputContent?: string;
+        StandardErrorContent?: string;
+        ResponseCode?: number;
+    }>;
+    /**
+     * Run a shell command on an EC2 instance and wait for result
+     */
+    runShellCommand(instanceId: string, commands: string[], options?: {
+        timeoutSeconds?: number;
+        waitForCompletion?: boolean;
+        pollIntervalMs?: number;
+        maxWaitMs?: number;
+    }): Promise<{
+        success: boolean;
+        output?: string;
+        error?: string;
+        status?: string;
+    }>;
+    /**
+     * List per-instance invocations for a previously-sent command.
+     * Used by tag-based deploys to discover which instances received the
+     * command and poll each one for completion.
+     */
+    listCommandInvocations(options: {
+        CommandId: string;
+        Details?: boolean;
+    }): Promise<Array<{
+        InstanceId: string;
+        Status?: string;
+        StatusDetails?: string;
+        StandardOutputContent?: string;
+        StandardErrorContent?: string;
+    }>>;
+    /**
+     * Fan out a shell command to every EC2 instance matching the given tags
+     * and wait for all of them to finish. The Forge-style "deploy to my app
+     * servers" primitive — no instance IDs to track, just tag filters.
+     */
+    sendCommandByTags(options: {
+        tags: Record<string, string>;
+        commands: string[];
+        timeoutSeconds?: number;
+        pollIntervalMs?: number;
+        maxWaitMs?: number;
+        comment?: string;
+    }): Promise<{
+        success: boolean;
+        instanceCount: number;
+        perInstance: Array<{
+            instanceId: string;
+            status: string;
+            output?: string;
+            error?: string;
+        }>;
+        error?: string;
+    }>;
+}

package/dist/aws/sts.d.ts

@@ -0,0 +1,21 @@
+/**
+ * AWS STS Operations
+ * Direct API calls without AWS CLI dependency
+ */
+export interface CallerIdentity {
+    UserId?: string;
+    Account?: string;
+    Arn?: string;
+}
+/**
+ * STS (Security Token Service) management using direct API calls
+ */
+export declare class STSClient {
+    private client;
+    private region;
+    constructor(region?: string, profile?: string);
+    /**
+     * Get information about the IAM identity whose credentials are used to call the operation
+     */
+    getCallerIdentity(): Promise<CallerIdentity>;
+}