@stacksjs/ts-cloud 0.7.56 → 0.7.57

package/dist/chunk-b82pbxyp.js

@@ -1,1572 +0,0 @@
-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 };