ccusage 16.2.5 → 17.0.0

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

@@ -0,0 +1,2307 @@
+//#region src/_consts.d.ts
+
+/**
+ * Days of the week for weekly aggregation
+ */
+declare const WEEK_DAYS: readonly ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+/**
+ * Week day names type
+ */
+type WeekDay = typeof WEEK_DAYS[number];
+/**
+ * Day of week as number (0 = Sunday, 1 = Monday, ..., 6 = Saturday)
+ */
+//#endregion
+//#region src/_session-blocks.d.ts
+/**
+ * Represents a single usage data entry loaded from JSONL files
+ */
+type LoadedUsageEntry = {
+  timestamp: Date;
+  usage: {
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationInputTokens: number;
+    cacheReadInputTokens: number;
+  };
+  costUSD: number | null;
+  model: string;
+  version?: string;
+  usageLimitResetTime?: Date;
+};
+/**
+ * Aggregated token counts for different token types
+ */
+type TokenCounts = {
+  inputTokens: number;
+  outputTokens: number;
+  cacheCreationInputTokens: number;
+  cacheReadInputTokens: number;
+};
+/**
+ * Represents a session block (typically 5-hour billing period) with usage data
+ */
+type SessionBlock = {
+  id: string;
+  startTime: Date;
+  endTime: Date;
+  actualEndTime?: Date;
+  isActive: boolean;
+  isGap?: boolean;
+  entries: LoadedUsageEntry[];
+  tokenCounts: TokenCounts;
+  costUSD: number;
+  models: string[];
+  usageLimitResetTime?: Date;
+};
+/**
+ * Represents usage burn rate calculations
+ */
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/observable-like.d.ts
+declare global {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+  interface SymbolConstructor {
+    readonly observable: symbol;
+  }
+}
+
+/**
+@remarks
+The TC39 observable proposal defines a `closed` property, but some implementations (such as xstream) do not as of 10/08/2021.
+As well, some guidance on making an `Observable` to not include `closed` property.
+@see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L129-L130
+@see https://github.com/staltz/xstream/blob/6c22580c1d84d69773ee4b0905df44ad464955b3/src/index.ts#L79-L85
+@see https://github.com/benlesh/symbol-observable#making-an-object-observable
+
+@category Observable
+*/
+
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/tuple-to-union.d.ts
+/**
+Convert a tuple/array into a union type of its elements.
+
+This can be useful when you have a fixed set of allowed values and want a type defining only the allowed values, but do not want to repeat yourself.
+
+@example
+```
+import type {TupleToUnion} from 'type-fest';
+
+const destinations = ['a', 'b', 'c'] as const;
+
+type Destination = TupleToUnion<typeof destinations>;
+//=> 'a' | 'b' | 'c'
+
+function verifyDestination(destination: unknown): destination is Destination {
+	return destinations.includes(destination as any);
+}
+
+type RequestBody = {
+	deliverTo: Destination;
+};
+
+function verifyRequestBody(body: unknown): body is RequestBody {
+	const deliverTo = (body as any).deliverTo;
+	return typeof body === 'object' && body !== null && verifyDestination(deliverTo);
+}
+```
+
+Alternatively, you may use `typeof destinations[number]`. If `destinations` is a tuple, there is no difference. However if `destinations` is a string, the resulting type will the union of the characters in the string. Other types of `destinations` may result in a compile error. In comparison, TupleToUnion will return `never` if a tuple is not provided.
+
+@example
+```
+const destinations = ['a', 'b', 'c'] as const;
+
+type Destination = typeof destinations[number];
+//=> 'a' | 'b' | 'c'
+
+const erroringType = new Set(['a', 'b', 'c']);
+
+type ErroringType = typeof erroringType[number];
+//=> Type 'Set<string>' has no matching index signature for type 'number'. ts(2537)
+
+const numberBool: { [n: number]: boolean } = { 1: true };
+
+type NumberBool = typeof numberBool[number];
+//=> boolean
+```
+
+@category Array
+*/
+type TupleToUnion<ArrayType> = ArrayType extends readonly unknown[] ? ArrayType[number] : never;
+//#endregion
+//#region ../../node_modules/.pnpm/valibot@1.1.0_typescript@5.9.2/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.
+ */
+
+/**
+ * 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>;
+
+/**
+ * Array schema interface.
+ */
+
+/**
+ * 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>;
+
+/**
+ * Custom issue interface.
+ */
+
+/**
+ * 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.
+ */
+
+/**
+ * Union issue interface.
+ */
+interface UnionIssue<TSubIssue extends BaseIssue<unknown>> extends BaseIssue<unknown> {
+  /**
+   * The issue kind.
+   */
+  readonly kind: 'schema';
+  /**
+   * The issue type.
+   */
+  readonly type: 'union';
+  /**
+   * The expected property.
+   */
+  readonly expected: string;
+  /**
+   * The sub issues.
+   */
+  readonly issues?: [TSubIssue, ...TSubIssue[]];
+}
+
+/**
+ * Union options type.
+ */
+type UnionOptions = MaybeReadonly<BaseSchema<unknown, unknown, BaseIssue<unknown>>[]>;
+/**
+ * Union schema interface.
+ */
+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.
+   */
+  readonly type: 'union';
+  /**
+   * The schema reference.
+   */
+  readonly reference: typeof union;
+  /**
+   * The union options.
+   */
+  readonly options: TOptions;
+  /**
+   * The error message.
+   */
+  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>;
+
+/**
+ * Union options async type.
+ */
+
+/**
+ * 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.
+ */
+
+/**
+ * Brand symbol.
+ */
+declare const BrandSymbol: unique symbol;
+/**
+ * Brand name type.
+ */
+type BrandName = string | number | symbol;
+/**
+ * Brand interface.
+ */
+interface Brand<TName extends BrandName> {
+  [BrandSymbol]: { [TValue in TName]: TValue };
+}
+/**
+ * Brand action interface.
+ */
+interface BrandAction<TInput, TName extends BrandName> extends BaseTransformation<TInput, TInput & Brand<TName>, never> {
+  /**
+   * The action type.
+   */
+  readonly type: 'brand';
+  /**
+   * The action reference.
+   */
+  readonly reference: typeof brand;
+  /**
+   * The brand name.
+   */
+  readonly name: TName;
+}
+/**
+ * Creates a brand transformation action.
+ *
+ * @param name The brand name.
+ *
+ * @returns A brand action.
+ */
+declare function brand<TInput, TName extends BrandName>(name: TName): BrandAction<TInput, TName>;
+
+/**
+ * Bytes issue interface.
+ */
+
+/**
+ * Length input type.
+ */
+type LengthInput = string | ArrayLike<unknown>;
+/**
+ * Size input type.
+ */
+
+/**
+ * Min length issue interface.
+ */
+interface MinLengthIssue<TInput extends LengthInput, TRequirement extends number> extends BaseIssue<TInput> {
+  /**
+   * The issue kind.
+   */
+  readonly kind: 'validation';
+  /**
+   * The issue type.
+   */
+  readonly type: 'min_length';
+  /**
+   * The expected property.
+   */
+  readonly expected: `>=${TRequirement}`;
+  /**
+   * The received property.
+   */
+  readonly received: `${number}`;
+  /**
+   * The minimum length.
+   */
+  readonly requirement: TRequirement;
+}
+/**
+ * Min length action interface.
+ */
+interface MinLengthAction<TInput extends LengthInput, TRequirement extends number, TMessage extends ErrorMessage<MinLengthIssue<TInput, TRequirement>> | undefined> extends BaseValidation<TInput, TInput, MinLengthIssue<TInput, TRequirement>> {
+  /**
+   * The action type.
+   */
+  readonly type: 'min_length';
+  /**
+   * The action reference.
+   */
+  readonly reference: typeof minLength;
+  /**
+   * The expected property.
+   */
+  readonly expects: `>=${TRequirement}`;
+  /**
+   * The minimum length.
+   */
+  readonly requirement: TRequirement;
+  /**
+   * The error message.
+   */
+  readonly message: TMessage;
+}
+/**
+ * Creates a min length validation action.
+ *
+ * @param requirement The minimum length.
+ *
+ * @returns A min length action.
+ */
+declare function minLength<TInput extends LengthInput, const TRequirement extends number>(requirement: TRequirement): MinLengthAction<TInput, TRequirement, undefined>;
+/**
+ * Creates a min length validation action.
+ *
+ * @param requirement The minimum length.
+ * @param message The error message.
+ *
+ * @returns A min length action.
+ */
+declare function minLength<TInput extends LengthInput, const TRequirement extends number, const TMessage extends ErrorMessage<MinLengthIssue<TInput, TRequirement>> | undefined>(requirement: TRequirement, message: TMessage): MinLengthAction<TInput, TRequirement, TMessage>;
+
+/**
+ * Min size 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.
+ */
+
+/**
+ * Regex issue interface.
+ */
+interface RegexIssue<TInput extends string> extends BaseIssue<TInput> {
+  /**
+   * The issue kind.
+   */
+  readonly kind: 'validation';
+  /**
+   * The issue type.
+   */
+  readonly type: 'regex';
+  /**
+   * The expected input.
+   */
+  readonly expected: string;
+  /**
+   * The received input.
+   */
+  readonly received: `"${string}"`;
+  /**
+   * The regex pattern.
+   */
+  readonly requirement: RegExp;
+}
+/**
+ * Regex action interface.
+ */
+interface RegexAction<TInput extends string, TMessage extends ErrorMessage<RegexIssue<TInput>> | undefined> extends BaseValidation<TInput, TInput, RegexIssue<TInput>> {
+  /**
+   * The action type.
+   */
+  readonly type: 'regex';
+  /**
+   * The action reference.
+   */
+  readonly reference: typeof regex;
+  /**
+   * The expected property.
+   */
+  readonly expects: string;
+  /**
+   * The regex pattern.
+   */
+  readonly requirement: RegExp;
+  /**
+   * The error message.
+   */
+  readonly message: TMessage;
+}
+/**
+ * Creates a [regex](https://en.wikipedia.org/wiki/Regular_expression) validation action.
+ *
+ * Hint: Be careful with the global flag `g` in your regex pattern, as it can lead to unexpected results. See [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/test#using_test_on_a_regex_with_the_global_flag) for more information.
+ *
+ * @param requirement The regex pattern.
+ *
+ * @returns A regex action.
+ */
+declare function regex<TInput extends string>(requirement: RegExp): RegexAction<TInput, undefined>;
+/**
+ * Creates a [regex](https://en.wikipedia.org/wiki/Regular_expression) validation action.
+ *
+ * Hint: Be careful with the global flag `g` in your regex pattern, as it can lead to unexpected results. See [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/test#using_test_on_a_regex_with_the_global_flag) for more information.
+ *
+ * @param requirement The regex pattern.
+ * @param message The error message.
+ *
+ * @returns A regex action.
+ */
+declare function regex<TInput extends string, const TMessage extends ErrorMessage<RegexIssue<TInput>> | undefined>(requirement: RegExp, message: TMessage): RegexAction<TInput, TMessage>;
+
+/**
+ * Returns action type.
+ */
+//#endregion
+//#region src/_types.d.ts
+declare const monthlyDateSchema: SchemaWithPipe<readonly [StringSchema<undefined>, RegexAction<string, "Date must be in YYYY-MM format">, BrandAction<string, "MonthlyDate">]>;
+declare const weeklyDateSchema: SchemaWithPipe<readonly [StringSchema<undefined>, RegexAction<string, "Date must be in YYYY-MM-DD format">, BrandAction<string, "WeeklyDate">]>;
+type MonthlyDate = InferOutput<typeof monthlyDateSchema>;
+type WeeklyDate = InferOutput<typeof weeklyDateSchema>;
+type Bucket = MonthlyDate | WeeklyDate;
+/**
+ * Available cost calculation modes
+ * - auto: Use pre-calculated costs when available, otherwise calculate from tokens
+ * - calculate: Always calculate costs from token counts using model pricing
+ * - display: Always use pre-calculated costs, show 0 for missing costs
+ */
+declare const CostModes: readonly ["auto", "calculate", "display"];
+/**
+ * Union type for cost calculation modes
+ */
+type CostMode = TupleToUnion<typeof CostModes>;
+/**
+ * Available sort orders for data presentation
+ */
+declare const SortOrders: readonly ["desc", "asc"];
+/**
+ * Union type for sort order options
+ */
+type SortOrder = TupleToUnion<typeof SortOrders>;
+/**
+ * Valibot schema for Claude Code statusline hook JSON data
+ */
+//#endregion
+//#region src/_pricing-fetcher.d.ts
+declare class PricingFetcher extends LiteLLMPricingFetcher {
+  constructor(offline?: boolean);
+}
+//#endregion
+//#region src/data-loader.d.ts
+/**
+ * Get Claude data directories to search for usage data
+ * When CLAUDE_CONFIG_DIR is set: uses only those paths
+ * When not set: uses default paths (~/.config/claude and ~/.claude)
+ * @returns Array of valid Claude data directory paths
+ */
+declare function getClaudePaths(): string[];
+/**
+ * Extract project name from Claude JSONL file path
+ * @param jsonlPath - Absolute path to JSONL file
+ * @returns Project name extracted from path, or "unknown" if malformed
+ */
+declare function extractProjectFromPath(jsonlPath: string): string;
+/**
+ * Valibot schema for validating Claude usage data from JSONL files
+ */
+declare const usageDataSchema: ObjectSchema<{
+  readonly cwd: OptionalSchema<StringSchema<undefined>, undefined>;
+  readonly sessionId: OptionalSchema<SchemaWithPipe<readonly [StringSchema<undefined>, MinLengthAction<string, 1, "Session ID cannot be empty">, BrandAction<string, "SessionId">]>, undefined>;
+  readonly timestamp: SchemaWithPipe<readonly [StringSchema<undefined>, RegexAction<string, "Invalid ISO timestamp">, BrandAction<string, "ISOTimestamp">]>;
+  readonly version: OptionalSchema<SchemaWithPipe<readonly [StringSchema<undefined>, RegexAction<string, "Invalid version format">, BrandAction<string, "Version">]>, 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>;
+    readonly model: OptionalSchema<SchemaWithPipe<readonly [StringSchema<undefined>, MinLengthAction<string, 1, "Model name cannot be empty">, BrandAction<string, "ModelName">]>, undefined>;
+    readonly id: OptionalSchema<SchemaWithPipe<readonly [StringSchema<undefined>, MinLengthAction<string, 1, "Message ID cannot be empty">, BrandAction<string, "MessageId">]>, undefined>;
+    readonly content: OptionalSchema<ArraySchema<ObjectSchema<{
+      readonly text: OptionalSchema<StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>, undefined>;
+  }, undefined>;
+  readonly costUSD: OptionalSchema<NumberSchema<undefined>, undefined>;
+  readonly requestId: OptionalSchema<SchemaWithPipe<readonly [StringSchema<undefined>, MinLengthAction<string, 1, "Request ID cannot be empty">, BrandAction<string, "RequestId">]>, undefined>;
+  readonly isApiErrorMessage: OptionalSchema<BooleanSchema<undefined>, undefined>;
+}, undefined>;
+/**
+ * Valibot schema for transcript usage data from Claude messages
+ */
+declare const transcriptUsageSchema: ObjectSchema<{
+  readonly input_tokens: OptionalSchema<NumberSchema<undefined>, undefined>;
+  readonly cache_creation_input_tokens: OptionalSchema<NumberSchema<undefined>, undefined>;
+  readonly cache_read_input_tokens: OptionalSchema<NumberSchema<undefined>, undefined>;
+  readonly output_tokens: OptionalSchema<NumberSchema<undefined>, undefined>;
+}, undefined>;
+/**
+ * Valibot schema for transcript message data
+ */
+declare const transcriptMessageSchema: ObjectSchema<{
+  readonly type: OptionalSchema<StringSchema<undefined>, undefined>;
+  readonly message: OptionalSchema<ObjectSchema<{
+    readonly usage: OptionalSchema<ObjectSchema<{
+      readonly input_tokens: OptionalSchema<NumberSchema<undefined>, undefined>;
+      readonly cache_creation_input_tokens: OptionalSchema<NumberSchema<undefined>, undefined>;
+      readonly cache_read_input_tokens: OptionalSchema<NumberSchema<undefined>, undefined>;
+      readonly output_tokens: OptionalSchema<NumberSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+  }, undefined>, undefined>;
+}, undefined>;
+/**
+ * Type definition for Claude usage data entries from JSONL files
+ */
+type UsageData = InferOutput<typeof usageDataSchema>;
+/**
+ * Valibot schema for model-specific usage breakdown data
+ */
+declare const modelBreakdownSchema: ObjectSchema<{
+  readonly modelName: SchemaWithPipe<readonly [StringSchema<undefined>, MinLengthAction<string, 1, "Model name cannot be empty">, BrandAction<string, "ModelName">]>;
+  readonly inputTokens: NumberSchema<undefined>;
+  readonly outputTokens: NumberSchema<undefined>;
+  readonly cacheCreationTokens: NumberSchema<undefined>;
+  readonly cacheReadTokens: NumberSchema<undefined>;
+  readonly cost: NumberSchema<undefined>;
+}, undefined>;
+/**
+ * Type definition for model-specific usage breakdown
+ */
+type ModelBreakdown = InferOutput<typeof modelBreakdownSchema>;
+/**
+ * Valibot schema for daily usage aggregation data
+ */
+declare const dailyUsageSchema: ObjectSchema<{
+  readonly date: SchemaWithPipe<readonly [StringSchema<undefined>, RegexAction<string, "Date must be in YYYY-MM-DD format">, BrandAction<string, "DailyDate">]>;
+  readonly inputTokens: NumberSchema<undefined>;
+  readonly outputTokens: NumberSchema<undefined>;
+  readonly cacheCreationTokens: NumberSchema<undefined>;
+  readonly cacheReadTokens: NumberSchema<undefined>;
+  readonly totalCost: NumberSchema<undefined>;
+  readonly modelsUsed: ArraySchema<SchemaWithPipe<readonly [StringSchema<undefined>, MinLengthAction<string, 1, "Model name cannot be empty">, BrandAction<string, "ModelName">]>, undefined>;
+  readonly modelBreakdowns: ArraySchema<ObjectSchema<{
+    readonly modelName: SchemaWithPipe<readonly [StringSchema<undefined>, MinLengthAction<string, 1, "Model name cannot be empty">, BrandAction<string, "ModelName">]>;
+    readonly inputTokens: NumberSchema<undefined>;
+    readonly outputTokens: NumberSchema<undefined>;
+    readonly cacheCreationTokens: NumberSchema<undefined>;
+    readonly cacheReadTokens: NumberSchema<undefined>;
+    readonly cost: NumberSchema<undefined>;
+  }, undefined>, undefined>;
+  readonly project: OptionalSchema<StringSchema<undefined>, undefined>;
+}, undefined>;
+/**
+ * Type definition for daily usage aggregation
+ */
+type DailyUsage = InferOutput<typeof dailyUsageSchema>;
+/**
+ * Valibot schema for session-based usage aggregation data
+ */
+declare const sessionUsageSchema: ObjectSchema<{
+  readonly sessionId: SchemaWithPipe<readonly [StringSchema<undefined>, MinLengthAction<string, 1, "Session ID cannot be empty">, BrandAction<string, "SessionId">]>;
+  readonly projectPath: SchemaWithPipe<readonly [StringSchema<undefined>, MinLengthAction<string, 1, "Project path cannot be empty">, BrandAction<string, "ProjectPath">]>;
+  readonly inputTokens: NumberSchema<undefined>;
+  readonly outputTokens: NumberSchema<undefined>;
+  readonly cacheCreationTokens: NumberSchema<undefined>;
+  readonly cacheReadTokens: NumberSchema<undefined>;
+  readonly totalCost: NumberSchema<undefined>;
+  readonly lastActivity: SchemaWithPipe<readonly [StringSchema<undefined>, RegexAction<string, "Date must be in YYYY-MM-DD format">, BrandAction<string, "ActivityDate">]>;
+  readonly versions: ArraySchema<SchemaWithPipe<readonly [StringSchema<undefined>, RegexAction<string, "Invalid version format">, BrandAction<string, "Version">]>, undefined>;
+  readonly modelsUsed: ArraySchema<SchemaWithPipe<readonly [StringSchema<undefined>, MinLengthAction<string, 1, "Model name cannot be empty">, BrandAction<string, "ModelName">]>, undefined>;
+  readonly modelBreakdowns: ArraySchema<ObjectSchema<{
+    readonly modelName: SchemaWithPipe<readonly [StringSchema<undefined>, MinLengthAction<string, 1, "Model name cannot be empty">, BrandAction<string, "ModelName">]>;
+    readonly inputTokens: NumberSchema<undefined>;
+    readonly outputTokens: NumberSchema<undefined>;
+    readonly cacheCreationTokens: NumberSchema<undefined>;
+    readonly cacheReadTokens: NumberSchema<undefined>;
+    readonly cost: NumberSchema<undefined>;
+  }, undefined>, undefined>;
+}, undefined>;
+/**
+ * Type definition for session-based usage aggregation
+ */
+type SessionUsage = InferOutput<typeof sessionUsageSchema>;
+/**
+ * Valibot schema for monthly usage aggregation data
+ */
+declare const monthlyUsageSchema: ObjectSchema<{
+  readonly month: SchemaWithPipe<readonly [StringSchema<undefined>, RegexAction<string, "Date must be in YYYY-MM format">, BrandAction<string, "MonthlyDate">]>;
+  readonly inputTokens: NumberSchema<undefined>;
+  readonly outputTokens: NumberSchema<undefined>;
+  readonly cacheCreationTokens: NumberSchema<undefined>;
+  readonly cacheReadTokens: NumberSchema<undefined>;
+  readonly totalCost: NumberSchema<undefined>;
+  readonly modelsUsed: ArraySchema<SchemaWithPipe<readonly [StringSchema<undefined>, MinLengthAction<string, 1, "Model name cannot be empty">, BrandAction<string, "ModelName">]>, undefined>;
+  readonly modelBreakdowns: ArraySchema<ObjectSchema<{
+    readonly modelName: SchemaWithPipe<readonly [StringSchema<undefined>, MinLengthAction<string, 1, "Model name cannot be empty">, BrandAction<string, "ModelName">]>;
+    readonly inputTokens: NumberSchema<undefined>;
+    readonly outputTokens: NumberSchema<undefined>;
+    readonly cacheCreationTokens: NumberSchema<undefined>;
+    readonly cacheReadTokens: NumberSchema<undefined>;
+    readonly cost: NumberSchema<undefined>;
+  }, undefined>, undefined>;
+  readonly project: OptionalSchema<StringSchema<undefined>, undefined>;
+}, undefined>;
+/**
+ * Type definition for monthly usage aggregation
+ */
+type MonthlyUsage = InferOutput<typeof monthlyUsageSchema>;
+/**
+ * Valibot schema for weekly usage aggregation data
+ */
+declare const weeklyUsageSchema: ObjectSchema<{
+  readonly week: SchemaWithPipe<readonly [StringSchema<undefined>, RegexAction<string, "Date must be in YYYY-MM-DD format">, BrandAction<string, "WeeklyDate">]>;
+  readonly inputTokens: NumberSchema<undefined>;
+  readonly outputTokens: NumberSchema<undefined>;
+  readonly cacheCreationTokens: NumberSchema<undefined>;
+  readonly cacheReadTokens: NumberSchema<undefined>;
+  readonly totalCost: NumberSchema<undefined>;
+  readonly modelsUsed: ArraySchema<SchemaWithPipe<readonly [StringSchema<undefined>, MinLengthAction<string, 1, "Model name cannot be empty">, BrandAction<string, "ModelName">]>, undefined>;
+  readonly modelBreakdowns: ArraySchema<ObjectSchema<{
+    readonly modelName: SchemaWithPipe<readonly [StringSchema<undefined>, MinLengthAction<string, 1, "Model name cannot be empty">, BrandAction<string, "ModelName">]>;
+    readonly inputTokens: NumberSchema<undefined>;
+    readonly outputTokens: NumberSchema<undefined>;
+    readonly cacheCreationTokens: NumberSchema<undefined>;
+    readonly cacheReadTokens: NumberSchema<undefined>;
+    readonly cost: NumberSchema<undefined>;
+  }, undefined>, undefined>;
+  readonly project: OptionalSchema<StringSchema<undefined>, undefined>;
+}, undefined>;
+/**
+ * Type definition for weekly usage aggregation
+ */
+type WeeklyUsage = InferOutput<typeof weeklyUsageSchema>;
+/**
+ * Valibot schema for bucket usage aggregation data
+ */
+declare const bucketUsageSchema: ObjectSchema<{
+  readonly bucket: UnionSchema<[SchemaWithPipe<readonly [StringSchema<undefined>, RegexAction<string, "Date must be in YYYY-MM-DD format">, BrandAction<string, "WeeklyDate">]>, SchemaWithPipe<readonly [StringSchema<undefined>, RegexAction<string, "Date must be in YYYY-MM format">, BrandAction<string, "MonthlyDate">]>], undefined>;
+  readonly inputTokens: NumberSchema<undefined>;
+  readonly outputTokens: NumberSchema<undefined>;
+  readonly cacheCreationTokens: NumberSchema<undefined>;
+  readonly cacheReadTokens: NumberSchema<undefined>;
+  readonly totalCost: NumberSchema<undefined>;
+  readonly modelsUsed: ArraySchema<SchemaWithPipe<readonly [StringSchema<undefined>, MinLengthAction<string, 1, "Model name cannot be empty">, BrandAction<string, "ModelName">]>, undefined>;
+  readonly modelBreakdowns: ArraySchema<ObjectSchema<{
+    readonly modelName: SchemaWithPipe<readonly [StringSchema<undefined>, MinLengthAction<string, 1, "Model name cannot be empty">, BrandAction<string, "ModelName">]>;
+    readonly inputTokens: NumberSchema<undefined>;
+    readonly outputTokens: NumberSchema<undefined>;
+    readonly cacheCreationTokens: NumberSchema<undefined>;
+    readonly cacheReadTokens: NumberSchema<undefined>;
+    readonly cost: NumberSchema<undefined>;
+  }, undefined>, undefined>;
+  readonly project: OptionalSchema<StringSchema<undefined>, undefined>;
+}, undefined>;
+/**
+ * Type definition for bucket usage aggregation
+ */
+type BucketUsage = InferOutput<typeof bucketUsageSchema>;
+/**
+ * Create a unique identifier for deduplication using message ID and request ID
+ */
+declare function createUniqueHash(data: UsageData): string | null;
+/**
+ * Extract the earliest timestamp from a JSONL file
+ * Scans through the file until it finds a valid timestamp
+ */
+declare function getEarliestTimestamp(filePath: string): Promise<Date | null>;
+/**
+ * Sort files by their earliest timestamp
+ * Files without valid timestamps are placed at the end
+ */
+declare function sortFilesByTimestamp(files: string[]): Promise<string[]>;
+/**
+ * Calculates cost for a single usage data entry based on the specified cost calculation mode
+ * @param data - Usage data entry
+ * @param mode - Cost calculation mode (auto, calculate, or display)
+ * @param fetcher - Pricing fetcher instance for calculating costs from tokens
+ * @returns Calculated cost in USD
+ */
+declare function calculateCostForEntry(data: UsageData, mode: CostMode, fetcher: PricingFetcher): Promise<number>;
+/**
+ * Get Claude Code usage limit expiration date
+ * @param data - Usage data entry
+ * @returns Usage limit expiration date
+ */
+declare function getUsageLimitResetTime(data: UsageData): Date | null;
+/**
+ * Result of glob operation with base directory information
+ */
+type GlobResult = {
+  file: string;
+  baseDir: string;
+};
+/**
+ * Glob files from multiple Claude paths in parallel
+ * @param claudePaths - Array of Claude base paths
+ * @returns Array of file paths with their base directories
+ */
+declare function globUsageFiles(claudePaths: string[]): Promise<GlobResult[]>;
+/**
+ * Date range filter for limiting usage data by date
+ */
+type DateFilter = {
+  since?: string;
+  until?: string;
+};
+/**
+ * Configuration options for loading usage data
+ */
+type LoadOptions = {
+  claudePath?: string;
+  mode?: CostMode;
+  order?: SortOrder;
+  offline?: boolean;
+  sessionDurationHours?: number;
+  groupByProject?: boolean;
+  project?: string;
+  startOfWeek?: WeekDay;
+  timezone?: string;
+  locale?: string;
+} & DateFilter;
+/**
+ * Loads and aggregates Claude usage data by day
+ * Processes all JSONL files in the Claude projects directory and groups usage by date
+ * @param options - Optional configuration for loading and filtering data
+ * @returns Array of daily usage summaries sorted by date
+ */
+declare function loadDailyUsageData(options?: LoadOptions): Promise<DailyUsage[]>;
+/**
+ * Loads and aggregates Claude usage data by session
+ * Groups usage data by project path and session ID based on file structure
+ * @param options - Optional configuration for loading and filtering data
+ * @returns Array of session usage summaries sorted by last activity
+ */
+declare function loadSessionData(options?: LoadOptions): Promise<SessionUsage[]>;
+/**
+ * Loads and aggregates Claude usage data by month
+ * Uses daily usage data as the source and groups by month
+ * @param options - Optional configuration for loading and filtering data
+ * @returns Array of monthly usage summaries sorted by month
+ */
+declare function loadMonthlyUsageData(options?: LoadOptions): Promise<MonthlyUsage[]>;
+declare function loadWeeklyUsageData(options?: LoadOptions): Promise<WeeklyUsage[]>;
+/**
+ * Load usage data for a specific session by sessionId
+ * Searches for a JSONL file named {sessionId}.jsonl in all Claude project directories
+ * @param sessionId - The session ID to load data for (matches the JSONL filename)
+ * @param options - Options for loading data
+ * @param options.mode - Cost calculation mode (auto, calculate, display)
+ * @param options.offline - Whether to use offline pricing data
+ * @returns Usage data for the specific session or null if not found
+ */
+declare function loadSessionUsageById(sessionId: string, options?: {
+  mode?: CostMode;
+  offline?: boolean;
+}): Promise<{
+  totalCost: number;
+  entries: UsageData[];
+} | null>;
+declare function loadBucketUsageData(groupingFn: (data: DailyUsage) => Bucket, options?: LoadOptions): Promise<BucketUsage[]>;
+/**
+ * Calculate context tokens from transcript file using improved JSONL parsing
+ * Based on the Python reference implementation for better accuracy
+ * @param transcriptPath - Path to the transcript JSONL file
+ * @returns Object with context tokens info or null if unavailable
+ */
+declare function calculateContextTokens(transcriptPath: string, modelId?: string, offline?: boolean): Promise<{
+  inputTokens: number;
+  percentage: number;
+  contextLimit: number;
+} | null>;
+/**
+ * Loads usage data and organizes it into session blocks (typically 5-hour billing periods)
+ * Processes all usage data and groups it into time-based blocks for billing analysis
+ * @param options - Optional configuration including session duration and filtering
+ * @returns Array of session blocks with usage and cost information
+ */
+declare function loadSessionBlockData(options?: LoadOptions): Promise<SessionBlock[]>;
+//#endregion
+export { BucketUsage, DailyUsage, DateFilter, GlobResult, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, WeeklyUsage, bucketUsageSchema, calculateContextTokens, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadBucketUsageData, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadSessionUsageById, loadWeeklyUsageData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, transcriptMessageSchema, transcriptUsageSchema, usageDataSchema, weeklyUsageSchema };