jmap-kit 0.0.0 → 1.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lachlan Hunt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,7 +1,142 @@
 # jmap-kit
 
-A comprehensive, type-safe JMAP SDK for building JMAP-based client applications.
+[![GitHub](https://img.shields.io/badge/GitHub-jmap--kit-blue?logo=github)](https://github.com/lachlanhunt/jmap-kit)
+[![npm](https://img.shields.io/npm/v/jmap-kit?logo=npm)](https://www.npmjs.com/package/jmap-kit)
 
-This is a placeholder package. The first release is coming soon.
+A typed TypeScript library for building [JMAP](https://jmap.io/) clients. It handles session discovery, request building with type-safe invocation factories, response dispatching, file operations, and a plugin system for validation and transformation — so you can focus on your application instead of the protocol.
 
-See the [GitHub repository](https://github.com/lachlanhunt/jmap-kit) for more information.
+See the complete [jmap-kit Documentation](https://lachlanhunt.github.io/jmap-kit/).
+
+## Using jmap-kit
+
+### Features
+
+- **Session management**: automatic discovery via `.well-known/jmap`, session state tracking, staleness detection
+- **Type-safe invocations**: factory functions for every JMAP method, with compile-time enforcement of argument types and property names
+- **Result references**: chain dependent method calls within a single request without extra round trips
+- **Request building**: combine multiple method calls into one request with automatic capability URI inclusion and ID management
+- **Response dispatching**: route responses to handlers by method name, data type, or invocation ID
+- **File operations**: upload and download with server limit enforcement and automatic concurrency control
+- **Plugin system**: validation and transformation hooks at each stage of request processing
+- **Server limit enforcement**: built-in validators for `maxObjectsInGet`, `maxObjectsInSet`, `maxCallsInRequest`, `maxSizeRequest`, and read-only accounts
+- **Extensible**: define custom capabilities with their own types, invocations, validators, and transformers
+
+### Installation
+
+```bash
+npm install jmap-kit
+```
+
+```bash
+yarn add jmap-kit
+```
+
+```bash
+pnpm add jmap-kit
+```
+
+### Quick Example
+
+```typescript
+import { JMAPClient, EmailCapability, Mailbox } from "jmap-kit";
+
+const transport = /* your HTTP transport (see Developer Guide) */;
+const client = new JMAPClient(transport, { hostname: "api.example.com" });
+client.registerCapabilities(EmailCapability);
+
+await client.connect();
+
+const accountId = client.primaryAccounts["urn:ietf:params:jmap:mail"];
+
+// Query for the Inbox, then fetch it — in a single request
+const query = Mailbox.request.query({
+    accountId,
+    filter: { role: "inbox" },
+});
+
+const get = Mailbox.request.get({
+    accountId,
+    ids: query.createReference("/ids"),
+    properties: ["id", "name", "role", "totalEmails", "unreadEmails"],
+});
+
+const request = client.createRequestBuilder().add(query).add(get);
+const response = await request.send();
+
+await response.methodResponses.dispatch({
+    "Mailbox/get": (invocation) => {
+        const mailboxes = invocation.getArgument("list");
+        console.log("Inbox:", mailboxes);
+    },
+    error: (invocation) => {
+        console.error("Error:", invocation.type);
+    },
+});
+
+await client.disconnect();
+```
+
+### Documentation
+
+See the [Developer Guide](./guide/README.md) for comprehensive documentation covering session management, capabilities, invocations, request building, response handling, file operations, customisation, the plugin system, and creating custom capabilities.
+
+## Development
+
+### Setup
+
+```bash
+git clone <repository-url>
+cd jmap-kit
+yarn install
+```
+
+### Scripts
+
+| Command             | Description                                                         |
+| ------------------- | ------------------------------------------------------------------- |
+| `yarn test`         | Run tests in interactive watch mode ([Vitest](https://vitest.dev/)) |
+| `yarn test --run`   | Run all tests once (CI)                                             |
+| `yarn format:check` | Check Prettier formatting                                           |
+| `yarn lint`         | Run ESLint (`--fix` to auto-fix)                                    |
+| `yarn typecheck`    | Type-check without emitting files                                   |
+| `yarn build`        | Compile TypeScript                                                  |
+| `yarn bundle`       | Build bundles with Rollup (for analysis, not shipped)               |
+| `yarn size-check`   | Bundle and print file sizes                                         |
+| `yarn docs`         | Generate API docs with TypeDoc                                      |
+
+### Contributing
+
+Contributions are welcome! See the [Contributing Guide](CONTRIBUTING.md) for development setup, conventions, and PR guidelines.
+
+## Roadmap
+
+jmap-kit currently implements the JMAP Core (RFC 8620), Mail (RFC 8621), and Blob Management (RFC 9404) specifications, plus the FastMail Masked Email extension. The following features are planned for future minor releases.
+
+### Core specification features
+
+- **PushSubscription** (RFC 8620 Section 7.2) — `PushSubscription/get` and `PushSubscription/set` methods for managing push notification subscriptions
+- **EventSource** (RFC 8620 Section 7.3) — built-in client for server-sent events, including connection management and automatic reconnection (URL generation via `getEventSourceUrl()` is already available)
+
+### Additional JMAP capabilities
+
+Support for capabilities defined in other published and draft JMAP specifications is planned, including:
+
+- **Quotas** — [RFC 9425](https://www.rfc-editor.org/rfc/rfc9425.html)
+- **Contacts** — [RFC 9610](https://www.rfc-editor.org/rfc/rfc9610.html)
+- **Sieve Scripts** — [RFC 9661](https://www.rfc-editor.org/rfc/rfc9661.html)
+- **Principals and Sharing** — [RFC 9670](https://www.rfc-editor.org/rfc/rfc9670.html)
+- **MDN (Message Disposition Notification)** — [RFC 9007](https://www.rfc-editor.org/rfc/rfc9007.html)
+- **S/MIME Signature Verification** — [RFC 9219](https://www.rfc-editor.org/rfc/rfc9219.html)
+- **WebPush VAPID** — [RFC 9749](https://www.rfc-editor.org/rfc/rfc9749.html)
+- **Calendars** — [Draft IETF JMAP Calendars](https://datatracker.ietf.org/doc/html/draft-ietf-jmap-calendars)
+- **Tasks** — [Draft IETF JMAP Tasks](https://datatracker.ietf.org/doc/html/draft-ietf-jmap-tasks)
+
+Any of the above capabilities can be implemented as [custom capabilities](./guide/custom-capabilities.md) using the plugin system. Contributions are welcome!
+
+### Other specifications
+
+- **JMAP over WebSocket** — [RFC 8887](https://www.rfc-editor.org/rfc/rfc8887.html).
+
+## License
+
+[MIT License](LICENSE)

package/dist/src/capabilities/blob/blob.d.ts

@@ -0,0 +1,83 @@
+import type { JMAPCapability, JMAPMethodName } from "../../common/types.js";
+import { Invocation } from "../../invocation/invocation.js";
+import type { InvocationArgs, InvocationFactory } from "../../invocation/types.js";
+import type { BlobCopyRequestInvocationArgs, BlobCopyResponseInvocationArgs, BlobGetRequestInvocationArgs, BlobGetResponseInvocationArgs, BlobLookupRequestInvocationArgs, BlobLookupResponseInvocationArgs, BlobRequestInvocationArgs, BlobResponseInvocationArgs, BlobUploadRequestInvocationArgs, BlobUploadResponseInvocationArgs } from "./types.js";
+/**
+ * BlobInvocation represents a JMAP Blob capability invocation.
+ *
+ * The Blob data type handles binary data management with methods for copying, uploading,
+ * retrieving, and looking up binary data across accounts. The Blob/copy method is part
+ * of the Core capability (RFC 8620), while upload/get/lookup are part of the Blob
+ * Management Extension (RFC 9404).
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc8620.html#section-6.3 | RFC 8620 Section 6.3: Blob/copy}
+ * @see {@link https://www.rfc-editor.org/rfc/rfc9404.html#section-4 | RFC 9404 Section 4: Blob Methods}
+ */
+export declare class BlobInvocation<TArgs extends BlobRequestInvocationArgs | BlobResponseInvocationArgs> extends Invocation<TArgs> {
+    get uri(): JMAPCapability;
+    /**
+     * Constructs a BlobInvocation
+     *
+     * @param method The name of the method being invoked (e.g., "copy", "upload", "get", "lookup")
+     * @param args The arguments for the method invocation
+     * @param methodCallId An optional unique symbol to identify this method call for result referencing
+     */
+    constructor(method: JMAPMethodName, args: InvocationArgs<TArgs>, methodCallId?: symbol);
+    /**
+     * Create an invocation factory function
+     *
+     * @param method The name of the method to create
+     * @returns A new Blob invocation factory function for creating invocations of the specified type
+     */
+    static createInvocationFactory<TArgs extends BlobRequestInvocationArgs | BlobResponseInvocationArgs>(method: JMAPMethodName): InvocationFactory<TArgs, BlobInvocation<TArgs>>;
+}
+export declare const Blob: {
+    request: {
+        /**
+         * Copies a Blob from one account to another.
+         *
+         * @param args The invocation arguments for Blob/copy
+         * @param methodCallId An optional unique symbol to identify this method call for result referencing
+         * @returns A BlobInvocation representing the Blob/copy request
+         *
+         * @see {@link https://www.rfc-editor.org/rfc/rfc8620.html#section-6.3 | RFC 8620 Section 6.3: Blob/copy}
+         */
+        copy: InvocationFactory<BlobCopyRequestInvocationArgs, BlobInvocation<BlobCopyRequestInvocationArgs>>;
+        /**
+         * Retrieves binary data by blob ID with optional range and encoding support.
+         *
+         * @param args The invocation arguments for Blob/get
+         * @param methodCallId An optional unique symbol to identify this method call for result referencing
+         * @returns A BlobInvocation representing the Blob/get request
+         *
+         * @see {@link https://www.rfc-editor.org/rfc/rfc9404.html#section-4.2 | RFC 9404 Section 4.2: Blob/get}
+         */
+        get: InvocationFactory<BlobGetRequestInvocationArgs, BlobInvocation<BlobGetRequestInvocationArgs>>;
+        /**
+         * Uploads binary data and returns the blob ID.
+         *
+         * @param args The invocation arguments for Blob/upload
+         * @param methodCallId An optional unique symbol to identify this method call for result referencing
+         * @returns A BlobInvocation representing the Blob/upload request
+         *
+         * @see {@link https://www.rfc-editor.org/rfc/rfc9404.html#section-4.1 | RFC 9404 Section 4.1: Blob/upload}
+         */
+        upload: InvocationFactory<BlobUploadRequestInvocationArgs, BlobInvocation<BlobUploadRequestInvocationArgs>>;
+        /**
+         * Looks up blob IDs by their data type and account.
+         *
+         * @param args The invocation arguments for Blob/lookup
+         * @param methodCallId An optional unique symbol to identify this method call for result referencing
+         * @returns A BlobInvocation representing the Blob/lookup request
+         *
+         * @see {@link https://www.rfc-editor.org/rfc/rfc9404.html#section-4.3 | RFC 9404 Section 4.3: Blob/lookup}
+         */
+        lookup: InvocationFactory<BlobLookupRequestInvocationArgs, BlobInvocation<BlobLookupRequestInvocationArgs>>;
+    };
+    response: {
+        copy: InvocationFactory<BlobCopyResponseInvocationArgs, BlobInvocation<BlobCopyResponseInvocationArgs>>;
+        get: InvocationFactory<BlobGetResponseInvocationArgs, BlobInvocation<BlobGetResponseInvocationArgs>>;
+        upload: InvocationFactory<BlobUploadResponseInvocationArgs, BlobInvocation<BlobUploadResponseInvocationArgs>>;
+        lookup: InvocationFactory<BlobLookupResponseInvocationArgs, BlobInvocation<BlobLookupResponseInvocationArgs>>;
+    };
+};

package/dist/src/capabilities/blob/blob.js

@@ -0,0 +1,98 @@
+import { BLOB_CAPABILITY_URI, CORE_CAPABILITY_URI } from "../../common/registry.js";
+import { Invocation } from "../../invocation/invocation.js";
+/**
+ * BlobInvocation represents a JMAP Blob capability invocation.
+ *
+ * The Blob data type handles binary data management with methods for copying, uploading,
+ * retrieving, and looking up binary data across accounts. The Blob/copy method is part
+ * of the Core capability (RFC 8620), while upload/get/lookup are part of the Blob
+ * Management Extension (RFC 9404).
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc8620.html#section-6.3 | RFC 8620 Section 6.3: Blob/copy}
+ * @see {@link https://www.rfc-editor.org/rfc/rfc9404.html#section-4 | RFC 9404 Section 4: Blob Methods}
+ */
+export class BlobInvocation extends Invocation {
+    get uri() {
+        if (this.name === "Blob/copy") {
+            return CORE_CAPABILITY_URI;
+        }
+        return BLOB_CAPABILITY_URI;
+    }
+    /**
+     * Constructs a BlobInvocation
+     *
+     * @param method The name of the method being invoked (e.g., "copy", "upload", "get", "lookup")
+     * @param args The arguments for the method invocation
+     * @param methodCallId An optional unique symbol to identify this method call for result referencing
+     */
+    constructor(method, args, methodCallId) {
+        super("Blob", method, args, methodCallId);
+    }
+    /**
+     * Create an invocation factory function
+     *
+     * @param method The name of the method to create
+     * @returns A new Blob invocation factory function for creating invocations of the specified type
+     */
+    static createInvocationFactory(method) {
+        /**
+         * An invocation factory function to create a `Blob/*` invocation for the specified `method`
+         *
+         * @param args The invocation arguments for the specified `method`
+         * @param methodCallId An optional unique symbol to identify this method call for result referencing
+         * @returns An object representing the named arguments for the specified `method`
+         */
+        return (args, methodCallId) => new BlobInvocation(method, args, methodCallId);
+    }
+}
+export const Blob = {
+    request: {
+        /**
+         * Copies a Blob from one account to another.
+         *
+         * @param args The invocation arguments for Blob/copy
+         * @param methodCallId An optional unique symbol to identify this method call for result referencing
+         * @returns A BlobInvocation representing the Blob/copy request
+         *
+         * @see {@link https://www.rfc-editor.org/rfc/rfc8620.html#section-6.3 | RFC 8620 Section 6.3: Blob/copy}
+         */
+        copy: BlobInvocation.createInvocationFactory("copy"),
+        /**
+         * Retrieves binary data by blob ID with optional range and encoding support.
+         *
+         * @param args The invocation arguments for Blob/get
+         * @param methodCallId An optional unique symbol to identify this method call for result referencing
+         * @returns A BlobInvocation representing the Blob/get request
+         *
+         * @see {@link https://www.rfc-editor.org/rfc/rfc9404.html#section-4.2 | RFC 9404 Section 4.2: Blob/get}
+         */
+        get: BlobInvocation.createInvocationFactory("get"),
+        /**
+         * Uploads binary data and returns the blob ID.
+         *
+         * @param args The invocation arguments for Blob/upload
+         * @param methodCallId An optional unique symbol to identify this method call for result referencing
+         * @returns A BlobInvocation representing the Blob/upload request
+         *
+         * @see {@link https://www.rfc-editor.org/rfc/rfc9404.html#section-4.1 | RFC 9404 Section 4.1: Blob/upload}
+         */
+        upload: BlobInvocation.createInvocationFactory("upload"),
+        /**
+         * Looks up blob IDs by their data type and account.
+         *
+         * @param args The invocation arguments for Blob/lookup
+         * @param methodCallId An optional unique symbol to identify this method call for result referencing
+         * @returns A BlobInvocation representing the Blob/lookup request
+         *
+         * @see {@link https://www.rfc-editor.org/rfc/rfc9404.html#section-4.3 | RFC 9404 Section 4.3: Blob/lookup}
+         */
+        lookup: BlobInvocation.createInvocationFactory("lookup"),
+    },
+    response: {
+        copy: BlobInvocation.createInvocationFactory("copy"),
+        get: BlobInvocation.createInvocationFactory("get"),
+        upload: BlobInvocation.createInvocationFactory("upload"),
+        lookup: BlobInvocation.createInvocationFactory("lookup"),
+    },
+};
+//# sourceMappingURL=blob.js.map

package/dist/src/capabilities/blob/blob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob.js","sourceRoot":"","sources":["../../../../src/capabilities/blob/blob.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpF,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAe5D;;;;;;;;;;GAUG;AACH,MAAM,OAAO,cAEX,SAAQ,UAAiB;IACvB,IAAI,GAAG;QACH,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;YAC5B,OAAO,mBAAmB,CAAC;QAC/B,CAAC;QACD,OAAO,mBAAmB,CAAC;IAC/B,CAAC;IAED;;;;;;OAMG;IACH,YAAY,MAAsB,EAAE,IAA2B,EAAE,YAAqB;QAClF,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,uBAAuB,CAC1B,MAAsB;QAEtB;;;;;;WAMG;QACH,OAAO,CAAC,IAAI,EAAE,YAAY,EAAE,EAAE,CAAC,IAAI,cAAc,CAAQ,MAAM,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;IACzF,CAAC;CACJ;AAED,MAAM,CAAC,MAAM,IAAI,GAAG;IAChB,OAAO,EAAE;QACL;;;;;;;;WAQG;QACH,IAAI,EAAE,cAAc,CAAC,uBAAuB,CAAgC,MAAM,CAAC;QACnF;;;;;;;;WAQG;QACH,GAAG,EAAE,cAAc,CAAC,uBAAuB,CAA+B,KAAK,CAAC;QAChF;;;;;;;;WAQG;QACH,MAAM,EAAE,cAAc,CAAC,uBAAuB,CAAkC,QAAQ,CAAC;QACzF;;;;;;;;WAQG;QACH,MAAM,EAAE,cAAc,CAAC,uBAAuB,CAAkC,QAAQ,CAAC;KAC5F;IACD,QAAQ,EAAE;QACN,IAAI,EAAE,cAAc,CAAC,uBAAuB,CAAiC,MAAM,CAAC;QACpF,GAAG,EAAE,cAAc,CAAC,uBAAuB,CAAgC,KAAK,CAAC;QACjF,MAAM,EAAE,cAAc,CAAC,uBAAuB,CAAmC,QAAQ,CAAC;QAC1F,MAAM,EAAE,cAAc,CAAC,uBAAuB,CAAmC,QAAQ,CAAC;KAC7F;CACkC,CAAC"}

package/dist/src/capabilities/blob/types.d.ts

@@ -0,0 +1,212 @@
+import { z } from "zod/v4";
+import type { Id, UnsignedInt } from "../../common/types.js";
+import type { BaseGetRequestInvocationArgs, BaseGetResponseInvocationArgs, SetError } from "../../invocation/types.js";
+/**
+ * Zod schema for validating HTTP Digest Algorithm values from the
+ * {@link https://www.iana.org/assignments/http-dig-alg/http-dig-alg.xhtml IANA HTTP Digest Algorithm Values registry}.
+ */
+export declare const HTTPDigestAlgorithmSchema: z.ZodEnum<{
+    adler32: "adler32";
+    crc32c: "crc32c";
+    md5: "md5";
+    sha: "sha";
+    "sha-256": "sha-256";
+    "sha-512": "sha-512";
+    unixsum: "unixsum";
+    unixcksum: "unixcksum";
+}>;
+/**
+ * The list of algorithms defined in the
+ * {@link https://www.iana.org/assignments/http-dig-alg/http-dig-alg.xhtml IANA HTTP Digest Algorithm Values registry}
+ * that the server supports for calculating blob digests.
+ */
+export type HTTPDigestAlgorithm = z.infer<typeof HTTPDigestAlgorithmSchema>;
+/**
+ * Specifies the encoding format for blob data (text or base64)
+ */
+export type BlobDataFormat = "asText" | "asBase64";
+/**
+ * Partial record of digest values for a blob, keyed by digest algorithm
+ */
+export type BlobObjectDigest = Partial<Record<`digest:${HTTPDigestAlgorithm}`, string>>;
+/**
+ * Partial record of blob data in various formats (raw data, asText, or asBase64)
+ */
+export type BlobObjectData = Partial<Record<"data" | `data:${BlobDataFormat}`, string>>;
+/**
+ * The size of a blob in octets
+ */
+export type BlobObjectSize = {
+    size?: UnsignedInt;
+};
+/**
+ * A Blob object represents binary data managed by the server
+ */
+export type BlobObject = BlobObjectDigest & BlobObjectData & BlobObjectSize;
+/**
+ * The arguments to copy Blob objects via a `Blob/copy` call
+ */
+export type BlobCopyRequestInvocationArgs = {
+    /** The accountId of the account to copy the blobs to */
+    accountId: Id;
+    /** The accountId of the account to copy the blobs from */
+    fromAccountId: Id;
+    /** The blobIds to copy */
+    blobIds: Id[];
+};
+export type BlobCopyResponseInvocationArgs = {
+    /** The id of the account blobs were copied from. */
+    fromAccountId: Id;
+    /** The id of the account blobs were copied to. */
+    accountId: Id;
+    /**
+     * A map of the blobId in the fromAccount to the id for the blob in the account it was copied
+     * to, or null if none were successfully copied.
+     */
+    copied: Record<Id, Id> | null;
+    /**
+     * A map of blobId to a SetError object for each blob that failed to be copied, or null if none.
+     */
+    notCopied: Record<Id, SetError<"create", "notFound">> | null;
+};
+/**
+ * The object representing the blob of data being uploaded
+ */
+export type UploadObject = {
+    /**
+     * An array of zero or more octet sources in order (zero to create an empty blob).
+     * The result of each of these sources is concatenated together in order to create the blob.
+     */
+    data: DataSourceObject[];
+    /** (default: null) Hint for media type of the data */
+    type?: string | null;
+};
+/**
+ * A source of octets to use in creating a blob
+ */
+export type DataSourceObject = {
+    /** The raw octets, must be UTF-8 */
+    "data:asText": string | null;
+} | {
+    /** The base64 representation of octets */
+    "data:asBase64": string | null;
+} | {
+    /** The blobId to copy from */
+    blobId: Id;
+    /** (default: 0) The number of octets offset into the referenced blob */
+    offset?: UnsignedInt | null;
+    /** (default: remaining octets in the blog) The length of data to copy from the referenced blob */
+    length?: UnsignedInt | null;
+};
+export type DataCreatedObject = {
+    /** The blobId that was created. */
+    id: Id;
+    /**
+     * The media type as given in the creation (if any). If not provided, the server MAY perform
+     * content analysis and return one of the following: the calculated value, `application/octet-string`,
+     * or `null`. */
+    type: string | null;
+    /** The size of the created blob in octets. */
+    size: UnsignedInt;
+};
+/**
+ * The arguments for fetching Blob objects via a `Blob/get` call
+ */
+export type BlobGetRequestInvocationArgs = BaseGetRequestInvocationArgs<BlobObject> & {
+    /** (default: 0) Start this many octets into the blob data */
+    offset?: UnsignedInt | null;
+    /**
+     * (default: all remaining octets) Return at most this many octets of the blob data.
+     * If null or unspecified, then all remaining octets in the blob are returned. This can be
+     * considered equivalent to an infinitely large length value, except that the isTruncated
+     * warning is not given unless the start offset is past the end of the blob.
+     */
+    length?: UnsignedInt | null;
+};
+/**
+ * The response to a `Blob/get` call
+ */
+export type BlobGetResponseInvocationArgs = Omit<BaseGetResponseInvocationArgs<Omit<BlobObject, "data">>, "state"> & {
+    /** (default: false) */
+    isEncodingProblem: boolean;
+    /** (default: false) */
+    isTruncated: boolean;
+};
+/**
+ * The arguments for uploading Blob objects via a `Blob/upload` call
+ */
+export type BlobUploadRequestInvocationArgs = {
+    /** The accountId of the account to upload the blob to */
+    accountId: Id;
+    /** The blobs to upload */
+    create: {
+        [id: string]: UploadObject;
+    };
+};
+/**
+ * The response to a `Blob/upload` call
+ */
+export type BlobUploadResponseInvocationArgs = {
+    /** The id of the account used for the call. */
+    accountId: Id;
+    /**
+     * The state string that would have been returned by Foo/get before making the requested
+     * changes, or null if the server doesn’t know what the previous state string was.
+     */
+    oldState?: string | null;
+    /** The state string that will now be returned by Foo/get. */
+    newState: string;
+    /**
+     * A map of the creation id to an object containing any properties of the created Foo object
+     * that were not sent by the client. This includes all server-set properties (such as the id in
+     * most object types) and any properties that were omitted by the client and thus set to a
+     * default by the server.
+     *
+     * This argument is null if no Foo objects were successfully created.
+     */
+    created?: Record<Id, DataCreatedObject> | null;
+    /**
+     * A map of the creation id to a SetError object for each record that failed to be created, or
+     * null if all successful.
+     */
+    notCreated?: Record<Id, SetError<"create">> | null;
+};
+/**
+ * The arguments for looking up blobs via the Blob/lookup method
+ */
+export type BlobLookupRequestInvocationArgs = {
+    /** The accountId of the account to lookup the blobs in */
+    accountId: Id;
+    /** A list of names from the "JMAP Data Types" registry, or defined by private extensions which the client has requested. Only names for which "Can reference blobs" is true may be specified, and the capability which defines each type must also be used by the overall JMAP request in which this method is called.If a type name is not known by the server, or the associated capability has not been requested, then the server returns an "unknownDataType" error. */
+    typeNames: string[];
+    /** A list of blobId values to be looked for. */
+    ids: Id[];
+    /** A list of BlobInfo objects. */
+    list: BlobInfo[];
+};
+/**
+ * The response to a `Blob/lookup` call
+ */
+export type BlobLookupResponseInvocationArgs = {
+    /** A list of BlobInfo objects. */
+    list: BlobInfo[];
+};
+export type BlobInfo = {
+    /** The Blob Identifier. */
+    id: Id;
+    /**
+     * A map from type name to list of Ids of that data type (e.g. the name "Email" maps to a list of emailIds)
+     * If a blob is not visible to a user, or does not exist on the server at all, then the server MUST still
+     * return an empty array for each type as this doesn't leak any information about whether the blob is on the
+     * server but not visible to the requesting user.
+     */
+    matchedIds: Record<string, Id[]>;
+};
+/**
+ * Union type of all Blob capability request invocation arguments
+ */
+export type BlobRequestInvocationArgs = BlobCopyRequestInvocationArgs | BlobGetRequestInvocationArgs | BlobUploadRequestInvocationArgs | BlobLookupRequestInvocationArgs;
+/**
+ * Union type of all Blob capability response invocation arguments
+ */
+export type BlobResponseInvocationArgs = BlobCopyResponseInvocationArgs | BlobGetResponseInvocationArgs | BlobUploadResponseInvocationArgs | BlobLookupResponseInvocationArgs;

package/dist/src/capabilities/blob/types.js

@@ -0,0 +1,16 @@
+import { z } from "zod/v4";
+/**
+ * Zod schema for validating HTTP Digest Algorithm values from the
+ * {@link https://www.iana.org/assignments/http-dig-alg/http-dig-alg.xhtml IANA HTTP Digest Algorithm Values registry}.
+ */
+export const HTTPDigestAlgorithmSchema = z.enum([
+    "adler32",
+    "crc32c",
+    "md5",
+    "sha",
+    "sha-256",
+    "sha-512",
+    "unixsum",
+    "unixcksum",
+]);
+//# sourceMappingURL=types.js.map

package/dist/src/capabilities/blob/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/capabilities/blob/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAI3B;;;GAGG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,IAAI,CAAC;IAC5C,SAAS;IACT,QAAQ;IACR,KAAK;IACL,KAAK;IACL,SAAS;IACT,SAAS;IACT,SAAS;IACT,WAAW;CACd,CAAC,CAAC"}