jmap-kit 0.0.0 → 1.0.2

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

@@ -0,0 +1,248 @@
+import type { Id, UnsignedInt } from "../../common/types.js";
+import type { BaseChangesRequestInvocationArgs, BaseChangesResponseInvocationArgs, BaseGetRequestInvocationArgs, BaseGetResponseInvocationArgs, BaseQueryChangesRequestInvocationArgs, BaseQueryChangesResponseInvocationArgs, BaseQueryRequestInvocationArgs, BaseQueryResponseInvocationArgs, BaseSetRequestInvocationArgs, BaseSetResponseInvocationArgs } from "../../invocation/types.js";
+/**
+ * The set of rights (Access Control Lists (ACLs)) the user has
+ * in relation to this Mailbox. These are backwards compatible with IMAP ACLs,
+ * as defined in {@link https://www.rfc-editor.org/rfc/rfc4314.html RFC 4314}.
+ */
+export type MailboxRights = {
+    /**
+     *
+     * If true, the user may use this Mailbox as part of a filter in an `Email/query`
+     * call, and the Mailbox may be included in the mailboxIds property of Email objects.
+     * Email objects may be fetched if they are in at least one Mailbox with this permission.
+     * If a sub-Mailbox is shared but not the parent Mailbox, this may be `false`.
+     * Corresponds to IMAP ACLs `lr` (if mapping from IMAP, both are required for this to be `true`).
+     */
+    mayReadItems: boolean;
+    /**
+     * The user may add mail to this Mailbox (by either creating a new Email
+     * or moving an existing one). Corresponds to IMAP ACL `i`.
+     */
+    mayAddItems: boolean;
+    /**
+     * The user may remove mail from this Mailbox (by either changing the
+     * Mailboxes of an Email or destroying the Email). Corresponds to
+     * IMAP ACLs `te` (if mapping from IMAP, both are required for this to be true).
+     */
+    mayRemoveItems: boolean;
+    /**
+     * The user may add or remove the `$seen` keyword to/from an Email.
+     * If an Email belongs to multiple Mailboxes, the user may only modify
+     * `$seen` if they have this permission for all of the Mailboxes.
+     * Corresponds to IMAP ACL `s`.
+     */
+    maySetSeen: boolean;
+    /**
+     * The user may add or remove any keyword other than `$seen` to/from an
+     * Email. If an Email belongs to multiple Mailboxes, the user may only
+     * modify keywords if they have this permission for all of the Mailboxes.
+     * Corresponds to IMAP ACL `w`.
+     */
+    maySetKeywords: boolean;
+    /**
+     * The user may create a Mailbox with this Mailbox as its parent.
+     * Corresponds to IMAP ACL k.
+     */
+    mayCreateChild: boolean;
+    /**
+     * The user may rename the Mailbox or make it a child of another Mailbox.
+     * Corresponds to IMAP ACL `x` (although this covers both rename and
+     * delete permissions).
+     */
+    mayRename: boolean;
+    /**
+     * The user may delete the Mailbox itself. Corresponds to IMAP ACL `x`
+     * (although this covers both rename and delete permissions).
+     */
+    mayDelete: boolean;
+    /**
+     * Messages may be submitted directly to this Mailbox. Corresponds to
+     * IMAP ACL `p`.
+     */
+    maySubmit: boolean;
+};
+/**
+ * MailboxObject properties set by the server. These cannot be set by a `Mailbox/set` call
+ */
+export type MailboxObjectServerSet = Readonly<{
+    /**
+     * (immutable) The id of the Mailbox.
+     */
+    id: Id;
+    /**
+     * The number of Emails in this Mailbox.
+     */
+    totalEmails: UnsignedInt;
+    /**
+     * The number of Emails in this Mailbox that have neither the
+     * `$seen` keyword nor the `$draft` keyword.
+     */
+    unreadEmails: UnsignedInt;
+    /**
+     * The number of Threads where at least one Email in the Thread
+     * is in this Mailbox.
+     */
+    totalThreads: UnsignedInt;
+    /**
+     * An indication of the number of “unread” Threads in the Mailbox.
+     */
+    unreadThreads: UnsignedInt;
+    /**
+     * The set of rights (Access Control Lists (ACLs)) the user has
+     * in relation to this Mailbox. These are backwards compatible with IMAP ACLs,
+     * as defined in {@link https://www.rfc-editor.org/rfc/rfc4314.html RFC 4314}.
+     */
+    myRights: MailboxRights;
+}>;
+/**
+ * MailboxObject properties that may be set via a `Mailbox/set` call
+ */
+export type MailboxObjectSettable = {
+    /**
+     * User-visible name for the Mailbox, e.g., “Inbox”. This MUST be a Net-Unicode string
+     * {@link https://www.rfc-editor.org/rfc/rfc5198.html RFC 5198} of at least 1 character in length,
+     * subject to the maximum size given in the capability object.
+     */
+    name: string;
+    /**
+     * (default: null) The Mailbox id for the parent of this Mailbox,
+     * or null if this Mailbox is at the top level.
+     */
+    parentId?: Id | null;
+    /**
+     * (default: null) Identifies Mailboxes that have a particular common purpose (e.g., the “inbox”),
+     * regardless of the name property (which may be localised).
+     */
+    role?: string | null;
+    /**
+     * (default: 0) Defines the sort order of Mailboxes when presented in the client’s UI,
+     * so it is consistent between devices. The number MUST be an integer in the range
+     * `0 <= sortOrder < 2^31`.
+     */
+    sortOrder?: UnsignedInt;
+    /**
+     * Has the user indicated they wish to see this Mailbox in their client?
+     * This SHOULD default to false for Mailboxes in shared accounts
+     * the user has access to and true for any new Mailboxes created by the
+     * user themself. This MUST be stored separately per user where multiple
+     * users have access to a shared Mailbox.
+     */
+    isSubscribed?: boolean;
+};
+/**
+ * Properties of the Mailbox object.
+ */
+export type MailboxObject = MailboxObjectServerSet & MailboxObjectSettable;
+/**
+ * The arguments for fetching Mailbox objects via a `Mailbox/get` call
+ */
+export type MailboxGetRequestInvocationArgs = BaseGetRequestInvocationArgs<MailboxObject>;
+/**
+ * The response to a `Mailbox/get` call
+ */
+export type MailboxGetResponseInvocationArgs = BaseGetResponseInvocationArgs<MailboxObject>;
+/**
+ * The arguments for fetching Mailbox changes via a `Mailbox/changes` call
+ */
+export type MailboxChangesRequestInvocationArgs = BaseChangesRequestInvocationArgs;
+/**
+ * The response to a `Mailbox/changes` call
+ */
+export type MailboxChangesResponseInvocationArgs = BaseChangesResponseInvocationArgs & {
+    /**
+     * If only the “totalEmails”, “unreadEmails”, “totalThreads”, and/or “unreadThreads” Mailbox
+     * properties have changed since the old state, this will be the list of properties that may
+     * have changed. If the server is unable to tell if only counts have changed, it MUST just be
+     * null.
+     */
+    updatedProperties?: string[] | null;
+};
+export type MailboxFilterCondition = Partial<{
+    /**
+     *
+     * The Mailbox parentId property must match the given value exactly.
+     */
+    parentId: Id | null;
+    /**
+     * The Mailbox name property contains the given string.
+     */
+    name: string;
+    /**
+     * The Mailbox role property must match the given value exactly.
+     */
+    role: string | null;
+    /**
+     *  If true, a Mailbox matches if it has any non-null value for its role property.
+     */
+    hasAnyRole: boolean;
+    /**
+     * The isSubscribed property of the Mailbox must be identical to the value given to match the condition.
+     */
+    isSubscribed: boolean;
+}>;
+/**
+ * The arguments to query Mailbox objects via a `Mailbox/query` call
+ */
+export type MailboxQueryRequestInvocationArgs = BaseQueryRequestInvocationArgs<MailboxObject, MailboxFilterCondition> & {
+    /**
+     * (default: false) If true, when sorting the query results and comparing
+     * Mailboxes A and B:
+     * - If A is an ancestor of B, it always comes first regardless of the sort
+     *   comparators. Similarly, if A is descendant of B, then B always comes first.
+     * - Otherwise, if A and B do not share a parentId, find the nearest ancestors
+     *   of each that do have the same parentId and compare the sort properties on
+     *   those Mailboxes instead.
+     *
+     * The result of this is that the Mailboxes are sorted as a tree according to
+     * the parentId properties, with each set of children with a common parent
+     * sorted according to the standard sort comparators.
+     */
+    sortAsTree?: boolean;
+    /**
+     * (default: false) If true, a Mailbox is only included in the query if all
+     * its ancestors are also included in the query according to the filter.
+     */
+    filterAsTree?: boolean;
+};
+/**
+ * The response to a `Mailbox/query` call
+ */
+export type MailboxQueryResponseInvocationArgs = BaseQueryResponseInvocationArgs;
+/**
+ * The arguments to query changes to Mailbox objects via a `Mailbox/queryChanges` call
+ */
+export type MailboxQueryChangesRequestInvocationArgs = BaseQueryChangesRequestInvocationArgs<MailboxObject, MailboxFilterCondition>;
+/**
+ * The response to a `Mailbox/queryChanges` call
+ */
+export type MailboxQueryChangesResponseInvocationArgs = BaseQueryChangesResponseInvocationArgs;
+/**
+ * The arguments for creating, updating, and destroying Mailbox objects via a `Mailbox/set` call
+ */
+export type MailboxSetRequestInvocationArgs = BaseSetRequestInvocationArgs<MailboxObjectSettable> & {
+    /**
+     * (default: false) If false, any attempt to destroy a Mailbox that still has Emails
+     * in it will be rejected with a mailboxHasEmail SetError. If true, any Emails that
+     * were in the Mailbox will be removed from it, and if in no other Mailboxes, they
+     * will be destroyed when the Mailbox is destroyed.
+     */
+    onDestroyRemoveEmails?: boolean;
+};
+export type MailboxSetResponseInvocationArgs = BaseSetResponseInvocationArgs<MailboxObject> & {
+    /**
+     * (default: false) If false, any attempt to destroy a Mailbox that still has Emails in it will
+     * be rejected with a mailboxHasEmail SetError. If true, any Emails that were in the Mailbox
+     * will be removed from it, and if in no other Mailboxes, they will be destroyed when the
+     * Mailbox is destroyed.
+     */
+    onDestroyRemoveEmails?: boolean;
+};
+/**
+ * Union type of all Mailbox capability request invocation arguments
+ */
+export type MailboxRequestInvocationArgs = MailboxGetRequestInvocationArgs | MailboxChangesRequestInvocationArgs | MailboxQueryRequestInvocationArgs | MailboxQueryChangesRequestInvocationArgs | MailboxSetRequestInvocationArgs;
+/**
+ * Union type of all Mailbox capability response invocation arguments
+ */
+export type MailboxResponseInvocationArgs = MailboxGetResponseInvocationArgs | MailboxChangesResponseInvocationArgs | MailboxQueryResponseInvocationArgs | MailboxQueryChangesResponseInvocationArgs | MailboxSetResponseInvocationArgs;

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/capabilities/mailbox/types.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,60 @@
+import type { JMAPCapability, JMAPMethodName } from "../../common/types.js";
+import { Invocation } from "../../invocation/invocation.js";
+import type { InvocationArgs, InvocationFactory } from "../../invocation/types.js";
+import type { MaskedEmailGetRequestInvocationArgs, MaskedEmailGetResponseInvocationArgs, MaskedEmailRequestInvocationArgs, MaskedEmailResponseInvocationArgs, MaskedEmailSetRequestInvocationArgs, MaskedEmailSetResponseInvocationArgs } from "./types.js";
+/**
+ * MaskedEmailInvocation represents a JMAP MaskedEmail capability invocation.
+ *
+ * The MaskedEmail data type is a FastMail vendor-specific extension that provides privacy-enhanced
+ * email addresses. Masked emails are temporary or permanent forwarding addresses that protect the
+ * user's primary email address. This capability supports creating, retrieving, and managing masked
+ * email addresses.
+ *
+ * @see {@link https://www.fastmail.com/dev/#masked-email-api | FastMail Developer Documentation - Masked Email API}
+ */
+export declare class MaskedEmailInvocation<TArgs extends MaskedEmailRequestInvocationArgs | MaskedEmailResponseInvocationArgs> extends Invocation<TArgs> {
+    get uri(): JMAPCapability;
+    /**
+     * Constructs a MaskedEmailInvocation
+     *
+     * @param method The name of the method being invoked (e.g., "get", "set")
+     * @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 MaskedEmail invocation factory function for creating invocations of the specified type
+     */
+    static createInvocationFactory<TArgs extends MaskedEmailRequestInvocationArgs | MaskedEmailResponseInvocationArgs>(method: JMAPMethodName): InvocationFactory<TArgs, MaskedEmailInvocation<TArgs>>;
+}
+export declare const MaskedEmail: {
+    request: {
+        /**
+         * Retrieves MaskedEmail objects by their IDs.
+         *
+         * @param args The invocation arguments for MaskedEmail/get
+         * @param methodCallId An optional unique symbol to identify this method call for result referencing
+         * @returns A MaskedEmailInvocation representing the MaskedEmail/get request
+         *
+         * @see {@link https://www.fastmail.com/dev/#masked-email-api | FastMail Developer Documentation - Masked Email API}
+         */
+        get: InvocationFactory<MaskedEmailGetRequestInvocationArgs, MaskedEmailInvocation<MaskedEmailGetRequestInvocationArgs>>;
+        /**
+         * Creates, updates, or destroys MaskedEmail objects.
+         *
+         * @param args The invocation arguments for MaskedEmail/set
+         * @param methodCallId An optional unique symbol to identify this method call for result referencing
+         * @returns A MaskedEmailInvocation representing the MaskedEmail/set request
+         *
+         * @see {@link https://www.fastmail.com/dev/#masked-email-api | FastMail Developer Documentation - Masked Email API}
+         */
+        set: InvocationFactory<MaskedEmailSetRequestInvocationArgs, MaskedEmailInvocation<MaskedEmailSetRequestInvocationArgs>>;
+    };
+    response: {
+        get: InvocationFactory<MaskedEmailGetResponseInvocationArgs, MaskedEmailInvocation<MaskedEmailGetResponseInvocationArgs>>;
+        set: InvocationFactory<MaskedEmailSetResponseInvocationArgs, MaskedEmailInvocation<MaskedEmailSetResponseInvocationArgs>>;
+    };
+};

package/dist/src/capabilities/maskedemail/maskedemail.js

@@ -0,0 +1,72 @@
+import { MASKED_EMAIL_CAPABILITY_URI } from "../../common/registry.js";
+import { Invocation } from "../../invocation/invocation.js";
+/**
+ * MaskedEmailInvocation represents a JMAP MaskedEmail capability invocation.
+ *
+ * The MaskedEmail data type is a FastMail vendor-specific extension that provides privacy-enhanced
+ * email addresses. Masked emails are temporary or permanent forwarding addresses that protect the
+ * user's primary email address. This capability supports creating, retrieving, and managing masked
+ * email addresses.
+ *
+ * @see {@link https://www.fastmail.com/dev/#masked-email-api | FastMail Developer Documentation - Masked Email API}
+ */
+export class MaskedEmailInvocation extends Invocation {
+    get uri() {
+        return MASKED_EMAIL_CAPABILITY_URI;
+    }
+    /**
+     * Constructs a MaskedEmailInvocation
+     *
+     * @param method The name of the method being invoked (e.g., "get", "set")
+     * @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("MaskedEmail", method, args, methodCallId);
+    }
+    /**
+     * Create an invocation factory function
+     *
+     * @param method The name of the method to create
+     * @returns A new MaskedEmail invocation factory function for creating invocations of the specified type
+     */
+    static createInvocationFactory(method) {
+        /**
+         * An invocation factory function to create a `MaskedEmail/*` 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 MaskedEmailInvocation(method, args, methodCallId);
+    }
+}
+export const MaskedEmail = {
+    request: {
+        /**
+         * Retrieves MaskedEmail objects by their IDs.
+         *
+         * @param args The invocation arguments for MaskedEmail/get
+         * @param methodCallId An optional unique symbol to identify this method call for result referencing
+         * @returns A MaskedEmailInvocation representing the MaskedEmail/get request
+         *
+         * @see {@link https://www.fastmail.com/dev/#masked-email-api | FastMail Developer Documentation - Masked Email API}
+         */
+        get: MaskedEmailInvocation.createInvocationFactory("get"),
+        /**
+         * Creates, updates, or destroys MaskedEmail objects.
+         *
+         * @param args The invocation arguments for MaskedEmail/set
+         * @param methodCallId An optional unique symbol to identify this method call for result referencing
+         * @returns A MaskedEmailInvocation representing the MaskedEmail/set request
+         *
+         * @see {@link https://www.fastmail.com/dev/#masked-email-api | FastMail Developer Documentation - Masked Email API}
+         */
+        set: MaskedEmailInvocation.createInvocationFactory("set"),
+    },
+    response: {
+        get: MaskedEmailInvocation.createInvocationFactory("get"),
+        set: MaskedEmailInvocation.createInvocationFactory("set"),
+    },
+};
+//# sourceMappingURL=maskedemail.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"maskedemail.js","sourceRoot":"","sources":["../../../../src/capabilities/maskedemail/maskedemail.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAEvE,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAW5D;;;;;;;;;GASG;AACH,MAAM,OAAO,qBAEX,SAAQ,UAAiB;IACvB,IAAI,GAAG;QACH,OAAO,2BAA2B,CAAC;IACvC,CAAC;IAED;;;;;;OAMG;IACH,YAAY,MAAsB,EAAE,IAA2B,EAAE,YAAqB;QAClF,KAAK,CAAC,aAAa,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;IACrD,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,uBAAuB,CAC1B,MAAsB;QAEtB;;;;;;WAMG;QACH,OAAO,CAAC,IAAI,EAAE,YAAY,EAAE,EAAE,CAAC,IAAI,qBAAqB,CAAQ,MAAM,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;IAChG,CAAC;CACJ;AAED,MAAM,CAAC,MAAM,WAAW,GAAG;IACvB,OAAO,EAAE;QACL;;;;;;;;WAQG;QACH,GAAG,EAAE,qBAAqB,CAAC,uBAAuB,CAAsC,KAAK,CAAC;QAC9F;;;;;;;;WAQG;QACH,GAAG,EAAE,qBAAqB,CAAC,uBAAuB,CAAsC,KAAK,CAAC;KACjG;IACD,QAAQ,EAAE;QACN,GAAG,EAAE,qBAAqB,CAAC,uBAAuB,CAAuC,KAAK,CAAC;QAC/F,GAAG,EAAE,qBAAqB,CAAC,uBAAuB,CAAuC,KAAK,CAAC;KAClG;CACkC,CAAC"}

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

@@ -0,0 +1,67 @@
+import type { BaseGetRequestInvocationArgs, BaseGetResponseInvocationArgs, BaseSetRequestInvocationArgs, BaseSetResponseInvocationArgs } from "../../invocation/types.js";
+/**
+ * The state of a MaskedEmail address.
+ * - pending: the initial state. Once set to anything else, it cannot be set back to pending. If a message is received by an address in the “pending” state, it will automatically be converted to “enabled”. Pending email addresses are automatically deleted 24h after creation.
+ * - enabled: the address is active and receiving mail normally.
+ * - disabled: the address is active, but mail is sent straight to trash.
+ * - deleted: the address is inactive; any mail sent to the address is bounced.
+ */
+export type MaskedEmailState = "pending" | "enabled" | "disabled" | "deleted";
+/**
+ * Immutable, server-set properties for MaskedEmail objects
+ */
+export type MaskedEmailObjectServerSet = {
+    /** The id of the masked email address (immutable; server-set). */
+    id: string;
+    /** The email address (immutable; server-set). */
+    email: string;
+    /** The date-time the most recent message was received at this email address, if any (server-set). */
+    lastMessageAt: string | null;
+    /** The date-time the email address was created (immutable; server-set). */
+    createdAt: string;
+    /** The name of the client that created this email address (immutable; server-set). */
+    createdBy: string;
+};
+/**
+ * Settable properties for MaskedEmail objects
+ */
+export type MaskedEmailObjectSettable = {
+    /** The state of the masked email address (default: pending). */
+    state?: MaskedEmailState;
+    /** The domain name of the site this address was created for, e.g. “https://example.com”. */
+    forDomain: string;
+    /** A short description of what this email address is for. */
+    description: string;
+    /** A URL pointing back to the integrator’s use of this email address, e.g. a custom-uri to open a password manager (nullable). */
+    url?: string | null;
+    /** The prefix for the generated email address (optional, create-only). Must be <= 64 chars, only a-z, 0-9, _ */
+    emailPrefix?: string;
+};
+/**
+ * The MaskedEmail object type representing a masked email address (intersection of server-set and settable properties)
+ */
+export type MaskedEmailObject = MaskedEmailObjectServerSet & MaskedEmailObjectSettable;
+/**
+ * Arguments for MaskedEmail/get method.
+ */
+export type MaskedEmailGetRequestInvocationArgs = BaseGetRequestInvocationArgs<MaskedEmailObject>;
+/**
+ * Response for MaskedEmail/get method.
+ */
+export type MaskedEmailGetResponseInvocationArgs = BaseGetResponseInvocationArgs<MaskedEmailObject>;
+/**
+ * Arguments for MaskedEmail/set method.
+ */
+export type MaskedEmailSetRequestInvocationArgs = BaseSetRequestInvocationArgs<MaskedEmailObjectSettable>;
+/**
+ * Response for MaskedEmail/set method.
+ */
+export type MaskedEmailSetResponseInvocationArgs = BaseSetResponseInvocationArgs<MaskedEmailObject>;
+/**
+ * Union type of all MaskedEmail capability request invocation arguments
+ */
+export type MaskedEmailRequestInvocationArgs = MaskedEmailGetRequestInvocationArgs | MaskedEmailSetRequestInvocationArgs;
+/**
+ * Union type of all MaskedEmail capability response invocation arguments
+ */
+export type MaskedEmailResponseInvocationArgs = MaskedEmailGetResponseInvocationArgs | MaskedEmailSetResponseInvocationArgs;

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

@@ -0,0 +1,4 @@
+// MaskedEmail types for the MaskedEmail JMAP capability
+// See: https://www.fastmail.com/dev/maskedemail
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/capabilities/maskedemail/types.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,gDAAgD"}

package/dist/src/capabilities/maskedemail-capability.d.ts

@@ -0,0 +1,112 @@
+import type { ValidationPlugin } from "../capability-registry/types.js";
+import { MASKED_EMAIL_CAPABILITY_URI } from "../common/registry.js";
+import type { MaskedEmailSetRequestInvocationArgs } from "./maskedemail/types.js";
+/**
+ * Validates that invocations using the MaskedEmail capability have a valid accountId that supports
+ * the MaskedEmail capability.
+ *
+ * This plugin performs three critical validation checks:
+ * 1. Verifies the invocation includes a valid `accountId` argument (non-empty string)
+ * 2. Confirms the account exists in the session's accounts collection
+ * 3. Ensures the account's `accountCapabilities` includes the MaskedEmail capability URI
+ *
+ * This validation applies to all MaskedEmail capability invocations (MaskedEmail/get, MaskedEmail/set)
+ * and implements the account capability checks for the FastMail Masked Email extension.
+ *
+ * @see {@link https://www.fastmail.com/dev/#masked-email-api | FastMail Developer Documentation - Masked Email API}
+ */
+export declare const maskedEmailAccountSupportPlugin: ValidationPlugin<"invocation">;
+/**
+ * Validates emailPrefix constraints for MaskedEmail creation.
+ *
+ * This plugin enforces FastMail's requirements for the emailPrefix property:
+ *
+ * **Email Prefix Constraints:**
+ * - Must be 64 characters or less
+ * - May only contain lowercase letters (a-z), digits (0-9), and underscores (_)
+ * - Only applicable during MaskedEmail creation (not updates)
+ *
+ * The emailPrefix is an optional property that allows clients to suggest a prefix for the
+ * generated masked email address. If not provided, the server generates one automatically.
+ *
+ * These validations catch invalid prefixes before sending requests to the server, providing
+ * immediate feedback and avoiding unnecessary network round-trips.
+ *
+ * @see {@link https://www.fastmail.com/dev/#masked-email-api | FastMail Developer Documentation - Masked Email API}
+ */
+export declare const maskedEmailPrefixValidationPlugin: ValidationPlugin<"invocation", MaskedEmailSetRequestInvocationArgs>;
+/**
+ * Validates MaskedEmail state transition constraints.
+ *
+ * This plugin enforces FastMail's state machine rules for MaskedEmail objects:
+ *
+ * **State Transition Rules:**
+ * - Once a MaskedEmail transitions from "pending" to any other state, it cannot be set back to "pending"
+ * - Valid states: "pending", "enabled", "disabled", "deleted"
+ * - State can transition: pending → enabled/disabled/deleted
+ * - State can transition: enabled ⟷ disabled ⟷ deleted
+ * - State cannot transition: enabled/disabled/deleted → pending
+ *
+ * **Automatic Transitions:**
+ * - Pending addresses automatically become "enabled" when they receive their first message
+ * - Pending addresses are automatically deleted after 24 hours if unused
+ *
+ * This validation prevents invalid state transitions during updates, catching errors before
+ * they reach the server.
+ *
+ * @see {@link https://www.fastmail.com/dev/#masked-email-api | FastMail Developer Documentation - Masked Email API}
+ */
+export declare const maskedEmailStateValidationPlugin: ValidationPlugin<"invocation", MaskedEmailSetRequestInvocationArgs>;
+/**
+ * Defines the MaskedEmail capability, including MaskedEmail invocations and validation plugins
+ * for the FastMail Masked Email extension.
+ *
+ * **Note:** Read-only account protection for MaskedEmail/set is handled by Core's generic
+ * `preventSetOnReadOnlyAccountPlugin`, which validates all `/set` methods.
+ */
+export declare const MaskedEmailCapability: {
+    uri: "https://www.fastmail.com/dev/maskedemail";
+    invocations: {
+        MaskedEmail: {
+            request: {
+                get: import("../index.js").InvocationFactory<import("./maskedemail/types.js").MaskedEmailGetRequestInvocationArgs, import("./maskedemail/maskedemail.js").MaskedEmailInvocation<import("./maskedemail/types.js").MaskedEmailGetRequestInvocationArgs>>;
+                set: import("../index.js").InvocationFactory<MaskedEmailSetRequestInvocationArgs, import("./maskedemail/maskedemail.js").MaskedEmailInvocation<MaskedEmailSetRequestInvocationArgs>>;
+            };
+            response: {
+                get: import("../index.js").InvocationFactory<import("./maskedemail/types.js").MaskedEmailGetResponseInvocationArgs, import("./maskedemail/maskedemail.js").MaskedEmailInvocation<import("./maskedemail/types.js").MaskedEmailGetResponseInvocationArgs>>;
+                set: import("../index.js").InvocationFactory<import("./maskedemail/types.js").MaskedEmailSetResponseInvocationArgs, import("./maskedemail/maskedemail.js").MaskedEmailInvocation<import("./maskedemail/types.js").MaskedEmailSetResponseInvocationArgs>>;
+            };
+        };
+    };
+    validators: ({
+        name: string;
+        hook: "invocation";
+        trigger: {
+            capabilityUri?: import("../index.js").JMAPCapability;
+            dataType?: import("../index.js").JMAPDataType;
+            method?: import("../index.js").JMAPMethodName;
+        };
+        validate(this: void, context: import("../capability-registry/types.js").BasePluginContext & {
+            invocation: import("../index.js").Invocation<import("../index.js").BaseInvocationArgs>;
+        }): import("../index.js").MaybePromise<import("../capability-registry/types.js").ValidationResult>;
+    } | {
+        name: string;
+        hook: "invocation";
+        trigger: {
+            capabilityUri?: import("../index.js").JMAPCapability;
+            dataType?: import("../index.js").JMAPDataType;
+            method?: import("../index.js").JMAPMethodName;
+        };
+        validate(this: void, context: import("../capability-registry/types.js").BasePluginContext & {
+            invocation: import("../index.js").Invocation<MaskedEmailSetRequestInvocationArgs>;
+        }): import("../index.js").MaybePromise<import("../capability-registry/types.js").ValidationResult>;
+    })[];
+};
+declare module "../common/types.js" {
+    interface ServerCapabilityRegistry {
+        [MASKED_EMAIL_CAPABILITY_URI]?: EmptyObject;
+    }
+    interface AccountCapabilityRegistry {
+        [MASKED_EMAIL_CAPABILITY_URI]?: EmptyObject;
+    }
+}