@abloatai/ablo 0.35.0 → 0.37.0

package/dist/testing/mocks/MockSyncContext.d.ts

@@ -1,51 +0,0 @@
-/**
- * Assembles a ready-to-use {@link RuntimeContext} for tests. The context
- * bundles every dependency the engine needs — logger, network monitor,
- * mutation executor, and configuration — so a test can start the engine
- * without a real backend. {@link createTestContext} is the entry point: it
- * wires the mocks, installs the context globally through {@link initRuntime},
- * and returns handles to each mock for assertions.
- */
-import type { RuntimeContext } from '../../RuntimeContext.js';
-import type { Logger, ObservabilityProvider, SessionErrorDetector, RuntimeConfig } from '../../interfaces/index.js';
-import { MockMutationExecutor } from './MockMutationExecutor.js';
-import { MockNetworkMonitor } from './MockNetworkMonitor.js';
-export interface TestContextOptions {
-    /** Replaces the default no-op logger. */
-    logger?: Logger;
-    /** Replaces the default no-op observability provider. */
-    observability?: ObservabilityProvider;
-    /** Replaces the detector that decides whether an error means the session has expired. */
-    sessionErrorDetector?: SessionErrorDetector;
-    /** Options forwarded to the {@link MockMutationExecutor} that the context creates. */
-    mutationExecutorOptions?: ConstructorParameters<typeof MockMutationExecutor>[0];
-    /** A partial {@link RuntimeConfig} merged over the defaults. */
-    config?: Partial<RuntimeConfig>;
-    /** Starts the network monitor offline. Defaults to online. */
-    startOffline?: boolean;
-}
-export interface TestContextResult {
-    /** The assembled context that {@link createTestContext} installed globally. */
-    context: RuntimeContext;
-    /** Handles to the underlying mocks, so tests can drive them and assert on them. */
-    mocks: {
-        mutationExecutor: MockMutationExecutor;
-        networkMonitor: MockNetworkMonitor;
-    };
-    /** Tears the test down by resetting the engine and the mocks. Call it when the test finishes. */
-    cleanup: () => void;
-}
-/**
- * Builds a {@link RuntimeContext} with every mock pre-wired and installs it
- * globally through {@link initRuntime}, so code under test reaches the engine
- * the same way it would in production. Returns the context, the mock handles,
- * and a cleanup function to call when the test finishes.
- *
- * @example
- * ```ts
- * const { context, mocks, cleanup } = createTestContext();
- * // ... run tests using mocks.mutationExecutor, mocks.networkMonitor
- * cleanup();
- * ```
- */
-export declare function createTestContext(options?: TestContextOptions): TestContextResult;

package/dist/testing/mocks/MockSyncContext.js

@@ -1,72 +0,0 @@
-/**
- * Assembles a ready-to-use {@link RuntimeContext} for tests. The context
- * bundles every dependency the engine needs — logger, network monitor,
- * mutation executor, and configuration — so a test can start the engine
- * without a real backend. {@link createTestContext} is the entry point: it
- * wires the mocks, installs the context globally through {@link initRuntime},
- * and returns handles to each mock for assertions.
- */
-import { noopLogger, noopObservability, noopAnalytics, defaultSessionErrorDetector, emptyConfig, } from '../../RuntimeContext.js';
-import { initRuntime, resetRuntime } from '../../context.js';
-import { ModelRegistry, getActiveRegistry, setActiveRegistry, hasActiveRegistry, clearActiveRegistry, } from '../../ModelRegistry.js';
-import { registerTestModels } from '../fixtures/models.js';
-import { MockMutationExecutor } from './MockMutationExecutor.js';
-import { MockNetworkMonitor } from './MockNetworkMonitor.js';
-/**
- * Builds a {@link RuntimeContext} with every mock pre-wired and installs it
- * globally through {@link initRuntime}, so code under test reaches the engine
- * the same way it would in production. Returns the context, the mock handles,
- * and a cleanup function to call when the test finishes.
- *
- * @example
- * ```ts
- * const { context, mocks, cleanup } = createTestContext();
- * // ... run tests using mocks.mutationExecutor, mocks.networkMonitor
- * cleanup();
- * ```
- */
-export function createTestContext(options = {}) {
-    const mutationExecutor = new MockMutationExecutor(options.mutationExecutorOptions);
-    const networkMonitor = new MockNetworkMonitor(!options.startOffline);
-    const config = {
-        ...emptyConfig,
-        ...options.config,
-        // Merge maps/sets properly if overrides provided
-        modelCreatePriority: options.config?.modelCreatePriority ?? emptyConfig.modelCreatePriority,
-    };
-    const context = {
-        getModelMetadata: (name) => (hasActiveRegistry() ? getActiveRegistry().getMetadata(name) : undefined),
-        logger: options.logger ?? noopLogger,
-        observability: options.observability ?? noopObservability,
-        analytics: noopAnalytics,
-        sessionErrorDetector: options.sessionErrorDetector ?? defaultSessionErrorDetector,
-        onlineStatus: networkMonitor,
-        mutationExecutor,
-        config,
-    };
-    initRuntime(context);
-    // Bootstrap a default ModelRegistry with test models if none is active.
-    // Tests that manage their own registry call setActiveRegistry before this.
-    const bootstrappedRegistry = !hasActiveRegistry();
-    if (bootstrappedRegistry) {
-        const defaultRegistry = new ModelRegistry();
-        setActiveRegistry(defaultRegistry);
-        registerTestModels(defaultRegistry);
-    }
-    return {
-        context,
-        mocks: {
-            mutationExecutor,
-            networkMonitor,
-        },
-        cleanup: () => {
-            resetRuntime();
-            // Leave the active ModelRegistry in place on purpose. Async callbacks
-            // from in-flight transactions can call Model.toJSON() after a test's
-            // teardown has run; keeping the default registry available keeps those
-            // late calls valid, and the next createTestContext simply reuses it.
-            mutationExecutor.reset();
-            networkMonitor.reset();
-        },
-    };
-}

package/dist/testing/mocks/MockSyncStore.d.ts

@@ -1,88 +0,0 @@
-/**
- * An in-memory {@link SyncStoreContract} for tests. It lets you seed rows,
- * read and write them synchronously, and inspect every call the code under
- * test made — all without a real sync backend.
- */
-import type { Model } from '../../Model.js';
-import type { ModelScope } from '../../InstanceCache.js';
-import type { SyncStoreContract } from '../../react/context.js';
-interface QueryOptions<T extends Model> {
-    predicate?: (model: T) => boolean;
-    scope?: ModelScope;
-    orderBy?: keyof T;
-    order?: 'asc' | 'desc';
-    limit?: number;
-    offset?: number;
-}
-interface QueryResult<T extends Model> {
-    data: T[];
-}
-type ModelCtor<T extends Model> = abstract new (...args: never[]) => T;
-/**
- * An in-memory implementation of {@link SyncStoreContract}. Seed rows with
- * {@link MockSyncStore.setModels}, then read and write through the contract
- * methods; every call is recorded on {@link MockSyncStore.calls} so tests can
- * assert on what happened.
- */
-export declare class MockSyncStore implements SyncStoreContract {
-    private byClass;
-    calls: {
-        retrieve: {
-            modelClass: ModelCtor<Model>;
-            id: string;
-        }[];
-        query: {
-            modelClass: ModelCtor<Model>;
-            options?: QueryOptions<Model>;
-        }[];
-        save: Model[];
-        delete: Model[];
-        archive: Model[];
-        unarchive: Model[];
-    };
-    /**
-     * Seed the store with models of a specific class.
-     *
-     * @example
-     * mockStore.setModels(Task, [task1, task2]);
-     */
-    setModels<T extends Model>(modelClass: ModelCtor<T>, models: T[]): void;
-    /**
-     * Adds or replaces a single model, keyed by its id.
-     */
-    addModel<T extends Model>(modelClass: ModelCtor<T>, model: T): void;
-    /**
-     * Remove a model by ID.
-     */
-    removeModel<T extends Model>(modelClass: ModelCtor<T>, id: string): void;
-    /**
-     * Clear all seeded data and call history.
-     */
-    reset(): void;
-    retrieve<T extends Model>(modelClass: ModelCtor<T>, id: string): T | undefined;
-    queryByClass<T extends Model>(modelClass: ModelCtor<T>, options?: QueryOptions<T>): QueryResult<T>;
-    save(model: Model): Promise<void>;
-    delete(model: Model): Promise<void>;
-    archive(model: Model): Promise<void>;
-    unarchive(model: Model): Promise<void>;
-    isReady: boolean;
-    isSyncing: boolean;
-    isOffline: boolean;
-    isReconnecting: boolean;
-    isError: boolean;
-    hasUnsyncedChanges: boolean;
-    syncStatus: {
-        state: "idle";
-        progress: number;
-        pendingChanges: number;
-        isSessionError: boolean;
-    };
-    /** A minimal object pool backing the useEntity and useEntities hooks in tests. */
-    pool: SyncStoreContract['pool'];
-}
-/**
- * Create a new MockSyncStore.
- * Shorthand for `new MockSyncStore()`.
- */
-export declare function createMockSyncStore(): MockSyncStore;
-export {};

package/dist/testing/mocks/MockSyncStore.js

@@ -1,171 +0,0 @@
-/**
- * An in-memory {@link SyncStoreContract} for tests. It lets you seed rows,
- * read and write them synchronously, and inspect every call the code under
- * test made — all without a real sync backend.
- */
-import { ViewRegistry } from '../../core/ViewRegistry.js';
-import { AbloValidationError } from '../../transaction/errors.js';
-/**
- * An in-memory implementation of {@link SyncStoreContract}. Seed rows with
- * {@link MockSyncStore.setModels}, then read and write through the contract
- * methods; every call is recorded on {@link MockSyncStore.calls} so tests can
- * assert on what happened.
- */
-export class MockSyncStore {
-    // Seeded data, keyed by model class
-    byClass = new Map();
-    // Call tracking for assertions
-    calls = {
-        retrieve: [],
-        query: [],
-        save: [],
-        delete: [],
-        archive: [],
-        unarchive: [],
-    };
-    /**
-     * Seed the store with models of a specific class.
-     *
-     * @example
-     * mockStore.setModels(Task, [task1, task2]);
-     */
-    setModels(modelClass, models) {
-        const map = new Map();
-        for (const m of models) {
-            map.set(m.id, m);
-        }
-        this.byClass.set(modelClass, map);
-    }
-    /**
-     * Adds or replaces a single model, keyed by its id.
-     */
-    addModel(modelClass, model) {
-        let map = this.byClass.get(modelClass);
-        if (!map) {
-            map = new Map();
-            this.byClass.set(modelClass, map);
-        }
-        map.set(model.id, model);
-    }
-    /**
-     * Remove a model by ID.
-     */
-    removeModel(modelClass, id) {
-        this.byClass.get(modelClass)?.delete(id);
-    }
-    /**
-     * Clear all seeded data and call history.
-     */
-    reset() {
-        this.byClass.clear();
-        this.calls = {
-            retrieve: [],
-            query: [],
-            save: [],
-            delete: [],
-            archive: [],
-            unarchive: [],
-        };
-    }
-    // ── SyncStoreContract implementation ──────────────────────────────────
-    retrieve(modelClass, id) {
-        this.calls.retrieve.push({ modelClass: modelClass, id });
-        return this.byClass.get(modelClass)?.get(id);
-    }
-    queryByClass(modelClass, options) {
-        this.calls.query.push({
-            modelClass: modelClass,
-            options: options,
-        });
-        const map = this.byClass.get(modelClass);
-        if (!map) {
-            return { data: [] };
-        }
-        let data = Array.from(map.values());
-        // Apply predicate
-        if (options?.predicate) {
-            data = data.filter(options.predicate);
-        }
-        // Apply ordering
-        if (options?.orderBy) {
-            const key = options.orderBy;
-            const order = options.order ?? 'asc';
-            data.sort((a, b) => {
-                const av = a[key];
-                const bv = b[key];
-                if (av === bv)
-                    return 0;
-                const cmp = av < bv ? -1 : 1;
-                return order === 'asc' ? cmp : -cmp;
-            });
-        }
-        // Apply pagination
-        if (options?.offset) {
-            data = data.slice(options.offset);
-        }
-        if (options?.limit !== undefined) {
-            data = data.slice(0, options.limit);
-        }
-        return { data };
-    }
-    async save(model) {
-        this.calls.save.push(model);
-        // Store the model under its constructor so a later retrieve or query
-        // returns it.
-        const ctor = model.constructor;
-        this.addModel(ctor, model);
-    }
-    async delete(model) {
-        this.calls.delete.push(model);
-        const ctor = model.constructor;
-        this.removeModel(ctor, model.id);
-    }
-    async archive(model) {
-        this.calls.archive.push(model);
-    }
-    async unarchive(model) {
-        this.calls.unarchive.push(model);
-    }
-    // Sync-status getters default to "ready, idle". Tests that exercise
-    // offline/reconnect flows can set these before rendering.
-    isReady = true;
-    isSyncing = false;
-    isOffline = false;
-    isReconnecting = false;
-    isError = false;
-    hasUnsyncedChanges = false;
-    syncStatus = {
-        state: 'idle',
-        progress: 100,
-        pendingChanges: 0,
-        isSessionError: false,
-    };
-    /** A minimal object pool backing the useEntity and useEntities hooks in tests. */
-    pool = {
-        get: (id) => {
-            for (const models of this.byClass.values()) {
-                const model = models.get(id);
-                if (model)
-                    return model;
-            }
-            return undefined;
-        },
-        getByTypeName: (_typename) => [],
-        getByForeignKey: () => [],
-        createFromData: () => null,
-        hasForeignKeyIndex: () => false,
-        createView: () => {
-            throw new AbloValidationError('MockSyncStore does not support createView', {
-                code: 'mock_unsupported_operation',
-            });
-        },
-        viewRegistry: new ViewRegistry(),
-    };
-}
-/**
- * Create a new MockSyncStore.
- * Shorthand for `new MockSyncStore()`.
- */
-export function createMockSyncStore() {
-    return new MockSyncStore();
-}

package/dist/testing/mocks/MockWebSocket.d.ts

@@ -1,71 +0,0 @@
-/**
- * A controllable WebSocket stand-in for sync engine tests. It reproduces the
- * event interface of the real connection without opening a socket, so tests
- * can drive connection changes, deltas, and bootstrap hints by hand.
- */
-import type { SyncActionType } from '../../stores/syncAction.js';
-import type { BootstrapReason } from '../../transaction/wire/bootstrapReason.js';
-/** The shape of a single delta — one change the server pushes to the client. */
-export interface MockDelta {
-    id: number;
-    modelName: string;
-    modelId: string;
-    action: SyncActionType;
-    data: Record<string, unknown>;
-}
-/**
- * A hint from the server that the client has fallen too far behind and should
- * rebuild its data from scratch rather than catch up one delta at a time.
- */
-export interface MockBootstrapHint {
-    reason: BootstrapReason;
-    tables?: string[];
-    staleTables?: string[];
-}
-type EventHandler = (...args: unknown[]) => void;
-/**
- * A controllable, event-based stand-in for the sync engine's WebSocket
- * connection. Subscribe with {@link MockWebSocket.on} exactly as production
- * code does, then use the `simulate*` and `receive*` methods to push
- * connection changes, deltas, and bootstrap hints. Every event the mock emits
- * is recorded on {@link MockWebSocket.emittedEvents} for assertions.
- */
-export declare class MockWebSocket {
-    private _connected;
-    private _sessionError;
-    private _listeners;
-    /** Every event the mock has emitted, in order, for assertions. */
-    readonly emittedEvents: {
-        type: string;
-        data: unknown;
-    }[];
-    get connected(): boolean;
-    get sessionError(): boolean;
-    on(event: string, handler: EventHandler): () => void;
-    private emit;
-    /** Fires a successful connection, emitting the `connected` event. */
-    simulateConnect(): void;
-    /** Drops the connection, emitting the `disconnected` event. */
-    simulateDisconnect(): void;
-    /** Emits a `reconnecting` event carrying the attempt number and retry delay. */
-    simulateReconnecting(attempt: number, delay: number): void;
-    /** Emits a `session_error` event, as when the server rejects the session as unauthorized. The code defaults to 401. */
-    simulateSessionError(code?: number): void;
-    /** Emits a `reconnect_failed` event, signaling the client gave up after exhausting its retries. */
-    simulateReconnectFailed(): void;
-    /** Delivers a single delta, emitting a `delta` event as if the server had sent it. */
-    receiveDelta(delta: MockDelta): void;
-    /** Delivers a batch of deltas, emitting a `delta_batch` event. */
-    receiveDeltas(deltas: MockDelta[]): void;
-    /** Emits a `bootstrap_required` hint, telling the client to rebuild its data instead of catching up. */
-    simulateBootstrapHint(hint: MockBootstrapHint): void;
-    /** Emits a `presence_update` event carrying the given payload. */
-    simulatePresenceUpdate(data: Record<string, unknown>): void;
-    /** Returns the payloads of every emitted event of the given type, in order. */
-    getEvents(type: string): unknown[];
-    /** Reports whether an event of the given type has been emitted. */
-    hasEmitted(type: string): boolean;
-    /** Clears connection state, listeners, and the record of emitted events. */
-    reset(): void;
-}
-export {};

package/dist/testing/mocks/MockWebSocket.js

@@ -1,118 +0,0 @@
-/**
- * A controllable WebSocket stand-in for sync engine tests. It reproduces the
- * event interface of the real connection without opening a socket, so tests
- * can drive connection changes, deltas, and bootstrap hints by hand.
- */
-/**
- * A controllable, event-based stand-in for the sync engine's WebSocket
- * connection. Subscribe with {@link MockWebSocket.on} exactly as production
- * code does, then use the `simulate*` and `receive*` methods to push
- * connection changes, deltas, and bootstrap hints. Every event the mock emits
- * is recorded on {@link MockWebSocket.emittedEvents} for assertions.
- */
-export class MockWebSocket {
-    _connected = false;
-    _sessionError = false;
-    _listeners = new Map();
-    /** Every event the mock has emitted, in order, for assertions. */
-    emittedEvents = [];
-    get connected() {
-        return this._connected;
-    }
-    get sessionError() {
-        return this._sessionError;
-    }
-    // ─────────────────────────────────────────────
-    // Event subscription (matches the real connection's API)
-    // ─────────────────────────────────────────────
-    on(event, handler) {
-        if (!this._listeners.has(event)) {
-            this._listeners.set(event, new Set());
-        }
-        this._listeners.get(event).add(handler);
-        return () => {
-            this._listeners.get(event)?.delete(handler);
-        };
-    }
-    emit(event, ...args) {
-        this.emittedEvents.push({ type: event, data: args[0] });
-        const handlers = this._listeners.get(event);
-        if (handlers) {
-            for (const handler of handlers) {
-                handler(...args);
-            }
-        }
-    }
-    // ─────────────────────────────────────────────
-    // Test control: connection lifecycle
-    // ─────────────────────────────────────────────
-    /** Fires a successful connection, emitting the `connected` event. */
-    simulateConnect() {
-        this._connected = true;
-        this._sessionError = false;
-        this.emit('connected');
-    }
-    /** Drops the connection, emitting the `disconnected` event. */
-    simulateDisconnect() {
-        this._connected = false;
-        this.emit('disconnected');
-    }
-    /** Emits a `reconnecting` event carrying the attempt number and retry delay. */
-    simulateReconnecting(attempt, delay) {
-        this.emit('reconnecting', { attempt, delay });
-    }
-    /** Emits a `session_error` event, as when the server rejects the session as unauthorized. The code defaults to 401. */
-    simulateSessionError(code = 401) {
-        this._sessionError = true;
-        this._connected = false;
-        this.emit('session_error', { code });
-    }
-    /** Emits a `reconnect_failed` event, signaling the client gave up after exhausting its retries. */
-    simulateReconnectFailed() {
-        this._connected = false;
-        this.emit('reconnect_failed');
-    }
-    // ─────────────────────────────────────────────
-    // Test control: delta injection
-    // ─────────────────────────────────────────────
-    /** Delivers a single delta, emitting a `delta` event as if the server had sent it. */
-    receiveDelta(delta) {
-        this.emit('delta', delta);
-    }
-    /** Delivers a batch of deltas, emitting a `delta_batch` event. */
-    receiveDeltas(deltas) {
-        this.emit('delta_batch', deltas);
-    }
-    // ─────────────────────────────────────────────
-    // Test control: bootstrap hints
-    // ─────────────────────────────────────────────
-    /** Emits a `bootstrap_required` hint, telling the client to rebuild its data instead of catching up. */
-    simulateBootstrapHint(hint) {
-        this.emit('bootstrap_required', hint);
-    }
-    // ─────────────────────────────────────────────
-    // Test control: presence
-    // ─────────────────────────────────────────────
-    /** Emits a `presence_update` event carrying the given payload. */
-    simulatePresenceUpdate(data) {
-        this.emit('presence_update', data);
-    }
-    // ─────────────────────────────────────────────
-    // Assertions
-    // ─────────────────────────────────────────────
-    /** Returns the payloads of every emitted event of the given type, in order. */
-    getEvents(type) {
-        return this.emittedEvents.filter((e) => e.type === type).map((e) => e.data);
-    }
-    /** Reports whether an event of the given type has been emitted. */
-    hasEmitted(type) {
-        return this.emittedEvents.some((e) => e.type === type);
-    }
-    /** Clears connection state, listeners, and the record of emitted events. */
-    reset() {
-        this._connected = false;
-        this._sessionError = false;
-        this._listeners.clear();
-        this.emittedEvents.length = 0;
-    }
-}

package/dist/transaction/ablo.d.ts

@@ -1,88 +0,0 @@
-/**
- * `Ablo` — the entry point to the coordination layer.
- *
- * The factory constructs the stateless client: typed model resources, commits,
- * claims, and session minting over request/response HTTP. It holds no socket,
- * no store, and no local copy of anything — the bearer credential is the
- * identity and the server resolves it on every request. This is the client a
- * server-side actor installs: an agent, a worker, a cron job, a route handler.
- *
- * ```ts
- * import { Ablo } from '@abloatai/ablo';
- * import { schema } from './schema';
- *
- * const ablo = Ablo({ schema, apiKey: process.env.ABLO_API_KEY, transport: 'http' });
- * await ablo.tasks.update({ id: taskId, data: { status: 'done' } });
- * ```
- *
- * The reactive materialiser — local store, live queries, presence rendering —
- * is the consumer package's entry point (`@abloatai/ablo`), which layers
- * above this one and shares the same `ablo.<model>` surface (ADR 0016).
- */
-import { type AbloHttpClient, type AbloHttpClientOptions } from './transport/httpClient.js';
-import type { SchemaRecord } from './schema/schema.js';
-import type * as _Streams from './types/streams.js';
-import type * as _SchemaTypes from './schema/schema.js';
-import type * as _Global from './types/global.js';
-import type * as _Policy from './policy/types.js';
-import type * as _Http from './resources/httpResources.js';
-/**
- * Create a coordination-layer client in one call.
- *
- * The core carries one transport today — request/response HTTP — so
- * `transport: 'http'` is accepted for symmetry with the reactive package's
- * factory and may be omitted. The duplex transport joins this slot when the
- * socket carve lands (ADR 0016, follow-up 3a).
- */
-export declare function Ablo<const S extends SchemaRecord>(options: AbloHttpClientOptions<S> & {
-    transport?: 'http';
-}): AbloHttpClient<S>;
-export declare namespace Ablo {
-    type ClaimTarget = _Streams.ClaimTarget;
-    type PresenceTarget = _Streams.PresenceTarget;
-    type Duration = _Streams.Duration;
-    type Peer = _Streams.Peer;
-    type Activity = _Streams.Activity;
-    type Claim = _Streams.Claim;
-    type ClaimHeartbeat = _Streams.ClaimHeartbeat;
-    type ClaimHeartbeatOptions = _Streams.ClaimHeartbeatOptions;
-    namespace Claim {
-        type Held<T = Record<string, unknown>, M = _Global.ResolveClaimMeta> = _Streams.HeldClaim<T, M>;
-        type WaitOptions = _Streams.ClaimWaitOptions;
-        type LeaseOptions = _Streams.ClaimLeaseOptions;
-    }
-    type Schema<S extends _SchemaTypes.SchemaRecord = _SchemaTypes.SchemaRecord> = _SchemaTypes.Schema<S>;
-    /**
-     * The schema this program has registered via `interface Register { Schema }`
-     * (falls back to a loose shape when unregistered). Use it where shared code
-     * needs "this app's schema" without importing a specific one.
-     */
-    type ResolveSchema = _Global.ResolveSchema;
-    /**
-     * The claim metadata shape this program has registered via
-     * `interface Register { ClaimMeta }` (falls back to a loose record when
-     * unregistered). Every claim surface reads `target.meta` as this.
-     */
-    type ResolveClaimMeta = _Global.ResolveClaimMeta;
-    namespace Schema {
-        type Model<S extends _SchemaTypes.Schema, K extends keyof S['models']> = _SchemaTypes.Model<S, K>;
-        type InferCreate<S extends _SchemaTypes.Schema, K extends keyof S['models']> = _SchemaTypes.InferCreate<S, K>;
-        type InferModelNames<S extends _SchemaTypes.Schema> = _SchemaTypes.InferModelNames<S>;
-    }
-    type Conflict = _Policy.Conflict;
-    namespace Conflict {
-        type Kind = _Policy.ConflictKind;
-        type Operation = _Policy.ConflictOperation;
-        type Decision = _Policy.ConflictDecision;
-        type Policy = _Policy.ConflictPolicy;
-        type Axis = _Policy.ConflictAxis;
-    }
-    namespace Commit {
-        type Wait = _Http.CommitWait;
-        type OperationAction = _Http.ModelOperationAction;
-        type OperationInput = _Http.CommitOperationInput;
-        type CreateOptions = _Http.CommitCreateOptions;
-        type Receipt = _Http.CommitReceipt;
-        type Client = _Http.CommitResource;
-    }
-}