@sst-community/sst 4.21.1 → 5.0.0-alpha.2

package/platform/types/components/aws/open-search.d.ts

@@ -0,0 +1,306 @@
+import { ComponentResourceOptions, Output } from "@pulumi/pulumi";
+import { Component, Transform } from "../component";
+import { Link } from "../link";
+import { Input } from "../input.js";
+import { opensearch } from "@pulumi/aws";
+import { SizeGbTb } from "../size";
+export interface OpenSearchArgs {
+    /**
+     * The OpenSearch engine version. Check out the [available versions](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/what-is.html#choosing-version).
+     *
+     * :::caution
+     * Changing the version will cause the domain to restart on the next `sst deploy`,
+     * causing downtime. Learn more about [upgrading databases](/docs/upgrade-aws-databases/).
+     * :::
+     *
+     * @default `"OpenSearch_2.17"`
+     * @example
+     * ```js
+     * {
+     *   version: "OpenSearch_2.5"
+     * }
+     * ```
+     */
+    version?: Input<string>;
+    /**
+     * The username of the master user.
+     *
+     * :::danger
+     * Changing the username will cause the domain to be destroyed and recreated.
+     * :::
+     *
+     * @default `"admin"`
+     * @example
+     * ```js
+     * {
+     *   username: "admin"
+     * }
+     * ```
+     */
+    username?: Input<string>;
+    /**
+     * The password of the master user.
+     * @default A random password is generated.
+     * @example
+     * ```js
+     * {
+     *   password: "^Passw0rd^"
+     * }
+     * ```
+     *
+     * Use [Secrets](/docs/component/secret) to manage the password.
+     * ```js
+     * {
+     *   password: new sst.Secret("MyDomainPassword").value
+     * }
+     * ```
+     */
+    password?: Input<string>;
+    /**
+     * The type of instance to use for the domain. Check out the [supported instance types](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/supported-instance-types.html).
+     *
+     * :::caution
+     * Changing the instance type will cause the domain to restart on the next `sst deploy`,
+     * causing downtime. Learn more about [upgrading databases](/docs/upgrade-aws-databases/).
+     * :::
+     *
+     * @default `"t3.small"`
+     * @example
+     * ```js
+     * {
+     *   instance: "m6g.large"
+     * }
+     * ```
+     */
+    instance?: Input<string>;
+    /**
+     * The storage limit for the domain.
+     *
+     * @default `"10 GB"`
+     * @example
+     * ```js
+     * {
+     *   storage: "100 GB"
+     * }
+     * ```
+     */
+    storage?: Input<SizeGbTb>;
+    /**
+     * Configure how this component works in `sst dev`.
+     *
+     * By default, your OpenSearch domain is deployed in `sst dev`. But if you want to
+     * instead connect to a locally running OpenSearch, you can configure the `dev` prop.
+     *
+     * :::note
+     * By default, this creates a new OpenSearch domain even in `sst dev`.
+     * :::
+     *
+     * This will skip deploying an OpenSearch domain and link to the locally running
+     * OpenSearch process instead.
+     *
+     * @example
+     *
+     * Setting the `dev` prop also means that any linked resources will connect to the right
+     * instance both in `sst dev` and `sst deploy`.
+     *
+     * ```ts
+     * {
+     *   dev: {
+     *     username: "admin",
+     *     password: "Passw0rd!",
+     *     url: "http://localhost:9200"
+     *   }
+     * }
+     * ```
+     */
+    dev?: {
+        /**
+         * The URL of the local OpenSearch to connect to when running in dev.
+         * @default `"http://localhost:9200"`
+         */
+        url?: Input<string>;
+        /**
+         * The username of the local OpenSearch to connect to when running in dev.
+         * @default Inherit from the top-level [`username`](#username).
+         */
+        username?: Input<string>;
+        /**
+         * The password of the local OpenSearch to connect to when running in dev.
+         * @default Inherit from the top-level [`password`](#password).
+         */
+        password?: Input<string>;
+    };
+    /**
+     * [Transform](/docs/components#transform) how this component creates its underlying
+     * resources.
+     */
+    transform?: {
+        /**
+         * Transform the OpenSearch domain.
+         */
+        domain?: Transform<opensearch.DomainArgs>;
+        /**
+         * Transform the OpenSearch domain policy.
+         */
+        policy?: Transform<opensearch.DomainPolicyArgs>;
+    };
+}
+/**
+ * The `OpenSearch` component lets you add a deployed instance of OpenSearch, or an
+ * OpenSearch _domain_ to your app using [Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/what-is.html).
+ *
+ * @example
+ *
+ * #### Create the instance
+ *
+ * ```js title="sst.config.ts"
+ * const search = new sst.aws.OpenSearch("MySearch");
+ * ```
+ *
+ * #### Link to a resource
+ *
+ * You can link your instance to other resources, like a function or your Next.js app.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.Nextjs("MyWeb", {
+ *   link: [search]
+ * });
+ * ```
+ *
+ * Once linked, you can connect to it from your function code.
+ *
+ * ```ts title="app/page.tsx" {1,5-9}
+ * import { Resource } from "sst";
+ * import { Client } from "@opensearch-project/opensearch";
+ *
+ * const client = new Client({
+ *   node: Resource.MySearch.url,
+ *   auth: {
+ *     username: Resource.MySearch.username,
+ *     password: Resource.MySearch.password
+ *   }
+ * });
+ *
+ * // Add a document
+ * await client.index({
+ *   index: "my-index",
+ *   body: { message: "Hello world!" }
+ * });
+ *
+ * // Search for documents
+ * const result = await client.search({
+ *   index: "my-index",
+ *   body: { query: { match: { message: "world" } } }
+ * });
+ * ```
+ *
+ * #### Running locally
+ *
+ * By default, your OpenSearch domain is deployed in `sst dev`. But let's say you are
+ * running OpenSearch locally.
+ *
+ * ```bash
+ * docker run \
+ *   --rm \
+ *   -p 9200:9200 \
+ *   -v $(pwd)/.sst/storage/opensearch:/usr/share/opensearch/data \
+ *   -e discovery.type=single-node \
+ *   -e plugins.security.disabled=true \
+ *   -e OPENSEARCH_INITIAL_ADMIN_PASSWORD=^Passw0rd^ \
+ *   opensearchproject/opensearch:2.17.0
+ * ```
+ *
+ * You can connect to it in `sst dev` by configuring the `dev` prop.
+ *
+ * ```ts title="sst.config.ts" {3-5}
+ * const opensearch = new sst.aws.OpenSearch("MyOpenSearch", {
+ *   dev: {
+ *     url: "http://localhost:9200",
+ *     username: "admin",
+ *     password: "^Passw0rd^"
+ *   }
+ * });
+ * ```
+ *
+ * This will skip deploying an OpenSearch domain and link to the locally running
+ * OpenSearch process instead.
+ *
+ * ---
+ *
+ * ### Cost
+ *
+ * By default this component uses a _Single-AZ Deployment_, _On-Demand Instances_ of a
+ * `t3.small.search` at $0.036 per hour. And 10GB of _General Purpose gp3 Storage_
+ * at $0.122 per GB per month.
+ *
+ * That works out to $0.036 x 24 x 30 + $0.122 x 10 or **$27 per month**. Adjust this for
+ * the `instance` type and the `storage` you are using.
+ *
+ * The above are rough estimates for _us-east-1_, check out the [OpenSearch Service pricing](https://aws.amazon.com/opensearch-service/pricing/)
+ * for more details.
+ */
+export declare class OpenSearch extends Component implements Link.Linkable {
+    private domain?;
+    private _username?;
+    private _password?;
+    private dev?;
+    constructor(name: string, args?: OpenSearchArgs, opts?: ComponentResourceOptions);
+    /**
+     * The ID of the OpenSearch component.
+     */
+    get id(): Output<string>;
+    /** The username of the master user. */
+    get username(): Output<string>;
+    /** The password of the master user. */
+    get password(): Output<string>;
+    /**
+     * The endpoint of the domain.
+     */
+    get url(): Output<string>;
+    get nodes(): {
+        domain: import("@pulumi/aws/opensearch/domain").Domain | undefined;
+    };
+    /** @internal */
+    getSSTLink(): {
+        properties: {
+            username: Output<string>;
+            password: Output<string>;
+            url: Output<string>;
+        };
+    };
+    /**
+     * Reference an existing OpenSearch domain with the given name. This is useful when you
+     * create a domain in one stage and want to share it in another. It avoids
+     * having to create a new domain in the other stage.
+     *
+     * :::tip
+     * You can use the `static get` method to share OpenSearch domains across stages.
+     * :::
+     *
+     * @param name The name of the component.
+     * @param id The ID of the existing OpenSearch component.
+     * @param opts Resource options.
+     *
+     * @example
+     * Imagine you create a domain in the `dev` stage. And in your personal stage `frank`,
+     * instead of creating a new domain, you want to share the same domain from `dev`.
+     *
+     * ```ts title="sst.config.ts"
+     * const search = $app.stage === "frank"
+     *   ? sst.aws.OpenSearch.get("MyOpenSearch", "app-dev-myopensearch-efsmkrbt")
+     *   : new sst.aws.OpenSearch("MyOpenSearch");
+     * ```
+     *
+     * Here `app-dev-myopensearch-efsmkrbt` is the
+     * ID of the OpenSearch component created in the `dev` stage.
+     * You can find this by outputting the ID in the `dev` stage.
+     *
+     * ```ts title="sst.config.ts"
+     * return {
+     *   id: search.id
+     * };
+     * ```
+     */
+    static get(name: string, id: Input<string>, opts?: ComponentResourceOptions): OpenSearch;
+}
+//# sourceMappingURL=open-search.d.ts.map

package/platform/types/components/aws/open-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-search.d.ts","sourceRoot":"","sources":["../../../../src/components/aws/open-search.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EAGxB,MAAM,EAEP,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAU,SAAS,EAAE,SAAS,EAAa,MAAM,cAAc,CAAC;AACvE,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAO,UAAU,EAAkB,MAAM,aAAa,CAAC;AAG9D,OAAO,EAAE,QAAQ,EAAS,MAAM,SAAS,CAAC;AAG1C,MAAM,WAAW,cAAc;IAC7B;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACzB;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACzB;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACzB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,GAAG,CAAC,EAAE;QACJ;;;WAGG;QACH,GAAG,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QACpB;;;WAGG;QACH,QAAQ,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QACzB;;;WAGG;QACH,QAAQ,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;KAC1B,CAAC;IACF;;;OAGG;IACH,SAAS,CAAC,EAAE;QACV;;WAEG;QACH,MAAM,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;QAC1C;;WAEG;QACH,MAAM,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;KACjD,CAAC;CACH;AAOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6FG;AACH,qBAAa,UAAW,SAAQ,SAAU,YAAW,IAAI,CAAC,QAAQ;IAChE,OAAO,CAAC,MAAM,CAAC,CAAoB;IACnC,OAAO,CAAC,SAAS,CAAC,CAAiB;IACnC,OAAO,CAAC,SAAS,CAAC,CAAiB;IACnC,OAAO,CAAC,GAAG,CAAC,CAKV;gBAGA,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,cAAmB,EACzB,IAAI,GAAE,wBAA6B;IA2OrC;;OAEG;IACH,IAAW,EAAE,mBAGZ;IAED,uCAAuC;IACvC,IAAW,QAAQ,mBAGlB;IAED,uCAAuC;IACvC,IAAW,QAAQ,mBAGlB;IAED;;OAEG;IACH,IAAW,GAAG,mBAGb;IAED,IAAW,KAAK;;MAIf;IAED,gBAAgB;IACT,UAAU;;;;;;;IAUjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;WACW,GAAG,CACf,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,KAAK,CAAC,MAAM,CAAC,EACjB,IAAI,CAAC,EAAE,wBAAwB;CAWlC"}

package/platform/types/components/aws/opencontrol.d.ts

@@ -0,0 +1,169 @@
+import { ComponentResourceOptions, Output } from "@pulumi/pulumi";
+import { Component } from "../component";
+import { FunctionArgs, Function } from ".";
+import { Input } from "../input";
+export interface OpenControlArgs {
+    /**
+     * The function that's running your OpenControl server.
+     *
+     * @example
+     * ```js
+     * {
+     *   server: "src/server.handler"
+     * }
+     * ```
+     *
+     * You can also pass in the full `FunctionArgs`.
+     *
+     * ```js
+     * {
+     *   server: {
+     *     handler: "src/server.handler",
+     *     link: [table]
+     *   }
+     * }
+     * ```
+     *
+     * Since the `server` function is a Hono app, you want to export it with the Lambda adapter.
+     *
+     * ```ts title="src/server.ts"
+     * import { handle } from "hono/aws-lambda";
+     * import { create } from "opencontrol";
+     *
+     * const app = create({
+     *   // ...
+     * });
+     *
+     * export const handler = handle(app);
+     * ```
+     *
+     * Learn more in the [OpenControl docs](https://opencontrol.ai) on how to
+     * configure the `server` function.
+     */
+    server: Input<string | FunctionArgs>;
+}
+/**
+ * The `OpenControl` component has been deprecated. It should not be used for new projects.
+ *
+ * :::caution
+ * This component has been deprecated.
+ * :::
+ *
+ * The `OpenControl` component lets you deploy your
+ * [OpenControl](https://opencontrol.ai) server to
+ * [AWS Lambda](https://aws.amazon.com/lambda/).
+ *
+ * @deprecated Use OpenControl outside of SST instead.
+ *
+ * @example
+ *
+ * #### Create an OpenControl server
+ *
+ * ```ts title="sst.config.ts"
+ * const server = new sst.aws.OpenControl("MyServer", {
+ *   server: "src/server.handler"
+ * });
+ * ```
+ *
+ * #### Link your AI API keys
+ *
+ * ```ts title="sst.config.ts" {6}
+ * const anthropicKey = new sst.Secret("AnthropicKey");
+ *
+ * const server = new sst.aws.OpenControl("MyServer", {
+ *   server: {
+ *     handler: "src/server.handler",
+ *     link: [anthropicKey]
+ *   }
+ * });
+ * ```
+ *
+ * #### Link your resources
+ *
+ * If your tools are need access to specific resources, you can link them to the
+ * OpenControl server.
+ *
+ * ```ts title="sst.config.ts" {6}
+ * const bucket = new sst.aws.Bucket("MyBucket");
+ *
+ * new sst.aws.OpenControl("MyServer", {
+ *   server: {
+ *     handler: "src/server.handler",
+ *     link: [bucket]
+ *   }
+ * });
+ * ```
+ *
+ * #### Give AWS permissions
+ *
+ * If you are using the AWS tool within OpenControl, you will need to give
+ * your OpenControl server permissions to access your AWS account.
+ *
+ * ```ts title="sst.config.ts" {4-6}
+ * new sst.aws.OpenControl("OpenControl", {
+ *   server: {
+ *     handler: "src/server.handler",
+ *     policies: $dev
+ *       ? ["arn:aws:iam::aws:policy/AdministratorAccess"]
+ *       : ["arn:aws:iam::aws:policy/ReadOnlyAccess"]
+ *   }
+ * });
+ * ```
+ *
+ * Here we are giving it admin access in dev but read-only access in prod.
+ *
+ * #### Define your server
+ *
+ * Your `server` function might look like this.
+ *
+ * ```ts title="src/server.ts"
+ * import { Resource } from "sst";
+ * import { create } from "opencontrol";
+ * import { tool } from "opencontrol/tool";
+ * import { handle } from "hono/aws-lambda";
+ * import { createAnthropic } from "@ai-sdk/anthropic";
+ *
+ * const myTool = tool({
+ *   name: "my_tool",
+ *   description: "Get the most popular greeting",
+ *   async run() {
+ *     return "Hello, world!";
+ *   }
+ * });
+ *
+ * const app = create({
+ *   model: createAnthropic({
+ *     apiKey: Resource.AnthropicKey.value,
+ *   })("claude-3-7-sonnet-20250219"),
+ *   tools: [myTool],
+ * });
+ *
+ * export const handler = handle(app);
+ * ```
+ *
+ * Learn more in the [OpenControl docs](https://opencontrol.ai) on how to configure
+ * the `server` function.
+ */
+export declare class OpenControl extends Component {
+    private readonly _server;
+    private readonly _key;
+    constructor(name: string, args: OpenControlArgs, opts?: ComponentResourceOptions);
+    /**
+     * The URL of the OpenControl server.
+     */
+    get url(): Output<string>;
+    /**
+     * The password for the OpenControl server.
+     */
+    get password(): Output<string>;
+    /**
+     * The underlying [resources](/docs/components/#nodes) this component creates.
+     */
+    get nodes(): {
+        /**
+         * The Function component for the server.
+         */
+        server: Output<Function>;
+    };
+}
+//# sourceMappingURL=opencontrol.d.ts.map

package/platform/types/components/aws/opencontrol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencontrol.d.ts","sourceRoot":"","sources":["../../../../src/components/aws/opencontrol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,wBAAwB,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAEvE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC;AAE3C,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC,MAAM,WAAW,eAAe;IAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,YAAY,CAAC,CAAC;CACtC;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqGG;AACH,qBAAa,WAAY,SAAQ,SAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAiB;gBAGpC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,eAAe,EACrB,IAAI,CAAC,EAAE,wBAAwB;IAiDjC;;OAEG;IACH,IAAW,GAAG,mBAEb;IAED;;OAEG;IACH,IAAW,QAAQ,mBAElB;IAED;;OAEG;IACH,IAAW,KAAK;QAEZ;;WAEG;;MAGN;CACF"}

package/platform/types/components/aws/permission.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The AWS Permission Linkable helper is used to define the AWS permissions included with the
+ * [`sst.Linkable`](/docs/component/linkable/) component.
+ *
+ * @example
+ *
+ * ```ts
+ * sst.aws.permission({
+ *   actions: ["lambda:InvokeFunction"],
+ *   resources: ["*"]
+ * })
+ * ```
+ *
+ * @packageDocumentation
+ */
+import { Prettify } from "../component.js";
+import type { Input } from "../input.js";
+import { FunctionPermissionArgs } from "./function.js";
+export interface InputArgs extends Prettify<FunctionPermissionArgs> {
+}
+/**
+ * The AWS Permission Linkable helper is used to define the AWS permissions included with the
+ * [`sst.Linkable`](/docs/component/linkable/) component.
+ *
+ * @example
+ *
+ * ```ts
+ * sst.aws.permission({
+ *   actions: ["lambda:InvokeFunction"],
+ *   resources: ["*"]
+ * })
+ * ```
+ */
+export declare function permission(input: InputArgs): {
+    effect?: "allow" | "deny" | undefined;
+    actions: string[];
+    resources: Input<Input<string>[]>;
+    conditions?: Input<Input<{
+        test: Input<string>;
+        variable: Input<string>;
+        values: Input<Input<string>[]>;
+    }>[]> | undefined;
+    type: "aws.permission";
+};
+export type Permission = ReturnType<typeof permission>;
+/**
+ * The IAM statements that grant access to a list of linked resources.
+ *
+ * Functions, services and tasks get these through their `link` prop. Use this
+ * to grant the same access to compute you create yourself, like a role for an
+ * ECS task definition or a Batch job.
+ *
+ * @example
+ * ```ts title="sst.config.ts"
+ * const bucket = new sst.aws.Bucket("MyBucket");
+ * const queue = new sst.aws.Queue("MyQueue");
+ *
+ * new aws.iam.RolePolicy("MyJobLinks", {
+ *   role: role.name,
+ *   policy: aws.iam.getPolicyDocumentOutput({
+ *     statements: sst.aws.iamStatements([bucket, queue]),
+ *   }).json,
+ * });
+ * ```
+ *
+ * Pair it with `sst.Linkable.env()` so `Resource.MyBucket` works at runtime.
+ * An IAM policy needs at least one statement, so don't create the policy when
+ * the list of links can be empty.
+ */
+export declare function iamStatements(links: Input<any[]>): import("@pulumi/pulumi").Output<{
+    effect: string;
+    actions: string[];
+    resources: Input<Input<string>[]>;
+    conditions: Input<Input<{
+        test: Input<string>;
+        variable: Input<string>;
+        values: Input<Input<string>[]>;
+    }>[]> | undefined;
+}[]>;
+//# sourceMappingURL=permission.d.ts.map

package/platform/types/components/aws/permission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission.d.ts","sourceRoot":"","sources":["../../../../src/components/aws/permission.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAEvD,MAAM,WAAW,SAAU,SAAQ,QAAQ,CAAC,sBAAsB,CAAC;CAAG;AAEtE;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS;;;;;;;;;;EAK1C;AAED,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE,CAAC;;;;;;;;;KAUhD"}