zeed 1.2.2 → 1.3.0

package/dist/rounding-B_PQ6XE8.d.cts

@@ -0,0 +1,39 @@
+//#region src/common/data/rounding.d.ts
+type RoundingMode = (value: number) => number;
+declare function isHalf(value: number): boolean;
+declare function isEven(value: number): boolean;
+declare const roundUp: RoundingMode;
+declare const roundDown: RoundingMode;
+declare const roundHalfUp: RoundingMode;
+/**
+ * Round a number with half values to nearest odd integer.
+ */
+declare const roundHalfOdd: RoundingMode;
+/**
+ * Round a number with half values to nearest integer farthest from zero.
+ */
+declare const roundHalfAwayFromZero: RoundingMode;
+/**
+ * Round a number with half values down.
+ */
+declare const roundHalfDown: RoundingMode;
+/**
+ * Round a number with half values to nearest even integer.
+ * https://wiki.c2.com/?BankersRounding
+ */
+declare const roundHalfEven: RoundingMode;
+/**
+ * Round a number with half values to nearest integer closest to zero.
+ */
+declare const roundHalfTowardsZero: RoundingMode;
+/**
+ * This is useful for percentages that should sum up to 100.
+ * But can also be fine tuned.
+ *
+ * Original from https://github.com/super-ienien/percent-round
+ */
+declare function roundArrayOfNumbersToMatchSum(ipt: number[], max?: number, decimalPlaces?: number): number[];
+declare function roundArrayOfObjectsToMatchSum<T extends Record<string, any>>(arr: T[], name: string, max?: number, decimalPlaces?: number): T[];
+//#endregion
+export { roundArrayOfObjectsToMatchSum as a, roundHalfDown as c, roundHalfTowardsZero as d, roundHalfUp as f, roundArrayOfNumbersToMatchSum as i, roundHalfEven as l, isEven as n, roundDown as o, roundUp as p, isHalf as r, roundHalfAwayFromZero as s, RoundingMode as t, roundHalfOdd as u };
+//# sourceMappingURL=rounding-B_PQ6XE8.d.cts.map

package/dist/rounding-D17a64Na.d.mts

@@ -0,0 +1,39 @@
+//#region src/common/data/rounding.d.ts
+type RoundingMode = (value: number) => number;
+declare function isHalf(value: number): boolean;
+declare function isEven(value: number): boolean;
+declare const roundUp: RoundingMode;
+declare const roundDown: RoundingMode;
+declare const roundHalfUp: RoundingMode;
+/**
+ * Round a number with half values to nearest odd integer.
+ */
+declare const roundHalfOdd: RoundingMode;
+/**
+ * Round a number with half values to nearest integer farthest from zero.
+ */
+declare const roundHalfAwayFromZero: RoundingMode;
+/**
+ * Round a number with half values down.
+ */
+declare const roundHalfDown: RoundingMode;
+/**
+ * Round a number with half values to nearest even integer.
+ * https://wiki.c2.com/?BankersRounding
+ */
+declare const roundHalfEven: RoundingMode;
+/**
+ * Round a number with half values to nearest integer closest to zero.
+ */
+declare const roundHalfTowardsZero: RoundingMode;
+/**
+ * This is useful for percentages that should sum up to 100.
+ * But can also be fine tuned.
+ *
+ * Original from https://github.com/super-ienien/percent-round
+ */
+declare function roundArrayOfNumbersToMatchSum(ipt: number[], max?: number, decimalPlaces?: number): number[];
+declare function roundArrayOfObjectsToMatchSum<T extends Record<string, any>>(arr: T[], name: string, max?: number, decimalPlaces?: number): T[];
+//#endregion
+export { roundArrayOfObjectsToMatchSum as a, roundHalfDown as c, roundHalfTowardsZero as d, roundHalfUp as f, roundArrayOfNumbersToMatchSum as i, roundHalfEven as l, isEven as n, roundDown as o, roundUp as p, isHalf as r, roundHalfAwayFromZero as s, RoundingMode as t, roundHalfOdd as u };
+//# sourceMappingURL=rounding-D17a64Na.d.mts.map

package/dist/rpc-5Ln_Xp7t.d.cts

@@ -0,0 +1,47 @@
+import { _ as LoggerInterface } from "./log-base-omQ8fkjE.cjs";
+import { t as UseStringHashPool } from "./string-hash-pool-9wgUkvIQ.cjs";
+import { t as Pipe } from "./pipe-Dw4EU9A_.cjs";
+
+//#region src/common/msg/rpc.d.ts
+type ArgumentsType<T> = T extends ((...args: infer A) => any) ? A : never;
+type ReturnType<T> = T extends ((...args: any) => infer R) ? R : never;
+interface RPCOptionsBasic extends Pipe {
+  /** No return values expected */
+  onlyEvents?: boolean;
+  /** Maximum timeout for waiting for response, in milliseconds */
+  timeout?: number;
+  /** Custom logger */
+  log?: LoggerInterface;
+  /** Custom error handler */
+  onError?: (error: Error, functionName: string, args: any[]) => boolean | void;
+  /** Custom error handler for timeouts */
+  onTimeoutError?: (functionName: string, args: any[]) => boolean | void;
+  /** Throw execptions. Default: true */
+  exceptions?: boolean;
+  /**  */
+  stringHashPool?: UseStringHashPool;
+}
+interface RPCOptions<Remote> extends RPCOptionsBasic {
+  /** Names of remote functions that do not need response. */
+  eventNames?: (keyof Remote)[];
+}
+interface RPCFn<T> {
+  /** Call the remote function and wait for the result. */
+  (...args: ArgumentsType<T>): Promise<Awaited<ReturnType<T>>>;
+  /** Send event without asking for response */
+  asEvent: (...args: ArgumentsType<T>) => void;
+}
+type RPCReturn<RemoteFunctions> = { [K in keyof RemoteFunctions]: RPCFn<RemoteFunctions[K]> };
+declare enum RPCMode {
+  request = 1,
+  event = 2,
+  resolve = 3,
+  reject = 4
+}
+type RPCMessage = [mode: RPCMode, id: number, method: string | number | any, ...any];
+declare function useRPC<LocalFunctions, RemoteFunctions = LocalFunctions>(functions: LocalFunctions, options: RPCOptions<RemoteFunctions>): RPCReturn<RemoteFunctions>;
+declare function useRPCHub(options: RPCOptionsBasic): <LocalFunctions, RemoteFunctions = LocalFunctions>(additionalFunctions?: LocalFunctions, additionalEventNames?: string[]) => RPCReturn<RemoteFunctions>;
+type UseRPCHubType = ReturnType<typeof useRPCHub>;
+//#endregion
+export { RPCOptions as a, ReturnType as c, useRPCHub as d, RPCMode as i, UseRPCHubType as l, RPCFn as n, RPCOptionsBasic as o, RPCMessage as r, RPCReturn as s, ArgumentsType as t, useRPC as u };
+//# sourceMappingURL=rpc-5Ln_Xp7t.d.cts.map

package/dist/rpc-DX1FYLVn.d.mts

@@ -0,0 +1,47 @@
+import { _ as LoggerInterface } from "./log-base-BP-JwjKY.mjs";
+import { t as UseStringHashPool } from "./string-hash-pool-BHDYziM7.mjs";
+import { t as Pipe } from "./pipe-Dgfm7NNL.mjs";
+
+//#region src/common/msg/rpc.d.ts
+type ArgumentsType<T> = T extends ((...args: infer A) => any) ? A : never;
+type ReturnType<T> = T extends ((...args: any) => infer R) ? R : never;
+interface RPCOptionsBasic extends Pipe {
+  /** No return values expected */
+  onlyEvents?: boolean;
+  /** Maximum timeout for waiting for response, in milliseconds */
+  timeout?: number;
+  /** Custom logger */
+  log?: LoggerInterface;
+  /** Custom error handler */
+  onError?: (error: Error, functionName: string, args: any[]) => boolean | void;
+  /** Custom error handler for timeouts */
+  onTimeoutError?: (functionName: string, args: any[]) => boolean | void;
+  /** Throw execptions. Default: true */
+  exceptions?: boolean;
+  /**  */
+  stringHashPool?: UseStringHashPool;
+}
+interface RPCOptions<Remote> extends RPCOptionsBasic {
+  /** Names of remote functions that do not need response. */
+  eventNames?: (keyof Remote)[];
+}
+interface RPCFn<T> {
+  /** Call the remote function and wait for the result. */
+  (...args: ArgumentsType<T>): Promise<Awaited<ReturnType<T>>>;
+  /** Send event without asking for response */
+  asEvent: (...args: ArgumentsType<T>) => void;
+}
+type RPCReturn<RemoteFunctions> = { [K in keyof RemoteFunctions]: RPCFn<RemoteFunctions[K]> };
+declare enum RPCMode {
+  request = 1,
+  event = 2,
+  resolve = 3,
+  reject = 4
+}
+type RPCMessage = [mode: RPCMode, id: number, method: string | number | any, ...any];
+declare function useRPC<LocalFunctions, RemoteFunctions = LocalFunctions>(functions: LocalFunctions, options: RPCOptions<RemoteFunctions>): RPCReturn<RemoteFunctions>;
+declare function useRPCHub(options: RPCOptionsBasic): <LocalFunctions, RemoteFunctions = LocalFunctions>(additionalFunctions?: LocalFunctions, additionalEventNames?: string[]) => RPCReturn<RemoteFunctions>;
+type UseRPCHubType = ReturnType<typeof useRPCHub>;
+//#endregion
+export { RPCOptions as a, ReturnType as c, useRPCHub as d, RPCMode as i, UseRPCHubType as l, RPCFn as n, RPCOptionsBasic as o, RPCMessage as r, RPCReturn as s, ArgumentsType as t, useRPC as u };
+//# sourceMappingURL=rpc-DX1FYLVn.d.mts.map

package/dist/schema-BNke0iHR.d.cts

@@ -0,0 +1,200 @@
+//#region src/common/schema/schema.d.ts
+/**
+ * Metadata interface for type descriptions and additional properties
+ */
+interface TypeMeta {
+  desc?: string;
+}
+/**
+ * Core Type class for schema validation and type inference
+ * Implements StandardSchemaV1 for cross-library compatibility
+ */
+declare class Type<T = unknown> {
+  readonly type: string;
+  _default?: any;
+  _optional?: boolean;
+  _meta?: TypeMeta;
+  _check?: (obj: any) => boolean;
+  _object?: any;
+  _type?: any;
+  _union?: any;
+  _enumValues?: any;
+  _args?: any;
+  _ret?: any;
+  _info?: any;
+  constructor(name: string, options?: Partial<Type<T>>);
+  /**
+   * Standard Schema V1 compliance property
+   * Provides a standard interface for validation and type inference
+   */
+  get '~standard'(): any;
+  /**
+   * Validation method for standard-schema compliance
+   */
+  validate(value: any): any;
+  /**
+   * Creates a copy of the type with new properties merged
+   */
+  private _cloneWithProps;
+  /**
+   * Helper to copy type properties when creating new type instances
+   */
+  private static _copyTypeProperties;
+  /**
+   * Marks the type as optional, meaning it can be undefined
+   * This is useful for properties that are not required.
+   */
+  optional(): Type<T | undefined>;
+  /**
+   * Sets a default value for the type, which will be used if the value is not provided
+   * The default value can be a function that receives the schema as argument, or a static value.
+   */
+  default(value: T | ((schema?: this) => T)): Type<T>;
+  /**
+   * Props / Metadata for the type, like description or other properties
+   */
+  meta(meta: TypeMeta): Type<T>;
+  /**
+   * Sets the `desc` property for the type, which is a human-readable description
+   */
+  describe(msg: string): Type<T>;
+  /**
+   * Extends the type with an object, merging the properties
+   */
+  extend<O>(obj: O): Type<T & TypeObject<O>>;
+  /**
+   * Picks certain keys from an object schema
+   */
+  pick<K extends keyof T>(keys: Record<K, true>): Type<Pick<T, K>>;
+  /**
+   * Omits certain keys from an object schema
+   */
+  omit<K extends keyof T>(keys: Record<K, true>): Type<Omit<T, K>>;
+  /**
+   * Helper method to modify object properties with a transformation function
+   */
+  private _transformObjectProperties;
+  /**
+   * Makes some or all properties of an object schema optional
+   */
+  partial(): Type<Partial<T>>;
+  partial<K extends keyof T>(keys: Record<K, true>): Type<Partial<Pick<T, K>> & Omit<T, K>>;
+  /**
+   * Makes some or all properties of an object schema required
+   */
+  required(): Type<Required<T>>;
+  required<K extends keyof T>(keys: Record<K, true>): Type<Required<Pick<T, K>> & Omit<T, K>>;
+  /**
+   * Helper method to clone a type with optional flag
+   */
+  private static _cloneTypeWithOptional;
+}
+/**
+ * Type inference utility for extracting the TypeScript type from a schema Type
+ */
+type Infer<T> = T extends Type<infer TT> ? TT : never;
+/**
+ * Creates a string type validator
+ */
+declare function string(): Type<string>;
+/**
+ * Creates a number type validator
+ */
+declare function number(): Type<number>;
+/**
+ * Creates an integer type validator
+ */
+declare function int(): Type<number>;
+/**
+ * Creates a boolean type validator
+ */
+declare function boolean(): Type<boolean>;
+/**
+ * Creates a none type validator (undefined | null)
+ * Like undefined | null in TS and nil in Swift
+ */
+declare function none(): Type<undefined>;
+/**
+ * Creates an any type validator that accepts any non-null value
+ */
+declare function any<T = any>(): Type<T>;
+declare const float: typeof number;
+declare const double: typeof number;
+declare const real: typeof number;
+/**
+ * Utility type to make object properties optional if their value type includes undefined.
+ * @category Schema
+ */
+type TypeObjectFixOptional<T> = { [K in keyof T as undefined extends T[K] ? K : never]?: T[K] & {} } & { [K in keyof T as undefined extends T[K] ? never : K]: T[K] & {} };
+/**
+ * Utility type for pretty-printing object types
+ */
+type TypeObjectPretty<V> = Extract<{ [K in keyof V]: V[K] }, unknown>;
+/**
+ * Main object type utility
+ */
+type TypeObject<T> = TypeObjectPretty<TypeObjectFixOptional<{ [K in keyof T]: Infer<T[K]> }>>;
+/**
+ * Creates an object type validator with specified properties
+ */
+declare function object<T>(tobj: T): Type<TypeObject<T>>;
+/**
+ * Creates a record type validator (object with string keys and uniform value type)
+ */
+declare function record<T extends Type>(valueType: T): Type<Record<string, Infer<T>>>;
+/**
+ * Utility type for union of types.
+ * @category Schema
+ */
+type TypeUnion<T extends Type<any>[]> = { [K in keyof T]: T[K] extends Type<infer U> ? U : never }[number];
+/**
+ * Creates a union type validator (like `string | number | boolean`)
+ */
+declare function union<T extends Type<any>[]>(options: T): Type<TypeUnion<T>>;
+/**
+ * Utility type for literal types.
+ * @category Schema
+ */
+type TypeLiterals = string | number | bigint | boolean;
+/**
+ * Creates a literal value validator
+ */
+declare function literal<T extends TypeLiterals>(value: T): Type<T>;
+/**
+ * Creates a string literal union validator (like `"a" | "b" | "c"`)
+ */
+declare function stringLiterals<const T extends readonly string[]>(values: T): Type<T[number]>;
+/**
+ * Utility type for tuple types.
+ * @category Schema
+ */
+type TypeTuple<T extends readonly Type[]> = { -readonly [K in keyof T]: T[K] extends Type<infer U> ? U : never };
+/**
+ * Output type for TypeArray.
+ * @category Schema
+ */
+type TypeArrayOutput<Head extends Type[], Rest extends Type | undefined> = [...TypeTuple<Head>, ...(Rest extends Type ? Infer<Rest>[] : [])];
+/**
+ * Utility type for array types.
+ * @category Schema
+ */
+type TypeArray<Head extends Type[] = Type[], Rest extends Type | undefined = Type | undefined> = Type<TypeArrayOutput<Head, Rest>>;
+/**
+ * Creates a tuple type validator with fixed length and types e.g. [string, number, boolean]
+ */
+declare function tuple<const T extends readonly Type[]>(items: T): Type<TypeTuple<T>>;
+/**
+ * Creates an array type validator for a specific item type
+ */
+declare function array<T>(itemType: Type<T>): Type<T[]>;
+/**
+ * Creates a regular function type validator
+ */
+declare function func<TypeFuncArgs extends [Type<unknown>, ...Type<any>[]] | [], TypeFuncRet = Type, T = (...args: TypeTuple<TypeFuncArgs>) => Infer<TypeFuncRet>>(args: TypeFuncArgs, ret: TypeFuncRet): Type<T>;
+/**
+ * Creates an RPC function type validator that takes one argument and returns a promise
+ */
+declare function rpc<TypeRpcInfo extends Type<unknown> | undefined = undefined, TypeRpcRet extends Type<unknown> = Type<void>, T = (TypeRpcInfo extends undefined ? () => Infer<TypeRpcRet> : (info: Infer<TypeRpcInfo>) => Infer<TypeRpcRet> | Promise<Infer<TypeRpcRet>>)>(info?: TypeRpcInfo, ret?: TypeRpcRet): Type<T>;
+//#endregion
+export { rpc as C, union as D, tuple as E, record as S, stringLiterals as T, literal as _, TypeLiterals as a, object as b, TypeTuple as c, array as d, boolean as f, int as g, func as h, TypeArrayOutput as i, TypeUnion as l, float as m, Type as n, TypeMeta as o, double as p, TypeArray as r, TypeObjectFixOptional as s, Infer as t, any as u, none as v, string as w, real as x, number as y };
+//# sourceMappingURL=schema-BNke0iHR.d.cts.map

package/dist/schema-eMFkYY24.d.mts

@@ -0,0 +1,200 @@
+//#region src/common/schema/schema.d.ts
+/**
+ * Metadata interface for type descriptions and additional properties
+ */
+interface TypeMeta {
+  desc?: string;
+}
+/**
+ * Core Type class for schema validation and type inference
+ * Implements StandardSchemaV1 for cross-library compatibility
+ */
+declare class Type<T = unknown> {
+  readonly type: string;
+  _default?: any;
+  _optional?: boolean;
+  _meta?: TypeMeta;
+  _check?: (obj: any) => boolean;
+  _object?: any;
+  _type?: any;
+  _union?: any;
+  _enumValues?: any;
+  _args?: any;
+  _ret?: any;
+  _info?: any;
+  constructor(name: string, options?: Partial<Type<T>>);
+  /**
+   * Standard Schema V1 compliance property
+   * Provides a standard interface for validation and type inference
+   */
+  get '~standard'(): any;
+  /**
+   * Validation method for standard-schema compliance
+   */
+  validate(value: any): any;
+  /**
+   * Creates a copy of the type with new properties merged
+   */
+  private _cloneWithProps;
+  /**
+   * Helper to copy type properties when creating new type instances
+   */
+  private static _copyTypeProperties;
+  /**
+   * Marks the type as optional, meaning it can be undefined
+   * This is useful for properties that are not required.
+   */
+  optional(): Type<T | undefined>;
+  /**
+   * Sets a default value for the type, which will be used if the value is not provided
+   * The default value can be a function that receives the schema as argument, or a static value.
+   */
+  default(value: T | ((schema?: this) => T)): Type<T>;
+  /**
+   * Props / Metadata for the type, like description or other properties
+   */
+  meta(meta: TypeMeta): Type<T>;
+  /**
+   * Sets the `desc` property for the type, which is a human-readable description
+   */
+  describe(msg: string): Type<T>;
+  /**
+   * Extends the type with an object, merging the properties
+   */
+  extend<O>(obj: O): Type<T & TypeObject<O>>;
+  /**
+   * Picks certain keys from an object schema
+   */
+  pick<K extends keyof T>(keys: Record<K, true>): Type<Pick<T, K>>;
+  /**
+   * Omits certain keys from an object schema
+   */
+  omit<K extends keyof T>(keys: Record<K, true>): Type<Omit<T, K>>;
+  /**
+   * Helper method to modify object properties with a transformation function
+   */
+  private _transformObjectProperties;
+  /**
+   * Makes some or all properties of an object schema optional
+   */
+  partial(): Type<Partial<T>>;
+  partial<K extends keyof T>(keys: Record<K, true>): Type<Partial<Pick<T, K>> & Omit<T, K>>;
+  /**
+   * Makes some or all properties of an object schema required
+   */
+  required(): Type<Required<T>>;
+  required<K extends keyof T>(keys: Record<K, true>): Type<Required<Pick<T, K>> & Omit<T, K>>;
+  /**
+   * Helper method to clone a type with optional flag
+   */
+  private static _cloneTypeWithOptional;
+}
+/**
+ * Type inference utility for extracting the TypeScript type from a schema Type
+ */
+type Infer<T> = T extends Type<infer TT> ? TT : never;
+/**
+ * Creates a string type validator
+ */
+declare function string(): Type<string>;
+/**
+ * Creates a number type validator
+ */
+declare function number(): Type<number>;
+/**
+ * Creates an integer type validator
+ */
+declare function int(): Type<number>;
+/**
+ * Creates a boolean type validator
+ */
+declare function boolean(): Type<boolean>;
+/**
+ * Creates a none type validator (undefined | null)
+ * Like undefined | null in TS and nil in Swift
+ */
+declare function none(): Type<undefined>;
+/**
+ * Creates an any type validator that accepts any non-null value
+ */
+declare function any<T = any>(): Type<T>;
+declare const float: typeof number;
+declare const double: typeof number;
+declare const real: typeof number;
+/**
+ * Utility type to make object properties optional if their value type includes undefined.
+ * @category Schema
+ */
+type TypeObjectFixOptional<T> = { [K in keyof T as undefined extends T[K] ? K : never]?: T[K] & {} } & { [K in keyof T as undefined extends T[K] ? never : K]: T[K] & {} };
+/**
+ * Utility type for pretty-printing object types
+ */
+type TypeObjectPretty<V> = Extract<{ [K in keyof V]: V[K] }, unknown>;
+/**
+ * Main object type utility
+ */
+type TypeObject<T> = TypeObjectPretty<TypeObjectFixOptional<{ [K in keyof T]: Infer<T[K]> }>>;
+/**
+ * Creates an object type validator with specified properties
+ */
+declare function object<T>(tobj: T): Type<TypeObject<T>>;
+/**
+ * Creates a record type validator (object with string keys and uniform value type)
+ */
+declare function record<T extends Type>(valueType: T): Type<Record<string, Infer<T>>>;
+/**
+ * Utility type for union of types.
+ * @category Schema
+ */
+type TypeUnion<T extends Type<any>[]> = { [K in keyof T]: T[K] extends Type<infer U> ? U : never }[number];
+/**
+ * Creates a union type validator (like `string | number | boolean`)
+ */
+declare function union<T extends Type<any>[]>(options: T): Type<TypeUnion<T>>;
+/**
+ * Utility type for literal types.
+ * @category Schema
+ */
+type TypeLiterals = string | number | bigint | boolean;
+/**
+ * Creates a literal value validator
+ */
+declare function literal<T extends TypeLiterals>(value: T): Type<T>;
+/**
+ * Creates a string literal union validator (like `"a" | "b" | "c"`)
+ */
+declare function stringLiterals<const T extends readonly string[]>(values: T): Type<T[number]>;
+/**
+ * Utility type for tuple types.
+ * @category Schema
+ */
+type TypeTuple<T extends readonly Type[]> = { -readonly [K in keyof T]: T[K] extends Type<infer U> ? U : never };
+/**
+ * Output type for TypeArray.
+ * @category Schema
+ */
+type TypeArrayOutput<Head extends Type[], Rest extends Type | undefined> = [...TypeTuple<Head>, ...(Rest extends Type ? Infer<Rest>[] : [])];
+/**
+ * Utility type for array types.
+ * @category Schema
+ */
+type TypeArray<Head extends Type[] = Type[], Rest extends Type | undefined = Type | undefined> = Type<TypeArrayOutput<Head, Rest>>;
+/**
+ * Creates a tuple type validator with fixed length and types e.g. [string, number, boolean]
+ */
+declare function tuple<const T extends readonly Type[]>(items: T): Type<TypeTuple<T>>;
+/**
+ * Creates an array type validator for a specific item type
+ */
+declare function array<T>(itemType: Type<T>): Type<T[]>;
+/**
+ * Creates a regular function type validator
+ */
+declare function func<TypeFuncArgs extends [Type<unknown>, ...Type<any>[]] | [], TypeFuncRet = Type, T = (...args: TypeTuple<TypeFuncArgs>) => Infer<TypeFuncRet>>(args: TypeFuncArgs, ret: TypeFuncRet): Type<T>;
+/**
+ * Creates an RPC function type validator that takes one argument and returns a promise
+ */
+declare function rpc<TypeRpcInfo extends Type<unknown> | undefined = undefined, TypeRpcRet extends Type<unknown> = Type<void>, T = (TypeRpcInfo extends undefined ? () => Infer<TypeRpcRet> : (info: Infer<TypeRpcInfo>) => Infer<TypeRpcRet> | Promise<Infer<TypeRpcRet>>)>(info?: TypeRpcInfo, ret?: TypeRpcRet): Type<T>;
+//#endregion
+export { rpc as C, union as D, tuple as E, record as S, stringLiterals as T, literal as _, TypeLiterals as a, object as b, TypeTuple as c, array as d, boolean as f, int as g, func as h, TypeArrayOutput as i, TypeUnion as l, float as m, Type as n, TypeMeta as o, double as p, TypeArray as r, TypeObjectFixOptional as s, Infer as t, any as u, none as v, string as w, real as x, number as y };
+//# sourceMappingURL=schema-eMFkYY24.d.mts.map

package/dist/schema-standard-BxRHxZeM.d.cts

@@ -0,0 +1,59 @@
+//#region src/common/schema/schema-standard.d.ts
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Schema. */
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+  /** Infers the output type of a Standard Schema. */
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+}
+//#endregion
+export { StandardSchemaV1 as t };
+//# sourceMappingURL=schema-standard-BxRHxZeM.d.cts.map