@ariestools/sdk-react 10.0.2

package/dist/_pkg/promise/browser/index.mjs

@@ -0,0 +1,117 @@
+// src/useAtomicPromise.ts
+import { Mutex as Mutex2 } from "async-mutex";
+
+// src/usePromise.ts
+import { Mutex } from "async-mutex";
+import {
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+
+// src/context/context.ts
+import { createContext } from "react";
+var defaultPromiseSettings = { logErrors: true };
+var PromiseSettingsContext = createContext(defaultPromiseSettings);
+
+// src/context/hook.ts
+import { use } from "react";
+var usePromiseSettings = () => {
+  return use(PromiseSettingsContext);
+};
+
+// src/usePromise.ts
+var usePromise = (promise, dependencies, config) => {
+  const { logErrors = true } = usePromiseSettings();
+  const [result, setResult] = useState(config?.defaultValue);
+  const [error, setError] = useState();
+  const [state, setState] = useState("pending");
+  const mutex = useRef(new Mutex()).current;
+  const debugLabel = config?.debug;
+  if (debugLabel !== void 0 && debugLabel.length > 0) console.log(`usePromise [${debugLabel}]: started [${typeof promise}]`);
+  const promiseMemo = useMemo(() => {
+    try {
+      if (debugLabel !== void 0 && debugLabel.length > 0) console.log(`usePromise [${debugLabel}]: re-memo [${typeof promise}]`);
+      setState("pending");
+      return promise();
+    } catch (ex) {
+      const error2 = ex;
+      if (logErrors) {
+        console.error(`usePromise-memo: ${error2}`);
+        globalThis?.rollbar?.error(error2);
+      }
+      if (debugLabel !== void 0 && debugLabel.length > 0) console.log(`usePromise [${debugLabel}]: useMemo rejection [${typeof promise}]`);
+      setResult(void 0);
+      setError(error2);
+      setState("rejected");
+    }
+  }, dependencies);
+  if (debugLabel !== void 0 && debugLabel.length > 0) console.log(`usePromise [${debugLabel}] Main Function`);
+  useEffect(() => {
+    let loaded = true;
+    if (debugLabel !== void 0 && debugLabel.length > 0) console.log(`usePromise [${debugLabel}] useEffect`);
+    void (async () => {
+      try {
+        await mutex.acquire();
+        try {
+          if (promiseMemo === void 0) {
+            return;
+          }
+          const payload = await promiseMemo;
+          if (debugLabel !== void 0 && debugLabel.length > 0) console.log(`usePromise [${debugLabel}] then`);
+          if (loaded) {
+            setResult(payload);
+            setError(void 0);
+            setState("resolved");
+          }
+        } catch (e) {
+          const error2 = e;
+          if (logErrors) {
+            console.error(error2);
+            globalThis?.rollbar?.error(error2);
+          }
+          if (loaded) {
+            setResult(void 0);
+            setError(error2);
+            setState("resolved");
+          }
+        } finally {
+          mutex.release();
+        }
+      } catch (ex) {
+        const error2 = ex;
+        if (logErrors) {
+          console.error(`usePromise-memo: ${error2}`);
+          globalThis?.rollbar?.error(error2);
+        }
+        if (loaded) {
+          setResult(void 0);
+          setError(error2);
+          setState("rejected");
+        }
+        mutex.release();
+      }
+    })();
+    return () => {
+      loaded = false;
+      if (debugLabel !== void 0 && debugLabel.length > 0) console.log(`usePromise [${debugLabel}] useEffect callback`);
+    };
+  }, [...dependencies, promiseMemo]);
+  if (debugLabel !== void 0 && debugLabel.length > 0) console.log(`usePromise [${debugLabel}] returning ${JSON.stringify([result, error, state], null, 2)}`);
+  return [result, error, state];
+};
+
+// src/useAtomicPromise.ts
+var mutexDictionary = {};
+var getMutex = (name) => {
+  mutexDictionary[name] ??= new Mutex2();
+  return mutexDictionary[name];
+};
+var useAtomicPromise = (name, promise, dependencies, config) => {
+  return usePromise(() => getMutex(name).runExclusive(promise), dependencies, config);
+};
+export {
+  useAtomicPromise,
+  usePromise
+};

package/dist/_pkg/promise/browser/model.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Represents the state of a promise.
+ *
+ * @type {UsePromiseState}
+ * @property {'pending'} pending - The promise is still pending.
+ * @property {'rejected'} rejected - The promise has been rejected.
+ * @property {'resolved'} resolved - The promise has been resolved.
+ */
+export type UsePromiseState = 'pending' | 'rejected' | 'resolved';
+/**
+ * Configuration options for the usePromise hook.
+ *
+ * @template TResult - The type of the result value.
+ *
+ * @property {string} [debug] - Optional debug string for logging purposes.
+ * @property {TResult} [defaultValue] - Optional default value to be used before the promise resolves.
+ */
+export interface UsePromiseConfig<TResult> {
+    debug?: string;
+    defaultValue?: TResult;
+}

package/dist/_pkg/promise/browser/useAtomicPromise.d.ts

@@ -0,0 +1,14 @@
+import type { DependencyList } from 'react';
+import type { UsePromiseConfig, UsePromiseState } from './model.ts';
+/**
+ * A custom hook that ensures a promise is executed atomically, using a mutex to prevent concurrent executions.
+ *
+ * @template TResult - The type of the result that the promise resolves to.
+ * @param {string} name - A unique name for the mutex to ensure atomic execution.
+ * @param {() => Promise<TResult | undefined>} promise - A function that returns the promise to be executed.
+ * @param {DependencyList} dependencies - An array of dependencies that will trigger the promise execution when changed.
+ * @param {UsePromiseConfig<TResult>} [config] - Optional configuration for the promise execution.
+ * @returns {[TResult | undefined, Error | undefined, UsePromiseState | undefined]}
+ * An array containing the result of the promise, any error that occurred, and the state of the promise.
+ */
+export declare const useAtomicPromise: <TResult>(name: string, promise: () => Promise<TResult | undefined>, dependencies: DependencyList, config?: UsePromiseConfig<TResult>) => [TResult | undefined, Error | undefined, UsePromiseState | undefined];

package/dist/_pkg/promise/browser/usePromise.d.ts

@@ -0,0 +1,17 @@
+import type { DependencyList } from 'react';
+import type { UsePromiseConfig, UsePromiseState } from './model.ts';
+/**
+ * A custom hook that manages the state of a promise, including its result, error, and state.
+ *
+ * @template TResult - The type of the result that the promise resolves to.
+ *
+ * @param {() => Promise<TResult | undefined>} promise - A function that returns a promise.
+ * @param {DependencyList} dependencies - An array of dependencies that will trigger the promise to be re-evaluated when changed.
+ * @param {UsePromiseConfig<TResult>} [config] - Optional configuration for the hook.
+ * @param {TResult} [config.defaultValue] - The default value to be used before the promise resolves.
+ * @param {boolean} [config.debug] - If true, debug information will be logged to the console.
+ *
+ * @returns {[TResult | undefined, Error | undefined, UsePromiseState | undefined]}
+ * An array containing the result of the promise, any error that occurred, and the current state of the promise.
+ */
+export declare const usePromise: <TResult>(promise: () => Promise<TResult | undefined>, dependencies: DependencyList, config?: UsePromiseConfig<TResult>) => [TResult | undefined, Error | undefined, UsePromiseState | undefined];

package/dist/_pkg/quick-tip-button/browser/QuickTipButton.d.ts

@@ -0,0 +1,11 @@
+import type { DialogProps, IconButtonProps, SvgIconProps } from '@mui/material';
+import type { JSXElementConstructor } from 'react';
+import React from 'react';
+export interface QuickTipButtonProps extends IconButtonProps {
+    Icon?: JSXElementConstructor<SvgIconProps>;
+    dialogProps?: Omit<DialogProps, 'open'>;
+    disableDialog?: boolean;
+    fontSize?: 'small' | 'medium' | 'large' | 'inherit';
+    hoverText?: string;
+}
+export declare const QuickTipButton: React.FC<QuickTipButtonProps>;

package/dist/_pkg/quick-tip-button/browser/index.d.ts

@@ -0,0 +1 @@
+export * from './QuickTipButton.tsx';

package/dist/_pkg/quick-tip-button/browser/index.mjs

@@ -0,0 +1,40 @@
+// src/QuickTipButton.tsx
+import { MessageDialog } from "../../dialogs/browser/index.mjs";
+import { HelpOutlined as HelpOutlineIcon } from "@mui/icons-material";
+import { IconButton, Tooltip } from "@mui/material";
+import { useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var QuickTipButton = ({
+  fontSize = "inherit",
+  title = "",
+  /** Removes dialog from the DOM and sets the CSS cursor to default */
+  disableDialog,
+  /** Props to pass on to the MessageDialog */
+  dialogProps,
+  hoverText,
+  /** Replacement for the help icon */
+  Icon,
+  /** Component(s) passes directly to the Dialog */
+  children,
+  ...props
+}) => {
+  const [messageOpen, setMessageOpen] = useState(false);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(IconButton, { onClick: () => setMessageOpen(true), size: "small", sx: { cursor: disableDialog === true ? "default" : "pointer" }, ...props, children: /* @__PURE__ */ jsx(Tooltip, { title: hoverText ?? title ?? "", children: Icon ? /* @__PURE__ */ jsx(Icon, { fontSize }) : /* @__PURE__ */ jsx(HelpOutlineIcon, { fontSize }) }) }),
+    disableDialog === true ? null : /* @__PURE__ */ jsx(
+      MessageDialog,
+      {
+        onOk: () => setMessageOpen(false),
+        onCancel: () => setMessageOpen(false),
+        onClose: () => setMessageOpen(false),
+        open: messageOpen,
+        title,
+        ...dialogProps,
+        children
+      }
+    )
+  ] });
+};
+export {
+  QuickTipButton
+};

package/dist/_pkg/render-spin-check/browser/components/RenderSpinCheck.d.ts

@@ -0,0 +1,5 @@
+import type { RenderSpinCheckBounce, RenderSpinCheckConfig } from '../hooks/index.ts';
+export type RenderSpinCheckProps = RenderSpinCheckConfig & {
+    bounce: RenderSpinCheckBounce;
+};
+export declare const RenderSpinCheck: React.FC<RenderSpinCheckProps>;

package/dist/_pkg/render-spin-check/browser/components/index.d.ts

@@ -0,0 +1 @@
+export * from './RenderSpinCheck.tsx';

package/dist/_pkg/render-spin-check/browser/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from './useRenderSpinCheck.tsx';

package/dist/_pkg/render-spin-check/browser/hooks/useRenderSpinCheck.d.ts

@@ -0,0 +1,10 @@
+export interface RenderSpinCheckConfig {
+    maxRate?: number;
+    minSamples?: number;
+    noThrow?: boolean;
+    reportOnce?: boolean;
+}
+export interface RenderSpinCheckBounce {
+    name: string;
+}
+export declare const useRenderSpinCheck: (bounce: RenderSpinCheckBounce, config?: RenderSpinCheckConfig) => void;

package/dist/_pkg/render-spin-check/browser/index.d.ts

@@ -0,0 +1,2 @@
+export * from './components/index.ts';
+export * from './hooks/index.ts';

package/dist/_pkg/render-spin-check/browser/index.mjs

@@ -0,0 +1,58 @@
+// src/hooks/useRenderSpinCheck.tsx
+import {
+  useEffect,
+  useRef,
+  useState
+} from "react";
+var spinCountMap = /* @__PURE__ */ new Map();
+var useRenderSpinCheck = (bounce, config) => {
+  const [startTime] = useState(() => Date.now());
+  const errorRef = useRef(void 0);
+  useEffect(() => {
+    const error = errorRef.current;
+    if (error) {
+      if (config?.reportOnce !== true) {
+        console.warn(error.message);
+      }
+    } else {
+      const spinCount = spinCountMap.get(startTime) ?? 0;
+      if (spinCount > (config?.minSamples ?? 20)) {
+        const elapsedTime = Date.now() - startTime;
+        const refreshRate = elapsedTime / spinCount;
+        if (refreshRate < (config?.maxRate ?? 1e3)) {
+          const newError = new Error(`Spinning [${bounce.name}] [Rate=${refreshRate.toFixed(2)}ms, Samples=${spinCount}]`);
+          console.warn(newError.message);
+          errorRef.current = newError;
+          if (config?.noThrow !== true) {
+            throw newError;
+          }
+        }
+      }
+      spinCountMap.set(startTime, spinCount + 1);
+    }
+    return () => {
+      spinCountMap.delete(startTime);
+    };
+  }, [bounce, config, startTime]);
+};
+
+// src/components/RenderSpinCheck.tsx
+var RenderSpinCheck = ({
+  minSamples = 20,
+  bounce,
+  maxRate = 1e3,
+  noThrow = false,
+  reportOnce
+}) => {
+  useRenderSpinCheck(bounce, {
+    maxRate,
+    minSamples,
+    noThrow,
+    reportOnce
+  });
+  return null;
+};
+export {
+  RenderSpinCheck,
+  useRenderSpinCheck
+};

package/dist/_pkg/rich-result/browser/RichResult.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { Thing } from './jsonld/index.ts';
+export interface RichResultProps {
+    thing: Thing;
+}
+export declare const RichResult: React.FC<RichResultProps>;

package/dist/_pkg/rich-result/browser/index.d.ts

@@ -0,0 +1,2 @@
+export * from './jsonld/index.ts';
+export * from './RichResult.tsx';

package/dist/_pkg/rich-result/browser/index.mjs

@@ -0,0 +1,62 @@
+// src/jsonld/ActionStatusType.ts
+import { Enum } from "@ariestools/sdk";
+var ActionStatusType = Enum({
+  ActiveActionStatus: "ActiveActionStatus",
+  CompletedActionStatus: "CompletedActionStatus",
+  FailedActionStatus: "FailedActionStatus",
+  PotentialActionStatus: "PotentialActionStatus"
+});
+
+// src/jsonld/ContactPointOption.ts
+import { Enum as Enum2 } from "@ariestools/sdk";
+var ContactPointOption = Enum2({
+  HearingImpairedSupported: "HearingImpairedSupported",
+  TollFree: "TollFree"
+});
+
+// src/jsonld/ItemAvailability.ts
+import { Enum as Enum3 } from "@ariestools/sdk";
+var ItemAvailability = Enum3({
+  /** Indicates that the item has been discontinued. */
+  Discontinued: "https://schema.org/Discontinued",
+  /** Indicates that the item is in stock. */
+  InStock: "https://schema.org/InStock",
+  /** Indicates that the item is available only at physical locations. */
+  InStoreOnly: "https://schema.org/InStoreOnly",
+  /** Indicates that the item has limited availability. */
+  LimitedAvailability: "https://schema.org/LimitedAvailability",
+  /** Indicates that the item is available only online. */
+  OnlineOnly: "https://schema.org/OnlineOnly",
+  /** Indicates that the item is out of stock. */
+  OutOfStock: "https://schema.org/OutOfStock",
+  /** Indicates that the item is available for pre-order. */
+  PreOrder: "https://schema.org/PreOrder",
+  /** Indicates that the item is available for ordering and delivery before general availability. */
+  PreSale: "https://schema.org/PreSale",
+  /** Indicates that the item has sold out. */
+  SoldOut: "https://schema.org/SoldOut"
+});
+
+// src/jsonld/MapCategoryType.ts
+import { Enum as Enum4 } from "@ariestools/sdk";
+var MapCategoryType = Enum4({
+  ParkingMap: "ParkingMap",
+  SeatingMap: "SeatingMap",
+  TransitMap: "TransitMap",
+  VenueMap: "VenueMap"
+});
+
+// src/RichResult.tsx
+import { jsx } from "react/jsx-runtime";
+var RichResult = (props) => {
+  const { thing } = props;
+  const thingWithContext = { ...thing, "@context": "https://schema.org" };
+  return /* @__PURE__ */ jsx("script", { type: "application/ld+json", children: JSON.stringify(thingWithContext) });
+};
+export {
+  ActionStatusType,
+  ContactPointOption,
+  ItemAvailability,
+  MapCategoryType,
+  RichResult
+};

package/dist/_pkg/rich-result/browser/jsonld/Action.d.ts

@@ -0,0 +1,23 @@
+import type { ActionStatusType } from './ActionStatusType.ts';
+import type { DateTime } from './DateTime.ts';
+import type { EntryPoint } from './EntryPoint.ts';
+import type { Organization } from './Organization.ts';
+import type { Person } from './Person.ts';
+import type { Place } from './Place.ts';
+import type { PostalAddress } from './PostalAddress.ts';
+import type { Thing } from './Thing.ts';
+import type { VirtualLocation } from './VirtualLocation.ts';
+interface Action extends Thing {
+    actionStatus?: ActionStatusType;
+    agent?: Organization | Person;
+    endTime?: DateTime;
+    error?: Thing;
+    instrument?: Thing;
+    location?: Place | PostalAddress | string | VirtualLocation;
+    object?: Thing;
+    participant?: Organization | Person;
+    result?: Thing;
+    startTime?: DateTime;
+    target?: EntryPoint;
+}
+export type { Action };

package/dist/_pkg/rich-result/browser/jsonld/ActionStatusType.d.ts

@@ -0,0 +1,9 @@
+import type { EnumValue } from '@ariestools/sdk';
+import { Enum } from '@ariestools/sdk';
+export declare const ActionStatusType: Enum<{
+    ActiveActionStatus: "ActiveActionStatus";
+    CompletedActionStatus: "CompletedActionStatus";
+    FailedActionStatus: "FailedActionStatus";
+    PotentialActionStatus: "PotentialActionStatus";
+}>;
+export type ActionStatusType = EnumValue<typeof ActionStatusType>;

package/dist/_pkg/rich-result/browser/jsonld/AdministrativeArea.d.ts

@@ -0,0 +1,3 @@
+import type { Place } from './Place.ts';
+type AdministrativeArea = Place;
+export type { AdministrativeArea };

package/dist/_pkg/rich-result/browser/jsonld/AggregateRating.d.ts

@@ -0,0 +1,8 @@
+import type { Rating } from './Rating.ts';
+import type { Thing } from './Thing.ts';
+interface AggregateRating extends Rating {
+    itemReviewed?: Thing;
+    ratingCount?: number;
+    reviewCount?: number;
+}
+export type { AggregateRating };

package/dist/_pkg/rich-result/browser/jsonld/Article.d.ts

@@ -0,0 +1,14 @@
+import type { CreativeWork } from './CreativeWork.ts';
+import type { Integer } from './Integer.ts';
+import type { Text } from './Text.ts';
+interface Article extends CreativeWork {
+    articleBody?: Text;
+    articleSection?: Text;
+    backstory?: CreativeWork | Text;
+    pageEnd?: Integer | Text;
+    pageStart?: Integer | Text;
+    pagination?: Text;
+    speakable?: unknown;
+    wordCount?: Integer;
+}
+export type { Article };

package/dist/_pkg/rich-result/browser/jsonld/Base.d.ts

@@ -0,0 +1,4 @@
+interface Base {
+    '@type': string;
+}
+export type { Base };

package/dist/_pkg/rich-result/browser/jsonld/Brand.d.ts

@@ -0,0 +1,10 @@
+import type { AggregateRating } from './AggregateRating.ts';
+import type { ImageObject } from './ImageObject.ts';
+import type { Intangible } from './Intangible.ts';
+import type { Review } from './Review.ts';
+export interface Brand extends Intangible {
+    aggregateRating?: AggregateRating;
+    logo?: ImageObject | URL;
+    review?: Review;
+    slogan?: Text;
+}

package/dist/_pkg/rich-result/browser/jsonld/Class.d.ts

@@ -0,0 +1,7 @@
+import type { Enumeration } from './Enumeration.ts';
+import type { Intangible } from './Intangible.ts';
+import type { Property } from './Property.ts';
+interface Class extends Intangible {
+    supersededBy?: Class | Enumeration | Property;
+}
+export type { Class };

package/dist/_pkg/rich-result/browser/jsonld/ContactPoint.d.ts

@@ -0,0 +1,18 @@
+import type { AdministrativeArea } from './AdministrativeArea.ts';
+import type { ContactPointOption } from './ContactPointOption.ts';
+import type { GeoShape } from './GeoShape.ts';
+import type { Language } from './Language.ts';
+import type { Product } from './Product.ts';
+import type { Text } from './Text.ts';
+import type { Thing } from './Thing.ts';
+interface ContactPoint extends Thing {
+    areaServed?: AdministrativeArea | GeoShape | Text;
+    availableLanguages?: Language | Text;
+    contactOption?: ContactPointOption;
+    contactType?: Text;
+    email?: Text;
+    hoursAvailable?: unknown;
+    productsSupported?: Product | Text;
+    telephone?: Text;
+}
+export type { ContactPoint };

package/dist/_pkg/rich-result/browser/jsonld/ContactPointOption.d.ts

@@ -0,0 +1,7 @@
+import type { EnumValue } from '@ariestools/sdk';
+import { Enum } from '@ariestools/sdk';
+export declare const ContactPointOption: Enum<{
+    HearingImpairedSupported: "HearingImpairedSupported";
+    TollFree: "TollFree";
+}>;
+export type ContactPointOption = EnumValue<typeof ContactPointOption>;

package/dist/_pkg/rich-result/browser/jsonld/Country.d.ts

@@ -0,0 +1,3 @@
+import type { AdministrativeArea } from './AdministrativeArea.ts';
+type Country = AdministrativeArea;
+export type { Country };

package/dist/_pkg/rich-result/browser/jsonld/CreativeWork.d.ts

@@ -0,0 +1,121 @@
+import type { AggregateRating } from './AggregateRating.ts';
+import type { DateTime } from './DateTime.ts';
+import type { Integer } from './Integer.ts';
+import type { Language } from './Language.ts';
+import type { MediaObject } from './MediaObject.ts';
+import type { Organization } from './Organization.ts';
+import type { Person } from './Person.ts';
+import type { Place } from './Place.ts';
+import type { Product } from './Product.ts';
+import type { QuantitativeValue } from './QuantitativeValue.ts';
+import type { Rating } from './Rating.ts';
+import type { Review } from './Review.ts';
+import type { Text } from './Text.ts';
+import type { Thing } from './Thing.ts';
+import type { URL } from './url.ts';
+interface CreativeWork extends Thing {
+    about?: Thing;
+    abstract?: Text;
+    accessMode?: Text;
+    accessModeSufficient?: unknown;
+    accessibilityAPI?: Text;
+    accessibilityControl?: Text;
+    accessibilityFeature?: Text;
+    accessibilityHazard?: Text;
+    accessibilitySummary?: Text;
+    accountablePerson?: Person;
+    acquireLicensePage?: CreativeWork | URL;
+    aggregateRating?: AggregateRating;
+    alternativeHeading?: Text;
+    assesses?: unknown;
+    associatedMedia?: MediaObject;
+    audience?: unknown;
+    audio?: unknown;
+    author?: Organization | Person;
+    award?: Text;
+    character?: Person;
+    citation?: CreativeWork | Text;
+    comment?: unknown;
+    commentCount?: Integer;
+    conditionsOfAccess?: Text;
+    contentLocation?: Place;
+    contentRating?: Rating | Text;
+    contentReferenceTime?: DateTime;
+    contributor?: Organization | Person;
+    copyrightHolder?: Organization | Person;
+    copyrightNotice?: Text;
+    copyrightYear?: number;
+    correction?: unknown;
+    creativeWorkStatus?: unknown;
+    creator?: Organization | Person;
+    creditText?: Text;
+    dateCreated?: DateTime;
+    dateModified?: DateTime;
+    datePublished?: DateTime;
+    discussionUrl?: URL;
+    editEIDR?: Text | URL;
+    editor?: Person;
+    educationalAlignment?: unknown;
+    educationalLevel?: unknown;
+    educationalUse?: unknown;
+    encoding?: MediaObject;
+    encodingFormat?: Text | URL;
+    exampleOfWork?: CreativeWork;
+    expires?: DateTime;
+    funder?: Organization | Person;
+    genre?: Text | URL;
+    hasPart?: CreativeWork;
+    headline?: Text;
+    inLanguage?: Language | Text;
+    interactionStatistic?: unknown;
+    interactiveityType?: Text;
+    isAccessibleForFree?: boolean;
+    isBasedOn?: CreativeWork | Product | URL;
+    isFamilyFriendly?: boolean;
+    isPartOf?: CreativeWork | URL;
+    keywords?: unknown;
+    learningResourceType?: unknown;
+    license?: CreativeWork | URL;
+    locationCreated?: Place;
+    mainEntry?: Thing;
+    maintainer?: Organization | Person;
+    material?: Product | Text | URL;
+    materialExtent?: QuantitativeValue | Text;
+    mentions?: Thing;
+    offers?: unknown;
+    pattern?: unknown;
+    position?: Integer | Text;
+    producer?: Organization | Person;
+    provider?: Organization | Person;
+    publication?: unknown;
+    publisher?: Organization | Person;
+    publisherImprint?: Organization;
+    publishingPrinciples?: CreativeWork | URL;
+    recordedAt?: Event;
+    releasedEvent?: unknown;
+    review?: Review;
+    schemaVersion?: Text | URL;
+    sdDatePublished?: DateTime;
+    sdLicense?: CreativeWork | URL;
+    sdPublisher?: Organization | Person;
+    size?: unknown;
+    sourceOrganization?: Organization;
+    spatial?: Place;
+    spatialCoverage?: Place;
+    sponsor?: Organization | Person;
+    teaches?: unknown;
+    temporal?: DateTime | Text;
+    temporalCoverage?: DateTime | Text | URL;
+    text?: Text;
+    thumbnailUrl?: URL;
+    timeRequired?: unknown;
+    translationOfWork?: CreativeWork;
+    translator?: Organization | Person;
+    typicalAgeRange?: Text;
+    usageInfo?: CreativeWork | URL;
+    version?: number | Text;
+    video?: unknown;
+    workExample?: CreativeWork;
+    workTranslation?: CreativeWork;
+}
+export type { CreativeWork };

package/dist/_pkg/rich-result/browser/jsonld/DateTime.d.ts

@@ -0,0 +1,2 @@
+type DateTime = string;
+export type { DateTime };

package/dist/_pkg/rich-result/browser/jsonld/EntryPoint.d.ts

@@ -0,0 +1,13 @@
+import type { Intangible } from './Intangible.ts';
+import type { SoftwareApplication } from './SoftwareApplication.ts';
+import type { Text } from './Text.ts';
+import type { URL } from './url.ts';
+interface EntryPoint extends Intangible {
+    actionApplication?: SoftwareApplication;
+    actionPlatform?: Text | URL;
+    contentType?: Text;
+    encodingType?: Text;
+    httpMethod?: Text;
+    urlTemplate?: Text;
+}
+export type { EntryPoint };