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

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

@@ -0,0 +1,348 @@
+import { ComponentResourceOptions, Output } from "@pulumi/pulumi";
+import { V5Args } from "../../parts-component";
+import { type ProxyArgs } from "../helpers/rds";
+import { RdsRoleLookup } from "../providers/rds-role-lookup";
+import { type TakesVpc } from "../helpers/vpc";
+import type { PostgresArgs as OriginalPostgresArgs, PostgresGetArgs } from "../postgres";
+declare const parts: {
+    /**
+     * The random password of the master user. It's created when you don't set a `password`.
+     */
+    password: import("../..").OptionalPart<typeof import("@pulumi/random/randomPassword").RandomPassword>;
+    /**
+     * The Secrets Manager secret that stores the master user's username and password.
+     */
+    secret: typeof import("@pulumi/aws/secretsmanager/secret").Secret;
+    /**
+     * The version of the secret holding the current username and password.
+     */
+    secretVersion: typeof import("@pulumi/aws/secretsmanager/secretVersion").SecretVersion;
+    /**
+     * The RDS subnet group.
+     */
+    subnetGroup: typeof import("@pulumi/aws/rds/subnetGroup").SubnetGroup;
+    /**
+     * The RDS parameter group.
+     */
+    parameterGroup: typeof import("@pulumi/aws/rds/parameterGroup").ParameterGroup;
+    /**
+     * The RDS database instance.
+     */
+    instance: typeof import("@pulumi/aws/rds/instance").Instance;
+    /**
+     * The read replicas of the database instance, by number, from `0`.
+     */
+    replica: import("../..").ManyPart<typeof import("@pulumi/aws/rds/instance").Instance>;
+    /**
+     * The secrets that store the additional credentials the proxy can use, by username.
+     */
+    proxySecret: import("../..").ManyPart<typeof import("@pulumi/aws/secretsmanager/secret").Secret>;
+    /**
+     * The versions of the secrets holding the additional credentials, by username.
+     */
+    proxySecretVersion: import("../..").ManyPart<typeof import("@pulumi/aws/secretsmanager/secretVersion").SecretVersion>;
+    /**
+     * The IAM role that lets the proxy read the secrets.
+     */
+    proxyRole: import("../..").OptionalPart<typeof import("@pulumi/aws/iam/role").Role>;
+    /**
+     * Waits for the service-linked role RDS needs before the proxy is created.
+     */
+    proxyRoleLookup: import("../..").OptionalPart<typeof RdsRoleLookup>;
+    /**
+     * The RDS Proxy.
+     */
+    proxy: import("../..").OptionalPart<typeof import("@pulumi/aws/rds/proxy").Proxy>;
+    /**
+     * The proxy's default target group.
+     */
+    proxyTargetGroup: import("../..").OptionalPart<typeof import("@pulumi/aws/rds/proxyDefaultTargetGroup").ProxyDefaultTargetGroup>;
+    /**
+     * The proxy's target: the database instance.
+     */
+    proxyTarget: import("../..").OptionalPart<typeof import("@pulumi/aws/rds/proxyTarget").ProxyTarget>;
+};
+export interface PostgresArgs extends V5Args<TakesVpc<Omit<OriginalPostgresArgs, "proxy" | "replicas">>, typeof parts> {
+    /**
+     * Enable [RDS Proxy](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy.html) for the database.
+     *
+     * Whether there is a proxy has to be a plain value.
+     *
+     * @default `false`
+     * @example
+     * ```js
+     * {
+     *   proxy: true
+     * }
+     * ```
+     */
+    proxy?: boolean | ProxyArgs;
+    /**
+     * @internal
+     */
+    replicas?: number;
+}
+declare const Postgres_base: import("../..").ComponentClass<{
+    /**
+     * The random password of the master user. It's created when you don't set a `password`.
+     */
+    password: import("../..").OptionalPart<typeof import("@pulumi/random/randomPassword").RandomPassword>;
+    /**
+     * The Secrets Manager secret that stores the master user's username and password.
+     */
+    secret: typeof import("@pulumi/aws/secretsmanager/secret").Secret;
+    /**
+     * The version of the secret holding the current username and password.
+     */
+    secretVersion: typeof import("@pulumi/aws/secretsmanager/secretVersion").SecretVersion;
+    /**
+     * The RDS subnet group.
+     */
+    subnetGroup: typeof import("@pulumi/aws/rds/subnetGroup").SubnetGroup;
+    /**
+     * The RDS parameter group.
+     */
+    parameterGroup: typeof import("@pulumi/aws/rds/parameterGroup").ParameterGroup;
+    /**
+     * The RDS database instance.
+     */
+    instance: typeof import("@pulumi/aws/rds/instance").Instance;
+    /**
+     * The read replicas of the database instance, by number, from `0`.
+     */
+    replica: import("../..").ManyPart<typeof import("@pulumi/aws/rds/instance").Instance>;
+    /**
+     * The secrets that store the additional credentials the proxy can use, by username.
+     */
+    proxySecret: import("../..").ManyPart<typeof import("@pulumi/aws/secretsmanager/secret").Secret>;
+    /**
+     * The versions of the secrets holding the additional credentials, by username.
+     */
+    proxySecretVersion: import("../..").ManyPart<typeof import("@pulumi/aws/secretsmanager/secretVersion").SecretVersion>;
+    /**
+     * The IAM role that lets the proxy read the secrets.
+     */
+    proxyRole: import("../..").OptionalPart<typeof import("@pulumi/aws/iam/role").Role>;
+    /**
+     * Waits for the service-linked role RDS needs before the proxy is created.
+     */
+    proxyRoleLookup: import("../..").OptionalPart<typeof RdsRoleLookup>;
+    /**
+     * The RDS Proxy.
+     */
+    proxy: import("../..").OptionalPart<typeof import("@pulumi/aws/rds/proxy").Proxy>;
+    /**
+     * The proxy's default target group.
+     */
+    proxyTargetGroup: import("../..").OptionalPart<typeof import("@pulumi/aws/rds/proxyDefaultTargetGroup").ProxyDefaultTargetGroup>;
+    /**
+     * The proxy's target: the database instance.
+     */
+    proxyTarget: import("../..").OptionalPart<typeof import("@pulumi/aws/rds/proxyTarget").ProxyTarget>;
+}>;
+/**
+ * The `Postgres` component lets you add a Postgres database to your app using
+ * [Amazon RDS Postgres](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html).
+ *
+ * It takes the same args as [`sst.aws.Postgres`](/docs/component/aws/postgres) 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 database
+ *
+ * ```js title="sst.config.ts"
+ * const vpc = new sst.aws.Vpc("MyVpc");
+ * const database = new sst.aws.v5.Postgres("MyDatabase", { vpc });
+ * ```
+ *
+ * #### Link to a resource
+ *
+ * You can link your database to other resources, like a function or your Next.js app.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.Nextjs("MyWeb", {
+ *   link: [database],
+ *   vpc
+ * });
+ * ```
+ *
+ * Once linked, you can connect to it from your function code.
+ *
+ * ```ts title="app/page.tsx" {1,5-9}
+ * import { Resource } from "sst";
+ * import { Pool } from "pg";
+ *
+ * const client = new Pool({
+ *   user: Resource.MyDatabase.username,
+ *   password: Resource.MyDatabase.password,
+ *   database: Resource.MyDatabase.database,
+ *   host: Resource.MyDatabase.host,
+ *   port: Resource.MyDatabase.port,
+ * });
+ * await client.connect();
+ * ```
+ *
+ * #### Running locally
+ *
+ * By default, your RDS Postgres database is deployed in `sst dev`. But let's say you are running
+ * Postgres locally.
+ *
+ * ```bash
+ * docker run \
+ *   --rm \
+ *   -p 5432:5432 \
+ *   -v $(pwd)/.sst/storage/postgres:/var/lib/postgresql/data \
+ *   -e POSTGRES_USER=postgres \
+ *   -e POSTGRES_PASSWORD=password \
+ *   -e POSTGRES_DB=local \
+ *   postgres:18
+ * ```
+ *
+ * You can connect to it in `sst dev` by configuring the `dev` prop.
+ *
+ * ```ts title="sst.config.ts" {3-8}
+ * const postgres = new sst.aws.v5.Postgres("MyPostgres", {
+ *   vpc,
+ *   dev: {
+ *     username: "postgres",
+ *     password: "password",
+ *     database: "local",
+ *     port: 5432
+ *   }
+ * });
+ * ```
+ *
+ * This will skip deploying an RDS database and link to the locally running Postgres database
+ * instead.
+ *
+ * #### Switch from `sst.aws.Postgres`
+ *
+ * Change `sst.aws.Postgres` to `sst.aws.v5.Postgres` and keep the name. The database
+ * you've deployed is kept, and so is everything around it: its password, secrets,
+ * parameter group and proxy.
+ *
+ * ```ts title="sst.config.ts" del={1} ins={2}
+ * const database = new sst.aws.Postgres("MyDatabase", { vpc });
+ * const database = new sst.aws.v5.Postgres("MyDatabase", { vpc });
+ * ```
+ *
+ * A few things are written differently:
+ *
+ * - `proxy`, its list of `credentials`, and each credential's `username` are plain values,
+ *   not outputs. They decide which resources are created.
+ * - `nodes` has every resource, not only the instance. The secret that stores the master
+ *   user's credentials is `nodes.secret`.
+ * - `proxyId` fails as soon as it's read when there is no proxy, where `sst.aws.Postgres`
+ *   failed on deploy.
+ * - If you set `tags` on the instance with an object in `transform`, it keeps the tags
+ *   SST sets next to yours. They're added back when you switch.
+ *
+ * ---
+ *
+ * ### Cost
+ *
+ * By default this component uses a _Single-AZ Deployment_, _On-Demand DB Instances_ of a
+ * `db.t4g.micro` at $0.016 per hour. And 20GB of _General Purpose gp3 Storage_
+ * at $0.115 per GB per month.
+ *
+ * That works out to $0.016 x 24 x 30 + $0.115 x 20 or **$14 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
+ * [RDS for PostgreSQL pricing](https://aws.amazon.com/rds/postgresql/pricing/#On-Demand_DB_Instances_costs) for more details.
+ *
+ * #### RDS Proxy
+ *
+ * If you enable the `proxy`, it uses _Provisioned instances_ with 2 vCPUs at $0.015 per hour.
+ *
+ * That works out to an **additional** $0.015 x 2 x 24 x 30 or **$22 per month**.
+ *
+ * This is a rough estimate for _us-east-1_, check out the
+ * [RDS Proxy pricing](https://aws.amazon.com/rds/proxy/pricing/) for more details.
+ */
+export declare class Postgres extends Postgres_base {
+    private connection;
+    constructor(name: string, args: PostgresArgs, opts?: ComponentResourceOptions);
+    /**
+     * The identifier of the Postgres instance.
+     */
+    get id(): Output<string>;
+    /**
+     * The name of the Postgres proxy.
+     */
+    get proxyId(): Output<string>;
+    /** The username of the master user. */
+    get username(): Output<string>;
+    /** The password of the master user. */
+    get password(): Output<string>;
+    /**
+     * The name of the database.
+     */
+    get database(): Output<string>;
+    /**
+     * The port of the database.
+     */
+    get port(): import("@pulumi/pulumi").OutputInstance<number>;
+    /**
+     * The host of the database.
+     */
+    get host(): Output<string>;
+    /**
+     * Linking a database gives the linked resource its host, port, database,
+     * username and password.
+     */
+    link(): {
+        properties: {
+            database: Output<string>;
+            username: Output<string>;
+            password: Output<string>;
+            port: import("@pulumi/pulumi").OutputInstance<number>;
+            host: Output<string>;
+        };
+    };
+    /**
+     * Reference an existing Postgres database with the given name. This is useful when you
+     * create a Postgres database in one stage and want to share it in another. It avoids
+     * having to create a new Postgres database in the other stage.
+     *
+     * :::tip
+     * You can use the `static get` method to share Postgres databases across stages.
+     * :::
+     *
+     * @param name The name of the component.
+     * @param args The arguments to get the Postgres database.
+     * @param opts Resource options.
+     *
+     * @example
+     * Imagine you create a database in the `dev` stage. And in your personal stage `frank`,
+     * instead of creating a new database, you want to share the same database from `dev`.
+     *
+     * ```ts title="sst.config.ts"
+     * const database = $app.stage === "frank"
+     *   ? sst.aws.v5.Postgres.get("MyDatabase", {
+     *       id: "app-dev-mydatabase",
+     *       proxyId: "app-dev-mydatabase-proxy"
+     *     })
+     *   : new sst.aws.v5.Postgres("MyDatabase", {
+     *       vpc,
+     *       proxy: true
+     *     });
+     * ```
+     *
+     * Here `app-dev-mydatabase` is the ID of the database, and `app-dev-mydatabase-proxy`
+     * is the ID of the proxy created in the `dev` stage. You can find these by outputting
+     * the database ID and proxy ID in the `dev` stage.
+     *
+     * ```ts title="sst.config.ts"
+     * return {
+     *   id: database.id,
+     *   proxyId: database.proxyId
+     * };
+     * ```
+     */
+    static get(name: string, args: PostgresGetArgs, opts?: ComponentResourceOptions): Postgres;
+}
+export {};
+//# sourceMappingURL=postgres.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../../../../src/components/aws/v5/postgres.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EAGxB,MAAM,EAEP,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,MAAM,EAA6B,MAAM,uBAAuB,CAAC;AAI1E,OAAO,EAIL,KAAK,SAAS,EAKf,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,KAAK,QAAQ,EAAS,MAAM,gBAAgB,CAAC;AAEtD,OAAO,KAAK,EACV,YAAY,IAAI,oBAAoB,EACpC,eAAe,EAChB,MAAM,aAAa,CAAC;AAErB,QAAA,MAAM,KAAK;IACT;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;CAEJ,CAAC;AAEF,MAAM,WAAW,YACf,SAAQ,MAAM,CACZ,QAAQ,CAAC,IAAI,CAAC,oBAAoB,EAAE,OAAO,GAAG,UAAU,CAAC,CAAC,EAC1D,OAAO,KAAK,CACb;IACD;;;;;;;;;;;;OAYG;IACH,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC5B;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;;IAjFC;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;;AAyCL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyHG;AACH,qBAAa,QAAS,SAAQ,aAAoC;IAChE,OAAO,CAAC,UAAU,CAAa;gBAG7B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,YAAY,EAClB,IAAI,CAAC,EAAE,wBAAwB;IA2OjC;;OAEG;IACH,IAAW,EAAE,mBAEZ;IAED;;OAEG;IACH,IAAW,OAAO,mBAMjB;IAED,uCAAuC;IACvC,IAAW,QAAQ,mBAElB;IAED,uCAAuC;IACvC,IAAW,QAAQ,mBAElB;IAED;;OAEG;IACH,IAAW,QAAQ,mBAElB;IAED;;OAEG;IACH,IAAW,IAAI,oDAEd;IAED;;OAEG;IACH,IAAW,IAAI,mBAEd;IAED;;;OAGG;IACI,IAAI;;;;;;;;;IAYX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;WACW,GAAG,CACf,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,eAAe,EACrB,IAAI,CAAC,EAAE,wBAAwB;CAalC"}

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

@@ -0,0 +1,190 @@
+import { ComponentResourceOptions } from "@pulumi/pulumi";
+import { V5Args } from "../../parts-component";
+import type { Input } from "../../input";
+import type { FunctionArgs as OriginalFunctionArgs, FunctionArn } from "../function";
+import { Function } from "./function";
+import type { QueueArgs as OriginalQueueArgs, QueueSubscriberArgs as OriginalQueueSubscriberArgs } from "../queue";
+declare const parts: () => {
+    /**
+     * The Amazon SQS Queue.
+     */
+    queue: typeof import("@pulumi/aws/sqs/queue").Queue;
+    /**
+     * The function subscribed to the queue.
+     */
+    subscriber: import("../..").DeferredPart<typeof Function>;
+    /**
+     * The Lambda event source mapping that sends the queue's messages to the subscriber.
+     */
+    eventSourceMapping: import("../..").OptionalPart<typeof import("@pulumi/aws/lambda/eventSourceMapping").EventSourceMapping>;
+};
+export interface QueueArgs extends V5Args<OriginalQueueArgs, typeof parts> {
+}
+export interface QueueSubscriberArgs extends Omit<OriginalQueueSubscriberArgs, "transform"> {
+}
+declare const Queue_base: import("../..").ComponentClass<{
+    /**
+     * The Amazon SQS Queue.
+     */
+    queue: typeof import("@pulumi/aws/sqs/queue").Queue;
+    /**
+     * The function subscribed to the queue.
+     */
+    subscriber: import("../..").DeferredPart<typeof Function>;
+    /**
+     * The Lambda event source mapping that sends the queue's messages to the subscriber.
+     */
+    eventSourceMapping: import("../..").OptionalPart<typeof import("@pulumi/aws/lambda/eventSourceMapping").EventSourceMapping>;
+}>;
+/**
+ * The `Queue` component lets you add a serverless queue to your app. It uses [Amazon SQS](https://aws.amazon.com/sqs/).
+ *
+ * It takes the same args as [`sst.aws.Queue`](/docs/component/aws/queue). 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 a queue
+ *
+ * ```ts title="sst.config.ts"
+ * const queue = new sst.aws.v5.Queue("MyQueue");
+ * ```
+ *
+ * #### Add a subscriber
+ *
+ * ```ts title="sst.config.ts"
+ * queue.subscribe("src/subscriber.handler");
+ * ```
+ *
+ * #### Link the queue to a resource
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.Nextjs("MyWeb", {
+ *   link: [queue]
+ * });
+ * ```
+ *
+ * #### Switch from `sst.aws.Queue`
+ *
+ * Change `sst.aws.Queue` to `sst.aws.v5.Queue` and keep the name. The queue and subscriber
+ * you've deployed are kept.
+ *
+ * ```ts title="sst.config.ts" del={1} ins={2}
+ * const queue = new sst.aws.Queue("MyQueue");
+ * const queue = new sst.aws.v5.Queue("MyQueue");
+ * ```
+ *
+ * #### Use a queue you already have
+ *
+ * Pass the queue, or its URL.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.Queue("MyQueue", {
+ *   existing: {
+ *     queue: "https://sqs.us-east-1.amazonaws.com/123456789012/my-queue"
+ *   }
+ * });
+ * ```
+ */
+export declare class Queue extends Queue_base {
+    constructor(name: string, args?: QueueArgs, opts?: ComponentResourceOptions);
+    /**
+     * The ARN of the SQS Queue.
+     */
+    get arn(): import("@pulumi/pulumi").Output<string>;
+    /**
+     * The SQS Queue URL.
+     */
+    get url(): import("@pulumi/pulumi").Output<string>;
+    /**
+     * Subscribe to this queue. A queue can have one subscriber.
+     *
+     * @param subscriber The function that'll be notified.
+     * @param args Configure the subscription.
+     *
+     * @example
+     *
+     * ```js title="sst.config.ts"
+     * queue.subscribe("src/subscriber.handler");
+     * ```
+     *
+     * Add a filter to the subscription.
+     *
+     * ```js title="sst.config.ts"
+     * queue.subscribe("src/subscriber.handler", {
+     *   filters: [
+     *     {
+     *       body: {
+     *         RequestCode: ["BBBB"]
+     *       }
+     *     }
+     *   ]
+     * });
+     * ```
+     *
+     * Or pass in the ARN of an existing Lambda function.
+     *
+     * ```js title="sst.config.ts"
+     * queue.subscribe("arn:aws:lambda:us-east-1:123456789012:function:my-function");
+     * ```
+     *
+     * To change how the subscriber is created, use the queue's `transform`.
+     *
+     * ```js title="sst.config.ts"
+     * new sst.aws.v5.Queue("MyQueue", {
+     *   transform: {
+     *     eventSourceMapping: { enabled: false }
+     *   }
+     * });
+     * ```
+     */
+    subscribe(subscriber: Input<string | OriginalFunctionArgs | FunctionArn>, args?: QueueSubscriberArgs): this;
+    /**
+     * Reference an existing SQS Queue. This is useful when you create a queue in one stage and
+     * want to share it in another, or to subscribe to a queue that isn't in your app.
+     *
+     * @param name The name of the component.
+     * @param queue The URL or ARN of the existing SQS Queue.
+     * @param opts Component resource options.
+     *
+     * @example
+     *
+     * ```ts title="sst.config.ts"
+     * const queue = $app.stage === "frank"
+     *   ? sst.aws.v5.Queue.get("MyQueue", "https://sqs.us-east-1.amazonaws.com/123456789012/app-dev-MyQueue")
+     *   : new sst.aws.v5.Queue("MyQueue");
+     * ```
+     *
+     * Subscribe to a queue that isn't in your app.
+     *
+     * ```ts title="sst.config.ts"
+     * sst.aws.v5.Queue
+     *   .get("Orders", "arn:aws:sqs:us-east-1:123456789012:orders")
+     *   .subscribe("src/subscriber.handler");
+     * ```
+     */
+    static get(name: string, queue: Input<string>, opts?: ComponentResourceOptions): Queue;
+    /**
+     * Linking a queue gives the linked resource the queue's URL and permission
+     * to use it.
+     */
+    link(): {
+        properties: {
+            url: 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=queue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../../../../src/components/aws/v5/queue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EAGzB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,MAAM,EAAiC,MAAM,uBAAuB,CAAC;AAE9E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGzC,OAAO,KAAK,EACV,YAAY,IAAI,oBAAoB,EACpC,WAAW,EACZ,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAKtC,OAAO,KAAK,EACV,SAAS,IAAI,iBAAiB,EAC9B,mBAAmB,IAAI,2BAA2B,EACnD,MAAM,UAAU,CAAC;AAElB,QAAA,MAAM,KAAK;IACT;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;CAEH,CAAC;AAEH,MAAM,WAAW,SAAU,SAAQ,MAAM,CAAC,iBAAiB,EAAE,OAAO,KAAK,CAAC;CAAG;AAE7E,MAAM,WAAW,mBACf,SAAQ,IAAI,CAAC,2BAA2B,EAAE,WAAW,CAAC;CAAG;;IAjBzD;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;;AASL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,qBAAa,KAAM,SAAQ,UAAiC;gBAExD,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,SAAc,EACpB,IAAI,CAAC,EAAE,wBAAwB;IA6BjC;;OAEG;IACH,IAAW,GAAG,4CAEb;IAED;;OAEG;IACH,IAAW,GAAG,4CAEb;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACI,SAAS,CACd,UAAU,EAAE,KAAK,CAAC,MAAM,GAAG,oBAAoB,GAAG,WAAW,CAAC,EAC9D,IAAI,GAAE,mBAAwB;IAsChC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;WACW,GAAG,CACf,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,EACpB,IAAI,CAAC,EAAE,wBAAwB;IAQjC;;;OAGG;IACI,IAAI;;;;;;;;;;;;;;;;CAMZ"}