@lifesi/genesis 0.0.0-stage → 0.1.1

package/dist/client.js

@@ -0,0 +1,179 @@
+import { operationTable, services } from './generated/operations.js';
+import { GenesisError } from './errors.js';
+import { validateHivesInvocation, hivesFunctionResponseHeaders, hivesFunctionMetadata } from './hives-functions.js';
+export const DEFAULT_BASE_URL = 'https://console.life.one/api';
+const env = globalThis.process?.env ?? {};
+export class GenesisClient {
+    baseUrl;
+    routing;
+    opts;
+    fetchImpl;
+    constructor(opts = {}) {
+        this.opts = opts;
+        this.baseUrl = (opts.baseUrl ?? env.GENESIS_BASE_URL ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.routing = opts.routing ?? (env.GENESIS_ROUTING === 'direct' ? 'direct' : 'gateway');
+        const f = opts.fetch ?? globalThis.fetch;
+        if (!f)
+            throw new Error('No fetch available; pass options.fetch');
+        this.fetchImpl = f.bind(globalThis);
+    }
+    static operations = operationTable;
+    static services = services;
+    /** Resolve the credential: explicit apiKey > token > env GENESIS_API_KEY > GENESIS_TOKEN > provider. */
+    async credential() {
+        return this.opts.apiKey ?? this.opts.token ?? env.GENESIS_API_KEY ?? env.GENESIS_TOKEN ?? (await this.opts.credentials?.());
+    }
+    /** Build the URL for an operation (exposed for tests and `--dry-run`). */
+    url(operationId, input = {}) {
+        const op = operationTable[operationId];
+        if (!op)
+            throw new Error(`Unknown Genesis operation: ${operationId}`);
+        const fill = (tpl) => tpl.replace(/\{([^}]+)\}/g, (_, k) => {
+            const v = input[k];
+            if (v === undefined || v === null || v === '')
+                throw new GenesisError({ status: 0, type: 'invalid_request', message: `Missing required path parameter "${k}" for ${operationId}`, operationId });
+            return encodeURIComponent(String(v));
+        });
+        let base;
+        let p;
+        if (this.routing === 'direct') {
+            base = (this.opts.upstreams?.[op.service] ?? op.upstream.base).replace(/\/+$/, '');
+            p = fill(op.upstream.path);
+        }
+        else {
+            base = this.baseUrl;
+            p = fill(op.path);
+        }
+        const qs = new URLSearchParams();
+        for (const q of op.queryParams) {
+            const v = input[q];
+            if (v === undefined || v === null)
+                continue;
+            if (Array.isArray(v))
+                v.forEach((x) => qs.append(q, String(x)));
+            else
+                qs.set(q, String(v));
+        }
+        const s = qs.toString();
+        return `${base}${p}${s ? `?${s}` : ''}`;
+    }
+    /** Call any Genesis operation by id, fully typed from the merged spec. */
+    async request(operationId, input, init = {}) {
+        const res = await this.raw(operationId, (input ?? {}), init);
+        if (operationTable[operationId].rawResponse)
+            return res;
+        if (res.status === 204)
+            return undefined;
+        const ct = res.headers.get('content-type') ?? '';
+        let value;
+        try {
+            value = ct.includes('json') ? await res.json() : await res.text();
+        }
+        catch (error) {
+            if (String(operationId).startsWith('hives_') && /_functions?$/.test(operationId))
+                throw new Error('Hives returned invalid function metadata.');
+            throw error;
+        }
+        if (operationId === 'hives_list_functions') {
+            if (!value || !Array.isArray(value.data) || !value.pagination)
+                throw new Error('Hives returned invalid function list metadata.');
+            const pagination = Object.fromEntries(['page', 'per_page', 'total', 'total_pages', 'has_next', 'has_prev'].map((key) => [key, value.pagination[key]]));
+            return { data: value.data.map((row) => hivesFunctionMetadata(row, input?.project_id)), pagination };
+        }
+        if (['hives_get_function', 'hives_create_function', 'hives_update_function'].includes(operationId)) {
+            return hivesFunctionMetadata(value, input?.project_id);
+        }
+        return value;
+    }
+    /** Raw Response. Completed Hives guest responses retain their actual status, including non-2xx. */
+    async raw(operationId, input = {}, init = {}) {
+        const op = operationTable[operationId];
+        if (op.rawResponse && op.service === 'hives')
+            validateHivesInvocation(input.body);
+        const url = this.url(operationId, input);
+        const headers = {
+            accept: 'application/json',
+            'user-agent': this.opts.userAgent ?? '@lifesi/genesis/0.1.0',
+            ...this.opts.headers, ...init.headers,
+        };
+        if (!op.public) {
+            const cred = await this.credential();
+            // Direct mode: let the upstream decide (some, like Foundry's model list, are public).
+            if (!cred && this.routing !== 'direct')
+                throw new GenesisError({ status: 401, type: 'unauthorized', message: 'No Genesis credential. Run `genesis login`, or set GENESIS_API_KEY.', operationId });
+            if (cred)
+                headers.authorization = `Bearer ${cred}`;
+        }
+        let body;
+        if (op.hasBody && input.body !== undefined) {
+            // Fetch owns multipart boundary generation. Never serialize a File/Blob as JSON.
+            for (const key of Object.keys(headers))
+                if (key.toLowerCase() === 'content-type')
+                    delete headers[key];
+            if (op.requestContentType === 'multipart/form-data') {
+                if (!(input.body instanceof FormData))
+                    throw new GenesisError({ status: 0, type: 'invalid_request', operationId,
+                        message: 'This operation requires a FormData body containing a real binary file.' });
+                body = input.body;
+            }
+            else {
+                if (input.body instanceof FormData || input.body instanceof Blob || input.body instanceof ArrayBuffer || ArrayBuffer.isView(input.body)) {
+                    throw new GenesisError({ status: 0, type: 'invalid_request', operationId, message: 'This operation requires a JSON body.' });
+                }
+                headers['content-type'] = 'application/json';
+                body = JSON.stringify(input.body);
+            }
+        }
+        const secretOperation = op.service === 'hives' && /_secrets?$/.test(operationId);
+        const functionOperation = op.service === 'hives' && (op.rawResponse || /_function(?:s|_async)?$/.test(operationId));
+        let res;
+        try {
+            res = await this.fetchImpl(url, { method: op.method, headers, body, signal: init.signal,
+                ...(op.service === 'hives' ? { cache: 'no-store', redirect: op.rawResponse ? 'manual' : 'error' } : {}) });
+        }
+        catch (error) {
+            if (functionOperation)
+                throw new GenesisError({ status: 0, type: 'transport_error', operationId,
+                    message: 'Hives function transport failed. No redirects are followed; check the service address and retry.' });
+            if (!secretOperation)
+                throw error;
+            throw new GenesisError({ status: 0, type: 'transport_error', operationId,
+                message: 'Hives secret transport failed. Redirects are refused; check the service address and retry.' });
+        }
+        if (op.rawResponse && /^exec_[a-f0-9]{32}$/.test(res.headers.get('x-execution-id') ?? '')) {
+            return new Response(res.body, { status: res.status, statusText: res.statusText, headers: hivesFunctionResponseHeaders(res.headers) });
+        }
+        if (op.rawResponse && res.ok)
+            throw new GenesisError({ status: res.status, type: 'invalid_response', operationId,
+                message: 'Hives did not confirm a completed guest execution. Refresh the resource and retry.' });
+        if (functionOperation && !res.ok) {
+            const message = res.status === 401 ? 'Genesis credential rejected. Sign in again.'
+                : res.status === 403 ? 'Missing the authorized Hives scope for this function action.'
+                    : res.status === 404 ? 'Function/deployment, project or artifact not found in the authenticated organization and project.'
+                        : res.status === 409 ? 'Function mutation conflicted. Refresh its metadata before retrying.'
+                            : res.status === 400 || res.status === 422 ? 'Invalid function request. Check artifact, resource bounds and guest request syntax.'
+                                : res.status === 413 ? 'Function request exceeds a body or serialized guest envelope limit.'
+                                    : res.status >= 300 && res.status < 400 ? 'Unexpected function service redirect. No redirect was followed.'
+                                        : `Hives function operation failed (${res.status}). Refresh and retry.`;
+            throw new GenesisError({ status: res.status, type: `http_${res.status}`, operationId, message,
+                requestId: res.headers.get('x-request-id') ?? undefined });
+        }
+        if (!res.ok && secretOperation) {
+            const message = res.status === 401 ? 'Genesis credential rejected. Sign in again.'
+                : res.status === 403 ? 'Missing the authorized Hives scope for this action (hives:read or hives:write).'
+                    : res.status === 404 ? 'Secret or project not found in your authenticated organization.'
+                        : res.status === 409 ? 'A secret with this name already exists. Update it instead.'
+                            : res.status === 400 || res.status === 422 ? 'Invalid secret request. Check names and UTF-8 value size.'
+                                : res.status === 413 ? 'Secret request too large. Use a smaller batch.'
+                                    : res.status === 429 ? 'Too many requests. Wait briefly before retrying.'
+                                        : res.status === 503 ? 'Hives customer encryption is unavailable or stored secrets require protected migration.'
+                                            : `Hives secret operation failed (${res.status}). Refresh metadata and retry.`;
+            // Validation/provider bodies may reflect submitted plaintext. Never retain or log them.
+            throw new GenesisError({ status: res.status, type: `http_${res.status}`, message, operationId,
+                requestId: res.headers.get('x-request-id') ?? undefined });
+        }
+        if (!res.ok)
+            throw await GenesisError.fromResponse(res, operationId);
+        return res;
+    }
+}

package/dist/dials.d.ts

@@ -0,0 +1,129 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput } from './types.js';
+import type { components } from './generated/schema.js';
+export type DialsScope = components['schemas']['Dials.Scope'];
+export type DialsCallControl = components['schemas']['Dials.CallControl'];
+/** The public call contract requires customer-selected behavior for every caller. */
+export type DialsOutboundCall = components['schemas']['Dials.OutboundCall'];
+export type DialsEmergencyAddress = components['schemas']['Dials.RegisterEmergencyAddress'];
+/** Scope is selection only; the Dials backend verifies its org against signed identity. */
+export declare function dialsModule(client: GenesisClient): {
+    overview: {
+        summary: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            scope: components["schemas"]["Dials.Scope"];
+            calls: {
+                total: number;
+                queued: number;
+                active: number;
+                completed: number;
+                failed: number;
+            };
+            dispatch: {
+                total: number;
+                pending: number;
+                claimed: number;
+                dispatched: number;
+                failed: number;
+            };
+            people: {
+                deployed: number;
+            };
+            agents: {
+                deployed: number;
+            };
+            routes: {
+                deployed: number;
+            };
+            numbers: {
+                deployed: number;
+            };
+            voice: {
+                deployed: number;
+            };
+            messages: {
+                total: number;
+                queued: number;
+                delivered: number;
+                failed: number;
+            };
+            usage: {
+                total: number;
+                quantity: number;
+                lastMetric: string | null;
+                lastResourceId: string | null;
+            };
+        }>;
+        operatingSurface: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            scope: components["schemas"]["Dials.Scope"];
+            summary: components["schemas"]["Dials.ConsoleSummary"];
+            surfaces: components["schemas"]["Dials.OperatingSurfaceCard"][];
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+    numbers: {
+        reconciliations: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            reconciliations: components["schemas"]["Dials.InventoryReconciliation"][];
+        }>;
+        drift: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            drift: components["schemas"]["Dials.InventoryDrift"][];
+        }>;
+        updateCallerName: (body: OperationInput<"dials_updateNumberCallerName">["body"]) => Promise<{
+            ok: boolean;
+            number: components["schemas"]["Dials.Number"];
+            auditId: string;
+            next: string;
+        }>;
+        reconcile: (body: OperationInput<"dials_reconcileNumberInventory">["body"]) => Promise<{
+            ok: boolean;
+            reconciliations: components["schemas"]["Dials.InventoryReconciliation"][];
+            drift: components["schemas"]["Dials.InventoryDrift"][];
+            orphanCount: number;
+            auditId: string;
+            next: string;
+        }>;
+        list: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            numbers: components["schemas"]["Dials.Number"][];
+        }>;
+        search: (scope: DialsScope, query?: Omit<OperationInput<"dials_searchNumbers">, keyof DialsScope>) => Promise<{
+            ok: boolean;
+            numbers: components["schemas"]["Dials.AvailableNumber"][];
+        }>;
+        provision: (body: OperationInput<"dials_provisionNumber">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        assign: (body: OperationInput<"dials_assignNumber">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        release: (body: OperationInput<"dials_releaseNumber">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        registerEmergencyAddress: (body: DialsEmergencyAddress) => Promise<{
+            ok: boolean;
+            number: components["schemas"]["Dials.Number"];
+            address: components["schemas"]["Dials.EmergencyAddress"];
+            auditId: string;
+            next: string;
+        }>;
+    };
+    calls: {
+        list: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            calls: components["schemas"]["Dials.Call"][];
+        }>;
+        validate: (body: DialsOutboundCall) => Promise<{
+            [key: string]: unknown;
+        }>;
+        create: (body: DialsOutboundCall) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+};
+export type DialsEmergencyAddressFeedback = components['schemas']['Dials.EmergencyAddressFeedback'];
+/** Read bounded, typed advisory feedback from the existing Genesis error. Never auto-apply it. */
+export declare function dialsEmergencyAddressFeedback(error: unknown): DialsEmergencyAddressFeedback | undefined;

package/dist/dials.js

@@ -0,0 +1,59 @@
+import { GenesisError } from './errors.js';
+/** Scope is selection only; the Dials backend verifies its org against signed identity. */
+export function dialsModule(client) {
+    return {
+        overview: {
+            summary: (scope) => client.request('dials_getConsoleSummary', scope),
+            operatingSurface: (scope) => client.request('dials_getOperatingSurface', scope),
+        },
+        numbers: {
+            reconciliations: (scope) => client.request('dials_listNumberReconciliations', scope),
+            drift: (scope) => client.request('dials_listNumberDrift', scope),
+            updateCallerName: (body) => client.request('dials_updateNumberCallerName', { body }),
+            reconcile: (body) => client.request('dials_reconcileNumberInventory', { body }),
+            list: (scope) => client.request('dials_listNumbers', scope),
+            search: (scope, query = {}) => client.request('dials_searchNumbers', { ...query, ...scope }),
+            provision: (body) => client.request('dials_provisionNumber', { body }),
+            assign: (body) => client.request('dials_assignNumber', { body }),
+            release: (body) => client.request('dials_releaseNumber', { body }),
+            registerEmergencyAddress: (body) => client.request('dials_registerEmergencyAddress', { body }),
+        },
+        calls: {
+            list: (scope) => client.request('dials_listCalls', scope),
+            validate: (body) => client.request('dials_validateOutboundCall', { body }),
+            create: (body) => client.request('dials_createOutboundCall', { body }),
+        },
+    };
+}
+const fields = { streetNumber: 'Review the street number.', streetName: 'Review the street name.', addressLine2: 'Review the suite or unit type and number.', city: 'Review the city.', region: 'Review the state.', postalCode: 'Review the postal code.', country: 'Review the country.', address: 'The carrier could not validate this address. Review the address and any suggestions.' };
+const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const addressText = (value, max) => typeof value === 'string' && value.length > 0 && value.length <= max && /^[\p{L}\p{N} .,'#/-]+$/u.test(value) && !/(bearer|basic |sk_|api_key|authorization|secret|token=)/i.test(value);
+/** Read bounded, typed advisory feedback from the existing Genesis error. Never auto-apply it. */
+export function dialsEmergencyAddressFeedback(error) {
+    if (!(error instanceof GenesisError) || error.status !== 422 || error.operationId !== 'dials_registerEmergencyAddress')
+        return;
+    const body = error.body;
+    if (!object(body) || body.error !== 'carrier_rejected' || body.automaticCorrection !== false || !Array.isArray(body.fieldErrors) || !body.fieldErrors.length || body.fieldErrors.length > 8 || !Array.isArray(body.candidates) || body.candidates.length > 5)
+        return;
+    const fieldErrors = [];
+    for (const value of body.fieldErrors) {
+        if (!object(value) || typeof value.field !== 'string' || !Object.hasOwn(fields, value.field) || !['required', 'invalid', 'not_found', 'ambiguous', 'not_validated'].includes(String(value.code)))
+            return;
+        const field = value.field;
+        fieldErrors.push({ field, code: value.code, message: fields[field] });
+    }
+    const candidates = [];
+    for (const value of body.candidates) {
+        if (!object(value) || !addressText(value.streetNumber, 32) || !addressText(value.streetName, 128) || !addressText(value.city, 80) || typeof value.region !== 'string' || !/^[A-Za-z]{2}$/.test(value.region) || typeof value.postalCode !== 'string' || !/^\d{5}(?:-\d{4})?$/.test(value.postalCode))
+            return;
+        const extra = {};
+        if (value.addressType !== undefined || value.addressNumber !== undefined) {
+            if (!['Apartment', 'Basement', 'Building', 'Department', 'Floor', 'Office', 'Penthouse', 'Suite', 'Trailer', 'Unit'].includes(String(value.addressType)) || !addressText(value.addressNumber, 32))
+                return;
+            extra.addressType = value.addressType;
+            extra.addressNumber = value.addressNumber;
+        }
+        candidates.push({ streetNumber: value.streetNumber, streetName: value.streetName, city: value.city, region: value.region, postalCode: value.postalCode, ...extra });
+    }
+    return { automaticCorrection: false, fieldErrors, candidates };
+}

package/dist/errors.d.ts

@@ -0,0 +1,19 @@
+/** Normalized error for every Genesis service (gateway `{error:{type,message}}`, IAM `{error,error_description}`, Relays `{error}`, Foundry/OpenAI shape). */
+export declare class GenesisError extends Error {
+    readonly status: number;
+    readonly type: string;
+    readonly code?: string;
+    readonly requestId?: string;
+    readonly operationId?: string;
+    readonly body: unknown;
+    constructor(init: {
+        status: number;
+        type: string;
+        message: string;
+        code?: string;
+        requestId?: string;
+        operationId?: string;
+        body?: unknown;
+    });
+    static fromResponse(res: Response, operationId?: string): Promise<GenesisError>;
+}

package/dist/errors.js

@@ -0,0 +1,35 @@
+/** Normalized error for every Genesis service (gateway `{error:{type,message}}`, IAM `{error,error_description}`, Relays `{error}`, Foundry/OpenAI shape). */
+export class GenesisError extends Error {
+    status;
+    type;
+    code;
+    requestId;
+    operationId;
+    body;
+    constructor(init) {
+        super(init.message);
+        this.name = 'GenesisError';
+        Object.assign(this, init);
+        this.status = init.status;
+        this.type = init.type;
+        this.body = init.body;
+    }
+    static async fromResponse(res, operationId) {
+        const text = await res.text().catch(() => '');
+        let body = text;
+        try {
+            body = text ? JSON.parse(text) : undefined;
+        }
+        catch { /* keep text */ }
+        const e = body?.error;
+        const type = typeof e === 'object' && e ? (e.type ?? e.code ?? 'error') : typeof e === 'string' ? e : statusType(res.status);
+        const message = (typeof e === 'object' && e?.message) || body?.error_description || body?.message ||
+            (typeof e === 'string' && e) || (typeof body === 'string' && body) || `${res.status} ${res.statusText}`;
+        return new GenesisError({
+            status: res.status, type, message, code: typeof e === 'object' ? e?.code : undefined,
+            requestId: res.headers.get('x-request-id') ?? (typeof e === 'object' ? e?.request_id : undefined) ?? body?.request_id,
+            operationId, body,
+        });
+    }
+}
+const statusType = (s) => s === 401 ? 'unauthorized' : s === 403 ? 'forbidden' : s === 404 ? 'not_found' : s === 429 ? 'rate_limited' : s >= 500 ? 'upstream_error' : 'error';

package/dist/fleets.d.ts

@@ -0,0 +1,71 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput } from './types.js';
+type TaskInput = NonNullable<OperationInput<'fleets_submitTask'>['body']>;
+/** Managed agent tasks, always scoped to the credential's verified organization. */
+export declare function fleetsModule(client: GenesisClient): {
+    connection: {
+        get: () => Promise<{
+            connected: boolean;
+            model: string;
+            updated_at?: number;
+        }>;
+        set: (api_key: string) => Promise<{
+            connected: boolean;
+            model: string;
+            updated_at?: number;
+        }>;
+        delete: () => Promise<{
+            connected: boolean;
+            model: string;
+            updated_at?: number;
+        }>;
+    };
+    tasks: {
+        list: (query?: OperationInput<"fleets_listTasks">) => Promise<{
+            tasks: import("./index.js").components["schemas"]["Fleets.Summary"][];
+            next_before: string | null;
+        }>;
+        submit: (body: TaskInput) => Promise<{
+            task_id: string;
+            status: import("./index.js").components["schemas"]["Fleets.Status"];
+            submitted_at: string;
+            started_at?: string | null;
+            completed_at?: string | null;
+        }>;
+        get: (task_id: string) => Promise<{
+            task_id: string;
+            status: import("./index.js").components["schemas"]["Fleets.Status"];
+            submitted_at: string;
+            started_at?: string | null;
+            completed_at?: string | null;
+        }>;
+        cancel: (task_id: string) => Promise<{
+            task_id: string;
+            status: import("./index.js").components["schemas"]["Fleets.Status"];
+        }>;
+        receipt: (task_id: string) => Promise<{
+            task_id: string;
+            status: import("./index.js").components["schemas"]["Fleets.Status"];
+            submitted_at: string;
+            started_at?: string | null;
+            completed_at?: string | null;
+        } & {
+            tenant: string;
+            principal: string;
+            idempotency_key: string | null;
+            request_fingerprint: string;
+            timeout_seconds: number;
+            exit_code: number | null;
+            exit_signal: number | null;
+            cleanup_result: {
+                process_group_gone?: boolean;
+                workdir_removed?: boolean;
+                sigkill_sent?: boolean;
+            } | null;
+            henry_receipt?: {
+                [key: string]: unknown;
+            };
+        }>;
+    };
+};
+export {};

package/dist/fleets.js

@@ -0,0 +1,44 @@
+import { GenesisError } from './errors.js';
+const byteLength = (value) => new TextEncoder().encode(value).byteLength;
+const invalid = (operationId, message) => new GenesisError({
+    status: 0, type: 'invalid_request', operationId, message,
+});
+function validateTask(body) {
+    if (typeof body?.input !== 'string' || !body.input || byteLength(body.input) > 65536 || body.input.includes('\0')) {
+        throw invalid('fleets_submitTask', 'Task input must contain 1–65536 UTF-8 bytes without NUL.');
+    }
+    if (body.timeout_seconds !== undefined && (!Number.isInteger(body.timeout_seconds) || body.timeout_seconds < 1 || body.timeout_seconds > 3600)) {
+        throw invalid('fleets_submitTask', 'Timeout must be 1–3600 seconds.');
+    }
+    if (body.idempotency_key !== undefined && (typeof body.idempotency_key !== 'string' || !/^[!-~]{1,128}$/.test(body.idempotency_key))) {
+        throw invalid('fleets_submitTask', 'Idempotency key must contain 1–128 visible ASCII characters.');
+    }
+}
+function validateKey(apiKey) {
+    if (typeof apiKey !== 'string' || !apiKey || byteLength(apiKey) > 4096 || /[\r\n\0]/.test(apiKey)) {
+        throw invalid('fleets_setConnection', 'Foundry key must contain 1–4096 UTF-8 bytes without CR, LF or NUL.');
+    }
+}
+/** Managed agent tasks, always scoped to the credential's verified organization. */
+export function fleetsModule(client) {
+    return {
+        connection: {
+            get: () => client.request('fleets_getConnection', {}),
+            set: async (api_key) => {
+                validateKey(api_key);
+                return client.request('fleets_setConnection', { body: { api_key } });
+            },
+            delete: () => client.request('fleets_deleteConnection', {}),
+        },
+        tasks: {
+            list: (query = {}) => client.request('fleets_listTasks', query),
+            submit: async (body) => {
+                validateTask(body);
+                return client.request('fleets_submitTask', { body });
+            },
+            get: (task_id) => client.request('fleets_getTask', { task_id }),
+            cancel: (task_id) => client.request('fleets_cancelTask', { task_id }),
+            receipt: (task_id) => client.request('fleets_getTaskReceipt', { task_id }),
+        },
+    };
+}