@voltro/plugin-storage 0.1.0

package/dist/rpc.d.ts

@@ -0,0 +1,272 @@
+import { ActionProcedureDescriptor } from '@voltro/protocol';
+import { MutationProcedureDescriptor } from '@voltro/protocol';
+import { PluginRpcClientDescriptor } from '@voltro/protocol';
+import { QueryProcedureDescriptor } from '@voltro/protocol';
+import { Schema } from 'effect';
+
+export declare const abortMultipartUploadDescriptor: ActionProcedureDescriptor<"storage.abortMultipartUpload", Schema.Struct<{
+    multipartToken: typeof Schema.String;
+}>, Schema.Struct<{
+    ok: typeof Schema.Boolean;
+}>, typeof StorageError>;
+
+export declare const beginMultipartUploadDescriptor: ActionProcedureDescriptor<"storage.beginMultipartUpload", Schema.Struct<{
+    contentType: typeof Schema.String;
+    size: typeof Schema.Number;
+    visibility: Schema.optional<Schema.Literal<["public", "private"]>>;
+    folder: Schema.optional<typeof Schema.String>;
+    tags: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    alt: Schema.optional<typeof Schema.String>;
+    caption: Schema.optional<typeof Schema.String>;
+    partSize: Schema.optional<typeof Schema.Number>;
+    expiresInSec: Schema.optional<typeof Schema.Number>;
+}>, Schema.Struct<{
+    multipartToken: typeof Schema.String;
+    partSize: typeof Schema.Number;
+    expiresInSec: typeof Schema.Number;
+}>, typeof StorageError>;
+
+export declare const beginResumableUploadDescriptor: ActionProcedureDescriptor<"storage.beginResumableUpload", Schema.Struct<{
+    contentType: typeof Schema.String;
+    size: typeof Schema.Number;
+    visibility: Schema.optional<Schema.Literal<["public", "private"]>>;
+    folder: Schema.optional<typeof Schema.String>;
+    tags: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    alt: Schema.optional<typeof Schema.String>;
+    caption: Schema.optional<typeof Schema.String>;
+    chunkSize: Schema.optional<typeof Schema.Number>;
+    expiresInSec: Schema.optional<typeof Schema.Number>;
+}>, Schema.Struct<{
+    uploadId: typeof Schema.String;
+    resumableToken: typeof Schema.String;
+    uploadUrl: typeof Schema.String;
+    chunkSize: typeof Schema.Number;
+    expiresInSec: typeof Schema.Number;
+}>, typeof StorageError>;
+
+export declare const completeMultipartUploadDescriptor: ActionProcedureDescriptor<"storage.completeMultipartUpload", Schema.Struct<{
+    multipartToken: typeof Schema.String;
+    parts: Schema.Array$<Schema.Struct<{
+        partNumber: typeof Schema.Number;
+        etag: typeof Schema.String;
+    }>>;
+}>, Schema.Struct<{
+    id: typeof Schema.String;
+    url: typeof Schema.String;
+    size: typeof Schema.Number;
+}>, Schema.Union<[typeof StorageError, typeof StorageRejected]>>;
+
+export declare const finalizeUploadDescriptor: ActionProcedureDescriptor<"storage.finalizeUpload", Schema.Struct<{
+    finalizeToken: typeof Schema.String;
+}>, Schema.Struct<{
+    id: typeof Schema.String;
+    url: typeof Schema.String;
+    contentType: typeof Schema.String;
+    size: typeof Schema.Number;
+    width: Schema.optional<typeof Schema.Number>;
+    height: Schema.optional<typeof Schema.Number>;
+}>, Schema.Union<[typeof StorageError, typeof StorageRejected, typeof StorageScanRejected]>>;
+
+export declare const ingestUrlDescriptor: ActionProcedureDescriptor<"storage.ingestUrl", Schema.Struct<{
+    url: typeof Schema.String;
+    visibility: Schema.optional<Schema.Literal<["public", "private"]>>;
+    folder: Schema.optional<typeof Schema.String>;
+    tags: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    alt: Schema.optional<typeof Schema.String>;
+    caption: Schema.optional<typeof Schema.String>;
+    key: Schema.optional<typeof Schema.String>;
+}>, Schema.Struct<{
+    id: typeof Schema.String;
+    url: typeof Schema.String;
+}>, Schema.Union<[typeof StorageError, typeof StorageRejected, typeof StorageScanRejected]>>;
+
+export declare const listGrantsDescriptor: QueryProcedureDescriptor<"storage.listGrants", Schema.Struct<{
+    refId: typeof Schema.String;
+}>, Schema.Struct<{
+    grants: Schema.Array$<Schema.Struct<{
+        id: typeof Schema.String;
+        refId: typeof Schema.String;
+        principalType: Schema.Literal<["user", "group", "apiKey"]>;
+        principalId: typeof Schema.String;
+        permission: Schema.Literal<["read", "write"]>;
+        createdAt: typeof Schema.String;
+        expiresAt: Schema.NullOr<typeof Schema.String>;
+        createdBy: Schema.NullOr<typeof Schema.String>;
+    }>>;
+}>, typeof StorageError>;
+
+/** Browse / search the stored refs by folder-prefix / tags / ownerId, paged.
+ *  The media-library / file-manager read (F6). Tenant is taken from the caller
+ *  subject server-side — a client can't list another tenant's objects. */
+export declare const listRefsDescriptor: QueryProcedureDescriptor<"storage.listRefs", Schema.Struct<{
+    folder: Schema.optional<typeof Schema.String>;
+    tags: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    ownerId: Schema.optional<typeof Schema.String>;
+    includeDerived: Schema.optional<typeof Schema.Boolean>;
+    limit: Schema.optional<typeof Schema.Number>;
+    offset: Schema.optional<typeof Schema.Number>;
+}>, Schema.Struct<{
+    refs: Schema.Array$<Schema.Struct<{
+        id: typeof Schema.String;
+        tenantId: Schema.NullOr<typeof Schema.String>;
+        ownerId: Schema.NullOr<typeof Schema.String>;
+        bucket: typeof Schema.String;
+        key: typeof Schema.String;
+        contentType: typeof Schema.String;
+        size: typeof Schema.Number;
+        checksum: typeof Schema.String;
+        visibility: Schema.Literal<["public", "private"]>;
+        hasPassword: typeof Schema.Boolean;
+        createdAt: typeof Schema.String;
+        width: Schema.NullOr<typeof Schema.Number>;
+        height: Schema.NullOr<typeof Schema.Number>;
+        duration: Schema.NullOr<typeof Schema.Number>;
+        placeholder: Schema.NullOr<typeof Schema.String>;
+        folder: Schema.NullOr<typeof Schema.String>;
+        tags: Schema.NullOr<Schema.Array$<typeof Schema.String>>;
+        alt: Schema.NullOr<typeof Schema.String>;
+        caption: Schema.NullOr<typeof Schema.String>;
+        derivedFrom: Schema.NullOr<typeof Schema.String>;
+        kind: Schema.NullOr<typeof Schema.String>;
+    }>>;
+    nextOffset: Schema.NullOr<typeof Schema.Number>;
+}>, typeof StorageError>;
+
+export declare const mintPresignedUploadDescriptor: ActionProcedureDescriptor<"storage.mintPresignedUpload", Schema.Struct<{
+    contentType: typeof Schema.String;
+    visibility: Schema.optional<Schema.Literal<["public", "private"]>>;
+    folder: Schema.optional<typeof Schema.String>;
+    tags: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    alt: Schema.optional<typeof Schema.String>;
+    caption: Schema.optional<typeof Schema.String>;
+    expiresInSec: Schema.optional<typeof Schema.Number>;
+}>, Schema.Struct<{
+    uploadUrl: typeof Schema.String;
+    finalizeToken: typeof Schema.String;
+    expiresInSec: typeof Schema.Number;
+}>, typeof StorageError>;
+
+export declare const mintUploadTicketDescriptor: ActionProcedureDescriptor<"storage.mintUploadTicket", Schema.Struct<{
+    contentType: typeof Schema.String;
+    visibility: Schema.optional<Schema.Literal<["public", "private"]>>;
+    key: Schema.optional<typeof Schema.String>;
+    folder: Schema.optional<typeof Schema.String>;
+    tags: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    alt: Schema.optional<typeof Schema.String>;
+    caption: Schema.optional<typeof Schema.String>;
+    expiresInSec: Schema.optional<typeof Schema.Number>;
+}>, Schema.Struct<{
+    uploadUrl: typeof Schema.String;
+    expiresInSec: typeof Schema.Number;
+}>, typeof StorageError>;
+
+export declare const mintUploadUrlDescriptor: ActionProcedureDescriptor<"storage.mintUploadUrl", Schema.Struct<{
+    key: typeof Schema.String;
+    contentType: typeof Schema.String;
+    expiresInSec: Schema.optional<typeof Schema.Number>;
+}>, Schema.Struct<{
+    url: typeof Schema.String;
+}>, typeof StorageError>;
+
+export declare const mintUrlDescriptor: ActionProcedureDescriptor<"storage.mintUrl", Schema.Struct<{
+    id: typeof Schema.String;
+    password: Schema.optional<typeof Schema.String>;
+    expiresInSec: Schema.optional<typeof Schema.Number>;
+}>, Schema.Struct<{
+    url: typeof Schema.String;
+}>, Schema.Union<[typeof StorageError, typeof StorageAccessDenied]>>;
+
+export declare const revokeDescriptor: MutationProcedureDescriptor<"storage.revoke", Schema.Struct<{
+    grantId: typeof Schema.String;
+}>, Schema.Struct<{
+    ok: typeof Schema.Boolean;
+}>, typeof StorageError>;
+
+export declare const shareDescriptor: MutationProcedureDescriptor<"storage.share", Schema.Struct<{
+    refId: typeof Schema.String;
+    principalType: Schema.Literal<["user", "group", "apiKey"]>;
+    principalId: typeof Schema.String;
+    permission: Schema.optional<Schema.Literal<["read", "write"]>>;
+    expiresInDays: Schema.optional<typeof Schema.Number>;
+}>, Schema.Struct<{
+    grantId: typeof Schema.String;
+}>, typeof StorageError>;
+
+export declare const signMultipartPartDescriptor: ActionProcedureDescriptor<"storage.signMultipartPart", Schema.Struct<{
+    multipartToken: typeof Schema.String;
+    partNumber: typeof Schema.Number;
+}>, Schema.Struct<{
+    url: typeof Schema.String;
+}>, typeof StorageError>;
+
+/**
+ * Access to a private object was refused. Distinct from `StorageError` so
+ * handlers can tell "not allowed" (403) from "backend blew up" (5xx) and
+ * the wire-error union carries it typed.
+ */
+declare class StorageAccessDenied extends StorageAccessDenied_base {
+}
+
+declare const StorageAccessDenied_base: Schema.TaggedErrorClass<StorageAccessDenied, "StorageAccessDenied", {
+    readonly _tag: Schema.tag<"StorageAccessDenied">;
+} & {
+    refId: typeof Schema.String;
+    reason: typeof Schema.String;
+}>;
+
+/**
+ * Storage failure. `transient` drives retry — `true` for 429 / 5xx /
+ * network blips, `false` for 4xx / config / not-found. Surfaced typed so
+ * handlers can `Effect.catchTag('StorageError', …)`.
+ */
+declare class StorageError extends StorageError_base {
+}
+
+declare const StorageError_base: Schema.TaggedErrorClass<StorageError, "StorageError", {
+    readonly _tag: Schema.tag<"StorageError">;
+} & {
+    provider: typeof Schema.String;
+    message: typeof Schema.String;
+    transient: typeof Schema.Boolean;
+    status: Schema.optional<typeof Schema.Number>;
+}>;
+
+/** An upload was rejected by a constraint (size / content-type / magic-byte
+ *  mismatch). `reason` is a stable code; `detail` is human-readable. */
+declare class StorageRejected extends StorageRejected_base {
+}
+
+declare const StorageRejected_base: Schema.TaggedErrorClass<StorageRejected, "StorageRejected", {
+    readonly _tag: Schema.tag<"StorageRejected">;
+} & {
+    /** `'too-large' | 'content-type-not-allowed' | 'content-mismatch'` */
+    reason: typeof Schema.String;
+    detail: typeof Schema.String;
+}>;
+
+/** Declared for the codegen (`VoltroPlugin.rpcClientDescriptors`) so each tag is
+ *  emitted into the generated client group. Kept in lockstep with the exports. */
+export declare const storageRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
+
+/** An upload was rejected by the virus scanner. */
+declare class StorageScanRejected extends StorageScanRejected_base {
+}
+
+declare const StorageScanRejected_base: Schema.TaggedErrorClass<StorageScanRejected, "StorageScanRejected", {
+    readonly _tag: Schema.tag<"StorageScanRejected">;
+} & {
+    threat: typeof Schema.String;
+}>;
+
+export declare const uploadDescriptor: ActionProcedureDescriptor<"storage.upload", Schema.Struct<{
+    bytesBase64: typeof Schema.String;
+    contentType: typeof Schema.String;
+    visibility: Schema.optional<Schema.Literal<["public", "private"]>>;
+    key: Schema.optional<typeof Schema.String>;
+    password: Schema.optional<typeof Schema.String>;
+}>, Schema.Struct<{
+    id: typeof Schema.String;
+    url: typeof Schema.String;
+}>, Schema.Union<[typeof StorageError, typeof StorageRejected, typeof StorageScanRejected]>>;
+
+export { }

package/dist/rpc.js

@@ -0,0 +1,365 @@
+import { StorageAccessDenied as e, StorageError as t, StorageRejected as n, StorageScanRejected as r } from "./types.js";
+import { Schema as i } from "effect";
+import { defineAction as a, defineMutation as o, defineQuery as s } from "@voltro/protocol";
+//#region src/rpc.ts
+var c = i.Literal("user", "group", "apiKey"), l = i.Literal("read", "write"), u = i.Struct({
+	id: i.String,
+	refId: i.String,
+	principalType: c,
+	principalId: i.String,
+	permission: l,
+	createdAt: i.String,
+	expiresAt: i.NullOr(i.String),
+	createdBy: i.NullOr(i.String)
+}), d = i.Struct({
+	id: i.String,
+	tenantId: i.NullOr(i.String),
+	ownerId: i.NullOr(i.String),
+	bucket: i.String,
+	key: i.String,
+	contentType: i.String,
+	size: i.Number,
+	checksum: i.String,
+	visibility: i.Literal("public", "private"),
+	hasPassword: i.Boolean,
+	createdAt: i.String,
+	width: i.NullOr(i.Number),
+	height: i.NullOr(i.Number),
+	duration: i.NullOr(i.Number),
+	placeholder: i.NullOr(i.String),
+	folder: i.NullOr(i.String),
+	tags: i.NullOr(i.Array(i.String)),
+	alt: i.NullOr(i.String),
+	caption: i.NullOr(i.String),
+	derivedFrom: i.NullOr(i.String),
+	kind: i.NullOr(i.String)
+}), f = s({
+	name: "storage.listRefs",
+	input: i.Struct({
+		folder: i.optional(i.String),
+		tags: i.optional(i.Array(i.String)),
+		ownerId: i.optional(i.String),
+		includeDerived: i.optional(i.Boolean),
+		limit: i.optional(i.Number),
+		offset: i.optional(i.Number)
+	}),
+	output: i.Struct({
+		refs: i.Array(d),
+		nextOffset: i.NullOr(i.Number)
+	}),
+	error: t
+}), p = a({
+	name: "storage.mintUrl",
+	input: i.Struct({
+		id: i.String,
+		password: i.optional(i.String),
+		expiresInSec: i.optional(i.Number)
+	}),
+	output: i.Struct({ url: i.String }),
+	error: i.Union(t, e)
+}), m = a({
+	name: "storage.mintUploadUrl",
+	input: i.Struct({
+		key: i.String,
+		contentType: i.String,
+		expiresInSec: i.optional(i.Number)
+	}),
+	output: i.Struct({ url: i.String }),
+	error: t
+}), h = a({
+	name: "storage.mintUploadTicket",
+	input: i.Struct({
+		contentType: i.String,
+		visibility: i.optional(i.Literal("public", "private")),
+		key: i.optional(i.String),
+		folder: i.optional(i.String),
+		tags: i.optional(i.Array(i.String)),
+		alt: i.optional(i.String),
+		caption: i.optional(i.String),
+		expiresInSec: i.optional(i.Number)
+	}),
+	output: i.Struct({
+		uploadUrl: i.String,
+		expiresInSec: i.Number
+	}),
+	error: t
+}), g = a({
+	name: "storage.mintPresignedUpload",
+	input: i.Struct({
+		contentType: i.String,
+		visibility: i.optional(i.Literal("public", "private")),
+		folder: i.optional(i.String),
+		tags: i.optional(i.Array(i.String)),
+		alt: i.optional(i.String),
+		caption: i.optional(i.String),
+		expiresInSec: i.optional(i.Number)
+	}),
+	output: i.Struct({
+		uploadUrl: i.String,
+		finalizeToken: i.String,
+		expiresInSec: i.Number
+	}),
+	error: t
+}), _ = a({
+	name: "storage.finalizeUpload",
+	input: i.Struct({ finalizeToken: i.String }),
+	output: i.Struct({
+		id: i.String,
+		url: i.String,
+		contentType: i.String,
+		size: i.Number,
+		width: i.optional(i.Number),
+		height: i.optional(i.Number)
+	}),
+	error: i.Union(t, n, r)
+}), v = a({
+	name: "storage.beginResumableUpload",
+	input: i.Struct({
+		contentType: i.String,
+		size: i.Number,
+		visibility: i.optional(i.Literal("public", "private")),
+		folder: i.optional(i.String),
+		tags: i.optional(i.Array(i.String)),
+		alt: i.optional(i.String),
+		caption: i.optional(i.String),
+		chunkSize: i.optional(i.Number),
+		expiresInSec: i.optional(i.Number)
+	}),
+	output: i.Struct({
+		uploadId: i.String,
+		resumableToken: i.String,
+		uploadUrl: i.String,
+		chunkSize: i.Number,
+		expiresInSec: i.Number
+	}),
+	error: t
+}), y = a({
+	name: "storage.beginMultipartUpload",
+	input: i.Struct({
+		contentType: i.String,
+		size: i.Number,
+		visibility: i.optional(i.Literal("public", "private")),
+		folder: i.optional(i.String),
+		tags: i.optional(i.Array(i.String)),
+		alt: i.optional(i.String),
+		caption: i.optional(i.String),
+		partSize: i.optional(i.Number),
+		expiresInSec: i.optional(i.Number)
+	}),
+	output: i.Struct({
+		multipartToken: i.String,
+		partSize: i.Number,
+		expiresInSec: i.Number
+	}),
+	error: t
+}), b = a({
+	name: "storage.signMultipartPart",
+	input: i.Struct({
+		multipartToken: i.String,
+		partNumber: i.Number
+	}),
+	output: i.Struct({ url: i.String }),
+	error: t
+}), x = a({
+	name: "storage.completeMultipartUpload",
+	input: i.Struct({
+		multipartToken: i.String,
+		parts: i.Array(i.Struct({
+			partNumber: i.Number,
+			etag: i.String
+		}))
+	}),
+	output: i.Struct({
+		id: i.String,
+		url: i.String,
+		size: i.Number
+	}),
+	error: i.Union(t, n)
+}), S = a({
+	name: "storage.abortMultipartUpload",
+	input: i.Struct({ multipartToken: i.String }),
+	output: i.Struct({ ok: i.Boolean }),
+	error: t
+}), C = a({
+	name: "storage.upload",
+	input: i.Struct({
+		bytesBase64: i.String,
+		contentType: i.String,
+		visibility: i.optional(i.Literal("public", "private")),
+		key: i.optional(i.String),
+		password: i.optional(i.String)
+	}),
+	output: i.Struct({
+		id: i.String,
+		url: i.String
+	}),
+	error: i.Union(t, n, r)
+}), w = a({
+	name: "storage.ingestUrl",
+	input: i.Struct({
+		url: i.String,
+		visibility: i.optional(i.Literal("public", "private")),
+		folder: i.optional(i.String),
+		tags: i.optional(i.Array(i.String)),
+		alt: i.optional(i.String),
+		caption: i.optional(i.String),
+		key: i.optional(i.String)
+	}),
+	output: i.Struct({
+		id: i.String,
+		url: i.String
+	}),
+	error: i.Union(t, n, r)
+}), T = o({
+	name: "storage.share",
+	input: i.Struct({
+		refId: i.String,
+		principalType: c,
+		principalId: i.String,
+		permission: i.optional(l),
+		expiresInDays: i.optional(i.Number)
+	}),
+	output: i.Struct({ grantId: i.String }),
+	error: t
+}), E = o({
+	name: "storage.revoke",
+	input: i.Struct({ grantId: i.String }),
+	output: i.Struct({ ok: i.Boolean }),
+	error: t
+}), D = s({
+	name: "storage.listGrants",
+	input: i.Struct({ refId: i.String }),
+	output: i.Struct({ grants: i.Array(u) }),
+	error: t
+}), O = [
+	{
+		tag: "storage.mintUrl",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-storage/rpc",
+			name: "mintUrlDescriptor"
+		}
+	},
+	{
+		tag: "storage.mintUploadUrl",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-storage/rpc",
+			name: "mintUploadUrlDescriptor"
+		}
+	},
+	{
+		tag: "storage.mintUploadTicket",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-storage/rpc",
+			name: "mintUploadTicketDescriptor"
+		}
+	},
+	{
+		tag: "storage.mintPresignedUpload",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-storage/rpc",
+			name: "mintPresignedUploadDescriptor"
+		}
+	},
+	{
+		tag: "storage.finalizeUpload",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-storage/rpc",
+			name: "finalizeUploadDescriptor"
+		}
+	},
+	{
+		tag: "storage.beginResumableUpload",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-storage/rpc",
+			name: "beginResumableUploadDescriptor"
+		}
+	},
+	{
+		tag: "storage.beginMultipartUpload",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-storage/rpc",
+			name: "beginMultipartUploadDescriptor"
+		}
+	},
+	{
+		tag: "storage.signMultipartPart",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-storage/rpc",
+			name: "signMultipartPartDescriptor"
+		}
+	},
+	{
+		tag: "storage.completeMultipartUpload",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-storage/rpc",
+			name: "completeMultipartUploadDescriptor"
+		}
+	},
+	{
+		tag: "storage.abortMultipartUpload",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-storage/rpc",
+			name: "abortMultipartUploadDescriptor"
+		}
+	},
+	{
+		tag: "storage.upload",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-storage/rpc",
+			name: "uploadDescriptor"
+		}
+	},
+	{
+		tag: "storage.ingestUrl",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-storage/rpc",
+			name: "ingestUrlDescriptor"
+		}
+	},
+	{
+		tag: "storage.share",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-storage/rpc",
+			name: "shareDescriptor"
+		}
+	},
+	{
+		tag: "storage.revoke",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-storage/rpc",
+			name: "revokeDescriptor"
+		}
+	},
+	{
+		tag: "storage.listGrants",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-storage/rpc",
+			name: "listGrantsDescriptor"
+		}
+	},
+	{
+		tag: "storage.listRefs",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-storage/rpc",
+			name: "listRefsDescriptor"
+		}
+	}
+];
+//#endregion
+export { S as abortMultipartUploadDescriptor, y as beginMultipartUploadDescriptor, v as beginResumableUploadDescriptor, x as completeMultipartUploadDescriptor, _ as finalizeUploadDescriptor, w as ingestUrlDescriptor, D as listGrantsDescriptor, f as listRefsDescriptor, g as mintPresignedUploadDescriptor, h as mintUploadTicketDescriptor, m as mintUploadUrlDescriptor, p as mintUrlDescriptor, E as revokeDescriptor, T as shareDescriptor, b as signMultipartPartDescriptor, O as storageRpcClientImports, C as uploadDescriptor };