@beachside/upstash-box 0.0.0 → 0.19.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +28 -2
- package/dist/adapter.d.ts +258 -0
- package/dist/exec.d.ts +10 -0
- package/dist/files-shell.d.ts +15 -0
- package/dist/files.d.ts +52 -0
- package/dist/index.d.ts +6 -0
- package/dist/index.js +2415 -0
- package/dist/process.d.ts +7 -0
- package/dist/regular.d.ts +14 -0
- package/dist/snapshots.d.ts +543 -0
- package/dist/transport.d.ts +15 -0
- package/package.json +38 -7
package/README.md
CHANGED
|
@@ -1,5 +1,31 @@
|
|
|
1
1
|
# @beachside/upstash-box
|
|
2
2
|
|
|
3
|
-
|
|
3
|
+
Beachside adapter for ephemeral and regular Upstash Box sandboxes in AWS us-east-1. Live tests cover lifecycle, reopening, execution, streaming and termination, Alpine files and directories, snapshots, regular-box pause and resume, both preview modes, and a custom HTTPS allowlist. Strict blocked egress is unsupported. See the [provider support matrix](https://beachside.run/docs/providers/support/).
|
|
4
4
|
|
|
5
|
-
|
|
5
|
+
```sh
|
|
6
|
+
npm install beachside @beachside/upstash-box
|
|
7
|
+
```
|
|
8
|
+
|
|
9
|
+
```ts
|
|
10
|
+
import { Beachside } from "beachside";
|
|
11
|
+
import { upstashBoxAdapter } from "@beachside/upstash-box";
|
|
12
|
+
|
|
13
|
+
const client = await Beachside.connect({
|
|
14
|
+
adapter: upstashBoxAdapter,
|
|
15
|
+
config: {},
|
|
16
|
+
credentials: { apiKey: process.env.UPSTASH_BOX_API_KEY! },
|
|
17
|
+
});
|
|
18
|
+
try {
|
|
19
|
+
const box = await client.sandboxes.create();
|
|
20
|
+
try {
|
|
21
|
+
const result = await box.exec(["node", "--version"]);
|
|
22
|
+
console.log(result.stdoutText());
|
|
23
|
+
} finally {
|
|
24
|
+
await box.destroy();
|
|
25
|
+
}
|
|
26
|
+
} finally {
|
|
27
|
+
await client.close();
|
|
28
|
+
}
|
|
29
|
+
```
|
|
30
|
+
|
|
31
|
+
See the [provider guide](https://beachside.run/docs/providers/upstash-box/) for defaults, bounds and recovery.
|
|
@@ -0,0 +1,258 @@
|
|
|
1
|
+
import { z } from "zod";
|
|
2
|
+
import { type AdapterSession, type ExecInput } from "@beachside/adapter";
|
|
3
|
+
export type UpstashBoxAdapterOptions = {
|
|
4
|
+
/** Native transport overrides for host-owned tests. */
|
|
5
|
+
fetch?: typeof fetch;
|
|
6
|
+
};
|
|
7
|
+
export declare function createUpstashBoxAdapter(options?: UpstashBoxAdapterOptions): import("@beachside/adapter").AdapterDefinition<z.ZodObject<{
|
|
8
|
+
image: z.ZodDefault<z.ZodEnum<{
|
|
9
|
+
node: "node";
|
|
10
|
+
python: "python";
|
|
11
|
+
golang: "golang";
|
|
12
|
+
ruby: "ruby";
|
|
13
|
+
rust: "rust";
|
|
14
|
+
"node-alpine": "node-alpine";
|
|
15
|
+
"python-alpine": "python-alpine";
|
|
16
|
+
"golang-alpine": "golang-alpine";
|
|
17
|
+
"ruby-alpine": "ruby-alpine";
|
|
18
|
+
"rust-alpine": "rust-alpine";
|
|
19
|
+
}>>;
|
|
20
|
+
boxKind: z.ZodDefault<z.ZodEnum<{
|
|
21
|
+
ephemeral: "ephemeral";
|
|
22
|
+
regular: "regular";
|
|
23
|
+
}>>;
|
|
24
|
+
keepAlive: z.ZodDefault<z.ZodBoolean>;
|
|
25
|
+
preview: z.ZodOptional<z.ZodObject<{
|
|
26
|
+
access: z.ZodDefault<z.ZodEnum<{
|
|
27
|
+
public: "public";
|
|
28
|
+
protected: "protected";
|
|
29
|
+
}>>;
|
|
30
|
+
}, z.core.$strict>>;
|
|
31
|
+
network: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<{
|
|
32
|
+
internet: "internet";
|
|
33
|
+
blocked: "blocked";
|
|
34
|
+
}>, z.ZodObject<{
|
|
35
|
+
allow: z.ZodArray<z.ZodString>;
|
|
36
|
+
}, z.core.$strict>]>>;
|
|
37
|
+
resources: z.ZodOptional<z.ZodObject<{
|
|
38
|
+
vcpus: z.ZodOptional<z.ZodNumber>;
|
|
39
|
+
memoryMiB: z.ZodOptional<z.ZodNumber>;
|
|
40
|
+
}, z.core.$strict>>;
|
|
41
|
+
lifecycle: z.ZodDefault<z.ZodObject<{
|
|
42
|
+
lifetimeSeconds: z.ZodOptional<z.ZodNumber>;
|
|
43
|
+
}, z.core.$strict>>;
|
|
44
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
45
|
+
apiKey: z.ZodString;
|
|
46
|
+
}, z.core.$strict>, AdapterSession<{
|
|
47
|
+
size: "small" | "medium" | "large";
|
|
48
|
+
runtime: "node" | "python" | "golang" | "ruby" | "rust" | "node-alpine" | "python-alpine" | "golang-alpine" | "ruby-alpine" | "rust-alpine";
|
|
49
|
+
network_policy: {
|
|
50
|
+
mode: "custom" | "allow-all" | "deny-all";
|
|
51
|
+
allowed_domains?: string[] | undefined;
|
|
52
|
+
allowed_cidrs?: string[] | undefined;
|
|
53
|
+
denied_cidrs?: string[] | undefined;
|
|
54
|
+
};
|
|
55
|
+
labels: string[];
|
|
56
|
+
ttl?: number | undefined;
|
|
57
|
+
env_vars?: Record<string, string> | undefined;
|
|
58
|
+
snapshot_id?: string | undefined;
|
|
59
|
+
}, {
|
|
60
|
+
id: string;
|
|
61
|
+
reference?: {
|
|
62
|
+
version: 1;
|
|
63
|
+
provider: string;
|
|
64
|
+
scope: {
|
|
65
|
+
authority: {
|
|
66
|
+
kind: string;
|
|
67
|
+
id: string;
|
|
68
|
+
};
|
|
69
|
+
partition: Record<string, string>;
|
|
70
|
+
};
|
|
71
|
+
nativeId: string;
|
|
72
|
+
ownership: "unknown" | "borrowed" | "verified-created";
|
|
73
|
+
kind: "sandbox";
|
|
74
|
+
generation?: string | undefined;
|
|
75
|
+
history?: z.core.util.JSONType | undefined;
|
|
76
|
+
receipt?: string | undefined;
|
|
77
|
+
} | undefined;
|
|
78
|
+
storage?: "require-durable" | "allow-unconfirmed" | undefined;
|
|
79
|
+
}, ExecInput, import("@beachside/adapter").FileWriteInput, "argv" | "shell", {
|
|
80
|
+
id: string;
|
|
81
|
+
size: "small" | "medium" | "large";
|
|
82
|
+
labels: string[];
|
|
83
|
+
policy: string;
|
|
84
|
+
runtime: "node" | "python" | "golang" | "ruby" | "rust" | "node-alpine" | "python-alpine" | "golang-alpine" | "ruby-alpine" | "rust-alpine";
|
|
85
|
+
boxKind: "ephemeral" | "regular";
|
|
86
|
+
keepAlive: boolean;
|
|
87
|
+
ttl?: number | undefined;
|
|
88
|
+
expiryAcknowledged?: true | undefined;
|
|
89
|
+
restore?: boolean | undefined;
|
|
90
|
+
}>>;
|
|
91
|
+
export declare function defineUpstashBoxAdapter(origin: string, options: UpstashBoxAdapterOptions): import("@beachside/adapter").AdapterDefinition<z.ZodObject<{
|
|
92
|
+
image: z.ZodDefault<z.ZodEnum<{
|
|
93
|
+
node: "node";
|
|
94
|
+
python: "python";
|
|
95
|
+
golang: "golang";
|
|
96
|
+
ruby: "ruby";
|
|
97
|
+
rust: "rust";
|
|
98
|
+
"node-alpine": "node-alpine";
|
|
99
|
+
"python-alpine": "python-alpine";
|
|
100
|
+
"golang-alpine": "golang-alpine";
|
|
101
|
+
"ruby-alpine": "ruby-alpine";
|
|
102
|
+
"rust-alpine": "rust-alpine";
|
|
103
|
+
}>>;
|
|
104
|
+
boxKind: z.ZodDefault<z.ZodEnum<{
|
|
105
|
+
ephemeral: "ephemeral";
|
|
106
|
+
regular: "regular";
|
|
107
|
+
}>>;
|
|
108
|
+
keepAlive: z.ZodDefault<z.ZodBoolean>;
|
|
109
|
+
preview: z.ZodOptional<z.ZodObject<{
|
|
110
|
+
access: z.ZodDefault<z.ZodEnum<{
|
|
111
|
+
public: "public";
|
|
112
|
+
protected: "protected";
|
|
113
|
+
}>>;
|
|
114
|
+
}, z.core.$strict>>;
|
|
115
|
+
network: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<{
|
|
116
|
+
internet: "internet";
|
|
117
|
+
blocked: "blocked";
|
|
118
|
+
}>, z.ZodObject<{
|
|
119
|
+
allow: z.ZodArray<z.ZodString>;
|
|
120
|
+
}, z.core.$strict>]>>;
|
|
121
|
+
resources: z.ZodOptional<z.ZodObject<{
|
|
122
|
+
vcpus: z.ZodOptional<z.ZodNumber>;
|
|
123
|
+
memoryMiB: z.ZodOptional<z.ZodNumber>;
|
|
124
|
+
}, z.core.$strict>>;
|
|
125
|
+
lifecycle: z.ZodDefault<z.ZodObject<{
|
|
126
|
+
lifetimeSeconds: z.ZodOptional<z.ZodNumber>;
|
|
127
|
+
}, z.core.$strict>>;
|
|
128
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
129
|
+
apiKey: z.ZodString;
|
|
130
|
+
}, z.core.$strict>, AdapterSession<{
|
|
131
|
+
size: "small" | "medium" | "large";
|
|
132
|
+
runtime: "node" | "python" | "golang" | "ruby" | "rust" | "node-alpine" | "python-alpine" | "golang-alpine" | "ruby-alpine" | "rust-alpine";
|
|
133
|
+
network_policy: {
|
|
134
|
+
mode: "custom" | "allow-all" | "deny-all";
|
|
135
|
+
allowed_domains?: string[] | undefined;
|
|
136
|
+
allowed_cidrs?: string[] | undefined;
|
|
137
|
+
denied_cidrs?: string[] | undefined;
|
|
138
|
+
};
|
|
139
|
+
labels: string[];
|
|
140
|
+
ttl?: number | undefined;
|
|
141
|
+
env_vars?: Record<string, string> | undefined;
|
|
142
|
+
snapshot_id?: string | undefined;
|
|
143
|
+
}, {
|
|
144
|
+
id: string;
|
|
145
|
+
reference?: {
|
|
146
|
+
version: 1;
|
|
147
|
+
provider: string;
|
|
148
|
+
scope: {
|
|
149
|
+
authority: {
|
|
150
|
+
kind: string;
|
|
151
|
+
id: string;
|
|
152
|
+
};
|
|
153
|
+
partition: Record<string, string>;
|
|
154
|
+
};
|
|
155
|
+
nativeId: string;
|
|
156
|
+
ownership: "unknown" | "borrowed" | "verified-created";
|
|
157
|
+
kind: "sandbox";
|
|
158
|
+
generation?: string | undefined;
|
|
159
|
+
history?: z.core.util.JSONType | undefined;
|
|
160
|
+
receipt?: string | undefined;
|
|
161
|
+
} | undefined;
|
|
162
|
+
storage?: "require-durable" | "allow-unconfirmed" | undefined;
|
|
163
|
+
}, ExecInput, import("@beachside/adapter").FileWriteInput, "argv" | "shell", {
|
|
164
|
+
id: string;
|
|
165
|
+
size: "small" | "medium" | "large";
|
|
166
|
+
labels: string[];
|
|
167
|
+
policy: string;
|
|
168
|
+
runtime: "node" | "python" | "golang" | "ruby" | "rust" | "node-alpine" | "python-alpine" | "golang-alpine" | "ruby-alpine" | "rust-alpine";
|
|
169
|
+
boxKind: "ephemeral" | "regular";
|
|
170
|
+
keepAlive: boolean;
|
|
171
|
+
ttl?: number | undefined;
|
|
172
|
+
expiryAcknowledged?: true | undefined;
|
|
173
|
+
restore?: boolean | undefined;
|
|
174
|
+
}>>;
|
|
175
|
+
export declare const upstashBoxAdapter: import("@beachside/adapter").AdapterDefinition<z.ZodObject<{
|
|
176
|
+
image: z.ZodDefault<z.ZodEnum<{
|
|
177
|
+
node: "node";
|
|
178
|
+
python: "python";
|
|
179
|
+
golang: "golang";
|
|
180
|
+
ruby: "ruby";
|
|
181
|
+
rust: "rust";
|
|
182
|
+
"node-alpine": "node-alpine";
|
|
183
|
+
"python-alpine": "python-alpine";
|
|
184
|
+
"golang-alpine": "golang-alpine";
|
|
185
|
+
"ruby-alpine": "ruby-alpine";
|
|
186
|
+
"rust-alpine": "rust-alpine";
|
|
187
|
+
}>>;
|
|
188
|
+
boxKind: z.ZodDefault<z.ZodEnum<{
|
|
189
|
+
ephemeral: "ephemeral";
|
|
190
|
+
regular: "regular";
|
|
191
|
+
}>>;
|
|
192
|
+
keepAlive: z.ZodDefault<z.ZodBoolean>;
|
|
193
|
+
preview: z.ZodOptional<z.ZodObject<{
|
|
194
|
+
access: z.ZodDefault<z.ZodEnum<{
|
|
195
|
+
public: "public";
|
|
196
|
+
protected: "protected";
|
|
197
|
+
}>>;
|
|
198
|
+
}, z.core.$strict>>;
|
|
199
|
+
network: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<{
|
|
200
|
+
internet: "internet";
|
|
201
|
+
blocked: "blocked";
|
|
202
|
+
}>, z.ZodObject<{
|
|
203
|
+
allow: z.ZodArray<z.ZodString>;
|
|
204
|
+
}, z.core.$strict>]>>;
|
|
205
|
+
resources: z.ZodOptional<z.ZodObject<{
|
|
206
|
+
vcpus: z.ZodOptional<z.ZodNumber>;
|
|
207
|
+
memoryMiB: z.ZodOptional<z.ZodNumber>;
|
|
208
|
+
}, z.core.$strict>>;
|
|
209
|
+
lifecycle: z.ZodDefault<z.ZodObject<{
|
|
210
|
+
lifetimeSeconds: z.ZodOptional<z.ZodNumber>;
|
|
211
|
+
}, z.core.$strict>>;
|
|
212
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
213
|
+
apiKey: z.ZodString;
|
|
214
|
+
}, z.core.$strict>, AdapterSession<{
|
|
215
|
+
size: "small" | "medium" | "large";
|
|
216
|
+
runtime: "node" | "python" | "golang" | "ruby" | "rust" | "node-alpine" | "python-alpine" | "golang-alpine" | "ruby-alpine" | "rust-alpine";
|
|
217
|
+
network_policy: {
|
|
218
|
+
mode: "custom" | "allow-all" | "deny-all";
|
|
219
|
+
allowed_domains?: string[] | undefined;
|
|
220
|
+
allowed_cidrs?: string[] | undefined;
|
|
221
|
+
denied_cidrs?: string[] | undefined;
|
|
222
|
+
};
|
|
223
|
+
labels: string[];
|
|
224
|
+
ttl?: number | undefined;
|
|
225
|
+
env_vars?: Record<string, string> | undefined;
|
|
226
|
+
snapshot_id?: string | undefined;
|
|
227
|
+
}, {
|
|
228
|
+
id: string;
|
|
229
|
+
reference?: {
|
|
230
|
+
version: 1;
|
|
231
|
+
provider: string;
|
|
232
|
+
scope: {
|
|
233
|
+
authority: {
|
|
234
|
+
kind: string;
|
|
235
|
+
id: string;
|
|
236
|
+
};
|
|
237
|
+
partition: Record<string, string>;
|
|
238
|
+
};
|
|
239
|
+
nativeId: string;
|
|
240
|
+
ownership: "unknown" | "borrowed" | "verified-created";
|
|
241
|
+
kind: "sandbox";
|
|
242
|
+
generation?: string | undefined;
|
|
243
|
+
history?: z.core.util.JSONType | undefined;
|
|
244
|
+
receipt?: string | undefined;
|
|
245
|
+
} | undefined;
|
|
246
|
+
storage?: "require-durable" | "allow-unconfirmed" | undefined;
|
|
247
|
+
}, ExecInput, import("@beachside/adapter").FileWriteInput, "argv" | "shell", {
|
|
248
|
+
id: string;
|
|
249
|
+
size: "small" | "medium" | "large";
|
|
250
|
+
labels: string[];
|
|
251
|
+
policy: string;
|
|
252
|
+
runtime: "node" | "python" | "golang" | "ruby" | "rust" | "node-alpine" | "python-alpine" | "golang-alpine" | "ruby-alpine" | "rust-alpine";
|
|
253
|
+
boxKind: "ephemeral" | "regular";
|
|
254
|
+
keepAlive: boolean;
|
|
255
|
+
ttl?: number | undefined;
|
|
256
|
+
expiryAcknowledged?: true | undefined;
|
|
257
|
+
restore?: boolean | undefined;
|
|
258
|
+
}>>;
|
package/dist/exec.d.ts
ADDED
|
@@ -0,0 +1,10 @@
|
|
|
1
|
+
import { type ExecInput, type ExecValue } from "@beachside/adapter";
|
|
2
|
+
export declare const MAX_OUTPUT_BYTES: number;
|
|
3
|
+
export declare class ExecLoss extends Error {
|
|
4
|
+
readonly output: ExecValue;
|
|
5
|
+
constructor(output: ExecValue);
|
|
6
|
+
}
|
|
7
|
+
export declare function createExec(origin: string, apiKey: string): {
|
|
8
|
+
exec: (input: ExecInput, signal: AbortSignal) => Promise<ExecValue>;
|
|
9
|
+
close: () => void;
|
|
10
|
+
};
|
|
@@ -0,0 +1,15 @@
|
|
|
1
|
+
import { type ExecInput, type ExecValue, type FileTransferContext, type Sandbox } from "@beachside/adapter";
|
|
2
|
+
export type GuestRunner = (input: ExecInput, signal: AbortSignal) => Promise<ExecValue>;
|
|
3
|
+
export declare const MAKE_STAGE = "mkdir -m 700 -- \"$1\"";
|
|
4
|
+
export declare const REMOVE_STAGE = "rm -rf -- \"$1\"";
|
|
5
|
+
export declare const APPEND_STAGE = "cat -- \"$1/chunk\" >> \"$1/data\"";
|
|
6
|
+
export declare const COPY_STAGE = "cp -P -- \"$1\" \"$2/data\" && [ ! -L \"$2/data\" ] && [ -f \"$2/data\" ]";
|
|
7
|
+
export declare const LINK_STAGE = "\nif ln -T -- \"$1/data\" \"$2\"; then exit 0; fi\nif [ -e \"$2\" ] || [ -L \"$2\" ]; then exit 73; fi\nexit 74\n";
|
|
8
|
+
export declare const REMOVE_EMPTY_DIRECTORY = "rmdir -- \"$1\"";
|
|
9
|
+
export declare function guest(run: GuestRunner, sandbox: Sandbox, script: string, args: string[], signal: AbortSignal): Promise<number | null>;
|
|
10
|
+
/** Keep unpublished bytes in a single private directory beside the destination. */
|
|
11
|
+
export declare function stagedFile(run: GuestRunner, input: {
|
|
12
|
+
sandbox: Sandbox;
|
|
13
|
+
destination: string;
|
|
14
|
+
source?: string;
|
|
15
|
+
}, ctx: FileTransferContext, fill: (stage: string) => Promise<void>, publish: (stage: string) => Promise<void>): Promise<void>;
|
package/dist/files.d.ts
ADDED
|
@@ -0,0 +1,52 @@
|
|
|
1
|
+
import { type AttemptContext, type FileEntry, type FileMutationInput, type FileStat, type FileTransferContext, type FileTransferInput, type FileWriteInput, type ReadContext, type Sandbox } from "@beachside/adapter";
|
|
2
|
+
import { type GuestRunner } from "./files-shell.js";
|
|
3
|
+
import { type Transport } from "./transport.js";
|
|
4
|
+
export declare const MAX_FILE_BYTES: number;
|
|
5
|
+
type PathInput = {
|
|
6
|
+
sandbox: Sandbox;
|
|
7
|
+
path: string;
|
|
8
|
+
};
|
|
9
|
+
type StreamWriteInput = PathInput & {
|
|
10
|
+
overwrite: boolean;
|
|
11
|
+
bytes: AsyncIterable<Uint8Array>;
|
|
12
|
+
};
|
|
13
|
+
export declare function boxPath(id: string): string;
|
|
14
|
+
export declare function boxFiles(transport: Transport, run: GuestRunner, identify: (sandbox: Sandbox) => string, guardGuest?: (sandbox: Sandbox, signal: AbortSignal) => Promise<void>): {
|
|
15
|
+
maxBytes: number;
|
|
16
|
+
read(input: PathInput & {
|
|
17
|
+
maxBytes?: number;
|
|
18
|
+
}, { signal }: ReadContext): Promise<Buffer<ArrayBufferLike> | Uint8Array<ArrayBuffer>>;
|
|
19
|
+
readStream(input: PathInput, { signal }: ReadContext): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
|
|
20
|
+
list: (input: PathInput, { signal }: ReadContext) => Promise<FileEntry[]>;
|
|
21
|
+
readDirectory(input: PathInput, ctx: ReadContext): Promise<{
|
|
22
|
+
entries: FileEntry[];
|
|
23
|
+
completeness: "complete";
|
|
24
|
+
observedAt: string;
|
|
25
|
+
}>;
|
|
26
|
+
stat(input: PathInput & {
|
|
27
|
+
followSymlinks: boolean;
|
|
28
|
+
}, { signal }: ReadContext): Promise<FileStat>;
|
|
29
|
+
exists(input: PathInput, { signal }: ReadContext): Promise<boolean>;
|
|
30
|
+
makeDirectory: {
|
|
31
|
+
prepare(input: FileMutationInput, { signal }: ReadContext): Promise<FileMutationInput>;
|
|
32
|
+
submit(input: FileMutationInput, ctx: AttemptContext): Promise<import("@beachside/adapter").Rejected | import("@beachside/adapter").Unknown | {
|
|
33
|
+
acknowledged: true;
|
|
34
|
+
}>;
|
|
35
|
+
};
|
|
36
|
+
remove(input: FileMutationInput, ctx: AttemptContext): Promise<import("@beachside/adapter").Rejected | import("@beachside/adapter").Unknown | {
|
|
37
|
+
acknowledged: true;
|
|
38
|
+
}>;
|
|
39
|
+
write(input: FileWriteInput, ctx: AttemptContext): Promise<import("@beachside/adapter").Rejected | import("@beachside/adapter").Unknown | {
|
|
40
|
+
bytesWritten: number;
|
|
41
|
+
}>;
|
|
42
|
+
writeStream(input: StreamWriteInput, ctx: FileTransferContext): Promise<{
|
|
43
|
+
bytesWritten: number;
|
|
44
|
+
}>;
|
|
45
|
+
copy(input: FileTransferInput, ctx: FileTransferContext): Promise<{
|
|
46
|
+
acknowledged: true;
|
|
47
|
+
}>;
|
|
48
|
+
move(input: FileTransferInput, ctx: FileTransferContext): Promise<{
|
|
49
|
+
acknowledged: true;
|
|
50
|
+
}>;
|
|
51
|
+
};
|
|
52
|
+
export {};
|
package/dist/index.d.ts
ADDED
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+
import { type BoundAdapter } from "@beachside/adapter";
|
|
2
|
+
import type { z } from "zod";
|
|
3
|
+
import { upstashBoxAdapter } from "./adapter.js";
|
|
4
|
+
export { createUpstashBoxAdapter, upstashBoxAdapter, type UpstashBoxAdapterOptions, } from "./adapter.js";
|
|
5
|
+
export type UpstashBoxOptions = z.input<typeof upstashBoxAdapter.credentials> & z.input<typeof upstashBoxAdapter.config>;
|
|
6
|
+
export declare function upstashBox(options: UpstashBoxOptions): BoundAdapter;
|