@onesi/genesis 0.0.0-stage → 0.1.13

package/README.md

@@ -1,3 +1,29 @@
-# Temporary Holding Version
+# @onesi/genesis
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The TypeScript SDK for OneOS. One typed client for every Genesis service, through the Genesis API at `https://os.one.ml/api`.
+
+```sh
+npm install @onesi/genesis@0.1.13
+```
+
+```ts
+import { Genesis, GenesisError } from '@onesi/genesis';
+
+const genesis = new Genesis({ apiKey: process.env.GENESIS_API_KEY });
+try {
+  const projects = await genesis.hives.projects.list();
+} catch (e) {
+  if (e instanceof GenesisError) console.error(e.status, e.code, e.requestId, e.message);
+}
+```
+
+- **Credentials:** create an organization API key in the Console at https://os.one.ml (API keys → Create) and pass it as `apiKey` or `GENESIS_API_KEY`. A WorkOS M2M or session token goes in `token` / `GENESIS_TOKEN`.
+- **Gateway:** defaults to `https://os.one.ml/api`; `https://console.life.one/api` is an alias. Override with `baseUrl` or `GENESIS_BASE_URL`. Only `https://` (or `http://` on loopback) is accepted.
+- **Every operation:** `genesis.call(operationId, input)` reaches any operation in the bundled OpenAPI document (`@onesi/genesis/spec.json`). `operationTable` lists them.
+- **Live service state:** `GET /v1/status` (or `genesis status` in the CLI).
+- **Errors:** every failure is a `GenesisError` with `status`, `code`, `requestId` and a message from the gateway's error catalog. `errorCatalog(e)` adds `required_scope` and `docs_url`.
+- **Runtime:** ESM only, Node.js 20.19 or later.
+
+Use the same version of the SDK, [`@onesi/genesis-cli`](https://www.npmjs.com/package/@onesi/genesis-cli) and [`@onesi/genesis-mcp`](https://www.npmjs.com/package/@onesi/genesis-mcp).
+
+Docs: https://os.one.ml/docs · API reference: https://os.one.ml/api/v1/openapi.json · Error codes: https://os.one.ml/api/v1/errors

package/dist/beacons.d.ts

@@ -0,0 +1,103 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput, OperationOutput } from './types.js';
+type DashboardOptions = {
+    signal?: AbortSignal;
+};
+type PolicyConfig = OperationInput<'beacons_updateDashboardPolicy'>['body']['config'];
+/** Beacons uses the authenticated Genesis organization; never supply an org header. */
+export declare function beaconsModule(client: GenesisClient): {
+    fleets: {
+        /** Current human-authorized selected Sandbox scope; no caller tenant identifiers. */
+        list: (options?: DashboardOptions) => Promise<{
+            data: import("./index.js").components["schemas"]["Beacons.DashboardFleet"][];
+        }>;
+        update: (id: string, body: {
+            name: string;
+        }, options?: DashboardOptions) => Promise<{
+            data: import("./index.js").components["schemas"]["Beacons.DashboardFleet"];
+        }>;
+        peers: (id: string, options?: DashboardOptions) => Promise<{
+            data: import("./index.js").components["schemas"]["Beacons.DashboardPeer"][];
+        }>;
+        policy: {
+            get: (id: string, options?: DashboardOptions) => Promise<{
+                data: {
+                    fleet_id: string;
+                    config: import("./index.js").components["schemas"]["Beacons.DashboardPolicyConfig"];
+                    source: "default" | "persisted";
+                    updated_at: string | null;
+                    scope: import("./index.js").components["schemas"]["Beacons.DashboardScope"];
+                };
+            }>;
+            /** Future device admissions only; this never grants IAM rights or revokes an existing peer. */
+            update: (id: string, config: PolicyConfig, options?: DashboardOptions) => Promise<{
+                data: {
+                    fleet_id: string;
+                    config: import("./index.js").components["schemas"]["Beacons.DashboardPolicyConfig"];
+                    source: "default" | "persisted";
+                    updated_at: string | null;
+                    scope: import("./index.js").components["schemas"]["Beacons.DashboardScope"];
+                };
+            }>;
+        };
+        /** Reuse the same request ID and body after an interrupted response. Creates metadata only. */
+        provision: (requestId: string, body?: {
+            name?: string;
+        }) => Promise<{
+            data: {
+                fleet_id: string;
+                organization_id: string;
+                workspace_id: string;
+                project_id: string;
+                environment_id: string;
+                metadata_only: true;
+            };
+        }>;
+    };
+    devices: {
+        revocations: (id: string) => Promise<{
+            data: import("./index.js").components["schemas"]["Beacons.DeviceRevocation"][];
+        }>;
+        acknowledge: (id: string, version: number, body: OperationInput<"beacons_acknowledgeBridgeDeviceRevocation">["body"]) => Promise<{
+            data: import("./index.js").components["schemas"]["Beacons.DeviceRevocation"];
+        }>;
+        challenge: (body: OperationInput<"beacons_issueBridgeDeviceChallenge">["body"]) => Promise<{
+            version: 1;
+            id: string;
+            nonce: string;
+            issuer: string;
+            organization: string;
+            principal: string;
+            workspace: string;
+            project: string;
+            environment: string;
+            binding_revision: string;
+            transport: string;
+            fleet_id: string;
+            proof_key: string;
+            tunnel_key: string;
+            issued_at: number;
+            expires_at: number;
+        }>;
+        enroll: (body: OperationInput<"beacons_enrollBridgeDevice">["body"]) => Promise<{
+            device_id: string;
+            fleet_id: string;
+            mesh: {
+                [key: string]: unknown;
+            };
+        }>;
+        list: () => Promise<{
+            data?: import("./index.js").components["schemas"]["Beacons.BridgeDevice"][];
+        }>;
+        update: (id: string, body: OperationInput<"beacons_updateBridgeDevice">["body"]) => Promise<{
+            id: string;
+            org_id: string;
+            name: string;
+            nicknames: string[];
+            created_at: string;
+            status: string;
+        }>;
+        revoke: (id: string) => Promise<OperationOutput<"beacons_revokeBridgeDevice"> | undefined>;
+    };
+};
+export {};

package/dist/beacons.js

@@ -0,0 +1,77 @@
+import { GenesisError } from './errors.js';
+function invalidDashboard(operationId) {
+    throw new GenesisError({ status: 0, type: 'invalid_request', operationId,
+        message: 'Provide a canonical fleet UUID and only the documented Beacons fields.' });
+}
+function fleetId(id, operationId) {
+    if (typeof id !== 'string' || id.length !== 36 || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(id)
+        || id === '00000000-0000-0000-0000-000000000000')
+        invalidDashboard(operationId);
+    return id;
+}
+function renameInput(body) {
+    const op = 'beacons_updateDashboardFleet';
+    if (!body || typeof body !== 'object' || Array.isArray(body)
+        || Object.keys(body).length !== 1 || !Object.hasOwn(body, 'name'))
+        invalidDashboard(op);
+    const suppliedName = body.name;
+    if (typeof suppliedName !== 'string')
+        invalidDashboard(op);
+    const name = suppliedName.trim();
+    if (!name || new TextEncoder().encode(name).length > 128 || /[\u0000-\u001f\u007f-\u009f]/.test(name))
+        invalidDashboard(op);
+    return { name };
+}
+function policyInput(config) {
+    const op = 'beacons_updateDashboardPolicy';
+    if (!config || typeof config !== 'object' || Array.isArray(config)
+        || Object.keys(config).some(key => !['device_enrollment', 'max_devices'].includes(key))
+        || !Object.hasOwn(config, 'device_enrollment'))
+        invalidDashboard(op);
+    const mode = config.device_enrollment;
+    const limit = config.max_devices;
+    if (!['allowed_with_permission', 'paused'].includes(mode)
+        || (limit !== undefined && (!Number.isInteger(limit) || limit < 1 || limit > 10000)))
+        invalidDashboard(op);
+    // Snapshot before the asynchronous credential provider can change the caller's object.
+    return { config: { device_enrollment: mode,
+            ...(limit === undefined ? {} : { max_devices: limit }) } };
+}
+function provisioningInput(requestId, body) {
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(requestId)
+        || requestId === '00000000-0000-0000-0000-000000000000'
+        || !body || typeof body !== 'object' || Array.isArray(body)
+        || Object.keys(body).some(key => key !== 'name')
+        || (body.name !== undefined && (typeof body.name !== 'string' || !body.name.trim()
+            || new TextEncoder().encode(body.name).length > 256 || /[\u0000-\u001f\u007f-\u009f]/.test(body.name)))) {
+        throw new GenesisError({ status: 0, type: 'invalid_request', operationId: 'beacons_provisionBridgeFleet', message: 'Provide a nonzero UUID request ID and an optional fleet name of up to 256 UTF-8 bytes.' });
+    }
+    return body.name === undefined ? {} : { name: body.name };
+}
+/** Beacons uses the authenticated Genesis organization; never supply an org header. */
+export function beaconsModule(client) {
+    return {
+        fleets: {
+            /** Current human-authorized selected Sandbox scope; no caller tenant identifiers. */
+            list: (options = {}) => client.request('beacons_listDashboardFleets', {}, options),
+            update: (id, body, options = {}) => client.request('beacons_updateDashboardFleet', { fleet_id: fleetId(id, 'beacons_updateDashboardFleet'), body: renameInput(body) }, options),
+            peers: (id, options = {}) => client.request('beacons_listDashboardPeers', { fleet_id: fleetId(id, 'beacons_listDashboardPeers') }, options),
+            policy: {
+                get: (id, options = {}) => client.request('beacons_getDashboardPolicy', { fleet_id: fleetId(id, 'beacons_getDashboardPolicy') }, options),
+                /** Future device admissions only; this never grants IAM rights or revokes an existing peer. */
+                update: (id, config, options = {}) => client.request('beacons_updateDashboardPolicy', { fleet_id: fleetId(id, 'beacons_updateDashboardPolicy'), body: policyInput(config) }, options),
+            },
+            /** Reuse the same request ID and body after an interrupted response. Creates metadata only. */
+            provision: (requestId, body = {}) => client.request('beacons_provisionBridgeFleet', { body: provisioningInput(requestId, body) }, { headers: { 'idempotency-key': requestId } }),
+        },
+        devices: {
+            revocations: (id) => client.request('beacons_listBridgeDeviceRevocations', { id }),
+            acknowledge: (id, version, body) => client.request('beacons_acknowledgeBridgeDeviceRevocation', { id, version, body }),
+            challenge: (body) => client.request('beacons_issueBridgeDeviceChallenge', { body }),
+            enroll: (body) => client.request('beacons_enrollBridgeDevice', { body }),
+            list: () => client.request('beacons_listBridgeDevices'),
+            update: (id, body) => client.request('beacons_updateBridgeDevice', { id, body }),
+            revoke: (id) => client.request('beacons_revokeBridgeDevice', { id }),
+        },
+    };
+}

package/dist/blinds-owner-enrollment.d.ts

@@ -0,0 +1,171 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput } from './types.js';
+export declare const isBlindsOwnerOperation: (id: string) => boolean;
+/** One original-human operation; all public metadata, no arbitrary signing payload or private key. */
+export declare function blindsOwnerTransport(options: {
+    operationId: string;
+    input: Record<string, unknown>;
+    routing: string;
+    url: string;
+    credential: () => Promise<string | undefined>;
+    fetch: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<Response>;
+export declare function blindsModule(client: GenesisClient): {
+    credentials: {
+        /** Variable names only; values never leave Blinds. */
+        list: (init?: {
+            signal?: AbortSignal;
+        }) => Promise<{
+            credentials: string[];
+        }>;
+        /** Connect a static credential. The value is KMS-encrypted and never returned. */
+        store: (body: OperationInput<"blinds_storeCredential">["body"], init?: {
+            signal?: AbortSignal;
+            idempotencyKey?: string;
+        }) => Promise<{
+            variable_name: string;
+        }>;
+        revoke: (variable: string, init?: {
+            signal?: AbortSignal;
+            idempotencyKey?: string;
+        }) => Promise<unknown>;
+    };
+    oauth: {
+        connections: (init?: {
+            signal?: AbortSignal;
+        }) => Promise<{
+            connections: import("./index.js").components["schemas"]["Blinds.OAuthConnection"][];
+            total: number;
+        }>;
+    };
+    consent: {
+        pending: (init?: {
+            signal?: AbortSignal;
+        }) => Promise<{
+            requests: import("./index.js").components["schemas"]["Blinds.ConsentPending"][];
+        }>;
+        records: (init?: {
+            signal?: AbortSignal;
+        }) => Promise<{
+            records: import("./index.js").components["schemas"]["Blinds.ConsentRecord"][];
+        }>;
+        approve: (consent_id: string, body: OperationInput<"blinds_approveConsent">["body"], init?: {
+            signal?: AbortSignal;
+            idempotencyKey?: string;
+        }) => Promise<unknown>;
+        deny: (consent_id: string, init?: {
+            signal?: AbortSignal;
+            idempotencyKey?: string;
+        }) => Promise<unknown>;
+        revoke: (consent_id: string, init?: {
+            signal?: AbortSignal;
+            idempotencyKey?: string;
+        }) => Promise<unknown>;
+    };
+    delegates: {
+        list: (init?: {
+            signal?: AbortSignal;
+        }) => Promise<{
+            delegates: import("./index.js").components["schemas"]["Blinds.Delegate"][];
+        }>;
+        create: (body: OperationInput<"blinds_createDelegate">["body"], init?: {
+            signal?: AbortSignal;
+            idempotencyKey?: string;
+        }) => Promise<{
+            delegate_id: string;
+            parent_id?: string | null;
+            name: string;
+            issuer_did: string;
+            delegated_variables: string[];
+            max_depth?: number;
+            current_depth?: number;
+            ttl_seconds?: number;
+            created_at?: string;
+            expires_at: string;
+        }>;
+        revoke: (delegate_id: string, init?: {
+            signal?: AbortSignal;
+            idempotencyKey?: string;
+        }) => Promise<unknown>;
+    };
+    activity: (init?: {
+        signal?: AbortSignal;
+    }) => Promise<{
+        events: import("./index.js").components["schemas"]["Blinds.ActivityEvent"][];
+    }>;
+    ownerEnrollment: {
+        reserve: (body: OperationInput<"blinds_ownerReserve">["body"], init?: {
+            signal?: AbortSignal;
+        }) => Promise<{
+            schemaVersion: 1;
+            requestId: string;
+            edReservationId: string;
+            operationId: string;
+            publicKey: string;
+            state: "key_ready" | "attached";
+            expiresAtMs: number;
+            originalOrganizationGeneration: number;
+        }>;
+        sign: (body: OperationInput<"blinds_ownerSign">["body"], init?: {
+            signal?: AbortSignal;
+        }) => Promise<{
+            schemaVersion: 1;
+            requestId: string;
+            edReservationId: string;
+            enrollmentIntentId: string;
+            operationId: string;
+            signingPayloadSha256: string;
+            signatureMultibase: string;
+        }>;
+        attach: (body: OperationInput<"blinds_ownerAttach">["body"], init?: {
+            signal?: AbortSignal;
+        }) => Promise<{
+            schemaVersion: 1;
+            requestId: string;
+            edReservationId: string;
+            enrollmentIntentId: string;
+            state: "attached";
+            creation: {
+                intent_id: string;
+                operation_id: string;
+                creation_receipt_id: string;
+                agent_id: string;
+                canonical_did: string;
+                registered_public_key: string;
+                owner: {
+                    issuer: "https://auth.life.one";
+                    original_owner: string;
+                    organization_generation: number;
+                    scope: {
+                        platform_id: "blinds";
+                        organization_id: string;
+                        workspace_id: string | null;
+                        project_id: string | null;
+                        environment_id: "sandbox" | "live";
+                    };
+                };
+            };
+        }>;
+        ensureP256: (body: OperationInput<"blinds_ownerP256Ensure">["body"], init?: {
+            signal?: AbortSignal;
+        }) => Promise<{
+            schemaVersion: 1;
+            requestId: string;
+            edReservationId: string;
+            enrollmentIntentId: string;
+            state: "ready";
+            dpopPublicJwk: {
+                kty: "EC";
+                crv: "P-256";
+                x: string;
+                y: string;
+            };
+            senderJkt: string;
+        }>;
+    };
+};
+/** Blinds admits a mutation only with one UUID Idempotency-Key, the logical operation ID it
+ *  records a receipt under. Take the caller's (input.idempotency_key or the header) so a retry
+ *  after an uncertain outcome is recognised, else mint a new one. Never retried here. */
+export declare function blindsOperationKey(operationId: string, input: Record<string, unknown>, headers: Record<string, string>): string;

package/dist/blinds-owner-enrollment.js

@@ -0,0 +1,150 @@
+import { GenesisError } from './errors.js';
+const operations = ['blinds_ownerReserve', 'blinds_ownerSign', 'blinds_ownerAttach', 'blinds_ownerP256Ensure'];
+export const isBlindsOwnerOperation = (id) => operations.includes(id);
+const uuid = (v) => typeof v === 'string' && /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(v);
+/** One original-human operation; all public metadata, no arbitrary signing payload or private key. */
+export async function blindsOwnerTransport(options) {
+    const { operationId, input, signal } = options;
+    const error = (status, type) => new GenesisError({ status, type, operationId,
+        message: 'Blinds owner enrollment was not confirmed. Preserve the original operation and locators; do not replay an unknown outcome automatically.' });
+    if (options.routing !== 'gateway')
+        throw error(0, 'invalid_request');
+    const body = input.body;
+    if (!body || typeof body !== 'object' || Array.isArray(body) || body.schemaVersion !== 1 || !uuid(body.requestId))
+        throw error(0, 'invalid_request');
+    const serialized = JSON.stringify(body);
+    if (new TextEncoder().encode(serialized).byteLength > 2048)
+        throw error(0, 'invalid_request');
+    const controller = new AbortController(), cancel = () => controller.abort(signal?.reason);
+    if (signal?.aborted)
+        cancel();
+    else
+        signal?.addEventListener('abort', cancel, { once: true });
+    const timer = setTimeout(() => controller.abort(), 12_000);
+    let abort = () => { };
+    const bounded = async (promise) => {
+        controller.signal.throwIfAborted();
+        try {
+            return await Promise.race([promise, new Promise((_, reject) => { abort = () => reject(error(0, 'transport_error')); controller.signal.addEventListener('abort', abort, { once: true }); })]);
+        }
+        finally {
+            controller.signal.removeEventListener('abort', abort);
+        }
+    };
+    try {
+        const credential = await bounded(options.credential());
+        controller.signal.throwIfAborted();
+        if (!credential)
+            throw error(401, 'unauthenticated');
+        const response = await bounded(options.fetch(options.url, { method: 'POST', body: serialized,
+            headers: { authorization: `Bearer ${credential}`, 'content-type': 'application/json', accept: 'application/json', 'x-l1fe-request-id': body.requestId },
+            redirect: 'error', cache: 'no-store', signal: controller.signal }).then(response => { if (controller.signal.aborted) {
+            void response.body?.cancel().catch(() => { });
+            throw error(0, 'transport_error');
+        } return response; }));
+        if (response.status !== 200) {
+            void response.body?.cancel().catch(() => { });
+            throw error(response.status, 'unconfirmed_operation');
+        }
+        if (!response.body || !/^application\/json(?:;|$)/i.test(response.headers.get('content-type') ?? ''))
+            throw error(0, 'invalid_response');
+        const reader = response.body.getReader(), chunks = [];
+        let length = 0;
+        const stop = () => { void reader.cancel().catch(() => { }); };
+        controller.signal.addEventListener('abort', stop, { once: true });
+        try {
+            for (;;) {
+                const r = await bounded(reader.read());
+                if (r.done)
+                    break;
+                length += r.value.length;
+                if (length > 16384)
+                    throw error(0, 'invalid_response');
+                chunks.push(r.value);
+            }
+        }
+        finally {
+            controller.signal.removeEventListener('abort', stop);
+            stop();
+            try {
+                reader.releaseLock();
+            }
+            catch { /* pending cancelled read */ }
+        }
+        const data = new Uint8Array(length);
+        let offset = 0;
+        for (const chunk of chunks) {
+            data.set(chunk, offset);
+            offset += chunk.length;
+        }
+        let value;
+        try {
+            value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(data));
+        }
+        catch {
+            throw error(0, 'invalid_response');
+        }
+        if (!value || value.schemaVersion !== 1 || value.requestId !== body.requestId || !uuid(value.edReservationId)
+            || operationId === 'blinds_ownerReserve' && value.operationId !== body.operationId
+            || operationId !== 'blinds_ownerReserve' && (value.edReservationId !== body.edReservationId || value.enrollmentIntentId !== body.enrollmentIntentId))
+            throw error(0, 'invalid_response');
+        return Response.json(value, { headers: { 'cache-control': 'no-store' } });
+    }
+    catch (e) {
+        if (e instanceof GenesisError)
+            throw e;
+        throw error(0, 'transport_error');
+    }
+    finally {
+        clearTimeout(timer);
+        controller.abort();
+        signal?.removeEventListener('abort', cancel);
+    }
+}
+export function blindsModule(client) {
+    const write = (id, input, init = {}) => client.request(id, { ...input, ...(init.idempotencyKey ? { idempotency_key: init.idempotencyKey } : {}) }, { signal: init.signal });
+    const read = (id, init = {}) => client.request(id, {}, init);
+    return {
+        credentials: {
+            /** Variable names only; values never leave Blinds. */
+            list: (init) => read('blinds_listCredentials', init),
+            /** Connect a static credential. The value is KMS-encrypted and never returned. */
+            store: (body, init) => write('blinds_storeCredential', { body }, init),
+            revoke: (variable, init) => write('blinds_deleteCredential', { variable }, init),
+        },
+        oauth: { connections: (init) => read('blinds_listOAuthConnections', init) },
+        consent: {
+            pending: (init) => read('blinds_listPendingConsent', init),
+            records: (init) => read('blinds_listConsentRecords', init),
+            approve: (consent_id, body, init) => write('blinds_approveConsent', { consent_id, body }, init),
+            deny: (consent_id, init) => write('blinds_denyConsent', { consent_id }, init),
+            revoke: (consent_id, init) => write('blinds_revokeConsent', { consent_id }, init),
+        },
+        delegates: {
+            list: (init) => read('blinds_listDelegates', init),
+            create: (body, init) => write('blinds_createDelegate', { body }, init),
+            revoke: (delegate_id, init) => write('blinds_revokeDelegate', { delegate_id }, init),
+        },
+        activity: (init) => read('blinds_listActivity', init),
+        ownerEnrollment: {
+            reserve: (body, init = {}) => client.request('blinds_ownerReserve', { body }, init),
+            sign: (body, init = {}) => client.request('blinds_ownerSign', { body }, init),
+            attach: (body, init = {}) => client.request('blinds_ownerAttach', { body }, init),
+            ensureP256: (body, init = {}) => client.request('blinds_ownerP256Ensure', { body }, init),
+        }
+    };
+}
+const blindsKey = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Blinds admits a mutation only with one UUID Idempotency-Key, the logical operation ID it
+ *  records a receipt under. Take the caller's (input.idempotency_key or the header) so a retry
+ *  after an uncertain outcome is recognised, else mint a new one. Never retried here. */
+export function blindsOperationKey(operationId, input, headers) {
+    const names = Object.keys(headers).filter(name => name.toLowerCase() === 'idempotency-key');
+    const given = [...names.map(name => headers[name]), ...(input.idempotency_key === undefined ? [] : [input.idempotency_key])];
+    if (new Set(given).size > 1 || given.some(v => typeof v !== 'string' || !blindsKey.test(v))) {
+        throw new GenesisError({ status: 0, type: 'invalid_request', message: 'A Blinds mutation takes one UUID idempotency key.', operationId });
+    }
+    for (const name of names)
+        delete headers[name];
+    return headers['idempotency-key'] = given[0] ?? crypto.randomUUID();
+}