alchemy-effect 0.5.0 → 0.6.2

package/src/AWS/CloudWatch/DescribeAlarmsForMetric.ts

@@ -0,0 +1,66 @@
+import * as cloudwatch from "@distilled.cloud/aws/cloudwatch";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+
+export interface DescribeAlarmsForMetricRequest
+  extends cloudwatch.DescribeAlarmsForMetricInput {}
+
+/**
+ * Runtime binding for `cloudwatch:DescribeAlarmsForMetric`.
+ */
+export class DescribeAlarmsForMetric extends Binding.Service<
+  DescribeAlarmsForMetric,
+  () => Effect.Effect<
+    (
+      request: DescribeAlarmsForMetricRequest,
+    ) => Effect.Effect<
+      cloudwatch.DescribeAlarmsForMetricOutput,
+      cloudwatch.DescribeAlarmsForMetricError
+    >
+  >
+>()("AWS.CloudWatch.DescribeAlarmsForMetric") {}
+
+export const DescribeAlarmsForMetricLive = Layer.effect(
+  DescribeAlarmsForMetric,
+  Effect.gen(function* () {
+    const Policy = yield* DescribeAlarmsForMetricPolicy;
+    const describeAlarmsForMetric = yield* cloudwatch.describeAlarmsForMetric;
+
+    return Effect.fn(function* () {
+      yield* Policy();
+      return Effect.fn(function* (request: DescribeAlarmsForMetricRequest) {
+        return yield* describeAlarmsForMetric(request);
+      });
+    });
+  }),
+);
+
+export class DescribeAlarmsForMetricPolicy extends Binding.Policy<
+  DescribeAlarmsForMetricPolicy,
+  () => Effect.Effect<void>
+>()("AWS.CloudWatch.DescribeAlarmsForMetric") {}
+
+export const DescribeAlarmsForMetricPolicyLive =
+  DescribeAlarmsForMetricPolicy.layer.succeed(
+    Effect.fn(function* (host) {
+      if (isFunction(host)) {
+        yield* host.bind`Allow(${host}, AWS.CloudWatch.DescribeAlarmsForMetric())`(
+          {
+            policyStatements: [
+              {
+                Effect: "Allow",
+                Action: ["cloudwatch:DescribeAlarmsForMetric"],
+                Resource: ["*"],
+              },
+            ],
+          },
+        );
+      } else {
+        return yield* Effect.die(
+          `DescribeAlarmsForMetricPolicy does not support runtime '${host.Type}'`,
+        );
+      }
+    }),
+  );

package/src/AWS/CloudWatch/DescribeAnomalyDetectors.ts

@@ -0,0 +1,68 @@
+import * as cloudwatch from "@distilled.cloud/aws/cloudwatch";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+
+export interface DescribeAnomalyDetectorsRequest
+  extends cloudwatch.DescribeAnomalyDetectorsInput {}
+
+/**
+ * Runtime binding for `cloudwatch:DescribeAnomalyDetectors`.
+ */
+export class DescribeAnomalyDetectors extends Binding.Service<
+  DescribeAnomalyDetectors,
+  () => Effect.Effect<
+    (
+      request?: DescribeAnomalyDetectorsRequest,
+    ) => Effect.Effect<
+      cloudwatch.DescribeAnomalyDetectorsOutput,
+      cloudwatch.DescribeAnomalyDetectorsError
+    >
+  >
+>()("AWS.CloudWatch.DescribeAnomalyDetectors") {}
+
+export const DescribeAnomalyDetectorsLive = Layer.effect(
+  DescribeAnomalyDetectors,
+  Effect.gen(function* () {
+    const Policy = yield* DescribeAnomalyDetectorsPolicy;
+    const describeAnomalyDetectors = yield* cloudwatch.describeAnomalyDetectors;
+
+    return Effect.fn(function* () {
+      yield* Policy();
+      return Effect.fn(function* (
+        request: DescribeAnomalyDetectorsRequest = {},
+      ) {
+        return yield* describeAnomalyDetectors(request);
+      });
+    });
+  }),
+);
+
+export class DescribeAnomalyDetectorsPolicy extends Binding.Policy<
+  DescribeAnomalyDetectorsPolicy,
+  () => Effect.Effect<void>
+>()("AWS.CloudWatch.DescribeAnomalyDetectors") {}
+
+export const DescribeAnomalyDetectorsPolicyLive =
+  DescribeAnomalyDetectorsPolicy.layer.succeed(
+    Effect.fn(function* (host) {
+      if (isFunction(host)) {
+        yield* host.bind`Allow(${host}, AWS.CloudWatch.DescribeAnomalyDetectors())`(
+          {
+            policyStatements: [
+              {
+                Effect: "Allow",
+                Action: ["cloudwatch:DescribeAnomalyDetectors"],
+                Resource: ["*"],
+              },
+            ],
+          },
+        );
+      } else {
+        return yield* Effect.die(
+          `DescribeAnomalyDetectorsPolicy does not support runtime '${host.Type}'`,
+        );
+      }
+    }),
+  );

package/src/AWS/CloudWatch/DescribeInsightRules.ts

@@ -0,0 +1,66 @@
+import * as cloudwatch from "@distilled.cloud/aws/cloudwatch";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+
+export interface DescribeInsightRulesRequest
+  extends cloudwatch.DescribeInsightRulesInput {}
+
+/**
+ * Runtime binding for `cloudwatch:DescribeInsightRules`.
+ */
+export class DescribeInsightRules extends Binding.Service<
+  DescribeInsightRules,
+  () => Effect.Effect<
+    (
+      request?: DescribeInsightRulesRequest,
+    ) => Effect.Effect<
+      cloudwatch.DescribeInsightRulesOutput,
+      cloudwatch.DescribeInsightRulesError
+    >
+  >
+>()("AWS.CloudWatch.DescribeInsightRules") {}
+
+export const DescribeInsightRulesLive = Layer.effect(
+  DescribeInsightRules,
+  Effect.gen(function* () {
+    const Policy = yield* DescribeInsightRulesPolicy;
+    const describeInsightRules = yield* cloudwatch.describeInsightRules;
+
+    return Effect.fn(function* () {
+      yield* Policy();
+      return Effect.fn(function* (request: DescribeInsightRulesRequest = {}) {
+        return yield* describeInsightRules(request);
+      });
+    });
+  }),
+);
+
+export class DescribeInsightRulesPolicy extends Binding.Policy<
+  DescribeInsightRulesPolicy,
+  () => Effect.Effect<void>
+>()("AWS.CloudWatch.DescribeInsightRules") {}
+
+export const DescribeInsightRulesPolicyLive =
+  DescribeInsightRulesPolicy.layer.succeed(
+    Effect.fn(function* (host) {
+      if (isFunction(host)) {
+        yield* host.bind`Allow(${host}, AWS.CloudWatch.DescribeInsightRules())`(
+          {
+            policyStatements: [
+              {
+                Effect: "Allow",
+                Action: ["cloudwatch:DescribeInsightRules"],
+                Resource: ["*"],
+              },
+            ],
+          },
+        );
+      } else {
+        return yield* Effect.die(
+          `DescribeInsightRulesPolicy does not support runtime '${host.Type}'`,
+        );
+      }
+    }),
+  );

package/src/AWS/CloudWatch/DisableAlarmActions.ts

@@ -0,0 +1,74 @@
+import * as cloudwatch from "@distilled.cloud/aws/cloudwatch";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import { type AlarmResource, sortAlarmResources } from "./binding-common.ts";
+
+type AlarmResources = [AlarmResource, ...AlarmResource[]];
+
+/**
+ * Runtime binding for `cloudwatch:DisableAlarmActions`.
+ */
+export class DisableAlarmActions extends Binding.Service<
+  DisableAlarmActions,
+  (
+    ...alarms: AlarmResources
+  ) => Effect.Effect<
+    () => Effect.Effect<cloudwatch.DisableAlarmActionsResponse, any>
+  >
+>()("AWS.CloudWatch.DisableAlarmActions") {}
+
+export const DisableAlarmActionsLive = Layer.effect(
+  DisableAlarmActions,
+  Effect.gen(function* () {
+    const Policy = yield* DisableAlarmActionsPolicy;
+    const disableAlarmActions = yield* cloudwatch.disableAlarmActions;
+
+    return Effect.fn(function* (...alarms: AlarmResources) {
+      const sorted = sortAlarmResources(alarms);
+      const AlarmNames = yield* Effect.forEach(sorted, (alarm) =>
+        alarm.alarmName.asEffect(),
+      );
+      yield* Policy(...sorted);
+
+      return Effect.fn(function* () {
+        return yield* disableAlarmActions({
+          AlarmNames: yield* Effect.forEach(
+            AlarmNames,
+            (alarmName) => alarmName,
+          ),
+        });
+      });
+    });
+  }),
+);
+
+export class DisableAlarmActionsPolicy extends Binding.Policy<
+  DisableAlarmActionsPolicy,
+  (...alarms: AlarmResources) => Effect.Effect<void>
+>()("AWS.CloudWatch.DisableAlarmActions") {}
+
+export const DisableAlarmActionsPolicyLive =
+  DisableAlarmActionsPolicy.layer.succeed(
+    Effect.fn(function* (host, ...alarms: AlarmResources) {
+      const sorted = sortAlarmResources(alarms);
+      if (isFunction(host)) {
+        yield* host.bind`Allow(${host}, AWS.CloudWatch.DisableAlarmActions(${sorted}))`(
+          {
+            policyStatements: [
+              {
+                Effect: "Allow",
+                Action: ["cloudwatch:DisableAlarmActions"],
+                Resource: sorted.map((alarm) => alarm.alarmArn),
+              },
+            ],
+          },
+        );
+      } else {
+        return yield* Effect.die(
+          `DisableAlarmActionsPolicy does not support runtime '${host.Type}'`,
+        );
+      }
+    }),
+  );

package/src/AWS/CloudWatch/DisableInsightRules.ts

@@ -0,0 +1,74 @@
+import * as cloudwatch from "@distilled.cloud/aws/cloudwatch";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import {
+  sortInsightRuleResources,
+  type InsightRuleResource,
+} from "./binding-common.ts";
+
+type InsightRules = [InsightRuleResource, ...InsightRuleResource[]];
+
+/**
+ * Runtime binding for `cloudwatch:DisableInsightRules`.
+ */
+export class DisableInsightRules extends Binding.Service<
+  DisableInsightRules,
+  (
+    ...rules: InsightRules
+  ) => Effect.Effect<
+    () => Effect.Effect<cloudwatch.DisableInsightRulesOutput, any>
+  >
+>()("AWS.CloudWatch.DisableInsightRules") {}
+
+export const DisableInsightRulesLive = Layer.effect(
+  DisableInsightRules,
+  Effect.gen(function* () {
+    const Policy = yield* DisableInsightRulesPolicy;
+    const disableInsightRules = yield* cloudwatch.disableInsightRules;
+
+    return Effect.fn(function* (...rules: InsightRules) {
+      const sorted = sortInsightRuleResources(rules);
+      const RuleNames = yield* Effect.forEach(sorted, (rule) =>
+        rule.ruleName.asEffect(),
+      );
+      yield* Policy(...sorted);
+
+      return Effect.fn(function* () {
+        return yield* disableInsightRules({
+          RuleNames: yield* Effect.forEach(RuleNames, (ruleName) => ruleName),
+        });
+      });
+    });
+  }),
+);
+
+export class DisableInsightRulesPolicy extends Binding.Policy<
+  DisableInsightRulesPolicy,
+  (...rules: InsightRules) => Effect.Effect<void>
+>()("AWS.CloudWatch.DisableInsightRules") {}
+
+export const DisableInsightRulesPolicyLive =
+  DisableInsightRulesPolicy.layer.succeed(
+    Effect.fn(function* (host, ...rules: InsightRules) {
+      const sorted = sortInsightRuleResources(rules);
+      if (isFunction(host)) {
+        yield* host.bind`Allow(${host}, AWS.CloudWatch.DisableInsightRules(${sorted}))`(
+          {
+            policyStatements: [
+              {
+                Effect: "Allow",
+                Action: ["cloudwatch:DisableInsightRules"],
+                Resource: sorted.map((rule) => rule.ruleArn),
+              },
+            ],
+          },
+        );
+      } else {
+        return yield* Effect.die(
+          `DisableInsightRulesPolicy does not support runtime '${host.Type}'`,
+        );
+      }
+    }),
+  );

package/src/AWS/CloudWatch/EnableAlarmActions.ts

@@ -0,0 +1,74 @@
+import * as cloudwatch from "@distilled.cloud/aws/cloudwatch";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import { type AlarmResource, sortAlarmResources } from "./binding-common.ts";
+
+type AlarmResources = [AlarmResource, ...AlarmResource[]];
+
+/**
+ * Runtime binding for `cloudwatch:EnableAlarmActions`.
+ */
+export class EnableAlarmActions extends Binding.Service<
+  EnableAlarmActions,
+  (
+    ...alarms: AlarmResources
+  ) => Effect.Effect<
+    () => Effect.Effect<cloudwatch.EnableAlarmActionsResponse, any>
+  >
+>()("AWS.CloudWatch.EnableAlarmActions") {}
+
+export const EnableAlarmActionsLive = Layer.effect(
+  EnableAlarmActions,
+  Effect.gen(function* () {
+    const Policy = yield* EnableAlarmActionsPolicy;
+    const enableAlarmActions = yield* cloudwatch.enableAlarmActions;
+
+    return Effect.fn(function* (...alarms: AlarmResources) {
+      const sorted = sortAlarmResources(alarms);
+      const AlarmNames = yield* Effect.forEach(sorted, (alarm) =>
+        alarm.alarmName.asEffect(),
+      );
+      yield* Policy(...sorted);
+
+      return Effect.fn(function* () {
+        return yield* enableAlarmActions({
+          AlarmNames: yield* Effect.forEach(
+            AlarmNames,
+            (alarmName) => alarmName,
+          ),
+        });
+      });
+    });
+  }),
+);
+
+export class EnableAlarmActionsPolicy extends Binding.Policy<
+  EnableAlarmActionsPolicy,
+  (...alarms: AlarmResources) => Effect.Effect<void>
+>()("AWS.CloudWatch.EnableAlarmActions") {}
+
+export const EnableAlarmActionsPolicyLive =
+  EnableAlarmActionsPolicy.layer.succeed(
+    Effect.fn(function* (host, ...alarms: AlarmResources) {
+      const sorted = sortAlarmResources(alarms);
+      if (isFunction(host)) {
+        yield* host.bind`Allow(${host}, AWS.CloudWatch.EnableAlarmActions(${sorted}))`(
+          {
+            policyStatements: [
+              {
+                Effect: "Allow",
+                Action: ["cloudwatch:EnableAlarmActions"],
+                Resource: sorted.map((alarm) => alarm.alarmArn),
+              },
+            ],
+          },
+        );
+      } else {
+        return yield* Effect.die(
+          `EnableAlarmActionsPolicy does not support runtime '${host.Type}'`,
+        );
+      }
+    }),
+  );

package/src/AWS/CloudWatch/GetAlarmMuteRule.ts

@@ -0,0 +1,75 @@
+import * as cloudwatch from "@distilled.cloud/aws/cloudwatch";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import type { AlarmMuteRule } from "./AlarmMuteRule.ts";
+
+export interface GetAlarmMuteRuleRequest extends Omit<
+  cloudwatch.GetAlarmMuteRuleInput,
+  "AlarmMuteRuleName"
+> {}
+
+/**
+ * Runtime binding for `cloudwatch:GetAlarmMuteRule`.
+ */
+export class GetAlarmMuteRule extends Binding.Service<
+  GetAlarmMuteRule,
+  (
+    rule: AlarmMuteRule,
+  ) => Effect.Effect<
+    (
+      request?: GetAlarmMuteRuleRequest,
+    ) => Effect.Effect<
+      cloudwatch.GetAlarmMuteRuleOutput,
+      cloudwatch.GetAlarmMuteRuleError
+    >
+  >
+>()("AWS.CloudWatch.GetAlarmMuteRule") {}
+
+export const GetAlarmMuteRuleLive = Layer.effect(
+  GetAlarmMuteRule,
+  Effect.gen(function* () {
+    const Policy = yield* GetAlarmMuteRulePolicy;
+    const getAlarmMuteRule = yield* cloudwatch.getAlarmMuteRule;
+
+    return Effect.fn(function* (rule: AlarmMuteRule) {
+      const AlarmMuteRuleName = yield* rule.alarmMuteRuleName;
+      yield* Policy(rule);
+
+      return Effect.fn(function* (request: GetAlarmMuteRuleRequest = {}) {
+        return yield* getAlarmMuteRule({
+          ...request,
+          AlarmMuteRuleName: yield* AlarmMuteRuleName,
+        });
+      });
+    });
+  }),
+);
+
+export class GetAlarmMuteRulePolicy extends Binding.Policy<
+  GetAlarmMuteRulePolicy,
+  (rule: AlarmMuteRule) => Effect.Effect<void>
+>()("AWS.CloudWatch.GetAlarmMuteRule") {}
+
+export const GetAlarmMuteRulePolicyLive = GetAlarmMuteRulePolicy.layer.succeed(
+  Effect.fn(function* (host, rule) {
+    if (isFunction(host)) {
+      yield* host.bind`Allow(${host}, AWS.CloudWatch.GetAlarmMuteRule(${rule}))`(
+        {
+          policyStatements: [
+            {
+              Effect: "Allow",
+              Action: ["cloudwatch:GetAlarmMuteRule"],
+              Resource: [rule.alarmMuteRuleArn],
+            },
+          ],
+        },
+      );
+    } else {
+      return yield* Effect.die(
+        `GetAlarmMuteRulePolicy does not support runtime '${host.Type}'`,
+      );
+    }
+  }),
+);

package/src/AWS/CloudWatch/GetDashboard.ts

@@ -0,0 +1,75 @@
+import * as cloudwatch from "@distilled.cloud/aws/cloudwatch";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import type { Dashboard } from "./Dashboard.ts";
+
+export interface GetDashboardRequest extends Omit<
+  cloudwatch.GetDashboardInput,
+  "DashboardName"
+> {}
+
+/**
+ * Runtime binding for `cloudwatch:GetDashboard`.
+ */
+export class GetDashboard extends Binding.Service<
+  GetDashboard,
+  (
+    dashboard: Dashboard,
+  ) => Effect.Effect<
+    (
+      request?: GetDashboardRequest,
+    ) => Effect.Effect<
+      cloudwatch.GetDashboardOutput,
+      cloudwatch.GetDashboardError
+    >
+  >
+>()("AWS.CloudWatch.GetDashboard") {}
+
+export const GetDashboardLive = Layer.effect(
+  GetDashboard,
+  Effect.gen(function* () {
+    const Policy = yield* GetDashboardPolicy;
+    const getDashboard = yield* cloudwatch.getDashboard;
+
+    return Effect.fn(function* (dashboard: Dashboard) {
+      const DashboardName = yield* dashboard.dashboardName;
+      yield* Policy(dashboard);
+
+      return Effect.fn(function* (request: GetDashboardRequest = {}) {
+        return yield* getDashboard({
+          ...request,
+          DashboardName: yield* DashboardName,
+        });
+      });
+    });
+  }),
+);
+
+export class GetDashboardPolicy extends Binding.Policy<
+  GetDashboardPolicy,
+  (dashboard: Dashboard) => Effect.Effect<void>
+>()("AWS.CloudWatch.GetDashboard") {}
+
+export const GetDashboardPolicyLive = GetDashboardPolicy.layer.succeed(
+  Effect.fn(function* (host, dashboard) {
+    if (isFunction(host)) {
+      yield* host.bind`Allow(${host}, AWS.CloudWatch.GetDashboard(${dashboard}))`(
+        {
+          policyStatements: [
+            {
+              Effect: "Allow",
+              Action: ["cloudwatch:GetDashboard"],
+              Resource: [dashboard.dashboardArn],
+            },
+          ],
+        },
+      );
+    } else {
+      return yield* Effect.die(
+        `GetDashboardPolicy does not support runtime '${host.Type}'`,
+      );
+    }
+  }),
+);

package/src/AWS/CloudWatch/GetInsightRuleReport.ts

@@ -0,0 +1,76 @@
+import * as cloudwatch from "@distilled.cloud/aws/cloudwatch";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import type { InsightRule } from "./InsightRule.ts";
+
+export interface GetInsightRuleReportRequest extends Omit<
+  cloudwatch.GetInsightRuleReportInput,
+  "RuleName"
+> {}
+
+/**
+ * Runtime binding for `cloudwatch:GetInsightRuleReport`.
+ */
+export class GetInsightRuleReport extends Binding.Service<
+  GetInsightRuleReport,
+  (
+    rule: InsightRule,
+  ) => Effect.Effect<
+    (
+      request: GetInsightRuleReportRequest,
+    ) => Effect.Effect<
+      cloudwatch.GetInsightRuleReportOutput,
+      cloudwatch.GetInsightRuleReportError
+    >
+  >
+>()("AWS.CloudWatch.GetInsightRuleReport") {}
+
+export const GetInsightRuleReportLive = Layer.effect(
+  GetInsightRuleReport,
+  Effect.gen(function* () {
+    const Policy = yield* GetInsightRuleReportPolicy;
+    const getInsightRuleReport = yield* cloudwatch.getInsightRuleReport;
+
+    return Effect.fn(function* (rule: InsightRule) {
+      const RuleName = yield* rule.ruleName;
+      yield* Policy(rule);
+
+      return Effect.fn(function* (request: GetInsightRuleReportRequest) {
+        return yield* getInsightRuleReport({
+          ...request,
+          RuleName: yield* RuleName,
+        });
+      });
+    });
+  }),
+);
+
+export class GetInsightRuleReportPolicy extends Binding.Policy<
+  GetInsightRuleReportPolicy,
+  (rule: InsightRule) => Effect.Effect<void>
+>()("AWS.CloudWatch.GetInsightRuleReport") {}
+
+export const GetInsightRuleReportPolicyLive =
+  GetInsightRuleReportPolicy.layer.succeed(
+    Effect.fn(function* (host, rule) {
+      if (isFunction(host)) {
+        yield* host.bind`Allow(${host}, AWS.CloudWatch.GetInsightRuleReport(${rule}))`(
+          {
+            policyStatements: [
+              {
+                Effect: "Allow",
+                Action: ["cloudwatch:GetInsightRuleReport"],
+                Resource: [rule.ruleArn],
+              },
+            ],
+          },
+        );
+      } else {
+        return yield* Effect.die(
+          `GetInsightRuleReportPolicy does not support runtime '${host.Type}'`,
+        );
+      }
+    }),
+  );