ccusage 0.3.1 → 0.3.2

package/dist/data-loader-ToqWI8hT.d.ts

@@ -0,0 +1,1467 @@
+//#region node_modules/valibot/dist/index.d.ts
+
+/**
+ * Fallback type.
+ */
+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>>);
+/**
+ * Schema with fallback type.
+ */
+type SchemaWithFallback<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TFallback extends Fallback<TSchema>> = TSchema & {
+  /**
+   * The fallback value.
+   */
+  readonly fallback: TFallback;
+};
+/**
+ * Returns a fallback value as output if the input does not match the schema.
+ *
+ * @param schema The schema to catch.
+ * @param fallback The fallback value.
+ *
+ * @returns The passed schema.
+ */
+
+/**
+ * Fallback async type.
+ */
+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>>>);
+/**
+ * Schema with fallback async type.
+ */
+type SchemaWithFallbackAsync<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TFallback extends FallbackAsync<TSchema>> = Omit<TSchema, 'async' | '~standard' | '~run'> & {
+  /**
+   * The fallback value.
+   */
+  readonly fallback: TFallback;
+  /**
+   * Whether it's async.
+   */
+  readonly async: true;
+  /**
+   * The Standard Schema properties.
+   *
+   * @internal
+   */
+  readonly '~standard': StandardProps<InferInput<TSchema>, InferOutput<TSchema>>;
+  /**
+   * Parses unknown input values.
+   *
+   * @param dataset The input dataset.
+   * @param config The configuration.
+   *
+   * @returns The output dataset.
+   *
+   * @internal
+   */
+  readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<InferOutput<TSchema>, InferIssue<TSchema>>>;
+};
+/**
+ * Returns a fallback value as output if the input does not match the schema.
+ *
+ * @param schema The schema to catch.
+ * @param fallback The fallback value.
+ *
+ * @returns The passed schema.
+ */
+
+/**
+ * Schema with pipe type.
+ */
+type SchemaWithPipe<TPipe extends readonly [BaseSchema<unknown, unknown, BaseIssue<unknown>>, ...PipeItem<any, unknown, BaseIssue<unknown>>[]]> = Omit<FirstTupleItem<TPipe>, 'pipe' | '~standard' | '~run' | '~types'> & {
+  /**
+   * The pipe items.
+   */
+  readonly pipe: TPipe;
+  /**
+   * The Standard Schema properties.
+   *
+   * @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 output dataset.
+   *
+   * @internal
+   */
+  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;
+};
+/**
+ * Adds a pipeline to a schema, that can validate and transform its input.
+ *
+ * @param schema The root schema.
+ * @param item1 The first pipe item.
+ *
+ * @returns A schema with a pipeline.
+ */
+
+/**
+ * Schema with pipe async type.
+ */
+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 pipe items.
+   */
+  readonly pipe: TPipe;
+  /**
+   * Whether it's async.
+   */
+  readonly async: true;
+  /**
+   * The Standard Schema properties.
+   *
+   * @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 output dataset.
+   *
+   * @internal
+   */
+  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;
+};
+/**
+ * Adds a pipeline to a schema, that can validate and transform its input.
+ *
+ * @param schema The root schema.
+ * @param item1 The first pipe item.
+ *
+ * @returns A schema with a pipeline.
+ */
+
+/**
+ * Base metadata interface.
+ */
+interface BaseMetadata<TInput> {
+  /**
+   * The object kind.
+   */
+  readonly kind: 'metadata';
+  /**
+   * The metadata type.
+   */
+  readonly type: string;
+  /**
+   * The metadata reference.
+   */
+  readonly reference: (...args: any[]) => BaseMetadata<any>;
+  /**
+   * The input, output and issue type.
+   *
+   * @internal
+   */
+  readonly '~types'?: {
+    readonly input: TInput;
+    readonly output: TInput;
+    readonly issue: never;
+  } | undefined;
+}
+/**
+ * Generic metadata type.
+ */
+
+/**
+ * Unknown dataset interface.
+ */
+interface UnknownDataset {
+  /**
+   * Whether is's typed.
+   */
+  typed?: false;
+  /**
+   * The dataset value.
+   */
+  value: unknown;
+  /**
+   * The dataset issues.
+   */
+  issues?: undefined;
+}
+/**
+ * Success dataset interface.
+ */
+interface SuccessDataset<TValue> {
+  /**
+   * Whether is's typed.
+   */
+  typed: true;
+  /**
+   * The dataset value.
+   */
+  value: TValue;
+  /**
+   * The dataset issues.
+   */
+  issues?: undefined;
+}
+/**
+ * Partial dataset interface.
+ */
+interface PartialDataset<TValue, TIssue extends BaseIssue<unknown>> {
+  /**
+   * Whether is's typed.
+   */
+  typed: true;
+  /**
+   * The dataset value.
+   */
+  value: TValue;
+  /**
+   * The dataset issues.
+   */
+  issues: [TIssue, ...TIssue[]];
+}
+/**
+ * Failure dataset interface.
+ */
+interface FailureDataset<TIssue extends BaseIssue<unknown>> {
+  /**
+   * Whether is's typed.
+   */
+  typed: false;
+  /**
+   * The dataset value.
+   */
+  value: unknown;
+  /**
+   * The dataset issues.
+   */
+  issues: [TIssue, ...TIssue[]];
+}
+/**
+ * Output dataset type.
+ */
+type OutputDataset<TValue, TIssue extends BaseIssue<unknown>> = SuccessDataset<TValue> | PartialDataset<TValue, TIssue> | FailureDataset<TIssue>;
+
+/**
+ * The Standard Schema properties interface.
+ */
+interface StandardProps<TInput, TOutput> {
+  /**
+   * The version number of the standard.
+   */
+  readonly version: 1;
+  /**
+   * The vendor name of the schema library.
+   */
+  readonly vendor: 'valibot';
+  /**
+   * Validates unknown input values.
+   */
+  readonly validate: (value: unknown) => StandardResult<TOutput> | Promise<StandardResult<TOutput>>;
+  /**
+   * Inferred types associated with the schema.
+   */
+  readonly types?: StandardTypes<TInput, TOutput> | undefined;
+}
+/**
+ * The result interface of the validate function.
+ */
+type StandardResult<TOutput> = StandardSuccessResult<TOutput> | StandardFailureResult;
+/**
+ * The result interface if validation succeeds.
+ */
+interface StandardSuccessResult<TOutput> {
+  /**
+   * The typed output value.
+   */
+  readonly value: TOutput;
+  /**
+   * The non-existent issues.
+   */
+  readonly issues?: undefined;
+}
+/**
+ * The result interface if validation fails.
+ */
+interface StandardFailureResult {
+  /**
+   * The issues of failed validation.
+   */
+  readonly issues: readonly StandardIssue[];
+}
+/**
+ * The issue interface of the failure output.
+ */
+interface StandardIssue {
+  /**
+   * The error message of the issue.
+   */
+  readonly message: string;
+  /**
+   * The path of the issue, if any.
+   */
+  readonly path?: readonly (PropertyKey | StandardPathItem)[] | undefined;
+}
+/**
+ * The path item interface of the issue.
+ */
+interface StandardPathItem {
+  /**
+   * The key of the path item.
+   */
+  readonly key: PropertyKey;
+}
+/**
+ * The Standard Schema types interface.
+ */
+interface StandardTypes<TInput, TOutput> {
+  /**
+   * The input type of the schema.
+   */
+  readonly input: TInput;
+  /**
+   * The output type of the schema.
+   */
+  readonly output: TOutput;
+}
+
+/**
+ * Base schema interface.
+ */
+interface BaseSchema<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
+  /**
+   * The object kind.
+   */
+  readonly kind: 'schema';
+  /**
+   * The schema type.
+   */
+  readonly type: string;
+  /**
+   * The schema reference.
+   */
+  readonly reference: (...args: any[]) => BaseSchema<unknown, unknown, BaseIssue<unknown>>;
+  /**
+   * The expected property.
+   */
+  readonly expects: string;
+  /**
+   * Whether it's async.
+   */
+  readonly async: false;
+  /**
+   * The Standard Schema properties.
+   *
+   * @internal
+   */
+  readonly '~standard': StandardProps<TInput, TOutput>;
+  /**
+   * Parses unknown input values.
+   *
+   * @param dataset The input dataset.
+   * @param config The configuration.
+   *
+   * @returns The output dataset.
+   *
+   * @internal
+   */
+  readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, TIssue>;
+  /**
+   * The input, output and issue type.
+   *
+   * @internal
+   */
+  readonly '~types'?: {
+    readonly input: TInput;
+    readonly output: TOutput;
+    readonly issue: TIssue;
+  } | undefined;
+}
+/**
+ * Base schema async interface.
+ */
+interface BaseSchemaAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseSchema<TInput, TOutput, TIssue>, 'reference' | 'async' | '~run'> {
+  /**
+   * The schema reference.
+   */
+  readonly reference: (...args: any[]) => BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>;
+  /**
+   * Whether it's async.
+   */
+  readonly async: true;
+  /**
+   * Parses unknown input values.
+   *
+   * @param dataset The input dataset.
+   * @param config The configuration.
+   *
+   * @returns The output dataset.
+   *
+   * @internal
+   */
+  readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, TIssue>>;
+}
+/**
+ * Generic schema type.
+ */
+
+/**
+ * Base transformation interface.
+ */
+interface BaseTransformation<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
+  /**
+   * The object kind.
+   */
+  readonly kind: 'transformation';
+  /**
+   * The transformation type.
+   */
+  readonly type: string;
+  /**
+   * The transformation reference.
+   */
+  readonly reference: (...args: any[]) => BaseTransformation<any, any, BaseIssue<unknown>>;
+  /**
+   * Whether it's async.
+   */
+  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;
+}
+/**
+ * Base transformation async interface.
+ */
+interface BaseTransformationAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseTransformation<TInput, TOutput, TIssue>, 'reference' | 'async' | '~run'> {
+  /**
+   * The transformation reference.
+   */
+  readonly reference: (...args: any[]) => BaseTransformation<any, any, BaseIssue<unknown>> | BaseTransformationAsync<any, any, BaseIssue<unknown>>;
+  /**
+   * Whether it's async.
+   */
+  readonly async: true;
+  /**
+   * 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>>) => Promise<OutputDataset<TOutput, BaseIssue<unknown> | TIssue>>;
+}
+/**
+ * Generic transformation type.
+ */
+
+/**
+ * Base validation interface.
+ */
+interface BaseValidation<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
+  /**
+   * The object kind.
+   */
+  readonly kind: 'validation';
+  /**
+   * The validation type.
+   */
+  readonly type: string;
+  /**
+   * 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
+   */
+  readonly '~types'?: {
+    readonly input: TInput;
+    readonly output: TOutput;
+    readonly issue: TIssue;
+  } | undefined;
+}
+/**
+ * Base validation async interface.
+ */
+interface BaseValidationAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseValidation<TInput, TOutput, TIssue>, 'reference' | 'async' | '~run'> {
+  /**
+   * The validation reference.
+   */
+  readonly reference: (...args: any[]) => BaseValidation<any, any, BaseIssue<unknown>> | BaseValidationAsync<any, any, BaseIssue<unknown>>;
+  /**
+   * Whether it's async.
+   */
+  readonly async: true;
+  /**
+   * 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>>) => Promise<OutputDataset<TOutput, BaseIssue<unknown> | TIssue>>;
+}
+/**
+ * Generic validation type.
+ */
+
+/**
+ * Infer input type.
+ */
+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'];
+/**
+ * Infer output type.
+ */
+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'];
+/**
+ * Infer issue type.
+ */
+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'];
+
+/**
+ * Checks if a type is `any`.
+ */
+
+/**
+ * Constructs a type that is maybe readonly.
+ */
+type MaybeReadonly<TValue> = TValue | Readonly<TValue>;
+/**
+ * Constructs a type that is maybe a promise.
+ */
+type MaybePromise<TValue> = TValue | Promise<TValue>;
+/**
+ * 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>>;
+/**
+ * Merges two objects. Overlapping entries from the second object overwrite
+ * properties from the first object.
+ */
+
+/**
+ * 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];
+/**
+ * Converts union to intersection type.
+ */
+
+/**
+ * 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;
+}
+/**
+ * Object keys type.
+ */
+
+/**
+ * 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]>;
+
+/**
+ * Tuple items type.
+ */
+
+/**
+ * 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;
+}
+/**
+ * Generic issue type.
+ */
+
+/**
+ * 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>;
+/**
+ * Schema without pipe type.
+ */
+
+/**
+ * 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>;
+
+/**
+ * File issue interface.
+ */
+
+/**
+ * Infer nullish output type.
+ */
+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>;
+
+/**
+ * Nullish schema interface.
+ */
+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;
+}
+/**
+ * Creates a nullish schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns A nullish schema.
+ */
+declare function nullish<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): NullishSchema<TWrapped, undefined>;
+/**
+ * Creates a nullish schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns A nullish schema.
+ */
+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>;
+
+/**
+ * Nullish schema async interface.
+ */
+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;
+}
+/**
+ * Creates a nullish schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns A nullish schema.
+ */
+declare function nullishAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): NullishSchemaAsync<TWrapped, undefined>;
+/**
+ * Creates a nullish schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns A nullish schema.
+ */
+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>;
+
+/**
+ * Number issue interface.
+ */
+interface NumberIssue extends BaseIssue<unknown> {
+  /**
+   * The issue kind.
+   */
+  readonly kind: 'schema';
+  /**
+   * The issue type.
+   */
+  readonly type: 'number';
+  /**
+   * The expected property.
+   */
+  readonly expected: 'number';
+}
+/**
+ * Number schema interface.
+ */
+interface NumberSchema<TMessage extends ErrorMessage<NumberIssue> | undefined> extends BaseSchema<number, number, NumberIssue> {
+  /**
+   * The schema type.
+   */
+  readonly type: 'number';
+  /**
+   * The schema reference.
+   */
+  readonly reference: typeof number;
+  /**
+   * The expected property.
+   */
+  readonly expects: 'number';
+  /**
+   * The error message.
+   */
+  readonly message: TMessage;
+}
+/**
+ * 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.
+ */
+declare function number<const TMessage extends ErrorMessage<NumberIssue> | undefined>(message: TMessage): NumberSchema<TMessage>;
+
+/**
+ * Object issue interface.
+ */
+interface ObjectIssue extends BaseIssue<unknown> {
+  /**
+   * The issue kind.
+   */
+  readonly kind: 'schema';
+  /**
+   * The issue type.
+   */
+  readonly type: 'object';
+  /**
+   * The expected property.
+   */
+  readonly expected: 'Object' | `"${string}"`;
+}
+
+/**
+ * Object schema interface.
+ */
+interface ObjectSchema<TEntries extends ObjectEntries, TMessage extends ErrorMessage<ObjectIssue> | undefined> extends BaseSchema<InferObjectInput<TEntries>, InferObjectOutput<TEntries>, ObjectIssue | InferObjectIssue<TEntries>> {
+  /**
+   * The schema type.
+   */
+  readonly type: 'object';
+  /**
+   * The schema reference.
+   */
+  readonly reference: typeof object;
+  /**
+   * The expected property.
+   */
+  readonly expects: 'Object';
+  /**
+   * The entries schema.
+   */
+  readonly entries: TEntries;
+  /**
+   * The error message.
+   */
+  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>;
+
+/**
+ * Object schema async interface.
+ */
+
+/**
+ * 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>;
+
+/**
+ * Optional schema interface.
+ */
+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.
+   */
+  readonly type: 'optional';
+  /**
+   * The schema reference.
+   */
+  readonly reference: typeof optional;
+  /**
+   * The expected property.
+   */
+  readonly expects: `(${TWrapped['expects']} | undefined)`;
+  /**
+   * The wrapped schema.
+   */
+  readonly wrapped: TWrapped;
+  /**
+   * The default value.
+   */
+  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>;
+
+/**
+ * Optional schema async interface.
+ */
+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.
+   */
+  readonly type: 'optional';
+  /**
+   * The schema reference.
+   */
+  readonly reference: typeof optional | typeof optionalAsync;
+  /**
+   * The expected property.
+   */
+  readonly expects: `(${TWrapped['expects']} | undefined)`;
+  /**
+   * The wrapped schema.
+   */
+  readonly wrapped: TWrapped;
+  /**
+   * The default value.
+   */
+  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>;
+
+/**
+ * Picklist options type.
+ */
+
+/**
+ * String issue interface.
+ */
+interface StringIssue extends BaseIssue<unknown> {
+  /**
+   * The issue kind.
+   */
+  readonly kind: 'schema';
+  /**
+   * The issue type.
+   */
+  readonly type: 'string';
+  /**
+   * The expected property.
+   */
+  readonly expected: 'string';
+}
+/**
+ * String schema interface.
+ */
+interface StringSchema<TMessage extends ErrorMessage<StringIssue> | undefined> extends BaseSchema<string, string, StringIssue> {
+  /**
+   * The schema type.
+   */
+  readonly type: 'string';
+  /**
+   * The schema reference.
+   */
+  readonly reference: typeof string;
+  /**
+   * The expected property.
+   */
+  readonly expects: 'string';
+  /**
+   * The error message.
+   */
+  readonly message: TMessage;
+}
+/**
+ * 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.
+ */
+declare function string<const TMessage extends ErrorMessage<StringIssue> | undefined>(message: TMessage): StringSchema<TMessage>;
+
+/**
+ * Symbol issue interface.
+ */
+
+/**
+ * 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 ReadonlyAction<TInput> extends BaseTransformation<TInput, ReadonlyOutput<TInput>, never> {
+  /**
+   * The action type.
+   */
+  readonly type: 'readonly';
+  /**
+   * The action reference.
+   */
+  readonly reference: typeof readonly;
+}
+/**
+ * Creates a readonly transformation action.
+ *
+ * @returns A readonly action.
+ */
+declare function readonly<TInput>(): ReadonlyAction<TInput>;
+
+/**
+ * Array action type.
+ */
+//#endregion
+//#region data-loader.d.ts
+declare const getDefaultClaudePath: () => string;
+declare const UsageDataSchema: ObjectSchema<{
+  readonly timestamp: StringSchema<undefined>;
+  readonly message: ObjectSchema<{
+    readonly usage: ObjectSchema<{
+      readonly input_tokens: NumberSchema<undefined>;
+      readonly output_tokens: NumberSchema<undefined>;
+      readonly cache_creation_input_tokens: OptionalSchema<NumberSchema<undefined>, undefined>;
+      readonly cache_read_input_tokens: OptionalSchema<NumberSchema<undefined>, undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly costUSD: NumberSchema<undefined>;
+}, undefined>;
+type UsageData = InferOutput<typeof UsageDataSchema>;
+declare const DailyUsageSchema: ObjectSchema<{
+  readonly date: StringSchema<undefined>;
+  readonly inputTokens: NumberSchema<undefined>;
+  readonly outputTokens: NumberSchema<undefined>;
+  readonly cacheCreationTokens: NumberSchema<undefined>;
+  readonly cacheReadTokens: NumberSchema<undefined>;
+  readonly totalCost: NumberSchema<undefined>;
+}, undefined>;
+type DailyUsage = InferOutput<typeof DailyUsageSchema>;
+declare const SessionUsageSchema: ObjectSchema<{
+  readonly sessionId: StringSchema<undefined>;
+  readonly projectPath: StringSchema<undefined>;
+  readonly inputTokens: NumberSchema<undefined>;
+  readonly outputTokens: NumberSchema<undefined>;
+  readonly cacheCreationTokens: NumberSchema<undefined>;
+  readonly cacheReadTokens: NumberSchema<undefined>;
+  readonly totalCost: NumberSchema<undefined>;
+  readonly lastActivity: StringSchema<undefined>;
+}, undefined>;
+type SessionUsage = InferOutput<typeof SessionUsageSchema>;
+declare const formatDate: (dateStr: string) => string;
+interface DateFilter {
+  since?: string;
+  until?: string;
+}
+interface LoadOptions extends DateFilter {
+  claudePath?: string;
+}
+declare function loadUsageData(options?: LoadOptions): Promise<DailyUsage[]>;
+declare function loadSessionData(options?: LoadOptions): Promise<SessionUsage[]>;
+//#endregion
+export { DailyUsage, DailyUsageSchema as DailyUsageSchema$1, DateFilter, LoadOptions, SessionUsage, SessionUsageSchema as SessionUsageSchema$1, UsageData, UsageDataSchema as UsageDataSchema$1, formatDate as formatDate$1, getDefaultClaudePath as getDefaultClaudePath$1, loadSessionData as loadSessionData$1, loadUsageData as loadUsageData$1 };