@xpadev-net/niconicomments 0.2.73 → 0.2.75

package/dist/bundle.d.ts

@@ -94,9 +94,9 @@ declare class FlashComment extends BaseComment {
             type: "spacer";
             char: string;
             charWidth: number;
-            count: number;
             isButton?: boolean | undefined;
             font?: "defont" | "gulim" | "simsun" | undefined;
+            count: number;
         } | {
             type: "text";
             content: string;
@@ -156,7 +156,11 @@ declare const index_d$4_FlashComment: typeof FlashComment;
 type index_d$4_HTML5Comment = HTML5Comment;
 declare const index_d$4_HTML5Comment: typeof HTML5Comment;
 declare namespace index_d$4 {
-  export { index_d$4_BaseComment as BaseComment, index_d$4_FlashComment as FlashComment, index_d$4_HTML5Comment as HTML5Comment };
+  export {
+    index_d$4_BaseComment as BaseComment,
+    index_d$4_FlashComment as FlashComment,
+    index_d$4_HTML5Comment as HTML5Comment,
+  };
 }
 
 type ConfigItem<T> = T | MultiConfigItem<T>;
@@ -269,7 +273,7 @@ type BaseConfig = {
         };
     };
 };
-type Config = Partial<BaseConfig>;
+type Config$1 = Partial<BaseConfig>;
 
 type Position = {
     x: number;
@@ -321,1074 +325,1942 @@ interface CommentEventMap {
 }
 
 /**
- * Pipe action context type.
- */
-interface PipeActionContext {
-    type: string;
-    expects: string | null;
-    message: ErrorMessage | undefined;
-    requirement: unknown;
-}
-/**
- * Valid action result type.
+ * Fallback type.
  */
-interface ValidActionResult<TOutput> {
-    /**
-     * The pipe output.
-     */
-    output: TOutput;
-    /**
-     * The pipe issues.
-     */
-    issues?: undefined;
-}
+type Fallback<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>> = MaybeReadonly<InferOutput<TSchema>> | ((dataset?: OutputDataset<InferOutput<TSchema>, InferIssue<TSchema>>, config?: Config<InferIssue<TSchema>>) => MaybeReadonly<InferOutput<TSchema>>);
 /**
- * Invalid action result type.
+ * Schema with fallback type.
  */
-interface InvalidActionResult {
-    /**
-     * The pipe output.
-     */
-    output?: undefined;
+type SchemaWithFallback<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TFallback extends Fallback<TSchema>> = TSchema & {
     /**
-     * The pipe issues.
+     * The fallback value.
      */
-    issues: PipeActionIssues;
-}
+    readonly fallback: TFallback;
+};
+
 /**
- * Pipe action result type.
+ * Fallback async type.
  */
-type PipeActionResult<TOutput> = ValidActionResult<TOutput> | InvalidActionResult;
+type FallbackAsync<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = MaybeReadonly<InferOutput<TSchema>> | ((dataset?: OutputDataset<InferOutput<TSchema>, InferIssue<TSchema>>, config?: Config<InferIssue<TSchema>>) => MaybePromise<MaybeReadonly<InferOutput<TSchema>>>);
 /**
- * Base validation type.
+ * Schema with fallback async type.
  */
-interface BaseValidation<TInput = any> {
+type SchemaWithFallbackAsync<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TFallback extends FallbackAsync<TSchema>> = Omit<TSchema, 'async' | '~standard' | '~run'> & {
     /**
-     * The validation type.
-     */
-    type: string;
-    /**
-     * The expected property.
+     * The fallback value.
      */
-    expects: string | null;
-    /**
-     * The error message.
-     */
-    message: ErrorMessage | undefined;
+    readonly fallback: TFallback;
     /**
      * Whether it's async.
      */
-    async: false;
+    readonly async: true;
     /**
-     * The validation requirement.
+     * The Standard Schema properties.
+     *
+     * @internal
      */
-    requirement: unknown;
+    readonly '~standard': StandardProps<InferInput<TSchema>, InferOutput<TSchema>>;
     /**
-     * Parses unknown input based on its requirement.
+     * Parses unknown input values.
      *
-     * @param input The input to be parsed.
+     * @param dataset The input dataset.
+     * @param config The configuration.
      *
-     * @returns The pipe action result.
+     * @returns The output dataset.
      *
      * @internal
      */
-    _parse(input: TInput): PipeActionResult<TInput>;
-}
+    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<InferOutput<TSchema>, InferIssue<TSchema>>>;
+};
+
 /**
- * Base validation async type.
+ * Schema with pipe type.
  */
-interface BaseValidationAsync<TInput = any> {
-    /**
-     * The validation type.
-     */
-    type: string;
-    /**
-     * The expected property.
-     */
-    expects: string | null;
-    /**
-     * The error message.
-     */
-    message: ErrorMessage | undefined;
+type SchemaWithPipe<TPipe extends readonly [
+    BaseSchema<unknown, unknown, BaseIssue<unknown>>,
+    ...PipeItem<any, unknown, BaseIssue<unknown>>[]
+]> = Omit<FirstTupleItem<TPipe>, 'pipe' | '~standard' | '~run' | '~types'> & {
     /**
-     * Whether it's async.
+     * The pipe items.
      */
-    async: true;
+    readonly pipe: TPipe;
     /**
-     * The validation requirement.
+     * The Standard Schema properties.
+     *
+     * @internal
      */
-    requirement: unknown;
+    readonly '~standard': StandardProps<InferInput<FirstTupleItem<TPipe>>, InferOutput<LastTupleItem<TPipe>>>;
     /**
-     * Parses unknown input based on its requirement.
+     * Parses unknown input values.
      *
-     * @param input The input to be parsed.
+     * @param dataset The input dataset.
+     * @param config The configuration.
      *
-     * @returns The pipe action result.
+     * @returns The output dataset.
      *
      * @internal
      */
-    _parse(input: TInput): Promise<PipeActionResult<TInput>>;
-}
+    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => OutputDataset<InferOutput<LastTupleItem<TPipe>>, InferIssue<TPipe[number]>>;
+    /**
+     * The input, output and issue type.
+     *
+     * @internal
+     */
+    readonly '~types'?: {
+        readonly input: InferInput<FirstTupleItem<TPipe>>;
+        readonly output: InferOutput<LastTupleItem<TPipe>>;
+        readonly issue: InferIssue<TPipe[number]>;
+    } | undefined;
+};
+
 /**
- * Base transformation type.
+ * Schema with pipe async type.
  */
-interface BaseTransformation<TInput = any> {
+type SchemaWithPipeAsync<TPipe extends readonly [
+    (BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>),
+    ...(PipeItem<any, unknown, BaseIssue<unknown>> | PipeItemAsync<any, unknown, BaseIssue<unknown>>)[]
+]> = Omit<FirstTupleItem<TPipe>, 'async' | 'pipe' | '~standard' | '~run' | '~types'> & {
     /**
-     * The transformation type.
+     * The pipe items.
      */
-    type: string;
+    readonly pipe: TPipe;
     /**
      * Whether it's async.
      */
-    async: false;
+    readonly async: true;
     /**
-     * Parses unknown input based on its requirement.
+     * The Standard Schema properties.
      *
-     * @param input The input to be parsed.
+     * @internal
+     */
+    readonly '~standard': StandardProps<InferInput<FirstTupleItem<TPipe>>, InferOutput<LastTupleItem<TPipe>>>;
+    /**
+     * Parses unknown input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
      *
-     * @returns The pipe action result.
+     * @returns The output dataset.
      *
      * @internal
      */
-    _parse(input: TInput): PipeActionResult<TInput>;
-}
+    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<InferOutput<LastTupleItem<TPipe>>, InferIssue<TPipe[number]>>>;
+    /**
+     * The input, output and issue type.
+     *
+     * @internal
+     */
+    readonly '~types'?: {
+        readonly input: InferInput<FirstTupleItem<TPipe>>;
+        readonly output: InferOutput<LastTupleItem<TPipe>>;
+        readonly issue: InferIssue<TPipe[number]>;
+    } | undefined;
+};
+
 /**
- * Base transformation async type.
+ * Base metadata interface.
  */
-interface BaseTransformationAsync<TInput = any> {
+interface BaseMetadata<TInput> {
     /**
-     * The transformation type.
+     * The object kind.
      */
-    type: string;
+    readonly kind: 'metadata';
     /**
-     * Whether it's async.
+     * The metadata type.
      */
-    async: true;
+    readonly type: string;
     /**
-     * Parses unknown input based on its requirement.
-     *
-     * @param input The input to be parsed.
-     *
-     * @returns The pipe action result.
+     * The metadata reference.
+     */
+    readonly reference: (...args: any[]) => BaseMetadata<any>;
+    /**
+     * The input, output and issue type.
      *
      * @internal
      */
-    _parse(input: TInput): Promise<PipeActionResult<TInput>>;
+    readonly '~types'?: {
+        readonly input: TInput;
+        readonly output: TInput;
+        readonly issue: never;
+    } | undefined;
 }
-/**
- * Pipe type.
- */
-type Pipe<TInput> = (BaseValidation<TInput> | BaseTransformation<TInput>)[];
-/**
- * Pipe async type.
- */
-type PipeAsync<TInput> = (BaseValidation<TInput> | BaseValidationAsync<TInput> | BaseTransformation<TInput> | BaseTransformationAsync<TInput>)[];
 
 /**
- * Issue reason type.
- */
-type IssueReason = 'any' | 'array' | 'bigint' | 'blob' | 'boolean' | 'date' | 'intersect' | 'function' | 'instance' | 'map' | 'number' | 'object' | 'record' | 'set' | 'special' | 'string' | 'symbol' | 'tuple' | 'undefined' | 'union' | 'unknown' | 'variant' | 'type';
-/**
- * Unknown path item type.
+ * Unknown dataset interface.
  */
-interface UnknownPathItem {
-    type: 'unknown';
-    origin: 'key' | 'value';
-    input: unknown;
-    key: unknown;
+interface UnknownDataset {
+    /**
+     * Whether is's typed.
+     */
+    typed?: false;
+    /**
+     * The dataset value.
+     */
     value: unknown;
+    /**
+     * The dataset issues.
+     */
+    issues?: undefined;
 }
 /**
- * Path item type.
+ * Success dataset interface.
  */
-type PathItem = ArrayPathItem | MapPathItem | ObjectPathItem | RecordPathItem | SetPathItem | TuplePathItem | UnknownPathItem;
-/**
- * Issue path type.
- */
-type IssuePath = [PathItem, ...PathItem[]];
-/**
- * Schema issue type.
- */
-interface SchemaIssue extends Omit<SchemaConfig, 'message'> {
+interface SuccessDataset<TValue> {
     /**
-     * The issue reason.
+     * Whether is's typed.
      */
-    reason: IssueReason;
+    typed: true;
     /**
-     * The context name.
+     * The dataset value.
      */
-    context: string;
+    value: TValue;
     /**
-     * The raw input data.
+     * The dataset issues.
      */
-    input: unknown;
+    issues?: undefined;
+}
+/**
+ * Partial dataset interface.
+ */
+interface PartialDataset<TValue, TIssue extends BaseIssue<unknown>> {
     /**
-     * The expected input.
+     * Whether is's typed.
      */
-    expected: string | null;
+    typed: true;
     /**
-     * The received input.
+     * The dataset value.
      */
-    received: string;
+    value: TValue;
     /**
-     * The error message.
+     * The dataset issues.
      */
-    message: string;
+    issues: [TIssue, ...TIssue[]];
+}
+/**
+ * Failure dataset interface.
+ */
+interface FailureDataset<TIssue extends BaseIssue<unknown>> {
     /**
-     * The validation requirement
+     * Whether is's typed.
      */
-    requirement?: unknown;
+    typed: false;
     /**
-     * The issue path.
+     * The dataset value.
      */
-    path?: IssuePath;
+    value: unknown;
     /**
-     * The sub issues.
+     * The dataset issues.
      */
-    issues?: SchemaIssues;
+    issues: [TIssue, ...TIssue[]];
 }
 /**
- * Schema issues type.
+ * Output dataset type.
  */
-type SchemaIssues = [SchemaIssue, ...SchemaIssue[]];
-/**
- * Pipe action issue type.
- */
-interface PipeActionIssue {
-    context: PipeActionContext;
-    reference: Function;
-    input: unknown;
-    label: string;
-    received?: string;
-    path?: IssuePath;
-}
-/**
- * Pipe action issues type.
- */
-type PipeActionIssues = [PipeActionIssue, ...PipeActionIssue[]];
+type OutputDataset<TValue, TIssue extends BaseIssue<unknown>> = SuccessDataset<TValue> | PartialDataset<TValue, TIssue> | FailureDataset<TIssue>;
 
 /**
- * Error message type.
- */
-type ErrorMessage = string | ((issue: SchemaIssue) => string);
-/**
- * The schema config type.
+ * The Standard Schema properties interface.
  */
-interface SchemaConfig {
+interface StandardProps<TInput, TOutput> {
     /**
-     * The selected language.
-     */
-    lang?: string;
-    /**
-     * The error message.
+     * The version number of the standard.
      */
-    message?: ErrorMessage;
+    readonly version: 1;
     /**
-     * Whether it was abort early.
+     * The vendor name of the schema library.
      */
-    abortEarly?: boolean;
+    readonly vendor: 'valibot';
     /**
-     * Whether the pipe was abort early.
+     * Validates unknown input values.
      */
-    abortPipeEarly?: boolean;
+    readonly validate: (value: unknown) => StandardResult<TOutput> | Promise<StandardResult<TOutput>>;
     /**
-     * Whether the pipe was skipped.
+     * Inferred types associated with the schema.
      */
-    skipPipe?: boolean;
+    readonly types?: StandardTypes<TInput, TOutput> | undefined;
 }
-
 /**
- * Typed schema result type.
+ * The result interface of the validate function.
+ */
+type StandardResult<TOutput> = StandardSuccessResult<TOutput> | StandardFailureResult;
+/**
+ * The result interface if validation succeeds.
  */
-interface TypedSchemaResult<TOutput> {
+interface StandardSuccessResult<TOutput> {
     /**
-     * Whether is's typed.
+     * The typed output value.
      */
-    typed: true;
+    readonly value: TOutput;
     /**
-     * The parse output.
+     * The non-existent issues.
      */
-    output: TOutput;
+    readonly issues?: undefined;
+}
+/**
+ * The result interface if validation fails.
+ */
+interface StandardFailureResult {
     /**
-     * The parse issues.
+     * The issues of failed validation.
      */
-    issues?: SchemaIssues;
+    readonly issues: readonly StandardIssue[];
 }
 /**
- * Untyped schema result type.
+ * The issue interface of the failure output.
  */
-interface UntypedSchemaResult {
+interface StandardIssue {
     /**
-     * Whether is's typed.
+     * The error message of the issue.
      */
-    typed: false;
+    readonly message: string;
     /**
-     * The parse output.
+     * The path of the issue, if any.
      */
-    output: unknown;
+    readonly path?: readonly (PropertyKey | StandardPathItem)[] | undefined;
+}
+/**
+ * The path item interface of the issue.
+ */
+interface StandardPathItem {
     /**
-     * The parse issues.
+     * The key of the path item.
      */
-    issues: SchemaIssues;
+    readonly key: PropertyKey;
 }
 /**
- * Schema result type.
+ * The Standard Schema types interface.
  */
-type SchemaResult<TOutput> = TypedSchemaResult<TOutput> | UntypedSchemaResult;
+interface StandardTypes<TInput, TOutput> {
+    /**
+     * The input type of the schema.
+     */
+    readonly input: TInput;
+    /**
+     * The output type of the schema.
+     */
+    readonly output: TOutput;
+}
+
 /**
- * Base schema type.
+ * Base schema interface.
  */
-interface BaseSchema<TInput = any, TOutput = TInput> {
+interface BaseSchema<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
+    /**
+     * The object kind.
+     */
+    readonly kind: 'schema';
     /**
      * The schema type.
      */
-    type: string;
+    readonly type: string;
+    /**
+     * The schema reference.
+     */
+    readonly reference: (...args: any[]) => BaseSchema<unknown, unknown, BaseIssue<unknown>>;
     /**
      * The expected property.
      */
-    expects: string;
+    readonly expects: string;
     /**
      * Whether it's async.
      */
-    async: false;
+    readonly async: false;
+    /**
+     * The Standard Schema properties.
+     *
+     * @internal
+     */
+    readonly '~standard': StandardProps<TInput, TOutput>;
     /**
-     * Parses unknown input based on its schema.
+     * Parses unknown input values.
      *
-     * @param input The input to be parsed.
-     * @param config The parse configuration.
+     * @param dataset The input dataset.
+     * @param config The configuration.
      *
-     * @returns The schema result.
+     * @returns The output dataset.
      *
      * @internal
      */
-    _parse(input: unknown, config?: SchemaConfig): SchemaResult<TOutput>;
+    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, TIssue>;
     /**
-     * Input and output type.
+     * The input, output and issue type.
      *
      * @internal
      */
-    _types?: {
-        input: TInput;
-        output: TOutput;
-    };
+    readonly '~types'?: {
+        readonly input: TInput;
+        readonly output: TOutput;
+        readonly issue: TIssue;
+    } | undefined;
 }
 /**
- * Base schema async type.
+ * Base schema async interface.
  */
-interface BaseSchemaAsync<TInput = any, TOutput = TInput> {
+interface BaseSchemaAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseSchema<TInput, TOutput, TIssue>, 'reference' | 'async' | '~run'> {
     /**
-     * The schema type.
-     */
-    type: string;
-    /**
-     * The expected property.
+     * The schema reference.
      */
-    expects: string;
+    readonly reference: (...args: any[]) => BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>;
     /**
      * Whether it's async.
      */
-    async: true;
+    readonly async: true;
     /**
-     * Parses unknown input based on its schema.
+     * Parses unknown input values.
      *
-     * @param input The input to be parsed.
-     * @param config The parse configuration.
+     * @param dataset The input dataset.
+     * @param config The configuration.
      *
-     * @returns The schema result.
-     *
-     * @internal
-     */
-    _parse(input: unknown, config?: SchemaConfig): Promise<SchemaResult<TOutput>>;
-    /**
-     * Input and output type.
+     * @returns The output dataset.
      *
      * @internal
      */
-    _types?: {
-        input: TInput;
-        output: TOutput;
-    };
+    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, TIssue>>;
 }
-/**
- * Input inference type.
- */
-type Input<TSchema extends BaseSchema | BaseSchemaAsync> = NonNullable<TSchema['_types']>['input'];
-/**
- * Output inference type.
- */
-type Output<TSchema extends BaseSchema | BaseSchemaAsync> = NonNullable<TSchema['_types']>['output'];
-
-/**
- * Default type.
- */
-type Default<TSchema extends BaseSchema> = Input<TSchema> | (() => Input<TSchema> | undefined) | undefined;
-/**
- * Default async type.
- */
-type DefaultAsync<TSchema extends BaseSchema | BaseSchemaAsync> = Input<TSchema> | (() => Input<TSchema> | Promise<Input<TSchema> | undefined> | undefined) | undefined;
-/**
- * Maybe readonly type.
- */
-type MaybeReadonly<T> = T | Readonly<T>;
-/**
- * Resolve type.
- *
- * Hint: This type has no effect and is only used so that TypeScript displays
- * the final type in the preview instead of the utility types used.
- */
-type Resolve<T> = T;
-/**
- * Resolve object type.
- *
- * Hint: This type has no effect and is only used so that TypeScript displays
- * the final type in the preview instead of the utility types used.
- */
-type ResolveObject<T> = Resolve<{
-    [k in keyof T]: T[k];
-}>;
 
 /**
- * Array schema type.
+ * Base transformation interface.
  */
-interface ArraySchema<TItem extends BaseSchema, TOutput = Output<TItem>[]> extends BaseSchema<Input<TItem>[], TOutput> {
+interface BaseTransformation<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
     /**
-     * The schema type.
+     * The object kind.
      */
-    type: 'array';
+    readonly kind: 'transformation';
     /**
-     * The array item schema.
+     * The transformation type.
      */
-    item: TItem;
+    readonly type: string;
     /**
-     * The error message.
+     * The transformation reference.
      */
-    message: ErrorMessage | undefined;
+    readonly reference: (...args: any[]) => BaseTransformation<any, any, BaseIssue<unknown>>;
     /**
-     * The validation and transformation pipeline.
+     * Whether it's async.
      */
-    pipe: Pipe<Output<TItem>[]> | undefined;
-}
-
-/**
- * Array path item type.
- */
-interface ArrayPathItem {
-    type: 'array';
-    origin: 'value';
-    input: unknown[];
-    key: number;
-    value: unknown;
+    readonly async: false;
+    /**
+     * Transforms known input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    readonly '~run': (dataset: SuccessDataset<TInput>, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, BaseIssue<unknown> | TIssue>;
+    /**
+     * The input, output and issue type.
+     *
+     * @internal
+     */
+    readonly '~types'?: {
+        readonly input: TInput;
+        readonly output: TOutput;
+        readonly issue: TIssue;
+    } | undefined;
 }
-
 /**
- * Boolean schema type.
+ * Base transformation async interface.
  */
-interface BooleanSchema<TOutput = boolean> extends BaseSchema<boolean, TOutput> {
+interface BaseTransformationAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseTransformation<TInput, TOutput, TIssue>, 'reference' | 'async' | '~run'> {
     /**
-     * The schema type.
+     * The transformation reference.
      */
-    type: 'boolean';
+    readonly reference: (...args: any[]) => BaseTransformation<any, any, BaseIssue<unknown>> | BaseTransformationAsync<any, any, BaseIssue<unknown>>;
     /**
-     * The error message.
+     * Whether it's async.
      */
-    message: ErrorMessage | undefined;
+    readonly async: true;
     /**
-     * The validation and transformation pipeline.
+     * Transforms known input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
      */
-    pipe: Pipe<boolean> | undefined;
+    readonly '~run': (dataset: SuccessDataset<TInput>, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, BaseIssue<unknown> | TIssue>>;
 }
 
 /**
- * Enum type.
- */
-interface Enum {
-    [key: string]: string | number;
-    [key: number]: string;
-}
-/**
- * Native enum schema type.
+ * Base validation interface.
  */
-interface EnumSchema<TEnum extends Enum, TOutput = TEnum[keyof TEnum]> extends BaseSchema<TEnum[keyof TEnum], TOutput> {
+interface BaseValidation<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
     /**
-     * The schema type.
+     * The object kind.
      */
-    type: 'enum';
+    readonly kind: 'validation';
     /**
-     * The enum value.
+     * The validation type.
      */
-    enum: TEnum;
+    readonly type: string;
     /**
-     * The error message.
+     * The validation reference.
+     */
+    readonly reference: (...args: any[]) => BaseValidation<any, any, BaseIssue<unknown>>;
+    /**
+     * The expected property.
+     */
+    readonly expects: string | null;
+    /**
+     * Whether it's async.
+     */
+    readonly async: false;
+    /**
+     * Validates known input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    readonly '~run': (dataset: OutputDataset<TInput, BaseIssue<unknown>>, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, BaseIssue<unknown> | TIssue>;
+    /**
+     * The input, output and issue type.
+     *
+     * @internal
      */
-    message: ErrorMessage | undefined;
+    readonly '~types'?: {
+        readonly input: TInput;
+        readonly output: TOutput;
+        readonly issue: TIssue;
+    } | undefined;
 }
-
 /**
- * Native enum schema async type.
+ * Base validation async interface.
  */
-interface EnumSchemaAsync<TEnum extends Enum, TOutput = TEnum[keyof TEnum]> extends BaseSchemaAsync<TEnum[keyof TEnum], TOutput> {
+interface BaseValidationAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseValidation<TInput, TOutput, TIssue>, 'reference' | 'async' | '~run'> {
     /**
-     * The schema type.
+     * The validation reference.
      */
-    type: 'enum';
+    readonly reference: (...args: any[]) => BaseValidation<any, any, BaseIssue<unknown>> | BaseValidationAsync<any, any, BaseIssue<unknown>>;
     /**
-     * The enum value.
+     * Whether it's async.
      */
-    enum: TEnum;
+    readonly async: true;
     /**
-     * The error message.
+     * Validates known input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
      */
-    message: ErrorMessage | undefined;
+    readonly '~run': (dataset: OutputDataset<TInput, BaseIssue<unknown>>, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, BaseIssue<unknown> | TIssue>>;
 }
 
 /**
- * Intersect options async type.
+ * Infer input type.
  */
-type IntersectOptionsAsync = MaybeReadonly<[
-    BaseSchema | BaseSchemaAsync,
-    BaseSchema | BaseSchemaAsync,
-    ...(BaseSchema[] | BaseSchemaAsync[])
-]>;
-
+type InferInput<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<any, unknown, BaseIssue<unknown>> | BaseValidationAsync<any, unknown, BaseIssue<unknown>> | BaseTransformation<any, unknown, BaseIssue<unknown>> | BaseTransformationAsync<any, unknown, BaseIssue<unknown>> | BaseMetadata<any>> = NonNullable<TItem['~types']>['input'];
 /**
- * Intersect input inference type.
+ * Infer output type.
  */
-type IntersectInput<TIntersectOptions extends IntersectOptions | IntersectOptionsAsync> = TIntersectOptions extends [
-    BaseSchema<infer TInput1, any> | BaseSchemaAsync<infer TInput1, any>,
-    ...infer TRest
-] ? TRest extends IntersectOptions ? TInput1 & IntersectOutput<TRest> : TRest extends [
-    BaseSchema<infer TInput2, any> | BaseSchemaAsync<infer TInput2, any>
-] ? TInput1 & TInput2 : never : never;
+type InferOutput<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<any, unknown, BaseIssue<unknown>> | BaseValidationAsync<any, unknown, BaseIssue<unknown>> | BaseTransformation<any, unknown, BaseIssue<unknown>> | BaseTransformationAsync<any, unknown, BaseIssue<unknown>> | BaseMetadata<any>> = NonNullable<TItem['~types']>['output'];
 /**
- * Intersect output inference type.
+ * Infer issue type.
  */
-type IntersectOutput<TIntersectOptions extends IntersectOptions | IntersectOptionsAsync> = TIntersectOptions extends [
-    BaseSchema<any, infer TOutput1> | BaseSchemaAsync<any, infer TOutput1>,
-    ...infer TRest
-] ? TRest extends IntersectOptions ? TOutput1 & IntersectOutput<TRest> : TRest extends [
-    BaseSchema<any, infer TOutput2> | BaseSchemaAsync<any, infer TOutput2>
-] ? TOutput1 & TOutput2 : never : never;
-
+type InferIssue<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<any, unknown, BaseIssue<unknown>> | BaseValidationAsync<any, unknown, BaseIssue<unknown>> | BaseTransformation<any, unknown, BaseIssue<unknown>> | BaseTransformationAsync<any, unknown, BaseIssue<unknown>> | BaseMetadata<any>> = NonNullable<TItem['~types']>['issue'];
 /**
- * Intersect options type.
+ * Constructs a type that is maybe readonly.
  */
-type IntersectOptions = MaybeReadonly<[
-    BaseSchema,
-    BaseSchema,
-    ...BaseSchema[]
-]>;
+type MaybeReadonly<TValue> = TValue | Readonly<TValue>;
 /**
- * Intersect schema type.
+ * Constructs a type that is maybe a promise.
  */
-interface IntersectSchema<TOptions extends IntersectOptions, TOutput = IntersectOutput<TOptions>> extends BaseSchema<IntersectInput<TOptions>, TOutput> {
-    /**
-     * The schema type.
-     */
-    type: 'intersect';
-    /**
-     * The intersect options.
-     */
-    options: TOptions;
-    /**
-     * The error message.
-     */
-    message: ErrorMessage | undefined;
-    /**
-     * The validation and transformation pipeline.
-     */
-    pipe: Pipe<IntersectOutput<TOptions>> | undefined;
-}
-
+type MaybePromise<TValue> = TValue | Promise<TValue>;
 /**
- * Literal type.
- */
-type Literal = number | string | boolean | symbol | bigint;
+ * Prettifies a type for better readability.
+ *
+ * Hint: This type has no effect and is only used so that TypeScript displays
+ * the final type in the preview instead of the utility types used.
+ */
+type Prettify<TObject> = {
+    [TKey in keyof TObject]: TObject[TKey];
+} & {};
+/**
+ * Marks specific keys as optional.
+ */
+type MarkOptional<TObject, TKeys extends keyof TObject> = {
+    [TKey in keyof TObject]?: unknown;
+} & Omit<TObject, TKeys> & Partial<Pick<TObject, TKeys>>;
+/**
+ * Extracts first tuple item.
+ */
+type FirstTupleItem<TTuple extends readonly [unknown, ...unknown[]]> = TTuple[0];
+/**
+ * Extracts last tuple item.
+ */
+type LastTupleItem<TTuple extends readonly [unknown, ...unknown[]]> = TTuple[TTuple extends readonly [unknown, ...infer TRest] ? TRest['length'] : never];
+
+/**
+ * Error message type.
+ */
+type ErrorMessage<TIssue extends BaseIssue<unknown>> = ((issue: TIssue) => string) | string;
+/**
+ * Default type.
+ */
+type Default<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TInput extends null | undefined> = MaybeReadonly<InferInput<TWrapped> | TInput> | ((dataset?: UnknownDataset, config?: Config<InferIssue<TWrapped>>) => MaybeReadonly<InferInput<TWrapped> | TInput>) | undefined;
+/**
+ * Default async type.
+ */
+type DefaultAsync<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TInput extends null | undefined> = MaybeReadonly<InferInput<TWrapped> | TInput> | ((dataset?: UnknownDataset, config?: Config<InferIssue<TWrapped>>) => MaybePromise<MaybeReadonly<InferInput<TWrapped> | TInput>>) | undefined;
+/**
+ * Default value type.
+ */
+type DefaultValue<TDefault extends Default<BaseSchema<unknown, unknown, BaseIssue<unknown>>, null | undefined> | DefaultAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, null | undefined>> = TDefault extends DefaultAsync<infer TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, infer TInput> ? TDefault extends (dataset?: UnknownDataset, config?: Config<InferIssue<TWrapped>>) => MaybePromise<InferInput<TWrapped> | TInput> ? Awaited<ReturnType<TDefault>> : TDefault : never;
+
+/**
+ * Optional entry schema type.
+ */
+type OptionalEntrySchema = ExactOptionalSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | NullishSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown>;
+/**
+ * Optional entry schema async type.
+ */
+type OptionalEntrySchemaAsync = ExactOptionalSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | NullishSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown>;
+/**
+ * Object entries interface.
+ */
+interface ObjectEntries {
+    [key: string]: BaseSchema<unknown, unknown, BaseIssue<unknown>> | SchemaWithFallback<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalEntrySchema;
+}
+/**
+ * Object entries async interface.
+ */
+interface ObjectEntriesAsync {
+    [key: string]: BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | SchemaWithFallback<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | SchemaWithFallbackAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalEntrySchema | OptionalEntrySchemaAsync;
+}
+/**
+ * Infer entries input type.
+ */
+type InferEntriesInput<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
+    -readonly [TKey in keyof TEntries]: InferInput<TEntries[TKey]>;
+};
+/**
+ * Infer entries output type.
+ */
+type InferEntriesOutput<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
+    -readonly [TKey in keyof TEntries]: InferOutput<TEntries[TKey]>;
+};
+/**
+ * Optional input keys type.
+ */
+type OptionalInputKeys<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
+    [TKey in keyof TEntries]: TEntries[TKey] extends OptionalEntrySchema | OptionalEntrySchemaAsync ? TKey : never;
+}[keyof TEntries];
+/**
+ * Optional output keys type.
+ */
+type OptionalOutputKeys<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
+    [TKey in keyof TEntries]: TEntries[TKey] extends OptionalEntrySchema | OptionalEntrySchemaAsync ? undefined extends TEntries[TKey]['default'] ? TKey : never : never;
+}[keyof TEntries];
+/**
+ * Input with question marks type.
+ */
+type InputWithQuestionMarks<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends InferEntriesInput<TEntries>> = MarkOptional<TObject, OptionalInputKeys<TEntries>>;
+/**
+ * Output with question marks type.
+ */
+type OutputWithQuestionMarks<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends InferEntriesOutput<TEntries>> = MarkOptional<TObject, OptionalOutputKeys<TEntries>>;
+/**
+ * Readonly output keys type.
+ */
+type ReadonlyOutputKeys<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
+    [TKey in keyof TEntries]: TEntries[TKey] extends SchemaWithPipe<infer TPipe> | SchemaWithPipeAsync<infer TPipe> ? ReadonlyAction<any> extends TPipe[number] ? TKey : never : never;
+}[keyof TEntries];
+/**
+ * Output with readonly type.
+ */
+type OutputWithReadonly<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends OutputWithQuestionMarks<TEntries, InferEntriesOutput<TEntries>>> = Readonly<TObject> & Pick<TObject, Exclude<keyof TObject, ReadonlyOutputKeys<TEntries>>>;
+/**
+ * Infer object input type.
+ */
+type InferObjectInput<TEntries extends ObjectEntries | ObjectEntriesAsync> = Prettify<InputWithQuestionMarks<TEntries, InferEntriesInput<TEntries>>>;
+/**
+ * Infer object output type.
+ */
+type InferObjectOutput<TEntries extends ObjectEntries | ObjectEntriesAsync> = Prettify<OutputWithReadonly<TEntries, OutputWithQuestionMarks<TEntries, InferEntriesOutput<TEntries>>>>;
+/**
+ * Infer object issue type.
+ */
+type InferObjectIssue<TEntries extends ObjectEntries | ObjectEntriesAsync> = InferIssue<TEntries[keyof TEntries]>;
+
+/**
+ * Array path item interface.
+ */
+interface ArrayPathItem {
+    /**
+     * The path item type.
+     */
+    readonly type: 'array';
+    /**
+     * The path item origin.
+     */
+    readonly origin: 'value';
+    /**
+     * The path item input.
+     */
+    readonly input: MaybeReadonly<unknown[]>;
+    /**
+     * The path item key.
+     */
+    readonly key: number;
+    /**
+     * The path item value.
+     */
+    readonly value: unknown;
+}
+/**
+ * Map path item interface.
+ */
+interface MapPathItem {
+    /**
+     * The path item type.
+     */
+    readonly type: 'map';
+    /**
+     * The path item origin.
+     */
+    readonly origin: 'key' | 'value';
+    /**
+     * The path item input.
+     */
+    readonly input: Map<unknown, unknown>;
+    /**
+     * The path item key.
+     */
+    readonly key: unknown;
+    /**
+     * The path item value.
+     */
+    readonly value: unknown;
+}
+/**
+ * Object path item interface.
+ */
+interface ObjectPathItem {
+    /**
+     * The path item type.
+     */
+    readonly type: 'object';
+    /**
+     * The path item origin.
+     */
+    readonly origin: 'key' | 'value';
+    /**
+     * The path item input.
+     */
+    readonly input: Record<string, unknown>;
+    /**
+     * The path item key.
+     */
+    readonly key: string;
+    /**
+     * The path item value.
+     */
+    readonly value: unknown;
+}
+/**
+ * Set path item interface.
+ */
+interface SetPathItem {
+    /**
+     * The path item type.
+     */
+    readonly type: 'set';
+    /**
+     * The path item origin.
+     */
+    readonly origin: 'value';
+    /**
+     * The path item input.
+     */
+    readonly input: Set<unknown>;
+    /**
+     * The path item key.
+     */
+    readonly key: null;
+    /**
+     * The path item key.
+     */
+    readonly value: unknown;
+}
+/**
+ * Unknown path item interface.
+ */
+interface UnknownPathItem {
+    /**
+     * The path item type.
+     */
+    readonly type: 'unknown';
+    /**
+     * The path item origin.
+     */
+    readonly origin: 'key' | 'value';
+    /**
+     * The path item input.
+     */
+    readonly input: unknown;
+    /**
+     * The path item key.
+     */
+    readonly key: unknown;
+    /**
+     * The path item value.
+     */
+    readonly value: unknown;
+}
+/**
+ * Issue path item type.
+ */
+type IssuePathItem = ArrayPathItem | MapPathItem | ObjectPathItem | SetPathItem | UnknownPathItem;
+/**
+ * Base issue interface.
+ */
+interface BaseIssue<TInput> extends Config<BaseIssue<TInput>> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema' | 'validation' | 'transformation';
+    /**
+     * The issue type.
+     */
+    readonly type: string;
+    /**
+     * The raw input data.
+     */
+    readonly input: TInput;
+    /**
+     * The expected property.
+     */
+    readonly expected: string | null;
+    /**
+     * The received property.
+     */
+    readonly received: string;
+    /**
+     * The error message.
+     */
+    readonly message: string;
+    /**
+     * The input requirement.
+     */
+    readonly requirement?: unknown | undefined;
+    /**
+     * The issue path.
+     */
+    readonly path?: [IssuePathItem, ...IssuePathItem[]] | undefined;
+    /**
+     * The sub issues.
+     */
+    readonly issues?: [BaseIssue<TInput>, ...BaseIssue<TInput>[]] | undefined;
+}
+
+/**
+ * Config interface.
+ */
+interface Config<TIssue extends BaseIssue<unknown>> {
+    /**
+     * The selected language.
+     */
+    readonly lang?: string | undefined;
+    /**
+     * The error message.
+     */
+    readonly message?: ErrorMessage<TIssue> | undefined;
+    /**
+     * Whether it should be aborted early.
+     */
+    readonly abortEarly?: boolean | undefined;
+    /**
+     * Whether a pipe should be aborted early.
+     */
+    readonly abortPipeEarly?: boolean | undefined;
+}
+
+/**
+ * Pipe action type.
+ */
+type PipeAction<TInput, TOutput, TIssue extends BaseIssue<unknown>> = BaseValidation<TInput, TOutput, TIssue> | BaseTransformation<TInput, TOutput, TIssue> | BaseMetadata<TInput>;
+/**
+ * Pipe action async type.
+ */
+type PipeActionAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> = BaseValidationAsync<TInput, TOutput, TIssue> | BaseTransformationAsync<TInput, TOutput, TIssue>;
+/**
+ * Pipe item type.
+ */
+type PipeItem<TInput, TOutput, TIssue extends BaseIssue<unknown>> = BaseSchema<TInput, TOutput, TIssue> | PipeAction<TInput, TOutput, TIssue>;
+/**
+ * Pipe item async type.
+ */
+type PipeItemAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> = BaseSchemaAsync<TInput, TOutput, TIssue> | PipeActionAsync<TInput, TOutput, TIssue>;
+
+/**
+ * Array issue interface.
+ */
+interface ArrayIssue extends BaseIssue<unknown> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The issue type.
+     */
+    readonly type: 'array';
+    /**
+     * The expected property.
+     */
+    readonly expected: 'Array';
+}
+
+/**
+ * Array schema interface.
+ */
+interface ArraySchema<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TMessage extends ErrorMessage<ArrayIssue> | undefined> extends BaseSchema<InferInput<TItem>[], InferOutput<TItem>[], ArrayIssue | InferIssue<TItem>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'array';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof array;
+    /**
+     * The expected property.
+     */
+    readonly expects: 'Array';
+    /**
+     * The array item schema.
+     */
+    readonly item: TItem;
+    /**
+     * The error message.
+     */
+    readonly message: TMessage;
+}
+/**
+ * Creates an array schema.
+ *
+ * @param item The item schema.
+ *
+ * @returns An array schema.
+ */
+declare function array<const TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(item: TItem): ArraySchema<TItem, undefined>;
+/**
+ * Creates an array schema.
+ *
+ * @param item The item schema.
+ * @param message The error message.
+ *
+ * @returns An array schema.
+ */
+declare function array<const TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TMessage extends ErrorMessage<ArrayIssue> | undefined>(item: TItem, message: TMessage): ArraySchema<TItem, TMessage>;
+
+/**
+ * Boolean issue interface.
+ */
+interface BooleanIssue extends BaseIssue<unknown> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The issue type.
+     */
+    readonly type: 'boolean';
+    /**
+     * The expected property.
+     */
+    readonly expected: 'boolean';
+}
+/**
+ * Boolean schema interface.
+ */
+interface BooleanSchema<TMessage extends ErrorMessage<BooleanIssue> | undefined> extends BaseSchema<boolean, boolean, BooleanIssue> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'boolean';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof boolean;
+    /**
+     * The expected property.
+     */
+    readonly expects: 'boolean';
+    /**
+     * The error message.
+     */
+    readonly message: TMessage;
+}
+/**
+ * Creates a boolean schema.
+ *
+ * @returns A boolean schema.
+ */
+declare function boolean(): BooleanSchema<undefined>;
+/**
+ * Creates a boolean schema.
+ *
+ * @param message The error message.
+ *
+ * @returns A boolean schema.
+ */
+declare function boolean<const TMessage extends ErrorMessage<BooleanIssue> | undefined>(message: TMessage): BooleanSchema<TMessage>;
+
+/**
+ * Exact optional schema interface.
+ */
+interface ExactOptionalSchema<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TDefault extends Default<TWrapped, never>> extends BaseSchema<InferInput<TWrapped>, InferOutput<TWrapped>, InferIssue<TWrapped>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'exact_optional';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof exactOptional;
+    /**
+     * The expected property.
+     */
+    readonly expects: TWrapped['expects'];
+    /**
+     * The wrapped schema.
+     */
+    readonly wrapped: TWrapped;
+    /**
+     * The default value.
+     */
+    readonly default: TDefault;
+}
+/**
+ * Creates an exact optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns An exact optional schema.
+ */
+declare function exactOptional<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): ExactOptionalSchema<TWrapped, undefined>;
+/**
+ * Creates an exact optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns An exact optional schema.
+ */
+declare function exactOptional<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TDefault extends Default<TWrapped, never>>(wrapped: TWrapped, default_: TDefault): ExactOptionalSchema<TWrapped, TDefault>;
+
+/**
+ * Exact optional schema async interface.
+ */
+interface ExactOptionalSchemaAsync<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped, never>> extends BaseSchemaAsync<InferInput<TWrapped>, InferOutput<TWrapped>, InferIssue<TWrapped>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'exact_optional';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof exactOptional | typeof exactOptionalAsync;
+    /**
+     * The expected property.
+     */
+    readonly expects: TWrapped['expects'];
+    /**
+     * The wrapped schema.
+     */
+    readonly wrapped: TWrapped;
+    /**
+     * The default value.
+     */
+    readonly default: TDefault;
+}
+/**
+ * Creates an exact optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns An exact optional schema.
+ */
+declare function exactOptionalAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): ExactOptionalSchemaAsync<TWrapped, undefined>;
+/**
+ * Creates an exact optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns An exact optional schema.
+ */
+declare function exactOptionalAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, const TDefault extends DefaultAsync<TWrapped, never>>(wrapped: TWrapped, default_: TDefault): ExactOptionalSchemaAsync<TWrapped, TDefault>;
+
+/**
+ * Intersect issue interface.
+ */
+interface IntersectIssue extends BaseIssue<unknown> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The issue type.
+     */
+    readonly type: 'intersect';
+    /**
+     * The expected property.
+     */
+    readonly expected: string;
+}
+/**
+ * Intersect options type.
+ */
+type IntersectOptions = MaybeReadonly<BaseSchema<unknown, unknown, BaseIssue<unknown>>[]>;
+/**
+ * Intersect options async type.
+ */
+type IntersectOptionsAsync = MaybeReadonly<(BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>)[]>;
+/**
+ * Infer option type.
+ */
+type InferOption<TInput, TOutput> = BaseSchema<TInput, TOutput, BaseIssue<unknown>> | BaseSchemaAsync<TInput, TOutput, BaseIssue<unknown>>;
+/**
+ * Infer intersect input type.
+ */
+type InferIntersectInput<TOptions extends IntersectOptions | IntersectOptionsAsync> = TOptions extends readonly [
+    InferOption<infer TInput, unknown>,
+    ...infer TRest
+] ? TRest extends readonly [
+    InferOption<unknown, unknown>,
+    ...InferOption<unknown, unknown>[]
+] ? TInput & InferIntersectInput<TRest> : TInput : never;
+/**
+ * Infer intersect output type.
+ */
+type InferIntersectOutput<TOptions extends IntersectOptions | IntersectOptionsAsync> = TOptions extends readonly [
+    InferOption<unknown, infer TOutput>,
+    ...infer TRest
+] ? TRest extends readonly [
+    InferOption<unknown, unknown>,
+    ...InferOption<unknown, unknown>[]
+] ? TOutput & InferIntersectOutput<TRest> : TOutput : never;
 
 /**
- * Literal schema type.
+ * Intersect schema interface.
  */
-interface LiteralSchema<TLiteral extends Literal, TOutput = TLiteral> extends BaseSchema<TLiteral, TOutput> {
+interface IntersectSchema<TOptions extends IntersectOptions, TMessage extends ErrorMessage<IntersectIssue> | undefined> extends BaseSchema<InferIntersectInput<TOptions>, InferIntersectOutput<TOptions>, IntersectIssue | InferIssue<TOptions[number]>> {
     /**
      * The schema type.
      */
-    type: 'literal';
+    readonly type: 'intersect';
     /**
-     * The literal value.
+     * The schema reference.
+     */
+    readonly reference: typeof intersect;
+    /**
+     * The intersect options.
      */
-    literal: TLiteral;
+    readonly options: TOptions;
     /**
      * The error message.
      */
-    message: ErrorMessage | undefined;
+    readonly message: TMessage;
 }
-
 /**
- * Map path item type.
+ * Creates an intersect schema.
+ *
+ * @param options The intersect options.
+ *
+ * @returns An intersect schema.
  */
-interface MapPathItem {
-    type: 'map';
-    origin: 'key' | 'value';
-    input: Map<unknown, unknown>;
-    key: unknown;
-    value: unknown;
-}
+declare function intersect<const TOptions extends IntersectOptions>(options: TOptions): IntersectSchema<TOptions, undefined>;
+/**
+ * Creates an intersect schema.
+ *
+ * @param options The intersect options.
+ * @param message The error message.
+ *
+ * @returns An intersect schema.
+ */
+declare function intersect<const TOptions extends IntersectOptions, const TMessage extends ErrorMessage<IntersectIssue> | undefined>(options: TOptions, message: TMessage): IntersectSchema<TOptions, TMessage>;
 
 /**
- * Never schema type.
+ * Literal type.
+ */
+type Literal = bigint | boolean | number | string | symbol;
+/**
+ * Literal issue interface.
  */
-interface NeverSchema extends BaseSchema<never> {
+interface LiteralIssue extends BaseIssue<unknown> {
     /**
-     * The schema type.
+     * The issue kind.
      */
-    type: 'never';
+    readonly kind: 'schema';
     /**
-     * The error message.
+     * The issue type.
+     */
+    readonly type: 'literal';
+    /**
+     * The expected property.
      */
-    message: ErrorMessage | undefined;
+    readonly expected: string;
 }
-
 /**
- * Never schema async type.
+ * Literal schema interface.
  */
-interface NeverSchemaAsync extends BaseSchemaAsync<never> {
+interface LiteralSchema<TLiteral extends Literal, TMessage extends ErrorMessage<LiteralIssue> | undefined> extends BaseSchema<TLiteral, TLiteral, LiteralIssue> {
     /**
      * The schema type.
      */
-    type: 'never';
+    readonly type: 'literal';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof literal;
+    /**
+     * The literal value.
+     */
+    readonly literal: TLiteral;
     /**
      * The error message.
      */
-    message: ErrorMessage | undefined;
+    readonly message: TMessage;
 }
+/**
+ * Creates a literal schema.
+ *
+ * @param literal_ The literal value.
+ *
+ * @returns A literal schema.
+ */
+declare function literal<const TLiteral extends Literal>(literal_: TLiteral): LiteralSchema<TLiteral, undefined>;
+/**
+ * Creates a literal schema.
+ *
+ * @param literal_ The literal value.
+ * @param message The error message.
+ *
+ * @returns A literal schema.
+ */
+declare function literal<const TLiteral extends Literal, const TMessage extends ErrorMessage<LiteralIssue> | undefined>(literal_: TLiteral, message: TMessage): LiteralSchema<TLiteral, TMessage>;
 
 /**
- * Nullable schema type.
+ * Union issue interface.
  */
-interface NullableSchema<TWrapped extends BaseSchema, TDefault extends Default<TWrapped> = undefined, TOutput = TDefault extends Input<TWrapped> | (() => Input<TWrapped>) ? Output<TWrapped> : Output<TWrapped> | null> extends BaseSchema<Input<TWrapped> | null, TOutput> {
+interface UnionIssue<TSubIssue extends BaseIssue<unknown>> extends BaseIssue<unknown> {
     /**
-     * The schema type.
+     * The issue kind.
      */
-    type: 'nullable';
+    readonly kind: 'schema';
     /**
-     * The wrapped schema.
+     * The issue type.
      */
-    wrapped: TWrapped;
+    readonly type: 'union';
     /**
-     * The default value.
+     * The expected property.
      */
-    default: TDefault;
+    readonly expected: string;
+    /**
+     * The sub issues.
+     */
+    readonly issues?: [TSubIssue, ...TSubIssue[]];
 }
 
 /**
- * Number schema type.
+ * Union options type.
+ */
+type UnionOptions = MaybeReadonly<BaseSchema<unknown, unknown, BaseIssue<unknown>>[]>;
+/**
+ * Union schema interface.
  */
-interface NumberSchema<TOutput = number> extends BaseSchema<number, TOutput> {
+interface UnionSchema<TOptions extends UnionOptions, TMessage extends ErrorMessage<UnionIssue<InferIssue<TOptions[number]>>> | undefined> extends BaseSchema<InferInput<TOptions[number]>, InferOutput<TOptions[number]>, UnionIssue<InferIssue<TOptions[number]>> | InferIssue<TOptions[number]>> {
     /**
      * The schema type.
      */
-    type: 'number';
+    readonly type: 'union';
     /**
-     * The error message.
+     * The schema reference.
+     */
+    readonly reference: typeof union;
+    /**
+     * The union options.
      */
-    message: ErrorMessage | undefined;
+    readonly options: TOptions;
     /**
-     * The validation and transformation pipeline.
+     * The error message.
      */
-    pipe: Pipe<number> | undefined;
+    readonly message: TMessage;
 }
+/**
+ * Creates an union schema.
+ *
+ * @param options The union options.
+ *
+ * @returns An union schema.
+ */
+declare function union<const TOptions extends UnionOptions>(options: TOptions): UnionSchema<TOptions, undefined>;
+/**
+ * Creates an union schema.
+ *
+ * @param options The union options.
+ * @param message The error message.
+ *
+ * @returns An union schema.
+ */
+declare function union<const TOptions extends UnionOptions, const TMessage extends ErrorMessage<UnionIssue<InferIssue<TOptions[number]>>> | undefined>(options: TOptions, message: TMessage): UnionSchema<TOptions, TMessage>;
+
+/**
+ * Infer nullable output type.
+ */
+type InferNullableOutput<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped, null>> = undefined extends TDefault ? InferOutput<TWrapped> | null : InferOutput<TWrapped> | Extract<DefaultValue<TDefault>, null>;
 
 /**
- * Optional schema type.
+ * Nullable schema interface.
  */
-interface OptionalSchema<TWrapped extends BaseSchema, TDefault extends Default<TWrapped> = undefined, TOutput = TDefault extends Input<TWrapped> | (() => Input<TWrapped>) ? Output<TWrapped> : Output<TWrapped> | undefined> extends BaseSchema<Input<TWrapped> | undefined, TOutput> {
+interface NullableSchema<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TDefault extends Default<TWrapped, null>> extends BaseSchema<InferInput<TWrapped> | null, InferNullableOutput<TWrapped, TDefault>, InferIssue<TWrapped>> {
     /**
      * The schema type.
      */
-    type: 'optional';
-    /**
-     * The wrapped schema.
-     */
-    wrapped: TWrapped;
+    readonly type: 'nullable';
     /**
-     * Returns the default value.
+     * The schema reference.
      */
-    default: TDefault;
-}
-
-/**
- * Optional schema async type.
- */
-interface OptionalSchemaAsync<TWrapped extends BaseSchema | BaseSchemaAsync, TDefault extends DefaultAsync<TWrapped> = undefined, TOutput = TDefault extends Input<TWrapped> | (() => Input<TWrapped> | Promise<Input<TWrapped>>) ? Output<TWrapped> : Output<TWrapped> | undefined> extends BaseSchemaAsync<Input<TWrapped> | undefined, TOutput> {
+    readonly reference: typeof nullable;
     /**
-     * The schema type.
+     * The expected property.
      */
-    type: 'optional';
+    readonly expects: `(${TWrapped['expects']} | null)`;
     /**
      * The wrapped schema.
      */
-    wrapped: TWrapped;
+    readonly wrapped: TWrapped;
     /**
-     * Returns the default value.
+     * The default value.
      */
-    default: TDefault;
+    readonly default: TDefault;
 }
-
 /**
- * Object entries async type.
+ * Creates a nullable schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns A nullable schema.
  */
-interface ObjectEntriesAsync {
-    [key: string]: BaseSchema | BaseSchemaAsync;
-}
-
+declare function nullable<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): NullableSchema<TWrapped, undefined>;
 /**
- * Object path item type.
+ * Creates a nullable schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns A nullable schema.
  */
-interface ObjectPathItem {
-    type: 'object';
-    origin: 'value';
-    input: Record<string, unknown>;
-    key: string;
-    value: unknown;
-}
+declare function nullable<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TDefault extends Default<TWrapped, null>>(wrapped: TWrapped, default_: TDefault): NullableSchema<TWrapped, TDefault>;
+
 /**
- * Required object keys type.
+ * Infer nullish output type.
  */
-type RequiredKeys<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends EntriesInput<TEntries> | EntriesOutput<TEntries>> = {
-    [TKey in keyof TEntries]: TEntries[TKey] extends OptionalSchema<any, any> | OptionalSchemaAsync<any, any> ? undefined extends TObject[TKey] ? never : TKey : TKey;
-}[keyof TEntries];
+type InferNullishOutput<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped, null | undefined>> = undefined extends TDefault ? InferOutput<TWrapped> | null | undefined : InferOutput<TWrapped> | Extract<DefaultValue<TDefault>, null | undefined>;
+
 /**
- * Optional object keys type.
+ * Nullish schema interface.
  */
-type OptionalKeys<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends EntriesInput<TEntries> | EntriesOutput<TEntries>> = {
-    [TKey in keyof TEntries]: TEntries[TKey] extends OptionalSchema<any, any> | OptionalSchemaAsync<any, any> ? undefined extends TObject[TKey] ? TKey : never : never;
-}[keyof TEntries];
+interface NullishSchema<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TDefault extends Default<TWrapped, null | undefined>> extends BaseSchema<InferInput<TWrapped> | null | undefined, InferNullishOutput<TWrapped, TDefault>, InferIssue<TWrapped>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'nullish';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof nullish;
+    /**
+     * The expected property.
+     */
+    readonly expects: `(${TWrapped['expects']} | null | undefined)`;
+    /**
+     * The wrapped schema.
+     */
+    readonly wrapped: TWrapped;
+    /**
+     * The default value.
+     */
+    readonly default: TDefault;
+}
 /**
- * Entries input inference type.
+ * Creates a nullish schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns A nullish schema.
  */
-type EntriesInput<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
-    [TKey in keyof TEntries]: Input<TEntries[TKey]>;
-};
+declare function nullish<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): NullishSchema<TWrapped, undefined>;
 /**
- * Entries output inference type.
+ * Creates a nullish schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns A nullish schema.
  */
-type EntriesOutput<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
-    [TKey in keyof TEntries]: Output<TEntries[TKey]>;
-};
+declare function nullish<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TDefault extends Default<TWrapped, null | undefined>>(wrapped: TWrapped, default_: TDefault): NullishSchema<TWrapped, TDefault>;
+
 /**
- * Object with question marks type.
+ * Nullish schema async interface.
  */
-type WithQuestionMarks<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends EntriesInput<TEntries> | EntriesOutput<TEntries>> = Pick<TObject, RequiredKeys<TEntries, TObject>> & Partial<Pick<TObject, OptionalKeys<TEntries, TObject>>>;
+interface NullishSchemaAsync<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped, null | undefined>> extends BaseSchemaAsync<InferInput<TWrapped> | null | undefined, InferNullishOutput<TWrapped, TDefault>, InferIssue<TWrapped>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'nullish';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof nullish | typeof nullishAsync;
+    /**
+     * The expected property.
+     */
+    readonly expects: `(${TWrapped['expects']} | null | undefined)`;
+    /**
+     * The wrapped schema.
+     */
+    readonly wrapped: TWrapped;
+    /**
+     * The default value.
+     */
+    readonly default: TDefault;
+}
 /**
- * Object input inference type.
+ * Creates a nullish schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns A nullish schema.
  */
-type ObjectInput<TEntries extends ObjectEntries | ObjectEntriesAsync, TRest extends BaseSchema | BaseSchemaAsync | undefined> = TRest extends undefined | NeverSchema | NeverSchemaAsync ? ResolveObject<WithQuestionMarks<TEntries, EntriesInput<TEntries>>> : TRest extends BaseSchema | BaseSchemaAsync ? ResolveObject<WithQuestionMarks<TEntries, EntriesInput<TEntries>>> & Record<string, Input<TRest>> : never;
+declare function nullishAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): NullishSchemaAsync<TWrapped, undefined>;
 /**
- * Object output inference type.
+ * Creates a nullish schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns A nullish schema.
  */
-type ObjectOutput<TEntries extends ObjectEntries | ObjectEntriesAsync, TRest extends BaseSchema | BaseSchemaAsync | undefined> = TRest extends undefined | NeverSchema | NeverSchemaAsync ? ResolveObject<WithQuestionMarks<TEntries, EntriesOutput<TEntries>>> : TRest extends BaseSchema | BaseSchemaAsync ? ResolveObject<WithQuestionMarks<TEntries, EntriesOutput<TEntries>>> & Record<string, Output<TRest>> : never;
+declare function nullishAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, const TDefault extends DefaultAsync<TWrapped, null | undefined>>(wrapped: TWrapped, default_: TDefault): NullishSchemaAsync<TWrapped, TDefault>;
 
 /**
- * Object entries type.
+ * Number issue interface.
  */
-interface ObjectEntries {
-    [key: string]: BaseSchema;
+interface NumberIssue extends BaseIssue<unknown> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The issue type.
+     */
+    readonly type: 'number';
+    /**
+     * The expected property.
+     */
+    readonly expected: 'number';
 }
 /**
- * Object schema type.
+ * Number schema interface.
  */
-interface ObjectSchema<TEntries extends ObjectEntries, TRest extends BaseSchema | undefined = undefined, TOutput = ObjectOutput<TEntries, TRest>> extends BaseSchema<ObjectInput<TEntries, TRest>, TOutput> {
+interface NumberSchema<TMessage extends ErrorMessage<NumberIssue> | undefined> extends BaseSchema<number, number, NumberIssue> {
     /**
      * The schema type.
      */
-    type: 'object';
+    readonly type: 'number';
     /**
-     * The object entries schema.
+     * The schema reference.
      */
-    entries: TEntries;
+    readonly reference: typeof number;
     /**
-     * The object rest schema.
+     * The expected property.
      */
-    rest: TRest;
+    readonly expects: 'number';
     /**
      * The error message.
      */
-    message: ErrorMessage | undefined;
-    /**
-     * The validation and transformation pipeline.
-     */
-    pipe: Pipe<ObjectOutput<TEntries, TRest>> | undefined;
+    readonly message: TMessage;
 }
-
 /**
- * Picklist options type.
+ * Creates a number schema.
+ *
+ * @returns A number schema.
+ */
+declare function number(): NumberSchema<undefined>;
+/**
+ * Creates a number schema.
+ *
+ * @param message The error message.
+ *
+ * @returns A number schema.
  */
-type PicklistOptions = MaybeReadonly<(string | number | bigint)[]>;
+declare function number<const TMessage extends ErrorMessage<NumberIssue> | undefined>(message: TMessage): NumberSchema<TMessage>;
 
 /**
- * Picklist schema type.
+ * Object issue interface.
  */
-interface PicklistSchema<TOptions extends PicklistOptions, TOutput = TOptions[number]> extends BaseSchema<TOptions[number], TOutput> {
+interface ObjectIssue extends BaseIssue<unknown> {
     /**
-     * The schema type.
+     * The issue kind.
      */
-    type: 'picklist';
+    readonly kind: 'schema';
     /**
-     * The picklist options.
+     * The issue type.
      */
-    options: TOptions;
+    readonly type: 'object';
     /**
-     * The error message.
+     * The expected property.
      */
-    message: ErrorMessage | undefined;
+    readonly expected: 'Object' | `"${string}"`;
 }
 
 /**
- * Picklist schema async type.
+ * Object schema interface.
  */
-interface PicklistSchemaAsync<TOptions extends PicklistOptions, TOutput = TOptions[number]> extends BaseSchemaAsync<TOptions[number], TOutput> {
+interface ObjectSchema<TEntries extends ObjectEntries, TMessage extends ErrorMessage<ObjectIssue> | undefined> extends BaseSchema<InferObjectInput<TEntries>, InferObjectOutput<TEntries>, ObjectIssue | InferObjectIssue<TEntries>> {
     /**
      * The schema type.
      */
-    type: 'picklist';
+    readonly type: 'object';
     /**
-     * The picklist value.
+     * The schema reference.
      */
-    options: TOptions;
+    readonly reference: typeof object;
+    /**
+     * The expected property.
+     */
+    readonly expects: 'Object';
+    /**
+     * The entries schema.
+     */
+    readonly entries: TEntries;
     /**
      * The error message.
      */
-    message: ErrorMessage | undefined;
+    readonly message: TMessage;
 }
+/**
+ * Creates an object schema.
+ *
+ * Hint: This schema removes unknown entries. The output will only include the
+ * entries you specify. To include unknown entries, use `looseObject`. To
+ * return an issue for unknown entries, use `strictObject`. To include and
+ * validate unknown entries, use `objectWithRest`.
+ *
+ * @param entries The entries schema.
+ *
+ * @returns An object schema.
+ */
+declare function object<const TEntries extends ObjectEntries>(entries: TEntries): ObjectSchema<TEntries, undefined>;
+/**
+ * Creates an object schema.
+ *
+ * Hint: This schema removes unknown entries. The output will only include the
+ * entries you specify. To include unknown entries, use `looseObject`. To
+ * return an issue for unknown entries, use `strictObject`. To include and
+ * validate unknown entries, use `objectWithRest`.
+ *
+ * @param entries The entries schema.
+ * @param message The error message.
+ *
+ * @returns An object schema.
+ */
+declare function object<const TEntries extends ObjectEntries, const TMessage extends ErrorMessage<ObjectIssue> | undefined>(entries: TEntries, message: TMessage): ObjectSchema<TEntries, TMessage>;
+
+/**
+ * Infer optional output type.
+ */
+type InferOptionalOutput<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped, undefined>> = undefined extends TDefault ? InferOutput<TWrapped> | undefined : InferOutput<TWrapped> | Extract<DefaultValue<TDefault>, undefined>;
 
 /**
- * Special schema type.
+ * Optional schema interface.
  */
-interface SpecialSchema<TInput, TOutput = TInput> extends BaseSchema<TInput, TOutput> {
+interface OptionalSchema<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TDefault extends Default<TWrapped, undefined>> extends BaseSchema<InferInput<TWrapped> | undefined, InferOptionalOutput<TWrapped, TDefault>, InferIssue<TWrapped>> {
     /**
      * The schema type.
      */
-    type: 'special';
+    readonly type: 'optional';
     /**
-     * The type check function.
+     * The schema reference.
      */
-    check: (input: unknown) => boolean;
+    readonly reference: typeof optional;
     /**
-     * The error message.
+     * The expected property.
      */
-    message: ErrorMessage | undefined;
+    readonly expects: `(${TWrapped['expects']} | undefined)`;
     /**
-     * The validation and transformation pipeline.
+     * The wrapped schema.
+     */
+    readonly wrapped: TWrapped;
+    /**
+     * The default value.
      */
-    pipe: Pipe<TInput> | undefined;
+    readonly default: TDefault;
 }
+/**
+ * Creates an optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns An optional schema.
+ */
+declare function optional<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): OptionalSchema<TWrapped, undefined>;
+/**
+ * Creates an optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns An optional schema.
+ */
+declare function optional<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TDefault extends Default<TWrapped, undefined>>(wrapped: TWrapped, default_: TDefault): OptionalSchema<TWrapped, TDefault>;
 
 /**
- * Special schema async type.
+ * Optional schema async interface.
  */
-interface SpecialSchemaAsync<TInput, TOutput = TInput> extends BaseSchemaAsync<TInput, TOutput> {
+interface OptionalSchemaAsync<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped, undefined>> extends BaseSchemaAsync<InferInput<TWrapped> | undefined, InferOptionalOutput<TWrapped, TDefault>, InferIssue<TWrapped>> {
     /**
      * The schema type.
      */
-    type: 'special';
+    readonly type: 'optional';
     /**
-     * The type check function.
+     * The schema reference.
      */
-    check: (input: unknown) => boolean | Promise<boolean>;
+    readonly reference: typeof optional | typeof optionalAsync;
     /**
-     * The error message.
+     * The expected property.
+     */
+    readonly expects: `(${TWrapped['expects']} | undefined)`;
+    /**
+     * The wrapped schema.
      */
-    message: ErrorMessage | undefined;
+    readonly wrapped: TWrapped;
     /**
-     * The validation and transformation pipeline.
+     * The default value.
      */
-    pipe: PipeAsync<TInput> | undefined;
+    readonly default: TDefault;
 }
+/**
+ * Creates an optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns An optional schema.
+ */
+declare function optionalAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): OptionalSchemaAsync<TWrapped, undefined>;
+/**
+ * Creates an optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns An optional schema.
+ */
+declare function optionalAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, const TDefault extends DefaultAsync<TWrapped, undefined>>(wrapped: TWrapped, default_: TDefault): OptionalSchemaAsync<TWrapped, TDefault>;
 
 /**
- * String schema type.
+ * Record issue interface.
  */
-interface StringSchema<TOutput = string> extends BaseSchema<string, TOutput> {
+interface RecordIssue extends BaseIssue<unknown> {
     /**
-     * The schema type.
+     * The issue kind.
      */
-    type: 'string';
+    readonly kind: 'schema';
     /**
-     * The error message.
+     * The issue type.
      */
-    message: ErrorMessage | undefined;
+    readonly type: 'record';
     /**
-     * The validation and transformation pipeline.
+     * The expected property.
      */
-    pipe: Pipe<string> | undefined;
+    readonly expected: 'Object';
 }
+/**
+ * Is literal type.
+ */
+type IsLiteral<TKey extends string | number | symbol> = string extends TKey ? false : number extends TKey ? false : symbol extends TKey ? false : TKey extends Brand<string | number | symbol> ? false : true;
+/**
+ * Optional keys type.
+ */
+type OptionalKeys<TObject extends Record<string | number | symbol, unknown>> = {
+    [TKey in keyof TObject]: IsLiteral<TKey> extends true ? TKey : never;
+}[keyof TObject];
+/**
+ * With question marks type.
+ *
+ * Hint: We mark an entry as optional if we detect that its key is a literal
+ * type. The reason for this is that it is not technically possible to detect
+ * missing literal keys without restricting the key schema to `string`, `enum`
+ * and `picklist`. However, if `enum` and `picklist` are used, it is better to
+ * use `object` with `entriesFromList` because it already covers the needed
+ * functionality. This decision also reduces the bundle size of `record`,
+ * because it only needs to check the entries of the input and not any missing
+ * keys.
+ */
+type WithQuestionMarks<TObject extends Record<string | number | symbol, unknown>> = MarkOptional<TObject, OptionalKeys<TObject>>;
+/**
+ * With readonly type.
+ */
+type WithReadonly<TValue extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TObject extends WithQuestionMarks<Record<string | number | symbol, unknown>>> = TValue extends SchemaWithPipe<infer TPipe> | SchemaWithPipeAsync<infer TPipe> ? ReadonlyAction<any> extends TPipe[number] ? Readonly<TObject> : TObject : TObject;
+/**
+ * Infer record input type.
+ */
+type InferRecordInput<TKey extends BaseSchema<string, string | number | symbol, BaseIssue<unknown>> | BaseSchemaAsync<string, string | number | symbol, BaseIssue<unknown>>, TValue extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = Prettify<WithQuestionMarks<Record<InferInput<TKey>, InferInput<TValue>>>>;
+/**
+ * Infer record output type.
+ */
+type InferRecordOutput<TKey extends BaseSchema<string, string | number | symbol, BaseIssue<unknown>> | BaseSchemaAsync<string, string | number | symbol, BaseIssue<unknown>>, TValue extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = Prettify<WithReadonly<TValue, WithQuestionMarks<Record<InferOutput<TKey>, InferOutput<TValue>>>>>;
 
 /**
- * String schema async type.
+ * Record schema interface.
  */
-interface StringSchemaAsync<TOutput = string> extends BaseSchemaAsync<string, TOutput> {
+interface RecordSchema<TKey extends BaseSchema<string, string | number | symbol, BaseIssue<unknown>>, TValue extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TMessage extends ErrorMessage<RecordIssue> | undefined> extends BaseSchema<InferRecordInput<TKey, TValue>, InferRecordOutput<TKey, TValue>, RecordIssue | InferIssue<TKey> | InferIssue<TValue>> {
     /**
      * The schema type.
      */
-    type: 'string';
+    readonly type: 'record';
     /**
-     * The error message.
+     * The schema reference.
+     */
+    readonly reference: typeof record;
+    /**
+     * The expected property.
+     */
+    readonly expects: 'Object';
+    /**
+     * The record key schema.
+     */
+    readonly key: TKey;
+    /**
+     * The record value schema.
      */
-    message: ErrorMessage | undefined;
+    readonly value: TValue;
     /**
-     * The validation and transformation pipeline.
+     * The error message.
      */
-    pipe: PipeAsync<string> | undefined;
+    readonly message: TMessage;
 }
+/**
+ * Creates a record schema.
+ *
+ * @param key The key schema.
+ * @param value The value schema.
+ *
+ * @returns A record schema.
+ */
+declare function record<const TKey extends BaseSchema<string, string | number | symbol, BaseIssue<unknown>>, const TValue extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(key: TKey, value: TValue): RecordSchema<TKey, TValue, undefined>;
+/**
+ * Creates a record schema.
+ *
+ * @param key The key schema.
+ * @param value The value schema.
+ * @param message The error message.
+ *
+ * @returns A record schema.
+ */
+declare function record<const TKey extends BaseSchema<string, string | number | symbol, BaseIssue<unknown>>, const TValue extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TMessage extends ErrorMessage<RecordIssue> | undefined>(key: TKey, value: TValue, message: TMessage): RecordSchema<TKey, TValue, TMessage>;
 
 /**
- * Union options type.
+ * String issue interface.
  */
-type UnionOptions = MaybeReadonly<BaseSchema[]>;
+interface StringIssue extends BaseIssue<unknown> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The issue type.
+     */
+    readonly type: 'string';
+    /**
+     * The expected property.
+     */
+    readonly expected: 'string';
+}
 /**
- * Union schema type.
+ * String schema interface.
  */
-interface UnionSchema<TOptions extends UnionOptions, TOutput = Output<TOptions[number]>> extends BaseSchema<Input<TOptions[number]>, TOutput> {
+interface StringSchema<TMessage extends ErrorMessage<StringIssue> | undefined> extends BaseSchema<string, string, StringIssue> {
     /**
      * The schema type.
      */
-    type: 'union';
+    readonly type: 'string';
     /**
-     * The union options.
+     * The schema reference.
      */
-    options: TOptions;
+    readonly reference: typeof string;
     /**
-     * The error message.
+     * The expected property.
      */
-    message: ErrorMessage | undefined;
+    readonly expects: 'string';
     /**
-     * The validation and transformation pipeline.
+     * The error message.
      */
-    pipe: Pipe<Output<TOptions[number]>> | undefined;
+    readonly message: TMessage;
 }
-
 /**
- * Union options async type.
+ * Creates a string schema.
+ *
+ * @returns A string schema.
+ */
+declare function string(): StringSchema<undefined>;
+/**
+ * Creates a string schema.
+ *
+ * @param message The error message.
+ *
+ * @returns A string schema.
  */
-type UnionOptionsAsync = MaybeReadonly<(BaseSchema | BaseSchemaAsync)[]>;
+declare function string<const TMessage extends ErrorMessage<StringIssue> | undefined>(message: TMessage): StringSchema<TMessage>;
+
 /**
- * Union schema async type.
+ * Unknown schema interface.
  */
-interface UnionSchemaAsync<TOptions extends UnionOptionsAsync, TOutput = Output<TOptions[number]>> extends BaseSchemaAsync<Input<TOptions[number]>, TOutput> {
-    /**
-     * The schema type.
-     */
-    type: 'union';
+interface UnknownSchema extends BaseSchema<unknown, unknown, never> {
     /**
-     * The union options.
+     * The schema type.
      */
-    options: TOptions;
+    readonly type: 'unknown';
     /**
-     * The error message.
+     * The schema reference.
      */
-    message: ErrorMessage | undefined;
+    readonly reference: typeof unknown;
     /**
-     * The validation and transformation pipeline.
+     * The expected property.
      */
-    pipe: PipeAsync<Input<TOptions[number]>> | undefined;
+    readonly expects: 'unknown';
 }
-
 /**
- * Record key async type.
+ * Creates a unknown schema.
+ *
+ * @returns A unknown schema.
  */
-type RecordKeyAsync = EnumSchema<any, string | number | symbol> | EnumSchemaAsync<any, string | number | symbol> | PicklistSchema<any, string | number | symbol> | PicklistSchemaAsync<any, string | number | symbol> | SpecialSchema<any, string | number | symbol> | SpecialSchemaAsync<any, string | number | symbol> | StringSchema<string | number | symbol> | StringSchemaAsync<string | number | symbol> | UnionSchema<any, string | number | symbol> | UnionSchemaAsync<any, string | number | symbol>;
+declare function unknown(): UnknownSchema;
 
 /**
- * Record path item type.
+ * Brand symbol.
  */
-interface RecordPathItem {
-    type: 'record';
-    origin: 'key' | 'value';
-    input: Record<string | number | symbol, unknown>;
-    key: string | number | symbol;
-    value: unknown;
-}
+declare const BrandSymbol: unique symbol;
 /**
- * Partial key schema type.
+ * Brand name type.
  */
-type PartialKeySchema = PicklistSchema<any> | PicklistSchemaAsync<any> | EnumSchema<any> | EnumSchemaAsync<any> | UnionSchema<any> | UnionSchemaAsync<any>;
+type BrandName = string | number | symbol;
 /**
- * Record input inference type.
+ * Brand interface.
  */
-type RecordInput<TKey extends RecordKey | RecordKeyAsync, TValue extends BaseSchema | BaseSchemaAsync> = ResolveObject<TKey extends PartialKeySchema ? Partial<Record<Input<TKey>, Input<TValue>>> : Record<Input<TKey>, Input<TValue>>>;
+interface Brand<TName extends BrandName> {
+    [BrandSymbol]: {
+        [TValue in TName]: TValue;
+    };
+}
 /**
- * Record output inference type.
+ * Value input type.
  */
-type RecordOutput<TKey extends RecordKey | RecordKeyAsync, TValue extends BaseSchema | BaseSchemaAsync> = ResolveObject<TKey extends PartialKeySchema ? Partial<Record<Output<TKey>, Output<TValue>>> : Record<Output<TKey>, Output<TValue>>>;
+type ValueInput = string | number | bigint | boolean | Date;
 
 /**
- * Record key type.
+ * Not value issue interface.
  */
-type RecordKey = EnumSchema<any, string | number | symbol> | PicklistSchema<any, string | number | symbol> | SpecialSchema<any, string | number | symbol> | StringSchema<string | number | symbol> | UnionSchema<any, string | number | symbol>;
+interface NotValueIssue<TInput extends ValueInput, TRequirement extends TInput> extends BaseIssue<TInput> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'validation';
+    /**
+     * The issue type.
+     */
+    readonly type: 'not_value';
+    /**
+     * The expected property.
+     */
+    readonly expected: `!${string}`;
+    /**
+     * The not required value.
+     */
+    readonly requirement: TRequirement;
+}
 /**
- * Record schema type.
+ * Not value action interface.
  */
-interface RecordSchema<TKey extends RecordKey, TValue extends BaseSchema, TOutput = RecordOutput<TKey, TValue>> extends BaseSchema<RecordInput<TKey, TValue>, TOutput> {
+interface NotValueAction<TInput extends ValueInput, TRequirement extends TInput, TMessage extends ErrorMessage<NotValueIssue<TInput, TRequirement>> | undefined> extends BaseValidation<TInput, TInput, NotValueIssue<TInput, TRequirement>> {
     /**
-     * The schema type.
+     * The action type.
      */
-    type: 'record';
+    readonly type: 'not_value';
     /**
-     * The record key schema.
+     * The action reference.
      */
-    key: TKey;
+    readonly reference: typeof notValue;
     /**
-     * The record value schema.
+     * The expected property.
      */
-    value: TValue;
+    readonly expects: `!${string}`;
     /**
-     * The error message.
+     * The not required value.
      */
-    message: ErrorMessage | undefined;
+    readonly requirement: TRequirement;
     /**
-     * The validation and transformation pipeline.
+     * The error message.
      */
-    pipe: Pipe<RecordOutput<TKey, TValue>> | undefined;
+    readonly message: TMessage;
 }
-
 /**
- * Set path item type.
+ * Creates a not value validation action.
+ *
+ * @param requirement The not required value.
+ *
+ * @returns A not value action.
  */
-interface SetPathItem {
-    type: 'set';
-    origin: 'value';
-    input: Set<unknown>;
-    key: number;
-    value: unknown;
-}
-
+declare function notValue<TInput extends ValueInput, const TRequirement extends TInput>(requirement: TRequirement): NotValueAction<TInput, TRequirement, undefined>;
 /**
- * Tuple path item type.
+ * Creates a not value validation action.
+ *
+ * @param requirement The not required value.
+ * @param message The error message.
+ *
+ * @returns A not value action.
  */
-interface TuplePathItem {
-    type: 'tuple';
-    origin: 'value';
-    input: [unknown, ...unknown[]];
-    key: number;
-    value: unknown;
-}
+declare function notValue<TInput extends ValueInput, const TRequirement extends TInput, const TMessage extends ErrorMessage<NotValueIssue<TInput, TRequirement>> | undefined>(requirement: TRequirement, message: TMessage): NotValueAction<TInput, TRequirement, TMessage>;
 
 /**
- * Unknown schema type.
+ * Readonly output type.
+ */
+type ReadonlyOutput<TInput> = TInput extends Map<infer TKey, infer TValue> ? ReadonlyMap<TKey, TValue> : TInput extends Set<infer TValue> ? ReadonlySet<TValue> : Readonly<TInput>;
+/**
+ * Readonly action interface.
  */
-interface UnknownSchema<TOutput = unknown> extends BaseSchema<unknown, TOutput> {
+interface ReadonlyAction<TInput> extends BaseTransformation<TInput, ReadonlyOutput<TInput>, never> {
     /**
-     * The schema type.
+     * The action type.
      */
-    type: 'unknown';
+    readonly type: 'readonly';
     /**
-     * The validation and transformation pipeline.
+     * The action reference.
      */
-    pipe: Pipe<unknown> | undefined;
+    readonly reference: typeof readonly;
 }
+/**
+ * Creates a readonly transformation action.
+ *
+ * @returns A readonly action.
+ */
+declare function readonly<TInput>(): ReadonlyAction<TInput>;
 
 type Platform = "win7" | "win8_1" | "win" | "mac10_9" | "mac10_11" | "mac" | "other";
-declare const ZHTML5Fonts: UnionSchema<(LiteralSchema<"defont", "defont"> | LiteralSchema<"mincho", "mincho"> | LiteralSchema<"gothic", "gothic">)[], "defont" | "mincho" | "gothic">;
-type HTML5Fonts = Output<typeof ZHTML5Fonts>;
+declare const ZHTML5Fonts: UnionSchema<[LiteralSchema<"gothic", undefined>, LiteralSchema<"mincho", undefined>, LiteralSchema<"defont", undefined>], undefined>;
+type HTML5Fonts = InferOutput<typeof ZHTML5Fonts>;
 type FontItem = {
     font: string;
     offset: number;
@@ -1399,478 +2271,253 @@ type PlatformFont = {
 };
 
 declare const ZFormattedComment: ObjectSchema<{
-    id: OptionalSchema<NumberSchema<number>, 0, number>;
-    vpos: OptionalSchema<NumberSchema<number>, 0, number>;
-    content: OptionalSchema<StringSchema<string>, "", string>;
-    date: OptionalSchema<NumberSchema<number>, 0, number>;
-    date_usec: OptionalSchema<NumberSchema<number>, 0, number>;
-    owner: OptionalSchema<BooleanSchema<boolean>, false, boolean>;
-    premium: OptionalSchema<BooleanSchema<boolean>, false, boolean>;
-    mail: OptionalSchema<ArraySchema<StringSchema<string>, string[]>, never[], string[]>;
-    user_id: OptionalSchema<NumberSchema<number>, 0, number>;
-    layer: OptionalSchema<NumberSchema<number>, -1, number>;
-    is_my_post: OptionalSchema<BooleanSchema<boolean>, false, boolean>;
-}, undefined, {
-    owner: boolean;
-    content: string;
-    id: number;
-    vpos: number;
-    date: number;
-    date_usec: number;
-    premium: boolean;
-    mail: string[];
-    user_id: number;
-    layer: number;
-    is_my_post: boolean;
-}>;
-type FormattedComment = Output<typeof ZFormattedComment>;
-declare const ZFormattedLegacyComment: ObjectSchema<Omit<{
-    id: OptionalSchema<NumberSchema<number>, 0, number>;
-    vpos: OptionalSchema<NumberSchema<number>, 0, number>;
-    content: OptionalSchema<StringSchema<string>, "", string>;
-    date: OptionalSchema<NumberSchema<number>, 0, number>;
-    date_usec: OptionalSchema<NumberSchema<number>, 0, number>;
-    owner: OptionalSchema<BooleanSchema<boolean>, false, boolean>;
-    premium: OptionalSchema<BooleanSchema<boolean>, false, boolean>;
-    mail: OptionalSchema<ArraySchema<StringSchema<string>, string[]>, never[], string[]>;
-    user_id: OptionalSchema<NumberSchema<number>, 0, number>;
-    layer: OptionalSchema<NumberSchema<number>, -1, number>;
-    is_my_post: OptionalSchema<BooleanSchema<boolean>, false, boolean>;
-}, "user_id" | "layer" | "is_my_post">, undefined, {
-    owner: boolean;
-    content: string;
-    id: number;
-    vpos: number;
-    date: number;
-    date_usec: number;
-    premium: boolean;
-    mail: string[];
-}>;
-type FormattedLegacyComment = Output<typeof ZFormattedLegacyComment>;
-type formattedComment = FormattedComment;
-type formattedLegacyComment = FormattedLegacyComment;
-
-declare const ZApiChat: ObjectSchema<{
-    thread: OptionalSchema<StringSchema<string>, "", string>;
-    no: OptionalSchema<NumberSchema<number>, 0, number>;
-    vpos: NumberSchema<number>;
-    date: OptionalSchema<NumberSchema<number>, 0, number>;
-    date_usec: OptionalSchema<NumberSchema<number>, 0, number>;
-    nicoru: OptionalSchema<NumberSchema<number>, 0, number>;
-    premium: OptionalSchema<NumberSchema<number>, 0, number>;
-    anonymity: OptionalSchema<NumberSchema<number>, 0, number>;
-    user_id: OptionalSchema<StringSchema<string>, "", string>;
-    mail: OptionalSchema<StringSchema<string>, "", string>;
-    content: StringSchema<string>;
-    deleted: OptionalSchema<NumberSchema<number>, 0, number>;
-}, undefined, {
-    content: string;
-    vpos: number;
-    date: number;
-    date_usec: number;
-    premium: number;
-    mail: string;
-    user_id: string;
-    thread: string;
-    no: number;
-    nicoru: number;
-    anonymity: number;
-    deleted: number;
-}>;
-type ApiChat = Output<typeof ZApiChat>;
-declare const ZRawApiResponse: UnionSchema<(ObjectSchema<{
-    chat: ObjectSchema<{
-        thread: OptionalSchema<StringSchema<string>, "", string>;
-        no: OptionalSchema<NumberSchema<number>, 0, number>;
-        vpos: NumberSchema<number>;
-        date: OptionalSchema<NumberSchema<number>, 0, number>;
-        date_usec: OptionalSchema<NumberSchema<number>, 0, number>;
-        nicoru: OptionalSchema<NumberSchema<number>, 0, number>;
-        premium: OptionalSchema<NumberSchema<number>, 0, number>;
-        anonymity: OptionalSchema<NumberSchema<number>, 0, number>;
-        user_id: OptionalSchema<StringSchema<string>, "", string>;
-        mail: OptionalSchema<StringSchema<string>, "", string>;
-        content: StringSchema<string>;
-        deleted: OptionalSchema<NumberSchema<number>, 0, number>;
-    }, undefined, {
+    readonly id: OptionalSchema<NumberSchema<undefined>, 0>;
+    readonly vpos: OptionalSchema<NumberSchema<undefined>, 0>;
+    readonly content: OptionalSchema<StringSchema<undefined>, "">;
+    readonly date: OptionalSchema<NumberSchema<undefined>, 0>;
+    readonly date_usec: OptionalSchema<NumberSchema<undefined>, 0>;
+    readonly owner: OptionalSchema<BooleanSchema<undefined>, false>;
+    readonly premium: OptionalSchema<BooleanSchema<undefined>, false>;
+    readonly mail: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, readonly []>;
+    readonly user_id: OptionalSchema<NumberSchema<undefined>, 0>;
+    readonly layer: OptionalSchema<NumberSchema<undefined>, -1>;
+    readonly is_my_post: OptionalSchema<BooleanSchema<undefined>, false>;
+}, undefined>;
+type FormattedComment = InferOutput<typeof ZFormattedComment>;
+declare const ZFormattedLegacyComment: Omit<ObjectSchema<{
+    readonly id: OptionalSchema<NumberSchema<undefined>, 0>;
+    readonly vpos: OptionalSchema<NumberSchema<undefined>, 0>;
+    readonly content: OptionalSchema<StringSchema<undefined>, "">;
+    readonly date: OptionalSchema<NumberSchema<undefined>, 0>;
+    readonly date_usec: OptionalSchema<NumberSchema<undefined>, 0>;
+    readonly owner: OptionalSchema<BooleanSchema<undefined>, false>;
+    readonly premium: OptionalSchema<BooleanSchema<undefined>, false>;
+    readonly mail: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, readonly []>;
+    readonly user_id: OptionalSchema<NumberSchema<undefined>, 0>;
+    readonly layer: OptionalSchema<NumberSchema<undefined>, -1>;
+    readonly is_my_post: OptionalSchema<BooleanSchema<undefined>, false>;
+}, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+    readonly entries: Omit<{
+        readonly id: OptionalSchema<NumberSchema<undefined>, 0>;
+        readonly vpos: OptionalSchema<NumberSchema<undefined>, 0>;
+        readonly content: OptionalSchema<StringSchema<undefined>, "">;
+        readonly date: OptionalSchema<NumberSchema<undefined>, 0>;
+        readonly date_usec: OptionalSchema<NumberSchema<undefined>, 0>;
+        readonly owner: OptionalSchema<BooleanSchema<undefined>, false>;
+        readonly premium: OptionalSchema<BooleanSchema<undefined>, false>;
+        readonly mail: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, readonly []>;
+        readonly user_id: OptionalSchema<NumberSchema<undefined>, 0>;
+        readonly layer: OptionalSchema<NumberSchema<undefined>, -1>;
+        readonly is_my_post: OptionalSchema<BooleanSchema<undefined>, false>;
+    }, "user_id" | "layer" | "is_my_post">;
+    readonly '~standard': StandardProps<{
+        owner?: boolean | undefined;
+        content?: string | undefined;
+        id?: number | undefined;
+        vpos?: number | undefined;
+        date?: number | undefined;
+        date_usec?: number | undefined;
+        premium?: boolean | undefined;
+        mail?: string[] | undefined;
+    }, {
+        owner: boolean;
         content: string;
+        id: number;
         vpos: number;
         date: number;
         date_usec: number;
-        premium: number;
-        mail: string;
-        user_id: string;
-        thread: string;
-        no: number;
-        nicoru: number;
-        anonymity: number;
-        deleted: number;
+        premium: boolean;
+        mail: string[];
     }>;
-}, undefined, {
-    chat: {
+    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => OutputDataset<{
+        owner: boolean;
         content: string;
+        id: number;
         vpos: number;
         date: number;
         date_usec: number;
-        premium: number;
-        mail: string;
-        user_id: string;
-        thread: string;
-        no: number;
-        nicoru: number;
-        anonymity: number;
-        deleted: number;
-    };
-}> | RecordSchema<StringSchema<string>, UnknownSchema<unknown>, {
-    [x: string]: unknown;
-}>)[], {
-    chat: {
-        content: string;
-        vpos: number;
-        date: number;
-        date_usec: number;
-        premium: number;
-        mail: string;
-        user_id: string;
-        thread: string;
-        no: number;
-        nicoru: number;
-        anonymity: number;
-        deleted: number;
-    };
-} | {
-    [x: string]: unknown;
-}>;
-type RawApiResponse = Output<typeof ZRawApiResponse>;
+        premium: boolean;
+        mail: string[];
+    }, StringIssue | NumberIssue | BooleanIssue | ObjectIssue | ArrayIssue>;
+    readonly '~types'?: {
+        readonly input: {
+            owner?: boolean | undefined;
+            content?: string | undefined;
+            id?: number | undefined;
+            vpos?: number | undefined;
+            date?: number | undefined;
+            date_usec?: number | undefined;
+            premium?: boolean | undefined;
+            mail?: string[] | undefined;
+        };
+        readonly output: {
+            owner: boolean;
+            content: string;
+            id: number;
+            vpos: number;
+            date: number;
+            date_usec: number;
+            premium: boolean;
+            mail: string[];
+        };
+        readonly issue: StringIssue | NumberIssue | BooleanIssue | ObjectIssue | ArrayIssue;
+    } | undefined;
+};
+type FormattedLegacyComment = InferOutput<typeof ZFormattedLegacyComment>;
+type formattedComment = FormattedComment;
+type formattedLegacyComment = FormattedLegacyComment;
+
+declare const ZApiChat: ObjectSchema<{
+    readonly thread: OptionalSchema<StringSchema<undefined>, "">;
+    readonly no: OptionalSchema<NumberSchema<undefined>, 0>;
+    readonly vpos: NumberSchema<undefined>;
+    readonly date: OptionalSchema<NumberSchema<undefined>, 0>;
+    readonly date_usec: OptionalSchema<NumberSchema<undefined>, 0>;
+    readonly nicoru: OptionalSchema<NumberSchema<undefined>, 0>;
+    readonly premium: OptionalSchema<NumberSchema<undefined>, 0>;
+    readonly anonymity: OptionalSchema<NumberSchema<undefined>, 0>;
+    readonly user_id: OptionalSchema<StringSchema<undefined>, "">;
+    readonly mail: OptionalSchema<StringSchema<undefined>, "">;
+    readonly content: StringSchema<undefined>;
+    readonly deleted: OptionalSchema<NumberSchema<undefined>, 0>;
+}, undefined>;
+type ApiChat = InferOutput<typeof ZApiChat>;
+declare const ZRawApiResponse: UnionSchema<[ObjectSchema<{
+    readonly chat: ObjectSchema<{
+        readonly thread: OptionalSchema<StringSchema<undefined>, "">;
+        readonly no: OptionalSchema<NumberSchema<undefined>, 0>;
+        readonly vpos: NumberSchema<undefined>;
+        readonly date: OptionalSchema<NumberSchema<undefined>, 0>;
+        readonly date_usec: OptionalSchema<NumberSchema<undefined>, 0>;
+        readonly nicoru: OptionalSchema<NumberSchema<undefined>, 0>;
+        readonly premium: OptionalSchema<NumberSchema<undefined>, 0>;
+        readonly anonymity: OptionalSchema<NumberSchema<undefined>, 0>;
+        readonly user_id: OptionalSchema<StringSchema<undefined>, "">;
+        readonly mail: OptionalSchema<StringSchema<undefined>, "">;
+        readonly content: StringSchema<undefined>;
+        readonly deleted: OptionalSchema<NumberSchema<undefined>, 0>;
+    }, undefined>;
+}, undefined>, RecordSchema<SchemaWithPipe<readonly [StringSchema<undefined>, NotValueAction<string, "chat", undefined>]>, UnknownSchema, undefined>], undefined>;
+type RawApiResponse = InferOutput<typeof ZRawApiResponse>;
 declare const ZApiPing: ObjectSchema<{
-    content: StringSchema<string>;
-}, undefined, {
-    content: string;
-}>;
-type ApiPing = Output<typeof ZApiPing>;
+    readonly content: StringSchema<undefined>;
+}, undefined>;
+type ApiPing = InferOutput<typeof ZApiPing>;
 declare const ZApiThread: ObjectSchema<{
-    resultcode: NumberSchema<number>;
-    thread: StringSchema<string>;
-    server_time: NumberSchema<number>;
-    ticket: StringSchema<string>;
-    revision: NumberSchema<number>;
-}, undefined, {
-    thread: string;
-    resultcode: number;
-    server_time: number;
-    ticket: string;
-    revision: number;
-}>;
-type ApiThread = Output<typeof ZApiThread>;
+    readonly resultcode: NumberSchema<undefined>;
+    readonly thread: StringSchema<undefined>;
+    readonly server_time: NumberSchema<undefined>;
+    readonly ticket: StringSchema<undefined>;
+    readonly revision: NumberSchema<undefined>;
+}, undefined>;
+type ApiThread = InferOutput<typeof ZApiThread>;
 declare const ZApiLeaf: ObjectSchema<{
-    thread: StringSchema<string>;
-    count: NumberSchema<number>;
-}, undefined, {
-    count: number;
-    thread: string;
-}>;
-type ApiLeaf = Output<typeof ZApiLeaf>;
+    readonly thread: StringSchema<undefined>;
+    readonly count: NumberSchema<undefined>;
+}, undefined>;
+type ApiLeaf = InferOutput<typeof ZApiLeaf>;
 declare const ZApiGlobalNumRes: ObjectSchema<{
-    thread: StringSchema<string>;
-    num_res: NumberSchema<number>;
-}, undefined, {
-    thread: string;
-    num_res: number;
-}>;
-type ApiGlobalNumRes = Output<typeof ZApiGlobalNumRes>;
+    readonly thread: StringSchema<undefined>;
+    readonly num_res: NumberSchema<undefined>;
+}, undefined>;
+type ApiGlobalNumRes = InferOutput<typeof ZApiGlobalNumRes>;
 type rawApiResponse = RawApiResponse;
 
 declare const ZOwnerComment: ObjectSchema<{
-    time: StringSchema<string>;
-    command: StringSchema<string>;
-    comment: StringSchema<string>;
-}, undefined, {
-    time: string;
-    command: string;
-    comment: string;
-}>;
-type OwnerComment = Output<typeof ZOwnerComment>;
+    readonly time: StringSchema<undefined>;
+    readonly command: StringSchema<undefined>;
+    readonly comment: StringSchema<undefined>;
+}, undefined>;
+type OwnerComment = InferOutput<typeof ZOwnerComment>;
 type ownerComment = OwnerComment;
 
 declare const ZV1Comment: ObjectSchema<{
-    id: StringSchema<string>;
-    no: NumberSchema<number>;
-    vposMs: NumberSchema<number>;
-    body: StringSchema<string>;
-    commands: ArraySchema<StringSchema<string>, string[]>;
-    userId: StringSchema<string>;
-    isPremium: BooleanSchema<boolean>;
-    score: NumberSchema<number>;
-    postedAt: StringSchema<string>;
-    nicoruCount: NumberSchema<number>;
-    nicoruId: NullableSchema<StringSchema<string>, undefined, string | null>;
-    source: StringSchema<string>;
-    isMyPost: BooleanSchema<boolean>;
-}, undefined, {
-    id: string;
-    no: number;
-    vposMs: number;
-    body: string;
-    commands: string[];
-    userId: string;
-    isPremium: boolean;
-    score: number;
-    postedAt: string;
-    nicoruCount: number;
-    nicoruId: string | null;
-    source: string;
-    isMyPost: boolean;
-}>;
-type V1Comment = Output<typeof ZV1Comment>;
+    readonly id: StringSchema<undefined>;
+    readonly no: NumberSchema<undefined>;
+    readonly vposMs: NumberSchema<undefined>;
+    readonly body: StringSchema<undefined>;
+    readonly commands: ArraySchema<StringSchema<undefined>, undefined>;
+    readonly userId: StringSchema<undefined>;
+    readonly isPremium: BooleanSchema<undefined>;
+    readonly score: NumberSchema<undefined>;
+    readonly postedAt: StringSchema<undefined>;
+    readonly nicoruCount: NumberSchema<undefined>;
+    readonly nicoruId: NullableSchema<StringSchema<undefined>, undefined>;
+    readonly source: StringSchema<undefined>;
+    readonly isMyPost: BooleanSchema<undefined>;
+}, undefined>;
+type V1Comment = InferOutput<typeof ZV1Comment>;
 declare const ZV1Thread: ObjectSchema<{
-    id: UnknownSchema<unknown>;
-    fork: StringSchema<string>;
-    commentCount: OptionalSchema<NumberSchema<number>, 0, number>;
-    comments: ArraySchema<ObjectSchema<{
-        id: StringSchema<string>;
-        no: NumberSchema<number>;
-        vposMs: NumberSchema<number>;
-        body: StringSchema<string>;
-        commands: ArraySchema<StringSchema<string>, string[]>;
-        userId: StringSchema<string>;
-        isPremium: BooleanSchema<boolean>;
-        score: NumberSchema<number>;
-        postedAt: StringSchema<string>;
-        nicoruCount: NumberSchema<number>;
-        nicoruId: NullableSchema<StringSchema<string>, undefined, string | null>;
-        source: StringSchema<string>;
-        isMyPost: BooleanSchema<boolean>;
-    }, undefined, {
-        id: string;
-        no: number;
-        vposMs: number;
-        body: string;
-        commands: string[];
-        userId: string;
-        isPremium: boolean;
-        score: number;
-        postedAt: string;
-        nicoruCount: number;
-        nicoruId: string | null;
-        source: string;
-        isMyPost: boolean;
-    }>, {
-        id: string;
-        no: number;
-        vposMs: number;
-        body: string;
-        commands: string[];
-        userId: string;
-        isPremium: boolean;
-        score: number;
-        postedAt: string;
-        nicoruCount: number;
-        nicoruId: string | null;
-        source: string;
-        isMyPost: boolean;
-    }[]>;
-}, undefined, {
-    id: unknown;
-    fork: string;
-    commentCount: number;
-    comments: {
-        id: string;
-        no: number;
-        vposMs: number;
-        body: string;
-        commands: string[];
-        userId: string;
-        isPremium: boolean;
-        score: number;
-        postedAt: string;
-        nicoruCount: number;
-        nicoruId: string | null;
-        source: string;
-        isMyPost: boolean;
-    }[];
-}>;
-type V1Thread = Output<typeof ZV1Thread>;
+    readonly id: UnknownSchema;
+    readonly fork: StringSchema<undefined>;
+    readonly commentCount: OptionalSchema<NumberSchema<undefined>, 0>;
+    readonly comments: ArraySchema<ObjectSchema<{
+        readonly id: StringSchema<undefined>;
+        readonly no: NumberSchema<undefined>;
+        readonly vposMs: NumberSchema<undefined>;
+        readonly body: StringSchema<undefined>;
+        readonly commands: ArraySchema<StringSchema<undefined>, undefined>;
+        readonly userId: StringSchema<undefined>;
+        readonly isPremium: BooleanSchema<undefined>;
+        readonly score: NumberSchema<undefined>;
+        readonly postedAt: StringSchema<undefined>;
+        readonly nicoruCount: NumberSchema<undefined>;
+        readonly nicoruId: NullableSchema<StringSchema<undefined>, undefined>;
+        readonly source: StringSchema<undefined>;
+        readonly isMyPost: BooleanSchema<undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+type V1Thread = InferOutput<typeof ZV1Thread>;
 type v1Thread = V1Thread;
 
 declare const ZXml2jsChatItem: ObjectSchema<{
-    _: StringSchema<string>;
-    $: ObjectSchema<{
-        no: OptionalSchema<StringSchema<string>, undefined, string | undefined>;
-        vpos: StringSchema<string>;
-        date: OptionalSchema<StringSchema<string>, "0", string>;
-        date_usec: OptionalSchema<StringSchema<string>, "0", string>;
-        user_id: OptionalSchema<StringSchema<string>, undefined, string | undefined>;
-        owner: OptionalSchema<StringSchema<string>, "", string>;
-        premium: OptionalSchema<StringSchema<string>, "", string>;
-        mail: OptionalSchema<StringSchema<string>, "", string>;
-    }, undefined, {
-        owner: string;
-        vpos: string;
-        date: string;
-        date_usec: string;
-        premium: string;
-        mail: string;
-        user_id?: string | undefined;
-        no?: string | undefined;
-    }>;
-}, undefined, {
-    _: string;
-    $: {
-        owner: string;
-        vpos: string;
-        date: string;
-        date_usec: string;
-        premium: string;
-        mail: string;
-        user_id?: string | undefined;
-        no?: string | undefined;
-    };
-}>;
-type Xml2jsChatItem = Output<typeof ZXml2jsChatItem>;
+    readonly _: StringSchema<undefined>;
+    readonly $: ObjectSchema<{
+        readonly no: OptionalSchema<StringSchema<undefined>, undefined>;
+        readonly vpos: StringSchema<undefined>;
+        readonly date: OptionalSchema<StringSchema<undefined>, "0">;
+        readonly date_usec: OptionalSchema<StringSchema<undefined>, "0">;
+        readonly user_id: OptionalSchema<StringSchema<undefined>, undefined>;
+        readonly owner: OptionalSchema<StringSchema<undefined>, "">;
+        readonly premium: OptionalSchema<StringSchema<undefined>, "">;
+        readonly mail: OptionalSchema<StringSchema<undefined>, "">;
+    }, undefined>;
+}, undefined>;
+type Xml2jsChatItem = InferOutput<typeof ZXml2jsChatItem>;
 declare const ZXml2jsChat: ObjectSchema<{
-    chat: ArraySchema<ObjectSchema<{
-        _: StringSchema<string>;
-        $: ObjectSchema<{
-            no: OptionalSchema<StringSchema<string>, undefined, string | undefined>;
-            vpos: StringSchema<string>;
-            date: OptionalSchema<StringSchema<string>, "0", string>;
-            date_usec: OptionalSchema<StringSchema<string>, "0", string>;
-            user_id: OptionalSchema<StringSchema<string>, undefined, string | undefined>;
-            owner: OptionalSchema<StringSchema<string>, "", string>;
-            premium: OptionalSchema<StringSchema<string>, "", string>;
-            mail: OptionalSchema<StringSchema<string>, "", string>;
-        }, undefined, {
-            owner: string;
-            vpos: string;
-            date: string;
-            date_usec: string;
-            premium: string;
-            mail: string;
-            user_id?: string | undefined;
-            no?: string | undefined;
-        }>;
-    }, undefined, {
-        _: string;
-        $: {
-            owner: string;
-            vpos: string;
-            date: string;
-            date_usec: string;
-            premium: string;
-            mail: string;
-            user_id?: string | undefined;
-            no?: string | undefined;
-        };
-    }>, {
-        _: string;
-        $: {
-            owner: string;
-            vpos: string;
-            date: string;
-            date_usec: string;
-            premium: string;
-            mail: string;
-            user_id?: string | undefined;
-            no?: string | undefined;
-        };
-    }[]>;
-}, undefined, {
-    chat: {
-        _: string;
-        $: {
-            owner: string;
-            vpos: string;
-            date: string;
-            date_usec: string;
-            premium: string;
-            mail: string;
-            user_id?: string | undefined;
-            no?: string | undefined;
-        };
-    }[];
-}>;
-type Xml2jsChat = Output<typeof ZXml2jsChat>;
+    readonly chat: ArraySchema<ObjectSchema<{
+        readonly _: StringSchema<undefined>;
+        readonly $: ObjectSchema<{
+            readonly no: OptionalSchema<StringSchema<undefined>, undefined>;
+            readonly vpos: StringSchema<undefined>;
+            readonly date: OptionalSchema<StringSchema<undefined>, "0">;
+            readonly date_usec: OptionalSchema<StringSchema<undefined>, "0">;
+            readonly user_id: OptionalSchema<StringSchema<undefined>, undefined>;
+            readonly owner: OptionalSchema<StringSchema<undefined>, "">;
+            readonly premium: OptionalSchema<StringSchema<undefined>, "">;
+            readonly mail: OptionalSchema<StringSchema<undefined>, "">;
+        }, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+type Xml2jsChat = InferOutput<typeof ZXml2jsChat>;
 declare const ZXml2jsPacket: ObjectSchema<{
-    packet: ObjectSchema<{
-        chat: ArraySchema<ObjectSchema<{
-            _: StringSchema<string>;
-            $: ObjectSchema<{
-                no: OptionalSchema<StringSchema<string>, undefined, string | undefined>;
-                vpos: StringSchema<string>;
-                date: OptionalSchema<StringSchema<string>, "0", string>;
-                date_usec: OptionalSchema<StringSchema<string>, "0", string>;
-                user_id: OptionalSchema<StringSchema<string>, undefined, string | undefined>;
-                owner: OptionalSchema<StringSchema<string>, "", string>;
-                premium: OptionalSchema<StringSchema<string>, "", string>;
-                mail: OptionalSchema<StringSchema<string>, "", string>;
-            }, undefined, {
-                owner: string;
-                vpos: string;
-                date: string;
-                date_usec: string;
-                premium: string;
-                mail: string;
-                user_id?: string | undefined;
-                no?: string | undefined;
-            }>;
-        }, undefined, {
-            _: string;
-            $: {
-                owner: string;
-                vpos: string;
-                date: string;
-                date_usec: string;
-                premium: string;
-                mail: string;
-                user_id?: string | undefined;
-                no?: string | undefined;
-            };
-        }>, {
-            _: string;
-            $: {
-                owner: string;
-                vpos: string;
-                date: string;
-                date_usec: string;
-                premium: string;
-                mail: string;
-                user_id?: string | undefined;
-                no?: string | undefined;
-            };
-        }[]>;
-    }, undefined, {
-        chat: {
-            _: string;
-            $: {
-                owner: string;
-                vpos: string;
-                date: string;
-                date_usec: string;
-                premium: string;
-                mail: string;
-                user_id?: string | undefined;
-                no?: string | undefined;
-            };
-        }[];
-    }>;
-}, undefined, {
-    packet: {
-        chat: {
-            _: string;
-            $: {
-                owner: string;
-                vpos: string;
-                date: string;
-                date_usec: string;
-                premium: string;
-                mail: string;
-                user_id?: string | undefined;
-                no?: string | undefined;
-            };
-        }[];
-    };
-}>;
-type Xml2jsPacket = Output<typeof ZXml2jsPacket>;
+    readonly packet: ObjectSchema<{
+        readonly chat: ArraySchema<ObjectSchema<{
+            readonly _: StringSchema<undefined>;
+            readonly $: ObjectSchema<{
+                readonly no: OptionalSchema<StringSchema<undefined>, undefined>;
+                readonly vpos: StringSchema<undefined>;
+                readonly date: OptionalSchema<StringSchema<undefined>, "0">;
+                readonly date_usec: OptionalSchema<StringSchema<undefined>, "0">;
+                readonly user_id: OptionalSchema<StringSchema<undefined>, undefined>;
+                readonly owner: OptionalSchema<StringSchema<undefined>, "">;
+                readonly premium: OptionalSchema<StringSchema<undefined>, "">;
+                readonly mail: OptionalSchema<StringSchema<undefined>, "">;
+            }, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
+type Xml2jsPacket = InferOutput<typeof ZXml2jsPacket>;
 
 interface IComment {
     comment: FormattedCommentWithSize;
@@ -1911,12 +2558,12 @@ type IPluginList = {
     canvas: IRenderer;
 }[];
 
-declare const ZInputFormatType: UnionSchema<(LiteralSchema<"XMLDocument", "XMLDocument"> | LiteralSchema<"niconicome", "niconicome"> | LiteralSchema<"xml2js", "xml2js"> | LiteralSchema<"formatted", "formatted"> | LiteralSchema<"legacy", "legacy"> | LiteralSchema<"legacyOwner", "legacyOwner"> | LiteralSchema<"owner", "owner"> | LiteralSchema<"v1", "v1"> | LiteralSchema<"empty", "empty"> | LiteralSchema<"default", "default">)[], "default" | "XMLDocument" | "niconicome" | "xml2js" | "formatted" | "legacy" | "legacyOwner" | "owner" | "v1" | "empty">;
-type InputFormatType = Output<typeof ZInputFormatType>;
+declare const ZInputFormatType: UnionSchema<[LiteralSchema<"XMLDocument", undefined>, LiteralSchema<"niconicome", undefined>, LiteralSchema<"xml2js", undefined>, LiteralSchema<"formatted", undefined>, LiteralSchema<"legacy", undefined>, LiteralSchema<"legacyOwner", undefined>, LiteralSchema<"owner", undefined>, LiteralSchema<"v1", undefined>, LiteralSchema<"empty", undefined>, LiteralSchema<"default", undefined>], undefined>;
+type InputFormatType = InferOutput<typeof ZInputFormatType>;
 type InputFormat = XMLDocument | Xml2jsPacket | FormattedComment[] | FormattedLegacyComment[] | RawApiResponse[] | OwnerComment[] | V1Thread[] | string | undefined;
 type ModeType = "default" | "html5" | "flash";
 type BaseOptions = {
-    config: Config;
+    config: Config$1;
     debug: boolean;
     enableLegacyPiP: boolean;
     format: InputFormatType;
@@ -1987,6 +2634,7 @@ type FormattedCommentWithFont = {
     strokeColor?: string;
     wakuColor?: string;
     fillColor?: string;
+    opacity?: number;
     full: boolean;
     ender: boolean;
     _live: boolean;
@@ -2027,6 +2675,7 @@ type ParseCommandAndNicoScriptResult = {
     strokeColor?: string;
     wakuColor?: string;
     fillColor?: string;
+    opacity?: number;
     font: CommentFont;
     full: boolean;
     ender: boolean;
@@ -2035,260 +2684,96 @@ type ParseCommandAndNicoScriptResult = {
     long: number;
     button?: ButtonParams;
 };
-declare const ZCommentFont: UnionSchema<(LiteralSchema<"defont", "defont"> | LiteralSchema<"mincho", "mincho"> | LiteralSchema<"gothic", "gothic"> | LiteralSchema<"gulim", "gulim"> | LiteralSchema<"simsun", "simsun">)[], "defont" | "mincho" | "gothic" | "gulim" | "simsun">;
-type CommentFont = Output<typeof ZCommentFont>;
-declare const ZCommentHTML5Font: UnionSchema<(LiteralSchema<"defont", "defont"> | LiteralSchema<"mincho", "mincho"> | LiteralSchema<"gothic", "gothic">)[], "defont" | "mincho" | "gothic">;
-type CommentHTML5Font = Output<typeof ZCommentHTML5Font>;
-declare const ZCommentFlashFont: UnionSchema<(LiteralSchema<"defont", "defont"> | LiteralSchema<"gulim", "gulim"> | LiteralSchema<"simsun", "simsun">)[], "defont" | "gulim" | "simsun">;
-type CommentFlashFont = Output<typeof ZCommentFlashFont>;
+declare const ZCommentFont: UnionSchema<[LiteralSchema<"defont", undefined>, LiteralSchema<"mincho", undefined>, LiteralSchema<"gothic", undefined>, LiteralSchema<"gulim", undefined>, LiteralSchema<"simsun", undefined>], undefined>;
+type CommentFont = InferOutput<typeof ZCommentFont>;
+declare const ZCommentHTML5Font: UnionSchema<[LiteralSchema<"defont", undefined>, LiteralSchema<"mincho", undefined>, LiteralSchema<"gothic", undefined>], undefined>;
+type CommentHTML5Font = InferOutput<typeof ZCommentHTML5Font>;
+declare const ZCommentFlashFont: UnionSchema<[LiteralSchema<"defont", undefined>, LiteralSchema<"gulim", undefined>, LiteralSchema<"simsun", undefined>], undefined>;
+type CommentFlashFont = InferOutput<typeof ZCommentFlashFont>;
 declare const ZCommentContentItemSpacer: ObjectSchema<{
-    type: LiteralSchema<"spacer", "spacer">;
-    char: StringSchema<string>;
-    charWidth: NumberSchema<number>;
-    isButton: OptionalSchema<BooleanSchema<boolean>, undefined, boolean | undefined>;
-    font: OptionalSchema<UnionSchema<(LiteralSchema<"defont", "defont"> | LiteralSchema<"gulim", "gulim"> | LiteralSchema<"simsun", "simsun">)[], "defont" | "gulim" | "simsun">, undefined, "defont" | "gulim" | "simsun" | undefined>;
-    count: NumberSchema<number>;
-}, undefined, {
-    type: "spacer";
-    char: string;
-    charWidth: number;
-    count: number;
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-}>;
+    readonly type: LiteralSchema<"spacer", undefined>;
+    readonly char: StringSchema<undefined>;
+    readonly charWidth: NumberSchema<undefined>;
+    readonly isButton: OptionalSchema<BooleanSchema<undefined>, undefined>;
+    readonly font: OptionalSchema<UnionSchema<[LiteralSchema<"defont", undefined>, LiteralSchema<"gulim", undefined>, LiteralSchema<"simsun", undefined>], undefined>, undefined>;
+    readonly count: NumberSchema<undefined>;
+}, undefined>;
 declare const ZCommentContentItemText: ObjectSchema<{
-    type: LiteralSchema<"text", "text">;
-    content: StringSchema<string>;
-    slicedContent: ArraySchema<StringSchema<string>, string[]>;
-    isButton: OptionalSchema<BooleanSchema<boolean>, undefined, boolean | undefined>;
-    font: OptionalSchema<UnionSchema<(LiteralSchema<"defont", "defont"> | LiteralSchema<"gulim", "gulim"> | LiteralSchema<"simsun", "simsun">)[], "defont" | "gulim" | "simsun">, undefined, "defont" | "gulim" | "simsun" | undefined>;
-    width: OptionalSchema<ArraySchema<NumberSchema<number>, number[]>, undefined, number[] | undefined>;
-}, undefined, {
-    type: "text";
-    content: string;
-    slicedContent: string[];
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-    width?: number[] | undefined;
-}>;
-type CommentContentItemText = Output<typeof ZCommentContentItemText>;
-declare const ZCommentContentItem: UnionSchema<(ObjectSchema<{
-    type: LiteralSchema<"spacer", "spacer">;
-    char: StringSchema<string>;
-    charWidth: NumberSchema<number>;
-    isButton: OptionalSchema<BooleanSchema<boolean>, undefined, boolean | undefined>;
-    font: OptionalSchema<UnionSchema<(LiteralSchema<"defont", "defont"> | LiteralSchema<"gulim", "gulim"> | LiteralSchema<"simsun", "simsun">)[], "defont" | "gulim" | "simsun">, undefined, "defont" | "gulim" | "simsun" | undefined>;
-    count: NumberSchema<number>;
-}, undefined, {
-    type: "spacer";
-    char: string;
-    charWidth: number;
-    count: number;
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-}> | ObjectSchema<{
-    type: LiteralSchema<"text", "text">;
-    content: StringSchema<string>;
-    slicedContent: ArraySchema<StringSchema<string>, string[]>;
-    isButton: OptionalSchema<BooleanSchema<boolean>, undefined, boolean | undefined>;
-    font: OptionalSchema<UnionSchema<(LiteralSchema<"defont", "defont"> | LiteralSchema<"gulim", "gulim"> | LiteralSchema<"simsun", "simsun">)[], "defont" | "gulim" | "simsun">, undefined, "defont" | "gulim" | "simsun" | undefined>;
-    width: OptionalSchema<ArraySchema<NumberSchema<number>, number[]>, undefined, number[] | undefined>;
-}, undefined, {
-    type: "text";
-    content: string;
-    slicedContent: string[];
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-    width?: number[] | undefined;
-}>)[], {
-    type: "spacer";
-    char: string;
-    charWidth: number;
-    count: number;
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-} | {
-    type: "text";
-    content: string;
-    slicedContent: string[];
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-    width?: number[] | undefined;
-}>;
-type CommentContentItem = Output<typeof ZCommentContentItem>;
-declare const ZCommentMeasuredContentItemText: IntersectSchema<[UnionSchema<(ObjectSchema<{
-    type: LiteralSchema<"spacer", "spacer">;
-    char: StringSchema<string>;
-    charWidth: NumberSchema<number>;
-    isButton: OptionalSchema<BooleanSchema<boolean>, undefined, boolean | undefined>;
-    font: OptionalSchema<UnionSchema<(LiteralSchema<"defont", "defont"> | LiteralSchema<"gulim", "gulim"> | LiteralSchema<"simsun", "simsun">)[], "defont" | "gulim" | "simsun">, undefined, "defont" | "gulim" | "simsun" | undefined>;
-    count: NumberSchema<number>;
-}, undefined, {
-    type: "spacer";
-    char: string;
-    charWidth: number;
-    count: number;
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-}> | ObjectSchema<{
-    type: LiteralSchema<"text", "text">;
-    content: StringSchema<string>;
-    slicedContent: ArraySchema<StringSchema<string>, string[]>;
-    isButton: OptionalSchema<BooleanSchema<boolean>, undefined, boolean | undefined>;
-    font: OptionalSchema<UnionSchema<(LiteralSchema<"defont", "defont"> | LiteralSchema<"gulim", "gulim"> | LiteralSchema<"simsun", "simsun">)[], "defont" | "gulim" | "simsun">, undefined, "defont" | "gulim" | "simsun" | undefined>;
-    width: OptionalSchema<ArraySchema<NumberSchema<number>, number[]>, undefined, number[] | undefined>;
-}, undefined, {
-    type: "text";
-    content: string;
-    slicedContent: string[];
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-    width?: number[] | undefined;
-}>)[], {
-    type: "spacer";
-    char: string;
-    charWidth: number;
-    count: number;
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-} | {
-    type: "text";
-    content: string;
-    slicedContent: string[];
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-    width?: number[] | undefined;
-}>, ObjectSchema<{
-    width: ArraySchema<NumberSchema<number>, number[]>;
-}, undefined, {
-    width: number[];
-}>], ({
-    type: "spacer";
-    char: string;
-    charWidth: number;
-    count: number;
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-} | {
-    type: "text";
-    content: string;
-    slicedContent: string[];
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-    width?: number[] | undefined;
-}) & {
-    width: number[];
-}>;
-declare const ZCommentMeasuredContentItem: UnionSchema<(ObjectSchema<{
-    type: LiteralSchema<"spacer", "spacer">;
-    char: StringSchema<string>;
-    charWidth: NumberSchema<number>;
-    isButton: OptionalSchema<BooleanSchema<boolean>, undefined, boolean | undefined>;
-    font: OptionalSchema<UnionSchema<(LiteralSchema<"defont", "defont"> | LiteralSchema<"gulim", "gulim"> | LiteralSchema<"simsun", "simsun">)[], "defont" | "gulim" | "simsun">, undefined, "defont" | "gulim" | "simsun" | undefined>;
-    count: NumberSchema<number>;
-}, undefined, {
-    type: "spacer";
-    char: string;
-    charWidth: number;
-    count: number;
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-}> | IntersectSchema<[UnionSchema<(ObjectSchema<{
-    type: LiteralSchema<"spacer", "spacer">;
-    char: StringSchema<string>;
-    charWidth: NumberSchema<number>;
-    isButton: OptionalSchema<BooleanSchema<boolean>, undefined, boolean | undefined>;
-    font: OptionalSchema<UnionSchema<(LiteralSchema<"defont", "defont"> | LiteralSchema<"gulim", "gulim"> | LiteralSchema<"simsun", "simsun">)[], "defont" | "gulim" | "simsun">, undefined, "defont" | "gulim" | "simsun" | undefined>;
-    count: NumberSchema<number>;
-}, undefined, {
-    type: "spacer";
-    char: string;
-    charWidth: number;
-    count: number;
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-}> | ObjectSchema<{
-    type: LiteralSchema<"text", "text">;
-    content: StringSchema<string>;
-    slicedContent: ArraySchema<StringSchema<string>, string[]>;
-    isButton: OptionalSchema<BooleanSchema<boolean>, undefined, boolean | undefined>;
-    font: OptionalSchema<UnionSchema<(LiteralSchema<"defont", "defont"> | LiteralSchema<"gulim", "gulim"> | LiteralSchema<"simsun", "simsun">)[], "defont" | "gulim" | "simsun">, undefined, "defont" | "gulim" | "simsun" | undefined>;
-    width: OptionalSchema<ArraySchema<NumberSchema<number>, number[]>, undefined, number[] | undefined>;
-}, undefined, {
-    type: "text";
-    content: string;
-    slicedContent: string[];
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-    width?: number[] | undefined;
-}>)[], {
-    type: "spacer";
-    char: string;
-    charWidth: number;
-    count: number;
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-} | {
-    type: "text";
-    content: string;
-    slicedContent: string[];
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-    width?: number[] | undefined;
-}>, ObjectSchema<{
-    width: ArraySchema<NumberSchema<number>, number[]>;
-}, undefined, {
-    width: number[];
-}>], ({
-    type: "spacer";
-    char: string;
-    charWidth: number;
-    count: number;
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-} | {
-    type: "text";
-    content: string;
-    slicedContent: string[];
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-    width?: number[] | undefined;
-}) & {
-    width: number[];
-}>)[], {
-    type: "spacer";
-    char: string;
-    charWidth: number;
-    count: number;
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-} | (({
-    type: "spacer";
-    char: string;
-    charWidth: number;
-    count: number;
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-} | {
-    type: "text";
-    content: string;
-    slicedContent: string[];
-    isButton?: boolean | undefined;
-    font?: "defont" | "gulim" | "simsun" | undefined;
-    width?: number[] | undefined;
-}) & {
-    width: number[];
-})>;
-type CommentMeasuredContentItem = Output<typeof ZCommentMeasuredContentItem>;
+    readonly type: LiteralSchema<"text", undefined>;
+    readonly content: StringSchema<undefined>;
+    readonly slicedContent: ArraySchema<StringSchema<undefined>, undefined>;
+    readonly isButton: OptionalSchema<BooleanSchema<undefined>, undefined>;
+    readonly font: OptionalSchema<UnionSchema<[LiteralSchema<"defont", undefined>, LiteralSchema<"gulim", undefined>, LiteralSchema<"simsun", undefined>], undefined>, undefined>;
+    readonly width: OptionalSchema<ArraySchema<NumberSchema<undefined>, undefined>, undefined>;
+}, undefined>;
+type CommentContentItemText = InferOutput<typeof ZCommentContentItemText>;
+declare const ZCommentContentItem: UnionSchema<[ObjectSchema<{
+    readonly type: LiteralSchema<"spacer", undefined>;
+    readonly char: StringSchema<undefined>;
+    readonly charWidth: NumberSchema<undefined>;
+    readonly isButton: OptionalSchema<BooleanSchema<undefined>, undefined>;
+    readonly font: OptionalSchema<UnionSchema<[LiteralSchema<"defont", undefined>, LiteralSchema<"gulim", undefined>, LiteralSchema<"simsun", undefined>], undefined>, undefined>;
+    readonly count: NumberSchema<undefined>;
+}, undefined>, ObjectSchema<{
+    readonly type: LiteralSchema<"text", undefined>;
+    readonly content: StringSchema<undefined>;
+    readonly slicedContent: ArraySchema<StringSchema<undefined>, undefined>;
+    readonly isButton: OptionalSchema<BooleanSchema<undefined>, undefined>;
+    readonly font: OptionalSchema<UnionSchema<[LiteralSchema<"defont", undefined>, LiteralSchema<"gulim", undefined>, LiteralSchema<"simsun", undefined>], undefined>, undefined>;
+    readonly width: OptionalSchema<ArraySchema<NumberSchema<undefined>, undefined>, undefined>;
+}, undefined>], undefined>;
+type CommentContentItem = InferOutput<typeof ZCommentContentItem>;
+declare const ZCommentMeasuredContentItemText: IntersectSchema<[UnionSchema<[ObjectSchema<{
+    readonly type: LiteralSchema<"spacer", undefined>;
+    readonly char: StringSchema<undefined>;
+    readonly charWidth: NumberSchema<undefined>;
+    readonly isButton: OptionalSchema<BooleanSchema<undefined>, undefined>;
+    readonly font: OptionalSchema<UnionSchema<[LiteralSchema<"defont", undefined>, LiteralSchema<"gulim", undefined>, LiteralSchema<"simsun", undefined>], undefined>, undefined>;
+    readonly count: NumberSchema<undefined>;
+}, undefined>, ObjectSchema<{
+    readonly type: LiteralSchema<"text", undefined>;
+    readonly content: StringSchema<undefined>;
+    readonly slicedContent: ArraySchema<StringSchema<undefined>, undefined>;
+    readonly isButton: OptionalSchema<BooleanSchema<undefined>, undefined>;
+    readonly font: OptionalSchema<UnionSchema<[LiteralSchema<"defont", undefined>, LiteralSchema<"gulim", undefined>, LiteralSchema<"simsun", undefined>], undefined>, undefined>;
+    readonly width: OptionalSchema<ArraySchema<NumberSchema<undefined>, undefined>, undefined>;
+}, undefined>], undefined>, ObjectSchema<{
+    readonly width: ArraySchema<NumberSchema<undefined>, undefined>;
+}, undefined>], undefined>;
+declare const ZCommentMeasuredContentItem: UnionSchema<[IntersectSchema<[UnionSchema<[ObjectSchema<{
+    readonly type: LiteralSchema<"spacer", undefined>;
+    readonly char: StringSchema<undefined>;
+    readonly charWidth: NumberSchema<undefined>;
+    readonly isButton: OptionalSchema<BooleanSchema<undefined>, undefined>;
+    readonly font: OptionalSchema<UnionSchema<[LiteralSchema<"defont", undefined>, LiteralSchema<"gulim", undefined>, LiteralSchema<"simsun", undefined>], undefined>, undefined>;
+    readonly count: NumberSchema<undefined>;
+}, undefined>, ObjectSchema<{
+    readonly type: LiteralSchema<"text", undefined>;
+    readonly content: StringSchema<undefined>;
+    readonly slicedContent: ArraySchema<StringSchema<undefined>, undefined>;
+    readonly isButton: OptionalSchema<BooleanSchema<undefined>, undefined>;
+    readonly font: OptionalSchema<UnionSchema<[LiteralSchema<"defont", undefined>, LiteralSchema<"gulim", undefined>, LiteralSchema<"simsun", undefined>], undefined>, undefined>;
+    readonly width: OptionalSchema<ArraySchema<NumberSchema<undefined>, undefined>, undefined>;
+}, undefined>], undefined>, ObjectSchema<{
+    readonly width: ArraySchema<NumberSchema<undefined>, undefined>;
+}, undefined>], undefined>, ObjectSchema<{
+    readonly type: LiteralSchema<"spacer", undefined>;
+    readonly char: StringSchema<undefined>;
+    readonly charWidth: NumberSchema<undefined>;
+    readonly isButton: OptionalSchema<BooleanSchema<undefined>, undefined>;
+    readonly font: OptionalSchema<UnionSchema<[LiteralSchema<"defont", undefined>, LiteralSchema<"gulim", undefined>, LiteralSchema<"simsun", undefined>], undefined>, undefined>;
+    readonly count: NumberSchema<undefined>;
+}, undefined>], undefined>;
+type CommentMeasuredContentItem = InferOutput<typeof ZCommentMeasuredContentItem>;
 type CommentFlashFontParsed = "gothic" | "gulim" | "simsunStrong" | "simsunWeak";
 type CommentContentIndex = {
     index: number;
     font: CommentFlashFontParsed;
 };
-declare const ZCommentSize: UnionSchema<(LiteralSchema<"big", "big"> | LiteralSchema<"medium", "medium"> | LiteralSchema<"small", "small">)[], "big" | "medium" | "small">;
-type CommentSize = Output<typeof ZCommentSize>;
-declare const ZCommentLoc: UnionSchema<(LiteralSchema<"ue", "ue"> | LiteralSchema<"naka", "naka"> | LiteralSchema<"shita", "shita">)[], "ue" | "naka" | "shita">;
-type CommentLoc = Output<typeof ZCommentLoc>;
+declare const ZCommentSize: UnionSchema<[LiteralSchema<"big", undefined>, LiteralSchema<"medium", undefined>, LiteralSchema<"small", undefined>], undefined>;
+type CommentSize = InferOutput<typeof ZCommentSize>;
+declare const ZCommentLoc: UnionSchema<[LiteralSchema<"ue", undefined>, LiteralSchema<"naka", undefined>, LiteralSchema<"shita", undefined>], undefined>;
+type CommentLoc = InferOutput<typeof ZCommentLoc>;
 type Collision = {
     [key in CollisionPos]: CollisionItem;
 };
@@ -2322,8 +2807,8 @@ type NicoScriptReverse = {
     start: number;
     end: number;
 };
-declare const ZNicoScriptReverseTarget: UnionSchema<(LiteralSchema<"コメ", "コメ"> | LiteralSchema<"投コメ", "投コメ"> | LiteralSchema<"全", "全">)[], "コメ" | "投コメ" | "全">;
-type NicoScriptReverseTarget = Output<typeof ZNicoScriptReverseTarget>;
+declare const ZNicoScriptReverseTarget: UnionSchema<[LiteralSchema<"コメ", undefined>, LiteralSchema<"投コメ", undefined>, LiteralSchema<"全", undefined>], undefined>;
+type NicoScriptReverseTarget = InferOutput<typeof ZNicoScriptReverseTarget>;
 type NicoScriptReplace = {
     start: number;
     long: number | undefined;
@@ -2338,12 +2823,12 @@ type NicoScriptReplace = {
     loc: CommentLoc | undefined;
     no: number;
 };
-declare const ZNicoScriptReplaceRange: UnionSchema<(LiteralSchema<"全", "全"> | LiteralSchema<"単", "単">)[], "全" | "単">;
-type NicoScriptReplaceRange = Output<typeof ZNicoScriptReplaceRange>;
-declare const ZNicoScriptReplaceTarget: UnionSchema<(LiteralSchema<"コメ", "コメ"> | LiteralSchema<"投コメ", "投コメ"> | LiteralSchema<"全", "全"> | LiteralSchema<"含まない", "含まない"> | LiteralSchema<"含む", "含む">)[], "コメ" | "投コメ" | "全" | "含まない" | "含む">;
-type NicoScriptReplaceTarget = Output<typeof ZNicoScriptReplaceTarget>;
-declare const ZNicoScriptReplaceCondition: UnionSchema<(LiteralSchema<"部分一致", "部分一致"> | LiteralSchema<"完全一致", "完全一致">)[], "部分一致" | "完全一致">;
-type NicoScriptReplaceCondition = Output<typeof ZNicoScriptReplaceCondition>;
+declare const ZNicoScriptReplaceRange: UnionSchema<[LiteralSchema<"単", undefined>, LiteralSchema<"全", undefined>], undefined>;
+type NicoScriptReplaceRange = InferOutput<typeof ZNicoScriptReplaceRange>;
+declare const ZNicoScriptReplaceTarget: UnionSchema<[LiteralSchema<"コメ", undefined>, LiteralSchema<"投コメ", undefined>, LiteralSchema<"全", undefined>, LiteralSchema<"含まない", undefined>, LiteralSchema<"含む", undefined>], undefined>;
+type NicoScriptReplaceTarget = InferOutput<typeof ZNicoScriptReplaceTarget>;
+declare const ZNicoScriptReplaceCondition: UnionSchema<[LiteralSchema<"部分一致", undefined>, LiteralSchema<"完全一致", undefined>], undefined>;
+type NicoScriptReplaceCondition = InferOutput<typeof ZNicoScriptReplaceCondition>;
 type NicoScriptBan = {
     start: number;
     end: number;
@@ -2390,6 +2875,7 @@ type ParsedCommand = {
     strokeColor?: string;
     wakuColor?: string;
     fillColor?: string;
+    opacity?: number;
     font: CommentFont | undefined;
     full: boolean;
     ender: boolean;
@@ -2407,89 +2893,27 @@ type MeasureTextInput = FormattedCommentWithFont & {
     scale: number;
 };
 declare const ZMeasureInput: ObjectSchema<{
-    font: UnionSchema<(LiteralSchema<"defont", "defont"> | LiteralSchema<"mincho", "mincho"> | LiteralSchema<"gothic", "gothic"> | LiteralSchema<"gulim", "gulim"> | LiteralSchema<"simsun", "simsun">)[], "defont" | "mincho" | "gothic" | "gulim" | "simsun">;
-    content: ArraySchema<UnionSchema<(ObjectSchema<{
-        type: LiteralSchema<"spacer", "spacer">;
-        char: StringSchema<string>;
-        charWidth: NumberSchema<number>;
-        isButton: OptionalSchema<BooleanSchema<boolean>, undefined, boolean | undefined>;
-        font: OptionalSchema<UnionSchema<(LiteralSchema<"defont", "defont"> | LiteralSchema<"gulim", "gulim"> | LiteralSchema<"simsun", "simsun">)[], "defont" | "gulim" | "simsun">, undefined, "defont" | "gulim" | "simsun" | undefined>;
-        count: NumberSchema<number>;
-    }, undefined, {
-        type: "spacer";
-        char: string;
-        charWidth: number;
-        count: number;
-        isButton?: boolean | undefined;
-        font?: "defont" | "gulim" | "simsun" | undefined;
-    }> | ObjectSchema<{
-        type: LiteralSchema<"text", "text">;
-        content: StringSchema<string>;
-        slicedContent: ArraySchema<StringSchema<string>, string[]>;
-        isButton: OptionalSchema<BooleanSchema<boolean>, undefined, boolean | undefined>;
-        font: OptionalSchema<UnionSchema<(LiteralSchema<"defont", "defont"> | LiteralSchema<"gulim", "gulim"> | LiteralSchema<"simsun", "simsun">)[], "defont" | "gulim" | "simsun">, undefined, "defont" | "gulim" | "simsun" | undefined>;
-        width: OptionalSchema<ArraySchema<NumberSchema<number>, number[]>, undefined, number[] | undefined>;
-    }, undefined, {
-        type: "text";
-        content: string;
-        slicedContent: string[];
-        isButton?: boolean | undefined;
-        font?: "defont" | "gulim" | "simsun" | undefined;
-        width?: number[] | undefined;
-    }>)[], {
-        type: "spacer";
-        char: string;
-        charWidth: number;
-        count: number;
-        isButton?: boolean | undefined;
-        font?: "defont" | "gulim" | "simsun" | undefined;
-    } | {
-        type: "text";
-        content: string;
-        slicedContent: string[];
-        isButton?: boolean | undefined;
-        font?: "defont" | "gulim" | "simsun" | undefined;
-        width?: number[] | undefined;
-    }>, ({
-        type: "spacer";
-        char: string;
-        charWidth: number;
-        count: number;
-        isButton?: boolean | undefined;
-        font?: "defont" | "gulim" | "simsun" | undefined;
-    } | {
-        type: "text";
-        content: string;
-        slicedContent: string[];
-        isButton?: boolean | undefined;
-        font?: "defont" | "gulim" | "simsun" | undefined;
-        width?: number[] | undefined;
-    })[]>;
-    lineHeight: NumberSchema<number>;
-    charSize: NumberSchema<number>;
-    lineCount: NumberSchema<number>;
-}, undefined, {
-    lineHeight: number;
-    font: "defont" | "mincho" | "gothic" | "gulim" | "simsun";
-    content: ({
-        type: "spacer";
-        char: string;
-        charWidth: number;
-        count: number;
-        isButton?: boolean | undefined;
-        font?: "defont" | "gulim" | "simsun" | undefined;
-    } | {
-        type: "text";
-        content: string;
-        slicedContent: string[];
-        isButton?: boolean | undefined;
-        font?: "defont" | "gulim" | "simsun" | undefined;
-        width?: number[] | undefined;
-    })[];
-    charSize: number;
-    lineCount: number;
-}>;
-type MeasureInput = Output<typeof ZMeasureInput>;
+    readonly font: UnionSchema<[LiteralSchema<"defont", undefined>, LiteralSchema<"mincho", undefined>, LiteralSchema<"gothic", undefined>, LiteralSchema<"gulim", undefined>, LiteralSchema<"simsun", undefined>], undefined>;
+    readonly content: ArraySchema<UnionSchema<[ObjectSchema<{
+        readonly type: LiteralSchema<"spacer", undefined>;
+        readonly char: StringSchema<undefined>;
+        readonly charWidth: NumberSchema<undefined>;
+        readonly isButton: OptionalSchema<BooleanSchema<undefined>, undefined>;
+        readonly font: OptionalSchema<UnionSchema<[LiteralSchema<"defont", undefined>, LiteralSchema<"gulim", undefined>, LiteralSchema<"simsun", undefined>], undefined>, undefined>;
+        readonly count: NumberSchema<undefined>;
+    }, undefined>, ObjectSchema<{
+        readonly type: LiteralSchema<"text", undefined>;
+        readonly content: StringSchema<undefined>;
+        readonly slicedContent: ArraySchema<StringSchema<undefined>, undefined>;
+        readonly isButton: OptionalSchema<BooleanSchema<undefined>, undefined>;
+        readonly font: OptionalSchema<UnionSchema<[LiteralSchema<"defont", undefined>, LiteralSchema<"gulim", undefined>, LiteralSchema<"simsun", undefined>], undefined>, undefined>;
+        readonly width: OptionalSchema<ArraySchema<NumberSchema<undefined>, undefined>, undefined>;
+    }, undefined>], undefined>, undefined>;
+    readonly lineHeight: NumberSchema<undefined>;
+    readonly charSize: NumberSchema<undefined>;
+    readonly lineCount: NumberSchema<undefined>;
+}, undefined>;
+type MeasureInput = InferOutput<typeof ZMeasureInput>;
 type ValueOf<T> = T[keyof T];
 
 declare let imageCache: {
@@ -2513,7 +2937,14 @@ declare const index_d$3_resetImageCache: typeof resetImageCache;
 declare const index_d$3_resetNicoScripts: typeof resetNicoScripts;
 declare const index_d$3_setPlugins: typeof setPlugins;
 declare namespace index_d$3 {
-  export { index_d$3_imageCache as imageCache, index_d$3_nicoScripts as nicoScripts, index_d$3_plugins as plugins, index_d$3_resetImageCache as resetImageCache, index_d$3_resetNicoScripts as resetNicoScripts, index_d$3_setPlugins as setPlugins };
+  export {
+    index_d$3_imageCache as imageCache,
+    index_d$3_nicoScripts as nicoScripts,
+    index_d$3_plugins as plugins,
+    index_d$3_resetImageCache as resetImageCache,
+    index_d$3_resetNicoScripts as resetNicoScripts,
+    index_d$3_setPlugins as setPlugins,
+  };
 }
 
 declare const colors: {
@@ -2548,7 +2979,9 @@ declare const colors: {
 
 declare const colors$1_colors: typeof colors;
 declare namespace colors$1 {
-  export { colors$1_colors as colors };
+  export {
+    colors$1_colors as colors,
+  };
 }
 
 declare let defaultConfig: BaseConfig;
@@ -2567,7 +3000,15 @@ declare const config$1_setConfig: typeof setConfig;
 declare const config$1_setOptions: typeof setOptions;
 declare const config$1_updateConfig: typeof updateConfig;
 declare namespace config$1 {
-  export { config$1_config as config, config$1_defaultConfig as defaultConfig, config$1_defaultOptions as defaultOptions, config$1_options as options, config$1_setConfig as setConfig, config$1_setOptions as setOptions, config$1_updateConfig as updateConfig };
+  export {
+    config$1_config as config,
+    config$1_defaultConfig as defaultConfig,
+    config$1_defaultOptions as defaultOptions,
+    config$1_options as options,
+    config$1_setConfig as setConfig,
+    config$1_setOptions as setOptions,
+    config$1_updateConfig as updateConfig,
+  };
 }
 
 declare const fontTemplates: {
@@ -2678,14 +3119,19 @@ declare const fonts: {
 declare const fonts$1_fontTemplates: typeof fontTemplates;
 declare const fonts$1_fonts: typeof fonts;
 declare namespace fonts$1 {
-  export { fonts$1_fontTemplates as fontTemplates, fonts$1_fonts as fonts };
+  export {
+    fonts$1_fontTemplates as fontTemplates,
+    fonts$1_fonts as fonts,
+  };
 }
 
 declare const initConfig: () => void;
 
 declare const initConfig$1_initConfig: typeof initConfig;
 declare namespace initConfig$1 {
-  export { initConfig$1_initConfig as initConfig };
+  export {
+    initConfig$1_initConfig as initConfig,
+  };
 }
 
 declare class CanvasRenderingContext2DError extends Error {
@@ -2723,7 +3169,12 @@ declare const index_d$2_InvalidOptionError: typeof InvalidOptionError;
 type index_d$2_NotImplementedError = NotImplementedError;
 declare const index_d$2_NotImplementedError: typeof NotImplementedError;
 declare namespace index_d$2 {
-  export { index_d$2_CanvasRenderingContext2DError as CanvasRenderingContext2DError, index_d$2_InvalidFormatError as InvalidFormatError, index_d$2_InvalidOptionError as InvalidOptionError, index_d$2_NotImplementedError as NotImplementedError };
+  export {
+    index_d$2_CanvasRenderingContext2DError as CanvasRenderingContext2DError,
+    index_d$2_InvalidFormatError as InvalidFormatError,
+    index_d$2_InvalidOptionError as InvalidOptionError,
+    index_d$2_NotImplementedError as NotImplementedError,
+  };
 }
 
 declare const registerHandler: <K extends keyof CommentEventHandlerMap>(eventName: K, handler: CommentEventHandlerMap[K]) => void;
@@ -2734,13 +3185,19 @@ declare const eventHandler_d_registerHandler: typeof registerHandler;
 declare const eventHandler_d_removeHandler: typeof removeHandler;
 declare const eventHandler_d_triggerHandler: typeof triggerHandler;
 declare namespace eventHandler_d {
-  export { eventHandler_d_registerHandler as registerHandler, eventHandler_d_removeHandler as removeHandler, eventHandler_d_triggerHandler as triggerHandler };
+  export {
+    eventHandler_d_registerHandler as registerHandler,
+    eventHandler_d_removeHandler as removeHandler,
+    eventHandler_d_triggerHandler as triggerHandler,
+  };
 }
 
 declare const convert2formattedComment: (data: unknown, type: InputFormatType) => FormattedComment[];
 
 declare namespace inputParser_d {
-  export { convert2formattedComment as default };
+  export {
+    convert2formattedComment as default,
+  };
 }
 
 declare class CanvasRenderer implements IRenderer {
@@ -2784,7 +3241,9 @@ declare class CanvasRenderer implements IRenderer {
 type index_d$1_CanvasRenderer = CanvasRenderer;
 declare const index_d$1_CanvasRenderer: typeof CanvasRenderer;
 declare namespace index_d$1 {
-  export { index_d$1_CanvasRenderer as CanvasRenderer };
+  export {
+    index_d$1_CanvasRenderer as CanvasRenderer,
+  };
 }
 
 declare const typeGuard: {
@@ -2855,7 +3314,9 @@ declare const typeGuard: {
 };
 
 declare namespace typeGuard_d {
-  export { typeGuard as default };
+  export {
+    typeGuard as default,
+  };
 }
 
 declare const arrayPush: (_array: {
@@ -2895,9 +3356,9 @@ declare const parseContent: (content: string) => ({
     type: "spacer";
     char: string;
     charWidth: number;
-    count: number;
     isButton?: boolean | undefined;
     font?: "defont" | "gulim" | "simsun" | undefined;
+    count: number;
 } | {
     type: "text";
     content: string;
@@ -2957,7 +3418,39 @@ declare const index_d_parseFont: typeof parseFont;
 declare const index_d_processFixedComment: typeof processFixedComment;
 declare const index_d_processMovableComment: typeof processMovableComment;
 declare namespace index_d {
-  export { index_d_addHTML5PartToResult as addHTML5PartToResult, index_d_arrayEqual as arrayEqual, index_d_arrayPush as arrayPush, index_d_buildAtButtonComment as buildAtButtonComment, index_d_changeCALayer as changeCALayer, index_d_getButtonParts as getButtonParts, index_d_getCharSize as getCharSize, index_d_getConfig as getConfig, index_d_getDefaultCommand as getDefaultCommand, index_d_getFixedPosY as getFixedPosY, index_d_getFlashFontIndex as getFlashFontIndex, index_d_getFlashFontName as getFlashFontName, index_d_getFontSizeAndScale as getFontSizeAndScale, index_d_getLineHeight as getLineHeight, index_d_getMovablePosY as getMovablePosY, index_d_getPosX as getPosX, index_d_getPosY as getPosY, index_d_getStrokeColor as getStrokeColor, index_d_hex2rgb as hex2rgb, index_d_hex2rgba as hex2rgba, index_d_isBanActive as isBanActive, index_d_isFlashComment as isFlashComment, index_d_isLineBreakResize as isLineBreakResize, index_d_isReverseActive as isReverseActive, index_d_measure as measure, index_d_nativeSort as nativeSort, index_d_parseCommandAndNicoScript as parseCommandAndNicoScript, index_d_parseContent as parseContent, index_d_parseFont as parseFont, index_d_processFixedComment as processFixedComment, index_d_processMovableComment as processMovableComment };
+  export {
+    index_d_addHTML5PartToResult as addHTML5PartToResult,
+    index_d_arrayEqual as arrayEqual,
+    index_d_arrayPush as arrayPush,
+    index_d_buildAtButtonComment as buildAtButtonComment,
+    index_d_changeCALayer as changeCALayer,
+    index_d_getButtonParts as getButtonParts,
+    index_d_getCharSize as getCharSize,
+    index_d_getConfig as getConfig,
+    index_d_getDefaultCommand as getDefaultCommand,
+    index_d_getFixedPosY as getFixedPosY,
+    index_d_getFlashFontIndex as getFlashFontIndex,
+    index_d_getFlashFontName as getFlashFontName,
+    index_d_getFontSizeAndScale as getFontSizeAndScale,
+    index_d_getLineHeight as getLineHeight,
+    index_d_getMovablePosY as getMovablePosY,
+    index_d_getPosX as getPosX,
+    index_d_getPosY as getPosY,
+    index_d_getStrokeColor as getStrokeColor,
+    index_d_hex2rgb as hex2rgb,
+    index_d_hex2rgba as hex2rgba,
+    index_d_isBanActive as isBanActive,
+    index_d_isFlashComment as isFlashComment,
+    index_d_isLineBreakResize as isLineBreakResize,
+    index_d_isReverseActive as isReverseActive,
+    index_d_measure as measure,
+    index_d_nativeSort as nativeSort,
+    index_d_parseCommandAndNicoScript as parseCommandAndNicoScript,
+    index_d_parseContent as parseContent,
+    index_d_parseFont as parseFont,
+    index_d_processFixedComment as processFixedComment,
+    index_d_processMovableComment as processMovableComment,
+  };
 }
 
 declare const definition: {
@@ -2969,7 +3462,17 @@ declare const definition: {
 
 declare const internal_definition: typeof definition;
 declare namespace internal {
-  export { index_d$4 as comments, index_d$3 as contexts, internal_definition as definition, index_d$2 as errors, eventHandler_d as eventHandler, inputParser_d as inputParser, index_d$1 as renderer, typeGuard_d as typeGuard, index_d as utils };
+  export {
+    index_d$4 as comments,
+    index_d$3 as contexts,
+    internal_definition as definition,
+    index_d$2 as errors,
+    eventHandler_d as eventHandler,
+    inputParser_d as inputParser,
+    index_d$1 as renderer,
+    typeGuard_d as typeGuard,
+    index_d as utils,
+  };
 }
 
 declare class NiconiComments {
@@ -3073,4 +3576,5 @@ declare class NiconiComments {
     click(vpos: number, pos: Position): void;
 }
 
-export { type ApiChat, type ApiGlobalNumRes, type ApiLeaf, type ApiPing, type ApiThread, type BaseConfig, type BaseOptions, type ButtonList, type ButtonParams, type ButtonPartLeft, type ButtonPartMiddle, type ButtonPartRight, type Canvas, type Collision, type CollisionItem, type CollisionPos, type CommentContentIndex, type CommentContentItem, type CommentContentItemText, type CommentDisableEvent, type CommentDisableEventHandler, type CommentEnableEvent, type CommentEnableEventHandler, type CommentEventBase, type CommentEventHandler, type CommentEventHandlerMap, type CommentEventMap, type CommentEventName, type CommentFlashFont, type CommentFlashFontParsed, type CommentFont, type CommentHTML5Font, type CommentLoc, type CommentMeasuredContentItem, type CommentSize, type CommentStageSize, type Config, type ConfigItem, type Context2D, type DefaultCommand, type FlashMode, type FlashScriptChar, type FontItem, type FormattedComment, type FormattedCommentWithFont, type FormattedCommentWithSize, type FormattedLegacyComment, type HTML5Fonts, type IComment, type IPlugin, type IPluginConstructor, type IPluginList, type IRenderer, type InputFormat, type InputFormatType, type InputParser, type JumpEvent, type JumpEventHandler, type MeasureInput, type MeasureTextInput, type MeasureTextResult, type MultiConfigItem, type NicoScript, type NicoScriptReplace, type NicoScriptReplaceCondition, type NicoScriptReplaceRange, type NicoScriptReplaceTarget, type NicoScriptReverseTarget, type Options, type OwnerComment, type ParseCommandAndNicoScriptResult, type ParseContentResult, type ParsedCommand, type Platform, type PlatformFont, type Position, type RawApiResponse, type SeekDisableEvent, type SeekDisableEventHandler, type SeekEnableEvent, type SeekEnableEventHandler, type Timeline, type V1Comment, type V1Thread, type ValueOf, type Xml2jsChat, type Xml2jsChatItem, type Xml2jsPacket, ZApiChat, ZApiGlobalNumRes, ZApiLeaf, ZApiPing, ZApiThread, ZCommentContentItem, ZCommentContentItemSpacer, ZCommentContentItemText, ZCommentFlashFont, ZCommentFont, ZCommentHTML5Font, ZCommentLoc, ZCommentMeasuredContentItem, ZCommentMeasuredContentItemText, ZCommentSize, ZFormattedComment, ZFormattedLegacyComment, ZHTML5Fonts, ZInputFormatType, ZMeasureInput, ZNicoScriptReplaceCondition, ZNicoScriptReplaceRange, ZNicoScriptReplaceTarget, ZNicoScriptReverseTarget, ZOwnerComment, ZRawApiResponse, ZV1Comment, ZV1Thread, ZXml2jsChat, ZXml2jsChatItem, ZXml2jsPacket, NiconiComments as default, type formattedComment, type formattedLegacyComment, type inputFormat, type inputFormatType, type ownerComment, type rawApiResponse, type v1Thread };
+export { ZApiChat, ZApiGlobalNumRes, ZApiLeaf, ZApiPing, ZApiThread, ZCommentContentItem, ZCommentContentItemSpacer, ZCommentContentItemText, ZCommentFlashFont, ZCommentFont, ZCommentHTML5Font, ZCommentLoc, ZCommentMeasuredContentItem, ZCommentMeasuredContentItemText, ZCommentSize, ZFormattedComment, ZFormattedLegacyComment, ZHTML5Fonts, ZInputFormatType, ZMeasureInput, ZNicoScriptReplaceCondition, ZNicoScriptReplaceRange, ZNicoScriptReplaceTarget, ZNicoScriptReverseTarget, ZOwnerComment, ZRawApiResponse, ZV1Comment, ZV1Thread, ZXml2jsChat, ZXml2jsChatItem, ZXml2jsPacket, NiconiComments as default };
+export type { ApiChat, ApiGlobalNumRes, ApiLeaf, ApiPing, ApiThread, BaseConfig, BaseOptions, ButtonList, ButtonParams, ButtonPartLeft, ButtonPartMiddle, ButtonPartRight, Canvas, Collision, CollisionItem, CollisionPos, CommentContentIndex, CommentContentItem, CommentContentItemText, CommentDisableEvent, CommentDisableEventHandler, CommentEnableEvent, CommentEnableEventHandler, CommentEventBase, CommentEventHandler, CommentEventHandlerMap, CommentEventMap, CommentEventName, CommentFlashFont, CommentFlashFontParsed, CommentFont, CommentHTML5Font, CommentLoc, CommentMeasuredContentItem, CommentSize, CommentStageSize, Config$1 as Config, ConfigItem, Context2D, DefaultCommand, FlashMode, FlashScriptChar, FontItem, FormattedComment, FormattedCommentWithFont, FormattedCommentWithSize, FormattedLegacyComment, HTML5Fonts, IComment, IPlugin, IPluginConstructor, IPluginList, IRenderer, InputFormat, InputFormatType, InputParser, JumpEvent, JumpEventHandler, MeasureInput, MeasureTextInput, MeasureTextResult, MultiConfigItem, NicoScript, NicoScriptReplace, NicoScriptReplaceCondition, NicoScriptReplaceRange, NicoScriptReplaceTarget, NicoScriptReverseTarget, Options, OwnerComment, ParseCommandAndNicoScriptResult, ParseContentResult, ParsedCommand, Platform, PlatformFont, Position, RawApiResponse, SeekDisableEvent, SeekDisableEventHandler, SeekEnableEvent, SeekEnableEventHandler, Timeline, V1Comment, V1Thread, ValueOf, Xml2jsChat, Xml2jsChatItem, Xml2jsPacket, formattedComment, formattedLegacyComment, inputFormat, inputFormatType, ownerComment, rawApiResponse, v1Thread };