export declare const KVString: import("arktype/internal/variants/object.ts").ObjectType<{
    key: string;
    value: string;
}, {}>;
export type KVString = typeof KVString.infer;
export declare function toKVString(record: Record<string, string>): KVString[];
export declare function fromKVString(entries: KVString[]): Record<string, string>;
export declare const AIParams: import("arktype/internal/variants/object.ts").ObjectType<{
    model: {
        id: string;
        name: string;
        description: string;
        featured?: boolean | undefined;
        preSelected?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
        fallbackFor?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
        supports?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
        imageInput?: boolean | undefined;
    };
    apiKey?: string | undefined;
}, {}>;
export type AIParams = typeof AIParams.infer;
export declare const tick: import("arktype/internal/variants/object.ts").ObjectType<{
    count: number;
    last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
}, {}>;
export declare const RawEmailWithoutFrom: import("arktype/internal/variants/object.ts").ObjectType<{
    to: string | string[];
    subject: string;
    text?: string | undefined;
    html?: string | undefined;
}, {}>;
export type RawEmailWithoutFrom = typeof RawEmailWithoutFrom.infer;
export declare const RawEmail: import("arktype/internal/variants/object.ts").ObjectType<{
    to: string | string[];
    subject: string;
    text?: string | undefined;
    html?: string | undefined;
    from: string;
}, {}>;
export type RawEmail = typeof RawEmail.infer;
export declare const EmailOpsBase: import("arktype/internal/variants/object.ts").ObjectType<{
    dst: string;
    role: "editor" | "submitter" | "viewer";
    appSlug: string;
    ownerHandle: string;
    fsId?: string | undefined;
}, {}>;
export declare const EmailOpsInvite: import("arktype/internal/variants/object.ts").ObjectType<{
    dst: string;
    role: "editor" | "submitter" | "viewer";
    appSlug: string;
    ownerHandle: string;
    fsId?: string | undefined;
    action: "invite";
    token: string;
}, {}>;
export type EmailOpsInvite = typeof EmailOpsInvite.infer;
export declare function isEmailOpsInvite(obj: unknown): obj is EmailOpsInvite;
export declare const EmailOpsInviteRevoked: import("arktype/internal/variants/object.ts").ObjectType<{
    dst: string;
    role: "editor" | "submitter" | "viewer";
    appSlug: string;
    ownerHandle: string;
    fsId?: string | undefined;
    action: "invite-revoked";
}, {}>;
export declare const EmailOpsRequest: import("arktype/internal/variants/object.ts").ObjectType<{
    dst: string;
    role: "editor" | "submitter" | "viewer";
    appSlug: string;
    ownerHandle: string;
    fsId?: string | undefined;
    action: "req-accepted" | "req-rejected";
}, {}>;
export type EmailOpsRequest = typeof EmailOpsRequest.infer;
export declare function isEmailOpsRequest(obj: unknown): obj is EmailOpsRequest;
export declare const EmailOps: import("arktype/internal/variants/object.ts").ObjectType<{
    dst: string;
    role: "editor" | "submitter" | "viewer";
    appSlug: string;
    ownerHandle: string;
    fsId?: string | undefined;
    action: "invite";
    token: string;
} | {
    dst: string;
    role: "editor" | "submitter" | "viewer";
    appSlug: string;
    ownerHandle: string;
    fsId?: string | undefined;
    action: "invite-revoked";
} | {
    dst: string;
    role: "editor" | "submitter" | "viewer";
    appSlug: string;
    ownerHandle: string;
    fsId?: string | undefined;
    action: "req-accepted" | "req-rejected";
}, {}>;
export type EmailOps = typeof EmailOps.infer;
export declare function isEmailOps(obj: unknown): obj is EmailOps;
export declare const EnablePublicAccess: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "app.public.access";
    enable: boolean;
    tick?: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    } | undefined;
}, {}>;
export type EnablePublicAccess = typeof EnablePublicAccess.infer;
export declare function isEnablePublicAccess(obj: unknown): obj is EnablePublicAccess;
export declare const EnableRequest: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "app.request";
    enable: boolean;
    autoAcceptRole?: "editor" | "submitter" | "viewer" | undefined;
}, {}>;
export type EnableRequest = typeof EnableRequest.infer;
export declare function isEnableRequest(obj: unknown): obj is EnableRequest;
export declare function requestsEnabled(entry: EnableRequest | undefined): boolean;
export declare const requestBase: import("arktype/internal/variants/object.ts").ObjectType<{
    key: string;
    provider: "clerk" | "github" | "google";
    msg?: string | undefined;
    userId: string;
    created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
}, {}>;
export declare const ActiveRequestPending: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "app.acl.active.request";
    role: "viewer";
    state: "pending";
    request: {
        key: string;
        provider: "clerk" | "github" | "google";
        msg?: string | undefined;
        userId: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
}, {}>;
export type ActiveRequestPending = typeof ActiveRequestPending.infer;
export declare function isActiveRequestPending(obj: unknown): obj is typeof ActiveRequestPending.infer;
export declare const ActiveRequestApproved: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "app.acl.active.request";
    role: "editor" | "submitter" | "viewer";
    state: "approved";
    request: {
        key: string;
        provider: "clerk" | "github" | "google";
        msg?: string | undefined;
        userId: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
}, {}>;
export type ActiveRequestApproved = typeof ActiveRequestApproved.infer;
export declare function isActiveRequestApproved(obj: unknown): obj is typeof ActiveRequestApproved.infer;
export declare const ActiveRequestRejected: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "app.acl.active.request";
    role: "editor" | "submitter" | "viewer";
    state: "rejected";
    request: {
        key: string;
        provider: "clerk" | "github" | "google";
        msg?: string | undefined;
        userId: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
}, {}>;
export type ActiveRequestRejected = typeof ActiveRequestRejected.infer;
export declare function isActiveRequestRejected(obj: unknown): obj is typeof ActiveRequestRejected.infer;
export declare const ActiveRequest: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "app.acl.active.request";
    role: "viewer";
    state: "pending";
    request: {
        key: string;
        provider: "clerk" | "github" | "google";
        msg?: string | undefined;
        userId: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.request";
    role: "editor" | "submitter" | "viewer";
    state: "approved";
    request: {
        key: string;
        provider: "clerk" | "github" | "google";
        msg?: string | undefined;
        userId: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.request";
    role: "editor" | "submitter" | "viewer";
    state: "rejected";
    request: {
        key: string;
        provider: "clerk" | "github" | "google";
        msg?: string | undefined;
        userId: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
}, {}>;
export type ActiveRequest = typeof ActiveRequest.infer;
export declare function isActiveRequest(obj: unknown): obj is typeof ActiveRequest.infer;
export declare const ActiveInviteEditorPending: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "app.acl.active.invite";
    role: "editor";
    state: "pending";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    token: string;
}, {}>;
export type ActiveInviteEditorPending = typeof ActiveInviteEditorPending.infer;
export declare function isActiveInviteEditorPending(obj: unknown): obj is typeof ActiveInviteEditorPending.infer;
export declare const ActiveInviteViewerPending: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "app.acl.active.invite";
    role: "viewer";
    state: "pending";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    token: string;
}, {}>;
export type ActiveInviteViewerPending = typeof ActiveInviteViewerPending.infer;
export declare function isActiveInviteViewerPending(obj: unknown): obj is typeof ActiveInviteViewerPending.infer;
export declare const ActiveInviteEditorAccepted: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "app.acl.active.invite";
    role: "editor";
    state: "accepted";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
}, {}>;
export type ActiveInviteEditorAccepted = typeof ActiveInviteEditorAccepted.infer;
export declare function isActiveInviteEditorAccepted(obj: unknown): obj is typeof ActiveInviteEditorAccepted.infer;
export declare const ActiveInviteViewerAccepted: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "app.acl.active.invite";
    role: "viewer";
    state: "accepted";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
}, {}>;
export type ActiveInviteViewerAccepted = typeof ActiveInviteViewerAccepted.infer;
export declare function isActiveInviteViewerAccepted(obj: unknown): obj is typeof ActiveInviteViewerAccepted.infer;
export declare const ActiveInviteEditorRevoked: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "app.acl.active.invite";
    role: "editor";
    state: "revoked";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
}, {}>;
export type ActiveInviteEditorRevoked = typeof ActiveInviteEditorRevoked.infer;
export declare function isActiveInviteEditorRevoked(obj: unknown): obj is typeof ActiveInviteEditorRevoked.infer;
export declare const ActiveInviteViewerRevoked: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "app.acl.active.invite";
    role: "viewer";
    state: "revoked";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
}, {}>;
export type ActiveInviteViewerRevoked = typeof ActiveInviteViewerRevoked.infer;
export declare function isActiveInviteViewerRevoked(obj: unknown): obj is typeof ActiveInviteViewerRevoked.infer;
export declare const ActiveInvite: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "app.acl.active.invite";
    role: "editor";
    state: "pending";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    token: string;
} | {
    type: "app.acl.active.invite";
    role: "viewer";
    state: "pending";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    token: string;
} | {
    type: "app.acl.active.invite";
    role: "editor";
    state: "accepted";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.invite";
    role: "viewer";
    state: "accepted";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.invite";
    role: "editor";
    state: "revoked";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.invite";
    role: "viewer";
    state: "revoked";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
}, {}>;
export type ActiveInvite = typeof ActiveInvite.infer;
export declare function isActiveInvite(obj: unknown): obj is typeof ActiveInvite.infer;
export declare const ActiveACL: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "app.acl.active.request";
    role: "viewer";
    state: "pending";
    request: {
        key: string;
        provider: "clerk" | "github" | "google";
        msg?: string | undefined;
        userId: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.request";
    role: "editor" | "submitter" | "viewer";
    state: "approved";
    request: {
        key: string;
        provider: "clerk" | "github" | "google";
        msg?: string | undefined;
        userId: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.request";
    role: "editor" | "submitter" | "viewer";
    state: "rejected";
    request: {
        key: string;
        provider: "clerk" | "github" | "google";
        msg?: string | undefined;
        userId: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.invite";
    role: "editor";
    state: "pending";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    token: string;
} | {
    type: "app.acl.active.invite";
    role: "viewer";
    state: "pending";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    token: string;
} | {
    type: "app.acl.active.invite";
    role: "editor";
    state: "accepted";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.invite";
    role: "viewer";
    state: "accepted";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.invite";
    role: "editor";
    state: "revoked";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.invite";
    role: "viewer";
    state: "revoked";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
}, {}>;
export type ActiveACL = typeof ActiveACL.infer;
export declare const ActiveTitle: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.title";
    title: string;
}, {}>;
export type ActiveTitle = typeof ActiveTitle.infer;
export declare function isActiveTitle(obj: unknown): obj is ActiveTitle;
export declare const ActiveSkills: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.skills";
    skills: string[];
}, {}>;
export type ActiveSkills = typeof ActiveSkills.infer;
export declare function isActiveSkills(obj: unknown): obj is ActiveSkills;
export declare const ActiveTheme: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.theme";
    theme: string;
}, {}>;
export type ActiveTheme = typeof ActiveTheme.infer;
export declare function isActiveTheme(obj: unknown): obj is ActiveTheme;
export declare const ActiveColorTheme: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.colorTheme";
    colorTheme: string;
}, {}>;
export type ActiveColorTheme = typeof ActiveColorTheme.infer;
export declare function isActiveColorTheme(obj: unknown): obj is ActiveColorTheme;
export declare const ActiveCodegenTheme: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.codegen-theme";
    theme: string;
}, {}>;
export type ActiveCodegenTheme = typeof ActiveCodegenTheme.infer;
export declare function isActiveCodegenTheme(obj: unknown): obj is ActiveCodegenTheme;
export declare const IconVersion: import("arktype/internal/variants/object.ts").ObjectType<{
    cid: string;
    mime: string;
    descriptionAt: string;
    created: string;
}, {}>;
export type IconVersion = typeof IconVersion.infer;
export declare function isIconVersion(obj: unknown): obj is IconVersion;
export declare const ActiveIcon: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.icon";
    versions: {
        cid: string;
        mime: string;
        descriptionAt: string;
        created: string;
    }[];
    currentCid: string;
}, {}>;
export type ActiveIcon = typeof ActiveIcon.infer;
export declare function isActiveIcon(obj: unknown): obj is ActiveIcon;
export declare const ActiveAvatarVersion: import("arktype/internal/variants/object.ts").ObjectType<{
    cid: string;
    mime: string;
    created: string;
}, {}>;
export type ActiveAvatarVersion = typeof ActiveAvatarVersion.infer;
export declare function isActiveAvatarVersion(obj: unknown): obj is ActiveAvatarVersion;
export declare const ActiveAvatar: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.avatar";
    versions: {
        cid: string;
        mime: string;
        created: string;
    }[];
    currentCid: string;
}, {}>;
export type ActiveAvatar = typeof ActiveAvatar.infer;
export declare function isActiveAvatar(obj: unknown): obj is ActiveAvatar;
export declare const ActiveSocial: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.social";
    private: boolean;
}, {}>;
export type ActiveSocial = typeof ActiveSocial.infer;
export declare function isActiveSocial(obj: unknown): obj is ActiveSocial;
export declare const ActiveAudiencePolicy: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.audience-policy";
    policy: "always-allow" | "ask" | "followers" | "never-allow" | "private" | "public";
}, {}>;
export type ActiveAudiencePolicy = typeof ActiveAudiencePolicy.infer;
export declare function isActiveAudiencePolicy(obj: unknown): obj is ActiveAudiencePolicy;
export declare const ActivePrivacySensitive: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.privacy-sensitive";
    sensitive: boolean;
}, {}>;
export type ActivePrivacySensitive = typeof ActivePrivacySensitive.infer;
export declare function isActivePrivacySensitive(obj: unknown): obj is ActivePrivacySensitive;
export declare const ActiveIconDescription: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.icon-description";
    description: string;
}, {}>;
export type ActiveIconDescription = typeof ActiveIconDescription.infer;
export declare function isActiveIconDescription(obj: unknown): obj is ActiveIconDescription;
export declare const ActiveEnrichedPrompt: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.enriched-prompt";
    enrichedPrompt: string;
}, {}>;
export type ActiveEnrichedPrompt = typeof ActiveEnrichedPrompt.infer;
export declare function isActiveEnrichedPrompt(obj: unknown): obj is ActiveEnrichedPrompt;
export declare const ActiveDeferredIntents: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.deferred-intents";
    access?: {
        needed: boolean;
        why: string;
    } | undefined;
    backend?: {
        recommended: boolean;
        why: string;
    } | undefined;
}, {}>;
export type ActiveDeferredIntents = typeof ActiveDeferredIntents.infer;
export declare function isActiveDeferredIntents(obj: unknown): obj is ActiveDeferredIntents;
export declare const ActiveModelSettingBase: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.model";
    param: {
        model: {
            id: string;
            name: string;
            description: string;
            featured?: boolean | undefined;
            preSelected?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            fallbackFor?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            supports?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            imageInput?: boolean | undefined;
        };
        apiKey?: string | undefined;
    };
}, {}>;
export declare const ActiveModelSettingCodegen: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.model";
    param: {
        model: {
            id: string;
            name: string;
            description: string;
            featured?: boolean | undefined;
            preSelected?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            fallbackFor?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            supports?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            imageInput?: boolean | undefined;
        };
        apiKey?: string | undefined;
    };
    usage: "chat" | "codegen";
}, {}>;
export type ActiveModelSettingCodegen = typeof ActiveModelSettingCodegen.infer;
export declare function isActiveModelSettingCodegen(obj: unknown): obj is typeof ActiveModelSettingCodegen.infer;
export declare const ActiveModelSettingRuntime: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.model";
    param: {
        model: {
            id: string;
            name: string;
            description: string;
            featured?: boolean | undefined;
            preSelected?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            fallbackFor?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            supports?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            imageInput?: boolean | undefined;
        };
        apiKey?: string | undefined;
    };
    usage: "app" | "runtime";
}, {}>;
export type ActiveModelSettingRuntime = typeof ActiveModelSettingRuntime.infer;
export declare function isActiveModelSettingRuntime(obj: unknown): obj is typeof ActiveModelSettingRuntime.infer;
export declare const ActiveModelSettingImg: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.model";
    param: {
        model: {
            id: string;
            name: string;
            description: string;
            featured?: boolean | undefined;
            preSelected?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            fallbackFor?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            supports?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            imageInput?: boolean | undefined;
        };
        apiKey?: string | undefined;
    };
    usage: "img";
}, {}>;
export type ActiveModelSettingImg = typeof ActiveModelSettingImg.infer;
export declare function isActiveModelSettingImg(obj: unknown): obj is ActiveModelSettingImg;
export declare const ActiveModelSetting: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.model";
    param: {
        model: {
            id: string;
            name: string;
            description: string;
            featured?: boolean | undefined;
            preSelected?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            fallbackFor?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            supports?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            imageInput?: boolean | undefined;
        };
        apiKey?: string | undefined;
    };
    usage: "chat" | "codegen";
} | {
    type: "active.model";
    param: {
        model: {
            id: string;
            name: string;
            description: string;
            featured?: boolean | undefined;
            preSelected?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            fallbackFor?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            supports?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            imageInput?: boolean | undefined;
        };
        apiKey?: string | undefined;
    };
    usage: "app" | "runtime";
} | {
    type: "active.model";
    param: {
        model: {
            id: string;
            name: string;
            description: string;
            featured?: boolean | undefined;
            preSelected?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            fallbackFor?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            supports?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            imageInput?: boolean | undefined;
        };
        apiKey?: string | undefined;
    };
    usage: "img";
}, {}>;
export type ActiveModelSetting = typeof ActiveModelSetting.infer;
export declare function isActiveModelSetting(obj: unknown): obj is ActiveModelSetting;
export declare const ActiveEnv: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.env";
    env: {
        key: string;
        value: string;
    }[];
}, {}>;
export type ActiveEnv = typeof ActiveEnv.infer;
export declare function isActiveEnv(obj: unknown): obj is ActiveEnv;
export declare const ActiveSecret: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.secret";
    key: string;
    value: string;
    updatedAt: number;
    setBy?: string | undefined;
}, {}>;
export type ActiveSecret = typeof ActiveSecret.infer;
export declare function isActiveSecret(obj: unknown): obj is ActiveSecret;
export declare const SecretMeta: import("arktype/internal/variants/object.ts").ObjectType<{
    key: string;
    last4?: string | undefined;
    updatedAt: number;
    setBy?: string | undefined;
}, {}>;
export type SecretMeta = typeof SecretMeta.infer;
export declare const ActiveBackend: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.backend";
    handlers: string[];
    intervalMs?: number | undefined;
}, {}>;
export type ActiveBackend = typeof ActiveBackend.infer;
export declare function isActiveBackend(obj: unknown): obj is ActiveBackend;
export declare const ActiveSeedApplied: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.seed-applied";
    fsId: string;
}, {}>;
export type ActiveSeedApplied = typeof ActiveSeedApplied.infer;
export declare function isActiveSeedApplied(obj: unknown): obj is ActiveSeedApplied;
export declare const ActiveSeedControl: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "active.seed-control";
    dontRun?: boolean | undefined;
    suppressed?: string[] | undefined;
}, {}>;
export type ActiveSeedControl = typeof ActiveSeedControl.infer;
export declare function isActiveSeedControl(obj: unknown): obj is ActiveSeedControl;
export declare const ActiveEntry: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "app.public.access";
    enable: boolean;
    tick?: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    } | undefined;
} | {
    type: "app.request";
    enable: boolean;
    autoAcceptRole?: "editor" | "submitter" | "viewer" | undefined;
} | {
    type: "app.acl.active.request";
    role: "viewer";
    state: "pending";
    request: {
        key: string;
        provider: "clerk" | "github" | "google";
        msg?: string | undefined;
        userId: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.request";
    role: "editor" | "submitter" | "viewer";
    state: "approved";
    request: {
        key: string;
        provider: "clerk" | "github" | "google";
        msg?: string | undefined;
        userId: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.request";
    role: "editor" | "submitter" | "viewer";
    state: "rejected";
    request: {
        key: string;
        provider: "clerk" | "github" | "google";
        msg?: string | undefined;
        userId: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.invite";
    role: "editor";
    state: "pending";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    token: string;
} | {
    type: "app.acl.active.invite";
    role: "viewer";
    state: "pending";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    token: string;
} | {
    type: "app.acl.active.invite";
    role: "editor";
    state: "accepted";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.invite";
    role: "viewer";
    state: "accepted";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.invite";
    role: "editor";
    state: "revoked";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.invite";
    role: "viewer";
    state: "revoked";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "active.title";
    title: string;
} | {
    type: "active.skills";
    skills: string[];
} | {
    type: "active.theme";
    theme: string;
} | {
    type: "active.colorTheme";
    colorTheme: string;
} | {
    type: "active.codegen-theme";
    theme: string;
} | {
    type: "active.icon";
    versions: {
        cid: string;
        mime: string;
        descriptionAt: string;
        created: string;
    }[];
    currentCid: string;
} | {
    type: "active.avatar";
    versions: {
        cid: string;
        mime: string;
        created: string;
    }[];
    currentCid: string;
} | {
    type: "active.social";
    private: boolean;
} | {
    type: "active.audience-policy";
    policy: "always-allow" | "ask" | "followers" | "never-allow" | "private" | "public";
} | {
    type: "active.privacy-sensitive";
    sensitive: boolean;
} | {
    type: "active.icon-description";
    description: string;
} | {
    type: "active.enriched-prompt";
    enrichedPrompt: string;
} | {
    type: "active.deferred-intents";
    access?: {
        needed: boolean;
        why: string;
    } | undefined;
    backend?: {
        recommended: boolean;
        why: string;
    } | undefined;
} | {
    type: "active.model";
    param: {
        model: {
            id: string;
            name: string;
            description: string;
            featured?: boolean | undefined;
            preSelected?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            fallbackFor?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            supports?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            imageInput?: boolean | undefined;
        };
        apiKey?: string | undefined;
    };
    usage: "chat" | "codegen";
} | {
    type: "active.model";
    param: {
        model: {
            id: string;
            name: string;
            description: string;
            featured?: boolean | undefined;
            preSelected?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            fallbackFor?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            supports?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            imageInput?: boolean | undefined;
        };
        apiKey?: string | undefined;
    };
    usage: "app" | "runtime";
} | {
    type: "active.model";
    param: {
        model: {
            id: string;
            name: string;
            description: string;
            featured?: boolean | undefined;
            preSelected?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            fallbackFor?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            supports?: ("app" | "chat" | "codegen" | "img" | "img-edit" | "runtime")[] | undefined;
            imageInput?: boolean | undefined;
        };
        apiKey?: string | undefined;
    };
    usage: "img";
} | {
    type: "active.env";
    env: {
        key: string;
        value: string;
    }[];
} | {
    type: "active.secret";
    key: string;
    value: string;
    updatedAt: number;
    setBy?: string | undefined;
} | {
    type: "active.backend";
    handlers: string[];
    intervalMs?: number | undefined;
} | {
    type: "active.seed-applied";
    fsId: string;
} | {
    type: "active.seed-control";
    dontRun?: boolean | undefined;
    suppressed?: string[] | undefined;
} | {
    type: "active.db-acl";
    dbName: string;
    acl: {
        read?: ("editors" | "members" | "readers" | "submitters")[] | undefined;
        write?: ("editors" | "members" | "readers" | "submitters")[] | undefined;
    };
} | {
    type: "active.cached-suggestion";
    key: string;
    fsId: string;
    sourceFsId: string;
} | {
    type: "active.cached-suggestion-bless";
    key: string;
    fsId?: string | undefined;
    sourceFsId?: string | undefined;
    targetOwnerHandle?: string | undefined;
    targetAppSlug?: string | undefined;
    approvedBy: string;
    approvedAt: string;
} | {
    type: "active.recommended-curated";
    items: {
        id: string;
        ownerHandle: string;
        appSlug: string;
    }[];
} | {
    type: "active.recommended-masked";
    items: {
        ownerHandle: string;
        appSlug: string;
    }[];
}, {}>;
export declare function isActiveAcl(obj: unknown): obj is typeof ActiveACL.infer;
export type ActiveEntry = typeof ActiveEntry.infer;
export declare const ActiveInviteEditor: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "app.acl.active.invite";
    role: "editor";
    state: "pending";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    token: string;
} | {
    type: "app.acl.active.invite";
    role: "editor";
    state: "accepted";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.invite";
    role: "editor";
    state: "revoked";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
}, {}>;
export declare const ActiveInviteViewer: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "app.acl.active.invite";
    role: "viewer";
    state: "pending";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    token: string;
} | {
    type: "app.acl.active.invite";
    role: "viewer";
    state: "accepted";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
} | {
    type: "app.acl.active.invite";
    role: "viewer";
    state: "revoked";
    invite: {
        email: string;
        created: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    grant: {
        ownerId: string;
        key?: string | undefined;
        on: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
    tick: {
        count: number;
        last: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
    };
}, {}>;
export type AppScopedActiveEntry = Exclude<ActiveEntry, ActiveAvatar | ActiveSocial | ActiveAudiencePolicy>;
export declare function isAppScopedEntry(entry: ActiveEntry): entry is AppScopedActiveEntry;
export declare function keyForEntry(entry: AppScopedActiveEntry): string;
export type ActiveInviteEditor = typeof ActiveInviteEditor.infer;
export type ActiveInviteViewer = typeof ActiveInviteViewer.infer;
export declare function isActiveInviteEditor(obj: unknown): obj is typeof ActiveInviteEditor.infer;
export declare function isActiveInviteViewer(obj: unknown): obj is typeof ActiveInviteViewer.infer;