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

package/platform/types/components/cloudflare/cron.d.ts

@@ -0,0 +1,151 @@
+import { ComponentResourceOptions, Output } from "@pulumi/pulumi";
+import * as cloudflare from "@pulumi/cloudflare";
+import { Component, Transform } from "../component";
+import { WorkerArgs } from "./worker";
+import { Input } from "../input.js";
+export interface CronArgs {
+    /**
+     * The worker that'll be executed when the cron job runs.
+     * @deprecated Use `worker` instead.
+     *
+     * @example
+     *
+     * ```ts
+     * {
+     *   job: "src/cron.ts"
+     * }
+     * ```
+     *
+     * You can pass in the full worker props.
+     *
+     * ```ts
+     * {
+     *   job: {
+     *     handler: "src/cron.ts",
+     *     link: [bucket]
+     *   }
+     * }
+     * ```
+     */
+    job?: Input<string | WorkerArgs>;
+    /**
+     * The worker that'll be executed when the cron job runs.
+     *
+     * @example
+     *
+     * ```ts
+     * {
+     *   worker: "src/cron.ts"
+     * }
+     * ```
+     *
+     * You can pass in the full worker props.
+     *
+     * ```ts
+     * {
+     *   worker: {
+     *     handler: "src/cron.ts",
+     *     link: [bucket]
+     *   }
+     * }
+     * ```
+     */
+    worker?: Input<string | WorkerArgs>;
+    /**
+     * The schedule for the cron job.
+     *
+     * :::note
+     * The cron job continues to run even after you exit `sst dev`.
+     * :::
+     *
+     * @example
+     *
+     * You can use a [cron expression](https://developers.cloudflare.com/workers/configuration/cron-triggers/#supported-cron-expressions).
+     *
+     * ```ts
+     * {
+     *   schedules: ["* * * * *"]
+     *   // schedules: ["*\/30 * * * *"]
+     *   // schedules: ["45 * * * *"]
+     *   // schedules: ["0 17 * * sun"]
+     *   // schedules: ["10 7 * * mon-fri"]
+     *   // schedules: ["0 15 1 * *"]
+     *   // schedules: ["59 23 LW * *"]
+     * }
+     * ```
+     */
+    schedules: Input<string[]>;
+    /**
+     * The Cloudflare account ID to use for this Cron and its worker.
+     * Overrides the default account ID set via `CLOUDFLARE_DEFAULT_ACCOUNT_ID`.
+     * @internal
+     */
+    accountId?: Input<string>;
+    /**
+     * [Transform](/docs/components/#transform) how this component creates its underlying
+     * resources.
+     */
+    transform?: {
+        /**
+         * Transform the Worker Cron Trigger resource.
+         */
+        trigger?: Transform<cloudflare.WorkerCronTriggerArgs>;
+    };
+}
+/**
+ * The `Cron` component lets you add cron jobs to your app using Cloudflare.
+ * It uses [Cloudflare Cron Triggers](https://developers.cloudflare.com/workers/configuration/cron-triggers/).
+ *
+ * @example
+ * #### Minimal example
+ *
+ * Create a worker file that exposes a `scheduled` handler:
+ *
+ * ```ts title="cron.ts"
+ * export default {
+ *   async scheduled() {
+ *     console.log("Running on a schedule");
+ *   },
+ * };
+ * ```
+ *
+ * Pass in a `schedules` and a `worker` that'll be executed.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.cloudflare.Cron("MyCronJob", {
+ *   worker: "cron.ts",
+ *   schedules: ["* * * * *"]
+ * });
+ * ```
+ *
+ * #### Customize the worker
+ *
+ * ```js title="sst.config.ts"
+ * new sst.cloudflare.Cron("MyCronJob", {
+ *   schedules: ["* * * * *"],
+ *   worker: {
+ *     handler: "cron.ts",
+ *     link: [bucket]
+ *   }
+ * });
+ * ```
+ */
+export declare class Cron extends Component {
+    private worker;
+    private trigger;
+    constructor(name: string, args: CronArgs, opts?: ComponentResourceOptions);
+    /**
+     * The underlying [resources](/docs/components/#nodes) this component creates.
+     */
+    get nodes(): {
+        /**
+         * The Cloudflare Worker.
+         */
+        worker: Output<import("@pulumi/cloudflare/workerScript").WorkerScript>;
+        /**
+         * The Cloudflare Worker Cron Trigger.
+         */
+        trigger: Output<import("@pulumi/cloudflare/workerCronTrigger").WorkerCronTrigger>;
+    };
+}
+//# sourceMappingURL=cron.d.ts.map

package/platform/types/components/cloudflare/cron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron.d.ts","sourceRoot":"","sources":["../../../../src/components/cloudflare/cron.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,wBAAwB,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAEvE,OAAO,KAAK,UAAU,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,SAAS,EAAa,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtC,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAIpC,MAAM,WAAW,QAAQ;IACvB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,GAAG,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,UAAU,CAAC,CAAC;IACjC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,UAAU,CAAC,CAAC;IACpC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,SAAS,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IAC3B;;;;OAIG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1B;;;OAGG;IACH,SAAS,CAAC,EAAE;QACV;;WAEG;QACH,OAAO,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,qBAAqB,CAAC,CAAC;KACvD,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBAAa,IAAK,SAAQ,SAAS;IACjC,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,OAAO,CAA+B;gBAElC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,wBAAwB;IA6CzE;;OAEG;IACH,IAAW,KAAK;QAEZ;;WAEG;;QAEH;;WAEG;;MAGN;CACF"}

package/platform/types/components/cloudflare/d1.d.ts

@@ -0,0 +1,142 @@
+import { ComponentResourceOptions } from "@pulumi/pulumi";
+import * as cloudflare from "@pulumi/cloudflare";
+import { Component, Transform } from "../component";
+import { Link } from "../link";
+import type { Input } from "../input";
+export interface D1Args {
+    /**
+     * The Cloudflare account ID to use for this D1 database.
+     * Overrides the default account ID set via `CLOUDFLARE_DEFAULT_ACCOUNT_ID`.
+     * @internal
+     */
+    accountId?: Input<string>;
+    /**
+     * [Transform](/docs/components/#transform) how this component creates its underlying
+     * resources.
+     */
+    transform?: {
+        /**
+         * Transform the D1 resource.
+         */
+        database?: Transform<cloudflare.D1DatabaseArgs>;
+    };
+}
+/**
+ * The `D1` component lets you add a [Cloudflare D1 database](https://developers.cloudflare.com/d1/) to
+ * your app.
+ *
+ * @example
+ *
+ * #### Minimal example
+ *
+ * ```ts title="sst.config.ts"
+ * const db = new sst.cloudflare.D1("MyDatabase");
+ * ```
+ *
+ * #### Link to a worker
+ *
+ * You can link the db to a worker.
+ *
+ * ```ts {3} title="sst.config.ts"
+ * new sst.cloudflare.Worker("MyWorker", {
+ *   handler: "./index.ts",
+ *   link: [db],
+ *   url: true
+ * });
+ * ```
+ *
+ * Once linked, you can use the SDK to interact with the db.
+ *
+ * ```ts title="index.ts" {1} "Resource.MyDatabase.prepare"
+ * import { Resource } from "sst";
+ *
+ * await Resource.MyDatabase.prepare(
+ *   "SELECT id FROM todo ORDER BY id DESC LIMIT 1",
+ * ).first();
+ * ```
+ */
+export declare class D1 extends Component implements Link.Linkable {
+    private database;
+    constructor(name: string, args?: D1Args, opts?: ComponentResourceOptions);
+    /**
+     * When you link a D1 database, the database will be available to the worker and you can
+     * query it using its [API methods](https://developers.cloudflare.com/d1/build-with-d1/d1-client-api/).
+     *
+     * @example
+     * ```ts title="index.ts" {1} "Resource.MyDatabase.prepare"
+     * import { Resource } from "sst";
+     *
+     * await Resource.MyDatabase.prepare(
+     *   "SELECT id FROM todo ORDER BY id DESC LIMIT 1",
+     * ).first();
+     * ```
+     *
+     * @internal
+     */
+    getSSTLink(): {
+        properties: {
+            databaseId: import("@pulumi/pulumi").Output<string>;
+        };
+        include: {
+            type: "cloudflare.binding";
+            binding: T;
+            properties: Extract<import("./binding").Binding, {
+                type: T;
+            }>["properties"];
+        }[];
+    };
+    /**
+     * The generated ID of the D1 database.
+     */
+    get databaseId(): import("@pulumi/pulumi").Output<string>;
+    /**
+     * The underlying [resources](/docs/components/#nodes) this component creates.
+     */
+    get nodes(): {
+        /**
+         * The Cloudflare D1 database.
+         */
+        database: import("@pulumi/cloudflare/d1database").D1Database;
+    };
+    /**
+     * Reference an existing D1 Database with the given database ID. This is
+     * useful when you create a D1 in one stage and want to share it in another.
+     * It avoids having to create a new D1 Database in the other stage.
+     *
+     * :::tip
+     * You can use the `static get` method to share D1 Databases across stages.
+     * :::
+     *
+     * @param name The name of the component.
+     * @param args The database ID and optional account ID of the existing D1 Database.
+     *
+     * @example
+     * Imagine you create a D1 Database in the `dev` stage. And in your personal
+     * stage `giorgio`, instead of creating a new database, you want to share the
+     * same database from `dev`.
+     *
+     * ```ts title="sst.config.ts"
+     * const d1 = $app.stage === "giorgio"
+     *   ? sst.cloudflare.D1.get("MyD1", { databaseId: "my-database-id" })
+     *   : new sst.cloudflare.D1("MyD1");
+     * ```
+     *
+     * Here `my-database-id` is the ID of the D1 Database created in the `dev`
+     * stage. You can find it by outputting the D1 Database in the `dev` stage.
+     *
+     * ```ts title="sst.config.ts"
+     * return {
+     *   d1
+     * };
+     * ```
+     */
+    static get(name: string, args: {
+        databaseId: string;
+        accountId?: string;
+    }, opts?: ComponentResourceOptions): D1;
+    /**
+     * @deprecated Use the object-based `args` signature instead: `get(name, { databaseId }, opts)`.
+     */
+    static get(name: string, databaseId: string, opts?: ComponentResourceOptions): D1;
+}
+//# sourceMappingURL=d1.d.ts.map

package/platform/types/components/cloudflare/d1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"d1.d.ts","sourceRoot":"","sources":["../../../../src/components/cloudflare/d1.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,KAAK,UAAU,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,SAAS,EAAa,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAG/B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEtC,MAAM,WAAW,MAAM;IACrB;;;;OAIG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1B;;;OAGG;IACH,SAAS,CAAC,EAAE;QACV;;WAEG;QACH,QAAQ,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;KACjD,CAAC;CACH;AAOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,EAAG,SAAQ,SAAU,YAAW,IAAI,CAAC,QAAQ;IACxD,OAAO,CAAC,QAAQ,CAAwB;gBAE5B,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,wBAAwB;IA6BxE;;;;;;;;;;;;;;OAcG;IACH,UAAU;;;;;;;;;;;;IAgBV;;OAEG;IACH,IAAW,UAAU,4CAKpB;IAED;;OAEG;IACH,IAAW,KAAK;QAEZ;;WAEG;;MAGN;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;WACW,GAAG,CACf,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,EAChD,IAAI,CAAC,EAAE,wBAAwB,GAC9B,EAAE;IACL;;OAEG;WACW,GAAG,CACf,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,IAAI,CAAC,EAAE,wBAAwB,GAC9B,EAAE;CA8BN"}

package/platform/types/components/cloudflare/dns.d.ts

@@ -0,0 +1,100 @@
+/**
+ * The Cloudflare DNS Adapter is used to create DNS records to manage domains hosted on
+ * [Cloudflare DNS](https://developers.cloudflare.com/dns/).
+ *
+ * :::note
+ * You need to [add the Cloudflare provider](/docs/providers/#install) to use this adapter.
+ * :::
+ *
+ * This needs the Cloudflare provider. To add it run:
+ *
+ * ```bash
+ * sst add cloudflare
+ * ```
+ *
+ * This adapter is passed in as `domain.dns` when setting a custom domain, where `example.com`
+ * is hosted on Cloudflare.
+ *
+ * ```ts
+ * {
+ *   domain: {
+ *     name: "example.com",
+ *     dns: sst.cloudflare.dns()
+ *   }
+ * }
+ * ```
+ *
+ * Specify the zone ID.
+ *
+ * ```ts
+ * {
+ *   domain: {
+ *     name: "example.com",
+ *     dns: sst.cloudflare.dns({
+ *       zone: "415e6f4653b6d95b775d350f32119abb"
+ *     })
+ *   }
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+import * as cloudflare from "@pulumi/cloudflare";
+import { AliasRecord, Record } from "../dns";
+import { ComponentResourceOptions } from "@pulumi/pulumi";
+import { Transform } from "../component";
+import { Input } from "../input";
+import { DnsRecord as OverridableDnsRecord } from "./providers/dns-record";
+export interface DnsArgs {
+    /**
+     * The ID of the Cloudflare zone to create the record in.
+     *
+     * @example
+     * ```js
+     * {
+     *   zone: "415e6f4653b6d95b775d350f32119abb"
+     * }
+     * ```
+     */
+    zone?: Input<string>;
+    /**
+     * The Cloudflare account ID to use for zone lookups.
+     * Overrides the default account ID set via `CLOUDFLARE_DEFAULT_ACCOUNT_ID`.
+     * @internal
+     */
+    accountId?: Input<string>;
+    /**
+     * Configure ALIAS DNS records as [proxy records](https://developers.cloudflare.com/learning-paths/get-started-free/onboarding/proxy-dns-records/).
+     *
+     * :::tip
+     * Proxied records help prevent DDoS attacks and allow you to use Cloudflare's global
+     * content delivery network (CDN) for caching.
+     * :::
+     *
+     * @default `false`
+     * @example
+     * ```js
+     * {
+     *   proxy: true
+     * }
+     * ```
+     */
+    proxy?: Input<boolean>;
+    /**
+     * [Transform](/docs/components#transform) how this component creates its underlying
+     * resources.
+     */
+    transform?: {
+        /**
+         * Transform the Cloudflare record resource.
+         */
+        record?: Transform<cloudflare.RecordArgs>;
+    };
+}
+export declare function dns(args?: DnsArgs): {
+    provider: "cloudflare";
+    createAlias: (namePrefix: string, record: AliasRecord, opts: ComponentResourceOptions) => import("@pulumi/pulumi").Output<import("@pulumi/cloudflare/dnsRecord").DnsRecord>;
+    createCaa: (namePrefix: string, recordName: string, opts: ComponentResourceOptions) => OverridableDnsRecord[];
+    createRecord: (namePrefix: string, record: Record, opts: ComponentResourceOptions) => import("@pulumi/pulumi").Output<import("@pulumi/cloudflare/dnsRecord").DnsRecord>;
+};
+//# sourceMappingURL=dns.d.ts.map

package/platform/types/components/cloudflare/dns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dns.d.ts","sourceRoot":"","sources":["../../../../src/components/cloudflare/dns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,KAAK,UAAU,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAO,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGlD,OAAO,EAAE,wBAAwB,EAAU,MAAM,gBAAgB,CAAC;AAClE,OAAO,EAAE,SAAS,EAAa,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC,OAAO,EAAE,SAAS,IAAI,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE3E,MAAM,WAAW,OAAO;IACtB;;;;;;;;;OASG;IACH,IAAI,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrB;;;;OAIG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1B;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IACvB;;;OAGG;IACH,SAAS,CAAC,EAAE;QACV;;WAEG;QACH,MAAM,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;KAC3C,CAAC;CACH;AAED,wBAAgB,GAAG,CAAC,IAAI,GAAE,OAAY;;8BAwCtB,MAAM,UACV,WAAW,QACb,wBAAwB;4BAelB,MAAM,cACN,MAAM,QACZ,wBAAwB;+BA+ClB,MAAM,UACV,MAAM,QACR,wBAAwB;EA6CjC"}

package/platform/types/components/cloudflare/durable-object.d.ts

@@ -0,0 +1,125 @@
+import { ComponentResourceOptions, type Output } from "@pulumi/pulumi";
+import { Component } from "../component.js";
+import { Link } from "../link.js";
+import type { Input } from "../input.js";
+export interface DurableObjectArgs {
+    /**
+     * The name of the class in your worker handler file that extends `DurableObject`.
+     *
+     * @example
+     * ```js
+     * {
+     *   className: "Counter"
+     * }
+     * ```
+     */
+    className: Input<string>;
+}
+/**
+ * Use the `DurableObject` component to register a
+ * [Cloudflare Durable Object](https://developers.cloudflare.com/durable-objects/)
+ * for a worker.
+ *
+ * Create the Durable Object and then link it to a `sst.cloudflare.Worker`. SST
+ * adds the Durable Object binding automatically. The `className` must match the
+ * exported Durable Object class name in your worker code.
+ *
+ * Durable Objects require migrations on the worker. Use the Worker's
+ * `migrations` field like Wrangler's top-level `migrations` config: keep the
+ * full ordered history there, and SST uses it to build the Cloudflare migration
+ * payload for the Worker.
+ *
+ * On the first deploy, add the class with `newSqliteClasses`. If you later
+ * rename the class, keep the original migration and add a new migration with a
+ * unique tag and `renamedClasses`.
+ *
+ * @example
+ *
+ * ```ts title="sst.config.ts"
+ * const counter = new sst.cloudflare.DurableObject("Counter", {
+ *   className: "Counter",
+ * });
+ *
+ * new sst.cloudflare.Worker("Api", {
+ *   handler: "src/worker.ts",
+ *   link: [counter],
+ *   migrations: [{
+ *     tag: "v1",
+ *     newSqliteClasses: [counter.className],
+ *   }],
+ *   url: true,
+ * });
+ * ```
+ *
+ * To rename a deployed class from `Counter` to `CounterV2`, update `className`
+ * and the exported class name, then append a migration.
+ *
+ * ```ts title="sst.config.ts"
+ * const counter = new sst.cloudflare.DurableObject("Counter", {
+ *   className: "CounterV2",
+ * });
+ *
+ * new sst.cloudflare.Worker("Api", {
+ *   handler: "src/worker.ts",
+ *   link: [counter],
+ *   migrations: [
+ *     {
+ *       tag: "v1",
+ *       newSqliteClasses: ["Counter"],
+ *     },
+ *     {
+ *       tag: "v2",
+ *       renamedClasses: [{ from: "Counter", to: counter.className }],
+ *     },
+ *   ],
+ *   url: true,
+ * });
+ * ```
+ *
+ * ```ts title="src/worker.ts"
+ * import { Resource } from "sst";
+ * import { DurableObject } from "cloudflare:workers";
+ *
+ * export default {
+ *   async fetch() {
+ *     const stub = Resource.Counter.getByName("global");
+ *     return stub.fetch("https://counter/");
+ *   },
+ * };
+ *
+ * export class Counter extends DurableObject {
+ *   async fetch() {
+ *     return new Response("hello from the durable object");
+ *   }
+ * }
+ * ```
+ */
+export declare class DurableObject extends Component implements Link.Linkable {
+    /**
+     * The exported Durable Object class name.
+     */
+    readonly className: Output<string>;
+    constructor(name: string, args: DurableObjectArgs, opts?: ComponentResourceOptions);
+    /**
+     * When you link a Durable Object to a worker, SST adds a Cloudflare Durable
+     * Object namespace binding.
+     *
+     * @internal
+     */
+    getSSTLink(): {
+        properties: {
+            className: Output<string>;
+        };
+        include: ({
+            type: "cloudflare.binding";
+            binding: T;
+            properties: Extract<import("./binding.js").Binding, {
+                type: T;
+            }>["properties"];
+        } | {
+            className: Output<string>;
+            type: string;
+        })[];
+    };
+}
+//# sourceMappingURL=durable-object.d.ts.map

package/platform/types/components/cloudflare/durable-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable-object.d.ts","sourceRoot":"","sources":["../../../../src/components/cloudflare/durable-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAU,KAAK,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAC/E,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAClC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGzC,MAAM,WAAW,iBAAiB;IAChC;;;;;;;;;OASG;IACH,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,qBAAa,aAAc,SAAQ,SAAU,YAAW,IAAI,CAAC,QAAQ;IACnE;;OAEG;IACH,SAAgB,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;gBAGxC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,iBAAiB,EACvB,IAAI,CAAC,EAAE,wBAAwB;IAMjC;;;;;OAKG;IACI,UAAU;;;;;;;;;;;;;;;CAmBlB"}

package/platform/types/components/cloudflare/experimental/index.d.ts

@@ -0,0 +1,4 @@
+export * from "../astro";
+export * from "./solid-start";
+export * from "./static-site";
+//# sourceMappingURL=index.d.ts.map

package/platform/types/components/cloudflare/experimental/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/cloudflare/experimental/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC"}