@onesi/genesis 0.0.0-stage → 0.1.13

package/dist/dials.d.ts

@@ -0,0 +1,299 @@
+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 DialsOutboundCallReceipt = components['schemas']['Dials.OutboundCallReceipt'];
+export type DialsRecoveredOutboundCallReceipt = components['schemas']['Dials.RecoveredOutboundCallReceipt'];
+export type DialsEmergencyAddress = components['schemas']['Dials.RegisterEmergencyAddress'];
+export type DialsCallListItem = components['schemas']['Dials.CallListItem'];
+export type DialsCallDispatchState = components['schemas']['Dials.CallDispatchState'];
+export type DialsMessage = components['schemas']['Dials.MessageEvent'];
+export type DialsMessageTemplate = components['schemas']['Dials.MessageTemplate'];
+export type DialsMessagingBrand = components['schemas']['Dials.MessagingBrand'];
+export type DialsMessagingCampaign = components['schemas']['Dials.MessagingCampaign'];
+export type DialsWorkflowDocument = components['schemas']['Dials.WorkflowDocument'];
+export type DialsRoutingAction = components['schemas']['Dials.RoutingAction'];
+export type DialsRoutingRule = components['schemas']['Dials.RoutingRule'];
+export type DialsRoutingRuleReceipt = components['schemas']['Dials.RoutingRuleReceipt'];
+/** Scope is selection only; the Dials backend verifies its org against signed identity. */
+export declare function dialsModule(client: GenesisClient): {
+    routing: {
+        list: (scope: DialsScope) => Promise<{
+            ok: true;
+            scope: components["schemas"]["Dials.Scope"];
+            rules: components["schemas"]["Dials.RoutingRule"][];
+        }>;
+        create: (body: OperationInput<"dials_createRoutingRule">["body"]) => Promise<{
+            ok: true;
+            rule: components["schemas"]["Dials.RoutingRule"];
+            auditId: string;
+            idempotentReplay: boolean;
+        }>;
+        disable: (ruleId: string, body: OperationInput<"dials_disableRoutingRule">["body"]) => Promise<{
+            ok: true;
+            rule: components["schemas"]["Dials.RoutingRule"];
+            auditId: string | null;
+            idempotentReplay: boolean;
+        }>;
+    };
+    people: {
+        list: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            humans: components["schemas"]["Dials.HumanProfile"][];
+        }>;
+        create: (body: OperationInput<"dials_createHumanProfile">["body"]) => Promise<{
+            ok: boolean;
+            human: components["schemas"]["Dials.HumanProfile"];
+            auditId: string;
+            usageEventId: string;
+            next: string;
+        }>;
+    };
+    agents: {
+        list: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            agents: components["schemas"]["Dials.AgentProfile"][];
+        }>;
+        create: (body: OperationInput<"dials_createAgent">["body"]) => Promise<{
+            ok: boolean;
+            agent: components["schemas"]["Dials.AgentProfile"];
+            auditId: string;
+            usageEventId: string;
+            next: string;
+        }>;
+    };
+    voice: {
+        list: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            voiceProfiles: components["schemas"]["Dials.VoiceProfile"][];
+        }>;
+        create: (body: OperationInput<"dials_createVoiceProfile">["body"]) => Promise<{
+            ok: boolean;
+            voiceProfile: components["schemas"]["Dials.VoiceProfile"];
+            auditId: string;
+            usageEventId: string;
+            next: string;
+        }>;
+    };
+    messages: {
+        list: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            messages: components["schemas"]["Dials.MessageEvent"][];
+        }>;
+        send: (body: OperationInput<"dials_createOutboundMessage">["body"]) => Promise<{
+            ok: boolean;
+            message: components["schemas"]["Dials.MessageEvent"];
+            auditId: string;
+            usageEventId: string;
+            next: string;
+            idempotentReplay: boolean;
+        }>;
+        templates: {
+            list: (scope: DialsScope) => Promise<{
+                ok: boolean;
+                templates: components["schemas"]["Dials.MessageTemplate"][];
+            }>;
+            create: (body: OperationInput<"dials_createMessageTemplate">["body"]) => Promise<{
+                ok: boolean;
+                template: components["schemas"]["Dials.MessageTemplate"];
+                auditId: string;
+                usageEventId: string;
+                next: string;
+            }>;
+        };
+        brands: {
+            list: (scope: DialsScope) => Promise<{
+                ok: boolean;
+                brands: components["schemas"]["Dials.MessagingBrand"][];
+            }>;
+            create: (body: OperationInput<"dials_createMessagingBrand">["body"]) => Promise<{
+                ok: boolean;
+                brand: components["schemas"]["Dials.MessagingBrand"];
+                auditId: string;
+                next: string;
+            }>;
+        };
+        campaigns: {
+            list: (scope: DialsScope) => Promise<{
+                ok: boolean;
+                campaigns: components["schemas"]["Dials.MessagingCampaign"][];
+            }>;
+            create: (body: OperationInput<"dials_createMessagingCampaign">["body"]) => Promise<{
+                ok: boolean;
+                campaign: components["schemas"]["Dials.MessagingCampaign"];
+                auditId: string;
+                next: string;
+            }>;
+            assignNumber: (campaignId: string, body: OperationInput<"dials_assignCampaignNumber">["body"]) => Promise<{
+                ok: boolean;
+                campaignId: string;
+                phoneNumberId: string;
+                auditId: string;
+                next: string;
+            }>;
+        };
+    };
+    workflows: {
+        list: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            workflows: components["schemas"]["Dials.WorkflowDocument"][];
+        }>;
+        deploy: (body: OperationInput<"dials_deployWorkflow">["body"]) => Promise<{
+            ok: boolean;
+            workflow: components["schemas"]["Dials.WorkflowDocument"];
+            auditId: string;
+            usageEventId: string;
+            next: string;
+            route: components["schemas"]["Dials.RoutingRule"];
+        }>;
+    };
+    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;
+        }>;
+        delete: (input: OperationInput<"dials_deleteNumber">) => Promise<{
+            ok: boolean;
+            number: components["schemas"]["Dials.Number"];
+            auditId: string;
+            usageEventId: string;
+            next: string;
+        }>;
+        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.CallListItem"][];
+        }>;
+        validate: (body: DialsOutboundCall) => Promise<{
+            [key: string]: unknown;
+        }>;
+        create: (body: DialsOutboundCall) => Promise<{
+            ok: boolean;
+            call: components["schemas"]["Dials.CallSession"];
+            auditId: string;
+            dispatchJobId: string;
+            usageEventId: string;
+            next: string;
+            idempotentReplay: boolean;
+        } & {
+            [key: string]: unknown;
+        }>;
+        recover: (body: DialsOutboundCall) => Promise<{
+            ok: boolean;
+            call: components["schemas"]["Dials.CallSession"];
+            auditId: string;
+            dispatchJobId: string;
+            usageEventId: string;
+            next: string;
+            idempotentReplay: boolean;
+        } & {
+            [key: string]: unknown;
+        } & {
+            idempotentReplay: true;
+        }>;
+    };
+};
+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,100 @@
+import { errorToken, GenesisError } from './errors.js';
+/** Scope is selection only; the Dials backend verifies its org against signed identity. */
+export function dialsModule(client) {
+    return {
+        routing: {
+            list: (scope) => client.request('dials_listRoutingRules', scope),
+            create: (body) => client.request('dials_createRoutingRule', { body }),
+            disable: (ruleId, body) => client.request('dials_disableRoutingRule', { rule_id: ruleId, body }),
+        },
+        people: {
+            list: (scope) => client.request('dials_listHumanProfiles', scope),
+            create: (body) => client.request('dials_createHumanProfile', { body }),
+        },
+        agents: {
+            list: (scope) => client.request('dials_listAgents', scope),
+            create: (body) => client.request('dials_createAgent', { body }),
+        },
+        voice: {
+            list: (scope) => client.request('dials_listVoiceProfiles', scope),
+            create: (body) => client.request('dials_createVoiceProfile', { body }),
+        },
+        messages: {
+            list: (scope) => client.request('dials_listMessages', scope),
+            send: (body) => client.request('dials_createOutboundMessage', { body }),
+            templates: {
+                list: (scope) => client.request('dials_listMessageTemplates', scope),
+                create: (body) => client.request('dials_createMessageTemplate', { body }),
+            },
+            brands: {
+                list: (scope) => client.request('dials_listMessagingBrands', scope),
+                create: (body) => client.request('dials_createMessagingBrand', { body }),
+            },
+            campaigns: {
+                list: (scope) => client.request('dials_listMessagingCampaigns', scope),
+                create: (body) => client.request('dials_createMessagingCampaign', { body }),
+                assignNumber: (campaignId, body) => client.request('dials_assignCampaignNumber', { campaign_id: campaignId, body }),
+            },
+        },
+        workflows: {
+            list: (scope) => client.request('dials_listWorkflows', scope),
+            deploy: (body) => client.request('dials_deployWorkflow', { body }),
+        },
+        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 }),
+            delete: (input) => client.request('dials_deleteNumber', input),
+            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 }),
+            recover: (body) => client.request('dials_recoverOutboundCall', { 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;
+    // The gateway sends the envelope (error.code CARRIER_REJECTED) with the advisory fields beside it; older bodies use the string form.
+    if (!object(body) || errorToken(body) !== '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,35 @@
+/** 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>;
+}
+/** The gateway catalog fields of an error, for JSON output: `code`, `required_scope` and `docs_url` when the gateway sent them. */
+export declare function errorCatalog(e: GenesisError): {
+    code?: string;
+    required_scope?: string;
+    docs_url?: string;
+};
+/**
+ * The refusal code of an error body in either form: the one Genesis envelope (`error.code`) or a
+ * legacy string (`{"error":"carrier_rejected"}`), lower-cased so `CARRIER_REJECTED` and `carrier_rejected` match.
+ */
+export declare function errorToken(body: unknown): string | undefined;
+/** An error body's dispatch outcome, from `error.outcome` (envelope) or the top level (legacy). */
+export declare function errorOutcome(body: unknown): string | undefined;
+/** Optional fields the gateway adds to an envelope; each must be a bounded string when present. */
+export declare const ENVELOPE_EXTRA_FIELDS: readonly string[];
+export declare const envelopeExtrasValid: (error: Record<string, unknown>) => boolean;

package/dist/errors.js

@@ -0,0 +1,66 @@
+/** 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;
+        // An OAuth-style token (`{"error":"forbidden"}`) is the type; any other string is a message, and type stays a stable token.
+        const type = typeof e === 'object' && e ? (e.type ?? e.code ?? 'error')
+            : typeof e === 'string' && /^[a-z][a-z0-9_]{0,63}$/.test(e) ? 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';
+/** The gateway catalog fields of an error, for JSON output: `code`, `required_scope` and `docs_url` when the gateway sent them. */
+export function errorCatalog(e) {
+    const body = e.body && typeof e.body === 'object' ? e.body.error : undefined;
+    const field = (k) => { const v = body && typeof body === 'object' ? body[k] : undefined; return typeof v === 'string' ? v : undefined; };
+    const scope = field('required_scope'), docs = field('docs_url');
+    return { ...(typeof e.code === 'string' && /^[A-Za-z][A-Za-z0-9_.-]{0,63}$/.test(e.code) ? { code: e.code } : {}), ...(scope ? { required_scope: scope } : {}),
+        ...(docs && /^https:\/\/[a-z0-9.-]+\/[^\s]{0,256}$/i.test(docs) ? { docs_url: docs } : {}) };
+}
+const row = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+/**
+ * The refusal code of an error body in either form: the one Genesis envelope (`error.code`) or a
+ * legacy string (`{"error":"carrier_rejected"}`), lower-cased so `CARRIER_REJECTED` and `carrier_rejected` match.
+ */
+export function errorToken(body) {
+    if (!row(body))
+        return undefined;
+    const value = typeof body.error === 'string' ? body.error : row(body.error) && typeof body.error.code === 'string' ? body.error.code : undefined;
+    return value && /^[A-Za-z][A-Za-z0-9_.:-]{0,127}$/.test(value) ? value.toLowerCase() : undefined;
+}
+/** An error body's dispatch outcome, from `error.outcome` (envelope) or the top level (legacy). */
+export function errorOutcome(body) {
+    if (!row(body))
+        return undefined;
+    const nested = row(body.error) && typeof body.error.outcome === 'string' ? body.error.outcome : undefined;
+    return nested ?? (typeof body.outcome === 'string' ? body.outcome : undefined);
+}
+/** Optional fields the gateway adds to an envelope; each must be a bounded string when present. */
+export const ENVELOPE_EXTRA_FIELDS = ['type', 'message', 'docs_url', 'layer', 'reason', 'required_scope'];
+export const envelopeExtrasValid = (error) => ENVELOPE_EXTRA_FIELDS.every(name => error[name] === undefined || typeof error[name] === 'string' && error[name].length <= 2048);

package/dist/flares.d.ts

@@ -0,0 +1,170 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput as In } from './types.js';
+/** Flares v2 (Sandbox): flares, conversations, commitments, presence, trust and choreography.
+ * Every mutation needs one stable idempotency key; reuse it to replay instead of acting twice. */
+export declare function flaresModule(client: GenesisClient): {
+    list: (q?: In<"flares_listFlares">) => Promise<({
+        id?: string;
+        status?: string;
+        flareType?: string;
+        recipientId?: string;
+        recipientType?: string;
+        priority?: string;
+        channels?: string[];
+        createdAt?: string;
+        updatedAt?: string;
+        deliveryReceipts?: {
+            [key: string]: unknown;
+        };
+    } & {
+        [key: string]: unknown;
+    })[]>;
+    get: (id: string) => Promise<{
+        id?: string;
+        status?: string;
+        flareType?: string;
+        recipientId?: string;
+        recipientType?: string;
+        priority?: string;
+        channels?: string[];
+        createdAt?: string;
+        updatedAt?: string;
+        deliveryReceipts?: {
+            [key: string]: unknown;
+        };
+    } & {
+        [key: string]: unknown;
+    }>;
+    send: (body: In<"flares_sendFlare">["body"], key: string) => Promise<{
+        id?: string;
+        status?: string;
+    }>;
+    sendBatch: (body: In<"flares_sendFlareBatch">["body"], key: string) => Promise<{
+        results?: import("./index.js").components["schemas"]["Flares.SendFlareResponse"][];
+    }>;
+    acknowledge: (id: string, body: In<"flares_acknowledgeFlare">["body"], key: string) => Promise<{
+        [key: string]: unknown;
+    }>;
+    act: (id: string, body: In<"flares_actOnFlare">["body"], key: string) => Promise<{
+        [key: string]: unknown;
+    }>;
+    conversations: {
+        list: () => Promise<{
+            [key: string]: unknown;
+        }[]>;
+        get: (id: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        create: (body: In<"flares_createConversation">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        send: (id: string, body: In<"flares_sendConversationMessage">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        close: (id: string, key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    commitments: {
+        list: () => Promise<{
+            [key: string]: unknown;
+        }[]>;
+        get: (id: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        create: (body: In<"flares_createCommitment">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        accept: (id: string, key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        start: (id: string, key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        progress: (id: string, body: In<"flares_reportCommitmentProgress">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        fulfill: (id: string, body: In<"flares_fulfillCommitment">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        fail: (id: string, body: In<"flares_failCommitment">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    presence: {
+        heartbeat: (body: In<"flares_presenceHeartbeat">["body"], key: string) => Promise<{
+            did?: string;
+            status?: string;
+            sessionId?: string;
+            sessionCount?: number;
+            lastSeenAt?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        get: (did: string) => Promise<{
+            did?: string;
+            status?: string;
+            sessionId?: string;
+            sessionCount?: number;
+            lastSeenAt?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+    trust: {
+        score: (did: string) => Promise<{
+            did?: string;
+            score?: number;
+            confidence?: number;
+            dataPoints?: number;
+            computedAt?: string;
+            expiresAt?: string;
+            trustLevel?: string;
+            endorsementCount?: number;
+        } & {
+            [key: string]: unknown;
+        }>;
+        check: (body: In<"flares_checkTrust">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        endorsements: (did: string) => Promise<{
+            [key: string]: unknown;
+        }[]>;
+        endorse: (body: In<"flares_createEndorsement">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        revoke: (id: string, key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    choreography: {
+        workflows: {
+            list: () => Promise<{
+                [key: string]: unknown;
+            }[]>;
+            create: (body: In<"flares_createChoreographyWorkflow">["body"], key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            start: (workflow_id: string, key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+        };
+        executions: {
+            list: () => Promise<{
+                [key: string]: unknown;
+            }[]>;
+            get: (execution_id: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            completeStep: (execution_id: string, step_id: string, body: In<"flares_completeChoreographyStep">["body"], key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            failStep: (execution_id: string, step_id: string, body: In<"flares_failChoreographyStep">["body"], key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            cancel: (execution_id: string, key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+        };
+    };
+};