mina-attestations/build/src/dynamic/schema.d.ts

Private Attestations on Mina

import { type Bool, type From, type InferProvable, type InferValue, type ProvableHashable, UInt64 } from 'o1js';
import { type ProvableHashableType, type ProvableHashableWide } from '../o1js-missing.ts';
import { NestedProvable } from '../nested.ts';
import type { DynamicString } from './dynamic-string.ts';
import type { DynamicArrayClass } from './dynamic-array.ts';
import type { DynamicRecordClass } from './dynamic-record.ts';
export { Schema };
type SchemaType = ProvableHashableType | SchemaString | SchemaNumber | SchemaBoolean | {
    type: 'array';
    inner: SchemaType;
} | {
    [key in string]: SchemaType;
};
type SchemaString = {
    type: 'string';
};
type SchemaNumber = {
    type: 'number';
};
type SchemaBoolean = {
    type: 'boolean';
};
type SchemaArray<T extends SchemaType = SchemaType> = {
    type: 'array';
    inner: T;
};
declare function Schema<T extends Record<string, SchemaType>>(schema: T): {
    schema: T;
    from(value: SchemaInput<T>): SchemaOutput<T>;
    nestedType(value: SchemaOutput<T>): { [key in keyof T]: ProvableTypeOf<T[key]>; };
    type(value: SchemaOutput<T>): ProvableHashableWide<{ [key in keyof T]: InferProvable<ProvableTypeOf<T[key]>>; }, { [key in keyof T]: InferValue<ProvableTypeOf<T[key]>>; }, { [key in keyof T]: From<ProvableTypeOf<T[key]>>; }>;
};
declare namespace Schema {
    var String: {
        type: "string";
    };
    var Number: {
        type: "number";
    };
    var Boolean: {
        type: "boolean";
    };
    var Array: <T extends SchemaType>(inner: T) => SchemaArray<T>;
    var nestedType: <S>(value: S) => unknown extends S ? NestedProvable : { [key in keyof S]: ProvableHashableType<S[key], S[key]>; };
    var type: <S>(value: S) => ProvableHashable<S, S>;
}
type SchemaInput<T = SchemaType> = T extends ProvableHashableType ? From<T> : T extends SchemaString ? string : T extends SchemaNumber ? number : T extends SchemaBoolean ? boolean : T extends SchemaArray<infer U> ? SchemaInput<U>[] : T extends {
    [key in string]: SchemaType;
} ? {
    [key in keyof T]: SchemaInput<T[key]>;
} : never;
type SchemaOutput<T = SchemaType> = T extends ProvableHashableType ? InferProvable<T> : T extends SchemaString ? string : T extends SchemaNumber ? UInt64 : T extends SchemaBoolean ? boolean : T extends SchemaArray<infer U> ? SchemaOutput<U>[] : {
    [key in keyof T]: SchemaOutput<T[key]>;
};
/**
 * Type version of `provableTypeOf()`.
 */
type ProvableTypeOf<T> = T extends ProvableHashableType ? T : T extends SchemaString ? ReturnType<typeof DynamicString> : T extends SchemaNumber ? typeof UInt64 : T extends SchemaBoolean ? typeof Bool : T extends SchemaArray<infer U> ? DynamicArrayClass<InferProvable<ProvableTypeOf<U>>, InferValue<ProvableTypeOf<U>>> : T extends {
    [key in string]: SchemaType;
} ? DynamicRecordClass<{
    [key in keyof T]: ProvableTypeOf<T[key]>;
}> : never;