opacacms 0.2.0 → 0.3.0

package/dist/schema/zod.d.ts

@@ -0,0 +1,564 @@
+import * as zOriginal from "zod";
+declare module "zod" {
+    interface ZodTypeAny {
+        unique(): this;
+        localized(): this;
+        required<T = any>(condition?: (data: T) => boolean): this;
+        condition<T = any>(fn: (data: T) => boolean): this;
+        cms<T = any>(meta: GlobalMeta["opaca"] & {
+            resolve?: (args: {
+                data: T;
+                req: any;
+                user: any;
+                session: any;
+                apiKey?: any;
+            }) => any | Promise<any>;
+        }): this;
+    }
+}
+declare module "zod" {
+    interface GlobalMeta {
+        opaca?: {
+            unique?: boolean;
+            localized?: boolean;
+            virtual?: boolean;
+            resolve?: (args: {
+                data: any;
+                req: any;
+                user: any;
+                session: any;
+                apiKey?: any;
+            }) => any | Promise<any>;
+            returnType?: "string" | "number" | "boolean" | "json";
+            hash?: {
+                algorithm?: "argon2" | "bcrypt";
+            };
+            admin?: {
+                component?: string;
+                label?: string;
+                description?: string;
+                hidden?: boolean;
+                readOnly?: boolean;
+                placeholder?: string;
+                components?: {
+                    Field?: string;
+                    Cell?: string;
+                };
+                slugOptions?: {
+                    from?: string;
+                    format?: (val: string) => string;
+                };
+                fileOptions?: {
+                    bucket?: string;
+                    allowedMimeTypes?: string[];
+                    maxFileSize?: number;
+                };
+                relationTo?: string;
+                hasMany?: boolean;
+                displayField?: string;
+                choices?: Array<{
+                    label: string;
+                    value: string;
+                }> | string[];
+                initiallyCollapsed?: boolean;
+                tabsConfig?: Array<{
+                    label: string;
+                    fields: string[];
+                }>;
+                useAsTitle?: string;
+            };
+            collectionConfig?: {
+                slug: string;
+                label?: string;
+                useAsTitle?: string;
+            };
+            globalConfig?: {
+                slug: string;
+                label?: string;
+            };
+            isVirtual?: boolean;
+            requiredCondition?: (data: any) => boolean;
+        };
+    }
+}
+/**
+ * Enhanced Zod object for OpacaCMS.
+ * Re-exports everything from 'zod' and adds CMS-specific field helpers.
+ */
+export declare const z: {
+    /**
+     * Helper factory for type-safe conditions and required fields.
+     * Usage: const { condition, required } = z.helpers<Product>();
+     */
+    helpers: <T extends unknown>(schemaOrType?: T) => {
+        condition: <S extends zOriginal.ZodTypeAny>(schema: S, fn: (data: T extends zOriginal.ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>> ? zOriginal.z.core.output<T> : T) => boolean) => S;
+        required: <S extends zOriginal.ZodTypeAny>(schema: S, fn: (data: T extends zOriginal.ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>> ? zOriginal.z.core.output<T> : T) => boolean) => S;
+        meta: <S extends zOriginal.ZodTypeAny>(schema: S, meta: Omit<NonNullable<zOriginal.GlobalMeta["opaca"]>, "resolve" | "requiredCondition"> & {
+            resolve?: (args: {
+                data: T extends zOriginal.ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>> ? zOriginal.z.core.output<T> : T;
+                req: any;
+                user: any;
+                session: any;
+                apiKey?: any;
+            }) => any | Promise<any>;
+            required?: (data: T extends zOriginal.ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>> ? zOriginal.z.core.output<T> : T) => boolean;
+            condition?: (data: T extends zOriginal.ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>> ? zOriginal.z.core.output<T> : T) => boolean;
+        }) => S;
+        cms: (schema: any, meta: any) => any;
+    };
+    /**
+     * CMS Text Field (standard z.string())
+     */
+    text: (options?: {
+        unique?: boolean;
+        localized?: boolean;
+        label?: string;
+        description?: string;
+    }) => zOriginal.ZodString;
+    /**
+     * CMS Slug Field
+     */
+    slug: (options: {
+        from: string;
+        label?: string;
+        format?: (val: string) => string;
+    }) => zOriginal.ZodString;
+    /**
+     * CMS Relationship Field
+     */
+    relationship: (collection: string, options?: {
+        hasMany?: boolean;
+        label?: string;
+        displayField?: string;
+    }) => zOriginal.ZodString | zOriginal.ZodArray<zOriginal.ZodNullable<zOriginal.ZodOptional<zOriginal.ZodString>>>;
+    /**
+     * CMS Rich Text Field
+     */
+    richText: (options?: {
+        mode?: "simple" | "notion";
+        label?: string;
+    }) => zOriginal.ZodUnion<readonly [zOriginal.ZodString, zOriginal.ZodObject<{}, zOriginal.z.core.$strip>]>;
+    /**
+     * CMS File/Media Field
+     */
+    file: (options?: {
+        bucket?: string;
+        allowedMimeTypes?: string[];
+        label?: string;
+    }) => zOriginal.ZodObject<{
+        id: zOriginal.ZodString;
+        url: zOriginal.ZodString;
+        filename: zOriginal.ZodString;
+        mime_type: zOriginal.ZodString;
+        filesize: zOriginal.ZodNumber;
+    }, zOriginal.z.core.$strip>;
+    /**
+     * CMS Textarea Field
+     */
+    textarea: (options?: {
+        localized?: boolean;
+        label?: string;
+        description?: string;
+    }) => zOriginal.ZodString;
+    /**
+     * CMS Number Field
+     */
+    number: (options?: {
+        label?: string;
+        description?: string;
+    }) => zOriginal.ZodNumber;
+    /**
+     * CMS Boolean Field
+     */
+    boolean: (options?: {
+        label?: string;
+        description?: string;
+    }) => zOriginal.ZodPipe<zOriginal.ZodTransform<unknown, unknown>, zOriginal.ZodBoolean>;
+    /**
+     * CMS Date Field
+     */
+    date: (options?: {
+        label?: string;
+        description?: string;
+    }) => zOriginal.ZodDate;
+    /**
+     * CMS Select Field
+     */
+    select: (choices: string[] | Array<{
+        label: string;
+        value: string;
+    }>, options?: {
+        label?: string;
+        description?: string;
+    }) => zOriginal.ZodEnum<{
+        [x: string]: string;
+    }>;
+    /**
+     * CMS Radio Field
+     */
+    radio: (choices: string[] | Array<{
+        label: string;
+        value: string;
+    }>, options?: {
+        label?: string;
+        description?: string;
+    }) => zOriginal.ZodEnum<{
+        [x: string]: string;
+    }>;
+    /**
+     * CMS Password Field (Hidden in UI, hashed on backend)
+     */
+    password: (options?: {
+        algorithm?: "argon2" | "bcrypt";
+        label?: string;
+    }) => zOriginal.ZodString;
+    /**
+     * CMS Join Field (Virtual reversed relationship)
+     */
+    join: (collection: string, on: string, options?: {
+        label?: string;
+    }) => zOriginal.ZodOptional<zOriginal.ZodArray<zOriginal.ZodAny>>;
+    /**
+     * UI Layout: Group
+     */
+    group: <T extends zOriginal.ZodRawShape>(shape: T, options?: {
+        label?: string;
+    }) => zOriginal.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zOriginal.z.core.$strip>;
+    /**
+     * UI Layout: Row (Visual grouping only)
+     */
+    row: <T extends zOriginal.ZodRawShape>(shape: T, options?: {
+        label?: string;
+    }) => zOriginal.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zOriginal.z.core.$strip>;
+    /**
+     * UI Layout: Collapsible
+     */
+    collapsible: <T extends zOriginal.ZodRawShape>(shape: T, options?: {
+        label?: string;
+        initiallyCollapsed?: boolean;
+    }) => zOriginal.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zOriginal.z.core.$strip>;
+    /**
+     * UI Layout: Tabs
+     */
+    tabs: (tabsConfig: Record<string, zOriginal.ZodObject<any>>, options?: {
+        label?: string;
+    }) => zOriginal.ZodObject<{
+        [x: string]: any;
+    }, zOriginal.z.core.$strip>;
+    /**
+     * CMS Blocks Field (Dynamic array of heterogenous objects)
+     */
+    blocks: <T extends [zOriginal.ZodObject<any>, ...zOriginal.ZodObject<any>[]]>(blockSchemas: T, options?: {
+        label?: string;
+    }) => zOriginal.ZodArray<zOriginal.ZodDiscriminatedUnion<T, "blockType">>;
+    /**
+     * CMS Localized Field Wrapper
+     */
+    localized: <T extends zOriginal.ZodTypeAny>(schema: T) => T;
+    /**
+     * CMS Custom UI Field
+     */
+    ui: (component: any, adminConfig?: any) => zOriginal.ZodAny;
+    /**
+     * Explicit Metadata injection helper
+     */
+    cms: <T extends zOriginal.ZodTypeAny>(schema: T, meta: zOriginal.GlobalMeta["opaca"]) => T;
+    z: typeof zOriginal.z;
+    default: typeof zOriginal.z;
+    ZodType: zOriginal.z.core.$constructor<zOriginal.ZodType>;
+    core: typeof zOriginal.core;
+    globalRegistry: zOriginal.z.core.$ZodRegistry<zOriginal.GlobalMeta, zOriginal.z.core.$ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>>>;
+    registry: typeof zOriginal.core.registry;
+    config: typeof zOriginal.core.config;
+    $output: typeof zOriginal.core.$output;
+    $input: typeof zOriginal.core.$input;
+    $brand: typeof zOriginal.core.$brand;
+    clone: typeof zOriginal.core.util.clone;
+    regexes: typeof zOriginal.core.regexes;
+    treeifyError: typeof zOriginal.core.treeifyError;
+    prettifyError: typeof zOriginal.core.prettifyError;
+    formatError: typeof zOriginal.core.formatError;
+    flattenError: typeof zOriginal.core.flattenError;
+    TimePrecision: {
+        readonly Any: null;
+        readonly Minute: -1;
+        readonly Second: 0;
+        readonly Millisecond: 3;
+        readonly Microsecond: 6;
+    };
+    util: typeof zOriginal.core.util;
+    NEVER: never;
+    toJSONSchema: typeof zOriginal.core.toJSONSchema;
+    fromJSONSchema: typeof zOriginal.fromJSONSchema;
+    locales: typeof zOriginal.core.locales;
+    ZodISODateTime: zOriginal.z.core.$constructor<zOriginal.z.ZodISODateTime, zOriginal.z.core.$ZodISODateTimeDef>;
+    ZodISODate: zOriginal.z.core.$constructor<zOriginal.z.ZodISODate, zOriginal.z.core.$ZodStringFormatDef<"date">>;
+    ZodISOTime: zOriginal.z.core.$constructor<zOriginal.z.ZodISOTime, zOriginal.z.core.$ZodISOTimeDef>;
+    ZodISODuration: zOriginal.z.core.$constructor<zOriginal.z.ZodISODuration, zOriginal.z.core.$ZodStringFormatDef<"duration">>;
+    iso: typeof zOriginal.iso;
+    coerce: typeof zOriginal.coerce;
+    string(params?: string | zOriginal.z.core.$ZodStringParams): zOriginal.ZodString;
+    string<T extends string>(params?: string | zOriginal.z.core.$ZodStringParams): zOriginal.z.core.$ZodType<T, T>;
+    email(params?: string | zOriginal.z.core.$ZodEmailParams): zOriginal.ZodEmail;
+    guid(params?: string | zOriginal.z.core.$ZodGUIDParams): zOriginal.ZodGUID;
+    uuid(params?: string | zOriginal.z.core.$ZodUUIDParams): zOriginal.ZodUUID;
+    uuidv4(params?: string | zOriginal.z.core.$ZodUUIDv4Params): zOriginal.ZodUUID;
+    uuidv6(params?: string | zOriginal.z.core.$ZodUUIDv6Params): zOriginal.ZodUUID;
+    uuidv7(params?: string | zOriginal.z.core.$ZodUUIDv7Params): zOriginal.ZodUUID;
+    url(params?: string | zOriginal.z.core.$ZodURLParams): zOriginal.ZodURL;
+    httpUrl(params?: string | Omit<zOriginal.z.core.$ZodURLParams, "protocol" | "hostname">): zOriginal.ZodURL;
+    emoji(params?: string | zOriginal.z.core.$ZodEmojiParams): zOriginal.ZodEmoji;
+    nanoid(params?: string | zOriginal.z.core.$ZodNanoIDParams): zOriginal.ZodNanoID;
+    cuid(params?: string | zOriginal.z.core.$ZodCUIDParams): zOriginal.ZodCUID;
+    cuid2(params?: string | zOriginal.z.core.$ZodCUID2Params): zOriginal.ZodCUID2;
+    ulid(params?: string | zOriginal.z.core.$ZodULIDParams): zOriginal.ZodULID;
+    xid(params?: string | zOriginal.z.core.$ZodXIDParams): zOriginal.ZodXID;
+    ksuid(params?: string | zOriginal.z.core.$ZodKSUIDParams): zOriginal.ZodKSUID;
+    ipv4(params?: string | zOriginal.z.core.$ZodIPv4Params): zOriginal.ZodIPv4;
+    mac(params?: string | zOriginal.z.core.$ZodMACParams): zOriginal.ZodMAC;
+    ipv6(params?: string | zOriginal.z.core.$ZodIPv6Params): zOriginal.ZodIPv6;
+    cidrv4(params?: string | zOriginal.z.core.$ZodCIDRv4Params): zOriginal.ZodCIDRv4;
+    cidrv6(params?: string | zOriginal.z.core.$ZodCIDRv6Params): zOriginal.ZodCIDRv6;
+    base64(params?: string | zOriginal.z.core.$ZodBase64Params): zOriginal.ZodBase64;
+    base64url(params?: string | zOriginal.z.core.$ZodBase64URLParams): zOriginal.ZodBase64URL;
+    e164(params?: string | zOriginal.z.core.$ZodE164Params): zOriginal.ZodE164;
+    jwt(params?: string | zOriginal.z.core.$ZodJWTParams): zOriginal.ZodJWT;
+    stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => zOriginal.z.core.util.MaybeAsync<unknown>) | RegExp, _params?: string | zOriginal.z.core.$ZodStringFormatParams): zOriginal.ZodCustomStringFormat<Format>;
+    hostname(_params?: string | zOriginal.z.core.$ZodStringFormatParams): zOriginal.ZodCustomStringFormat<"hostname">;
+    hex(_params?: string | zOriginal.z.core.$ZodStringFormatParams): zOriginal.ZodCustomStringFormat<"hex">;
+    hash<Alg extends zOriginal.z.core.util.HashAlgorithm, Enc extends zOriginal.z.core.util.HashEncoding = "hex">(alg: Alg, params?: {
+        enc?: Enc;
+    } & zOriginal.z.core.$ZodStringFormatParams): zOriginal.ZodCustomStringFormat<`${Alg}_${Enc}`>;
+    int(params?: string | zOriginal.z.core.$ZodCheckNumberFormatParams): zOriginal.ZodInt;
+    float32(params?: string | zOriginal.z.core.$ZodCheckNumberFormatParams): zOriginal.ZodFloat32;
+    float64(params?: string | zOriginal.z.core.$ZodCheckNumberFormatParams): zOriginal.ZodFloat64;
+    int32(params?: string | zOriginal.z.core.$ZodCheckNumberFormatParams): zOriginal.ZodInt32;
+    uint32(params?: string | zOriginal.z.core.$ZodCheckNumberFormatParams): zOriginal.ZodUInt32;
+    bigint(params?: string | zOriginal.z.core.$ZodBigIntParams): zOriginal.ZodBigInt;
+    int64(params?: string | zOriginal.z.core.$ZodBigIntFormatParams): zOriginal.ZodBigIntFormat;
+    uint64(params?: string | zOriginal.z.core.$ZodBigIntFormatParams): zOriginal.ZodBigIntFormat;
+    symbol(params?: string | zOriginal.z.core.$ZodSymbolParams): zOriginal.ZodSymbol;
+    any(): zOriginal.ZodAny;
+    unknown(): zOriginal.ZodUnknown;
+    never(params?: string | zOriginal.z.core.$ZodNeverParams): zOriginal.ZodNever;
+    array<T extends zOriginal.z.core.SomeType>(element: T, params?: string | zOriginal.z.core.$ZodArrayParams): zOriginal.ZodArray<T>;
+    keyof<T extends zOriginal.ZodObject>(schema: T): zOriginal.ZodEnum<zOriginal.z.core.util.KeysEnum<T["_zod"]["output"]>>;
+    object<T extends zOriginal.z.core.$ZodLooseShape = Partial<Record<never, zOriginal.z.core.SomeType>>>(shape?: T, params?: string | zOriginal.z.core.$ZodObjectParams): zOriginal.ZodObject<zOriginal.z.core.util.Writeable<T>, zOriginal.z.core.$strip>;
+    strictObject<T extends zOriginal.z.core.$ZodLooseShape>(shape: T, params?: string | zOriginal.z.core.$ZodObjectParams): zOriginal.ZodObject<T, zOriginal.z.core.$strict>;
+    looseObject<T extends zOriginal.z.core.$ZodLooseShape>(shape: T, params?: string | zOriginal.z.core.$ZodObjectParams): zOriginal.ZodObject<T, zOriginal.z.core.$loose>;
+    union<const T extends readonly zOriginal.z.core.SomeType[]>(options: T, params?: string | zOriginal.z.core.$ZodUnionParams): zOriginal.ZodUnion<T>;
+    xor<const T extends readonly zOriginal.z.core.SomeType[]>(options: T, params?: string | zOriginal.z.core.$ZodXorParams): zOriginal.ZodXor<T>;
+    discriminatedUnion<Types extends readonly [zOriginal.z.core.$ZodTypeDiscriminable, ...zOriginal.z.core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | zOriginal.z.core.$ZodDiscriminatedUnionParams): zOriginal.ZodDiscriminatedUnion<Types, Disc>;
+    intersection<T extends zOriginal.z.core.SomeType, U extends zOriginal.z.core.SomeType>(left: T, right: U): zOriginal.ZodIntersection<T, U>;
+    tuple<T extends readonly [zOriginal.z.core.SomeType, ...zOriginal.z.core.SomeType[]]>(items: T, params?: string | zOriginal.z.core.$ZodTupleParams): zOriginal.ZodTuple<T, null>;
+    tuple<T extends readonly [zOriginal.z.core.SomeType, ...zOriginal.z.core.SomeType[]], Rest extends zOriginal.z.core.SomeType>(items: T, rest: Rest, params?: string | zOriginal.z.core.$ZodTupleParams): zOriginal.ZodTuple<T, Rest>;
+    tuple(items: [], params?: string | zOriginal.z.core.$ZodTupleParams): zOriginal.ZodTuple<[], null>;
+    record<Key extends zOriginal.z.core.$ZodRecordKey, Value extends zOriginal.z.core.SomeType>(keyType: Key, valueType: Value, params?: string | zOriginal.z.core.$ZodRecordParams): zOriginal.ZodRecord<Key, Value>;
+    partialRecord<Key extends zOriginal.z.core.$ZodRecordKey, Value extends zOriginal.z.core.SomeType>(keyType: Key, valueType: Value, params?: string | zOriginal.z.core.$ZodRecordParams): zOriginal.ZodRecord<Key & zOriginal.z.core.$partial, Value>;
+    looseRecord<Key extends zOriginal.z.core.$ZodRecordKey, Value extends zOriginal.z.core.SomeType>(keyType: Key, valueType: Value, params?: string | zOriginal.z.core.$ZodRecordParams): zOriginal.ZodRecord<Key, Value>;
+    map<Key extends zOriginal.z.core.SomeType, Value extends zOriginal.z.core.SomeType>(keyType: Key, valueType: Value, params?: string | zOriginal.z.core.$ZodMapParams): zOriginal.ZodMap<Key, Value>;
+    set<Value extends zOriginal.z.core.SomeType>(valueType: Value, params?: string | zOriginal.z.core.$ZodSetParams): zOriginal.ZodSet<Value>;
+    nativeEnum<T extends zOriginal.z.core.util.EnumLike>(entries: T, params?: string | zOriginal.z.core.$ZodEnumParams): zOriginal.ZodEnum<T>;
+    literal<const T extends ReadonlyArray<zOriginal.z.core.util.Literal>>(value: T, params?: string | zOriginal.z.core.$ZodLiteralParams): zOriginal.ZodLiteral<T[number]>;
+    literal<const T extends zOriginal.z.core.util.Literal>(value: T, params?: string | zOriginal.z.core.$ZodLiteralParams): zOriginal.ZodLiteral<T>;
+    transform<I = unknown, O = I>(fn: (input: I, ctx: zOriginal.z.core.ParsePayload) => O): zOriginal.ZodTransform<Awaited<O>, I>;
+    optional<T extends zOriginal.z.core.SomeType>(innerType: T): zOriginal.ZodOptional<T>;
+    exactOptional<T extends zOriginal.z.core.SomeType>(innerType: T): zOriginal.ZodExactOptional<T>;
+    nullable<T extends zOriginal.z.core.SomeType>(innerType: T): zOriginal.ZodNullable<T>;
+    nullish<T extends zOriginal.z.core.SomeType>(innerType: T): zOriginal.ZodOptional<zOriginal.ZodNullable<T>>;
+    _default<T extends zOriginal.z.core.SomeType>(innerType: T, defaultValue: zOriginal.z.core.util.NoUndefined<zOriginal.z.core.output<T>> | (() => zOriginal.z.core.util.NoUndefined<zOriginal.z.core.output<T>>)): zOriginal.ZodDefault<T>;
+    prefault<T extends zOriginal.z.core.SomeType>(innerType: T, defaultValue: zOriginal.z.core.input<T> | (() => zOriginal.z.core.input<T>)): zOriginal.ZodPrefault<T>;
+    nonoptional<T extends zOriginal.z.core.SomeType>(innerType: T, params?: string | zOriginal.z.core.$ZodNonOptionalParams): zOriginal.ZodNonOptional<T>;
+    success<T extends zOriginal.z.core.SomeType>(innerType: T): zOriginal.ZodSuccess<T>;
+    nan(params?: string | zOriginal.z.core.$ZodNaNParams): zOriginal.ZodNaN;
+    pipe<const A extends zOriginal.z.core.SomeType, B extends zOriginal.z.core.$ZodType<unknown, zOriginal.z.core.output<A>> = zOriginal.z.core.$ZodType<unknown, zOriginal.z.core.output<A>, zOriginal.z.core.$ZodTypeInternals<unknown, zOriginal.z.core.output<A>>>>(in_: A, out: B | zOriginal.z.core.$ZodType<unknown, zOriginal.z.core.output<A>>): zOriginal.ZodPipe<A, B>;
+    codec<const A extends zOriginal.z.core.SomeType, B extends zOriginal.z.core.SomeType = zOriginal.z.core.$ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>>>(in_: A, out: B, params: {
+        decode: (value: zOriginal.z.core.output<A>, payload: zOriginal.z.core.ParsePayload<zOriginal.z.core.output<A>>) => zOriginal.z.core.util.MaybeAsync<zOriginal.z.core.input<B>>;
+        encode: (value: zOriginal.z.core.input<B>, payload: zOriginal.z.core.ParsePayload<zOriginal.z.core.input<B>>) => zOriginal.z.core.util.MaybeAsync<zOriginal.z.core.output<A>>;
+    }): zOriginal.ZodCodec<A, B>;
+    readonly<T extends zOriginal.z.core.SomeType>(innerType: T): zOriginal.ZodReadonly<T>;
+    templateLiteral<const Parts extends zOriginal.z.core.$ZodTemplateLiteralPart[]>(parts: Parts, params?: string | zOriginal.z.core.$ZodTemplateLiteralParams): zOriginal.ZodTemplateLiteral<zOriginal.z.core.$PartsToTemplateLiteral<Parts>>;
+    lazy<T extends zOriginal.z.core.SomeType>(getter: () => T): zOriginal.ZodLazy<T>;
+    promise<T extends zOriginal.z.core.SomeType>(innerType: T): zOriginal.ZodPromise<T>;
+    _function(): zOriginal.ZodFunction;
+    _function<const In extends ReadonlyArray<zOriginal.z.core.$ZodType>>(params: {
+        input: In;
+    }): zOriginal.ZodFunction<zOriginal.ZodTuple<In, null>, zOriginal.z.core.$ZodFunctionOut>;
+    _function<const In extends ReadonlyArray<zOriginal.z.core.$ZodType>, const Out extends zOriginal.z.core.$ZodFunctionOut = zOriginal.z.core.$ZodFunctionOut>(params: {
+        input: In;
+        output: Out;
+    }): zOriginal.ZodFunction<zOriginal.ZodTuple<In, null>, Out>;
+    _function<const In extends zOriginal.z.core.$ZodFunctionIn = zOriginal.z.core.$ZodFunctionArgs>(params: {
+        input: In;
+    }): zOriginal.ZodFunction<In, zOriginal.z.core.$ZodFunctionOut>;
+    _function<const Out extends zOriginal.z.core.$ZodFunctionOut = zOriginal.z.core.$ZodFunctionOut>(params: {
+        output: Out;
+    }): zOriginal.ZodFunction<zOriginal.z.core.$ZodFunctionIn, Out>;
+    _function<In extends zOriginal.z.core.$ZodFunctionIn = zOriginal.z.core.$ZodFunctionArgs, Out extends zOriginal.z.core.$ZodType = zOriginal.z.core.$ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>>>(params?: {
+        input: In;
+        output: Out;
+    }): zOriginal.ZodFunction<In, Out>;
+    check<O = unknown>(fn: zOriginal.z.core.CheckFn<O>): zOriginal.z.core.$ZodCheck<O>;
+    custom<O>(fn?: (data: unknown) => unknown, _params?: string | zOriginal.z.core.$ZodCustomParams | undefined): zOriginal.ZodCustom<O, O>;
+    refine<T>(fn: (arg: NoInfer<T>) => zOriginal.z.core.util.MaybeAsync<unknown>, _params?: string | zOriginal.z.core.$ZodCustomParams): zOriginal.z.core.$ZodCheck<T>;
+    superRefine<T>(fn: (arg: T, payload: zOriginal.z.core.$RefinementCtx<T>) => void | Promise<void>): zOriginal.z.core.$ZodCheck<T>;
+    json(params?: string | zOriginal.z.core.$ZodCustomParams): zOriginal.ZodJSONSchema;
+    preprocess<A, U extends zOriginal.z.core.SomeType, B = unknown>(fn: (arg: B, ctx: zOriginal.z.core.$RefinementCtx) => A, schema: U): zOriginal.ZodPipe<zOriginal.ZodTransform<A, B>, U>;
+    _ZodString: zOriginal.z.core.$constructor<zOriginal._ZodString>;
+    ZodString: zOriginal.z.core.$constructor<zOriginal.ZodString>;
+    ZodStringFormat: zOriginal.z.core.$constructor<zOriginal.ZodStringFormat>;
+    ZodEmail: zOriginal.z.core.$constructor<zOriginal.ZodEmail>;
+    ZodGUID: zOriginal.z.core.$constructor<zOriginal.ZodGUID>;
+    ZodUUID: zOriginal.z.core.$constructor<zOriginal.ZodUUID>;
+    ZodURL: zOriginal.z.core.$constructor<zOriginal.ZodURL>;
+    ZodEmoji: zOriginal.z.core.$constructor<zOriginal.ZodEmoji>;
+    ZodNanoID: zOriginal.z.core.$constructor<zOriginal.ZodNanoID>;
+    ZodCUID: zOriginal.z.core.$constructor<zOriginal.ZodCUID>;
+    ZodCUID2: zOriginal.z.core.$constructor<zOriginal.ZodCUID2>;
+    ZodULID: zOriginal.z.core.$constructor<zOriginal.ZodULID>;
+    ZodXID: zOriginal.z.core.$constructor<zOriginal.ZodXID>;
+    ZodKSUID: zOriginal.z.core.$constructor<zOriginal.ZodKSUID>;
+    ZodIPv4: zOriginal.z.core.$constructor<zOriginal.ZodIPv4>;
+    ZodMAC: zOriginal.z.core.$constructor<zOriginal.ZodMAC>;
+    ZodIPv6: zOriginal.z.core.$constructor<zOriginal.ZodIPv6>;
+    ZodCIDRv4: zOriginal.z.core.$constructor<zOriginal.ZodCIDRv4>;
+    ZodCIDRv6: zOriginal.z.core.$constructor<zOriginal.ZodCIDRv6>;
+    ZodBase64: zOriginal.z.core.$constructor<zOriginal.ZodBase64>;
+    ZodBase64URL: zOriginal.z.core.$constructor<zOriginal.ZodBase64URL>;
+    ZodE164: zOriginal.z.core.$constructor<zOriginal.ZodE164>;
+    ZodJWT: zOriginal.z.core.$constructor<zOriginal.ZodJWT>;
+    ZodCustomStringFormat: zOriginal.z.core.$constructor<zOriginal.ZodCustomStringFormat>;
+    ZodNumber: zOriginal.z.core.$constructor<zOriginal.ZodNumber>;
+    ZodNumberFormat: zOriginal.z.core.$constructor<zOriginal.ZodNumberFormat>;
+    ZodBoolean: zOriginal.z.core.$constructor<zOriginal.ZodBoolean>;
+    ZodBigInt: zOriginal.z.core.$constructor<zOriginal.ZodBigInt>;
+    ZodBigIntFormat: zOriginal.z.core.$constructor<zOriginal.ZodBigIntFormat>;
+    ZodSymbol: zOriginal.z.core.$constructor<zOriginal.ZodSymbol>;
+    ZodUndefined: zOriginal.z.core.$constructor<zOriginal.ZodUndefined>;
+    undefined: typeof zOriginal.undefined;
+    ZodNull: zOriginal.z.core.$constructor<zOriginal.ZodNull>;
+    null: typeof zOriginal.null;
+    ZodAny: zOriginal.z.core.$constructor<zOriginal.ZodAny>;
+    ZodUnknown: zOriginal.z.core.$constructor<zOriginal.ZodUnknown>;
+    ZodNever: zOriginal.z.core.$constructor<zOriginal.ZodNever>;
+    ZodVoid: zOriginal.z.core.$constructor<zOriginal.ZodVoid>;
+    void: typeof zOriginal.void;
+    ZodDate: zOriginal.z.core.$constructor<zOriginal.ZodDate>;
+    ZodArray: zOriginal.z.core.$constructor<zOriginal.ZodArray>;
+    ZodObject: zOriginal.z.core.$constructor<zOriginal.ZodObject>;
+    ZodUnion: zOriginal.z.core.$constructor<zOriginal.ZodUnion>;
+    ZodXor: zOriginal.z.core.$constructor<zOriginal.ZodXor>;
+    ZodDiscriminatedUnion: zOriginal.z.core.$constructor<zOriginal.ZodDiscriminatedUnion>;
+    ZodIntersection: zOriginal.z.core.$constructor<zOriginal.ZodIntersection>;
+    ZodTuple: zOriginal.z.core.$constructor<zOriginal.ZodTuple>;
+    ZodRecord: zOriginal.z.core.$constructor<zOriginal.ZodRecord>;
+    ZodMap: zOriginal.z.core.$constructor<zOriginal.ZodMap>;
+    ZodSet: zOriginal.z.core.$constructor<zOriginal.ZodSet>;
+    ZodEnum: zOriginal.z.core.$constructor<zOriginal.ZodEnum>;
+    enum: typeof zOriginal.enum;
+    ZodLiteral: zOriginal.z.core.$constructor<zOriginal.ZodLiteral>;
+    ZodFile: zOriginal.z.core.$constructor<zOriginal.ZodFile>;
+    ZodTransform: zOriginal.z.core.$constructor<zOriginal.ZodTransform>;
+    ZodOptional: zOriginal.z.core.$constructor<zOriginal.ZodOptional>;
+    ZodExactOptional: zOriginal.z.core.$constructor<zOriginal.ZodExactOptional>;
+    ZodNullable: zOriginal.z.core.$constructor<zOriginal.ZodNullable>;
+    ZodDefault: zOriginal.z.core.$constructor<zOriginal.ZodDefault>;
+    ZodPrefault: zOriginal.z.core.$constructor<zOriginal.ZodPrefault>;
+    ZodNonOptional: zOriginal.z.core.$constructor<zOriginal.ZodNonOptional>;
+    ZodSuccess: zOriginal.z.core.$constructor<zOriginal.ZodSuccess>;
+    ZodCatch: zOriginal.z.core.$constructor<zOriginal.ZodCatch>;
+    catch: typeof zOriginal.catch;
+    ZodNaN: zOriginal.z.core.$constructor<zOriginal.ZodNaN>;
+    ZodPipe: zOriginal.z.core.$constructor<zOriginal.ZodPipe>;
+    ZodCodec: zOriginal.z.core.$constructor<zOriginal.ZodCodec>;
+    ZodReadonly: zOriginal.z.core.$constructor<zOriginal.ZodReadonly>;
+    ZodTemplateLiteral: zOriginal.z.core.$constructor<zOriginal.ZodTemplateLiteral>;
+    ZodLazy: zOriginal.z.core.$constructor<zOriginal.ZodLazy>;
+    ZodPromise: zOriginal.z.core.$constructor<zOriginal.ZodPromise>;
+    ZodFunction: zOriginal.z.core.$constructor<zOriginal.ZodFunction>;
+    function: typeof zOriginal._function;
+    ZodCustom: zOriginal.z.core.$constructor<zOriginal.ZodCustom>;
+    describe: typeof zOriginal.core.describe;
+    meta: typeof zOriginal.core.meta;
+    instanceof: typeof zOriginal.instanceof;
+    stringbool: (_params?: string | zOriginal.z.core.$ZodStringBoolParams) => zOriginal.ZodCodec<zOriginal.ZodString, zOriginal.ZodBoolean>;
+    lt: typeof zOriginal.core._lt;
+    lte: typeof zOriginal.core._lte;
+    gt: typeof zOriginal.core._gt;
+    gte: typeof zOriginal.core._gte;
+    positive: typeof zOriginal.core._positive;
+    negative: typeof zOriginal.core._negative;
+    nonpositive: typeof zOriginal.core._nonpositive;
+    nonnegative: typeof zOriginal.core._nonnegative;
+    multipleOf: typeof zOriginal.core._multipleOf;
+    maxSize: typeof zOriginal.core._maxSize;
+    minSize: typeof zOriginal.core._minSize;
+    size: typeof zOriginal.core._size;
+    maxLength: typeof zOriginal.core._maxLength;
+    minLength: typeof zOriginal.core._minLength;
+    length: typeof zOriginal.core._length;
+    regex: typeof zOriginal.core._regex;
+    lowercase: typeof zOriginal.core._lowercase;
+    uppercase: typeof zOriginal.core._uppercase;
+    includes: typeof zOriginal.core._includes;
+    startsWith: typeof zOriginal.core._startsWith;
+    endsWith: typeof zOriginal.core._endsWith;
+    property: typeof zOriginal.core._property;
+    mime: typeof zOriginal.core._mime;
+    overwrite: typeof zOriginal.core._overwrite;
+    normalize: typeof zOriginal.core._normalize;
+    trim: typeof zOriginal.core._trim;
+    toLowerCase: typeof zOriginal.core._toLowerCase;
+    toUpperCase: typeof zOriginal.core._toUpperCase;
+    slugify: typeof zOriginal.core._slugify;
+    ZodError: zOriginal.z.core.$constructor<zOriginal.ZodError>;
+    ZodRealError: zOriginal.z.core.$constructor<zOriginal.ZodError>;
+    parse: <T extends zOriginal.z.core.$ZodType>(schema: T, value: unknown, _ctx?: zOriginal.z.core.ParseContext<zOriginal.z.core.$ZodIssue>, _params?: {
+        callee?: zOriginal.z.core.util.AnyFunc;
+        Err?: zOriginal.z.core.$ZodErrorClass;
+    }) => zOriginal.z.core.output<T>;
+    parseAsync: <T extends zOriginal.z.core.$ZodType>(schema: T, value: unknown, _ctx?: zOriginal.z.core.ParseContext<zOriginal.z.core.$ZodIssue>, _params?: {
+        callee?: zOriginal.z.core.util.AnyFunc;
+        Err?: zOriginal.z.core.$ZodErrorClass;
+    }) => Promise<zOriginal.z.core.output<T>>;
+    safeParse: <T extends zOriginal.z.core.$ZodType>(schema: T, value: unknown, _ctx?: zOriginal.z.core.ParseContext<zOriginal.z.core.$ZodIssue>) => zOriginal.ZodSafeParseResult<zOriginal.z.core.output<T>>;
+    safeParseAsync: <T extends zOriginal.z.core.$ZodType>(schema: T, value: unknown, _ctx?: zOriginal.z.core.ParseContext<zOriginal.z.core.$ZodIssue>) => Promise<zOriginal.ZodSafeParseResult<zOriginal.z.core.output<T>>>;
+    encode: <T extends zOriginal.z.core.$ZodType>(schema: T, value: zOriginal.z.core.output<T>, _ctx?: zOriginal.z.core.ParseContext<zOriginal.z.core.$ZodIssue>) => zOriginal.z.core.input<T>;
+    decode: <T extends zOriginal.z.core.$ZodType>(schema: T, value: zOriginal.z.core.input<T>, _ctx?: zOriginal.z.core.ParseContext<zOriginal.z.core.$ZodIssue>) => zOriginal.z.core.output<T>;
+    encodeAsync: <T extends zOriginal.z.core.$ZodType>(schema: T, value: zOriginal.z.core.output<T>, _ctx?: zOriginal.z.core.ParseContext<zOriginal.z.core.$ZodIssue>) => Promise<zOriginal.z.core.input<T>>;
+    decodeAsync: <T extends zOriginal.z.core.$ZodType>(schema: T, value: zOriginal.z.core.input<T>, _ctx?: zOriginal.z.core.ParseContext<zOriginal.z.core.$ZodIssue>) => Promise<zOriginal.z.core.output<T>>;
+    safeEncode: <T extends zOriginal.z.core.$ZodType>(schema: T, value: zOriginal.z.core.output<T>, _ctx?: zOriginal.z.core.ParseContext<zOriginal.z.core.$ZodIssue>) => zOriginal.ZodSafeParseResult<zOriginal.z.core.input<T>>;
+    safeDecode: <T extends zOriginal.z.core.$ZodType>(schema: T, value: zOriginal.z.core.input<T>, _ctx?: zOriginal.z.core.ParseContext<zOriginal.z.core.$ZodIssue>) => zOriginal.ZodSafeParseResult<zOriginal.z.core.output<T>>;
+    safeEncodeAsync: <T extends zOriginal.z.core.$ZodType>(schema: T, value: zOriginal.z.core.output<T>, _ctx?: zOriginal.z.core.ParseContext<zOriginal.z.core.$ZodIssue>) => Promise<zOriginal.ZodSafeParseResult<zOriginal.z.core.input<T>>>;
+    safeDecodeAsync: <T extends zOriginal.z.core.$ZodType>(schema: T, value: zOriginal.z.core.input<T>, _ctx?: zOriginal.z.core.ParseContext<zOriginal.z.core.$ZodIssue>) => Promise<zOriginal.ZodSafeParseResult<zOriginal.z.core.output<T>>>;
+    setErrorMap(map: zOriginal.z.core.$ZodErrorMap): void;
+    getErrorMap(): zOriginal.z.core.$ZodErrorMap<zOriginal.z.core.$ZodIssue> | undefined;
+    ZodIssueCode: {
+        readonly invalid_type: "invalid_type";
+        readonly too_big: "too_big";
+        readonly too_small: "too_small";
+        readonly invalid_format: "invalid_format";
+        readonly not_multiple_of: "not_multiple_of";
+        readonly unrecognized_keys: "unrecognized_keys";
+        readonly invalid_union: "invalid_union";
+        readonly invalid_key: "invalid_key";
+        readonly invalid_element: "invalid_element";
+        readonly invalid_value: "invalid_value";
+        readonly custom: "custom";
+    };
+    ZodSchema: zOriginal.z.core.$constructor<zOriginal.ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>>, zOriginal.z.core.$ZodTypeDef>;
+    Schema: zOriginal.z.core.$constructor<zOriginal.ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>>, zOriginal.z.core.$ZodTypeDef>;
+    ZodFirstPartyTypeKind: typeof zOriginal.ZodFirstPartyTypeKind;
+};
+export declare const $ZodOptional: zOriginal.z.core.$constructor<zOriginal.ZodOptional<zOriginal.z.core.$ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>>>, zOriginal.z.core.$ZodOptionalDef<zOriginal.z.core.$ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>>>>;
+export declare const $ZodNullable: zOriginal.z.core.$constructor<zOriginal.ZodNullable<zOriginal.z.core.$ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>>>, zOriginal.z.core.$ZodNullableDef<zOriginal.z.core.$ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>>>>;
+export declare const $ZodDefault: zOriginal.z.core.$constructor<zOriginal.ZodDefault<zOriginal.z.core.$ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>>>, zOriginal.z.core.$ZodDefaultDef<zOriginal.z.core.$ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>>>>;
+export declare const $ZodString: zOriginal.z.core.$constructor<zOriginal.ZodString, zOriginal.z.core.$ZodStringDef>;
+export declare const $ZodNumber: zOriginal.z.core.$constructor<zOriginal.ZodNumber, zOriginal.z.core.$ZodNumberDef>;
+export declare const $ZodBoolean: zOriginal.z.core.$constructor<zOriginal.ZodBoolean, zOriginal.z.core.$ZodBooleanDef>;
+export declare const $ZodDate: zOriginal.z.core.$constructor<zOriginal.ZodDate, zOriginal.z.core.$ZodDateDef>;
+export declare const $ZodEnum: zOriginal.z.core.$constructor<zOriginal.ZodEnum<Readonly<Record<string, zOriginal.z.core.util.EnumValue>>>, zOriginal.z.core.$ZodEnumDef<Readonly<Record<string, zOriginal.z.core.util.EnumValue>>>>;
+export declare const $ZodObject: zOriginal.z.core.$constructor<zOriginal.ZodObject<zOriginal.z.core.$ZodLooseShape, zOriginal.z.core.$strip>, zOriginal.z.core.$ZodObjectDef<zOriginal.z.core.$ZodLooseShape>>;
+export declare const $ZodArray: zOriginal.z.core.$constructor<zOriginal.ZodArray<zOriginal.z.core.$ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>>>, zOriginal.z.core.$ZodArrayDef<zOriginal.z.core.$ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>>>>;
+export declare const $ZodDiscriminatedUnion: zOriginal.z.core.$constructor<zOriginal.ZodDiscriminatedUnion<readonly zOriginal.z.core.$ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>>[], string>, zOriginal.z.core.$ZodDiscriminatedUnionDef<readonly zOriginal.z.core.$ZodType<unknown, unknown, zOriginal.z.core.$ZodTypeInternals<unknown, unknown>>[], string>>;
+export type { infer, ZodArray, ZodBoolean, ZodDate, ZodEnum, ZodNumber, ZodObject, ZodRawShape, ZodString, ZodType, ZodTypeAny, } from "zod";

package/dist/server/admin-router.d.ts

@@ -1,7 +1,7 @@
 import { Hono } from "hono";
 import type { Auth } from "../auth";
-import type { OpacaConfig } from "../types";
 import type { ApiContextVariables } from "../server/router";
+import type { OpacaConfig } from "../types";
 export declare function createAdminRouter(config: OpacaConfig, settings: Record<string, any>, state: {
     auth: Auth | undefined;
 }): Hono<{

package/dist/server/collection-router.d.ts

@@ -1,7 +1,7 @@
 import type { Hono } from "hono";
 import type { Auth } from "../auth";
-import type { OpacaConfig } from "../types";
 import type { ApiContextVariables } from "../server/router";
+import type { OpacaConfig } from "../types";
 export declare function mountCollectionRoutes(router: Hono<{
     Variables: ApiContextVariables;
 }>, config: OpacaConfig, state: {

package/dist/server/graphql.d.ts

@@ -0,0 +1,6 @@
+import { GraphQLSchema } from "graphql";
+import type { Auth } from "../auth";
+import type { OpacaConfig } from "../types";
+export declare function generateGraphQLSchema(config: OpacaConfig, state: {
+    auth: Auth | undefined;
+}): GraphQLSchema;