@sst-community/sst 4.20.0 → 5.0.0-alpha.1

package/platform/types/components/aws/static-site.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-site.d.ts","sourceRoot":"","sources":["../../../../src/components/aws/static-site.ts"],"names":[],"mappings":"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"}

package/platform/types/components/aws/step-functions/choice.d.ts

@@ -0,0 +1,73 @@
+import { JSONata, State, StateArgs } from "./state";
+export interface ChoiceArgs extends StateArgs {
+}
+/**
+ * The `Choice` state is internally used by the `StepFunctions` component to add a [Choice
+ * workflow state](https://docs.aws.amazon.com/step-functions/latest/dg/state-choice.html)
+ * to a state machine.
+ *
+ * :::note
+ * This component is not intended to be created directly.
+ * :::
+ *
+ * You'll find this component returned by the `choice` method of the `StepFunctions` component.
+ */
+export declare class Choice extends State {
+    protected args: ChoiceArgs;
+    private choices;
+    private defaultNext?;
+    constructor(args: ChoiceArgs);
+    /**
+     * Add a matching condition to the `Choice` state. If the given condition matches,
+     * it'll continue execution to the given state.
+     *
+     * The condition needs to be a JSONata expression that evaluates to a boolean.
+     *
+     * @example
+     *
+     * ```ts
+     * sst.aws.StepFunctions.choice({
+     *   // ...
+     * })
+     * .when(
+     *   "{% $states.input.status === 'unpaid' %}",
+     *   state
+     * );
+     * ```
+     *
+     * @param condition The JSONata condition to evaluate.
+     * @param next The state to transition to.
+     */
+    when(condition: JSONata, next: State): this;
+    /**
+     * Add a default next state to the `Choice` state. If no other condition matches,
+     * continue execution with the given state.
+     */
+    otherwise(next: State): this;
+    /**
+     * @internal
+     */
+    assertStateNameUnique(states?: Map<string, State>): void;
+    /**
+     * @internal
+     */
+    assertStateNotReused(states?: Map<State, string>, graphId?: string): void;
+    /**
+     * @internal
+     */
+    getPermissions(): import("..").FunctionPermissionArgs[];
+    /**
+     * @internal
+     */
+    serialize(): {};
+    protected toJSON(): {
+        End: undefined;
+        Type: string;
+        Choices: {
+            Condition: `{% ${string} %}`;
+            Next: string;
+        }[];
+        Default: string | undefined;
+    };
+}
+//# sourceMappingURL=choice.d.ts.map

package/platform/types/components/aws/step-functions/choice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"choice.d.ts","sourceRoot":"","sources":["../../../../../src/components/aws/step-functions/choice.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAE/D,MAAM,WAAW,UAAW,SAAQ,SAAS;CAAI;AAEjD;;;;;;;;;;GAUG;AACH,qBAAa,MAAO,SAAQ,KAAK;IAOnB,SAAS,CAAC,IAAI,EAAE,UAAU;IANtC,OAAO,CAAC,OAAO,CAGN;IACT,OAAO,CAAC,WAAW,CAAC,CAAQ;gBAEN,IAAI,EAAE,UAAU;IAItC;;;;;;;;;;;;;;;;;;;;OAoBG;IACI,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK;IAQ3C;;;OAGG;IACI,SAAS,CAAC,IAAI,EAAE,KAAK;IAK5B;;OAEG;IACI,qBAAqB,CAAC,MAAM,GAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAa;IAMnE;;OAEG;IACI,oBAAoB,CACzB,MAAM,GAAE,GAAG,CAAC,KAAK,EAAE,MAAM,CAAa,EACtC,OAAO,GAAE,MAAe;IAO1B;;OAEG;IACI,cAAc;IAQrB;;OAEG;IACI,SAAS;IAWhB,SAAS,CAAC,MAAM;;;;;;;;;CAYjB"}

package/platform/types/components/aws/step-functions/fail.d.ts

@@ -0,0 +1,63 @@
+import { Input } from "../../input";
+import { State, StateArgs } from "./state";
+export interface FailArgs extends StateArgs {
+    /**
+     * A custom string that describes the cause of the error.
+     *
+     * ```ts
+     * {
+     *   cause: "User not found"
+     * }
+     * ```
+     *
+     * Alternatively, you can specify a JSONata expression that evaluates to a string.
+     *
+     * ```ts
+     * {
+     *   cause: "{% $states.input.user %}"
+     * }
+     * ```
+     */
+    cause?: Input<string>;
+    /**
+     * An error name that you can provide to perform error handling using `retry` or
+     * `catch`.
+     * ```ts
+     * {
+     *   error: "UserNotFound"
+     * }
+     * ```
+     * Alternatively, you can specify a JSONata expression that evaluates to a string.
+     * ```ts
+     * {
+     *   error: "{% $states.input.error %}"
+     * }
+     * ```
+     */
+    error?: Input<string>;
+}
+/**
+ * The `Fail` state is internally used by the `StepFunctions` component to add a
+ * [Fail workflow state](https://docs.aws.amazon.com/step-functions/latest/dg/state-fail.html)
+ * to a state machine.
+ *
+ * :::note
+ * This component is not intended to be created directly.
+ * :::
+ *
+ * You'll find this component returned by the `fail` method of the `StepFunctions` component.
+ */
+export declare class Fail extends State {
+    protected args: FailArgs;
+    constructor(args: FailArgs);
+    /**
+     * Serialize the state into JSON state definition.
+     */
+    protected toJSON(): {
+        End: undefined;
+        Type: string;
+        Error: Input<string> | undefined;
+        Cause: Input<string> | undefined;
+    };
+}
+//# sourceMappingURL=fail.d.ts.map

package/platform/types/components/aws/step-functions/fail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fail.d.ts","sourceRoot":"","sources":["../../../../../src/components/aws/step-functions/fail.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAE3C,MAAM,WAAW,QAAS,SAAQ,SAAS;IACzC;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACtB;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACvB;AAED;;;;;;;;;;GAUG;AACH,qBAAa,IAAK,SAAQ,KAAK;IACjB,SAAS,CAAC,IAAI,EAAE,QAAQ;gBAAd,IAAI,EAAE,QAAQ;IAIpC;;OAEG;IACH,SAAS,CAAC,MAAM;;;;;;CASjB"}

package/platform/types/components/aws/step-functions/map.d.ts

@@ -0,0 +1,236 @@
+import { Output } from "@pulumi/pulumi";
+import { Input } from "../../input";
+import { CatchArgs, Failable, JSONata, Nextable, RetryArgs, State, StateArgs } from "./state";
+export interface MapArgs extends StateArgs {
+    /**
+     * The processing mode for the `Map` state.
+     *
+     * The `inline` mode is the default and has limited concurrency. In this mode, each item
+     * in the `Map` state runs as a part of the current workflow.
+     *
+     * The `standard` and `express` mode have high concurrency. In these mode, each item in
+     * the `Map` state runs as a child workflow. This enables high concurrency of up to 10,000
+     * parallel child workflows. Each child workflow has its own, separate execution history.
+     * - In `standard` mode, each child runs as a StepFunctions Standard workflow.
+     * - In `express` mode, each child runs as a StepFunctions Express workflow.
+     *
+     * :::note
+     * `Map` state with `standard` or `express` mode is not supported in `express` type StepFunctions.
+     * :::
+     *
+     * @default `"inline"`
+     * @example
+     * ```js
+     * {
+     *   type: "express"
+     * }
+     * ```
+     */
+    mode?: Input<"inline" | "standard" | "express">;
+    /**
+     * The list of items to process.
+     *
+     * @example
+     * For example, you can specify an array of items.
+     *
+     * ```ts
+     * {
+     *   items: ["item1", "item2", "item3"]
+     * }
+     * ```
+     *
+     * Or, specify a JSONata expression that evaluates to an array of items.
+     *
+     * ```ts
+     * {
+     *   items: "{% $states.input.items %}"
+     * }
+     * ```
+     */
+    items?: Input<JSONata | any[]>;
+    /**
+     * Reformat the values of the input array items before they're passed on to each
+     * state iteration.
+     *
+     * For example, you can pass in what you want the fields to be.
+     *
+     * ```ts
+     * {
+     *   "itemSelector": {
+     *     "size": 10,
+     *     "value.$": "$$.Map.Item.Value"
+     *   }
+     * }
+     * ```
+     *
+     * When applied to the following list of items.
+     *
+     * ```ts
+     * [
+     *   {
+     *     "resize": "true",
+     *     "format": "jpg"
+     *   },
+     *   {
+     *     "resize": "false",
+     *     "format": "png"
+     *   }
+     * ]
+     * ```
+     *
+     * A transformed item will look like.
+     *
+     * ```ts
+     * {
+     *   "size": 10,
+     *   "value": {
+     *     "resize": "true",
+     *     "format": "jpg"
+     *   }
+     * }
+     * ```
+     *
+     * Learn more about [`ItemSelector`](https://docs.aws.amazon.com/step-functions/latest/dg/input-output-itemselector.html).
+     */
+    itemSelector?: Input<Record<string, Input<any>>>;
+    /**
+     * An upper bound on the number of `Map` state iterations that can run in parallel.
+     * Takes an integer or a JSONata expression that evaluates to an integer.
+     *
+     * Default to 0, which means there's no limit on the concurrency.
+     *
+     * @default `0`
+     * @example
+     * For example, to limit it to 10 concurrent iterations.
+     * ```ts
+     * {
+     *   maxConcurrency: 10
+     * }
+     * ```
+     */
+    maxConcurrency?: Input<JSONata | number>;
+    /**
+     * The state to execute for each item in the array.
+     *
+     * @example
+     *
+     * For example, to iterate over an array of items and execute a Lambda function
+     * for each item.
+     *
+     * ```ts title="sst.config.ts"
+     * const processor = sst.aws.StepFunctions.lambdaInvoke({
+     *   name: "Processor",
+     *   function: "src/processor.handler"
+     * });
+     *
+     * sst.aws.StepFunctions.map({
+     *   processor,
+     *   name: "Map",
+     *   items: "{% $states.input.items %}"
+     * });
+     * ```
+     */
+    processor: State;
+}
+/**
+ * The `Map` state is internally used by the `StepFunctions` component to add a [Map
+ * workflow state](https://docs.aws.amazon.com/step-functions/latest/dg/state-map.html)
+ * to a state machine.
+ *
+ * :::note
+ * This component is not intended to be created directly.
+ * :::
+ *
+ * You'll find this component returned by the `map` method of the `StepFunctions` component.
+ */
+export declare class Map extends State implements Nextable, Failable {
+    protected args: MapArgs;
+    private processor;
+    private mode;
+    constructor(args: MapArgs);
+    /**
+     * Add a next state to the `Map` state. If the state completes successfully,
+     * continue execution to the given `state`.
+     *
+     * @param state The state to transition to.
+     *
+     * @example
+     *
+     * ```ts title="sst.config.ts"
+     * sst.aws.StepFunctions.map({
+     *   // ...
+     * })
+     * .next(state);
+     * ```
+     */
+    next<T extends State>(state: T): T;
+    /**
+     * Add a retry behavior to the `Map` state. If the state fails with any of the
+     * specified errors, retry the execution.
+     *
+     * @param args Properties to define the retry behavior.
+     *
+     * @example
+     *
+     * This defaults to.
+     *
+     * ```ts title="sst.config.ts" {5-8}
+     * sst.aws.StepFunctions.map({
+     *   // ...
+     * })
+     * .retry({
+     *   errors: ["States.ALL"],
+     *   interval: "1 second",
+     *   maxAttempts: 3,
+     *   backoffRate: 2
+     * });
+     * ```
+     */
+    retry(args?: RetryArgs): this;
+    /**
+     * Add a catch behavior to the `Map` state. So if the state fails with any of the
+     * specified errors, it'll continue execution to the given `state`.
+     *
+     * @param state The state to transition to on error.
+     * @param args Properties to customize error handling.
+     *
+     * @example
+     *
+     * This defaults to.
+     *
+     * ```ts title="sst.config.ts" {5}
+     * sst.aws.StepFunctions.map({
+     *   // ...
+     * })
+     * .catch({
+     *   errors: ["States.ALL"]
+     * });
+     * ```
+     */
+    catch(state: State, args?: CatchArgs): this;
+    /**
+     * @internal
+     */
+    getPermissions(): import("..").FunctionPermissionArgs[];
+    /**
+     * Serialize the state into JSON state definition.
+     */
+    protected toJSON(): {
+        Type: string;
+        Items: Input<any[] | `{% ${string} %}`> | undefined;
+        ItemSelector: Input<Record<string, any>> | undefined;
+        ItemProcessor: {
+            ProcessorConfig: Output<{
+                Mode: string;
+                ExecutionType?: undefined;
+            } | {
+                Mode: string;
+                ExecutionType: string;
+            }>;
+            StartAt: string;
+            States: Record<string, any>;
+        };
+        MaxConcurrency: Input<number | `{% ${string} %}`> | undefined;
+    };
+}
+//# sourceMappingURL=map.d.ts.map

package/platform/types/components/aws/step-functions/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../../../../src/components/aws/step-functions/map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAU,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EACL,SAAS,EACT,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,SAAS,EACT,KAAK,EACL,SAAS,EACV,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,OAAQ,SAAQ,SAAS;IACxC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,IAAI,CAAC,EAAE,KAAK,CAAC,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC,CAAC;IAChD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC,OAAO,GAAG,GAAG,EAAE,CAAC,CAAC;IAC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,YAAY,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IACjD;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,EAAE,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC,CAAC;IACzC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,SAAS,EAAE,KAAK,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,qBAAa,GAAI,SAAQ,KAAM,YAAW,QAAQ,EAAE,QAAQ;IAI9C,SAAS,CAAC,IAAI,EAAE,OAAO;IAHnC,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,IAAI,CAA4C;gBAElC,IAAI,EAAE,OAAO;IAOnC;;;;;;;;;;;;;;OAcG;IACI,IAAI,CAAC,CAAC,SAAS,KAAK,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC;IAIzC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACI,KAAK,CAAC,IAAI,CAAC,EAAE,SAAS;IAI7B;;;;;;;;;;;;;;;;;;;OAmBG;IACI,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,GAAE,SAAc;IAI/C;;OAEG;IACI,cAAc;IAIrB;;OAEG;IACH,SAAS,CAAC,MAAM;;;;;;;;;;;;;;;;;CAkBjB"}

package/platform/types/components/aws/step-functions/parallel.d.ts

@@ -0,0 +1,127 @@
+import { Input } from "../../input";
+import { CatchArgs, Failable, Nextable, RetryArgs, State, StateArgs } from "./state";
+export interface ParallelArgs extends StateArgs {
+    /**
+     * The arguments to be passed to the APIs of the connected resources. Values can
+     * include outputs from other resources and JSONata expressions.
+     *
+     * @example
+     *
+     * ```ts
+     * {
+     *   arguments: {
+     *     product: "{% $states.input.order.product %}",
+     *     url: api.url,
+     *     count: 32
+     *   }
+     * }
+     * ```
+     */
+    arguments?: Input<Record<string, Input<any>>>;
+}
+/**
+ * The `Parallel` state is internally used by the `StepFunctions` component to add a [Parallel
+ * workflow state](https://docs.aws.amazon.com/step-functions/latest/dg/state-parallel.html)
+ * to a state machine.
+ *
+ * :::note
+ * This component is not intended to be created directly.
+ * :::
+ *
+ * You'll find this component returned by the `parallel` method of the `StepFunctions` component.
+ */
+export declare class Parallel extends State implements Nextable, Failable {
+    protected args: ParallelArgs;
+    private branches;
+    constructor(args: ParallelArgs);
+    /**
+     * Add a branch state to the `Parallel` state. Each branch runs concurrently.
+     *
+     * @param branch The state to add as a branch.
+     *
+     * @example
+     *
+     * ```ts title="sst.config.ts"
+     * const parallel = sst.aws.StepFunctions.parallel({ name: "Parallel" });
+     *
+     * parallel.branch(processorA);
+     * parallel.branch(processorB);
+     * ```
+     */
+    branch(branch: State): this;
+    /**
+     * Add a next state to the `Parallel` state. If all branches complete successfully,
+     * this'll continue execution to the given `state`.
+     *
+     * @param state The state to transition to.
+     *
+     * @example
+     *
+     * ```ts title="sst.config.ts"
+     * sst.aws.StepFunctions.parallel({
+     *   // ...
+     * })
+     * .next(state);
+     * ```
+     */
+    next<T extends State>(state: T): T;
+    /**
+     * Add a retry behavior to the `Parallel` state. If the state fails with any of the
+     * specified errors, retry execution using the specified parameters.
+     *
+     * @param args Properties to define the retry behavior.
+     *
+     * @example
+     *
+     * This defaults to.
+     *
+     * ```ts title="sst.config.ts" {5-8}
+     * sst.aws.StepFunctions.parallel({
+     *   // ...
+     * })
+     * .retry({
+     *   errors: ["States.ALL"],
+     *   interval: "1 second",
+     *   maxAttempts: 3,
+     *   backoffRate: 2
+     * });
+     * ```
+     */
+    retry(args?: RetryArgs): this;
+    /**
+     * Add a catch behavior to the `Parallel` state. So if the state fails with any
+     * of the specified errors, it'll continue execution to the given `state`.
+     *
+     * @param state The state to transition to on error.
+     * @param args Properties to customize error handling.
+     *
+     * @example
+     *
+     * This defaults to.
+     *
+     * ```ts title="sst.config.ts" {5}
+     * sst.aws.StepFunctions.parallel({
+     *   // ...
+     * })
+     * .catch({
+     *   errors: ["States.ALL"]
+     * });
+     * ```
+     */
+    catch(state: State, args?: CatchArgs): this;
+    /**
+     * @internal
+     */
+    getPermissions(): import("..").FunctionPermissionArgs[];
+    /**
+     * Serialize the state into JSON state definition.
+     */
+    protected toJSON(): {
+        Type: string;
+        Branches: {
+            StartAt: string;
+            States: Record<string, any>;
+        }[];
+    };
+}
+//# sourceMappingURL=parallel.d.ts.map

package/platform/types/components/aws/step-functions/parallel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel.d.ts","sourceRoot":"","sources":["../../../../../src/components/aws/step-functions/parallel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EACL,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,KAAK,EACL,SAAS,EACV,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,YAAa,SAAQ,SAAS;IAC7C;;;;;;;;;;;;;;;OAeG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,qBAAa,QAAS,SAAQ,KAAM,YAAW,QAAQ,EAAE,QAAQ;IAGnD,SAAS,CAAC,IAAI,EAAE,YAAY;IAFxC,OAAO,CAAC,QAAQ,CAAe;gBAET,IAAI,EAAE,YAAY;IAIxC;;;;;;;;;;;;;OAaG;IACI,MAAM,CAAC,MAAM,EAAE,KAAK;IAO3B;;;;;;;;;;;;;;OAcG;IACI,IAAI,CAAC,CAAC,SAAS,KAAK,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC;IAIzC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACI,KAAK,CAAC,IAAI,CAAC,EAAE,SAAS;IAI7B;;;;;;;;;;;;;;;;;;;OAmBG;IACI,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,GAAE,SAAc;IAI/C;;OAEG;IACI,cAAc;IAOrB;;OAEG;IACH,SAAS,CAAC,MAAM;;;;;;;CAkBjB"}

package/platform/types/components/aws/step-functions/pass.d.ts

@@ -0,0 +1,39 @@
+import { Nextable, State, StateArgs } from "./state";
+export interface PassArgs extends StateArgs {
+}
+/**
+ * The `Pass` state is internally used by the `StepFunctions` component to add a [Pass
+ * workflow state](https://docs.aws.amazon.com/step-functions/latest/dg/state-pass.html)
+ * to a state machine.
+ *
+ * :::note
+ * This component is not intended to be created directly.
+ * :::
+ *
+ * You'll find this component returned by the `pass` method of the `StepFunctions` component.
+ */
+export declare class Pass extends State implements Nextable {
+    protected args: PassArgs;
+    constructor(args: PassArgs);
+    /**
+     * Add a next state to the `Pass` state. After this state completes, it'll
+     * transition to the given `state`.
+     *
+     * @example
+     *
+     * ```ts title="sst.config.ts"
+     * sst.aws.StepFunctions.pass({
+     *   // ...
+     * })
+     * .next(state);
+     * ```
+     */
+    next<T extends State>(state: T): T;
+    /**
+     * Serialize the state into JSON state definition.
+     */
+    protected toJSON(): {
+        Type: string;
+    };
+}
+//# sourceMappingURL=pass.d.ts.map

package/platform/types/components/aws/step-functions/pass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pass.d.ts","sourceRoot":"","sources":["../../../../../src/components/aws/step-functions/pass.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAErD,MAAM,WAAW,QAAS,SAAQ,SAAS;CAAI;AAE/C;;;;;;;;;;GAUG;AACH,qBAAa,IAAK,SAAQ,KAAM,YAAW,QAAQ;IACrC,SAAS,CAAC,IAAI,EAAE,QAAQ;gBAAd,IAAI,EAAE,QAAQ;IAIpC;;;;;;;;;;;;OAYG;IACI,IAAI,CAAC,CAAC,SAAS,KAAK,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC;IAIzC;;OAEG;IACH,SAAS,CAAC,MAAM;;;CAMjB"}