import { dbAcl } from "@vibes.diy/api-types/db-acls";
export type { AccessDescriptor, AccessFunction, Helpers, UserContext } from "@vibes.diy/api-types/access-function";
import { docAccessLevel } from "./doc-access-level.js";
export * from "./img-gen.js";
export { isImgGenVersionAppend } from "./img-gen-append.js";
export { mediaDbName, mediaVersionDocId, mediaPointerDocId, buildMediaVersionDoc, buildMediaPointerDoc } from "./media-doc.js";
export type { MediaVersionDoc, MediaPointerDoc, BuildMediaVersionDocInput, BuildMediaPointerDocInput } from "./media-doc.js";
export { MEDIA_BUILTIN_SOURCE } from "./media-access-fn-source.js";
export type { DbAcl, DbAclSubject } from "./db-acl-eval.js";
export { canRead, canWrite, inGroup, aclAllows } from "./db-acl-eval.js";
export { toRFC2822_32ByteLength } from "./handle-slug.js";
export { dbAcl };
export declare const EvtRuntimeReady: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibe.evt.runtime.ready";
    deps: string[];
    fsId?: string | undefined;
    runtimeId?: string | undefined;
    mirrorProto?: number | undefined;
}, {}>;
export type EvtRuntimeReady = typeof EvtRuntimeReady.infer;
export declare function isEvtRuntimeReady(x: unknown): x is EvtRuntimeReady;
export declare const EvtRuntimeAck: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibe.evt.runtime.ack";
    mirrorProto?: number | undefined;
}, {}>;
export type EvtRuntimeAck = typeof EvtRuntimeAck.infer;
export declare function isEvtRuntimeAck(x: unknown): x is EvtRuntimeAck;
export declare const EvtVibeSetSource: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibe.evt.set-source";
    source: string;
    id?: string | undefined;
    files?: {
        path: string;
        source: string;
    }[] | undefined;
}, {}>;
export type EvtVibeSetSource = typeof EvtVibeSetSource.infer;
export declare function isEvtVibeSetSource(x: unknown): x is EvtVibeSetSource;
export declare const EvtVibeHotSwapError: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibe.evt.hot-swap-error";
    message: string;
    id?: string | undefined;
    runtimeId?: string | undefined;
    restored?: boolean | undefined;
}, {}>;
export type EvtVibeHotSwapError = typeof EvtVibeHotSwapError.infer;
export declare function isEvtVibeHotSwapError(x: unknown): x is EvtVibeHotSwapError;
export declare const EvtVibeHotSwapOk: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibe.evt.hot-swap-ok";
    id: string;
    ok: true;
    runtimeId?: string | undefined;
}, {}>;
export type EvtVibeHotSwapOk = typeof EvtVibeHotSwapOk.infer;
export declare function isEvtVibeHotSwapOk(x: unknown): x is EvtVibeHotSwapOk;
export declare function hotSwapAttemptId(streamId: string, blockId: string, seq: number): string;
export declare const EvtVibeNetworkActive: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibe.evt.network.active";
    count: number;
}, {}>;
export type EvtVibeNetworkActive = typeof EvtVibeNetworkActive.infer;
export declare const EvtVibeNetworkIdle: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibe.evt.network.idle";
}, {}>;
export type EvtVibeNetworkIdle = typeof EvtVibeNetworkIdle.infer;
export declare const JSONSchema: import("arktype/internal/variants/object.ts").ObjectType<{
    type?: string | string[] | undefined;
    title?: string | undefined;
    description?: string | undefined;
    default?: unknown;
    examples?: unknown[] | undefined;
    enum?: unknown[] | undefined;
    const?: unknown;
    minLength?: number | undefined;
    maxLength?: number | undefined;
    pattern?: string | undefined;
    format?: string | undefined;
    minimum?: number | undefined;
    maximum?: number | undefined;
    exclusiveMinimum?: number | undefined;
    exclusiveMaximum?: number | undefined;
    multipleOf?: number | undefined;
    items?: unknown;
    minItems?: number | undefined;
    maxItems?: number | undefined;
    uniqueItems?: boolean | undefined;
    properties?: Record<string, unknown> | undefined;
    required?: string[] | undefined;
    additionalProperties?: boolean | Record<string, unknown> | undefined;
    minProperties?: number | undefined;
    maxProperties?: number | undefined;
    allOf?: unknown[] | undefined;
    anyOf?: unknown[] | undefined;
    oneOf?: unknown[] | undefined;
    not?: unknown;
    $ref?: string | undefined;
    $defs?: Record<string, unknown> | undefined;
}, {}>;
export type JSONSchema = typeof JSONSchema.infer;
export declare const ReqCallAI: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.req.callAI";
    ownerHandle: string;
    appSlug: string;
    prompt: string;
    schema: {
        type?: string | string[] | undefined;
        title?: string | undefined;
        description?: string | undefined;
        default?: unknown;
        examples?: unknown[] | undefined;
        enum?: unknown[] | undefined;
        const?: unknown;
        minLength?: number | undefined;
        maxLength?: number | undefined;
        pattern?: string | undefined;
        format?: string | undefined;
        minimum?: number | undefined;
        maximum?: number | undefined;
        exclusiveMinimum?: number | undefined;
        exclusiveMaximum?: number | undefined;
        multipleOf?: number | undefined;
        items?: unknown;
        minItems?: number | undefined;
        maxItems?: number | undefined;
        uniqueItems?: boolean | undefined;
        properties?: Record<string, unknown> | undefined;
        required?: string[] | undefined;
        additionalProperties?: boolean | Record<string, unknown> | undefined;
        minProperties?: number | undefined;
        maxProperties?: number | undefined;
        allOf?: unknown[] | undefined;
        anyOf?: unknown[] | undefined;
        oneOf?: unknown[] | undefined;
        not?: unknown;
        $ref?: string | undefined;
        $defs?: Record<string, unknown> | undefined;
    };
}, {}>;
export type ReqCallAI = typeof ReqCallAI.infer;
export declare function isReqCallAI(x: unknown): x is ReqCallAI;
export declare const ResOkCallAI: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.callAI";
    status: "ok";
    promptId: string;
    result: string;
}, {}>;
export type ResOkCallAI = typeof ResOkCallAI.infer;
export declare const ResErrorCallAI: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.callAI";
    status: "error";
    message: string;
}, {}>;
export type ResErrorCallAI = typeof ResErrorCallAI.infer;
declare const ResCallAI: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.callAI";
    status: "ok";
    promptId: string;
    result: string;
} | {
    tid: string;
    type: "vibe.res.callAI";
    status: "error";
    message: string;
}, {}>;
export type ResCallAI = typeof ResCallAI.infer;
export declare function isResCallAI(x: unknown): x is ResCallAI;
export declare function isResErrorCallAI(x: unknown): x is ResErrorCallAI;
export declare const NativeInferenceAvailability: import("arktype/internal/variants/object.ts").ObjectType<{
    status: "available" | "deviceNotEligible" | "modelNotReady" | "notEnabled";
}, {}>;
export type NativeInferenceAvailability = typeof NativeInferenceAvailability.infer;
export declare function isNativeInferenceAvailability(x: unknown): x is NativeInferenceAvailability;
export interface NativeInferenceGenerateOpts {
    prompt: string;
    schema: JSONSchema;
    timeoutMs?: number;
}
export interface NativeInference {
    availability(): Promise<NativeInferenceAvailability>;
    generate(opts: NativeInferenceGenerateOpts): Promise<string>;
}
export declare const ImgGenTargetShape: import("arktype/internal/variants/object.ts").ObjectType<{
    dbName: string;
    docId: string;
    regen?: boolean | undefined;
    sourceKey?: string | undefined;
}, {}>;
export declare const ReqImgGen: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.req.imgGen";
    ownerHandle: string;
    appSlug: string;
    prompt: string;
    inputImageBase64?: string | undefined;
    model?: string | undefined;
    target?: {
        dbName: string;
        docId: string;
        regen?: boolean | undefined;
        sourceKey?: string | undefined;
    } | undefined;
}, {}>;
export type ReqImgGen = typeof ReqImgGen.infer;
export declare function isReqImgGen(x: unknown): x is ReqImgGen;
export declare const ImgGenFile: import("arktype/internal/variants/object.ts").ObjectType<{
    uploadId: string;
    cid: string;
    mimeType: string;
    size: number;
}, {}>;
export type ImgGenFile = typeof ImgGenFile.infer;
export declare const ResOkImgGen: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.imgGen";
    status: "ok";
    files: {
        uploadId: string;
        cid: string;
        mimeType: string;
        size: number;
    }[];
    docWritten?: boolean | undefined;
}, {}>;
export type ResOkImgGen = typeof ResOkImgGen.infer;
export declare const ResErrorImgGen: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.imgGen";
    status: "error";
    message: string;
}, {}>;
export type ResErrorImgGen = typeof ResErrorImgGen.infer;
declare const ResImgGen: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.imgGen";
    status: "ok";
    files: {
        uploadId: string;
        cid: string;
        mimeType: string;
        size: number;
    }[];
    docWritten?: boolean | undefined;
} | {
    tid: string;
    type: "vibe.res.imgGen";
    status: "error";
    message: string;
}, {}>;
export type ResImgGen = typeof ResImgGen.infer;
export declare function isResImgGen(x: unknown): x is ResImgGen;
export declare function isResErrorImgGen(x: unknown): x is ResErrorImgGen;
export { type ResPutDoc, type ResGetDoc, type ResGetDocNotFound, type ResQueryDocs, type ResDeleteDoc, type ResSubscribeDocs, type ResListDbNames, type EvtDocChanged, type EvtDocEphemeral, type EvtDocEphemeralDrop, type EvtWriteOutcome, type QueryFilter, type SyncEntry, type ResSyncPull, type ResSyncPush, isResPutDoc, isResGetDoc, isResGetDocNotFound, isResQueryDocs, isResDeleteDoc, isResSubscribeDocs, isResListDbNames, isEvtDocChanged, isEvtDocEphemeral, isEvtDocEphemeralDrop, isEvtWriteOutcome, isSyncEntry, isResSyncPull, isResSyncPush, INTEREST_LEASE_MS, MAX_INTERESTS, } from "@vibes.diy/api-types/app-documents";
export declare const ReqPutDoc: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibes.diy.req-put-doc";
    appSlug: string;
    ownerHandle: string;
    dbName: string;
    doc: Record<string, unknown>;
    docId?: string | undefined;
}, {}>;
export type ReqPutDoc = typeof ReqPutDoc.infer;
export declare function isReqPutDoc(x: unknown): x is ReqPutDoc;
export declare const ReqGetDoc: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibes.diy.req-get-doc";
    appSlug: string;
    ownerHandle: string;
    dbName: string;
    docId: string;
    adminMode?: boolean | undefined;
}, {}>;
export type ReqGetDoc = typeof ReqGetDoc.infer;
export declare function isReqGetDoc(x: unknown): x is ReqGetDoc;
export declare const ReqQueryDocs: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibes.diy.req-query-docs";
    appSlug: string;
    ownerHandle: string;
    dbName: string;
    filter?: {
        field: string;
        key?: unknown;
        keys?: unknown[] | undefined;
        range?: [unknown, unknown] | undefined;
    } | undefined;
    adminMode?: boolean | undefined;
}, {}>;
export type ReqQueryDocs = typeof ReqQueryDocs.infer;
export declare function isReqQueryDocs(x: unknown): x is ReqQueryDocs;
export declare const ReqDeleteDoc: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibes.diy.req-delete-doc";
    appSlug: string;
    ownerHandle: string;
    dbName: string;
    docId: string;
}, {}>;
export type ReqDeleteDoc = typeof ReqDeleteDoc.infer;
export declare function isReqDeleteDoc(x: unknown): x is ReqDeleteDoc;
export declare const ReqSubscribeDocs: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibes.diy.req-subscribe-docs";
    appSlug: string;
    ownerHandle: string;
    dbName: string;
    interests?: string[] | undefined;
}, {}>;
export type ReqSubscribeDocs = typeof ReqSubscribeDocs.infer;
export declare function isReqSubscribeDocs(x: unknown): x is ReqSubscribeDocs;
export declare const ReqBroadcastEphemeral: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibes.diy.req-broadcast-ephemeral";
    appSlug: string;
    ownerHandle: string;
    dbName: string;
    docId: string;
    doc: Record<string, unknown>;
}, {}>;
export type ReqBroadcastEphemeral = typeof ReqBroadcastEphemeral.infer;
export declare function isReqBroadcastEphemeral(x: unknown): x is ReqBroadcastEphemeral;
export declare const ReqSetDbAcl: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibes.diy.req-set-db-acl";
    appSlug: string;
    ownerHandle: string;
    dbName: string;
    acl: {
        read?: ("editors" | "members" | "readers" | "submitters")[] | undefined;
        write?: ("editors" | "members" | "readers" | "submitters")[] | undefined;
    };
}, {}>;
export type ReqSetDbAcl = typeof ReqSetDbAcl.infer;
export declare function isReqSetDbAcl(x: unknown): x is ReqSetDbAcl;
export interface ResSetDbAcl {
    readonly tid: string;
    readonly type: "vibes.diy.res-set-db-acl";
    readonly status: "ok" | "error";
    readonly message?: string;
}
export declare function isResSetDbAcl(x: unknown): x is ResSetDbAcl;
export declare const ReqListDbNames: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibes.diy.req-list-db-names";
    appSlug: string;
    ownerHandle: string;
}, {}>;
export type ReqListDbNames = typeof ReqListDbNames.infer;
export declare function isReqListDbNames(x: unknown): x is ReqListDbNames;
export declare const ReqSyncPull: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibes.diy.req-sync-pull";
    appSlug: string;
    ownerHandle: string;
    dbName: string;
    cursors: Record<string, number>;
    adminMode?: boolean | undefined;
    actingHandle?: string | undefined;
    interests?: string[] | undefined;
}, {}>;
export type ReqSyncPull = typeof ReqSyncPull.infer;
export declare function isReqSyncPull(x: unknown): x is ReqSyncPull;
export declare const ReqSyncPush: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibes.diy.req-sync-push";
    appSlug: string;
    ownerHandle: string;
    dbName: string;
    writes: {
        docId: string;
        doc: Record<string, unknown>;
        baseSeq: number | null;
        deleted?: boolean | undefined;
    }[];
    adminMode?: boolean | undefined;
    actingHandle?: string | undefined;
}, {}>;
export type ReqSyncPush = typeof ReqSyncPush.infer;
export declare function isReqSyncPush(x: unknown): x is ReqSyncPush;
export declare const EvtSyncReconnected: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.evt-sync-reconnected";
}, {}>;
export type EvtSyncReconnected = typeof EvtSyncReconnected.infer;
export declare function isEvtSyncReconnected(x: unknown): x is EvtSyncReconnected;
export declare const MIRROR_PROTO = 1;
export declare const MirrorOp: import("arktype/internal/variants/object.ts").ObjectType<{
    op: "put";
    docId: string;
    doc: Record<string, unknown>;
} | {
    op: "del";
    docId: string;
}, {}>;
export type MirrorOp = typeof MirrorOp.infer;
declare const MirrorWriteOp: import("arktype/internal/variants/object.ts").ObjectType<{
    op: "put";
    doc: Record<string, unknown>;
    docId?: string | undefined;
} | {
    op: "del";
    docId: string;
}, {}>;
export type MirrorWriteOp = typeof MirrorWriteOp.infer;
export declare const ReqMirrorSubscribe: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibes.diy.req-mirror-subscribe";
    appSlug: string;
    ownerHandle: string;
    dbName: string;
    fromSeq?: number | undefined;
}, {}>;
export type ReqMirrorSubscribe = typeof ReqMirrorSubscribe.infer;
export declare function isReqMirrorSubscribe(x: unknown): x is ReqMirrorSubscribe;
export interface ResMirrorSubscribe {
    readonly tid: string;
    readonly type: "vibes.diy.res-mirror-subscribe";
    readonly status: "ok" | "error";
    readonly dbName: string;
    readonly mode?: "snapshot" | "resume";
    readonly seq?: number;
    readonly docs?: Record<string, unknown>[];
    readonly ops?: MirrorOp[];
    readonly message?: string;
    readonly settled?: boolean;
}
export declare function isResMirrorSubscribe(x: unknown): x is ResMirrorSubscribe;
export declare const ReqMirrorWrite: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibes.diy.req-mirror-write";
    appSlug: string;
    ownerHandle: string;
    dbName: string;
    originRuntimeId: string;
    writes: ({
        op: "put";
        doc: Record<string, unknown>;
        docId?: string | undefined;
    } | {
        op: "del";
        docId: string;
    })[];
}, {}>;
export type ReqMirrorWrite = typeof ReqMirrorWrite.infer;
export declare function isReqMirrorWrite(x: unknown): x is ReqMirrorWrite;
export declare const ReqMirrorInterest: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibes.diy.req-mirror-interest";
    appSlug: string;
    ownerHandle: string;
    interests: string[];
}, {}>;
export type ReqMirrorInterest = typeof ReqMirrorInterest.infer;
export declare function isReqMirrorInterest(x: unknown): x is ReqMirrorInterest;
export interface ResMirrorInterest {
    readonly tid: string;
    readonly type: "vibes.diy.res-mirror-interest";
    readonly status: "ok" | "error";
    readonly message?: string;
}
export declare function isResMirrorInterest(x: unknown): x is ResMirrorInterest;
export interface ResMirrorWrite {
    readonly tid: string;
    readonly type: "vibes.diy.res-mirror-write";
    readonly status: "ok" | "error";
    readonly results: {
        id: string;
        ok: boolean;
        message?: string;
    }[];
    readonly message?: string;
}
export declare function isResMirrorWrite(x: unknown): x is ResMirrorWrite;
export declare const EvtMirrorDelta: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.evt-mirror-delta";
    appSlug: string;
    ownerHandle: string;
    dbName: string;
    seq: number;
    ops: ({
        op: "put";
        docId: string;
        doc: Record<string, unknown>;
    } | {
        op: "del";
        docId: string;
    })[];
    originRuntimeId?: string | undefined;
}, {}>;
export type EvtMirrorDelta = typeof EvtMirrorDelta.infer;
export declare function isEvtMirrorDelta(x: unknown): x is EvtMirrorDelta;
export declare const EvtMirrorReset: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.evt-mirror-reset";
    appSlug: string;
    ownerHandle: string;
    dbName: string;
    seq: number;
    docs: Record<string, unknown>[];
}, {}>;
export type EvtMirrorReset = typeof EvtMirrorReset.infer;
export declare function isEvtMirrorReset(x: unknown): x is EvtMirrorReset;
export declare const EvtMirrorSettled: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.evt-mirror-settled";
    appSlug: string;
    ownerHandle: string;
    dbName: string;
    settled: boolean;
}, {}>;
export type EvtMirrorSettled = typeof EvtMirrorSettled.infer;
export declare function isEvtMirrorSettled(x: unknown): x is EvtMirrorSettled;
export interface ReqVibePutAsset {
    readonly tid: string;
    readonly type: "vibe.req.putAsset";
    readonly ownerHandle: string;
    readonly appSlug: string;
    readonly blob: Blob;
    readonly mimeType?: string;
}
export declare function isReqVibePutAsset(x: unknown): x is ReqVibePutAsset;
export declare const ResOkVibePutAsset: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.putAsset";
    status: "ok";
    cid: string;
    getURL: string;
    size: number;
    uploadId: string;
}, {}>;
export type ResOkVibePutAsset = typeof ResOkVibePutAsset.infer;
export declare const ResErrorVibePutAsset: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.putAsset";
    status: "error";
    message: string;
}, {}>;
export type ResErrorVibePutAsset = typeof ResErrorVibePutAsset.infer;
declare const ResVibePutAsset: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.putAsset";
    status: "ok";
    cid: string;
    getURL: string;
    size: number;
    uploadId: string;
} | {
    tid: string;
    type: "vibe.res.putAsset";
    status: "error";
    message: string;
}, {}>;
export type ResVibePutAsset = typeof ResVibePutAsset.infer;
export declare function isResVibePutAsset(x: unknown): x is ResVibePutAsset;
export declare const EvtVibePutAssetProgress: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.evt.putAsset.progress";
    bytes: number;
}, {}>;
export type EvtVibePutAssetProgress = typeof EvtVibePutAssetProgress.infer;
export declare const viewerPayload: import("arktype/internal/variants/object.ts").ObjectType<{
    userHandle: string;
    displayName?: string | undefined;
}, {}>;
export type ViewerPayload = typeof viewerPayload.infer;
export { docAccessLevel };
export type { DocAccessLevel } from "./doc-access-level.js";
export declare const ReqVibeWhoAmI: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.req.whoAmI";
    appSlug: string;
    ownerHandle: string;
    adminMode?: boolean | undefined;
}, {}>;
export type ReqVibeWhoAmI = typeof ReqVibeWhoAmI.infer;
export declare function isReqVibeWhoAmI(x: unknown): x is ReqVibeWhoAmI;
export declare const ResVibeWhoAmI: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.whoAmI";
    viewer: {
        userHandle: string;
        displayName?: string | undefined;
    } | null;
    access: "editor" | "none" | "override" | "submitter" | "viewer";
    isOwner?: boolean | undefined;
    grants?: {
        [x: string]: {
            channels: string[];
            publicChannels: string[];
            roles: string[];
        };
    } | undefined;
    adminMode?: boolean | undefined;
}, {}>;
export type ResVibeWhoAmI = typeof ResVibeWhoAmI.infer;
export declare function isResVibeWhoAmI(x: unknown): x is ResVibeWhoAmI;
export declare const ReqVibeAccessFnSource: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.req.accessFnSource";
    appSlug: string;
    ownerHandle: string;
    cid: string;
}, {}>;
export type ReqVibeAccessFnSource = typeof ReqVibeAccessFnSource.infer;
export declare function isReqVibeAccessFnSource(x: unknown): x is ReqVibeAccessFnSource;
export declare const ResVibeAccessFnSource: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.accessFnSource";
    cid: string;
    source: string | null;
}, {}>;
export type ResVibeAccessFnSource = typeof ResVibeAccessFnSource.infer;
export declare function isResVibeAccessFnSource(x: unknown): x is ResVibeAccessFnSource;
export declare const ReqVibeLookupHandles: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.req.lookupHandles";
    appSlug: string;
    ownerHandle: string;
    query: string;
}, {}>;
export type ReqVibeLookupHandles = typeof ReqVibeLookupHandles.infer;
export declare function isReqVibeLookupHandles(x: unknown): x is ReqVibeLookupHandles;
export declare const lookupHandleItem: import("arktype/internal/variants/object.ts").ObjectType<{
    handle: string;
    known: boolean;
}, {}>;
export type LookupHandleItem = typeof lookupHandleItem.infer;
export declare const ResVibeLookupHandles: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.lookupHandles";
    query: string;
    items: {
        handle: string;
        known: boolean;
    }[];
}, {}>;
export type ResVibeLookupHandles = typeof ResVibeLookupHandles.infer;
export declare function isResVibeLookupHandles(x: unknown): x is ResVibeLookupHandles;
export declare const ReqVibeProfileInfo: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.req.profileInfo";
    handle: string;
    ownerHandle: string;
    appSlug: string;
}, {}>;
export type ReqVibeProfileInfo = typeof ReqVibeProfileInfo.infer;
export declare function isReqVibeProfileInfo(x: unknown): x is ReqVibeProfileInfo;
export declare const ResVibeProfileInfo: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.profileInfo";
    handle: string;
    status?: "error" | "ok" | undefined;
    exists?: boolean | undefined;
    private?: boolean | undefined;
    message?: string | undefined;
}, {}>;
export type ResVibeProfileInfo = typeof ResVibeProfileInfo.infer;
export declare function isResVibeProfileInfo(x: unknown): x is ResVibeProfileInfo;
export declare const ReqVibeUpdateAvatarCid: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.req.updateAvatarCid";
    ownerHandle: string;
    appSlug: string;
    cid: string;
    handle: string;
    mimeType?: string | undefined;
}, {}>;
export type ReqVibeUpdateAvatarCid = typeof ReqVibeUpdateAvatarCid.infer;
export declare function isReqVibeUpdateAvatarCid(x: unknown): x is ReqVibeUpdateAvatarCid;
export declare const ResVibeUpdateAvatarCid: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.updateAvatarCid";
    status: "cancelled" | "error" | "ok";
    message?: string | undefined;
}, {}>;
export type ResVibeUpdateAvatarCid = typeof ResVibeUpdateAvatarCid.infer;
export declare function isResVibeUpdateAvatarCid(x: unknown): x is ResVibeUpdateAvatarCid;
export declare const ReqVibeLogin: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.req.login";
}, {}>;
export type ReqVibeLogin = typeof ReqVibeLogin.infer;
export declare function isReqVibeLogin(x: unknown): x is ReqVibeLogin;
export declare const EvtVibeViewerChanged: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibe.evt.viewerChanged";
    viewer: {
        userHandle: string;
        displayName?: string | undefined;
    } | null;
    access: "editor" | "none" | "override" | "submitter" | "viewer";
    isOwner?: boolean | undefined;
    grants?: {
        [x: string]: {
            channels: string[];
            publicChannels: string[];
            roles: string[];
        };
    } | undefined;
    adminMode?: boolean | undefined;
    pending?: boolean | undefined;
    soft?: boolean | undefined;
}, {}>;
export type EvtVibeViewerChanged = typeof EvtVibeViewerChanged.infer;
export declare function isEvtVibeViewerChanged(x: unknown): x is EvtVibeViewerChanged;
export declare function actingHandlePinFrom(evt: EvtVibeViewerChanged | undefined): {
    actingHandle: string;
} | Record<string, never>;
export declare const socialEdgeView: import("arktype/internal/variants/object.ts").ObjectType<{
    handle: string;
    state: "active" | "requested";
}, {}>;
export type SocialEdgeView = typeof socialEdgeView.infer;
export declare const EvtVibeSocialChanged: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibe.evt.socialChanged";
    handle: string;
    private: boolean;
    following: {
        handle: string;
        state: "active" | "requested";
    }[];
    followers: {
        handle: string;
        state: "active" | "requested";
    }[];
    requests: {
        handle: string;
        state: "active" | "requested";
    }[];
    followersEnabled: boolean;
    visibility: "followers" | "private" | "public";
    soft?: boolean | undefined;
}, {}>;
export type EvtVibeSocialChanged = typeof EvtVibeSocialChanged.infer;
export declare function isEvtVibeSocialChanged(x: unknown): x is EvtVibeSocialChanged;
export declare const EvtVibeSocialCleared: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibe.evt.socialCleared";
}, {}>;
export type EvtVibeSocialCleared = typeof EvtVibeSocialCleared.infer;
export declare function isEvtVibeSocialCleared(x: unknown): x is EvtVibeSocialCleared;
export declare const ReqVibeSocial: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.req.social";
    action: "approve" | "block" | "follow" | "remove-follower" | "unfollow";
    handle: string;
    ownerHandle: string;
    appSlug: string;
}, {}>;
export type ReqVibeSocial = typeof ReqVibeSocial.infer;
export declare function isReqVibeSocial(x: unknown): x is ReqVibeSocial;
export declare const ResVibeSocial: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.social";
    status: "error" | "ok";
    message?: string | undefined;
}, {}>;
export type ResVibeSocial = typeof ResVibeSocial.infer;
export declare function isResVibeSocial(x: unknown): x is ResVibeSocial;
export declare const ReqVibeRequestFollowersAccess: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.req.requestFollowersAccess";
    ownerHandle: string;
    appSlug: string;
}, {}>;
export type ReqVibeRequestFollowersAccess = typeof ReqVibeRequestFollowersAccess.infer;
export declare function isReqVibeRequestFollowersAccess(x: unknown): x is ReqVibeRequestFollowersAccess;
export declare const ResVibeRequestFollowersAccess: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.requestFollowersAccess";
    status: "ok";
}, {}>;
export type ResVibeRequestFollowersAccess = typeof ResVibeRequestFollowersAccess.infer;
export declare function isResVibeRequestFollowersAccess(x: unknown): x is ResVibeRequestFollowersAccess;
export declare const ReqVibeSetVisibility: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.req.setVisibility";
    visibility: "followers" | "private" | "public";
    ownerHandle: string;
    appSlug: string;
}, {}>;
export type ReqVibeSetVisibility = typeof ReqVibeSetVisibility.infer;
export declare function isReqVibeSetVisibility(x: unknown): x is ReqVibeSetVisibility;
export declare const ResVibeSetVisibility: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.setVisibility";
    status: "error" | "ok";
    message?: string | undefined;
}, {}>;
export type ResVibeSetVisibility = typeof ResVibeSetVisibility.infer;
export declare function isResVibeSetVisibility(x: unknown): x is ResVibeSetVisibility;
export declare const ReqVibeSetAccountPrivacy: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.req.setAccountPrivacy";
    private: boolean;
    ownerHandle: string;
    appSlug: string;
}, {}>;
export type ReqVibeSetAccountPrivacy = typeof ReqVibeSetAccountPrivacy.infer;
export declare function isReqVibeSetAccountPrivacy(x: unknown): x is ReqVibeSetAccountPrivacy;
export declare const ResVibeSetAccountPrivacy: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.setAccountPrivacy";
    status: "cancelled" | "error" | "ok";
    message?: string | undefined;
}, {}>;
export type ResVibeSetAccountPrivacy = typeof ResVibeSetAccountPrivacy.infer;
export declare function isResVibeSetAccountPrivacy(x: unknown): x is ResVibeSetAccountPrivacy;
export declare const ReqVibeSocialInvite: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.req.socialInvite";
    contact: string;
    ownerHandle: string;
    appSlug: string;
}, {}>;
export type ReqVibeSocialInvite = typeof ReqVibeSocialInvite.infer;
export declare function isReqVibeSocialInvite(x: unknown): x is ReqVibeSocialInvite;
export declare const ResVibeSocialInvite: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibe.res.socialInvite";
    status: "cancelled" | "ok" | "rate-limited";
}, {}>;
export type ResVibeSocialInvite = typeof ResVibeSocialInvite.infer;
export declare function isResVibeSocialInvite(x: unknown): x is ResVibeSocialInvite;
export declare const EvtVibeAccessFnSource: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibe.evt.accessFnSource";
    cid: string;
    source: string | null;
}, {}>;
export type EvtVibeAccessFnSource = typeof EvtVibeAccessFnSource.infer;
export declare function isEvtVibeAccessFnSource(x: unknown): x is EvtVibeAccessFnSource;
export declare const EvtVibeColorOverride: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibe.evt.color-override";
    colors: {
        [x: string]: string;
    };
    colorsDark?: {
        [x: string]: string;
    } | undefined;
}, {}>;
export type EvtVibeColorOverride = typeof EvtVibeColorOverride.infer;
export declare function isEvtVibeColorOverride(x: unknown): x is EvtVibeColorOverride;
export declare const EvtVibeScrollToTop: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibe.evt.scroll-to-top";
}, {}>;
export type EvtVibeScrollToTop = typeof EvtVibeScrollToTop.infer;
export declare function isEvtVibeScrollToTop(x: unknown): x is EvtVibeScrollToTop;
export declare const EvtVibeEnablePullToRefresh: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibe.evt.enable-pull-to-refresh";
}, {}>;
export type EvtVibeEnablePullToRefresh = typeof EvtVibeEnablePullToRefresh.infer;
export declare function isEvtVibeEnablePullToRefresh(x: unknown): x is EvtVibeEnablePullToRefresh;
export declare const EvtVibeUrlState: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibe.evt.url-state";
    search: string;
    hash: string;
}, {}>;
export type EvtVibeUrlState = typeof EvtVibeUrlState.infer;
export declare function isEvtVibeUrlState(x: unknown): x is EvtVibeUrlState;
export declare const ReqOpenDmThread: import("arktype/internal/variants/object.ts").ObjectType<{
    tid: string;
    type: "vibes.diy.req-open-dm-thread";
    recipientUserSlug: string;
}, {}>;
export type ReqOpenDmThread = typeof ReqOpenDmThread.infer;
export declare function isReqOpenDmThread(x: unknown): x is ReqOpenDmThread;