@stackshift-cloud/sdk 1.3.1 → 1.4.0

package/dist/mail-mailboxes.d.ts

@@ -0,0 +1,358 @@
+import type { StackShift } from './client.js';
+export type MailboxDomainStatus = 'pending' | 'receiving' | 'mx_lost' | 'disabled';
+export type MailboxStatus = 'active' | 'suspended' | 'pending' | 'deleted';
+export type MailboxKind = 'person' | 'shared';
+export type MailboxPlanSlug = 'basic' | 'pro';
+export type MailboxRouteTargetKind = 'mailbox' | 'group' | 'app' | 'support' | 'forward' | 'reject';
+export interface MailboxRouteTarget {
+    kind: MailboxRouteTargetKind;
+    mailboxId?: string;
+    groupId?: string;
+    webhookUrl?: string;
+    supportChannelId?: string;
+    forwardTo?: string;
+}
+export interface MailboxDnsRecord {
+    type: string;
+    name: string;
+    value: string;
+    priority?: number;
+    status: string;
+    required: boolean;
+    explanation?: string;
+}
+export interface MailboxDomain {
+    id: string;
+    workspaceId: string;
+    domain: string;
+    status: MailboxDomainStatus;
+    mxVerifiedAt?: string;
+    catchAll?: MailboxRouteTarget;
+    retentionDays?: number;
+    addonStorageUnits: number;
+    quotaPoolBytes: number;
+    usedBytes: number;
+    verificationToken: string;
+    revision: number;
+    createdAt: string;
+    updatedAt: string;
+    records: MailboxDnsRecord[];
+    foundMx: string | null;
+    dns: {
+        cloudflareConnected: boolean;
+        lastApplied: {
+            at: string;
+            byName: string;
+            recordCount: number;
+        } | null;
+    };
+}
+export interface MailboxDomainUpdateInput {
+    catchAll?: MailboxRouteTarget | null;
+    retentionDays?: number | null;
+    addonStorageUnits?: number;
+}
+export interface MailboxInvitation {
+    email: string;
+    expiresAt: string;
+    expired: boolean;
+}
+export interface Mailbox {
+    id: string;
+    workspaceId: string;
+    domainId: string;
+    localPart: string;
+    address: string;
+    displayName: string;
+    kind: MailboxKind;
+    ownerUserId?: string;
+    quotaBytes: number;
+    usedBytes: number;
+    plan: MailboxPlanSlug;
+    status: MailboxStatus;
+    aiEnabled: boolean;
+    revision: number;
+    createdAt: string;
+    updatedAt: string;
+    invitation: MailboxInvitation | null;
+    aiMicrocreditsThisMonth: number | null;
+}
+export interface MailboxCreateInput {
+    domainId: string;
+    localPart: string;
+    displayName?: string;
+    kind?: MailboxKind;
+    ownerUserId?: string;
+    ownerEmail?: string;
+    plan?: MailboxPlanSlug;
+    quotaBytes?: number;
+    aiEnabled?: boolean;
+}
+export interface MailboxUpdateInput {
+    displayName?: string;
+    quotaBytes?: number;
+    aiEnabled?: boolean;
+    plan?: MailboxPlanSlug;
+}
+export interface MailboxMember {
+    mailboxId: string;
+    userId: string;
+    role: 'owner' | 'member';
+    createdAt: string;
+}
+export interface MailboxAppPassword {
+    id: string;
+    mailboxId: string;
+    label: string;
+    lastUsedAt?: string;
+    createdAt: string;
+    revokedAt?: string;
+}
+export interface MailboxAppPasswordCreated extends MailboxAppPassword {
+    secret: string;
+}
+export interface MailboxDevice {
+    id: string;
+    kind: 'app_password' | 'web';
+    label: string;
+    lastUsedAt: string | null;
+    createdAt: string;
+}
+export interface MailboxPasswordReset {
+    password: string;
+    appliedNow: boolean;
+}
+export interface MailboxProfileLink {
+    url: string;
+    expiresAt: string;
+}
+export interface MailboxPlan {
+    slug: MailboxPlanSlug;
+    quotaBytes: number;
+    monthlyPriceKobo: number;
+}
+export interface MailboxPricing {
+    plans: MailboxPlan[];
+    addonUnitBytes: number;
+    addonPriceKobo: number;
+    pricesArePlaceholders: boolean;
+}
+export interface MailboxClientEndpoint {
+    host: string;
+    port: number;
+    security: string;
+}
+export interface MailboxClientSettings {
+    incoming: MailboxClientEndpoint | null;
+    outgoing: MailboxClientEndpoint | null;
+}
+export interface MailboxUsage {
+    mailboxLimit: number;
+    mailboxesUsed: number;
+    ai: {
+        availableMicrocredits: number;
+        usedThisMonthMicrocredits: number;
+        nextReset: string;
+    } | null;
+}
+export interface MailboxAlias {
+    id: string;
+    mailboxId: string;
+    address: string;
+    sendAs: boolean;
+    createdAt: string;
+}
+export interface MailboxAliasCreateInput {
+    mailboxId: string;
+    localPart: string;
+    domainId?: string;
+    sendAs?: boolean;
+}
+export interface MailboxGroup {
+    id: string;
+    domainId: string;
+    address: string;
+    displayName: string;
+    memberIds: string[];
+    moderatorId?: string;
+    revision: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface MailboxGroupCreateInput {
+    domainId: string;
+    localPart: string;
+    displayName?: string;
+    memberIds?: string[];
+    moderatorId?: string;
+}
+export interface MailboxGroupUpdateInput {
+    displayName?: string;
+    moderatorId?: string | null;
+    memberIds?: string[];
+}
+export interface MailboxRoute {
+    id: string;
+    domainId: string;
+    pattern: string;
+    priority: number;
+    targets: MailboxRouteTarget[];
+    revision: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface MailboxRouteCreateInput {
+    domainId: string;
+    pattern: string;
+    priority?: number;
+    targets: MailboxRouteTarget[];
+}
+export interface MailboxRouteUpdateInput {
+    priority?: number;
+    targets?: MailboxRouteTarget[];
+}
+export interface MailboxAppHealthIssue {
+    routeId: string;
+    address: string;
+    since: string;
+    undeliveredCount: number;
+    holderName: string | null;
+    url: string;
+    lastError: string;
+    endpointId: string;
+}
+export type MailboxImportSource = 'google' | 'microsoft' | 'stackshift-hosting' | 'imap';
+export interface MailboxImportAccountInput {
+    mailboxId: string;
+    username: string;
+    password: string;
+}
+export interface MailboxImportStartInput {
+    domainId: string;
+    source: MailboxImportSource;
+    host?: string;
+    port?: number;
+    accounts: MailboxImportAccountInput[];
+}
+export interface MailboxImportMailbox {
+    mailboxId: string;
+    address: string;
+    sourceUsername: string;
+    state: 'pending' | 'copying' | 'copied' | 'refused' | 'skipped' | 'failed' | 'cancelled';
+    totalEmails: number;
+    copiedEmails: number;
+    totalBytes: number;
+    copiedBytes: number;
+    minutesLeft: number | null;
+    message: string | null;
+}
+export interface MailboxImport {
+    id: string;
+    domainId: string;
+    domain: string;
+    source: MailboxImportSource;
+    sourceLabel: string;
+    host: string;
+    createdAt: string;
+    updatedAt: string;
+    stage: 'copy' | 'switch' | 'done' | 'cancelled';
+    switch: {
+        requestedFor: string | null;
+        scheduledAt: string | null;
+        switchedAt: string | null;
+    };
+    mailboxes: MailboxImportMailbox[];
+}
+interface MailboxList<T> {
+    data: T[];
+}
+export declare class MailboxDomainsClient {
+    private readonly client;
+    constructor(client: StackShift);
+    create(domain: string): Promise<MailboxDomain>;
+    list(): Promise<MailboxList<MailboxDomain>>;
+    get(domainId: string): Promise<MailboxDomain>;
+    update(domainId: string, input: MailboxDomainUpdateInput): Promise<MailboxDomain>;
+    verify(domainId: string): Promise<MailboxDomain>;
+    applyDns(domainId: string): Promise<MailboxDomain>;
+    dnsApplications(domainId: string): Promise<MailboxList<Record<string, unknown>>>;
+    delete(domainId: string): Promise<void>;
+}
+export declare class MailboxesClient {
+    private readonly client;
+    constructor(client: StackShift);
+    plans(): Promise<MailboxPricing>;
+    clientSettings(): Promise<MailboxClientSettings>;
+    usage(): Promise<MailboxUsage>;
+    create(input: MailboxCreateInput): Promise<Mailbox>;
+    list(options?: {
+        domainId?: string;
+    }): Promise<MailboxList<Mailbox>>;
+    get(mailboxId: string): Promise<Mailbox>;
+    update(mailboxId: string, input: MailboxUpdateInput): Promise<Mailbox>;
+    delete(mailboxId: string): Promise<void>;
+    suspend(mailboxId: string): Promise<Mailbox>;
+    resume(mailboxId: string): Promise<Mailbox>;
+    resendInvitation(mailboxId: string): Promise<Mailbox>;
+    resetPassword(mailboxId: string): Promise<MailboxPasswordReset>;
+    createProfileLink(mailboxId: string): Promise<MailboxProfileLink>;
+    listDevices(mailboxId: string): Promise<MailboxList<MailboxDevice>>;
+    revokeDevice(mailboxId: string, kind: MailboxDevice['kind'], deviceId: string): Promise<void>;
+    listMembers(mailboxId: string): Promise<MailboxList<MailboxMember>>;
+    addMember(mailboxId: string, userId: string): Promise<MailboxMember>;
+    removeMember(mailboxId: string, userId: string): Promise<void>;
+    listAppPasswords(mailboxId: string): Promise<MailboxList<MailboxAppPassword>>;
+    createAppPassword(mailboxId: string, label: string): Promise<MailboxAppPasswordCreated>;
+    revokeAppPassword(mailboxId: string, passwordId: string): Promise<void>;
+}
+export declare class MailboxAliasesClient {
+    private readonly client;
+    constructor(client: StackShift);
+    create(input: MailboxAliasCreateInput): Promise<MailboxAlias>;
+    list(options?: {
+        mailboxId?: string;
+    }): Promise<MailboxList<MailboxAlias>>;
+    update(aliasId: string, input: {
+        sendAs: boolean;
+    }): Promise<MailboxAlias>;
+    delete(aliasId: string): Promise<void>;
+}
+export declare class MailboxGroupsClient {
+    private readonly client;
+    constructor(client: StackShift);
+    create(input: MailboxGroupCreateInput): Promise<MailboxGroup>;
+    list(options?: {
+        domainId?: string;
+    }): Promise<MailboxList<MailboxGroup>>;
+    get(groupId: string): Promise<MailboxGroup>;
+    update(groupId: string, input: MailboxGroupUpdateInput): Promise<MailboxGroup>;
+    delete(groupId: string): Promise<void>;
+}
+export declare class MailboxRoutesClient {
+    private readonly client;
+    constructor(client: StackShift);
+    create(input: MailboxRouteCreateInput): Promise<MailboxRoute>;
+    list(options?: {
+        domainId?: string;
+    }): Promise<MailboxList<MailboxRoute>>;
+    get(routeId: string): Promise<MailboxRoute>;
+    update(routeId: string, input: MailboxRouteUpdateInput): Promise<MailboxRoute>;
+    delete(routeId: string): Promise<void>;
+    appHealth(domainId: string): Promise<{
+        issue: MailboxAppHealthIssue | null;
+    }>;
+    retryDeliveries(routeId: string): Promise<{
+        retried: number;
+    }>;
+}
+export declare class MailboxImportsClient {
+    private readonly client;
+    constructor(client: StackShift);
+    start(input: MailboxImportStartInput): Promise<MailboxImport>;
+    list(): Promise<MailboxList<MailboxImport>>;
+    get(importId: string): Promise<MailboxImport>;
+    cancel(importId: string): Promise<MailboxImport>;
+    skip(importId: string, mailboxId: string): Promise<MailboxImport>;
+    switch(importId: string, when: 'now' | 'tonight'): Promise<MailboxImport>;
+}
+export {};

package/dist/mail-mailboxes.js

@@ -0,0 +1,202 @@
+function path(...parts) {
+    return parts.map(encodeURIComponent).join('/');
+}
+function query(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined) {
+            search.append(key, value);
+        }
+    }
+    const suffix = search.toString();
+    return suffix ? `?${suffix}` : '';
+}
+export class MailboxDomainsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    create(domain) {
+        return this.client.mailRequest('/mail/mailbox-domains', { method: 'POST', body: { domain } });
+    }
+    list() {
+        return this.client.mailRequest('/mail/mailbox-domains');
+    }
+    get(domainId) {
+        return this.client.mailRequest(`/mail/mailbox-domains/${path(domainId)}`);
+    }
+    update(domainId, input) {
+        return this.client.mailRequest(`/mail/mailbox-domains/${path(domainId)}`, { method: 'PATCH', body: input });
+    }
+    verify(domainId) {
+        return this.client.mailRequest(`/mail/mailbox-domains/${path(domainId)}/verify`, { method: 'POST' });
+    }
+    applyDns(domainId) {
+        return this.client.mailRequest(`/mail/mailbox-domains/${path(domainId)}/dns/apply`, { method: 'POST' });
+    }
+    dnsApplications(domainId) {
+        return this.client.mailRequest(`/mail/mailbox-domains/${path(domainId)}/dns/applications`);
+    }
+    delete(domainId) {
+        return this.client.mailRequest(`/mail/mailbox-domains/${path(domainId)}`, { method: 'DELETE' });
+    }
+}
+export class MailboxesClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    plans() {
+        return this.client.mailRequest('/mail/mailbox-plans');
+    }
+    clientSettings() {
+        return this.client.mailRequest('/mail/mailbox-client-settings');
+    }
+    usage() {
+        return this.client.mailRequest('/mail/mailbox-usage');
+    }
+    create(input) {
+        return this.client.mailRequest('/mail/mailboxes', { method: 'POST', body: input });
+    }
+    list(options = {}) {
+        return this.client.mailRequest(`/mail/mailboxes${query({ domainId: options.domainId })}`);
+    }
+    get(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}`);
+    }
+    update(mailboxId, input) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}`, { method: 'PATCH', body: input });
+    }
+    delete(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}`, { method: 'DELETE' });
+    }
+    suspend(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/suspend`, { method: 'POST' });
+    }
+    resume(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/resume`, { method: 'POST' });
+    }
+    resendInvitation(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/invitation/resend`, { method: 'POST' });
+    }
+    resetPassword(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/password-reset`, { method: 'POST' });
+    }
+    createProfileLink(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/mobileconfig`, { method: 'POST' });
+    }
+    listDevices(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/devices`);
+    }
+    revokeDevice(mailboxId, kind, deviceId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/devices/${path(kind, deviceId)}`, { method: 'DELETE' });
+    }
+    listMembers(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/members`);
+    }
+    addMember(mailboxId, userId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/members`, { method: 'POST', body: { userId } });
+    }
+    removeMember(mailboxId, userId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/members/${path(userId)}`, { method: 'DELETE' });
+    }
+    listAppPasswords(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/app-passwords`);
+    }
+    createAppPassword(mailboxId, label) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/app-passwords`, { method: 'POST', body: { label } });
+    }
+    revokeAppPassword(mailboxId, passwordId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/app-passwords/${path(passwordId)}`, { method: 'DELETE' });
+    }
+}
+export class MailboxAliasesClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    create(input) {
+        return this.client.mailRequest('/mail/aliases', { method: 'POST', body: input });
+    }
+    list(options = {}) {
+        return this.client.mailRequest(`/mail/aliases${query({ mailboxId: options.mailboxId })}`);
+    }
+    update(aliasId, input) {
+        return this.client.mailRequest(`/mail/aliases/${path(aliasId)}`, { method: 'PATCH', body: input });
+    }
+    delete(aliasId) {
+        return this.client.mailRequest(`/mail/aliases/${path(aliasId)}`, { method: 'DELETE' });
+    }
+}
+export class MailboxGroupsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    create(input) {
+        return this.client.mailRequest('/mail/groups', { method: 'POST', body: input });
+    }
+    list(options = {}) {
+        return this.client.mailRequest(`/mail/groups${query({ domainId: options.domainId })}`);
+    }
+    get(groupId) {
+        return this.client.mailRequest(`/mail/groups/${path(groupId)}`);
+    }
+    update(groupId, input) {
+        return this.client.mailRequest(`/mail/groups/${path(groupId)}`, { method: 'PATCH', body: input });
+    }
+    delete(groupId) {
+        return this.client.mailRequest(`/mail/groups/${path(groupId)}`, { method: 'DELETE' });
+    }
+}
+export class MailboxRoutesClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    create(input) {
+        return this.client.mailRequest('/mail/routes', { method: 'POST', body: input });
+    }
+    list(options = {}) {
+        return this.client.mailRequest(`/mail/routes${query({ domainId: options.domainId })}`);
+    }
+    get(routeId) {
+        return this.client.mailRequest(`/mail/routes/${path(routeId)}`);
+    }
+    update(routeId, input) {
+        return this.client.mailRequest(`/mail/routes/${path(routeId)}`, { method: 'PATCH', body: input });
+    }
+    delete(routeId) {
+        return this.client.mailRequest(`/mail/routes/${path(routeId)}`, { method: 'DELETE' });
+    }
+    appHealth(domainId) {
+        return this.client.mailRequest(`/mail/routes/app-health${query({ domainId })}`);
+    }
+    retryDeliveries(routeId) {
+        return this.client.mailRequest(`/mail/routes/${path(routeId)}/retry-deliveries`, { method: 'POST' });
+    }
+}
+export class MailboxImportsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    start(input) {
+        return this.client.mailRequest('/mail/mailbox-imports', { method: 'POST', body: input });
+    }
+    list() {
+        return this.client.mailRequest('/mail/mailbox-imports');
+    }
+    get(importId) {
+        return this.client.mailRequest(`/mail/mailbox-imports/${path(importId)}`);
+    }
+    cancel(importId) {
+        return this.client.mailRequest(`/mail/mailbox-imports/${path(importId)}/cancel`, { method: 'POST' });
+    }
+    skip(importId, mailboxId) {
+        return this.client.mailRequest(`/mail/mailbox-imports/${path(importId)}/mailboxes/${path(mailboxId)}/skip`, { method: 'POST' });
+    }
+    switch(importId, when) {
+        return this.client.mailRequest(`/mail/mailbox-imports/${path(importId)}/switch`, { method: 'POST', body: { when } });
+    }
+}

package/dist/mail.d.ts

@@ -19,6 +19,8 @@ import { MailAudiencesClient, MailCampaignsClient } from './mail-campaigns.js';
 export { MailAudiencesClient, MailCampaignsClient } from './mail-campaigns.js';
 import { MailExportsClient } from './mail-exports.js';
 export { MailExportsClient } from './mail-exports.js';
+import { MailboxAliasesClient, MailboxDomainsClient, MailboxGroupsClient, MailboxImportsClient, MailboxRoutesClient, MailboxesClient } from './mail-mailboxes.js';
+export { MailboxAliasesClient, MailboxDomainsClient, MailboxGroupsClient, MailboxImportsClient, MailboxRoutesClient, MailboxesClient } from './mail-mailboxes.js';
 import type { MailTemplateDiagnosticInput, MailTemplateDiagnosticResult } from './mail-diagnostics.js';
 export declare class MailClient {
     private readonly client;
@@ -41,6 +43,12 @@ export declare class MailClient {
     readonly audiences: MailAudiencesClient;
     readonly campaigns: MailCampaignsClient;
     readonly exports: MailExportsClient;
+    readonly mailboxDomains: MailboxDomainsClient;
+    readonly mailboxes: MailboxesClient;
+    readonly aliases: MailboxAliasesClient;
+    readonly groups: MailboxGroupsClient;
+    readonly routes: MailboxRoutesClient;
+    readonly mailboxImports: MailboxImportsClient;
     readonly limits: MailLimitsClient;
     readonly reputation: MailReputationClient;
     readonly scheduled: MailScheduledClient;

package/dist/mail.js

@@ -13,6 +13,8 @@ import { MailAudiencesClient, MailCampaignsClient } from './mail-campaigns.js';
 export { MailAudiencesClient, MailCampaignsClient } from './mail-campaigns.js';
 import { MailExportsClient } from './mail-exports.js';
 export { MailExportsClient } from './mail-exports.js';
+import { MailboxAliasesClient, MailboxDomainsClient, MailboxGroupsClient, MailboxImportsClient, MailboxRoutesClient, MailboxesClient } from './mail-mailboxes.js';
+export { MailboxAliasesClient, MailboxDomainsClient, MailboxGroupsClient, MailboxImportsClient, MailboxRoutesClient, MailboxesClient } from './mail-mailboxes.js';
 export class MailClient {
     client;
     automations;
@@ -34,6 +36,12 @@ export class MailClient {
     audiences;
     campaigns;
     exports;
+    mailboxDomains;
+    mailboxes;
+    aliases;
+    groups;
+    routes;
+    mailboxImports;
     limits;
     reputation;
     scheduled;
@@ -61,6 +69,12 @@ export class MailClient {
         this.audiences = new MailAudiencesClient(client);
         this.campaigns = new MailCampaignsClient(client);
         this.exports = new MailExportsClient(client);
+        this.mailboxDomains = new MailboxDomainsClient(client);
+        this.mailboxes = new MailboxesClient(client);
+        this.aliases = new MailboxAliasesClient(client);
+        this.groups = new MailboxGroupsClient(client);
+        this.routes = new MailboxRoutesClient(client);
+        this.mailboxImports = new MailboxImportsClient(client);
         this.limits = new MailLimitsClient(client);
         this.reputation = new MailReputationClient(client);
         this.scheduled = new MailScheduledClient(client);

package/dist/support-action-manifest.d.ts

@@ -0,0 +1,3 @@
+import type { SupportActionDescriptor } from './support-action-types.js';
+/** Validate action declarations locally; server registration and destination checks remain authoritative. */
+export declare function validateSupportActionCatalog(version: string, actions: SupportActionDescriptor[]): void;

package/dist/support-action-manifest.js

@@ -0,0 +1,40 @@
+import { actionCheck } from './support-actions.js';
+const reserved = new Set(['customer', 'customer_id', 'external_customer_id', 'external_id', 'contact_id', 'workspace_id', 'environment_id', 'inbox_id', 'conversation_id', 'installation_id', 'tenant_id', 'user_id', 'organization_id', 'authorization', 'scope', 'identity', 'credentials', 'secret', 'token']);
+function endpoint(value) {
+    if (!value || value.length > 2048)
+        return false;
+    try {
+        const url = new URL(value);
+        return url.protocol === 'https:' && !!url.hostname && !url.username && !url.password && !url.search && !url.hash && !value.includes('?') && !value.includes('#');
+    }
+    catch {
+        return false;
+    }
+}
+function fields(schema, input) {
+    actionCheck(schema && typeof schema === 'object' && !Array.isArray(schema) && Object.keys(schema).length <= 32, 'invalid_catalog');
+    for (const [name, field] of Object.entries(schema)) {
+        actionCheck(/^[a-z][a-z0-9_]{0,63}$/.test(name) && (!input || (!reserved.has(name) && !/^(customer_|tenant_|auth_)/.test(name))), 'invalid_catalog');
+        actionCheck(field && typeof field.required === 'boolean' && Object.keys(field).every(k => ['type', 'required', 'max_length', 'minimum', 'maximum', 'enum'].includes(k)), 'invalid_catalog');
+        if (field.type === 'string')
+            actionCheck(Number.isInteger(field.max_length) && field.max_length >= 1 && field.max_length <= 16000 && field.minimum === undefined && field.maximum === undefined && (!field.enum || (Array.isArray(field.enum) && field.enum.length <= 64 && new Set(field.enum).size === field.enum.length && field.enum.every(v => typeof v === 'string' && [...v].length <= field.max_length))), 'invalid_catalog');
+        else if (field.type === 'number' || field.type === 'integer')
+            actionCheck(!field.max_length && !field.enum?.length && [field.minimum, field.maximum].every(n => n === undefined || (Number.isFinite(n) && (field.type !== 'integer' || Number.isSafeInteger(n)))) && (field.minimum === undefined || field.maximum === undefined || field.minimum <= field.maximum), 'invalid_catalog');
+        else
+            actionCheck(field.type === 'boolean' && !field.max_length && !field.enum?.length && field.minimum === undefined && field.maximum === undefined, 'invalid_catalog');
+    }
+}
+/** Validate action declarations locally; server registration and destination checks remain authoritative. */
+export function validateSupportActionCatalog(version, actions) {
+    actionCheck(typeof version === 'string' && version.length <= 32 && /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$/.test(version) && Array.isArray(actions) && actions.length >= 1 && actions.length <= 32, 'invalid_catalog');
+    const names = new Set();
+    for (const action of actions) {
+        actionCheck(/^[a-z][a-z0-9_.]{0,79}$/.test(action.name) && !names.has(action.name) && action.version === version && action.identity_required === true && ['read', 'bounded_write', 'customer_change', 'financial', 'security'].includes(action.risk) && typeof action.idempotency_supported === 'boolean' && typeof action.safe_retry === 'boolean' && Number.isInteger(action.timeout_seconds) && action.timeout_seconds >= 1 && action.timeout_seconds <= 30 && endpoint(action.endpoint), 'invalid_catalog');
+        actionCheck((action.risk === 'read' || (action.idempotency_supported && endpoint(action.reconciliation_endpoint) && !!action.verification_operation)) && (!action.safe_retry || action.idempotency_supported) && (!action.reconciliation_endpoint || endpoint(action.reconciliation_endpoint)), 'invalid_catalog');
+        fields(action.input, true);
+        fields(action.output, false);
+        names.add(action.name);
+    }
+    for (const action of actions)
+        actionCheck(!action.verification_operation || actions.some(a => a.name === action.verification_operation && a.risk === 'read'), 'invalid_catalog');
+}

package/dist/support-action-receiver.d.ts

@@ -0,0 +1,20 @@
+import type { SupportActionReceipt, SupportActionRequest, SupportActionVerification } from './support-action-types.js';
+export interface SupportActionClaim {
+    state: 'acquired' | 'completed' | 'running' | 'unknown' | 'conflict';
+    fence?: string;
+    response?: Uint8Array;
+}
+export interface SupportActionDurableStore {
+    claim(namespace: 'delivery' | 'execution', key: string, digest: string): Promise<SupportActionClaim>;
+    complete(namespace: 'delivery' | 'execution', key: string, fence: string, response: Uint8Array, unknown?: boolean): Promise<void>;
+}
+export type SupportActionHandler = (request: SupportActionRequest) => Promise<Pick<SupportActionReceipt, 'state' | 'result' | 'error_code'>>;
+export declare function receiveSupportAction(raw: Uint8Array, headers: Record<string, string>, options: {
+    verification: SupportActionVerification;
+    store: SupportActionDurableStore;
+    execute: SupportActionHandler;
+    reconcile: SupportActionHandler;
+}): Promise<{
+    body: Uint8Array<ArrayBufferLike>;
+    headers: Record<string, string>;
+}>;