@stacksjs/ts-cloud 0.7.4 → 0.7.6

package/dist/chunk-b82pbxyp.js

@@ -0,0 +1,1572 @@
+import {
+  resolveCredentials
+} from "./chunk-vd87cpvn.js";
+import {
+  AWSClient
+} from "./chunk-arsh1g5h.js";
+
+// src/aws/cost-explorer-cache.ts
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var CACHE_SCHEMA_VERSION = 1;
+var HOUR_MS = 60 * 60 * 1000;
+var DAY_MS = 24 * HOUR_MS;
+var OPEN_PERIOD_TTL_MS = HOUR_MS;
+var CLOSED_PERIOD_TTL_MS = 30 * DAY_MS;
+function cacheRoot() {
+  const xdg = process.env.XDG_CACHE_HOME;
+  return join(xdg && xdg.trim() ? xdg : join(homedir(), ".cache"), "ts-cloud", "cost-explorer");
+}
+function profileDir(profile) {
+  return join(cacheRoot(), profile ?? "__default__");
+}
+function hashKey(key) {
+  const canonical = {
+    s: key.start,
+    e: key.end,
+    g: key.granularity,
+    m: [...key.metrics].sort(),
+    gb: [...key.groupBy].map((g) => `${g.Type}:${g.Key}`).sort()
+  };
+  return createHash("sha256").update(JSON.stringify(canonical)).digest("hex").slice(0, 24);
+}
+function isClosedPeriod(start, end) {
+  const endTs = Date.parse(`${end}T00:00:00Z`);
+  if (Number.isNaN(endTs))
+    return false;
+  const now = new Date;
+  const firstOfThisMonth = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1);
+  return endTs <= firstOfThisMonth;
+}
+function ttlForPeriod(key) {
+  return isClosedPeriod(key.start, key.end) ? CLOSED_PERIOD_TTL_MS : OPEN_PERIOD_TTL_MS;
+}
+function loadCache(profile, key) {
+  const file = join(profileDir(profile), `${hashKey(key)}.json`);
+  if (!existsSync(file))
+    return null;
+  let entry;
+  try {
+    entry = JSON.parse(readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+  if (entry.schema !== CACHE_SCHEMA_VERSION)
+    return null;
+  const ageMs = Date.now() - entry.savedAt;
+  if (ageMs < 0 || ageMs > ttlForPeriod(key))
+    return null;
+  return { response: entry.response, ageSeconds: Math.floor(ageMs / 1000) };
+}
+function saveCache(profile, key, response) {
+  const dir = profileDir(profile);
+  mkdirSync(dir, { recursive: true });
+  const entry = {
+    schema: CACHE_SCHEMA_VERSION,
+    savedAt: Date.now(),
+    key,
+    response
+  };
+  writeFileSync(join(dir, `${hashKey(key)}.json`), JSON.stringify(entry));
+}
+
+// src/aws/cost-explorer.ts
+class CostExplorerClient {
+  client;
+  profile;
+  useCache;
+  lastCacheAgeSeconds = null;
+  constructor(profile, options) {
+    this.profile = profile;
+    this.useCache = options?.useCache ?? true;
+    this.client = new AWSClient(resolveCredentials(profile));
+  }
+  async getCostByService(params) {
+    const { start, end, granularity = "MONTHLY" } = params;
+    const metrics = ["UnblendedCost"];
+    const groupBy = [{ Type: "DIMENSION", Key: "SERVICE" }];
+    const cacheKey = { start, end, granularity, metrics, groupBy };
+    if (this.useCache) {
+      const hit = loadCache(this.profile, cacheKey);
+      if (hit) {
+        this.lastCacheAgeSeconds = hit.ageSeconds;
+        return hit.response;
+      }
+    }
+    this.lastCacheAgeSeconds = null;
+    const result = await this.client.request({
+      service: "ce",
+      region: "us-east-1",
+      method: "POST",
+      path: "/",
+      headers: {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "AWSInsightsIndexService.GetCostAndUsage"
+      },
+      body: JSON.stringify({
+        TimePeriod: { Start: start, End: end },
+        Granularity: granularity,
+        Metrics: metrics,
+        GroupBy: groupBy
+      })
+    });
+    const groups = result?.ResultsByTime?.[0]?.Groups ?? [];
+    const services = groups.map((g) => ({
+      service: g.Keys?.[0] ?? "Unknown",
+      amount: Number.parseFloat(g.Metrics?.UnblendedCost?.Amount ?? "0"),
+      unit: g.Metrics?.UnblendedCost?.Unit ?? "USD"
+    })).filter((g) => g.amount > 0).sort((a, b) => b.amount - a.amount);
+    if (this.useCache) {
+      saveCache(this.profile, cacheKey, services);
+    }
+    return services;
+  }
+  async getDailyTotals(params) {
+    const result = await this.client.request({
+      service: "ce",
+      region: "us-east-1",
+      method: "POST",
+      path: "/",
+      headers: {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "AWSInsightsIndexService.GetCostAndUsage"
+      },
+      body: JSON.stringify({
+        TimePeriod: { Start: params.start, End: params.end },
+        Granularity: "DAILY",
+        Metrics: ["UnblendedCost"]
+      })
+    });
+    const byTime = result?.ResultsByTime ?? [];
+    return byTime.map((t) => Number.parseFloat(t.Total?.UnblendedCost?.Amount ?? "0"));
+  }
+}
+
+// src/aws/secrets-manager.ts
+class SecretsManagerClient {
+  client;
+  region;
+  constructor(region = "us-east-1", profile) {
+    this.region = region;
+    this.client = new AWSClient;
+  }
+  async createSecret(options) {
+    const params = {
+      Name: options.Name
+    };
+    if (options.Description) {
+      params.Description = options.Description;
+    }
+    if (options.KmsKeyId) {
+      params.KmsKeyId = options.KmsKeyId;
+    }
+    if (options.SecretBinary) {
+      params.SecretBinary = options.SecretBinary;
+    }
+    if (options.SecretString) {
+      params.SecretString = options.SecretString;
+    }
+    if (options.Tags && options.Tags.length > 0) {
+      params.Tags = options.Tags;
+    }
+    if (options.AddReplicaRegions && options.AddReplicaRegions.length > 0) {
+      params.AddReplicaRegions = options.AddReplicaRegions;
+    }
+    if (options.ForceOverwriteReplicaSecret !== undefined) {
+      params.ForceOverwriteReplicaSecret = options.ForceOverwriteReplicaSecret;
+    }
+    params.ClientRequestToken = options.ClientRequestToken || crypto.randomUUID();
+    const result = await this.client.request({
+      service: "secretsmanager",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "secretsmanager.CreateSecret",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+    return {
+      ARN: result.ARN,
+      Name: result.Name,
+      VersionId: result.VersionId,
+      ReplicationStatus: result.ReplicationStatus
+    };
+  }
+  async updateSecret(options) {
+    const params = {
+      SecretId: options.SecretId
+    };
+    if (options.Description) {
+      params.Description = options.Description;
+    }
+    if (options.KmsKeyId) {
+      params.KmsKeyId = options.KmsKeyId;
+    }
+    if (options.SecretBinary) {
+      params.SecretBinary = options.SecretBinary;
+    }
+    if (options.SecretString) {
+      params.SecretString = options.SecretString;
+    }
+    const result = await this.client.request({
+      service: "secretsmanager",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "secretsmanager.UpdateSecret",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+    return {
+      ARN: result.ARN,
+      Name: result.Name,
+      VersionId: result.VersionId
+    };
+  }
+  async putSecretValue(options) {
+    const params = {
+      SecretId: options.SecretId
+    };
+    if (options.SecretBinary) {
+      params.SecretBinary = options.SecretBinary;
+    }
+    if (options.SecretString) {
+      params.SecretString = options.SecretString;
+    }
+    if (options.VersionStages && options.VersionStages.length > 0) {
+      params.VersionStages = options.VersionStages;
+    }
+    if (options.ClientRequestToken) {
+      params.ClientRequestToken = options.ClientRequestToken;
+    }
+    const result = await this.client.request({
+      service: "secretsmanager",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "secretsmanager.PutSecretValue",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+    return {
+      ARN: result.ARN,
+      Name: result.Name,
+      VersionId: result.VersionId,
+      VersionStages: result.VersionStages
+    };
+  }
+  async getSecretValue(options) {
+    const params = {
+      SecretId: options.SecretId
+    };
+    if (options.VersionId) {
+      params.VersionId = options.VersionId;
+    }
+    if (options.VersionStage) {
+      params.VersionStage = options.VersionStage;
+    }
+    const result = await this.client.request({
+      service: "secretsmanager",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "secretsmanager.GetSecretValue",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+    return {
+      ARN: result.ARN,
+      Name: result.Name,
+      VersionId: result.VersionId,
+      SecretBinary: result.SecretBinary,
+      SecretString: result.SecretString,
+      VersionStages: result.VersionStages,
+      CreatedDate: result.CreatedDate
+    };
+  }
+  async describeSecret(secretId) {
+    const params = {
+      SecretId: secretId
+    };
+    const result = await this.client.request({
+      service: "secretsmanager",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "secretsmanager.DescribeSecret",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+    return this.parseSecret(result);
+  }
+  async listSecrets(options) {
+    const params = {};
+    if (options?.MaxResults) {
+      params.MaxResults = options.MaxResults;
+    }
+    if (options?.NextToken) {
+      params.NextToken = options.NextToken;
+    }
+    if (options?.Filters && options.Filters.length > 0) {
+      params.Filters = options.Filters;
+    }
+    if (options?.SortOrder) {
+      params.SortOrder = options.SortOrder;
+    }
+    const result = await this.client.request({
+      service: "secretsmanager",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "secretsmanager.ListSecrets",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+    return {
+      SecretList: result.SecretList?.map((s) => this.parseSecret(s)),
+      NextToken: result.NextToken
+    };
+  }
+  async deleteSecret(options) {
+    const params = {
+      SecretId: options.SecretId
+    };
+    if (options.RecoveryWindowInDays !== undefined) {
+      params.RecoveryWindowInDays = options.RecoveryWindowInDays;
+    }
+    if (options.ForceDeleteWithoutRecovery !== undefined) {
+      params.ForceDeleteWithoutRecovery = options.ForceDeleteWithoutRecovery;
+    }
+    const result = await this.client.request({
+      service: "secretsmanager",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "secretsmanager.DeleteSecret",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+    return {
+      ARN: result.ARN,
+      Name: result.Name,
+      DeletionDate: result.DeletionDate
+    };
+  }
+  async restoreSecret(secretId) {
+    const params = {
+      SecretId: secretId
+    };
+    const result = await this.client.request({
+      service: "secretsmanager",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "secretsmanager.RestoreSecret",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+    return {
+      ARN: result.ARN,
+      Name: result.Name
+    };
+  }
+  async rotateSecret(options) {
+    const params = {
+      SecretId: options.SecretId
+    };
+    if (options.ClientRequestToken) {
+      params.ClientRequestToken = options.ClientRequestToken;
+    }
+    if (options.RotationLambdaARN) {
+      params.RotationLambdaARN = options.RotationLambdaARN;
+    }
+    if (options.RotationRules) {
+      params.RotationRules = options.RotationRules;
+    }
+    if (options.RotateImmediately !== undefined) {
+      params.RotateImmediately = options.RotateImmediately;
+    }
+    const result = await this.client.request({
+      service: "secretsmanager",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "secretsmanager.RotateSecret",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+    return {
+      ARN: result.ARN,
+      Name: result.Name,
+      VersionId: result.VersionId
+    };
+  }
+  async cancelRotateSecret(secretId) {
+    const params = {
+      SecretId: secretId
+    };
+    const result = await this.client.request({
+      service: "secretsmanager",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "secretsmanager.CancelRotateSecret",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+    return {
+      ARN: result.ARN,
+      Name: result.Name
+    };
+  }
+  async getResourcePolicy(secretId) {
+    const params = {
+      SecretId: secretId
+    };
+    const result = await this.client.request({
+      service: "secretsmanager",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "secretsmanager.GetResourcePolicy",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+    return {
+      ARN: result.ARN,
+      Name: result.Name,
+      ResourcePolicy: result.ResourcePolicy
+    };
+  }
+  async putResourcePolicy(options) {
+    const params = {
+      SecretId: options.SecretId,
+      ResourcePolicy: options.ResourcePolicy
+    };
+    if (options.BlockPublicPolicy !== undefined) {
+      params.BlockPublicPolicy = options.BlockPublicPolicy;
+    }
+    const result = await this.client.request({
+      service: "secretsmanager",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "secretsmanager.PutResourcePolicy",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+    return {
+      ARN: result.ARN,
+      Name: result.Name
+    };
+  }
+  async deleteResourcePolicy(secretId) {
+    const params = {
+      SecretId: secretId
+    };
+    const result = await this.client.request({
+      service: "secretsmanager",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "secretsmanager.DeleteResourcePolicy",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+    return {
+      ARN: result.ARN,
+      Name: result.Name
+    };
+  }
+  async tagResource(options) {
+    const params = {
+      SecretId: options.SecretId,
+      Tags: options.Tags
+    };
+    await this.client.request({
+      service: "secretsmanager",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "secretsmanager.TagResource",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+  }
+  async untagResource(options) {
+    const params = {
+      SecretId: options.SecretId,
+      TagKeys: options.TagKeys
+    };
+    await this.client.request({
+      service: "secretsmanager",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "secretsmanager.UntagResource",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+  }
+  async setString(name, value, options) {
+    try {
+      const result = await this.putSecretValue({
+        SecretId: name,
+        SecretString: value
+      });
+      return { ARN: result.ARN, VersionId: result.VersionId };
+    } catch (error) {
+      if (error.code === "ResourceNotFoundException") {
+        const result = await this.createSecret({
+          Name: name,
+          SecretString: value,
+          Description: options?.description,
+          KmsKeyId: options?.kmsKeyId,
+          Tags: options?.tags
+        });
+        return { ARN: result.ARN, VersionId: result.VersionId };
+      }
+      throw error;
+    }
+  }
+  async setJson(name, value, options) {
+    return this.setString(name, JSON.stringify(value), options);
+  }
+  async getString(secretId) {
+    const result = await this.getSecretValue({ SecretId: secretId });
+    return result.SecretString;
+  }
+  async getJson(secretId) {
+    const str = await this.getString(secretId);
+    if (str) {
+      return JSON.parse(str);
+    }
+    return;
+  }
+  async listAll() {
+    const allSecrets = [];
+    let nextToken;
+    do {
+      const result = await this.listSecrets({ NextToken: nextToken });
+      if (result.SecretList) {
+        allSecrets.push(...result.SecretList);
+      }
+      nextToken = result.NextToken;
+    } while (nextToken);
+    return allSecrets;
+  }
+  parseSecret(s) {
+    return {
+      ARN: s.ARN,
+      Name: s.Name,
+      Description: s.Description,
+      KmsKeyId: s.KmsKeyId,
+      RotationEnabled: s.RotationEnabled,
+      RotationLambdaARN: s.RotationLambdaARN,
+      RotationRules: s.RotationRules,
+      LastRotatedDate: s.LastRotatedDate,
+      LastChangedDate: s.LastChangedDate,
+      LastAccessedDate: s.LastAccessedDate,
+      DeletedDate: s.DeletedDate,
+      NextRotationDate: s.NextRotationDate,
+      Tags: s.Tags,
+      SecretVersionsToStages: s.SecretVersionsToStages,
+      CreatedDate: s.CreatedDate,
+      PrimaryRegion: s.PrimaryRegion
+    };
+  }
+}
+
+// src/aws/sqs.ts
+class SQSClient {
+  client;
+  region;
+  constructor(region = "us-east-1", profile) {
+    this.region = region;
+    this.client = new AWSClient;
+  }
+  async createQueue(options) {
+    const queueName = options.fifo && !options.queueName.endsWith(".fifo") ? `${options.queueName}.fifo` : options.queueName;
+    const params = {
+      Action: "CreateQueue",
+      QueueName: queueName,
+      Version: "2012-11-05"
+    };
+    let attrIndex = 1;
+    if (options.visibilityTimeout !== undefined) {
+      params[`Attribute.${attrIndex}.Name`] = "VisibilityTimeout";
+      params[`Attribute.${attrIndex}.Value`] = options.visibilityTimeout.toString();
+      attrIndex++;
+    }
+    if (options.messageRetentionPeriod !== undefined) {
+      params[`Attribute.${attrIndex}.Name`] = "MessageRetentionPeriod";
+      params[`Attribute.${attrIndex}.Value`] = options.messageRetentionPeriod.toString();
+      attrIndex++;
+    }
+    if (options.delaySeconds !== undefined) {
+      params[`Attribute.${attrIndex}.Name`] = "DelaySeconds";
+      params[`Attribute.${attrIndex}.Value`] = options.delaySeconds.toString();
+      attrIndex++;
+    }
+    if (options.maxMessageSize !== undefined) {
+      params[`Attribute.${attrIndex}.Name`] = "MaximumMessageSize";
+      params[`Attribute.${attrIndex}.Value`] = options.maxMessageSize.toString();
+      attrIndex++;
+    }
+    if (options.receiveMessageWaitTime !== undefined) {
+      params[`Attribute.${attrIndex}.Name`] = "ReceiveMessageWaitTimeSeconds";
+      params[`Attribute.${attrIndex}.Value`] = options.receiveMessageWaitTime.toString();
+      attrIndex++;
+    }
+    if (options.fifo) {
+      params[`Attribute.${attrIndex}.Name`] = "FifoQueue";
+      params[`Attribute.${attrIndex}.Value`] = "true";
+      attrIndex++;
+      if (options.contentBasedDeduplication) {
+        params[`Attribute.${attrIndex}.Name`] = "ContentBasedDeduplication";
+        params[`Attribute.${attrIndex}.Value`] = "true";
+        attrIndex++;
+      }
+    }
+    if (options.deadLetterTargetArn && options.maxReceiveCount) {
+      params[`Attribute.${attrIndex}.Name`] = "RedrivePolicy";
+      params[`Attribute.${attrIndex}.Value`] = JSON.stringify({
+        deadLetterTargetArn: options.deadLetterTargetArn,
+        maxReceiveCount: options.maxReceiveCount
+      });
+      attrIndex++;
+    }
+    if (options.tags && Object.keys(options.tags).length > 0) {
+      let tagIndex = 1;
+      for (const [key, value] of Object.entries(options.tags)) {
+        params[`Tag.${tagIndex}.Key`] = key;
+        params[`Tag.${tagIndex}.Value`] = value;
+        tagIndex++;
+      }
+    }
+    const result = await this.client.request({
+      service: "sqs",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      body: new URLSearchParams(params).toString()
+    });
+    return { QueueUrl: result.QueueUrl || result.CreateQueueResult?.QueueUrl };
+  }
+  async listQueues(prefix) {
+    const params = {
+      Action: "ListQueues",
+      Version: "2012-11-05"
+    };
+    if (prefix) {
+      params.QueueNamePrefix = prefix;
+    }
+    const result = await this.client.request({
+      service: "sqs",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      body: new URLSearchParams(params).toString()
+    });
+    const queueUrls = [];
+    if (result.QueueUrl) {
+      queueUrls.push(result.QueueUrl);
+    } else if (result.ListQueuesResult?.QueueUrl) {
+      if (Array.isArray(result.ListQueuesResult.QueueUrl)) {
+        queueUrls.push(...result.ListQueuesResult.QueueUrl);
+      } else {
+        queueUrls.push(result.ListQueuesResult.QueueUrl);
+      }
+    }
+    return { QueueUrls: queueUrls };
+  }
+  async getQueueAttributes(queueUrl) {
+    const params = {
+      Action: "GetQueueAttributes",
+      QueueUrl: queueUrl,
+      Version: "2012-11-05",
+      "AttributeName.1": "All"
+    };
+    const result = await this.client.request({
+      service: "sqs",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      body: new URLSearchParams(params).toString()
+    });
+    return { Attributes: result.Attributes || result.GetQueueAttributesResult?.Attributes || {} };
+  }
+  async getQueueUrl(queueName) {
+    const params = {
+      Action: "GetQueueUrl",
+      QueueName: queueName,
+      Version: "2012-11-05"
+    };
+    const result = await this.client.request({
+      service: "sqs",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      body: new URLSearchParams(params).toString()
+    });
+    return { QueueUrl: result.QueueUrl || result.GetQueueUrlResult?.QueueUrl };
+  }
+  async deleteQueue(queueUrl) {
+    const params = {
+      Action: "DeleteQueue",
+      QueueUrl: queueUrl,
+      Version: "2012-11-05"
+    };
+    await this.client.request({
+      service: "sqs",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      body: new URLSearchParams(params).toString()
+    });
+  }
+  async purgeQueue(queueUrl) {
+    const params = {
+      Action: "PurgeQueue",
+      QueueUrl: queueUrl,
+      Version: "2012-11-05"
+    };
+    await this.client.request({
+      service: "sqs",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      body: new URLSearchParams(params).toString()
+    });
+  }
+  async sendMessage(options) {
+    const params = {
+      Action: "SendMessage",
+      QueueUrl: options.queueUrl,
+      MessageBody: options.messageBody,
+      Version: "2012-11-05"
+    };
+    if (options.delaySeconds !== undefined) {
+      params.DelaySeconds = options.delaySeconds;
+    }
+    if (options.messageGroupId) {
+      params.MessageGroupId = options.messageGroupId;
+    }
+    if (options.messageDeduplicationId) {
+      params.MessageDeduplicationId = options.messageDeduplicationId;
+    }
+    const result = await this.client.request({
+      service: "sqs",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      body: new URLSearchParams(params).toString()
+    });
+    return { MessageId: result.MessageId || result.SendMessageResult?.MessageId };
+  }
+  async receiveMessages(options) {
+    const params = {
+      Action: "ReceiveMessage",
+      QueueUrl: options.queueUrl,
+      Version: "2012-11-05"
+    };
+    if (options.maxMessages !== undefined) {
+      params.MaxNumberOfMessages = options.maxMessages;
+    }
+    if (options.visibilityTimeout !== undefined) {
+      params.VisibilityTimeout = options.visibilityTimeout;
+    }
+    if (options.waitTimeSeconds !== undefined) {
+      params.WaitTimeSeconds = options.waitTimeSeconds;
+    }
+    const result = await this.client.request({
+      service: "sqs",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      body: new URLSearchParams(params).toString()
+    });
+    const messages = [];
+    const msgData = result.Message || result.ReceiveMessageResult?.Message;
+    if (msgData) {
+      if (Array.isArray(msgData)) {
+        messages.push(...msgData.map((m) => ({
+          MessageId: m.MessageId,
+          ReceiptHandle: m.ReceiptHandle,
+          Body: m.Body
+        })));
+      } else {
+        messages.push({
+          MessageId: msgData.MessageId,
+          ReceiptHandle: msgData.ReceiptHandle,
+          Body: msgData.Body
+        });
+      }
+    }
+    return { Messages: messages };
+  }
+  async deleteMessage(queueUrl, receiptHandle) {
+    const params = {
+      Action: "DeleteMessage",
+      QueueUrl: queueUrl,
+      ReceiptHandle: receiptHandle,
+      Version: "2012-11-05"
+    };
+    await this.client.request({
+      service: "sqs",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      body: new URLSearchParams(params).toString()
+    });
+  }
+}
+
+// src/aws/lambda.ts
+import { deflateRawSync } from "zlib";
+function createZipFile(filename, content) {
+  const data = typeof content === "string" ? Buffer.from(content, "utf-8") : content;
+  const compressedData = deflateRawSync(data);
+  const crc32 = calculateCrc32(data);
+  const now = new Date;
+  const dosTime = (now.getHours() << 11 | now.getMinutes() << 5 | now.getSeconds() >> 1) & 65535;
+  const dosDate = (now.getFullYear() - 1980 << 9 | now.getMonth() + 1 << 5 | now.getDate()) & 65535;
+  const filenameBuffer = Buffer.from(filename, "utf-8");
+  const localHeader = Buffer.alloc(30 + filenameBuffer.length);
+  localHeader.writeUInt32LE(67324752, 0);
+  localHeader.writeUInt16LE(20, 4);
+  localHeader.writeUInt16LE(0, 6);
+  localHeader.writeUInt16LE(8, 8);
+  localHeader.writeUInt16LE(dosTime, 10);
+  localHeader.writeUInt16LE(dosDate, 12);
+  localHeader.writeUInt32LE(crc32, 14);
+  localHeader.writeUInt32LE(compressedData.length, 18);
+  localHeader.writeUInt32LE(data.length, 22);
+  localHeader.writeUInt16LE(filenameBuffer.length, 26);
+  localHeader.writeUInt16LE(0, 28);
+  filenameBuffer.copy(localHeader, 30);
+  const centralHeader = Buffer.alloc(46 + filenameBuffer.length);
+  centralHeader.writeUInt32LE(33639248, 0);
+  centralHeader.writeUInt16LE(20, 4);
+  centralHeader.writeUInt16LE(20, 6);
+  centralHeader.writeUInt16LE(0, 8);
+  centralHeader.writeUInt16LE(8, 10);
+  centralHeader.writeUInt16LE(dosTime, 12);
+  centralHeader.writeUInt16LE(dosDate, 14);
+  centralHeader.writeUInt32LE(crc32, 16);
+  centralHeader.writeUInt32LE(compressedData.length, 20);
+  centralHeader.writeUInt32LE(data.length, 24);
+  centralHeader.writeUInt16LE(filenameBuffer.length, 28);
+  centralHeader.writeUInt16LE(0, 30);
+  centralHeader.writeUInt16LE(0, 32);
+  centralHeader.writeUInt16LE(0, 34);
+  centralHeader.writeUInt16LE(0, 36);
+  centralHeader.writeUInt32LE(0, 38);
+  centralHeader.writeUInt32LE(0, 42);
+  filenameBuffer.copy(centralHeader, 46);
+  const centralDirOffset = localHeader.length + compressedData.length;
+  const centralDirSize = centralHeader.length;
+  const endRecord = Buffer.alloc(22);
+  endRecord.writeUInt32LE(101010256, 0);
+  endRecord.writeUInt16LE(0, 4);
+  endRecord.writeUInt16LE(0, 6);
+  endRecord.writeUInt16LE(1, 8);
+  endRecord.writeUInt16LE(1, 10);
+  endRecord.writeUInt32LE(centralDirSize, 12);
+  endRecord.writeUInt32LE(centralDirOffset, 16);
+  endRecord.writeUInt16LE(0, 20);
+  return Buffer.concat([localHeader, compressedData, centralHeader, endRecord]);
+}
+function calculateCrc32(data) {
+  const table = [];
+  for (let i = 0;i < 256; i++) {
+    let c = i;
+    for (let j = 0;j < 8; j++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    table[i] = c;
+  }
+  let crc = 4294967295;
+  for (let i = 0;i < data.length; i++) {
+    crc = table[(crc ^ data[i]) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+
+class LambdaClient {
+  client;
+  region;
+  constructor(region = "us-east-1") {
+    this.region = region;
+    this.client = new AWSClient;
+  }
+  async createFunction(params) {
+    const result = await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "POST",
+      path: "/2015-03-31/functions",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(params)
+    });
+    return result;
+  }
+  async getFunction(functionName) {
+    const result = await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "GET",
+      path: `/2015-03-31/functions/${encodeURIComponent(functionName)}`,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    return result;
+  }
+  async updateFunctionCode(params) {
+    const { FunctionName, ...rest } = params;
+    const result = await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "PUT",
+      path: `/2015-03-31/functions/${encodeURIComponent(FunctionName)}/code`,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(rest)
+    });
+    return result;
+  }
+  async updateFunctionCodeInline(functionName, code, filename = "index.js") {
+    const zipBuffer = createZipFile(filename, code);
+    return this.updateFunctionCode({
+      FunctionName: functionName,
+      ZipFile: zipBuffer.toString("base64")
+    });
+  }
+  async updateFunctionConfiguration(params) {
+    const { FunctionName, ...rest } = params;
+    const result = await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "PUT",
+      path: `/2015-03-31/functions/${encodeURIComponent(FunctionName)}/configuration`,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(rest)
+    });
+    return result;
+  }
+  async deleteFunction(functionName) {
+    await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "DELETE",
+      path: `/2015-03-31/functions/${encodeURIComponent(functionName)}`,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  async invoke(params) {
+    const { FunctionName, InvocationType = "RequestResponse", Payload, LogType } = params;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Amz-Invocation-Type": InvocationType
+    };
+    if (LogType) {
+      headers["X-Amz-Log-Type"] = LogType;
+    }
+    const body = Payload ? typeof Payload === "string" ? Payload : JSON.stringify(Payload) : undefined;
+    const result = await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "POST",
+      path: `/2015-03-31/functions/${encodeURIComponent(FunctionName)}/invocations`,
+      headers,
+      body,
+      returnHeaders: true
+    });
+    return {
+      StatusCode: result.statusCode || 200,
+      FunctionError: result.headers?.["x-amz-function-error"],
+      LogResult: result.headers?.["x-amz-log-result"],
+      Payload: typeof result.body === "string" ? result.body : JSON.stringify(result.body),
+      ExecutedVersion: result.headers?.["x-amz-executed-version"]
+    };
+  }
+  async listFunctions(params) {
+    const queryParams = {};
+    if (params?.MaxItems)
+      queryParams.MaxItems = String(params.MaxItems);
+    if (params?.Marker)
+      queryParams.Marker = params.Marker;
+    if (params?.FunctionVersion)
+      queryParams.FunctionVersion = params.FunctionVersion;
+    const result = await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "GET",
+      path: "/2015-03-31/functions",
+      queryParams: Object.keys(queryParams).length > 0 ? queryParams : undefined,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    return result;
+  }
+  async addPermission(params) {
+    const { FunctionName, ...rest } = params;
+    const result = await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "POST",
+      path: `/2015-03-31/functions/${encodeURIComponent(FunctionName)}/policy`,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(rest)
+    });
+    return result;
+  }
+  async removePermission(functionName, statementId) {
+    await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "DELETE",
+      path: `/2015-03-31/functions/${encodeURIComponent(functionName)}/policy/${encodeURIComponent(statementId)}`,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  async publishVersion(params) {
+    const { FunctionName, ...rest } = params;
+    const result = await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "POST",
+      path: `/2015-03-31/functions/${encodeURIComponent(FunctionName)}/versions`,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(rest)
+    });
+    return result;
+  }
+  async createAlias(params) {
+    const { FunctionName, ...rest } = params;
+    const result = await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "POST",
+      path: `/2015-03-31/functions/${encodeURIComponent(FunctionName)}/aliases`,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(rest)
+    });
+    return result;
+  }
+  async updateAlias(params) {
+    const { FunctionName, Name, ...rest } = params;
+    return this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "PUT",
+      path: `/2015-03-31/functions/${encodeURIComponent(FunctionName)}/aliases/${encodeURIComponent(Name)}`,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(rest)
+    });
+  }
+  async getAlias(functionName, name) {
+    try {
+      return await this.client.request({
+        service: "lambda",
+        region: this.region,
+        method: "GET",
+        path: `/2015-03-31/functions/${encodeURIComponent(functionName)}/aliases/${encodeURIComponent(name)}`
+      });
+    } catch (err) {
+      if (/ResourceNotFound/i.test(String(err?.message)))
+        return null;
+      throw err;
+    }
+  }
+  async getProvisionedConcurrencyConfig(functionName, qualifier) {
+    try {
+      return await this.client.request({
+        service: "lambda",
+        region: this.region,
+        method: "GET",
+        path: `/2019-09-30/functions/${encodeURIComponent(functionName)}/provisioned-concurrency`,
+        queryParams: { Qualifier: qualifier }
+      });
+    } catch (err) {
+      if (/ProvisionedConcurrencyConfigNotFound|ResourceNotFound/i.test(String(err?.message)))
+        return null;
+      throw err;
+    }
+  }
+  async putProvisionedConcurrencyConfig(params) {
+    const { FunctionName, Qualifier, ProvisionedConcurrentExecutions } = params;
+    return this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "PUT",
+      path: `/2019-09-30/functions/${encodeURIComponent(FunctionName)}/provisioned-concurrency`,
+      queryParams: { Qualifier },
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ProvisionedConcurrentExecutions })
+    });
+  }
+  async deleteProvisionedConcurrencyConfig(functionName, qualifier) {
+    await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "DELETE",
+      path: `/2019-09-30/functions/${encodeURIComponent(functionName)}/provisioned-concurrency`,
+      queryParams: { Qualifier: qualifier }
+    });
+  }
+  async waitForFunctionActive(functionName, maxWaitSeconds = 60) {
+    const startTime = Date.now();
+    const maxWaitMs = maxWaitSeconds * 1000;
+    while (Date.now() - startTime < maxWaitMs) {
+      try {
+        const response = await this.getFunction(functionName);
+        const state = response.Configuration?.State;
+        if (state === "Active") {
+          return response.Configuration;
+        }
+        if (state === "Failed") {
+          throw new Error(`Function ${functionName} failed: ${response.Configuration?.StateReason}`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+      } catch (error) {
+        if (error.code === "ResourceNotFoundException") {
+          await new Promise((resolve) => setTimeout(resolve, 2000));
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw new Error(`Timeout waiting for function ${functionName} to become active`);
+  }
+  async functionExists(functionName) {
+    try {
+      await this.getFunction(functionName);
+      return true;
+    } catch (error) {
+      if (error.code === "ResourceNotFoundException" || error.statusCode === 404) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async createFunctionUrl(params) {
+    const { FunctionName, ...rest } = params;
+    const result = await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "POST",
+      path: `/2021-10-31/functions/${encodeURIComponent(FunctionName)}/url`,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(rest)
+    });
+    return result;
+  }
+  async getFunctionUrl(functionName) {
+    try {
+      const result = await this.client.request({
+        service: "lambda",
+        region: this.region,
+        method: "GET",
+        path: `/2021-10-31/functions/${encodeURIComponent(functionName)}/url`,
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      return result;
+    } catch (error) {
+      if (error.statusCode === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async deleteFunctionUrl(functionName) {
+    await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "DELETE",
+      path: `/2021-10-31/functions/${encodeURIComponent(functionName)}/url`,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  async createFunctionWithCode(params) {
+    const { Code, Filename = "index.js", ...rest } = params;
+    const zipBuffer = createZipFile(Filename, Code);
+    return this.createFunction({
+      ...rest,
+      Code: {
+        ZipFile: zipBuffer.toString("base64")
+      }
+    });
+  }
+  async addFunctionUrlPermission(functionName) {
+    return this.addPermission({
+      FunctionName: functionName,
+      StatementId: "FunctionURLAllowPublicAccess",
+      Action: "lambda:InvokeFunctionUrl",
+      Principal: "*",
+      FunctionUrlAuthType: "NONE"
+    });
+  }
+  async publishLayerVersion(params) {
+    const { LayerName, ...rest } = params;
+    const result = await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "POST",
+      path: `/2018-10-31/layers/${encodeURIComponent(LayerName)}/versions`,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(rest)
+    });
+    return result;
+  }
+  async listLayerVersions(layerName, params) {
+    const queryParams = {};
+    if (params?.CompatibleRuntime)
+      queryParams.CompatibleRuntime = params.CompatibleRuntime;
+    if (params?.CompatibleArchitecture)
+      queryParams.CompatibleArchitecture = params.CompatibleArchitecture;
+    if (params?.MaxItems)
+      queryParams.MaxItems = String(params.MaxItems);
+    if (params?.Marker)
+      queryParams.Marker = params.Marker;
+    const result = await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "GET",
+      path: `/2018-10-31/layers/${encodeURIComponent(layerName)}/versions`,
+      queryParams: Object.keys(queryParams).length > 0 ? queryParams : undefined,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    return result;
+  }
+  async getLayerVersion(layerName, versionNumber) {
+    const result = await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "GET",
+      path: `/2018-10-31/layers/${encodeURIComponent(layerName)}/versions/${versionNumber}`,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    return result;
+  }
+  async addLayerVersionPermission(params) {
+    const { LayerName, VersionNumber, ...rest } = params;
+    const result = await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "POST",
+      path: `/2018-10-31/layers/${encodeURIComponent(LayerName)}/versions/${VersionNumber}/policy`,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(rest)
+    });
+    return result;
+  }
+  async deleteLayerVersion(layerName, versionNumber) {
+    await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "DELETE",
+      path: `/2018-10-31/layers/${encodeURIComponent(layerName)}/versions/${versionNumber}`,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+}
+
+// src/aws/cloudwatch-logs.ts
+class CloudWatchLogsClient {
+  client;
+  region;
+  constructor(region = "us-east-1", profile) {
+    this.region = region;
+    this.client = new AWSClient;
+  }
+  async describeLogStreams(options) {
+    const params = {
+      logGroupName: options.logGroupName
+    };
+    if (options.logStreamNamePrefix)
+      params.logStreamNamePrefix = options.logStreamNamePrefix;
+    if (options.orderBy)
+      params.orderBy = options.orderBy;
+    if (options.descending !== undefined)
+      params.descending = options.descending;
+    if (options.limit)
+      params.limit = options.limit;
+    const result = await this.client.request({
+      service: "logs",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "Logs_20140328.DescribeLogStreams",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+    return result;
+  }
+  async getLogEvents(options) {
+    const params = {
+      logGroupName: options.logGroupName,
+      logStreamName: options.logStreamName
+    };
+    if (options.startTime)
+      params.startTime = options.startTime;
+    if (options.endTime)
+      params.endTime = options.endTime;
+    if (options.limit)
+      params.limit = options.limit;
+    if (options.startFromHead !== undefined)
+      params.startFromHead = options.startFromHead;
+    const result = await this.client.request({
+      service: "logs",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "Logs_20140328.GetLogEvents",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+    return result;
+  }
+  async describeLogGroups(options) {
+    const params = {};
+    if (options?.logGroupNamePrefix)
+      params.logGroupNamePrefix = options.logGroupNamePrefix;
+    if (options?.limit)
+      params.limit = options.limit;
+    const result = await this.client.request({
+      service: "logs",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "Logs_20140328.DescribeLogGroups",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+    return result;
+  }
+  async deleteLogGroup(logGroupName) {
+    await this.client.request({
+      service: "logs",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "Logs_20140328.DeleteLogGroup",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify({ logGroupName })
+    });
+  }
+  async filterLogEvents(options) {
+    const params = {
+      logGroupName: options.logGroupName
+    };
+    if (options.logStreamNames)
+      params.logStreamNames = options.logStreamNames;
+    if (options.startTime)
+      params.startTime = options.startTime;
+    if (options.endTime)
+      params.endTime = options.endTime;
+    if (options.filterPattern)
+      params.filterPattern = options.filterPattern;
+    if (options.limit)
+      params.limit = options.limit;
+    const result = await this.client.request({
+      service: "logs",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "Logs_20140328.FilterLogEvents",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
+    });
+    return result;
+  }
+}
+
+// src/aws/eventbridge.ts
+class EventBridgeClient {
+  client;
+  region;
+  constructor(region = "us-east-1") {
+    this.region = region;
+    this.client = new AWSClient;
+  }
+  async request(action, params) {
+    return this.client.request({
+      service: "events",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "Content-Type": "application/x-amz-json-1.1",
+        "X-Amz-Target": `AWSEvents.${action}`
+      },
+      body: JSON.stringify(params)
+    });
+  }
+  async putRule(params) {
+    return this.request("PutRule", params);
+  }
+  async deleteRule(params) {
+    return this.request("DeleteRule", params);
+  }
+  async describeRule(params) {
+    return this.request("DescribeRule", params);
+  }
+  async listRules(params) {
+    return this.request("ListRules", params || {});
+  }
+  async listEventBuses(params) {
+    return this.request("ListEventBuses", params || {});
+  }
+  async enableRule(params) {
+    return this.request("EnableRule", params);
+  }
+  async disableRule(params) {
+    return this.request("DisableRule", params);
+  }
+  async putTargets(params) {
+    return this.request("PutTargets", params);
+  }
+  async removeTargets(params) {
+    return this.request("RemoveTargets", params);
+  }
+  async listTargetsByRule(params) {
+    return this.request("ListTargetsByRule", params);
+  }
+  async putEvents(params) {
+    return this.request("PutEvents", params);
+  }
+  async createSchedule(params) {
+    return this.client.request({
+      service: "scheduler",
+      region: this.region,
+      method: "POST",
+      path: `/schedules/${params.Name}`,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(params)
+    });
+  }
+}
+
+// src/aws/efs.ts
+class EFSClient {
+  client;
+  region;
+  constructor(region = "us-east-1") {
+    this.region = region;
+    this.client = new AWSClient;
+  }
+  async describeFileSystems(options) {
+    const queryParams = [];
+    if (options?.FileSystemId) {
+      queryParams.push(`FileSystemId=${encodeURIComponent(options.FileSystemId)}`);
+    }
+    if (options?.CreationToken) {
+      queryParams.push(`CreationToken=${encodeURIComponent(options.CreationToken)}`);
+    }
+    const path = `/2015-02-01/file-systems${queryParams.length > 0 ? `?${queryParams.join("&")}` : ""}`;
+    const result = await this.client.request({
+      service: "elasticfilesystem",
+      region: this.region,
+      method: "GET",
+      path,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    return {
+      FileSystems: (result.FileSystems || []).map((fs) => ({
+        FileSystemId: fs.FileSystemId,
+        Name: fs.Name,
+        CreationTime: fs.CreationTime,
+        LifeCycleState: fs.LifeCycleState,
+        NumberOfMountTargets: fs.NumberOfMountTargets,
+        SizeInBytes: fs.SizeInBytes ? {
+          Value: fs.SizeInBytes.Value,
+          Timestamp: fs.SizeInBytes.Timestamp
+        } : undefined,
+        PerformanceMode: fs.PerformanceMode,
+        Encrypted: fs.Encrypted,
+        ThroughputMode: fs.ThroughputMode,
+        Tags: fs.Tags
+      }))
+    };
+  }
+}
+
+export { CostExplorerClient, SecretsManagerClient, SQSClient, LambdaClient, CloudWatchLogsClient, EventBridgeClient, EFSClient };