@cossistant/react 0.0.6 → 0.0.8

package/errors.d.ts

@@ -0,0 +1,121 @@
+import { Flatten, MakePartial, Primitive } from "./util.js";
+import { $ZodType } from "./schemas.js";
+import { $ZodCheck, $ZodStringFormats } from "./checks.js";
+import { $constructor } from "./core.js";
+
+//#region ../../node_modules/.bun/zod@4.1.12/node_modules/zod/v4/core/errors.d.cts
+interface $ZodIssueBase {
+  readonly code?: string;
+  readonly input?: unknown;
+  readonly path: PropertyKey[];
+  readonly message: string;
+}
+interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_type";
+  readonly expected: $ZodType["_zod"]["def"]["type"];
+  readonly input?: Input;
+}
+interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
+  readonly code: "too_big";
+  readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
+  readonly maximum: number | bigint;
+  readonly inclusive?: boolean;
+  readonly exact?: boolean;
+  readonly input?: Input;
+}
+interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
+  readonly code: "too_small";
+  readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
+  readonly minimum: number | bigint;
+  /** True if the allowable range includes the minimum */
+  readonly inclusive?: boolean;
+  /** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
+  readonly exact?: boolean;
+  readonly input?: Input;
+}
+interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
+  readonly code: "invalid_format";
+  readonly format: $ZodStringFormats | (string & {});
+  readonly pattern?: string;
+  readonly input?: string;
+}
+interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
+  readonly code: "not_multiple_of";
+  readonly divisor: number;
+  readonly input?: Input;
+}
+interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
+  readonly code: "unrecognized_keys";
+  readonly keys: string[];
+  readonly input?: Record<string, unknown>;
+}
+interface $ZodIssueInvalidUnion extends $ZodIssueBase {
+  readonly code: "invalid_union";
+  readonly errors: $ZodIssue[][];
+  readonly input?: unknown;
+  readonly discriminator?: string | undefined;
+}
+interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_key";
+  readonly origin: "map" | "record";
+  readonly issues: $ZodIssue[];
+  readonly input?: Input;
+}
+interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_element";
+  readonly origin: "map" | "set";
+  readonly key: unknown;
+  readonly issues: $ZodIssue[];
+  readonly input?: Input;
+}
+interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_value";
+  readonly values: Primitive[];
+  readonly input?: Input;
+}
+interface $ZodIssueCustom extends $ZodIssueBase {
+  readonly code: "custom";
+  readonly params?: Record<string, any> | undefined;
+  readonly input?: unknown;
+}
+type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
+type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
+type RawIssue<T extends $ZodIssueBase> = T extends any ? Flatten<MakePartial<T, "message" | "path"> & {
+  /** The input data */
+  readonly input: unknown;
+  /** The schema or check that originated this issue. */
+  readonly inst?: $ZodType | $ZodCheck;
+  /** If `true`, Zod will continue executing checks/refinements after this issue. */
+  readonly continue?: boolean | undefined;
+} & Record<string, unknown>> : never;
+type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;
+interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
+  (issue: $ZodRawIssue<T>): {
+    message: string;
+  } | string | undefined | null;
+}
+interface $ZodError<T = unknown> extends Error {
+  type: T;
+  issues: $ZodIssue[];
+  _zod: {
+    output: T;
+    def: $ZodIssue[];
+  };
+  stack?: string;
+  name: string;
+}
+declare const $ZodError: $constructor<$ZodError>;
+type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;
+type _FlattenedError<T, U = string> = {
+  formErrors: U[];
+  fieldErrors: { [P in keyof T]?: U[] };
+};
+type _ZodFormattedError<T, U = string> = T extends [any, ...any[]] ? { [K in keyof T]?: $ZodFormattedError<T[K], U> } : T extends any[] ? {
+  [k: number]: $ZodFormattedError<T[number], U>;
+} : T extends object ? Flatten<{ [K in keyof T]?: $ZodFormattedError<T[K], U> }> : any;
+type $ZodFormattedError<T, U = string> = {
+  _errors: U[];
+} & Flatten<_ZodFormattedError<T, U>>;
+//#endregion
+export { $ZodError, $ZodErrorMap, $ZodFlattenedError, $ZodFormattedError, $ZodIssue, $ZodIssueBase, $ZodIssueInvalidKey, $ZodIssueInvalidStringFormat, $ZodIssueInvalidType, $ZodIssueInvalidUnion, $ZodIssueInvalidValue, $ZodIssueNotMultipleOf, $ZodIssueTooBig, $ZodIssueTooSmall, $ZodIssueUnrecognizedKeys, $ZodRawIssue };
+//# sourceMappingURL=errors.d.ts.map

package/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","names":["$ZodCheck","$ZodStringFormats","$constructor","$ZodType","StandardSchemaV1","util","$ZodIssueBase","PropertyKey","$ZodIssueInvalidType","Input","$ZodIssueTooBig","$ZodIssueTooSmall","$ZodIssueInvalidStringFormat","$ZodIssueNotMultipleOf","$ZodIssueUnrecognizedKeys","Record","$ZodIssueInvalidUnion","$ZodIssue","$ZodIssueInvalidKey","$ZodIssueInvalidElement","$ZodIssueInvalidValue","Primitive","$ZodIssueCustom","$ZodIssueStringCommonFormats","Exclude","$ZodIssueStringInvalidRegex","$ZodIssueStringInvalidJWT","$ZodIssueStringStartsWith","$ZodIssueStringEndsWith","$ZodIssueStringIncludes","$ZodStringFormatIssues","$ZodIssueCode","$ZodInternalIssue","T","RawIssue","MakePartial","Flatten","$ZodRawIssue","$ZodErrorMap","$ZodError","Error","$ZodRealError","$ZodFlattenedError","U","_FlattenedError","flattenError","_ZodFormattedError","K","$ZodFormattedError","formatError","$ZodErrorTree","Array","treeifyError","toDotPath","PathSegment","prettifyError","FailureResult"],"sources":["../../../node_modules/.bun/zod@4.1.12/node_modules/zod/v4/core/errors.d.cts"],"sourcesContent":["import type { $ZodCheck, $ZodStringFormats } from \"./checks.cjs\";\nimport { $constructor } from \"./core.cjs\";\nimport type { $ZodType } from \"./schemas.cjs\";\nimport type { StandardSchemaV1 } from \"./standard-schema.cjs\";\nimport * as util from \"./util.cjs\";\nexport interface $ZodIssueBase {\n    readonly code?: string;\n    readonly input?: unknown;\n    readonly path: PropertyKey[];\n    readonly message: string;\n}\nexport interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {\n    readonly code: \"invalid_type\";\n    readonly expected: $ZodType[\"_zod\"][\"def\"][\"type\"];\n    readonly input?: Input;\n}\nexport interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {\n    readonly code: \"too_big\";\n    readonly origin: \"number\" | \"int\" | \"bigint\" | \"date\" | \"string\" | \"array\" | \"set\" | \"file\" | (string & {});\n    readonly maximum: number | bigint;\n    readonly inclusive?: boolean;\n    readonly exact?: boolean;\n    readonly input?: Input;\n}\nexport interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {\n    readonly code: \"too_small\";\n    readonly origin: \"number\" | \"int\" | \"bigint\" | \"date\" | \"string\" | \"array\" | \"set\" | \"file\" | (string & {});\n    readonly minimum: number | bigint;\n    /** True if the allowable range includes the minimum */\n    readonly inclusive?: boolean;\n    /** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */\n    readonly exact?: boolean;\n    readonly input?: Input;\n}\nexport interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {\n    readonly code: \"invalid_format\";\n    readonly format: $ZodStringFormats | (string & {});\n    readonly pattern?: string;\n    readonly input?: string;\n}\nexport interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {\n    readonly code: \"not_multiple_of\";\n    readonly divisor: number;\n    readonly input?: Input;\n}\nexport interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {\n    readonly code: \"unrecognized_keys\";\n    readonly keys: string[];\n    readonly input?: Record<string, unknown>;\n}\nexport interface $ZodIssueInvalidUnion extends $ZodIssueBase {\n    readonly code: \"invalid_union\";\n    readonly errors: $ZodIssue[][];\n    readonly input?: unknown;\n    readonly discriminator?: string | undefined;\n}\nexport interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {\n    readonly code: \"invalid_key\";\n    readonly origin: \"map\" | \"record\";\n    readonly issues: $ZodIssue[];\n    readonly input?: Input;\n}\nexport interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {\n    readonly code: \"invalid_element\";\n    readonly origin: \"map\" | \"set\";\n    readonly key: unknown;\n    readonly issues: $ZodIssue[];\n    readonly input?: Input;\n}\nexport interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {\n    readonly code: \"invalid_value\";\n    readonly values: util.Primitive[];\n    readonly input?: Input;\n}\nexport interface $ZodIssueCustom extends $ZodIssueBase {\n    readonly code: \"custom\";\n    readonly params?: Record<string, any> | undefined;\n    readonly input?: unknown;\n}\nexport interface $ZodIssueStringCommonFormats extends $ZodIssueInvalidStringFormat {\n    format: Exclude<$ZodStringFormats, \"regex\" | \"jwt\" | \"starts_with\" | \"ends_with\" | \"includes\">;\n}\nexport interface $ZodIssueStringInvalidRegex extends $ZodIssueInvalidStringFormat {\n    format: \"regex\";\n    pattern: string;\n}\nexport interface $ZodIssueStringInvalidJWT extends $ZodIssueInvalidStringFormat {\n    format: \"jwt\";\n    algorithm?: string;\n}\nexport interface $ZodIssueStringStartsWith extends $ZodIssueInvalidStringFormat {\n    format: \"starts_with\";\n    prefix: string;\n}\nexport interface $ZodIssueStringEndsWith extends $ZodIssueInvalidStringFormat {\n    format: \"ends_with\";\n    suffix: string;\n}\nexport interface $ZodIssueStringIncludes extends $ZodIssueInvalidStringFormat {\n    format: \"includes\";\n    includes: string;\n}\nexport type $ZodStringFormatIssues = $ZodIssueStringCommonFormats | $ZodIssueStringInvalidRegex | $ZodIssueStringInvalidJWT | $ZodIssueStringStartsWith | $ZodIssueStringEndsWith | $ZodIssueStringIncludes;\nexport type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;\nexport type $ZodIssueCode = $ZodIssue[\"code\"];\nexport type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;\ntype RawIssue<T extends $ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, \"message\" | \"path\"> & {\n    /** The input data */\n    readonly input: unknown;\n    /** The schema or check that originated this issue. */\n    readonly inst?: $ZodType | $ZodCheck;\n    /** If `true`, Zod will continue executing checks/refinements after this issue. */\n    readonly continue?: boolean | undefined;\n} & Record<string, unknown>> : never;\nexport type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;\nexport interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {\n    (issue: $ZodRawIssue<T>): {\n        message: string;\n    } | string | undefined | null;\n}\nexport interface $ZodError<T = unknown> extends Error {\n    type: T;\n    issues: $ZodIssue[];\n    _zod: {\n        output: T;\n        def: $ZodIssue[];\n    };\n    stack?: string;\n    name: string;\n}\nexport declare const $ZodError: $constructor<$ZodError>;\ninterface $ZodRealError<T = any> extends $ZodError<T> {\n}\nexport declare const $ZodRealError: $constructor<$ZodRealError>;\nexport type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;\ntype _FlattenedError<T, U = string> = {\n    formErrors: U[];\n    fieldErrors: {\n        [P in keyof T]?: U[];\n    };\n};\nexport declare function flattenError<T>(error: $ZodError<T>): _FlattenedError<T>;\nexport declare function flattenError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): _FlattenedError<T, U>;\ntype _ZodFormattedError<T, U = string> = T extends [any, ...any[]] ? {\n    [K in keyof T]?: $ZodFormattedError<T[K], U>;\n} : T extends any[] ? {\n    [k: number]: $ZodFormattedError<T[number], U>;\n} : T extends object ? util.Flatten<{\n    [K in keyof T]?: $ZodFormattedError<T[K], U>;\n}> : any;\nexport type $ZodFormattedError<T, U = string> = {\n    _errors: U[];\n} & util.Flatten<_ZodFormattedError<T, U>>;\nexport declare function formatError<T>(error: $ZodError<T>): $ZodFormattedError<T>;\nexport declare function formatError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;\nexport type $ZodErrorTree<T, U = string> = T extends util.Primitive ? {\n    errors: U[];\n} : T extends [any, ...any[]] ? {\n    errors: U[];\n    items?: {\n        [K in keyof T]?: $ZodErrorTree<T[K], U>;\n    };\n} : T extends any[] ? {\n    errors: U[];\n    items?: Array<$ZodErrorTree<T[number], U>>;\n} : T extends object ? {\n    errors: U[];\n    properties?: {\n        [K in keyof T]?: $ZodErrorTree<T[K], U>;\n    };\n} : {\n    errors: U[];\n};\nexport declare function treeifyError<T>(error: $ZodError<T>): $ZodErrorTree<T>;\nexport declare function treeifyError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodErrorTree<T, U>;\n/** Format a ZodError as a human-readable string in the following form.\n *\n * From\n *\n * ```ts\n * ZodError {\n *   issues: [\n *     {\n *       expected: 'string',\n *       code: 'invalid_type',\n *       path: [ 'username' ],\n *       message: 'Invalid input: expected string'\n *     },\n *     {\n *       expected: 'number',\n *       code: 'invalid_type',\n *       path: [ 'favoriteNumbers', 1 ],\n *       message: 'Invalid input: expected number'\n *     }\n *   ];\n * }\n * ```\n *\n * to\n *\n * ```\n * username\n *   ✖ Expected number, received string at \"username\n * favoriteNumbers[0]\n *   ✖ Invalid input: expected number\n * ```\n */\nexport declare function toDotPath(_path: readonly (string | number | symbol | StandardSchemaV1.PathSegment)[]): string;\nexport declare function prettifyError(error: StandardSchemaV1.FailureResult): string;\nexport {};\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/errors2.d.ts

@@ -0,0 +1,24 @@
+import { $ZodError, $ZodErrorMap, $ZodFlattenedError, $ZodFormattedError, $ZodIssue } from "./errors.js";
+import { $constructor } from "./core.js";
+
+//#region ../../node_modules/.bun/zod@4.1.12/node_modules/zod/v4/classic/errors.d.cts
+
+/** An Error-like class used to store Zod validation issues.  */
+interface ZodError<T = unknown> extends $ZodError<T> {
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  format(): $ZodFormattedError<T>;
+  format<U>(mapper: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  flatten(): $ZodFlattenedError<T>;
+  flatten<U>(mapper: (issue: $ZodIssue) => U): $ZodFlattenedError<T, U>;
+  /** @deprecated Push directly to `.issues` instead. */
+  addIssue(issue: $ZodIssue): void;
+  /** @deprecated Push directly to `.issues` instead. */
+  addIssues(issues: $ZodIssue[]): void;
+  /** @deprecated Check `err.issues.length === 0` instead. */
+  isEmpty: boolean;
+}
+declare const ZodError: $constructor<ZodError>;
+//#endregion
+export { ZodError };
+//# sourceMappingURL=errors2.d.ts.map

package/errors2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors2.d.ts","names":["core","$ZodError","ZodIssue","$ZodIssue","ZodError","U","T","$ZodFormattedError","$ZodFlattenedError","$constructor","ZodRealError","ZodFlattenedError","ZodFormattedError","$ZodErrorMap","ZodErrorMap","IssueData","$ZodRawIssue"],"sources":["../../../node_modules/.bun/zod@4.1.12/node_modules/zod/v4/classic/errors.d.cts"],"sourcesContent":["import * as core from \"../core/index.cjs\";\nimport { $ZodError } from \"../core/index.cjs\";\n/** @deprecated Use `z.core.$ZodIssue` from `@zod/core` instead, especially if you are building a library on top of Zod. */\nexport type ZodIssue = core.$ZodIssue;\n/** An Error-like class used to store Zod validation issues.  */\nexport interface ZodError<T = unknown> extends $ZodError<T> {\n    /** @deprecated Use the `z.treeifyError(err)` function instead. */\n    format(): core.$ZodFormattedError<T>;\n    format<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFormattedError<T, U>;\n    /** @deprecated Use the `z.treeifyError(err)` function instead. */\n    flatten(): core.$ZodFlattenedError<T>;\n    flatten<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFlattenedError<T, U>;\n    /** @deprecated Push directly to `.issues` instead. */\n    addIssue(issue: core.$ZodIssue): void;\n    /** @deprecated Push directly to `.issues` instead. */\n    addIssues(issues: core.$ZodIssue[]): void;\n    /** @deprecated Check `err.issues.length === 0` instead. */\n    isEmpty: boolean;\n}\nexport declare const ZodError: core.$constructor<ZodError>;\nexport declare const ZodRealError: core.$constructor<ZodError>;\nexport type { \n/** @deprecated Use `z.core.$ZodFlattenedError` instead. */\n$ZodFlattenedError as ZodFlattenedError, \n/** @deprecated Use `z.core.$ZodFormattedError` instead. */\n$ZodFormattedError as ZodFormattedError, \n/** @deprecated Use `z.core.$ZodErrorMap` instead. */\n$ZodErrorMap as ZodErrorMap, } from \"../core/index.cjs\";\n/** @deprecated Use `z.core.$ZodRawIssue` instead. */\nexport type IssueData = core.$ZodRawIssue;\n"],"x_google_ignoreList":[0],"mappings":";;;;;AAKA;AAAyDM,UAAxCF,QAAwCE,CAAAA,IAAAA,OAAAA,CAAAA,SAAVL,SAAUK,CAAAA,CAAAA,CAAAA,CAAAA;EAEnBA;EAAxBN,MAAAA,EAAAA,EAAAA,kBAAAA,CAAwBM,CAAxBN,CAAAA;EACgBA,MAAAA,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAAAA,CAAAA,KAAAA,EAAAA,SAAAA,EAAAA,GAAmBK,CAAnBL,CAAAA,EAAuBA,kBAAvBA,CAA+CM,CAA/CN,EAAkDK,CAAlDL,CAAAA;EAAmBK;EAA4BC,OAAAA,EAAAA,EAE9DN,kBAF8DM,CAEtCA,CAFsCA,CAAAA;EAAGD,OAAAA,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAAAA,CAAAA,KAAAA,EAGjDL,SAHiDK,EAAAA,GAG9BA,CAH8BA,CAAAA,EAG1BL,kBAH0BK,CAGFC,CAHED,EAGCA,CAHDA,CAAAA;EAA3BL;EAEdM,QAAAA,CAAAA,KAAAA,EAGnBN,SAHmBM,CAAAA,EAAAA,IAAAA;EAAxBN;EACgBA,SAAAA,CAAAA,MAAAA,EAITA,SAJSA,EAAAA,CAAAA,EAAAA,IAAAA;EAAmBK;EAA4BC,OAAAA,EAAAA,OAAAA;;AAAxBN,cAQjCI,QARiCJ,EAQvBA,YARuBA,CAQLI,QARKJ,CAAAA"}

package/hooks/private/use-grouped-messages.d.ts

@@ -1,5 +1,5 @@
 import { TimelineItem } from "../../timeline-item.js";
-import { ConversationSeen } from "../../schemas.js";
+import { ConversationSeen } from "../../schemas3.js";
 import { SenderType } from "@cossistant/types";
 
 //#region src/hooks/private/use-grouped-messages.d.ts

package/hooks/use-conversation-seen.d.ts

@@ -1,4 +1,4 @@
-import { ConversationSeen } from "../schemas.js";
+import { ConversationSeen } from "../schemas3.js";
 
 //#region src/hooks/use-conversation-seen.d.ts
 type UseConversationSeenOptions = {

package/hooks/use-create-conversation.d.ts

@@ -1,5 +1,5 @@
 import { TimelineItem } from "../timeline-item.js";
-import { Conversation } from "../schemas.js";
+import { Conversation } from "../schemas3.js";
 import { CreateConversationResponseBody } from "../conversation.js";
 import { CossistantClient } from "@cossistant/core";
 

package/hooks/use-realtime-support.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-realtime-support.d.ts","names":[],"sources":["../../src/hooks/use-realtime-support.ts"],"sourcesContent":[],"mappings":";;;KAIY,yBAAA;oBACO;AADnB,CAAA;AAIY,KAAA,wBAAA,GAAwB;EAG5B,WAAA,EAAA,OAAA;EACO,YAAA,EAAA,OAAA;EACH,KAAA,EAFJ,KAEI,GAAA,IAAA;EAEE,IAAA,EAAA,CAAA,KAAA,EAHC,gBAGD,EAAA,GAAA,IAAA;EACgB,SAAA,EAHlB,gBAGkB,GAAA,IAAA;EAAgB;EAQ9B,WAAA,EATF,gBASoB,GAAA,IACxB;+BAToB;;;;;;;iBAQd,kBAAA,WACN,4BACP"}
+{"version":3,"file":"use-realtime-support.d.ts","names":[],"sources":["../../src/hooks/use-realtime-support.ts"],"sourcesContent":[],"mappings":";;;KAIY,yBAAA;oBACO;AADnB,CAAA;AAIY,KAAA,wBAAA,GAAwB;EAG5B,WAAA,EAAA,OAAA;EACO,YAAA,EAAA,OAAA;EACH,KAAA,EAFJ,KAEI,GAAA,IAAA;EAEE,IAAA,EAAA,CAAA,KAAA,EAHC,gBAGD,EAAA,GAAA,IAAA;EACgB,SAAA,EAHlB,gBAGkB,GAAA,IAAA;EAAgB;EAQ9B,WAAA,EATF,gBASoB,GACxB,IAAA;+BAToB;;;;;;;iBAQd,kBAAA,WACN,4BACP"}

package/index2.d.ts

@@ -0,0 +1,4 @@
+import { ZodOpenAPIMetadata } from "./zod-extensions.js";
+import "./metadata.js";
+import "./openapi-generator2.js";
+import "./openapi-generator3.js";

package/index3.d.ts

@@ -0,0 +1 @@
+import "./index2.js";

package/index4.d.ts

@@ -0,0 +1,18 @@
+//#region ../../node_modules/.bun/motion-utils@12.23.6/node_modules/motion-utils/dist/index.d.ts
+
+type EasingFunction = (v: number) => number;
+type BezierDefinition = readonly [number, number, number, number];
+type EasingDefinition = BezierDefinition | "linear" | "easeIn" | "easeOut" | "easeInOut" | "circIn" | "circOut" | "circInOut" | "backIn" | "backOut" | "backInOut" | "anticipate";
+/**
+ * The easing function to use. Set as one of:
+ *
+ * - The name of an in-built easing function.
+ * - An array of four numbers to define a cubic bezier curve.
+ * - An easing function, that accepts and returns a progress value between `0` and `1`.
+ *
+ * @public
+ */
+type Easing = EasingDefinition | EasingFunction;
+//#endregion
+export { type BezierDefinition, type Easing, type EasingDefinition, type EasingFunction };
+//# sourceMappingURL=index4.d.ts.map

package/index4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index4.d.ts","names":["addUniqueItem","T","removeItem","moveItem","clamp","DevMessage","warning","invariant","MotionGlobalConfig","isNumericalString","isObject","isZeroValueString","memo","noop","pipe","Function","progress","GenericHandler","SubscriptionManager","Handler","VoidFunction","Parameters","secondsToMilliseconds","millisecondsToSeconds","velocityPerSecond","hasWarned","warnOnce","wrap","anticipate","backOut","backIn","EasingFunction","backInOut","EasingModifier","BezierDefinition","EasingDefinition","Easing","circIn","circOut","circInOut","cubicBezier","easeIn","easeOut","easeInOut","mirrorEasing","reverseEasing","Direction","steps","getEasingForSegment","isBezierDefinition","isEasingArray","easingDefinitionToFunction","Point","Axis","Box","BoundingBox","AxisDelta","Delta","TransformPoint"],"sources":["../../../node_modules/.bun/motion-utils@12.23.6/node_modules/motion-utils/dist/index.d.ts"],"sourcesContent":["declare function addUniqueItem<T>(arr: T[], item: T): void;\ndeclare function removeItem<T>(arr: T[], item: T): void;\ndeclare function moveItem<T>([...arr]: T[], fromIndex: number, toIndex: number): T[];\n\ndeclare const clamp: (min: number, max: number, v: number) => number;\n\ntype DevMessage = (check: boolean, message: string, errorCode?: string) => void;\ndeclare let warning: DevMessage;\ndeclare let invariant: DevMessage;\n\ndeclare const MotionGlobalConfig: {\n    skipAnimations?: boolean;\n    instantAnimations?: boolean;\n    useManualTiming?: boolean;\n    WillChange?: any;\n    mix?: <T>(a: T, b: T) => (p: number) => T;\n};\n\n/**\n * Check if value is a numerical string, ie a string that is purely a number eg \"100\" or \"-100.1\"\n */\ndeclare const isNumericalString: (v: string) => boolean;\n\ndeclare function isObject(value: unknown): value is object;\n\n/**\n * Check if the value is a zero value string like \"0px\" or \"0%\"\n */\ndeclare const isZeroValueString: (v: string) => boolean;\n\ndeclare function memo<T extends any>(callback: () => T): () => T;\n\ndeclare const noop: <T>(any: T) => T;\n\ndeclare const pipe: (...transformers: Function[]) => Function;\n\ndeclare const progress: (from: number, to: number, value: number) => number;\n\ntype GenericHandler = (...args: any) => void;\ndeclare class SubscriptionManager<Handler extends GenericHandler> {\n    private subscriptions;\n    add(handler: Handler): VoidFunction;\n    notify(a?: Parameters<Handler>[0], b?: Parameters<Handler>[1], c?: Parameters<Handler>[2]): void;\n    getSize(): number;\n    clear(): void;\n}\n\n/**\n * Converts seconds to milliseconds\n *\n * @param seconds - Time in seconds.\n * @return milliseconds - Converted time in milliseconds.\n */\ndeclare const secondsToMilliseconds: (seconds: number) => number;\ndeclare const millisecondsToSeconds: (milliseconds: number) => number;\n\ndeclare function velocityPerSecond(velocity: number, frameDuration: number): number;\n\ndeclare function hasWarned(message: string): boolean;\ndeclare function warnOnce(condition: boolean, message: string, errorCode?: string): void;\n\ndeclare const wrap: (min: number, max: number, v: number) => number;\n\ndeclare const anticipate: (p: number) => number;\n\ndeclare const backOut: (t: number) => number;\ndeclare const backIn: EasingFunction;\ndeclare const backInOut: EasingFunction;\n\ntype EasingFunction = (v: number) => number;\ntype EasingModifier = (easing: EasingFunction) => EasingFunction;\ntype BezierDefinition = readonly [number, number, number, number];\ntype EasingDefinition = BezierDefinition | \"linear\" | \"easeIn\" | \"easeOut\" | \"easeInOut\" | \"circIn\" | \"circOut\" | \"circInOut\" | \"backIn\" | \"backOut\" | \"backInOut\" | \"anticipate\";\n/**\n * The easing function to use. Set as one of:\n *\n * - The name of an in-built easing function.\n * - An array of four numbers to define a cubic bezier curve.\n * - An easing function, that accepts and returns a progress value between `0` and `1`.\n *\n * @public\n */\ntype Easing = EasingDefinition | EasingFunction;\n\ndeclare const circIn: EasingFunction;\ndeclare const circOut: EasingFunction;\ndeclare const circInOut: EasingFunction;\n\ndeclare function cubicBezier(mX1: number, mY1: number, mX2: number, mY2: number): (t: number) => number;\n\ndeclare const easeIn: (t: number) => number;\ndeclare const easeOut: (t: number) => number;\ndeclare const easeInOut: (t: number) => number;\n\ndeclare const mirrorEasing: EasingModifier;\n\ndeclare const reverseEasing: EasingModifier;\n\ntype Direction = \"start\" | \"end\";\ndeclare function steps(numSteps: number, direction?: Direction): EasingFunction;\n\ndeclare function getEasingForSegment(easing: Easing | Easing[], i: number): Easing;\n\ndeclare const isBezierDefinition: (easing: Easing | Easing[]) => easing is BezierDefinition;\n\ndeclare const isEasingArray: (ease: any) => ease is Easing[];\n\ndeclare const easingDefinitionToFunction: (definition: Easing) => EasingFunction;\n\ninterface Point {\n    x: number;\n    y: number;\n}\ninterface Axis {\n    min: number;\n    max: number;\n}\ninterface Box {\n    x: Axis;\n    y: Axis;\n}\ninterface BoundingBox {\n    top: number;\n    right: number;\n    bottom: number;\n    left: number;\n}\ninterface AxisDelta {\n    translate: number;\n    scale: number;\n    origin: number;\n    originPoint: number;\n}\ninterface Delta {\n    x: AxisDelta;\n    y: AxisDelta;\n}\ntype TransformPoint = (point: Point) => Point;\n\nexport { type Axis, type AxisDelta, type BezierDefinition, type BoundingBox, type Box, type Delta, type DevMessage, type Direction, type Easing, type EasingDefinition, type EasingFunction, type EasingModifier, MotionGlobalConfig, type Point, SubscriptionManager, type TransformPoint, addUniqueItem, anticipate, backIn, backInOut, backOut, circIn, circInOut, circOut, clamp, cubicBezier, easeIn, easeInOut, easeOut, easingDefinitionToFunction, getEasingForSegment, hasWarned, invariant, isBezierDefinition, isEasingArray, isNumericalString, isObject, isZeroValueString, memo, millisecondsToSeconds, mirrorEasing, moveItem, noop, pipe, progress, removeItem, reverseEasing, secondsToMilliseconds, steps, velocityPerSecond, warnOnce, warning, wrap };\n"],"x_google_ignoreList":[0],"mappings":";;KAqEK+B,cAAAA;KAEAG,gBAAAA;KACAC,gBAAAA,GAAmBD;;;;;;;;;;KAUnBE,MAAAA,GAASD,mBAAmBJ"}