@stacksjs/ts-cloud 0.2.3 → 0.2.6

package/dist/aws/lambda.d.ts

@@ -0,0 +1,319 @@
+/**
+ * AWS Lambda Operations
+ * Direct API calls without AWS SDK dependency
+ */
+export interface LambdaFunctionConfiguration {
+    FunctionName?: string;
+    FunctionArn?: string;
+    Runtime?: string;
+    Role?: string;
+    Handler?: string;
+    CodeSize?: number;
+    Description?: string;
+    Timeout?: number;
+    MemorySize?: number;
+    LastModified?: string;
+    CodeSha256?: string;
+    Version?: string;
+    State?: 'Pending' | 'Active' | 'Inactive' | 'Failed';
+    StateReason?: string;
+    StateReasonCode?: string;
+    Environment?: {
+        Variables?: Record<string, string>;
+    };
+    Architectures?: ('x86_64' | 'arm64')[];
+}
+export interface InvokeResult {
+    StatusCode?: number;
+    FunctionError?: string;
+    LogResult?: string;
+    Payload?: string;
+    ExecutedVersion?: string;
+}
+export interface CreateFunctionParams {
+    FunctionName: string;
+    Runtime: 'nodejs18.x' | 'nodejs20.x' | 'python3.11' | 'python3.12' | string;
+    Role: string;
+    Handler: string;
+    Code: {
+        ZipFile?: string;
+        S3Bucket?: string;
+        S3Key?: string;
+        S3ObjectVersion?: string;
+    };
+    Description?: string;
+    Timeout?: number;
+    MemorySize?: number;
+    Environment?: {
+        Variables: Record<string, string>;
+    };
+    Tags?: Record<string, string>;
+    Architectures?: ('x86_64' | 'arm64')[];
+    EphemeralStorage?: {
+        Size: number;
+    };
+}
+export interface UpdateFunctionCodeParams {
+    FunctionName: string;
+    ZipFile?: string;
+    S3Bucket?: string;
+    S3Key?: string;
+    S3ObjectVersion?: string;
+    Publish?: boolean;
+    Architectures?: ('x86_64' | 'arm64')[];
+}
+export interface AddPermissionParams {
+    FunctionName: string;
+    StatementId: string;
+    Action: string;
+    Principal: string;
+    SourceArn?: string;
+    SourceAccount?: string;
+}
+/**
+ * Lambda service management using direct API calls
+ */
+export declare class LambdaClient {
+    private client;
+    private region;
+    constructor(region?: string);
+    /**
+     * Create a new Lambda function
+     */
+    createFunction(params: CreateFunctionParams): Promise<LambdaFunctionConfiguration>;
+    /**
+     * Get function configuration
+     */
+    getFunction(functionName: string): Promise<{
+        Configuration?: LambdaFunctionConfiguration;
+        Code?: {
+            RepositoryType?: string;
+            Location?: string;
+        };
+        Tags?: Record<string, string>;
+    }>;
+    /**
+     * Update function code
+     */
+    updateFunctionCode(params: UpdateFunctionCodeParams): Promise<LambdaFunctionConfiguration>;
+    /**
+     * Update function code with inline JavaScript/TypeScript code
+     * Automatically creates a zip file with the code as index.js
+     */
+    updateFunctionCodeInline(functionName: string, code: string, filename?: string): Promise<LambdaFunctionConfiguration>;
+    /**
+     * Update function configuration
+     */
+    updateFunctionConfiguration(params: {
+        FunctionName: string;
+        Runtime?: string;
+        Role?: string;
+        Handler?: string;
+        Description?: string;
+        Timeout?: number;
+        MemorySize?: number;
+        Environment?: {
+            Variables: Record<string, string>;
+        };
+    }): Promise<LambdaFunctionConfiguration>;
+    /**
+     * Delete a Lambda function
+     */
+    deleteFunction(functionName: string): Promise<void>;
+    /**
+     * Invoke a Lambda function
+     */
+    invoke(params: {
+        FunctionName: string;
+        InvocationType?: 'RequestResponse' | 'Event' | 'DryRun';
+        Payload?: string | object;
+        LogType?: 'None' | 'Tail';
+    }): Promise<InvokeResult>;
+    /**
+     * List Lambda functions
+     */
+    listFunctions(params?: {
+        MaxItems?: number;
+        Marker?: string;
+        FunctionVersion?: 'ALL';
+    }): Promise<{
+        Functions?: LambdaFunctionConfiguration[];
+        NextMarker?: string;
+    }>;
+    /**
+     * Add permission to Lambda function (resource-based policy)
+     */
+    addPermission(params: AddPermissionParams): Promise<{
+        Statement?: string;
+    }>;
+    /**
+     * Remove permission from Lambda function
+     */
+    removePermission(functionName: string, statementId: string): Promise<void>;
+    /**
+     * Publish a version of the function
+     */
+    publishVersion(params: {
+        FunctionName: string;
+        Description?: string;
+        CodeSha256?: string;
+    }): Promise<LambdaFunctionConfiguration>;
+    /**
+     * Create an alias for a function version
+     */
+    createAlias(params: {
+        FunctionName: string;
+        Name: string;
+        FunctionVersion: string;
+        Description?: string;
+    }): Promise<{
+        AliasArn?: string;
+        Name?: string;
+        FunctionVersion?: string;
+        Description?: string;
+    }>;
+    /**
+     * Wait for function to become active
+     */
+    waitForFunctionActive(functionName: string, maxWaitSeconds?: number): Promise<LambdaFunctionConfiguration>;
+    /**
+     * Check if function exists
+     */
+    functionExists(functionName: string): Promise<boolean>;
+    /**
+     * Create a function URL for the Lambda function
+     */
+    createFunctionUrl(params: {
+        FunctionName: string;
+        AuthType: 'NONE' | 'AWS_IAM';
+        Cors?: {
+            AllowOrigins?: string[];
+            AllowMethods?: string[];
+            AllowHeaders?: string[];
+            ExposeHeaders?: string[];
+            MaxAge?: number;
+            AllowCredentials?: boolean;
+        };
+        InvokeMode?: 'BUFFERED' | 'RESPONSE_STREAM';
+    }): Promise<{
+        FunctionUrl?: string;
+        FunctionArn?: string;
+        AuthType?: string;
+        CreationTime?: string;
+    }>;
+    /**
+     * Get function URL configuration
+     */
+    getFunctionUrl(functionName: string): Promise<{
+        FunctionUrl?: string;
+        FunctionArn?: string;
+        AuthType?: string;
+        Cors?: {
+            AllowOrigins?: string[];
+            AllowMethods?: string[];
+            AllowHeaders?: string[];
+        };
+        CreationTime?: string;
+    } | null>;
+    /**
+     * Delete function URL configuration
+     */
+    deleteFunctionUrl(functionName: string): Promise<void>;
+    /**
+     * Create function with inline code (convenience method)
+     */
+    createFunctionWithCode(params: {
+        FunctionName: string;
+        Runtime: 'nodejs18.x' | 'nodejs20.x' | 'python3.11' | 'python3.12' | string;
+        Role: string;
+        Handler: string;
+        Code: string;
+        Filename?: string;
+        Description?: string;
+        Timeout?: number;
+        MemorySize?: number;
+        Environment?: {
+            Variables: Record<string, string>;
+        };
+    }): Promise<LambdaFunctionConfiguration>;
+    /**
+     * Add permission for Function URL public access
+     */
+    addFunctionUrlPermission(functionName: string): Promise<{
+        Statement?: string;
+    }>;
+    /**
+     * Publish a new Lambda layer version
+     */
+    publishLayerVersion(params: {
+        LayerName: string;
+        Description?: string;
+        Content: {
+            S3Bucket?: string;
+            S3Key?: string;
+            ZipFile?: string;
+        };
+        CompatibleRuntimes?: string[];
+        CompatibleArchitectures?: ('x86_64' | 'arm64')[];
+        LicenseInfo?: string;
+    }): Promise<{
+        LayerArn?: string;
+        LayerVersionArn?: string;
+        Description?: string;
+        Version?: number;
+        CompatibleRuntimes?: string[];
+        CompatibleArchitectures?: string[];
+    }>;
+    /**
+     * List layer versions
+     */
+    listLayerVersions(layerName: string, params?: {
+        CompatibleRuntime?: string;
+        CompatibleArchitecture?: 'x86_64' | 'arm64';
+        MaxItems?: number;
+        Marker?: string;
+    }): Promise<{
+        LayerVersions?: Array<{
+            LayerVersionArn?: string;
+            Version?: number;
+            Description?: string;
+            CompatibleRuntimes?: string[];
+            CompatibleArchitectures?: string[];
+        }>;
+        NextMarker?: string;
+    }>;
+    /**
+     * Get layer version details
+     */
+    getLayerVersion(layerName: string, versionNumber: number): Promise<{
+        LayerArn?: string;
+        LayerVersionArn?: string;
+        Description?: string;
+        Version?: number;
+        CompatibleRuntimes?: string[];
+        CompatibleArchitectures?: string[];
+        Content?: {
+            Location?: string;
+            CodeSha256?: string;
+            CodeSize?: number;
+        };
+    }>;
+    /**
+     * Add permission to a layer version (e.g., make it public)
+     */
+    addLayerVersionPermission(params: {
+        LayerName: string;
+        VersionNumber: number;
+        StatementId: string;
+        Action: string;
+        Principal: string;
+        OrganizationId?: string;
+    }): Promise<{
+        Statement?: string;
+        RevisionId?: string;
+    }>;
+    /**
+     * Delete a layer version
+     */
+    deleteLayerVersion(layerName: string, versionNumber: number): Promise<void>;
+}

package/dist/aws/opensearch.d.ts

@@ -0,0 +1,121 @@
+/**
+ * AWS OpenSearch Service Client
+ * Direct API calls for OpenSearch operations
+ */
+export interface DomainStatus {
+    DomainId: string;
+    DomainName: string;
+    ARN: string;
+    Created: boolean;
+    Deleted: boolean;
+    Endpoint?: string;
+    Endpoints?: Record<string, string>;
+    Processing: boolean;
+    EngineVersion: string;
+    ClusterConfig: {
+        InstanceType: string;
+        InstanceCount: number;
+        DedicatedMasterEnabled: boolean;
+        ZoneAwarenessEnabled: boolean;
+        DedicatedMasterType?: string;
+        DedicatedMasterCount?: number;
+    };
+    EBSOptions?: {
+        EBSEnabled: boolean;
+        VolumeType?: string;
+        VolumeSize?: number;
+    };
+}
+/**
+ * OpenSearch client for direct API calls
+ */
+export declare class OpenSearchClient {
+    private client;
+    private region;
+    constructor(region?: string);
+    /**
+     * Create an OpenSearch domain
+     */
+    createDomain(params: {
+        DomainName: string;
+        EngineVersion?: string;
+        ClusterConfig?: {
+            InstanceType?: string;
+            InstanceCount?: number;
+            DedicatedMasterEnabled?: boolean;
+            DedicatedMasterType?: string;
+            DedicatedMasterCount?: number;
+            ZoneAwarenessEnabled?: boolean;
+        };
+        EBSOptions?: {
+            EBSEnabled: boolean;
+            VolumeType?: string;
+            VolumeSize?: number;
+        };
+        AccessPolicies?: string;
+        EncryptionAtRestOptions?: {
+            Enabled: boolean;
+            KmsKeyId?: string;
+        };
+        NodeToNodeEncryptionOptions?: {
+            Enabled: boolean;
+        };
+        AdvancedSecurityOptions?: {
+            Enabled: boolean;
+            InternalUserDatabaseEnabled?: boolean;
+            MasterUserOptions?: {
+                MasterUserName?: string;
+                MasterUserPassword?: string;
+            };
+        };
+        DomainEndpointOptions?: {
+            EnforceHTTPS?: boolean;
+            TLSSecurityPolicy?: string;
+        };
+        Tags?: Array<{
+            Key: string;
+            Value: string;
+        }>;
+    }): Promise<{
+        DomainStatus: DomainStatus;
+    }>;
+    /**
+     * Delete an OpenSearch domain
+     */
+    deleteDomain(domainName: string): Promise<{
+        DomainStatus: DomainStatus;
+    }>;
+    /**
+     * Describe an OpenSearch domain
+     */
+    describeDomain(domainName: string): Promise<{
+        DomainStatus: DomainStatus;
+    }>;
+    /**
+     * List all OpenSearch domains
+     */
+    listDomainNames(): Promise<{
+        DomainNames: Array<{
+            DomainName: string;
+            EngineType: string;
+        }>;
+    }>;
+    /**
+     * Update domain config
+     */
+    updateDomainConfig(params: {
+        DomainName: string;
+        ClusterConfig?: {
+            InstanceType?: string;
+            InstanceCount?: number;
+        };
+        EBSOptions?: {
+            EBSEnabled: boolean;
+            VolumeType?: string;
+            VolumeSize?: number;
+        };
+        AccessPolicies?: string;
+    }): Promise<{
+        DomainConfig: any;
+    }>;
+}