@waterlock/gateway 0.0.0-stage → 0.1.1

package/dist/core/session.js

@@ -0,0 +1,66 @@
+const PREFIX = "as1";
+const enc = new TextEncoder();
+export function createSessions(opts) {
+    const keyBytes = typeof opts.signingKey === "string" ? enc.encode(opts.signingKey) : opts.signingKey;
+    if (keyBytes.length < 32)
+        throw new Error("session signingKey must be at least 32 bytes");
+    const now = opts.now ?? (() => Date.now());
+    const defaultTtl = opts.defaultTtlSeconds ?? 900;
+    const key = crypto.subtle.importKey("raw", keyBytes, { name: "HMAC", hash: "SHA-256" }, false, [
+        "sign",
+        "verify",
+    ]);
+    return {
+        store: opts.store,
+        async addUserMessage(input) {
+            if (!opts.store?.addUserMessage)
+                throw new Error("session store does not support addUserMessage");
+            await opts.store.addUserMessage(input);
+        },
+        async mint(input) {
+            const iat = Math.floor(now() / 1000);
+            const claims = {
+                sid: input.sid ?? crypto.randomUUID(),
+                provider: input.provider,
+                agent: input.agent,
+                onBehalfOf: input.onBehalfOf,
+                ...(input.intent ? { intent: input.intent } : {}),
+                iat,
+                exp: iat + (input.ttlSeconds ?? defaultTtl),
+            };
+            const payload = `${PREFIX}.${b64url(enc.encode(JSON.stringify(claims)))}`;
+            const sig = new Uint8Array(await crypto.subtle.sign("HMAC", await key, enc.encode(payload)));
+            return { token: `${payload}.${b64url(sig)}`, claims };
+        },
+        async verify({ token }) {
+            const parts = token.split(".");
+            if (parts.length !== 3 || parts[0] !== PREFIX)
+                return { error: "malformed" };
+            let sig;
+            let claims;
+            try {
+                sig = fromB64url(parts[2]);
+                const ok = await crypto.subtle.verify("HMAC", await key, sig, enc.encode(`${parts[0]}.${parts[1]}`));
+                if (!ok)
+                    return { error: "bad_signature" };
+                claims = JSON.parse(new TextDecoder().decode(fromB64url(parts[1])));
+            }
+            catch {
+                return { error: "malformed" };
+            }
+            if (typeof claims.exp !== "number" || typeof claims.provider !== "string")
+                return { error: "malformed" };
+            if (claims.exp * 1000 <= now())
+                return { error: "expired" };
+            return { claims };
+        },
+    };
+}
+function b64url(bytes) {
+    return Buffer.from(bytes).toString("base64url");
+}
+function fromB64url(s) {
+    if (!/^[A-Za-z0-9_-]*$/.test(s))
+        throw new Error("bad base64url");
+    return new Uint8Array(Buffer.from(s, "base64url"));
+}

package/dist/core/store.d.ts

@@ -0,0 +1,44 @@
+import type { SessionClaims } from "./session.js";
+/** One message the human typed. An object so it can gain fields (id, role, source...) later. */
+export interface UserMessage {
+    text: string;
+    at?: Date;
+}
+/** A page of user messages. An object so it can gain fields (hasMore, cursor...) later. */
+export interface UserMessages {
+    items: UserMessage[];
+}
+/** Points at a session. Grows with new identifiers without breaking stores. */
+export interface SessionRef {
+    sid: string;
+}
+/**
+ * Pluggable session storage. Every method is optional: implement one and the gateway uses
+ * the feature it unlocks. No store at all = stateless signed tokens, no extras.
+ * Methods take a single input object so new fields never break existing stores.
+ *
+ * Trust: this is the gateway's view of the truth. Only trusted code (your front door /
+ * backend) may write to it, never the agent. A store that returns agent-written data
+ * lets a rogue agent forge context.
+ */
+export interface SessionStore {
+    /** Record what the human said. Called by your trusted front door via `sessions.addUserMessage`. */
+    addUserMessage?(input: {
+        session: SessionRef;
+        message: UserMessage;
+    }): Promise<void>;
+    /**
+     * Messages the human typed in this session, oldest first. When implemented, `checkPrompt`
+     * reads them (via the `store` handed to `check`) and adds them as intent context.
+     * Must return only messages written by trusted code (filter out assistant/tool/agent rows).
+     * `limit`: return at most the last N.
+     */
+    getUserMessages?(input: {
+        session: SessionClaims;
+        limit?: number;
+    }): Promise<UserMessages>;
+}
+/** In-process store. One gateway process only; data is lost on restart. */
+export declare function memoryStore(opts?: {
+    maxMessagesPerSession?: number;
+}): Required<SessionStore>;

package/dist/core/store.js

@@ -0,0 +1,18 @@
+/** In-process store. One gateway process only; data is lost on restart. */
+export function memoryStore(opts = {}) {
+    const max = opts.maxMessagesPerSession ?? 50;
+    const messages = new Map();
+    return {
+        async addUserMessage({ session, message }) {
+            const list = messages.get(session.sid) ?? [];
+            list.push({ ...message, at: message.at ?? new Date() });
+            if (list.length > max)
+                list.splice(0, list.length - max);
+            messages.set(session.sid, list);
+        },
+        async getUserMessages({ session, limit }) {
+            const list = messages.get(session.sid) ?? [];
+            return { items: (limit === undefined ? list : list.slice(-limit)).map((m) => ({ ...m })) };
+        },
+    };
+}

package/dist/core/types.d.ts

@@ -0,0 +1,40 @@
+/** May gain members later (e.g. "HEAD"). */
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export declare const HTTP_METHODS: readonly HttpMethod[];
+export type ParamType = "string" | "integer" | "number" | "boolean";
+export interface ParamSpec {
+    name: string;
+    in: "path" | "query";
+    type: ParamType;
+    required?: boolean;
+    repeated?: boolean;
+    enum?: readonly string[];
+    /** `{+name}` template: value may span multiple path segments. */
+    multiSegment?: boolean;
+}
+/**
+ * Same action can be reachable through several routes. Google APIs expose
+ * `/upload/...` and `/resumable/upload/...` twins for media methods — each is
+ * a separate route to the same action and must be governed the same way.
+ */
+export type OperationVariant = "standard" | "upload" | "resumable";
+export interface Operation {
+    action: string;
+    method: HttpMethod;
+    path: string;
+    variant: OperationVariant;
+    params: readonly ParamSpec[];
+    hasBody: boolean;
+}
+export interface OperationTable {
+    provider: string;
+    source: {
+        kind: "discovery" | "openapi";
+        title: string;
+        version: string;
+        revision?: string;
+        url?: string;
+    };
+    globalQueryParams: readonly ParamSpec[];
+    operations: readonly Operation[];
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export const HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { createGateway, type GatewayOptions } from "./core/gateway.js";
+export { definePolicy, type AnyRequest, type Policy, type PolicyRule, type ProviderRequest, } from "./core/policy.js";
+export { evaluatePolicy, type Check, type CheckOptions, type Decision } from "./core/evaluate.js";
+export { createSessions, type MintInput, type SessionClaims, type Sessions, type VerifyError } from "./core/session.js";
+export { memoryStore, type SessionRef, type SessionStore, type UserMessage, type UserMessages } from "./core/store.js";
+export { oauth2Refresh, staticToken, type Credential, type CredentialSource } from "./core/credentials.js";
+export { createProvider, type Decoder, type ProviderDefinition, type RequestOf } from "./core/provider.js";
+export { createMatcher, type Matcher, type MatchResult } from "./core/match.js";
+export type { HttpMethod, Operation, OperationTable, OperationVariant, ParamSpec } from "./core/types.js";

package/dist/index.js

@@ -0,0 +1,8 @@
+export { createGateway } from "./core/gateway.js";
+export { definePolicy, } from "./core/policy.js";
+export { evaluatePolicy } from "./core/evaluate.js";
+export { createSessions } from "./core/session.js";
+export { memoryStore } from "./core/store.js";
+export { oauth2Refresh, staticToken } from "./core/credentials.js";
+export { createProvider } from "./core/provider.js";
+export { createMatcher } from "./core/match.js";

package/dist/providers/gmail/decode.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Gmail sends opaque base64url RFC 822 in `raw`. Recipients live in the MIME headers and
+ * content in (possibly nested, encoded) MIME parts, so policy can't see either without
+ * decoding. postal-mime does the parsing; it is lenient like a mail client, so the checks
+ * below turn anything ambiguous into a throw, which denies the call.
+ */
+export interface GmailAttachment {
+    contentType: string;
+    filename: string | null;
+}
+export interface GmailMessageContext {
+    /** Lowercased addresses from every To, Cc and Bcc header. */
+    recipients: string[];
+    recipient_domains: string[];
+    subject: string | null;
+    /** The text/plain body as sent. Null when the message has none (e.g. HTML-only). */
+    text: string | null;
+    /** The text/html body as sent, markup included. Null when the message has none. */
+    html: string | null;
+    attachments: GmailAttachment[];
+}
+/**
+ * drafts.send sends a stored draft by id. The body may contain a message, but
+ * Gmail sends the stored version, so recipients and content are unknown to the
+ * gateway. Typed as null so policies must decide explicitly what to do.
+ */
+export interface GmailDraftSendContext {
+    recipients: null;
+    recipient_domains: null;
+    subject: null;
+    text: null;
+    html: null;
+    attachments: null;
+    draft_id: string;
+}
+export declare function decodeMessageSend(body: Uint8Array): Promise<GmailMessageContext>;
+export declare function decodeDraftWrite(body: Uint8Array): Promise<GmailMessageContext>;
+export declare function decodeDraftSend(body: Uint8Array): GmailDraftSendContext;

package/dist/providers/gmail/decode.js

@@ -0,0 +1,85 @@
+import PostalMime from "postal-mime";
+export async function decodeMessageSend(body) {
+    const json = parseJson(body);
+    return fromRaw(json.raw);
+}
+export async function decodeDraftWrite(body) {
+    const json = parseJson(body);
+    return fromRaw(json.message?.raw);
+}
+export function decodeDraftSend(body) {
+    const json = parseJson(body);
+    if (typeof json.id !== "string" || !json.id)
+        throw new Error("drafts.send requires a draft id");
+    return { recipients: null, recipient_domains: null, subject: null, text: null, html: null, attachments: null, draft_id: json.id };
+}
+function parseJson(body) {
+    const parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(body));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+        throw new Error("body must be a JSON object");
+    return parsed;
+}
+/** Strict on purpose: no quotes, spaces, brackets or comments. Anything fancier denies. */
+const ADDR = /^[^\s@<>()",;:[\]\\]+@[A-Za-z0-9.-]+$/;
+async function fromRaw(raw) {
+    if (typeof raw !== "string" || !raw)
+        throw new Error("missing raw message");
+    if (!/^[A-Za-z0-9+/_-]+={0,2}$/.test(raw))
+        throw new Error("raw is not base64");
+    const bytes = Buffer.from(raw, "base64url");
+    // Limits throw (deny) instead of truncating.
+    const email = await PostalMime.parse(bytes, { maxNestingDepth: 8, maxPartCount: 100, attachmentEncoding: "arraybuffer" });
+    const headerValues = (key) => email.headers.filter((h) => h.key === key).map((h) => h.value);
+    const recipients = [
+        ...addresses(email.to, headerValues("to")),
+        ...addresses(email.cc, headerValues("cc")),
+        ...addresses(email.bcc, headerValues("bcc")),
+    ];
+    const unique = [...new Set(recipients)];
+    assertBodyParsed(bytes, email);
+    return {
+        recipients: unique,
+        recipient_domains: [...new Set(unique.map((a) => a.slice(a.lastIndexOf("@") + 1)))],
+        subject: email.subject ?? null,
+        text: email.text ?? null,
+        html: email.html ?? null,
+        attachments: email.attachments.map((a) => ({ contentType: a.mimeType, filename: a.filename })),
+    };
+}
+/**
+ * postal-mime keeps going on malformed lists: `a@x <b@y> <c@z>` yields b@y with
+ * "a@x c@z" as the display name. Gmail may read that differently, so: every address must
+ * be plain, and an address-like display name is only accepted when it was quoted or a comment.
+ */
+function addresses(list, rawHeaders) {
+    const raw = rawHeaders.join("\n");
+    return (list ?? [])
+        .flatMap((a) => (a.group ? a.group : [a]))
+        .map(({ address, name }) => {
+        if (!ADDR.test(address))
+            throw new Error(`unparseable recipient ${JSON.stringify(address || name)}`);
+        const delimited = raw.includes(`"${name}"`) || raw.includes(`(${name})`);
+        if (/[@<>]/.test(name) && !delimited)
+            throw new Error(`ambiguous recipient ${JSON.stringify(name)} <${address}>`);
+        return address.toLowerCase();
+    });
+}
+/**
+ * Lenient parsing can drop content it doesn't understand (e.g. a broken multipart boundary),
+ * which a content check would then never see. Deny when a non-empty body produced nothing,
+ * or a top-level multipart is never closed.
+ */
+function assertBodyParsed(bytes, email) {
+    const source = Buffer.from(bytes).toString("latin1");
+    const split = source.search(/\r?\n\r?\n/);
+    const body = split === -1 ? "" : source.slice(split).trim();
+    if (body && !email.text && !email.html && email.attachments.length === 0)
+        throw new Error("message body could not be parsed");
+    const contentType = email.headers.find((h) => h.key === "content-type")?.value ?? "";
+    const boundary = contentType.match(/boundary\s*=\s*(?:"([^"]+)"|([^\s;]+))/i);
+    if (/^\s*multipart\//i.test(contentType)) {
+        const b = boundary?.[1] ?? boundary?.[2];
+        if (!b || !source.includes(`--${b}--`))
+            throw new Error("multipart message is missing its closing boundary");
+    }
+}

package/dist/providers/gmail/generated.d.ts

@@ -0,0 +1,323 @@
+import type { OperationTable } from "../../core/types.js";
+export type GmailAction = "gmail.users.drafts.create" | "gmail.users.drafts.delete" | "gmail.users.drafts.get" | "gmail.users.drafts.list" | "gmail.users.drafts.send" | "gmail.users.drafts.update" | "gmail.users.getProfile" | "gmail.users.history.list" | "gmail.users.labels.create" | "gmail.users.labels.delete" | "gmail.users.labels.get" | "gmail.users.labels.list" | "gmail.users.labels.patch" | "gmail.users.labels.update" | "gmail.users.messages.attachments.get" | "gmail.users.messages.batchDelete" | "gmail.users.messages.batchModify" | "gmail.users.messages.delete" | "gmail.users.messages.get" | "gmail.users.messages.import" | "gmail.users.messages.insert" | "gmail.users.messages.list" | "gmail.users.messages.modify" | "gmail.users.messages.send" | "gmail.users.messages.trash" | "gmail.users.messages.untrash" | "gmail.users.settings.cse.identities.create" | "gmail.users.settings.cse.identities.delete" | "gmail.users.settings.cse.identities.get" | "gmail.users.settings.cse.identities.list" | "gmail.users.settings.cse.identities.patch" | "gmail.users.settings.cse.keypairs.create" | "gmail.users.settings.cse.keypairs.disable" | "gmail.users.settings.cse.keypairs.enable" | "gmail.users.settings.cse.keypairs.get" | "gmail.users.settings.cse.keypairs.list" | "gmail.users.settings.cse.keypairs.obliterate" | "gmail.users.settings.delegates.create" | "gmail.users.settings.delegates.delete" | "gmail.users.settings.delegates.get" | "gmail.users.settings.delegates.list" | "gmail.users.settings.filters.create" | "gmail.users.settings.filters.delete" | "gmail.users.settings.filters.get" | "gmail.users.settings.filters.list" | "gmail.users.settings.forwardingAddresses.create" | "gmail.users.settings.forwardingAddresses.delete" | "gmail.users.settings.forwardingAddresses.get" | "gmail.users.settings.forwardingAddresses.list" | "gmail.users.settings.getAutoForwarding" | "gmail.users.settings.getImap" | "gmail.users.settings.getLanguage" | "gmail.users.settings.getPop" | "gmail.users.settings.getVacation" | "gmail.users.settings.sendAs.create" | "gmail.users.settings.sendAs.delete" | "gmail.users.settings.sendAs.get" | "gmail.users.settings.sendAs.list" | "gmail.users.settings.sendAs.patch" | "gmail.users.settings.sendAs.smimeInfo.delete" | "gmail.users.settings.sendAs.smimeInfo.get" | "gmail.users.settings.sendAs.smimeInfo.insert" | "gmail.users.settings.sendAs.smimeInfo.list" | "gmail.users.settings.sendAs.smimeInfo.setDefault" | "gmail.users.settings.sendAs.update" | "gmail.users.settings.sendAs.verify" | "gmail.users.settings.updateAutoForwarding" | "gmail.users.settings.updateImap" | "gmail.users.settings.updateLanguage" | "gmail.users.settings.updatePop" | "gmail.users.settings.updateVacation" | "gmail.users.stop" | "gmail.users.threads.delete" | "gmail.users.threads.get" | "gmail.users.threads.list" | "gmail.users.threads.modify" | "gmail.users.threads.trash" | "gmail.users.threads.untrash" | "gmail.users.watch";
+/** Typed path + query params per action, as seen by policy rules. */
+export interface GmailParams {
+    "gmail.users.drafts.create": {
+        "userId": string;
+    };
+    "gmail.users.drafts.delete": {
+        "id": string;
+        "userId": string;
+    };
+    "gmail.users.drafts.get": {
+        "format"?: "minimal" | "full" | "raw" | "metadata";
+        "id": string;
+        "userId": string;
+    };
+    "gmail.users.drafts.list": {
+        "includeSpamTrash"?: boolean;
+        "maxResults"?: number;
+        "pageToken"?: string;
+        "q"?: string;
+        "userId": string;
+    };
+    "gmail.users.drafts.send": {
+        "userId": string;
+    };
+    "gmail.users.drafts.update": {
+        "id": string;
+        "userId": string;
+    };
+    "gmail.users.getProfile": {
+        "userId": string;
+    };
+    "gmail.users.history.list": {
+        "historyTypes"?: ("messageAdded" | "messageDeleted" | "labelAdded" | "labelRemoved")[];
+        "labelId"?: string;
+        "maxResults"?: number;
+        "pageToken"?: string;
+        "startHistoryId"?: string;
+        "userId": string;
+    };
+    "gmail.users.labels.create": {
+        "userId": string;
+    };
+    "gmail.users.labels.delete": {
+        "id": string;
+        "userId": string;
+    };
+    "gmail.users.labels.get": {
+        "id": string;
+        "userId": string;
+    };
+    "gmail.users.labels.list": {
+        "userId": string;
+    };
+    "gmail.users.labels.patch": {
+        "id": string;
+        "userId": string;
+    };
+    "gmail.users.labels.update": {
+        "id": string;
+        "userId": string;
+    };
+    "gmail.users.messages.attachments.get": {
+        "id": string;
+        "messageId": string;
+        "userId": string;
+    };
+    "gmail.users.messages.batchDelete": {
+        "userId": string;
+    };
+    "gmail.users.messages.batchModify": {
+        "userId": string;
+    };
+    "gmail.users.messages.delete": {
+        "id": string;
+        "userId": string;
+    };
+    "gmail.users.messages.get": {
+        "format"?: "minimal" | "full" | "raw" | "metadata";
+        "id": string;
+        "metadataHeaders"?: string[];
+        "userId": string;
+    };
+    "gmail.users.messages.import": {
+        "deleted"?: boolean;
+        "internalDateSource"?: "receivedTime" | "dateHeader";
+        "neverMarkSpam"?: boolean;
+        "processForCalendar"?: boolean;
+        "userId": string;
+    };
+    "gmail.users.messages.insert": {
+        "deleted"?: boolean;
+        "internalDateSource"?: "receivedTime" | "dateHeader";
+        "userId": string;
+    };
+    "gmail.users.messages.list": {
+        "includeSpamTrash"?: boolean;
+        "labelIds"?: string[];
+        "maxResults"?: number;
+        "pageToken"?: string;
+        "q"?: string;
+        "userId": string;
+    };
+    "gmail.users.messages.modify": {
+        "id": string;
+        "userId": string;
+    };
+    "gmail.users.messages.send": {
+        "userId": string;
+    };
+    "gmail.users.messages.trash": {
+        "id": string;
+        "userId": string;
+    };
+    "gmail.users.messages.untrash": {
+        "id": string;
+        "userId": string;
+    };
+    "gmail.users.settings.cse.identities.create": {
+        "userId": string;
+    };
+    "gmail.users.settings.cse.identities.delete": {
+        "cseEmailAddress": string;
+        "userId": string;
+    };
+    "gmail.users.settings.cse.identities.get": {
+        "cseEmailAddress": string;
+        "userId": string;
+    };
+    "gmail.users.settings.cse.identities.list": {
+        "pageSize"?: number;
+        "pageToken"?: string;
+        "userId": string;
+    };
+    "gmail.users.settings.cse.identities.patch": {
+        "emailAddress": string;
+        "userId": string;
+    };
+    "gmail.users.settings.cse.keypairs.create": {
+        "chainValidation"?: "all" | "none";
+        "userId": string;
+    };
+    "gmail.users.settings.cse.keypairs.disable": {
+        "keyPairId": string;
+        "userId": string;
+    };
+    "gmail.users.settings.cse.keypairs.enable": {
+        "keyPairId": string;
+        "userId": string;
+    };
+    "gmail.users.settings.cse.keypairs.get": {
+        "keyPairId": string;
+        "userId": string;
+    };
+    "gmail.users.settings.cse.keypairs.list": {
+        "pageSize"?: number;
+        "pageToken"?: string;
+        "userId": string;
+    };
+    "gmail.users.settings.cse.keypairs.obliterate": {
+        "keyPairId": string;
+        "userId": string;
+    };
+    "gmail.users.settings.delegates.create": {
+        "userId": string;
+    };
+    "gmail.users.settings.delegates.delete": {
+        "delegateEmail": string;
+        "userId": string;
+    };
+    "gmail.users.settings.delegates.get": {
+        "delegateEmail": string;
+        "userId": string;
+    };
+    "gmail.users.settings.delegates.list": {
+        "userId": string;
+    };
+    "gmail.users.settings.filters.create": {
+        "userId": string;
+    };
+    "gmail.users.settings.filters.delete": {
+        "id": string;
+        "userId": string;
+    };
+    "gmail.users.settings.filters.get": {
+        "id": string;
+        "userId": string;
+    };
+    "gmail.users.settings.filters.list": {
+        "userId": string;
+    };
+    "gmail.users.settings.forwardingAddresses.create": {
+        "userId": string;
+    };
+    "gmail.users.settings.forwardingAddresses.delete": {
+        "forwardingEmail": string;
+        "userId": string;
+    };
+    "gmail.users.settings.forwardingAddresses.get": {
+        "forwardingEmail": string;
+        "userId": string;
+    };
+    "gmail.users.settings.forwardingAddresses.list": {
+        "userId": string;
+    };
+    "gmail.users.settings.getAutoForwarding": {
+        "userId": string;
+    };
+    "gmail.users.settings.getImap": {
+        "userId": string;
+    };
+    "gmail.users.settings.getLanguage": {
+        "userId": string;
+    };
+    "gmail.users.settings.getPop": {
+        "userId": string;
+    };
+    "gmail.users.settings.getVacation": {
+        "userId": string;
+    };
+    "gmail.users.settings.sendAs.create": {
+        "userId": string;
+    };
+    "gmail.users.settings.sendAs.delete": {
+        "sendAsEmail": string;
+        "userId": string;
+    };
+    "gmail.users.settings.sendAs.get": {
+        "sendAsEmail": string;
+        "userId": string;
+    };
+    "gmail.users.settings.sendAs.list": {
+        "userId": string;
+    };
+    "gmail.users.settings.sendAs.patch": {
+        "sendAsEmail": string;
+        "userId": string;
+    };
+    "gmail.users.settings.sendAs.smimeInfo.delete": {
+        "id": string;
+        "sendAsEmail": string;
+        "userId": string;
+    };
+    "gmail.users.settings.sendAs.smimeInfo.get": {
+        "id": string;
+        "sendAsEmail": string;
+        "userId": string;
+    };
+    "gmail.users.settings.sendAs.smimeInfo.insert": {
+        "sendAsEmail": string;
+        "userId": string;
+    };
+    "gmail.users.settings.sendAs.smimeInfo.list": {
+        "sendAsEmail": string;
+        "userId": string;
+    };
+    "gmail.users.settings.sendAs.smimeInfo.setDefault": {
+        "id": string;
+        "sendAsEmail": string;
+        "userId": string;
+    };
+    "gmail.users.settings.sendAs.update": {
+        "sendAsEmail": string;
+        "userId": string;
+    };
+    "gmail.users.settings.sendAs.verify": {
+        "sendAsEmail": string;
+        "userId": string;
+    };
+    "gmail.users.settings.updateAutoForwarding": {
+        "userId": string;
+    };
+    "gmail.users.settings.updateImap": {
+        "userId": string;
+    };
+    "gmail.users.settings.updateLanguage": {
+        "userId": string;
+    };
+    "gmail.users.settings.updatePop": {
+        "userId": string;
+    };
+    "gmail.users.settings.updateVacation": {
+        "userId": string;
+    };
+    "gmail.users.stop": {
+        "userId": string;
+    };
+    "gmail.users.threads.delete": {
+        "id": string;
+        "userId": string;
+    };
+    "gmail.users.threads.get": {
+        "format"?: "full" | "metadata" | "minimal";
+        "id": string;
+        "metadataHeaders"?: string[];
+        "userId": string;
+    };
+    "gmail.users.threads.list": {
+        "includeSpamTrash"?: boolean;
+        "labelIds"?: string[];
+        "maxResults"?: number;
+        "pageToken"?: string;
+        "q"?: string;
+        "userId": string;
+    };
+    "gmail.users.threads.modify": {
+        "id": string;
+        "userId": string;
+    };
+    "gmail.users.threads.trash": {
+        "id": string;
+        "userId": string;
+    };
+    "gmail.users.threads.untrash": {
+        "id": string;
+        "userId": string;
+    };
+    "gmail.users.watch": {
+        "userId": string;
+    };
+}
+export declare const gmailTable: OperationTable;