busroot-sdk 0.0.1 → 0.0.2

package/build/client.d.ts

@@ -1,4 +1,4 @@
-import { PlantSchema, PlantViewModel, ScheduleViewModel, BusrootSignals, SkuViewModel, StationSchema, StationViewModel, AccountViewModel, ApiKeyViewModel } from "../build/common";
+import { PlantSchema, PlantViewModel, ScheduleViewModel, BusrootSignals, SkuViewModel, StationSchema, StationViewModel, AccountViewModel, ApiKeyViewModel } from "./common";
 import mqtt from "mqtt/dist/mqtt.esm";
 export declare const MqttEventType: {
     StationMetricNew: string;
@@ -60,4 +60,3 @@ declare class Client {
     off(event: MqttEventType, listener: Listener): void;
 }
 export { Client };
-//# sourceMappingURL=client.d.ts.map

package/build/client.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=client.test.d.ts.map

package/build/common.d.ts

@@ -1,701 +1,4 @@
-type Primitive = string | number | symbol | bigint | boolean | null | undefined;
-
-declare namespace util {
-    type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
-    export type isAny<T> = 0 extends 1 & T ? true : false;
-    export const assertEqual: <A, B>(_: AssertEqual<A, B>) => void;
-    export function assertIs<T>(_arg: T): void;
-    export function assertNever(_x: never): never;
-    export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
-    export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
-    export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-    export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
-    export type InexactPartial<T> = {
-        [k in keyof T]?: T[k] | undefined;
-    };
-    export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k; };
-    export const getValidEnumValues: (obj: any) => any[];
-    export const objectValues: (obj: any) => any[];
-    export const objectKeys: ObjectConstructor["keys"];
-    export const find: <T>(arr: T[], checker: (arg: T) => any) => T | undefined;
-    export type identity<T> = objectUtil.identity<T>;
-    export type flatten<T> = objectUtil.flatten<T>;
-    export type noUndefined<T> = T extends undefined ? never : T;
-    export const isInteger: NumberConstructor["isInteger"];
-    export function joinValues<T extends any[]>(array: T, separator?: string): string;
-    export const jsonStringifyReplacer: (_: string, value: any) => any;
-    export {};
-}
-declare namespace objectUtil {
-    export type MergeShapes<U, V> = keyof U & keyof V extends never ? U & V : {
-        [k in Exclude<keyof U, keyof V>]: U[k];
-    } & V;
-    type optionalKeys<T extends object> = {
-        [k in keyof T]: undefined extends T[k] ? k : never;
-    }[keyof T];
-    type requiredKeys<T extends object> = {
-        [k in keyof T]: undefined extends T[k] ? never : k;
-    }[keyof T];
-    export type addQuestionMarks<T extends object, _O = any> = {
-        [K in requiredKeys<T>]: T[K];
-    } & {
-        [K in optionalKeys<T>]?: T[K];
-    } & {
-        [k in keyof T]?: unknown;
-    };
-    export type identity<T> = T;
-    export type flatten<T> = identity<{
-        [k in keyof T]: T[k];
-    }>;
-    export type noNeverKeys<T> = {
-        [k in keyof T]: [T[k]] extends [never] ? never : k;
-    }[keyof T];
-    export type noNever<T> = identity<{
-        [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never;
-    }>;
-    export const mergeShapes: <U, T>(first: U, second: T) => T & U;
-    export type extendShape<A extends object, B extends object> = keyof A & keyof B extends never ? A & B : {
-        [K in keyof A as K extends keyof B ? never : K]: A[K];
-    } & {
-        [K in keyof B]: B[K];
-    };
-    export {};
-}
-declare const ZodParsedType: {
-    string: "string";
-    nan: "nan";
-    number: "number";
-    integer: "integer";
-    float: "float";
-    boolean: "boolean";
-    date: "date";
-    bigint: "bigint";
-    symbol: "symbol";
-    function: "function";
-    undefined: "undefined";
-    null: "null";
-    array: "array";
-    object: "object";
-    unknown: "unknown";
-    promise: "promise";
-    void: "void";
-    never: "never";
-    map: "map";
-    set: "set";
-};
-type ZodParsedType = keyof typeof ZodParsedType;
-
-type allKeys<T> = T extends any ? keyof T : never;
-type typeToFlattenedError<T, U = string> = {
-    formErrors: U[];
-    fieldErrors: {
-        [P in allKeys<T>]?: U[];
-    };
-};
-declare const ZodIssueCode: {
-    invalid_type: "invalid_type";
-    invalid_literal: "invalid_literal";
-    custom: "custom";
-    invalid_union: "invalid_union";
-    invalid_union_discriminator: "invalid_union_discriminator";
-    invalid_enum_value: "invalid_enum_value";
-    unrecognized_keys: "unrecognized_keys";
-    invalid_arguments: "invalid_arguments";
-    invalid_return_type: "invalid_return_type";
-    invalid_date: "invalid_date";
-    invalid_string: "invalid_string";
-    too_small: "too_small";
-    too_big: "too_big";
-    invalid_intersection_types: "invalid_intersection_types";
-    not_multiple_of: "not_multiple_of";
-    not_finite: "not_finite";
-};
-type ZodIssueCode = keyof typeof ZodIssueCode;
-type ZodIssueBase = {
-    path: (string | number)[];
-    message?: string | undefined;
-};
-interface ZodInvalidTypeIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_type;
-    expected: ZodParsedType;
-    received: ZodParsedType;
-}
-interface ZodInvalidLiteralIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_literal;
-    expected: unknown;
-    received: unknown;
-}
-interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.unrecognized_keys;
-    keys: string[];
-}
-interface ZodInvalidUnionIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_union;
-    unionErrors: ZodError[];
-}
-interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_union_discriminator;
-    options: Primitive[];
-}
-interface ZodInvalidEnumValueIssue extends ZodIssueBase {
-    received: string | number;
-    code: typeof ZodIssueCode.invalid_enum_value;
-    options: (string | number)[];
-}
-interface ZodInvalidArgumentsIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_arguments;
-    argumentsError: ZodError;
-}
-interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_return_type;
-    returnTypeError: ZodError;
-}
-interface ZodInvalidDateIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_date;
-}
-type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "cidr" | "base64" | "jwt" | "base64url" | {
-    includes: string;
-    position?: number | undefined;
-} | {
-    startsWith: string;
-} | {
-    endsWith: string;
-};
-interface ZodInvalidStringIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_string;
-    validation: StringValidation;
-}
-interface ZodTooSmallIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.too_small;
-    minimum: number | bigint;
-    inclusive: boolean;
-    exact?: boolean;
-    type: "array" | "string" | "number" | "set" | "date" | "bigint";
-}
-interface ZodTooBigIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.too_big;
-    maximum: number | bigint;
-    inclusive: boolean;
-    exact?: boolean;
-    type: "array" | "string" | "number" | "set" | "date" | "bigint";
-}
-interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_intersection_types;
-}
-interface ZodNotMultipleOfIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.not_multiple_of;
-    multipleOf: number | bigint;
-}
-interface ZodNotFiniteIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.not_finite;
-}
-interface ZodCustomIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.custom;
-    params?: {
-        [k: string]: any;
-    };
-}
-type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
-type ZodIssue = ZodIssueOptionalMessage & {
-    fatal?: boolean | undefined;
-    message: string;
-};
-type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? {
-    [K in keyof T]?: ZodFormattedError<T[K]>;
-} : T extends any[] ? {
-    [k: number]: ZodFormattedError<T[number]>;
-} : T extends object ? {
-    [K in keyof T]?: ZodFormattedError<T[K]>;
-} : unknown;
-type ZodFormattedError<T, U = string> = {
-    _errors: U[];
-} & recursiveZodFormattedError<NonNullable<T>>;
-declare class ZodError<T = any> extends Error {
-    issues: ZodIssue[];
-    get errors(): ZodIssue[];
-    constructor(issues: ZodIssue[]);
-    format(): ZodFormattedError<T>;
-    format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
-    static create: (issues: ZodIssue[]) => ZodError<any>;
-    static assert(value: unknown): asserts value is ZodError;
-    toString(): string;
-    get message(): string;
-    get isEmpty(): boolean;
-    addIssue: (sub: ZodIssue) => void;
-    addIssues: (subs?: ZodIssue[]) => void;
-    flatten(): typeToFlattenedError<T>;
-    flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
-    get formErrors(): typeToFlattenedError<T, string>;
-}
-type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
-type IssueData = stripPath<ZodIssueOptionalMessage> & {
-    path?: (string | number)[];
-    fatal?: boolean | undefined;
-};
-type ErrorMapCtx = {
-    defaultError: string;
-    data: any;
-};
-type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
-    message: string;
-};
-
-type ParseParams = {
-    path: (string | number)[];
-    errorMap: ZodErrorMap;
-    async: boolean;
-};
-type ParsePathComponent = string | number;
-type ParsePath = ParsePathComponent[];
-interface ParseContext {
-    readonly common: {
-        readonly issues: ZodIssue[];
-        readonly contextualErrorMap?: ZodErrorMap | undefined;
-        readonly async: boolean;
-    };
-    readonly path: ParsePath;
-    readonly schemaErrorMap?: ZodErrorMap | undefined;
-    readonly parent: ParseContext | null;
-    readonly data: any;
-    readonly parsedType: ZodParsedType;
-}
-type ParseInput = {
-    data: any;
-    path: (string | number)[];
-    parent: ParseContext;
-};
-declare class ParseStatus {
-    value: "aborted" | "dirty" | "valid";
-    dirty(): void;
-    abort(): void;
-    static mergeArray(status: ParseStatus, results: SyncParseReturnType<any>[]): SyncParseReturnType;
-    static mergeObjectAsync(status: ParseStatus, pairs: {
-        key: ParseReturnType<any>;
-        value: ParseReturnType<any>;
-    }[]): Promise<SyncParseReturnType<any>>;
-    static mergeObjectSync(status: ParseStatus, pairs: {
-        key: SyncParseReturnType<any>;
-        value: SyncParseReturnType<any>;
-        alwaysSet?: boolean;
-    }[]): SyncParseReturnType;
-}
-type INVALID = {
-    status: "aborted";
-};
-declare const INVALID: INVALID;
-type DIRTY<T> = {
-    status: "dirty";
-    value: T;
-};
-declare const DIRTY: <T>(value: T) => DIRTY<T>;
-type OK<T> = {
-    status: "valid";
-    value: T;
-};
-declare const OK: <T>(value: T) => OK<T>;
-type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
-type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
-type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
-
-declare namespace errorUtil {
-    type ErrMessage = string | {
-        message?: string | undefined;
-    };
-    const errToObj: (message?: ErrMessage) => {
-        message?: string | undefined;
-    };
-    const toString: (message?: ErrMessage) => string | undefined;
-}
-
-/**
- * The Standard Schema interface.
- */
-type StandardSchemaV1<Input = unknown, Output = Input> = {
-    /**
-     * The Standard Schema properties.
-     */
-    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
-};
-declare namespace StandardSchemaV1 {
-    /**
-     * The Standard Schema properties interface.
-     */
-    export interface Props<Input = unknown, Output = Input> {
-        /**
-         * The version number of the standard.
-         */
-        readonly version: 1;
-        /**
-         * The vendor name of the schema library.
-         */
-        readonly vendor: string;
-        /**
-         * Validates unknown input values.
-         */
-        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-        /**
-         * Inferred types associated with the schema.
-         */
-        readonly types?: Types<Input, Output> | undefined;
-    }
-    /**
-     * The result interface of the validate function.
-     */
-    export type Result<Output> = SuccessResult<Output> | FailureResult;
-    /**
-     * The result interface if validation succeeds.
-     */
-    export interface SuccessResult<Output> {
-        /**
-         * The typed output value.
-         */
-        readonly value: Output;
-        /**
-         * The non-existent issues.
-         */
-        readonly issues?: undefined;
-    }
-    /**
-     * The result interface if validation fails.
-     */
-    export interface FailureResult {
-        /**
-         * The issues of failed validation.
-         */
-        readonly issues: ReadonlyArray<Issue>;
-    }
-    /**
-     * The issue interface of the failure output.
-     */
-    export interface Issue {
-        /**
-         * The error message of the issue.
-         */
-        readonly message: string;
-        /**
-         * The path of the issue, if any.
-         */
-        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-    }
-    /**
-     * The path segment interface of the issue.
-     */
-    export interface PathSegment {
-        /**
-         * The key representing a path segment.
-         */
-        readonly key: PropertyKey;
-    }
-    /**
-     * The Standard Schema types interface.
-     */
-    export interface Types<Input = unknown, Output = Input> {
-        /**
-         * The input type of the schema.
-         */
-        readonly input: Input;
-        /**
-         * The output type of the schema.
-         */
-        readonly output: Output;
-    }
-    /**
-     * Infers the input type of a Standard Schema.
-     */
-    export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-    /**
-     * Infers the output type of a Standard Schema.
-     */
-    export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-    export {};
-}
-
-interface RefinementCtx {
-    addIssue: (arg: IssueData) => void;
-    path: (string | number)[];
-}
-type ZodTypeAny = ZodType<any, any, any>;
-type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
-type input<T extends ZodType<any, any, any>> = T["_input"];
-type output<T extends ZodType<any, any, any>> = T["_output"];
-
-type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
-interface ZodTypeDef {
-    errorMap?: ZodErrorMap | undefined;
-    description?: string | undefined;
-}
-type RawCreateParams = {
-    errorMap?: ZodErrorMap | undefined;
-    invalid_type_error?: string | undefined;
-    required_error?: string | undefined;
-    message?: string | undefined;
-    description?: string | undefined;
-} | undefined;
-type SafeParseSuccess<Output> = {
-    success: true;
-    data: Output;
-    error?: never;
-};
-type SafeParseError<Input> = {
-    success: false;
-    error: ZodError<Input>;
-    data?: never;
-};
-type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
-declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
-    readonly _type: Output;
-    readonly _output: Output;
-    readonly _input: Input;
-    readonly _def: Def;
-    get description(): string | undefined;
-    "~standard": StandardSchemaV1.Props<Input, Output>;
-    abstract _parse(input: ParseInput): ParseReturnType<Output>;
-    _getType(input: ParseInput): string;
-    _getOrReturnCtx(input: ParseInput, ctx?: ParseContext | undefined): ParseContext;
-    _processInputParams(input: ParseInput): {
-        status: ParseStatus;
-        ctx: ParseContext;
-    };
-    _parseSync(input: ParseInput): SyncParseReturnType<Output>;
-    _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
-    parse(data: unknown, params?: util.InexactPartial<ParseParams>): Output;
-    safeParse(data: unknown, params?: util.InexactPartial<ParseParams>): SafeParseReturnType<Input, Output>;
-    "~validate"(data: unknown): StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>;
-    parseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<Output>;
-    safeParseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
-    /** Alias of safeParseAsync */
-    spa: (data: unknown, params?: util.InexactPartial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
-    refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;
-    refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
-    refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;
-    refinement(check: (arg: Output) => boolean, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, Output, Input>;
-    _refinement(refinement: RefinementEffect<Output>["refinement"]): ZodEffects<this, Output, Input>;
-    superRefine<RefinedOutput extends Output>(refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput): ZodEffects<this, RefinedOutput, Input>;
-    superRefine(refinement: (arg: Output, ctx: RefinementCtx) => void): ZodEffects<this, Output, Input>;
-    superRefine(refinement: (arg: Output, ctx: RefinementCtx) => Promise<void>): ZodEffects<this, Output, Input>;
-    constructor(def: Def);
-    optional(): ZodOptional<this>;
-    nullable(): ZodNullable<this>;
-    nullish(): ZodOptional<ZodNullable<this>>;
-    array(): ZodArray<this>;
-    promise(): ZodPromise<this>;
-    or<T extends ZodTypeAny>(option: T): ZodUnion<[this, T]>;
-    and<T extends ZodTypeAny>(incoming: T): ZodIntersection<this, T>;
-    transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;
-    default(def: util.noUndefined<Input>): ZodDefault<this>;
-    default(def: () => util.noUndefined<Input>): ZodDefault<this>;
-    brand<B extends string | number | symbol>(brand?: B): ZodBranded<this, B>;
-    catch(def: Output): ZodCatch<this>;
-    catch(def: (ctx: {
-        error: ZodError;
-        input: Input;
-    }) => Output): ZodCatch<this>;
-    describe(description: string): this;
-    pipe<T extends ZodTypeAny>(target: T): ZodPipeline<this, T>;
-    readonly(): ZodReadonly<this>;
-    isOptional(): boolean;
-    isNullable(): boolean;
-}
-interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    type: T;
-    typeName: ZodFirstPartyTypeKind.ZodArray;
-    exactLength: {
-        value: number;
-        message?: string | undefined;
-    } | null;
-    minLength: {
-        value: number;
-        message?: string | undefined;
-    } | null;
-    maxLength: {
-        value: number;
-        message?: string | undefined;
-    } | null;
-}
-type ArrayCardinality = "many" | "atleastone";
-type arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [T["_output"], ...T["_output"][]] : T["_output"][];
-declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> extends ZodType<arrayOutputType<T, Cardinality>, ZodArrayDef<T>, Cardinality extends "atleastone" ? [T["_input"], ...T["_input"][]] : T["_input"][]> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    get element(): T;
-    min(minLength: number, message?: errorUtil.ErrMessage): this;
-    max(maxLength: number, message?: errorUtil.ErrMessage): this;
-    length(len: number, message?: errorUtil.ErrMessage): this;
-    nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
-    static create: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
-}
-type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
-interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>> extends ZodTypeDef {
-    options: T;
-    typeName: ZodFirstPartyTypeKind.ZodUnion;
-}
-declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    get options(): T;
-    static create: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
-}
-interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    left: T;
-    right: U;
-    typeName: ZodFirstPartyTypeKind.ZodIntersection;
-}
-declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
-}
-interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    type: T;
-    typeName: ZodFirstPartyTypeKind.ZodPromise;
-}
-declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {
-    unwrap(): T;
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
-}
-type RefinementEffect<T> = {
-    type: "refinement";
-    refinement: (arg: T, ctx: RefinementCtx) => any;
-};
-type TransformEffect<T> = {
-    type: "transform";
-    transform: (arg: T, ctx: RefinementCtx) => any;
-};
-type PreprocessEffect<T> = {
-    type: "preprocess";
-    transform: (arg: T, ctx: RefinementCtx) => any;
-};
-type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;
-interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    schema: T;
-    typeName: ZodFirstPartyTypeKind.ZodEffects;
-    effect: Effect<any>;
-}
-declare class ZodEffects<T extends ZodTypeAny, Output = output<T>, Input = input<T>> extends ZodType<Output, ZodEffectsDef<T>, Input> {
-    innerType(): T;
-    sourceType(): T;
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
-    static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
-}
-
-interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    innerType: T;
-    typeName: ZodFirstPartyTypeKind.ZodOptional;
-}
-declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    unwrap(): T;
-    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
-}
-interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    innerType: T;
-    typeName: ZodFirstPartyTypeKind.ZodNullable;
-}
-declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    unwrap(): T;
-    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
-}
-interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    innerType: T;
-    defaultValue: () => util.noUndefined<T["_input"]>;
-    typeName: ZodFirstPartyTypeKind.ZodDefault;
-}
-declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    removeDefault(): T;
-    static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
-        default: Inner["_input"] | (() => util.noUndefined<Inner["_input"]>);
-    }) => ZodDefault<Inner>;
-}
-interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    innerType: T;
-    catchValue: (ctx: {
-        error: ZodError;
-        input: unknown;
-    }) => T["_input"];
-    typeName: ZodFirstPartyTypeKind.ZodCatch;
-}
-declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    removeCatch(): T;
-    static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
-        catch: Inner["_output"] | (() => Inner["_output"]);
-    }) => ZodCatch<Inner>;
-}
-interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
-    type: T;
-    typeName: ZodFirstPartyTypeKind.ZodBranded;
-}
-declare const BRAND: unique symbol;
-type BRAND<T extends string | number | symbol> = {
-    [BRAND]: {
-        [k in T]: true;
-    };
-};
-declare class ZodBranded<T extends ZodTypeAny, B extends string | number | symbol> extends ZodType<T["_output"] & BRAND<B>, ZodBrandedDef<T>, T["_input"]> {
-    _parse(input: ParseInput): ParseReturnType<any>;
-    unwrap(): T;
-}
-interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodTypeDef {
-    in: A;
-    out: B;
-    typeName: ZodFirstPartyTypeKind.ZodPipeline;
-}
-declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {
-    _parse(input: ParseInput): ParseReturnType<any>;
-    static create<ASchema extends ZodTypeAny, BSchema extends ZodTypeAny>(a: ASchema, b: BSchema): ZodPipeline<ASchema, BSchema>;
-}
-type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
-    readonly [Symbol.toStringTag]: string;
-} | Date | Error | Generator | Promise<unknown> | RegExp;
-type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
-interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    innerType: T;
-    typeName: ZodFirstPartyTypeKind.ZodReadonly;
-}
-declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["_output"]>, ZodReadonlyDef<T>, MakeReadonly<T["_input"]>> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodReadonly<Inner>;
-    unwrap(): T;
-}
-declare enum ZodFirstPartyTypeKind {
-    ZodString = "ZodString",
-    ZodNumber = "ZodNumber",
-    ZodNaN = "ZodNaN",
-    ZodBigInt = "ZodBigInt",
-    ZodBoolean = "ZodBoolean",
-    ZodDate = "ZodDate",
-    ZodSymbol = "ZodSymbol",
-    ZodUndefined = "ZodUndefined",
-    ZodNull = "ZodNull",
-    ZodAny = "ZodAny",
-    ZodUnknown = "ZodUnknown",
-    ZodNever = "ZodNever",
-    ZodVoid = "ZodVoid",
-    ZodArray = "ZodArray",
-    ZodObject = "ZodObject",
-    ZodUnion = "ZodUnion",
-    ZodDiscriminatedUnion = "ZodDiscriminatedUnion",
-    ZodIntersection = "ZodIntersection",
-    ZodTuple = "ZodTuple",
-    ZodRecord = "ZodRecord",
-    ZodMap = "ZodMap",
-    ZodSet = "ZodSet",
-    ZodFunction = "ZodFunction",
-    ZodLazy = "ZodLazy",
-    ZodLiteral = "ZodLiteral",
-    ZodEnum = "ZodEnum",
-    ZodEffects = "ZodEffects",
-    ZodNativeEnum = "ZodNativeEnum",
-    ZodOptional = "ZodOptional",
-    ZodNullable = "ZodNullable",
-    ZodDefault = "ZodDefault",
-    ZodCatch = "ZodCatch",
-    ZodPromise = "ZodPromise",
-    ZodBranded = "ZodBranded",
-    ZodPipeline = "ZodPipeline",
-    ZodReadonly = "ZodReadonly"
-}
+import { z } from 'zod';
 
 interface BusrootSignals {
   timestamp?: number;
@@ -784,7 +87,7 @@ declare const StationSchema = z.object({
   archivedAt: z.string().nullish(),
 });
 
-type StationSchema = TypeOf<typeof StationSchema>;
+type StationSchema = z.infer<typeof StationSchema>;
 
 declare const ApiKeySchema = z.object({
   accountId: z.string(),
@@ -794,7 +97,7 @@ declare const ApiKeySchema = z.object({
   createdAt: z.string().optional(),
   updatedAt: z.string().optional(),
 });
-type ApiKeySchema = TypeOf<typeof ApiKeySchema>;
+type ApiKeySchema = z.infer<typeof ApiKeySchema>;
 
 declare const PlantViewModel = z.object({
   code: z.string(),
@@ -805,7 +108,7 @@ declare const PlantViewModel = z.object({
   dayStartHour: z.number(),
 });
 
-type PlantViewModel = TypeOf<typeof PlantViewModel>;
+type PlantViewModel = z.infer<typeof PlantViewModel>;
 
 declare const SkuViewModel = z.object({
   code: z.string(),
@@ -822,7 +125,7 @@ declare const SkuViewModel = z.object({
   value: z.number().nullish(),
   minimumCycleTime: z.number().nullish(),
 });
-type SkuViewModel = TypeOf<typeof SkuViewModel>;
+type SkuViewModel = z.infer<typeof SkuViewModel>;
 
 type ApiKeyViewModel = ApiKeySchema;
 
@@ -881,7 +184,7 @@ declare const ScheduleViewModel = z.object({
   priorityAt: z.string().optional(),
 });
 
-type ScheduleViewModel = TypeOf<typeof ScheduleViewModel>;
+type ScheduleViewModel = z.infer<typeof ScheduleViewModel>;
 
 declare const StationViewModel = z.object({
   code: z.string(), // from station table
@@ -943,7 +246,7 @@ declare const StationViewModel = z.object({
   lastStationWindow: StationWindowViewModel.nullish(),
 });
 
-type StationViewModel = TypeOf<typeof StationViewModel>;
+type StationViewModel = z.infer<typeof StationViewModel>;
 
 declare const AccountViewModel = AccountSchema.merge(
   z.object({
@@ -967,7 +270,7 @@ declare const AccountViewModel = AccountSchema.merge(
   }),
 );
 
-type AccountViewModel = TypeOf<typeof AccountViewModel>;
+type AccountViewModel = z.infer<typeof AccountViewModel>;
 
 export { AccountViewModel, PlantViewModel, ScheduleViewModel, SkuViewModel, StationSchema, StationViewModel };
 export type { ApiKeyViewModel, BusrootSignals, PlantSchema };

package/build/example.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=example.d.ts.map

package/build/hooks.d.ts

@@ -5,16 +5,15 @@ export declare const ConfigPayloadSchema: z.ZodObject<{
     apiKey: z.ZodString;
     host: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    host: string;
     accountId: string;
+    host: string;
     apiKey: string;
 }, {
-    host: string;
     accountId: string;
+    host: string;
     apiKey: string;
 }>;
 export declare function useBusroot(): {
     client: Client | undefined;
     logout: () => void;
 };
-//# sourceMappingURL=hooks.d.ts.map

package/build/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./client";
 export * from "./hooks";
-//# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "busroot-sdk",
-  "version": "0.0.1",
-  "description": "An SDK for accessing Busroot.",
+  "version": "0.0.2",
+  "description": "An SDK for accessing Busroot from output.industries",
   "homepage": "https://www.output.industries",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -9,7 +9,7 @@
   "scripts": {
     "example": "ts-node -r dotenv-expand/config ./src/example.ts",
     "dev": "pnpm run lint && tsc -b --watch",
-    "build": "pnpm rollup && pnpm run lint && tsc -b --verbose",
+    "build": "pnpm run lint && tsc --build --clean && tsc --build && pnpm run rollup",
     "lint": "eslint 'src/**/*.ts'",
     "test": "jest",
     "rollup": "rollup -c"

package/build/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,cAAc,EACd,iBAAiB,EACjB,cAAc,EACd,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EAChB,MAAM,iBAAiB,CAAC;AACzB,OAAO,IAAI,MAAM,oBAAoB,CAAC;AAEtC,eAAO,MAAM,aAAa;;;;;;;CAOzB,CAAC;AACF,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,aAAa,CAAC;AAEvD,MAAM,MAAM,QAAQ,GAAG,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,CAAC;AAS1C,cAAM,MAAM;IAKS,MAAM,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;IAJ9E,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC;IAC5B,oBAAoB,wIAAwD;IAC5E,MAAM,EAAE,MAAM,CAAC;gBAEI,MAAM,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;IA4C9E,OAAO;YAIO,GAAG;YAyBH,IAAI;IAYlB,IAAI,OAAO;;MAQV;IAED,IAAI,OAAO;yBAEgB,MAAM,aAAa,MAAM,KAAG,OAAO,CAAC;YAAE,OAAO,EAAE,gBAAgB,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC;MAM5G;IAED,IAAI,MAAM;sBAEY,OAAO,CAAC,eAAe,CAAC;MAM7C;IAED,IAAI,KAAK;yBAEkB,MAAM,KAAG,OAAO,CAAC,cAAc,CAAC;gCAKzB,OAAO,CAAC,WAAW,CAAC,KAAG,OAAO,CAAC,cAAc,CAAC;MAM/E;IAED,IAAI,OAAO;2BAEkB,MAAM,KAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;gCAK/B,OAAO,CAAC,aAAa,CAAC,KAAG,OAAO,CAAC,gBAAgB,CAAC;8BAK1D,MAAM,WAAW,cAAc,KAAG,IAAI;MAI/D;IAED,GAAG;uBACoB,MAAM,KAAG,OAAO,CAAC,YAAY,CAAC;4BAKzB,OAAO,CAAC,YAAY,CAAC,KAAG,OAAO,CAAC,YAAY,CAAC;MAKvE;IAEF,QAAQ;0BACkB,MAAM,KAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;iCAK9B,OAAO,CAAC,iBAAiB,CAAC,KAAG,OAAO,CAAC,iBAAiB,CAAC;MAKtF;IAEF,EAAE,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,QAAQ;IAU3C,GAAG,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,QAAQ;CAW7C;AAED,OAAO,EAAE,MAAM,EAAE,CAAC"}

package/build/client.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.test.d.ts","sourceRoot":"","sources":["../src/client.test.ts"],"names":[],"mappings":""}

package/build/example.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"example.d.ts","sourceRoot":"","sources":["../src/example.ts"],"names":[],"mappings":""}

package/build/hooks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,CAAC,MAAM,KAAK,CAAC;AAKpB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAI9B,CAAC;AAEH,wBAAgB,UAAU;;;EA6BzB"}

package/build/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC"}