qarpeo 0.0.0-alpha.10

package/dist/runtime/types/drizzle.d.ts

@@ -0,0 +1,13 @@
+import type { AnyRelations, defineRelations, ExtractTablesFromSchema } from "drizzle-orm";
+import type { DrizzleD1Database } from "drizzle-orm/d1";
+import type { D1Database } from "./d1";
+/**
+ * Derives the `TRelations` type that Drizzle RC infers when you call `defineRelations(schema)` with
+ * no explicit relation config — i.e. every table is included but no foreign-key relations are
+ * declared yet. This gives `db.query.<table>.findMany()` full type-safety without any cast.
+ */
+export type InferDrizzleRelations<TSchema extends Record<string, unknown>> = ReturnType<typeof defineRelations<ExtractTablesFromSchema<TSchema>>>;
+export type QarpeoDrizzleDB<TRelations extends AnyRelations = AnyRelations> = DrizzleD1Database<TRelations> & {
+    /** Access the raw underlying Cloudflare D1Database binding. */
+    raw(bindingName?: string): D1Database;
+};

package/dist/runtime/types/durable-object.d.ts

@@ -0,0 +1,51 @@
+/** Cloudflare Durable Objects types for Qarpeo Realtime. */
+export interface DurableObjectId {
+    toString(): string;
+    equals(other: DurableObjectId): boolean;
+    readonly name?: string;
+}
+export interface DurableObjectStub {
+    readonly id: DurableObjectId;
+    readonly name?: string;
+    fetch(request: Request | string, init?: RequestInit): Promise<Response>;
+}
+export interface DurableObjectNamespace {
+    newUniqueId(options?: {
+        jurisdiction?: string;
+    }): DurableObjectId;
+    idFromName(name: string): DurableObjectId;
+    idFromString(id: string): DurableObjectId;
+    get(id: DurableObjectId): DurableObjectStub;
+}
+export interface DurableObjectStorage {
+    get<T = unknown>(key: string): Promise<T | undefined>;
+    get<T = unknown>(keys: string[]): Promise<Map<string, T>>;
+    put<T = unknown>(key: string, value: T): Promise<void>;
+    put<T = unknown>(entries: Record<string, T>): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    delete(keys: string[]): Promise<number>;
+    deleteAll(): Promise<void>;
+    list<T = unknown>(options?: {
+        start?: string;
+        startAfter?: string;
+        end?: string;
+        prefix?: string;
+        reverse?: boolean;
+        limit?: number;
+    }): Promise<Map<string, T>>;
+    transaction<T>(closure: (txn: DurableObjectStorage) => Promise<T>): Promise<T>;
+    setAlarm?(scheduledTime: number | Date): Promise<void>;
+    getAlarm?(): Promise<number | null>;
+    deleteAlarm?(): Promise<void>;
+}
+export interface DurableObjectState {
+    readonly id: DurableObjectId;
+    readonly storage: DurableObjectStorage;
+    waitUntil(promise: Promise<unknown>): void;
+    blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+    acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+    getWebSockets(tag?: string): WebSocket[];
+    setWebSocketAutoResponse?(maybeReqResp?: unknown): void;
+    getWebSocketAutoResponse?(): unknown;
+    getWebSocketAutoResponseTimestamp?(ws: WebSocket): Date | null;
+}

package/dist/runtime/types/email.d.ts

@@ -0,0 +1,66 @@
+import type { CFEvent } from "./index";
+/** Parsed sender identity for UI selection, multi-inbox routing, and reply formatting. */
+export interface EmailSenderIdentity {
+    /** Identifier key (e.g. 'default', 'support', 'billing', 'alerts') */
+    key: string;
+    /** Clean email address (e.g. 'support@myapp.com') */
+    address: string;
+    /** Display name if present (e.g. 'Support Team') */
+    name?: string;
+    /** Full RFC formatted label (e.g. 'Support Team [support@myapp.com](mailto:support@myapp.com)') */
+    label: string;
+}
+/** Options for sending transactional emails via Cloudflare send_email or dev interceptor. */
+export interface SendEmailOptions {
+    /** Recipient email address or array of recipient addresses. */
+    to: string | string[];
+    /**
+     * Sender email address (e.g. 'noreply@myapp.com' or 'MyApp
+     * [noreply@myapp.com](mailto:noreply@myapp.com)'). If omitted, falls back to `QARPEO_EMAIL_FROM`
+     * or the configured site email.
+     */
+    from?: string;
+    /** Email subject line. */
+    subject: string;
+    /** Plain-text version of the email body. */
+    text?: string;
+    /** HTML formatted version of the email body. */
+    html?: string;
+    /** Carbon copy recipient(s). */
+    cc?: string | string[];
+    /** Blind carbon copy recipient(s). */
+    bcc?: string | string[];
+    /** Reply-To email address. */
+    replyTo?: string;
+    /** Custom RFC 2822 email headers. */
+    headers?: Record<string, string>;
+    /** Optional Cloudflare send_email binding name override (defaults to 'EMAIL'). */
+    binding?: string;
+    /** Optional event context for resolving Cloudflare worker environment. */
+    event?: CFEvent;
+}
+/** Result returned by `sendEmail()`. */
+export interface SendEmailResult {
+    /** Whether the email was sent or accepted by the dev mailbox interceptor. */
+    success: boolean;
+    /** Generated unique message identifier (Message-ID). */
+    id: string;
+    /** Optional status or diagnostic message. */
+    message?: string;
+}
+/** Raw Cloudflare SendEmail binding interface available in the Worker environment. */
+export interface SendEmailBinding {
+    /** Sends an EmailMessage through Cloudflare's email delivery infrastructure. */
+    send(message: any): Promise<void>;
+    [key: string]: any;
+}
+/** Typed client interface for Cloudflare transactional email. */
+export interface QarpeoEmail {
+    /**
+     * Send a transactional email. In dev mode, intercepts and formats output to the terminal console.
+     * In production, sends via Cloudflare's native `send_email` Workers binding.
+     */
+    send(options: SendEmailOptions): Promise<SendEmailResult>;
+    /** Access the raw underlying Cloudflare `send_email` binding. */
+    raw(bindingName?: string): SendEmailBinding;
+}

package/dist/runtime/types/hyperdrive.d.ts

@@ -0,0 +1,18 @@
+export interface HyperdriveBinding {
+    /** The complete connection URI routed through Hyperdrive's global connection pool. */
+    readonly connectionString: string;
+    /** The host of the Hyperdrive proxy server. */
+    readonly host: string;
+    /** The port of the Hyperdrive proxy server. */
+    readonly port: number;
+    /** The database username. */
+    readonly user: string;
+    /** The database password. */
+    readonly password: string;
+    /** The database name. */
+    readonly database: string;
+}
+export interface QarpeoHyperdrive extends HyperdriveBinding {
+    /** Access the raw underlying Cloudflare Hyperdrive binding. */
+    raw(bindingName?: string): HyperdriveBinding;
+}

package/dist/runtime/types/imports.d.ts

@@ -0,0 +1,58 @@
+declare const $fetch: any
+declare const useAsyncData: any
+declare const useRuntimeConfig: (event?: any) => any
+declare const defineNuxtPlugin: any
+declare const useRouter: any
+
+declare global {
+  const getAuthSession: (event: any) => Promise<any>
+  const setAuthSession: (event: any, session: any, config?: any) => Promise<any>
+  const replaceAuthSession: (event: any, session: any, config?: any) => Promise<any>
+  const clearAuthSession: (event: any, config?: any) => Promise<boolean>
+  const requireAuthSession: (event: any, opts?: any) => Promise<any>
+  const getUserSession: (event: any) => Promise<any>
+  const setUserSession: (event: any, session: any, config?: any) => Promise<any>
+  const replaceUserSession: (event: any, session: any, config?: any) => Promise<any>
+  const clearUserSession: (event: any, config?: any) => Promise<boolean>
+  const requireUserSession: (event: any, opts?: any) => Promise<any>
+}
+
+declare module "#qarpeo/agents-registry" {
+  const def: any
+  export default def
+}
+
+declare module "#qarpeo/queue-consumer" {
+  const handler: any
+  export default handler
+}
+
+declare module "#app" {
+  export const useRuntimeConfig: any
+  export const useAsyncData: any
+  export const navigateTo: any
+  export const defineNuxtRouteMiddleware: any
+  export const createError: any
+  export const $fetch: any
+}
+
+declare module "#imports" {
+  export const useAuth: any
+  export const useUserSession: any
+  export const getAuthSession: any
+  export const setAuthSession: any
+  export const replaceAuthSession: any
+  export const clearAuthSession: any
+  export const requireAuthSession: any
+  export const getUserSession: any
+  export const setUserSession: any
+  export const replaceUserSession: any
+  export const clearUserSession: any
+  export const requireUserSession: any
+  export const useRuntimeConfig: any
+  export const useNitroApp: any
+  export const navigateTo: any
+  export const defineNuxtRouteMiddleware: any
+  export const createError: any
+  export const $fetch: any
+}

package/dist/runtime/types/index.d.ts

@@ -0,0 +1,156 @@
+import type { RequestEvent } from "nuxt/server";
+export * from "./d1";
+export * from "./r2";
+export * from "./drizzle";
+export * from "./email";
+export * from "./ai";
+export * from "./vectorize";
+export * from "./queue";
+export * from "./analytics";
+export * from "./ratelimit";
+export * from "./hyperdrive";
+export * from "./browser";
+export * from "./auth";
+export * from "./durable-object";
+/** Cloudflare Execution Context for waitUntil and passThroughOnException. */
+export interface CFExecutionContext {
+    waitUntil(promise: Promise<any>): void;
+    passThroughOnException(): void;
+    [key: string]: any;
+}
+/** Cloudflare environment and execution context container attached to events. */
+export interface CloudflareEventContext {
+    env: Record<string, any>;
+    context?: CFExecutionContext;
+    [key: string]: any;
+}
+/** Context container found on Nuxt 5 `RequestEvent`, H3 `H3Event`, and Nitro events. */
+export interface CFEventContext {
+    cloudflare?: CloudflareEventContext;
+    [key: string]: any;
+}
+/**
+ * Server event type: supports modern Nuxt 5 `RequestEvent`, Nitro / H3 events, and objects with a
+ * request context container.
+ */
+export type CFEvent = RequestEvent | {
+    context?: CFEventContext;
+    env?: Record<string, any>;
+    platform?: {
+        env?: Record<string, any>;
+        context?: any;
+    };
+    [key: string]: any;
+};
+export interface KVNamespaceListKey<Metadata = unknown> {
+    name: string;
+    expiration?: number;
+    metadata?: Metadata;
+}
+export interface KVNamespaceListResult<Metadata = unknown> {
+    keys: KVNamespaceListKey<Metadata>[];
+    list_complete: boolean;
+    cursor?: string;
+}
+export interface KVNamespacePutOptions {
+    expiration?: number;
+    expirationTtl?: number;
+    metadata?: unknown;
+}
+export interface KVNamespace {
+    get(key: string, options?: {
+        type?: "text" | "json" | "arrayBuffer" | "stream";
+    }): Promise<any>;
+    getWithMetadata<M = unknown>(key: string, options?: {
+        type?: "text" | "json" | "arrayBuffer" | "stream";
+    }): Promise<{
+        value: any;
+        metadata: M | null;
+    }>;
+    put(key: string, value: string | ArrayBuffer | ReadableStream, options?: KVNamespacePutOptions): Promise<void>;
+    delete(key: string): Promise<void>;
+    list(options?: {
+        prefix?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<KVNamespaceListResult<unknown>>;
+}
+export interface KVSetOptions {
+    /** Time to live in seconds (minimum 60 for Cloudflare KV) */
+    ttl?: number;
+    /** Alias for ttl (seconds) */
+    ex?: number;
+    /** Absolute Unix timestamp (seconds) when the key should expire */
+    expiration?: number;
+    /** Arbitrary metadata attached alongside the value in Cloudflare KV */
+    metadata?: unknown;
+}
+export interface KVGetOptions {
+    /**
+     * Return type for the value:
+     *
+     * - `"json"` (default): auto-deserializes JSON back to the original type
+     * - `"text"`: returns the raw stored string
+     * - `"arrayBuffer"`: returns raw bytes as ArrayBuffer
+     * - `"stream"`: returns a ReadableStream
+     */
+    type?: "json" | "text" | "arrayBuffer" | "stream";
+    /**
+     * Time-to-live in seconds for edge PoP cache caching this KV read.
+     * Minimum is 60 seconds per Cloudflare KV specifications.
+     */
+    cacheTtl?: number;
+}
+export interface KVListOptions {
+    /** Only return keys with this prefix */
+    prefix?: string;
+    /** Maximum number of keys per page (max 1000, default 1000) */
+    limit?: number;
+    /** Pagination cursor from a previous list() call */
+    cursor?: string;
+}
+export interface QarpeoKV {
+    /**
+     * Get a value from KV. Defaults to JSON deserialization. Pass `{ type: "text" | "arrayBuffer" |
+     * "stream" }` for binary/raw access.
+     *
+     * @template T Expected return type (default: `unknown`)
+     */
+    get<T = unknown>(key: string, options?: KVGetOptions): Promise<T | null>;
+    /** Store a value in KV. Objects and arrays are auto-serialized to JSON. Strings are stored as-is. */
+    set(key: string, value: unknown, options?: KVSetOptions): Promise<void>;
+    /** Check if a key exists in KV */
+    has(key: string): Promise<boolean>;
+    /** Delete a key from KV */
+    delete(key: string): Promise<boolean>;
+    /** Alias for delete */
+    del(key: string): Promise<boolean>;
+    /**
+     * List all keys, transparently handling CF KV's 1000-key cursor pagination. Pass a `prefix` to
+     * filter keys by prefix.
+     */
+    keys(prefix?: string): Promise<string[]>;
+    /**
+     * Raw paginated list — returns one page of keys plus a cursor for continuation. Use this when you
+     * need manual pagination control.
+     */
+    list(options?: KVListOptions): Promise<KVNamespaceListResult<unknown>>;
+    /**
+     * Delete all keys (or all keys matching a prefix). Handles pagination internally; deletes
+     * concurrently.
+     */
+    clear(prefix?: string): Promise<void>;
+    /**
+     * Get a value together with its metadata in a single CF KV round-trip. This is a Cloudflare
+     * KV-native feature — no other KV provider supports it.
+     *
+     * @template T Value type
+     * @template M Metadata type
+     */
+    getWithMetadata<T = unknown, M = unknown>(key: string, options?: KVGetOptions): Promise<{
+        value: T | null;
+        metadata: M | null;
+    }>;
+    /** Access the raw underlying Cloudflare KVNamespace binding */
+    raw(bindingName?: string): KVNamespace;
+}

package/dist/runtime/types/index.mjs

@@ -0,0 +1,13 @@
+export * from "./d1.mjs";
+export * from "./r2.mjs";
+export * from "./drizzle.mjs";
+export * from "./email.mjs";
+export * from "./ai.mjs";
+export * from "./vectorize.mjs";
+export * from "./queue.mjs";
+export * from "./analytics.mjs";
+export * from "./ratelimit.mjs";
+export * from "./hyperdrive.mjs";
+export * from "./browser.mjs";
+export * from "./auth.mjs";
+export * from "./durable-object.mjs";

package/dist/runtime/types/queue.d.ts

@@ -0,0 +1,67 @@
+export type QueueContentType = "json" | "text" | "bytes" | "v8";
+export interface QueueSendOptions {
+    /** Content type of the message body (default: 'json') */
+    contentType?: QueueContentType;
+    /** Delay delivery of this message in seconds (default: 0) */
+    delaySeconds?: number;
+}
+export interface MessageSendRequest<T = any> {
+    /** The message payload */
+    body: T;
+    /** Content type of the message body */
+    contentType?: QueueContentType;
+    /** Delay delivery of this message in seconds */
+    delaySeconds?: number;
+}
+export interface QueueSendBatchOptions {
+    /** Delay delivery of all messages in this batch in seconds */
+    delaySeconds?: number;
+}
+export interface QueueMessage<T = any> {
+    /** Unique ID of the message */
+    readonly id: string;
+    /** Timestamp when the message was initially published */
+    readonly timestamp: Date;
+    /** The message payload */
+    readonly body: T;
+    /** Number of times delivery has been attempted */
+    readonly attempts: number;
+    /** Acknowledge successful processing of this message */
+    ack(): void;
+    /** Mark message as failed and retry delivery after optional delay */
+    retry(options?: {
+        delaySeconds?: number;
+    }): void;
+}
+export interface QueueMessageBatch<T = any> {
+    /** Name of the queue that produced this batch */
+    readonly queue: string;
+    /** Array of messages contained in this batch */
+    readonly messages: readonly QueueMessage<T>[];
+    /** Acknowledge all messages in the batch at once */
+    ackAll(): void;
+    /** Retry all messages in the batch at once */
+    retryAll(options?: {
+        delaySeconds?: number;
+    }): void;
+}
+export interface Queue<T = any> {
+    /**
+     * Send a single message to the queue.
+     *
+     * @param message The message payload
+     * @param options Optional content type or delay settings
+     */
+    send(message: T, options?: QueueSendOptions): Promise<void>;
+    /**
+     * Send a batch of messages to the queue in a single network request.
+     *
+     * @param messages Iterable of message requests
+     * @param options Optional batch delay settings
+     */
+    sendBatch(messages: Iterable<MessageSendRequest<T>>, options?: QueueSendBatchOptions): Promise<void>;
+}
+export interface QarpeoQueue<T = any> extends Queue<T> {
+    /** Access the raw underlying Cloudflare Queue binding */
+    raw(bindingName?: string): Queue<T>;
+}

package/dist/runtime/types/r2.d.ts

@@ -0,0 +1,108 @@
+import type { CFEvent } from "./index";
+export type BlobAccessTier = "public" | "unlisted" | "private";
+export interface R2HttpMetadata {
+    contentType?: string;
+    contentLanguage?: string;
+    contentDisposition?: string;
+    contentEncoding?: string;
+    cacheControl?: string;
+    cacheExpiry?: Date;
+}
+export interface R2Object {
+    key: string;
+    version: string;
+    size: number;
+    etag: string;
+    httpEtag: string;
+    uploaded: Date;
+    httpMetadata?: R2HttpMetadata;
+    customMetadata?: Record<string, string>;
+    writeHttpMetadata(headers: Headers): void;
+}
+export interface R2ObjectBody extends R2Object {
+    body: ReadableStream;
+    bodyUsed: boolean;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    text(): Promise<string>;
+    json<T = unknown>(): Promise<T>;
+    blob(): Promise<Blob>;
+}
+export interface R2Objects {
+    objects: R2Object[];
+    truncated: boolean;
+    cursor?: string;
+    delimitedPrefixes: string[];
+}
+export interface R2ListOptions {
+    limit?: number;
+    prefix?: string;
+    cursor?: string;
+    delimiter?: string;
+    include?: ("httpMetadata" | "customMetadata")[];
+}
+export interface R2PutOptions {
+    httpMetadata?: R2HttpMetadata | Headers;
+    customMetadata?: Record<string, string>;
+    sha1?: ArrayBuffer | string;
+    sha256?: ArrayBuffer | string;
+    md5?: ArrayBuffer | string;
+}
+export interface R2Bucket {
+    head(key: string): Promise<R2Object | null>;
+    get(key: string, options?: {
+        onlyIf?: Headers;
+    }): Promise<R2ObjectBody | null>;
+    put(key: string, value: ReadableStream | ArrayBuffer | ArrayBufferView | string | Blob | null, options?: R2PutOptions): Promise<R2Object>;
+    delete(keys: string | string[]): Promise<void>;
+    list(options?: R2ListOptions): Promise<R2Objects>;
+}
+export interface BlobPutOptions {
+    contentType?: string;
+    customMetadata?: Record<string, string>;
+    httpMetadata?: R2HttpMetadata;
+}
+export interface BlobServeOptions {
+    cacheControl?: string;
+    contentDisposition?: string;
+}
+export type BlobSize = "100KB" | "250KB" | "500KB" | "1MB" | "2MB" | "5MB" | "10MB" | "25MB" | "50MB" | "100MB" | "250MB" | "500MB" | "1GB" | "2GB" | "5GB" | (string & {}) | number;
+export interface BlobEnsureOptions {
+    maxSize?: BlobSize;
+    types?: string[] | string;
+}
+export interface BlobHandleUploadOptions {
+    formKey?: string;
+    pathname?: string | ((file: File) => string);
+    prefix?: string;
+    ensure?: BlobEnsureOptions;
+    customMetadata?: Record<string, string>;
+}
+export interface R2UploadedPart {
+    partNumber: number;
+    etag: string;
+}
+export interface R2MultipartUpload {
+    key: string;
+    uploadId: string;
+    uploadPart(partNumber: number, value: ReadableStream | ArrayBuffer | ArrayBufferView | string | Blob | Uint8Array): Promise<R2UploadedPart>;
+    abort(): Promise<void>;
+    complete(uploadedParts: R2UploadedPart[]): Promise<R2Object>;
+}
+export interface QarpeoBlob {
+    put(pathname: string, data: ReadableStream | ArrayBuffer | ArrayBufferView | string | Blob | Uint8Array, options?: BlobPutOptions): Promise<R2Object>;
+    get(pathname: string): Promise<R2ObjectBody | null>;
+    text(pathname: string): Promise<string | null>;
+    json<T = unknown>(pathname: string): Promise<T | null>;
+    arrayBuffer(pathname: string): Promise<ArrayBuffer | null>;
+    has(pathname: string): Promise<boolean>;
+    head(pathname: string): Promise<R2Object | null>;
+    delete(pathname: string | string[]): Promise<void>;
+    list(options?: R2ListOptions): Promise<R2Objects>;
+    serve(event: CFEvent, pathname: string, options?: BlobServeOptions): Promise<Response>;
+    handleUpload(event: CFEvent, options?: BlobHandleUploadOptions): Promise<R2Object & {
+        pathname: string;
+    }>;
+    createMultipartUpload(pathname: string, options?: R2PutOptions): Promise<R2MultipartUpload>;
+    resumeMultipartUpload(pathname: string, uploadId: string): R2MultipartUpload;
+    raw(bindingName?: string): R2Bucket;
+}

package/dist/runtime/types/ratelimit.d.ts

@@ -0,0 +1,21 @@
+export interface RateLimitOptions {
+    /** The unique key to rate limit against (e.g. client IP, user ID, route path) */
+    key: string;
+}
+export interface RateLimitResult {
+    /** Whether the request is permitted within the rate limit threshold */
+    success: boolean;
+}
+export interface RateLimiterBinding {
+    /**
+     * Evaluates the rate limit for the specified key.
+     *
+     * @param options The key to limit
+     * @returns Object containing boolean `success` flag
+     */
+    limit(options: RateLimitOptions): Promise<RateLimitResult>;
+}
+export interface QarpeoRateLimit extends RateLimiterBinding {
+    /** Access the raw underlying Cloudflare RateLimiter binding. */
+    raw(bindingName?: string): RateLimiterBinding;
+}

package/dist/runtime/types/vectorize.d.ts

@@ -0,0 +1,74 @@
+export type VectorizeDistanceMetric = "cosine" | "euclidean" | "dot-product";
+export type VectorizeVectorValues = number[] | Float32Array | Float64Array;
+export interface VectorizeVector {
+    /** Unique identifier for the vector */
+    id: string;
+    /** Dense vector embedding values */
+    values: VectorizeVectorValues;
+    /** Optional namespace to group vectors within an index */
+    namespace?: string;
+    /** Optional key-value metadata attached to the vector */
+    metadata?: Record<string, any>;
+}
+export interface VectorizeMatch {
+    /** Vector identifier */
+    id: string;
+    /** Similarity score relative to the query vector */
+    score: number;
+    /** Vector values (if returnValues was set to true) */
+    values?: number[];
+    /** Namespace (if present) */
+    namespace?: string;
+    /** Metadata attached to the vector (if returnMetadata was requested) */
+    metadata?: Record<string, any>;
+}
+export interface VectorizeQueryOptions {
+    /** Maximum number of nearest neighbors to return (default: 5, max: 100) */
+    topK?: number;
+    /** Whether to return the raw vector values in matches (default: false) */
+    returnValues?: boolean;
+    /** Whether and which metadata to return: 'none', 'indexed', 'all', or boolean */
+    returnMetadata?: "none" | "indexed" | "all" | boolean;
+    /** Filter criteria for metadata-based filtering */
+    filter?: Record<string, any>;
+    /** Search only within a specific vector namespace */
+    namespace?: string;
+}
+export interface VectorizeQueryResult {
+    /** Matching vector records sorted by similarity */
+    matches: VectorizeMatch[];
+    /** Number of returned matches */
+    count: number;
+}
+export interface VectorizeAsyncMutation {
+    /** Unique ID tracking the async background mutation in Vectorize */
+    mutationId: string;
+}
+export interface VectorizeIndexDetails {
+    /** Dimensionality of the vectors stored in the index (e.g. 768, 1536) */
+    dimensions: number;
+    /** Distance metric used for nearest-neighbor calculation */
+    metric: VectorizeDistanceMetric;
+    /** Approximate number of vectors stored */
+    vectorCount?: number;
+    /** The most recent mutation ID that has been indexed */
+    processedUpToMutation?: string;
+}
+export interface VectorizeIndex {
+    /** Query the index with a vector to find its nearest neighbors */
+    query(vector: VectorizeVectorValues, options?: VectorizeQueryOptions): Promise<VectorizeQueryResult>;
+    /** Insert new vectors into the index */
+    insert(vectors: VectorizeVector[]): Promise<VectorizeAsyncMutation>;
+    /** Insert or update vectors by ID in the index */
+    upsert(vectors: VectorizeVector[]): Promise<VectorizeAsyncMutation>;
+    /** Delete vectors from the index by their IDs */
+    deleteByIds(ids: string[]): Promise<VectorizeAsyncMutation>;
+    /** Retrieve vectors from the index by their IDs */
+    getByIds(ids: string[]): Promise<VectorizeVector[]>;
+    /** Retrieve index metadata and statistics */
+    describe(): Promise<VectorizeIndexDetails>;
+}
+export interface QarpeoVectorize extends VectorizeIndex {
+    /** Access the raw underlying Cloudflare VectorizeIndex binding */
+    raw(bindingName?: string): VectorizeIndex;
+}