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

package/platform/types/components/aws/v5/dynamo.d.ts

@@ -0,0 +1,328 @@
+import { ComponentResourceOptions } from "@pulumi/pulumi";
+import { V5Args } from "../../parts-component";
+import type { Input } from "../../input";
+import type { DynamoArgs as OriginalDynamoArgs, DynamoSubscriberArgs as OriginalDynamoSubscriberArgs } from "../dynamo";
+import type { FunctionArgs as OriginalFunctionArgs, FunctionArn } from "../function";
+import { Function } from "./function";
+declare const parts: () => {
+    /**
+     * The Amazon DynamoDB Table.
+     */
+    table: typeof import("@pulumi/aws/dynamodb/table").Table;
+    /**
+     * The functions subscribed to the table's stream, by subscriber name.
+     */
+    subscriber: import("../..").ManyPart<import("../..").DeferredPart<typeof Function>>;
+    /**
+     * The Lambda event source mappings that send the stream's records to each
+     * subscriber, by subscriber name.
+     */
+    eventSourceMapping: import("../..").ManyPart<typeof import("@pulumi/aws/lambda/eventSourceMapping").EventSourceMapping>;
+};
+export interface DynamoArgs extends V5Args<OriginalDynamoArgs, typeof parts> {
+}
+export interface DynamoSubscriberArgs extends Omit<OriginalDynamoSubscriberArgs, "transform"> {
+}
+declare const Dynamo_base: import("../..").ComponentClass<{
+    /**
+     * The Amazon DynamoDB Table.
+     */
+    table: typeof import("@pulumi/aws/dynamodb/table").Table;
+    /**
+     * The functions subscribed to the table's stream, by subscriber name.
+     */
+    subscriber: import("../..").ManyPart<import("../..").DeferredPart<typeof Function>>;
+    /**
+     * The Lambda event source mappings that send the stream's records to each
+     * subscriber, by subscriber name.
+     */
+    eventSourceMapping: import("../..").ManyPart<typeof import("@pulumi/aws/lambda/eventSourceMapping").EventSourceMapping>;
+}>;
+/**
+ * The `Dynamo` component lets you add an [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) table to your app.
+ *
+ * It takes the same args as [`sst.aws.Dynamo`](/docs/component/aws/dynamo). It's built
+ * from parts, so every resource it creates can be transformed, is available in `nodes`,
+ * and can be swapped for one you already have.
+ *
+ * @example
+ *
+ * #### Minimal example
+ *
+ * ```ts title="sst.config.ts"
+ * const table = new sst.aws.v5.Dynamo("MyTable", {
+ *   fields: {
+ *     userId: "string",
+ *     noteId: "string"
+ *   },
+ *   primaryIndex: { hashKey: "userId", rangeKey: "noteId" }
+ * });
+ * ```
+ *
+ * #### Add a global index
+ *
+ * ```ts {8-10} title="sst.config.ts"
+ * new sst.aws.v5.Dynamo("MyTable", {
+ *   fields: {
+ *     userId: "string",
+ *     noteId: "string",
+ *     createdAt: "number",
+ *   },
+ *   primaryIndex: { hashKey: "userId", rangeKey: "noteId" },
+ *   globalIndexes: {
+ *     CreatedAtIndex: { hashKey: "userId", rangeKey: "createdAt" }
+ *   }
+ * });
+ * ```
+ *
+ * #### Add a local index
+ *
+ * ```ts {8-10} title="sst.config.ts"
+ * new sst.aws.v5.Dynamo("MyTable", {
+ *   fields: {
+ *     userId: "string",
+ *     noteId: "string",
+ *     createdAt: "number",
+ *   },
+ *   primaryIndex: { hashKey: "userId", rangeKey: "noteId" },
+ *   localIndexes: {
+ *     CreatedAtIndex: { rangeKey: "createdAt" }
+ *   }
+ * });
+ * ```
+ *
+ * #### Subscribe to a DynamoDB Stream
+ *
+ * To subscribe to a [DynamoDB Stream](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html), start by enabling it.
+ *
+ * ```ts {7} title="sst.config.ts"
+ * const table = new sst.aws.v5.Dynamo("MyTable", {
+ *   fields: {
+ *     userId: "string",
+ *     noteId: "string"
+ *   },
+ *   primaryIndex: { hashKey: "userId", rangeKey: "noteId" },
+ *   stream: "new-and-old-images"
+ * });
+ * ```
+ *
+ * Then subscribe to it. Each subscriber has a name.
+ *
+ * ```ts title="sst.config.ts"
+ * table.subscribe("MySubscriber", "src/subscriber.handler");
+ * ```
+ *
+ * #### Link the table to a resource
+ *
+ * You can link the table to other resources, like a function or your Next.js app.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.Nextjs("MyWeb", {
+ *   link: [table]
+ * });
+ * ```
+ *
+ * Once linked, you can query the table through your app.
+ *
+ * ```ts title="app/page.tsx" {1,7}
+ * import { Resource } from "sst";
+ * import { DynamoDBClient, QueryCommand } from "@aws-sdk/client-dynamodb";
+ *
+ * const client = new DynamoDBClient();
+ *
+ * await client.send(new QueryCommand({
+ *   TableName: Resource.MyTable.name,
+ *   KeyConditionExpression: "userId = :userId",
+ *   ExpressionAttributeValues: {
+ *     ":userId": "my-user-id"
+ *   }
+ * }));
+ * ```
+ *
+ * #### Switch from `sst.aws.Dynamo`
+ *
+ * Change `sst.aws.Dynamo` to `sst.aws.v5.Dynamo` and keep the name. The table and the
+ * subscribers you've deployed are kept, as long as the subscribers have names.
+ *
+ * ```ts title="sst.config.ts" del={1} ins={2}
+ * const table = new sst.aws.Dynamo("MyTable", { fields, primaryIndex });
+ * const table = new sst.aws.v5.Dynamo("MyTable", { fields, primaryIndex });
+ * ```
+ *
+ * A few things are written differently:
+ *
+ * - `nodes.table` is the table, not an output of it.
+ * - A subscriber's resources are parts of the table. `subscribe()` returns the table, and
+ *   the subscriber's function and event source mapping are in `nodes.subscriber` and
+ *   `nodes.eventSourceMapping` under its name. To change how they're created, use the
+ *   table's `transform`.
+ * - Every subscriber has a name. One that was added without a name isn't kept: remove it
+ *   and deploy before you switch, then add it back with a name.
+ * - To subscribe to the stream of a table that isn't in your app, reference the table with
+ *   `get` and subscribe to that, in place of the static `subscribe`.
+ *
+ *   ```ts title="sst.config.ts" del={1} ins={2-4}
+ *   sst.aws.Dynamo.subscribe("MySubscriber", streamArn, "src/subscriber.handler");
+ *   sst.aws.v5.Dynamo
+ *     .get("Orders", "orders-table")
+ *     .subscribe("MySubscriber", "src/subscriber.handler");
+ *   ```
+ * - `get` gives its options to the component, so a `provider` or `parent` you pass it
+ *   applies to the table's subscribers too. `sst.aws.Dynamo.get` gave them to the table it
+ *   looked up and to nothing else. If you pass `get` a `provider` and subscribe to that
+ *   table, the subscriber is replaced on switch, to be created with that provider: remove
+ *   it and deploy before you switch, then add it back.
+ * - A `transform` function for the table is given the table's indexes, attributes and
+ *   stream settings as outputs. To replace one, set it; to change it, use `.apply()`.
+ *
+ * #### Use a table you already have
+ *
+ * Reference it by its name.
+ *
+ * ```ts title="sst.config.ts"
+ * const table = sst.aws.v5.Dynamo.get("MyTable", "app-dev-mytable");
+ * ```
+ */
+export declare class Dynamo extends Dynamo_base {
+    constructor(name: string, args: DynamoArgs, opts?: ComponentResourceOptions);
+    /**
+     * The ARN of the DynamoDB Table.
+     */
+    get arn(): import("@pulumi/pulumi").Output<string>;
+    /**
+     * The name of the DynamoDB Table.
+     */
+    get name(): import("@pulumi/pulumi").Output<string>;
+    private get streamArn();
+    /**
+     * Subscribe to the DynamoDB Stream of this table.
+     *
+     * :::note
+     * You'll first need to enable the `stream` before subscribing to it.
+     * :::
+     *
+     * @param name The name of the subscriber.
+     * @param subscriber The function that'll be notified.
+     * @param args Configure the subscription.
+     *
+     * @example
+     *
+     * ```js title="sst.config.ts"
+     * table.subscribe("MySubscriber", "src/subscriber.handler");
+     * ```
+     *
+     * Add a filter to the subscription.
+     *
+     * ```js title="sst.config.ts"
+     * table.subscribe("MySubscriber", "src/subscriber.handler", {
+     *   filters: [
+     *     {
+     *       dynamodb: {
+     *         Keys: {
+     *           CustomerName: {
+     *             S: ["AnyCompany Industries"]
+     *           }
+     *         }
+     *       }
+     *     }
+     *   ]
+     * });
+     * ```
+     *
+     * Customize the subscriber function.
+     *
+     * ```js title="sst.config.ts"
+     * table.subscribe("MySubscriber", {
+     *   handler: "src/subscriber.handler",
+     *   timeout: "60 seconds"
+     * });
+     * ```
+     *
+     * Or pass in the ARN of an existing Lambda function.
+     *
+     * ```js title="sst.config.ts"
+     * table.subscribe("MySubscriber", "arn:aws:lambda:us-east-1:123456789012:function:my-function");
+     * ```
+     *
+     * To change how one subscriber is created, use the table's `transform`. Its function
+     * form is given the subscriber's name.
+     *
+     * ```js title="sst.config.ts"
+     * new sst.aws.v5.Dynamo("MyTable", {
+     *   // ...
+     *   transform: {
+     *     eventSourceMapping: (args, opts, name, subscriber) => {
+     *       if (subscriber === "MySubscriber") args.startingPosition = "TRIM_HORIZON";
+     *     }
+     *   }
+     * });
+     * ```
+     */
+    subscribe(name: string, subscriber: Input<string | OriginalFunctionArgs | FunctionArn>, args?: DynamoSubscriberArgs): this;
+    /**
+     * Reference an existing DynamoDB Table with the given table name. This is useful when you
+     * create a table in one stage and want to share it in another stage, or to subscribe to
+     * the stream of a table that isn't in your app.
+     *
+     * :::tip
+     * You can use the `static get` method to share a table across stages.
+     * :::
+     *
+     * @param name The name of the component.
+     * @param tableName The name of the DynamoDB Table.
+     * @param opts Component resource options.
+     *
+     * @example
+     * Imagine you create a table in the `dev` stage. And in your personal stage `frank`,
+     * instead of creating a new table, you want to share the table from `dev`.
+     *
+     * ```ts title="sst.config.ts"
+     * const table = $app.stage === "frank"
+     *   ? sst.aws.v5.Dynamo.get("MyTable", "app-dev-mytable")
+     *   : new sst.aws.v5.Dynamo("MyTable", {
+     *       fields: { userId: "string" },
+     *       primaryIndex: { hashKey: "userId" }
+     *     });
+     * ```
+     *
+     * Here `app-dev-mytable` is the name of the DynamoDB Table created in the `dev` stage.
+     * You can find this by outputting the table name in the `dev` stage.
+     *
+     * ```ts title="sst.config.ts"
+     * return {
+     *   table: table.name
+     * };
+     * ```
+     *
+     * Subscribe to the stream of a table that isn't in your app.
+     *
+     * ```ts title="sst.config.ts"
+     * sst.aws.v5.Dynamo
+     *   .get("Orders", "orders-table")
+     *   .subscribe("MySubscriber", "src/subscriber.handler");
+     * ```
+     */
+    static get(name: string, tableName: Input<string>, opts?: ComponentResourceOptions): Dynamo;
+    /**
+     * Linking a table gives the linked resource the table's name and permission
+     * to use it.
+     */
+    link(): {
+        properties: {
+            name: import("@pulumi/pulumi").Output<string>;
+        };
+        include: {
+            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 {};
+//# sourceMappingURL=dynamo.d.ts.map

package/platform/types/components/aws/v5/dynamo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamo.d.ts","sourceRoot":"","sources":["../../../../../src/components/aws/v5/dynamo.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EAIzB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,MAAM,EAA6B,MAAM,uBAAuB,CAAC;AAE1E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,KAAK,EACV,UAAU,IAAI,kBAAkB,EAChC,oBAAoB,IAAI,4BAA4B,EACrD,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EACV,YAAY,IAAI,oBAAoB,EACpC,WAAW,EACZ,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAKtC,QAAA,MAAM,KAAK;IACT;;OAEG;;IAEH;;OAEG;;IAEH;;;OAGG;;CAEH,CAAC;AAEH,MAAM,WAAW,UAAW,SAAQ,MAAM,CAAC,kBAAkB,EAAE,OAAO,KAAK,CAAC;CAAG;AAE/E,MAAM,WAAW,oBACf,SAAQ,IAAI,CAAC,4BAA4B,EAAE,WAAW,CAAC;CAAG;;IAlB1D;;OAEG;;IAEH;;OAEG;;IAEH;;;OAGG;;;AAgBL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgJG;AACH,qBAAa,MAAO,SAAQ,WAAkC;gBAE1D,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU,EAChB,IAAI,CAAC,EAAE,wBAAwB;IA+CjC;;OAEG;IACH,IAAW,GAAG,4CAEb;IAED;;OAEG;IACH,IAAW,IAAI,4CAEd;IAGD,OAAO,KAAK,SAAS,GAWpB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+DG;IACI,SAAS,CACd,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,KAAK,CAAC,MAAM,GAAG,oBAAoB,GAAG,WAAW,CAAC,EAC9D,IAAI,GAAE,oBAAyB;IAoCjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;WACW,GAAG,CACf,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,EACxB,IAAI,CAAC,EAAE,wBAAwB;IASjC;;;OAGG;IACI,IAAI;;;;;;;;;;;;;;;;CAWZ"}

package/platform/types/components/aws/v5/efs.d.ts

@@ -0,0 +1,178 @@
+import { ComponentResourceOptions, type Output } from "@pulumi/pulumi";
+import { V5Args } from "../../parts-component";
+import type { Input } from "../../input";
+import { type TakesVpc } from "../helpers/vpc";
+import type { EfsArgs as OriginalEfsArgs } from "../efs";
+declare const parts: {
+    /**
+     * The Amazon EFS file system.
+     */
+    fileSystem: typeof import("@pulumi/aws/efs/fileSystem").FileSystem;
+    /**
+     * The security group of the mount targets. It lets in traffic from inside the VPC.
+     */
+    securityGroup: typeof import("@pulumi/aws/ec2/securityGroup").SecurityGroup;
+    /**
+     * The mount targets of the file system, by the id of the subnet each one is in.
+     * They're added once the subnets are known.
+     */
+    mountTarget: import("../..").ManyPart<typeof import("@pulumi/aws/efs/mountTarget").MountTarget>;
+    /**
+     * The Amazon EFS access point.
+     */
+    accessPoint: typeof import("@pulumi/aws/efs/accessPoint").AccessPoint;
+};
+export interface EfsArgs extends V5Args<TakesVpc<OriginalEfsArgs>, typeof parts> {
+}
+declare const Efs_base: import("../..").ComponentClass<{
+    /**
+     * The Amazon EFS file system.
+     */
+    fileSystem: typeof import("@pulumi/aws/efs/fileSystem").FileSystem;
+    /**
+     * The security group of the mount targets. It lets in traffic from inside the VPC.
+     */
+    securityGroup: typeof import("@pulumi/aws/ec2/securityGroup").SecurityGroup;
+    /**
+     * The mount targets of the file system, by the id of the subnet each one is in.
+     * They're added once the subnets are known.
+     */
+    mountTarget: import("../..").ManyPart<typeof import("@pulumi/aws/efs/mountTarget").MountTarget>;
+    /**
+     * The Amazon EFS access point.
+     */
+    accessPoint: typeof import("@pulumi/aws/efs/accessPoint").AccessPoint;
+}>;
+/**
+ * The `Efs` component lets you add [Amazon Elastic File System (EFS)](https://docs.aws.amazon.com/efs/latest/ug/whatisefs.html) to your app.
+ *
+ * It takes the same args as [`sst.aws.Efs`](/docs/component/aws/efs) and creates the same
+ * resources. It's built from parts, so every resource it creates can be transformed, is
+ * available in `nodes`, and can be swapped for one you already have.
+ *
+ * @example
+ *
+ * #### Create the file system
+ *
+ * ```js title="sst.config.ts" {2}
+ * const vpc = new sst.aws.Vpc("MyVpc");
+ * const efs = new sst.aws.v5.Efs("MyEfs", { vpc });
+ * ```
+ *
+ * This needs a VPC.
+ *
+ * #### Attach it to a Lambda function
+ *
+ * ```ts title="sst.config.ts" {4}
+ * new sst.aws.v5.Function("MyFunction", {
+ *   vpc,
+ *   handler: "lambda.handler",
+ *   volume: { efs, path: "/mnt/efs" }
+ * });
+ * ```
+ *
+ * This is now mounted at `/mnt/efs` in the Lambda function.
+ *
+ * #### Attach it to a container
+ *
+ * ```ts title="sst.config.ts" {4-6}
+ * const cluster = new sst.aws.v5.Cluster("MyCluster", { vpc });
+ * new sst.aws.v5.Service("MyService", {
+ *   cluster,
+ *   volumes: [
+ *     { efs, path: "/mnt/efs" }
+ *   ]
+ * });
+ * ```
+ *
+ * Mounted at `/mnt/efs` in the container.
+ *
+ * #### Switch from `sst.aws.Efs`
+ *
+ * Change `sst.aws.Efs` to `sst.aws.v5.Efs` and keep the name. The file system, its mount
+ * targets, their security group and the access point are kept.
+ *
+ * ```ts title="sst.config.ts" del={1} ins={2}
+ * const efs = new sst.aws.Efs("MyEfs", { vpc });
+ * const efs = new sst.aws.v5.Efs("MyEfs", { vpc });
+ * ```
+ *
+ * A few things work differently:
+ *
+ * - Switch what mounts the file system first, or along with it. A `sst.aws.v5.Function`,
+ *   `sst.aws.v5.Service` and `sst.aws.v5.Task` take either one. A
+ *   [`sst.aws.Function`](/docs/component/aws/function),
+ *   [`sst.aws.Service`](/docs/component/aws/service) and
+ *   [`sst.aws.Task`](/docs/component/aws/task) only know `sst.aws.Efs`.
+ * - `nodes.fileSystem` and `nodes.accessPoint` are the resources, not outputs of them.
+ *   `nodes` also has the security group, and the mount targets by subnet id.
+ * - The mount targets can be transformed. A transform function is also given the id
+ *   of the subnet.
+ * - A file system from `get` is looked up inside the component, with its access point.
+ *   `sst.aws.Efs.get` looked them up at the top of the app, so a deploy drops those two
+ *   lookups from its state and reads the same resources again.
+ * - If you set part of the access point's `posixUser` or `rootDirectory` with an object
+ *   in `transform`, the rest of it is kept.
+ *
+ * ---
+ *
+ * ### Cost
+ *
+ * By default this component uses _Regional (Multi-AZ) with Elastic Throughput_. The pricing is
+ * pay-per-use.
+ *
+ * - For storage: $0.30 per GB per month
+ * - For reads: $0.03 per GB per month
+ * - For writes: $0.06 per GB per month
+ *
+ * The above are rough estimates for _us-east-1_, check out the
+ * [EFS pricing](https://aws.amazon.com/efs/pricing/) for more details.
+ */
+export declare class Efs extends Efs_base {
+    private mounted;
+    constructor(name: string, args: EfsArgs, opts?: ComponentResourceOptions);
+    /**
+     * The ID of the EFS file system.
+     */
+    get id(): Output<string>;
+    /**
+     * The ID of the EFS access point.
+     */
+    get accessPoint(): Output<string>;
+    /**
+     * Reference an existing EFS file system with the given file system ID. This is useful when
+     * you create a EFS file system in one stage and want to share it in another. It avoids
+     * having to create a new EFS file system in the other stage.
+     *
+     * :::tip
+     * You can use the `static get` method to share EFS file systems across stages.
+     * :::
+     *
+     * @param name The name of the component.
+     * @param fileSystemID The ID of the existing EFS file system.
+     * @param opts Resource options.
+     *
+     * @example
+     * Imagine you create a EFS file system in the `dev` stage. And in your personal stage
+     * `frank`, instead of creating a new file system, you want to share the same file system
+     * from `dev`.
+     *
+     * ```ts title="sst.config.ts"
+     * const efs = $app.stage === "frank"
+     *   ? sst.aws.v5.Efs.get("MyEfs", "app-dev-myefs")
+     *   : new sst.aws.v5.Efs("MyEfs", { vpc });
+     * ```
+     *
+     * Here `app-dev-myefs` is the ID of the file system created in the `dev` stage.
+     * You can find this by outputting the file system ID in the `dev` stage.
+     *
+     * ```ts title="sst.config.ts"
+     * return {
+     *   id: efs.id
+     * };
+     * ```
+     */
+    static get(name: string, fileSystemID: Input<string>, opts?: ComponentResourceOptions): Efs;
+}
+export {};
+//# sourceMappingURL=efs.d.ts.map

package/platform/types/components/aws/v5/efs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"efs.d.ts","sourceRoot":"","sources":["../../../../../src/components/aws/v5/efs.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,wBAAwB,EACxB,KAAK,MAAM,EAEZ,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,MAAM,EAAmB,MAAM,uBAAuB,CAAC;AAGhE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,KAAK,QAAQ,EAAS,MAAM,gBAAgB,CAAC;AACtD,OAAO,KAAK,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,QAAQ,CAAC;AAEzD,QAAA,MAAM,KAAK;IACT;;OAEG;;IAEH;;OAEG;;IAEH;;;OAGG;;IAEH;;OAEG;;CAEJ,CAAC;AAEF,MAAM,WAAW,OACf,SAAQ,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,KAAK,CAAC;CAAG;;IApB1D;;OAEG;;IAEH;;OAEG;;IAEH;;;OAGG;;IAEH;;OAEG;;;AAOL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoFG;AACH,qBAAa,GAAI,SAAQ,QAA+B;IAGtD,OAAO,CAAC,OAAO,CAAsD;gBAEzD,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,wBAAwB;IA6HxE;;OAEG;IACH,IAAW,EAAE,mBAEZ;IAED;;OAEG;IACH,IAAW,WAAW,mBAErB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;WACW,GAAG,CACf,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,KAAK,CAAC,MAAM,CAAC,EAC3B,IAAI,CAAC,EAAE,wBAAwB;CAQlC"}