@schematichq/schematic-typescript-node 1.2.7 → 1.3.1

package/dist/core/logging/logger.d.ts

@@ -0,0 +1,126 @@
+export declare const LogLevel: {
+    readonly Debug: "debug";
+    readonly Info: "info";
+    readonly Warn: "warn";
+    readonly Error: "error";
+};
+export type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+export interface ILogger {
+    /**
+     * Logs a debug message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Logs an info message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Logs a warning message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Logs an error message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    error(message: string, ...args: unknown[]): void;
+}
+/**
+ * Configuration for logger initialization.
+ */
+export interface LogConfig {
+    /**
+     * Minimum log level to output.
+     * @default LogLevel.Info
+     */
+    level?: LogLevel;
+    /**
+     * Logger implementation to use.
+     * @default new ConsoleLogger()
+     */
+    logger?: ILogger;
+    /**
+     * Whether logging should be silenced.
+     * @default true
+     */
+    silent?: boolean;
+}
+/**
+ * Default console-based logger implementation.
+ */
+export declare class ConsoleLogger implements ILogger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+/**
+ * Logger class that provides level-based logging functionality.
+ */
+export declare class Logger {
+    private readonly level;
+    private readonly logger;
+    private readonly silent;
+    /**
+     * Creates a new logger instance.
+     * @param config - Logger configuration
+     */
+    constructor(config: Required<LogConfig>);
+    /**
+     * Checks if a log level should be output based on configuration.
+     * @param level - The log level to check
+     * @returns True if the level should be logged
+     */
+    shouldLog(level: LogLevel): boolean;
+    /**
+     * Checks if debug logging is enabled.
+     * @returns True if debug logs should be output
+     */
+    isDebug(): boolean;
+    /**
+     * Logs a debug message if debug logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Checks if info logging is enabled.
+     * @returns True if info logs should be output
+     */
+    isInfo(): boolean;
+    /**
+     * Logs an info message if info logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Checks if warning logging is enabled.
+     * @returns True if warning logs should be output
+     */
+    isWarn(): boolean;
+    /**
+     * Logs a warning message if warning logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Checks if error logging is enabled.
+     * @returns True if error logs should be output
+     */
+    isError(): boolean;
+    /**
+     * Logs an error message if error logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    error(message: string, ...args: unknown[]): void;
+}
+export declare function createLogger(config?: LogConfig | Logger): Logger;

package/dist/core/schemas/Schema.d.ts

@@ -1,4 +1,4 @@
-import { SchemaUtils } from "./builders";
+import type { SchemaUtils } from "./builders/index";
 export type Schema<Raw = unknown, Parsed = unknown> = BaseSchema<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
 export type inferRaw<S extends Schema> = S extends Schema<infer Raw, any> ? Raw : never;
 export type inferParsed<S extends Schema> = S extends Schema<any, infer Parsed> ? Parsed : never;
@@ -20,6 +20,7 @@ export declare const SchemaType: {
     readonly NUMBER: "number";
     readonly STRING: "string";
     readonly UNKNOWN: "unknown";
+    readonly NEVER: "never";
     readonly RECORD: "record";
     readonly SET: "set";
     readonly UNION: "union";

package/dist/core/schemas/builders/bigint/bigint.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function bigint(): Schema<bigint | number, bigint>;

package/dist/core/schemas/builders/date/date.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function date(): Schema<string, Date>;

package/dist/core/schemas/builders/enum/enum.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function enum_<U extends string, E extends U[]>(values: E): Schema<E[number], E[number]>;

package/dist/core/schemas/builders/index.d.ts

@@ -1,14 +1,14 @@
-export * from "./bigint";
-export * from "./date";
-export * from "./enum";
-export * from "./lazy";
-export * from "./list";
-export * from "./literals";
-export * from "./object";
-export * from "./object-like";
-export * from "./primitives";
-export * from "./record";
-export * from "./schema-utils";
-export * from "./set";
-export * from "./undiscriminated-union";
-export * from "./union";
+export * from "./bigint/index";
+export * from "./date/index";
+export * from "./enum/index";
+export * from "./lazy/index";
+export * from "./list/index";
+export * from "./literals/index";
+export * from "./object/index";
+export * from "./object-like/index";
+export * from "./primitives/index";
+export * from "./record/index";
+export * from "./schema-utils/index";
+export * from "./set/index";
+export * from "./undiscriminated-union/index";
+export * from "./union/index";

package/dist/core/schemas/builders/lazy/index.d.ts

@@ -1,3 +1,3 @@
-export { lazy } from "./lazy";
 export type { SchemaGetter } from "./lazy";
+export { lazy } from "./lazy";
 export { lazyObject } from "./lazyObject";

package/dist/core/schemas/builders/lazy/lazy.d.ts

@@ -1,4 +1,4 @@
-import { BaseSchema, Schema } from "../../Schema";
+import type { BaseSchema, Schema } from "../../Schema";
 export type SchemaGetter<SchemaType extends Schema<any, any>> = () => SchemaType;
 export declare function lazy<Raw, Parsed>(getter: SchemaGetter<Schema<Raw, Parsed>>): Schema<Raw, Parsed>;
 export declare function constructLazyBaseSchema<Raw, Parsed>(getter: SchemaGetter<Schema<Raw, Parsed>>): BaseSchema<Raw, Parsed>;

package/dist/core/schemas/builders/lazy/lazyObject.d.ts

@@ -1,3 +1,3 @@
-import { ObjectSchema } from "../object/types";
-import { SchemaGetter } from "./lazy";
+import type { ObjectSchema } from "../object/types";
+import { type SchemaGetter } from "./lazy";
 export declare function lazyObject<Raw, Parsed>(getter: SchemaGetter<ObjectSchema<Raw, Parsed>>): ObjectSchema<Raw, Parsed>;

package/dist/core/schemas/builders/list/list.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function list<Raw, Parsed>(schema: Schema<Raw, Parsed>): Schema<Raw[], Parsed[]>;

package/dist/core/schemas/builders/literals/booleanLiteral.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function booleanLiteral<V extends boolean>(literal: V): Schema<V, V>;

package/dist/core/schemas/builders/literals/index.d.ts

@@ -1,2 +1,2 @@
-export { stringLiteral } from "./stringLiteral";
 export { booleanLiteral } from "./booleanLiteral";
+export { stringLiteral } from "./stringLiteral";

package/dist/core/schemas/builders/literals/stringLiteral.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function stringLiteral<V extends string>(literal: V): Schema<V, V>;

package/dist/core/schemas/builders/object/index.d.ts

@@ -1,6 +1,6 @@
 export { getObjectUtils, object } from "./object";
-export { objectWithoutOptionalProperties } from "./objectWithoutOptionalProperties";
 export type { inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas, inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas, } from "./objectWithoutOptionalProperties";
-export { isProperty, property } from "./property";
+export { objectWithoutOptionalProperties } from "./objectWithoutOptionalProperties";
 export type { Property } from "./property";
+export { isProperty, property } from "./property";
 export type { BaseObjectSchema, inferObjectSchemaFromPropertySchemas, inferParsedObject, inferParsedObjectFromPropertySchemas, inferParsedPropertySchema, inferRawKey, inferRawObject, inferRawObjectFromPropertySchemas, inferRawPropertySchema, ObjectSchema, ObjectUtils, PropertySchemas, } from "./types";

package/dist/core/schemas/builders/object/object.d.ts

@@ -1,3 +1,3 @@
-import { BaseObjectSchema, ObjectUtils, PropertySchemas, inferObjectSchemaFromPropertySchemas } from "./types";
+import type { BaseObjectSchema, inferObjectSchemaFromPropertySchemas, ObjectUtils, PropertySchemas } from "./types";
 export declare function object<ParsedKeys extends string, T extends PropertySchemas<ParsedKeys>>(schemas: T): inferObjectSchemaFromPropertySchemas<T>;
 export declare function getObjectUtils<Raw, Parsed>(schema: BaseObjectSchema<Raw, Parsed>): ObjectUtils<Raw, Parsed>;

package/dist/core/schemas/builders/object/objectWithoutOptionalProperties.d.ts

@@ -1,4 +1,4 @@
-import { ObjectSchema, PropertySchemas, inferParsedPropertySchema, inferRawObjectFromPropertySchemas } from "./types";
+import type { inferParsedPropertySchema, inferRawObjectFromPropertySchemas, ObjectSchema, PropertySchemas } from "./types";
 export declare function objectWithoutOptionalProperties<ParsedKeys extends string, T extends PropertySchemas<ParsedKeys>>(schemas: T): inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas<T>;
 export type inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas<T extends PropertySchemas<keyof T>> = ObjectSchema<inferRawObjectFromPropertySchemas<T>, inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas<T>>;
 export type inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas<T extends PropertySchemas<keyof T>> = {

package/dist/core/schemas/builders/object/property.d.ts

@@ -1,4 +1,4 @@
-import { Schema } from "../../Schema";
+import type { Schema } from "../../Schema";
 export declare function property<RawKey extends string, RawValue, ParsedValue>(rawKey: RawKey, valueSchema: Schema<RawValue, ParsedValue>): Property<RawKey, RawValue, ParsedValue>;
 export interface Property<RawKey extends string, RawValue, ParsedValue> {
     rawKey: RawKey;

package/dist/core/schemas/builders/object/types.d.ts

@@ -1,8 +1,8 @@
-import { BaseSchema, Schema, inferParsed, inferRaw } from "../../Schema";
-import { addQuestionMarksToNullableProperties } from "../../utils/addQuestionMarksToNullableProperties";
-import { ObjectLikeUtils } from "../object-like";
-import { SchemaUtils } from "../schema-utils";
-import { Property } from "./property";
+import type { BaseSchema, inferParsed, inferRaw, Schema } from "../../Schema";
+import type { addQuestionMarksToNullableProperties } from "../../utils/addQuestionMarksToNullableProperties";
+import type { ObjectLikeUtils } from "../object-like/index";
+import type { SchemaUtils } from "../schema-utils/index";
+import type { Property } from "./property";
 export type ObjectSchema<Raw, Parsed> = BaseObjectSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed> & ObjectUtils<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
 export interface BaseObjectSchema<Raw, Parsed> extends BaseSchema<Raw, Parsed> {
     _getRawProperties: () => (keyof Raw)[];

package/dist/core/schemas/builders/object-like/getObjectLikeUtils.d.ts

@@ -1,5 +1,5 @@
-import { BaseSchema } from "../../Schema";
-import { ObjectLikeSchema, ObjectLikeUtils } from "./types";
+import type { BaseSchema } from "../../Schema";
+import type { ObjectLikeSchema, ObjectLikeUtils } from "./types";
 export declare function getObjectLikeUtils<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): ObjectLikeUtils<Raw, Parsed>;
 /**
  * object-like utils are defined in one file to resolve issues with circular imports

package/dist/core/schemas/builders/object-like/types.d.ts

@@ -1,4 +1,4 @@
-import { BaseSchema, Schema } from "../../Schema";
+import type { BaseSchema, Schema } from "../../Schema";
 export type ObjectLikeSchema<Raw, Parsed> = Schema<Raw, Parsed> & BaseSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed>;
 export interface ObjectLikeUtils<Raw, Parsed> {
     withParsedProperties: <T extends Record<string, any>>(properties: {

package/dist/core/schemas/builders/primitives/any.d.ts

@@ -1 +1,2 @@
-export declare const any: () => import("../../Schema").Schema<any, any>;
+import { type Schema } from "../../Schema";
+export declare const any: () => Schema<any, any>;

package/dist/core/schemas/builders/primitives/boolean.d.ts

@@ -1 +1,2 @@
-export declare const boolean: () => import("../../Schema").Schema<boolean, boolean>;
+import { type Schema } from "../../Schema";
+export declare const boolean: () => Schema<boolean, boolean>;

package/dist/core/schemas/builders/primitives/index.d.ts

@@ -1,5 +1,6 @@
 export { any } from "./any";
 export { boolean } from "./boolean";
+export { never } from "./never";
 export { number } from "./number";
 export { string } from "./string";
 export { unknown } from "./unknown";

package/dist/core/schemas/builders/primitives/never.d.ts

@@ -0,0 +1,2 @@
+import { type Schema } from "../../Schema";
+export declare const never: () => Schema<never, never>;

package/dist/core/schemas/builders/primitives/number.d.ts

@@ -1 +1,2 @@
-export declare const number: () => import("../../Schema").Schema<number, number>;
+import { type Schema } from "../../Schema";
+export declare const number: () => Schema<number, number>;

package/dist/core/schemas/builders/primitives/string.d.ts

@@ -1 +1,2 @@
-export declare const string: () => import("../../Schema").Schema<string, string>;
+import { type Schema } from "../../Schema";
+export declare const string: () => Schema<string, string>;

package/dist/core/schemas/builders/primitives/unknown.d.ts

@@ -1 +1,2 @@
-export declare const unknown: () => import("../../Schema").Schema<unknown, unknown>;
+import { type Schema } from "../../Schema";
+export declare const unknown: () => Schema<unknown, unknown>;

package/dist/core/schemas/builders/record/record.d.ts

@@ -1,3 +1,3 @@
-import { Schema } from "../../Schema";
-import { RecordSchema } from "./types";
+import { type Schema } from "../../Schema";
+import type { RecordSchema } from "./types";
 export declare function record<RawKey extends string | number, RawValue, ParsedValue, ParsedKey extends string | number>(keySchema: Schema<RawKey, ParsedKey>, valueSchema: Schema<RawValue, ParsedValue>): RecordSchema<RawKey, RawValue, ParsedKey, ParsedValue>;

package/dist/core/schemas/builders/record/types.d.ts

@@ -1,4 +1,4 @@
-import { BaseSchema } from "../../Schema";
-import { SchemaUtils } from "../schema-utils";
+import type { BaseSchema } from "../../Schema";
+import type { SchemaUtils } from "../schema-utils/index";
 export type RecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseRecordSchema<RawKey, RawValue, ParsedKey, ParsedValue> & SchemaUtils<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;
 export type BaseRecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseSchema<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;

package/dist/core/schemas/builders/schema-utils/JsonError.d.ts

@@ -1,4 +1,4 @@
-import { ValidationError } from "../../Schema";
+import type { ValidationError } from "../../Schema";
 export declare class JsonError extends Error {
     readonly errors: ValidationError[];
     constructor(errors: ValidationError[]);

package/dist/core/schemas/builders/schema-utils/ParseError.d.ts

@@ -1,4 +1,4 @@
-import { ValidationError } from "../../Schema";
+import type { ValidationError } from "../../Schema";
 export declare class ParseError extends Error {
     readonly errors: ValidationError[];
     constructor(errors: ValidationError[]);

package/dist/core/schemas/builders/schema-utils/getSchemaUtils.d.ts

@@ -1,4 +1,4 @@
-import { BaseSchema, Schema, SchemaOptions } from "../../Schema";
+import { type BaseSchema, type Schema, type SchemaOptions } from "../../Schema";
 export interface SchemaUtils<Raw, Parsed> {
     nullable: () => Schema<Raw | null, Parsed | null>;
     optional: () => Schema<Raw | null | undefined, Parsed | undefined>;

package/dist/core/schemas/builders/schema-utils/index.d.ts

@@ -1,4 +1,4 @@
-export { getSchemaUtils, optional, transform } from "./getSchemaUtils";
 export type { SchemaUtils } from "./getSchemaUtils";
+export { getSchemaUtils, optional, transform } from "./getSchemaUtils";
 export { JsonError } from "./JsonError";
 export { ParseError } from "./ParseError";

package/dist/core/schemas/builders/schema-utils/stringifyValidationErrors.d.ts

@@ -1,2 +1,2 @@
-import { ValidationError } from "../../Schema";
+import type { ValidationError } from "../../Schema";
 export declare function stringifyValidationError(error: ValidationError): string;

package/dist/core/schemas/builders/set/set.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function set<Raw, Parsed>(schema: Schema<Raw, Parsed>): Schema<Raw[], Set<Parsed>>;

package/dist/core/schemas/builders/undiscriminated-union/types.d.ts

@@ -1,4 +1,4 @@
-import { Schema, inferParsed, inferRaw } from "../../Schema";
+import type { inferParsed, inferRaw, Schema } from "../../Schema";
 export type UndiscriminatedUnionSchema<Schemas extends [...Schema[]]> = Schema<inferRawUnidiscriminatedUnionSchema<Schemas>, inferParsedUnidiscriminatedUnionSchema<Schemas>>;
 export type inferRawUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferRaw<Schemas[number]>;
 export type inferParsedUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferParsed<Schemas[number]>;

package/dist/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.d.ts

@@ -1,3 +1,3 @@
-import { Schema } from "../../Schema";
-import { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema } from "./types";
+import { type Schema } from "../../Schema";
+import type { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema } from "./types";
 export declare function undiscriminatedUnion<Schemas extends [Schema<any, any>, ...Schema<any, any>[]]>(schemas: Schemas): Schema<inferRawUnidiscriminatedUnionSchema<Schemas>, inferParsedUnidiscriminatedUnionSchema<Schemas>>;

package/dist/core/schemas/builders/union/index.d.ts

@@ -1,4 +1,4 @@
-export { discriminant } from "./discriminant";
 export type { Discriminant } from "./discriminant";
+export { discriminant } from "./discriminant";
 export type { inferParsedDiscriminant, inferParsedUnion, inferRawDiscriminant, inferRawUnion, UnionSubtypes, } from "./types";
 export { union } from "./union";

package/dist/core/schemas/builders/union/types.d.ts

@@ -1,5 +1,5 @@
-import { ObjectSchema, inferParsedObject, inferRawObject } from "../object";
-import { Discriminant } from "./discriminant";
+import type { inferParsedObject, inferRawObject, ObjectSchema } from "../object/index";
+import type { Discriminant } from "./discriminant";
 export type UnionSubtypes<DiscriminantValues extends string | number | symbol> = {
     [K in DiscriminantValues]: ObjectSchema<any, any>;
 };

package/dist/core/schemas/builders/union/union.d.ts

@@ -1,4 +1,4 @@
-import { ObjectLikeSchema } from "../object-like";
-import { Discriminant } from "./discriminant";
-import { UnionSubtypes, inferParsedUnion, inferRawUnion } from "./types";
+import { type ObjectLikeSchema } from "../object-like";
+import type { Discriminant } from "./discriminant";
+import type { inferParsedUnion, inferRawUnion, UnionSubtypes } from "./types";
 export declare function union<D extends string | Discriminant<any, any>, U extends UnionSubtypes<any>>(discriminant: D, union: U): ObjectLikeSchema<inferRawUnion<D, U>, inferParsedUnion<D, U>>;

package/dist/core/schemas/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./builders";
+export * from "./builders/index";
 export type { inferParsed, inferRaw, Schema, SchemaOptions } from "./Schema";

package/dist/core/schemas/utils/createIdentitySchemaCreator.d.ts

@@ -1,2 +1,2 @@
-import { MaybeValid, Schema, SchemaOptions, SchemaType } from "../Schema";
+import type { MaybeValid, Schema, SchemaOptions, SchemaType } from "../Schema";
 export declare function createIdentitySchemaCreator<T>(schemaType: SchemaType, validate: (value: unknown, opts?: SchemaOptions) => MaybeValid<T>): () => Schema<T, T>;

package/dist/core/schemas/utils/maybeSkipValidation.d.ts

@@ -1,2 +1,2 @@
-import { BaseSchema } from "../Schema";
+import type { BaseSchema } from "../Schema";
 export declare function maybeSkipValidation<S extends BaseSchema<Raw, Parsed>, Raw, Parsed>(schema: S): S;

package/dist/core/url/encodePathParam.d.ts

@@ -0,0 +1 @@
+export declare function encodePathParam(param: unknown): string;

package/dist/core/url/index.d.ts

@@ -0,0 +1,3 @@
+export { encodePathParam } from "./encodePathParam";
+export { join } from "./join";
+export { toQueryString } from "./qs";

package/dist/core/url/join.d.ts

@@ -0,0 +1 @@
+export declare function join(base: string, ...segments: string[]): string;

package/dist/core/url/qs.d.ts

@@ -0,0 +1,6 @@
+interface QueryStringOptions {
+    arrayFormat?: "indices" | "repeat";
+    encode?: boolean;
+}
+export declare function toQueryString(obj: unknown, options?: QueryStringOptions): string;
+export {};

package/dist/environments.d.ts

@@ -1,6 +1,3 @@
-/**
- * This file was auto-generated by Fern from our API Definition.
- */
 export declare const SchematicEnvironment: {
     readonly Default: "https://api.schematichq.com";
 };

package/dist/errors/SchematicError.d.ts

@@ -1,7 +1,4 @@
-/**
- * This file was auto-generated by Fern from our API Definition.
- */
-import * as core from "../core";
+import type * as core from "../core";
 export declare class SchematicError extends Error {
     readonly statusCode?: number;
     readonly body?: unknown;

package/dist/errors/SchematicTimeoutError.d.ts

@@ -1,6 +1,3 @@
-/**
- * This file was auto-generated by Fern from our API Definition.
- */
 export declare class SchematicTimeoutError extends Error {
     constructor(message: string);
 }

package/dist/errors/handleNonStatusCodeError.d.ts

@@ -0,0 +1,2 @@
+import type * as core from "../core";
+export declare function handleNonStatusCodeError(error: core.Fetcher.Error, rawResponse: core.RawResponse, method: string, path: string): never;

package/dist/events.d.ts

@@ -1,5 +1,5 @@
 import { CreateEventRequestBody } from "./api";
-import { Events } from "./api/resources/events/client/Client";
+import { EventsClient } from "./api/resources/events/client/Client";
 import { Logger } from "./logger";
 interface EventBufferOptions {
     interval?: number;
@@ -22,7 +22,7 @@ declare class EventBuffer {
     private shutdown;
     private stopped;
     private flushing;
-    constructor(eventsApi: Events, opts?: EventBufferOptions);
+    constructor(eventsApi: EventsClient, opts?: EventBufferOptions);
     flush(): Promise<void>;
     push(event: CreateEventRequestBody): Promise<void>;
     stop(): Promise<void>;

package/dist/exports.d.ts

@@ -0,0 +1 @@
+export * from "./core/exports";