@adukilabs/sdk 0.1.1 → 0.1.2

package/dist/api/tenant.d.ts

@@ -0,0 +1,319 @@
+import type { Api } from './api.js';
+import type * as model from './model.js';
+import type { Page, PageQuery } from './model.js';
+/** The workspace: profile, members, audits, usage and the mail admin routes. */
+export declare class Tenant {
+    #private;
+    readonly members: TenantMembers;
+    readonly audits: TenantAudits;
+    readonly usage: TenantUsage;
+    readonly domains: TenantDomains;
+    readonly aliases: TenantAliases;
+    readonly quotas: TenantQuotas;
+    readonly rules: TenantRules;
+    readonly webhooks: TenantWebhooks;
+    readonly holidays: TenantHolidays;
+    readonly schedule: TenantSchedule;
+    constructor(api: Api);
+    /** `GET /v1/tenant`: the workspace's profile (scope `tenants:read`). */
+    get(): Promise<model.TenantProfile>;
+    /** `GET /v1/tenant/view/slug/{slug}` (`tenants:read`; another workspace's slug is `403`). */
+    bySlug(slug: string): Promise<model.TenantProfile>;
+    /** `GET /v1/tenant/security`: MTA-STS, TLSA, BIMI and the DMARC/TLS reports (`security:read`). */
+    security(): Promise<model.SecurityStatus>;
+    /** `GET /v1/tenant/mail/services`: the mail services and whether this workspace may use each (`mailservices:read`). */
+    services(): Promise<{
+        services: model.MailService[];
+    }>;
+}
+/**
+ * The members as Aduki Mail sees them. Listing all needs `tenants:read`, the
+ * filtered lists `members:read`; removing `tenants:write`. Inviting, roles
+ * and closing an account are Aduki ID's and need a signed-in person.
+ */
+export declare class TenantMembers {
+    #private;
+    constructor(api: Api);
+    /** `GET /v1/tenant/members`, `.../active` or `.../owners`. */
+    list(query?: PageQuery & {
+        state?: 'active' | 'owners';
+    }): Promise<Page<model.MemberRow>>;
+    /** `GET /v1/tenant/members/search/{q}`. */
+    search(text: string, query?: PageQuery): Promise<Page<model.MemberRow>>;
+    /** `DELETE /v1/tenant/members/{user}`: removes the member's mail account from the workspace (`404` for a non-member). */
+    remove(user: string): Promise<void>;
+}
+/** The workspace's audit trail (`audits:read`; one record by hex: `tenants:read`). */
+export declare class TenantAudits {
+    #private;
+    constructor(api: Api);
+    /**
+     * `GET /v1/tenant/audits[/user/{user}][/action/{action} | /failed |
+     * /successful | /ip/{ip}]`: one filter besides `user` at a time (the
+     * server has no route for two).
+     */
+    list(query?: PageQuery & {
+        user?: string;
+        action?: string;
+        outcome?: 'failed' | 'successful';
+        ip?: string;
+    }): Promise<Page<model.AuditRow>>;
+    /** `GET /v1/tenant/view/audit/{hex}`: one record with its `meta` (`tenants:read`). */
+    get(hex: string): Promise<model.AuditDetail>;
+}
+/** Metered usage (`usage:read`). */
+export declare class TenantUsage {
+    #private;
+    constructor(api: Api);
+    /** `GET /v1/tenant/usage`. */
+    list(query?: PageQuery): Promise<Page<model.UsageRow>>;
+    /** `GET /v1/tenant/usage/summary`: one row per metric, no paging. */
+    summary(): Promise<model.UsageRow[]>;
+    /** `GET /v1/tenant/usage/metric/{metric}`. */
+    metric(metric: string, query?: PageQuery): Promise<Page<model.UsageRow>>;
+}
+/**
+ * Mail domains: `domains:read`, `domains:write` to change. The DNS records
+ * to publish are on the domain (`dkim`, and `pending` of a DKIM rotation).
+ */
+export declare class TenantDomains {
+    #private;
+    readonly dkim: TenantDkim;
+    constructor(api: Api);
+    /** `POST /v1/tenant/domains`: registers a domain (status `pending`); returns its hex. */
+    add(input: model.DomainCreate): Promise<string>;
+    /** `GET /v1/tenant/domains`, `.../active` or `.../pending`. */
+    list(query?: PageQuery & {
+        state?: 'active' | 'pending';
+    }): Promise<Page<model.DomainRow>>;
+    /** `GET /v1/tenant/domains/{hex}`: the full record with its DNS snapshots. */
+    get(hex: string): Promise<model.Domain>;
+    /** `GET /v1/tenant/domains/lookup/name?name=`: a domain by name (`404` when none). */
+    byName(name: string): Promise<model.Domain>;
+    /** `PATCH /v1/tenant/domains/{hex}/name`. */
+    rename(hex: string, name: string): Promise<void>;
+    /** `PATCH /v1/tenant/domains/{hex}/kind`: `primary`, `sending`, `receiving` or `alias`. */
+    kind(hex: string, kind: string): Promise<void>;
+    /** `PATCH /v1/tenant/domains/{hex}/selector`: the DKIM selector, before the domain has a key (`409` after). */
+    selector(hex: string, selector: string): Promise<void>;
+    /** `PATCH /v1/tenant/domains/{hex}/auth`: the SPF, DMARC, MTA-STS and BIMI settings, all four. */
+    auth(hex: string, input: {
+        spf: unknown;
+        dmarc: unknown;
+        mta_sts: unknown;
+        bimi: unknown;
+    }): Promise<void>;
+    /** `PATCH /v1/tenant/domains/{hex}/meta`. */
+    meta(hex: string, meta: Record<string, unknown>): Promise<void>;
+    /** `DELETE /v1/tenant/domains/{hex}`. */
+    delete(hex: string): Promise<void>;
+}
+/**
+ * DKIM key rotation without a gap: stage a key the server makes, publish its
+ * TXT record, check, confirm. No private key is sent or returned.
+ */
+export declare class TenantDkim {
+    #private;
+    constructor(api: Api);
+    /** `GET /v1/tenant/domains/{hex}/dkim/rotation`: the active, staged and retired records (`domains:read`). */
+    state(hex: string): Promise<model.DkimRotation>;
+    /** `POST .../dkim/rotation`: stages the next key (a retry returns the same one); publish `pending.value` at `pending.name`. */
+    stage(hex: string, input?: {
+        selector?: string;
+    }): Promise<model.DkimRotation>;
+    /** `POST .../dkim/rotation/check`: whether DNS carries the staged record; changes nothing (`domains:read`). */
+    check(hex: string): Promise<{
+        ready: boolean;
+        reason?: string;
+        pending?: unknown;
+        [field: string]: unknown;
+    }>;
+    /** `POST .../dkim/rotation/confirm`: switches signing to the staged key (`409` while DNS does not carry it). */
+    confirm(hex: string): Promise<model.DkimRotation>;
+    /** `DELETE .../dkim/rotation`: drops the staged key (`404` when none). */
+    cancel(hex: string): Promise<void>;
+}
+/** Members' extra addresses on the workspace's verified domains: `aliases:read`, `aliases:write`. */
+export declare class TenantAliases {
+    #private;
+    constructor(api: Api);
+    /** `POST /v1/tenant/aliases`: `created` is false when the member already had it. */
+    add(user: string, address: string): Promise<model.Alias & {
+        created: boolean;
+    }>;
+    /** `GET /v1/tenant/aliases[?user=]`: at most 1000, by address. */
+    list(query?: {
+        user?: string;
+    }): Promise<{
+        items: model.Alias[];
+    }>;
+    /** `DELETE /v1/tenant/aliases/{address}`. */
+    remove(address: string): Promise<void>;
+}
+/** The workspace's own usage ceilings per metric: `quotas:read`, `quotas:write`. */
+export declare class TenantQuotas {
+    #private;
+    constructor(api: Api);
+    /** `POST /v1/tenant/quotas`. */
+    add(input: {
+        metric: string;
+        ceiling: number;
+        reason?: string;
+        expires?: string;
+    }): Promise<model.Quota>;
+    /** `GET /v1/tenant/quotas`. */
+    list(query?: PageQuery): Promise<Page<model.QuotaRow>>;
+    /** `GET /v1/tenant/quotas/{metric}`. */
+    get(metric: string): Promise<model.Quota>;
+    /** `PATCH /v1/tenant/quotas/{metric}/ceiling`, `/expires`, `/reason`: the fields given, one call each. */
+    edit(metric: string, change: {
+        ceiling?: number;
+        expires?: string;
+        reason?: string;
+    }): Promise<void>;
+    /** `DELETE /v1/tenant/quotas/{metric}`. */
+    delete(metric: string): Promise<void>;
+}
+/** Spam rules of the workspace: `rules:read`, `rules:write`. */
+export declare class TenantRules {
+    #private;
+    constructor(api: Api);
+    /** `POST /v1/tenant/rules`. */
+    add(input: model.RuleCreate): Promise<model.Rule>;
+    /** `GET /v1/tenant/rules`, `.../active`, or `.../target/{target}`. */
+    list(query?: PageQuery & {
+        active?: boolean;
+        target?: string;
+    }): Promise<Page<model.RuleRow>>;
+    /** `GET /v1/tenant/rules/{hex}/detail`: the rule with its `meta`. */
+    get(hex: string): Promise<model.Rule>;
+    /** `GET /v1/tenant/rules/name/{name}`. */
+    byName(name: string): Promise<model.Rule>;
+    /**
+     * `PATCH /v1/tenant/rules/{hex}/{field}` for each field given (`regex` is
+     * sent after `pattern`, so a new pattern and `regex: true` go together).
+     */
+    edit(hex: string, change: {
+        name?: string;
+        target?: string;
+        pattern?: string;
+        regex?: boolean;
+        score?: number;
+        active?: boolean;
+    }): Promise<void>;
+    /** `DELETE /v1/tenant/rules/{hex}`. */
+    delete(hex: string): Promise<void>;
+}
+/** Delivery-event webhooks: `webhooks:read`, `webhooks:write`. */
+export declare class TenantWebhooks {
+    #private;
+    constructor(api: Api);
+    /** `POST /v1/tenant/webhooks`: returns the hex and the signing secret, shown this once. */
+    add(input: model.WebhookCreate): Promise<{
+        hex: string;
+        secret: string;
+    }>;
+    /** `GET /v1/tenant/webhooks`, `.../active`, or `.../subscribers/{event}`. */
+    list(query?: PageQuery & {
+        active?: boolean;
+        event?: string;
+    }): Promise<Page<model.WebhookRow>>;
+    /** `GET /v1/tenant/webhooks/{hex}`: the record, never the secret. */
+    get(hex: string): Promise<model.Webhook>;
+    /** `PATCH /v1/tenant/webhooks/{hex}/{field}` for each field given (`url` is checked again: `https`, a public host). */
+    edit(hex: string, change: {
+        url?: string;
+        events?: string[];
+        domains?: string[];
+        active?: boolean;
+        secret?: string;
+    }): Promise<void>;
+    /** `POST /v1/tenant/webhooks/{hex}/secret/rotate`: a new secret made by the server, returned once. */
+    rotate(hex: string): Promise<string>;
+    /** `DELETE /v1/tenant/webhooks/{hex}`. */
+    delete(hex: string): Promise<void>;
+}
+/** The workspace's holidays and closures: reading `tenant:read`, writing `tenants:write`. */
+export declare class TenantHolidays {
+    #private;
+    constructor(api: Api);
+    /** `GET /v1/tenant/holidays?region&year`: the effective days (`region` defaults to the workspace's). */
+    list(query?: {
+        region?: string;
+        year?: number;
+    }): Promise<model.Holiday[]>;
+    /**
+     * `POST /v1/tenant/holidays`: a day or range of the workspace's own
+     * (`kind` `closure` by default, or `observance`), or `{exclude: true,
+     * region, date}` to drop the platform's day on that date.
+     */
+    add(input: {
+        date: string;
+        until?: string;
+        name: string;
+        kind?: 'closure' | 'observance';
+        region?: string;
+    } | {
+        exclude: true;
+        region: string;
+        date: string;
+    }): Promise<model.Holiday>;
+    /** `DELETE /v1/tenant/holidays/{hex}`: one of the workspace's own rows. */
+    remove(hex: string): Promise<void>;
+    /** `GET /v1/tenant/holidays/region`: the default region, or null. */
+    region(): Promise<{
+        region: string;
+        subdivision?: string | null;
+        updated: string;
+    } | null>;
+    /** `PUT /v1/tenant/holidays/region` (`422` for a region with no data); `null` clears it (`DELETE`). */
+    setRegion(region: {
+        region: string;
+        subdivision?: string;
+    } | null): Promise<void>;
+}
+/** Scheduling templates and resources: reading `tenant:read`, writing `tenants:write`. */
+export declare class TenantSchedule {
+    #private;
+    constructor(api: Api);
+    /** `GET /v1/tenant/schedule/templates`. */
+    templates(): Promise<model.ScheduleTemplate[]>;
+    /** `GET /v1/tenant/schedule/templates/{hex}`. */
+    template(hex: string): Promise<model.ScheduleTemplate>;
+    /** `POST /v1/tenant/schedule/templates` (rules default to weekdays 09:00-17:00, zone to UTC). */
+    addTemplate(input: {
+        name: string;
+        zone?: string;
+        rules?: unknown[];
+    }): Promise<model.ScheduleTemplate>;
+    /** `PATCH /v1/tenant/schedule/templates/{hex}`: name and zone. */
+    editTemplate(hex: string, change: {
+        name?: string;
+        zone?: string;
+    }): Promise<model.ScheduleTemplate>;
+    /** `PUT /v1/tenant/schedule/templates/{hex}/rules`: replaces the weekly rules. */
+    setRules(hex: string, rules: unknown[]): Promise<model.ScheduleTemplate>;
+    /** `DELETE /v1/tenant/schedule/templates/{hex}` (`409` while followed or used). */
+    deleteTemplate(hex: string): Promise<void>;
+    /** `GET /v1/tenant/schedule/resources`: rooms and equipment, live ones first. */
+    resources(): Promise<model.ScheduleResource[]>;
+    /** `GET /v1/tenant/schedule/resources/{hex}`. */
+    resource(hex: string): Promise<model.ScheduleResource>;
+    /** `POST /v1/tenant/schedule/resources` (`409` for a name in use). */
+    addResource(input: {
+        name: string;
+        kind: 'room' | 'equipment';
+        capacity?: number;
+        schedule?: string;
+    }): Promise<model.ScheduleResource>;
+    /** `PATCH /v1/tenant/schedule/resources/{hex}`: `null` clears `capacity` and `schedule`; `retired` stops offering it. */
+    editResource(hex: string, change: {
+        name?: string;
+        kind?: 'room' | 'equipment';
+        capacity?: number | null;
+        schedule?: string | null;
+        retired?: boolean;
+    }): Promise<model.ScheduleResource>;
+    /** `DELETE /v1/tenant/schedule/resources/{hex}` (`409` once booked: retire it instead). */
+    deleteResource(hex: string): Promise<void>;
+}