@xyo-network/location-payload-plugin 6.1.0 → 7.0.0

package/dist/neutral/GeographicCoordinateSystemLocationPayload.d.ts

@@ -1,19 +1,253 @@
-import type { Payload } from '@xyo-network/sdk-js';
-import type { GeographicCoordinateSystemLocationSchema, QuadkeyLocationSchema } from './GeographicCoordinateSystemLocationSchema.ts';
-export interface GeographicCoordinateSystemLocation {
-    accuracy?: number;
-    altitude?: number;
-    altitudeAccuracy?: number;
+import * as z from 'zod/mini';
+export declare const GeographicCoordinateSystemLocationZod: z.ZodMiniObject<{
+    accuracy: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    altitude: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    altitudeAccuracy: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    latitude: z.ZodMiniNumber<number>;
+    longitude: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+export type GeographicCoordinateSystemLocation = z.infer<typeof GeographicCoordinateSystemLocationZod>;
+export declare const QuadkeyLocationZod: z.ZodMiniObject<{
+    altitude: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    altitudeAccuracy: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    quadkey: z.ZodMiniString<string>;
+}, z.core.$strip>;
+export type QuadkeyLocation = z.infer<typeof QuadkeyLocationZod>;
+export declare const LocationZod: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+    accuracy: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    altitude: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    altitudeAccuracy: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    latitude: z.ZodMiniNumber<number>;
+    longitude: z.ZodMiniNumber<number>;
+}, z.core.$strip>, z.ZodMiniObject<{
+    altitude: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    altitudeAccuracy: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    quadkey: z.ZodMiniString<string>;
+}, z.core.$strip>]>;
+export type Location = z.infer<typeof LocationZod>;
+export declare const GeographicCoordinateSystemLocationPayloadZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.location.gcs" & {
+        readonly __schema: true;
+    }>;
+    accuracy: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    altitude: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    altitudeAccuracy: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    latitude: z.ZodMiniNumber<number>;
+    longitude: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+export type GeographicCoordinateSystemLocationPayload = z.infer<typeof GeographicCoordinateSystemLocationPayloadZod>;
+export declare const isGeographicCoordinateSystemLocationPayload: <T>(value: T) => value is T & {
+    schema: "network.xyo.location.gcs" & {
+        readonly __schema: true;
+    };
     latitude: number;
     longitude: number;
-}
-export interface QuadkeyLocation {
-    altitude?: number;
-    altitudeAccuracy?: number;
+    accuracy?: number | undefined;
+    altitude?: number | undefined;
+    altitudeAccuracy?: number | undefined;
+};
+export declare const asGeographicCoordinateSystemLocationPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.location.gcs" & {
+            readonly __schema: true;
+        };
+        latitude: number;
+        longitude: number;
+        accuracy?: number | undefined;
+        altitude?: number | undefined;
+        altitudeAccuracy?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & {
+        schema: "network.xyo.location.gcs" & {
+            readonly __schema: true;
+        };
+        latitude: number;
+        longitude: number;
+        accuracy?: number | undefined;
+        altitude?: number | undefined;
+        altitudeAccuracy?: number | undefined;
+    };
+};
+export declare const toGeographicCoordinateSystemLocationPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.location.gcs" & {
+            readonly __schema: true;
+        };
+        latitude: number;
+        longitude: number;
+        accuracy?: number | undefined;
+        altitude?: number | undefined;
+        altitudeAccuracy?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & {
+        schema: "network.xyo.location.gcs" & {
+            readonly __schema: true;
+        };
+        latitude: number;
+        longitude: number;
+        accuracy?: number | undefined;
+        altitude?: number | undefined;
+        altitudeAccuracy?: number | undefined;
+    };
+};
+export declare const QuadkeyLocationPayloadZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.location.quadkey" & {
+        readonly __schema: true;
+    }>;
+    altitude: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    altitudeAccuracy: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    quadkey: z.ZodMiniString<string>;
+}, z.core.$strip>;
+export type QuadkeyLocationPayload = z.infer<typeof QuadkeyLocationPayloadZod>;
+export declare const isQuadkeyLocationPayload: <T>(value: T) => value is T & {
+    schema: "network.xyo.location.quadkey" & {
+        readonly __schema: true;
+    };
     quadkey: string;
-}
-export type Location = GeographicCoordinateSystemLocation | QuadkeyLocation;
-export type GeographicCoordinateSystemLocationPayload = Payload<GeographicCoordinateSystemLocation, GeographicCoordinateSystemLocationSchema>;
-export type QuadkeyLocationPayload = Payload<QuadkeyLocation, QuadkeyLocationSchema>;
-export type LocationPayload = Payload<Location>;
+    altitude?: number | undefined;
+    altitudeAccuracy?: number | undefined;
+};
+export declare const asQuadkeyLocationPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.location.quadkey" & {
+            readonly __schema: true;
+        };
+        quadkey: string;
+        altitude?: number | undefined;
+        altitudeAccuracy?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & {
+        schema: "network.xyo.location.quadkey" & {
+            readonly __schema: true;
+        };
+        quadkey: string;
+        altitude?: number | undefined;
+        altitudeAccuracy?: number | undefined;
+    };
+};
+export declare const toQuadkeyLocationPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.location.quadkey" & {
+            readonly __schema: true;
+        };
+        quadkey: string;
+        altitude?: number | undefined;
+        altitudeAccuracy?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & {
+        schema: "network.xyo.location.quadkey" & {
+            readonly __schema: true;
+        };
+        quadkey: string;
+        altitude?: number | undefined;
+        altitudeAccuracy?: number | undefined;
+    };
+};
+export declare const LocationPayloadZod: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.location" & {
+        readonly __schema: true;
+    }>;
+    accuracy: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    altitude: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    altitudeAccuracy: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    latitude: z.ZodMiniNumber<number>;
+    longitude: z.ZodMiniNumber<number>;
+}, z.core.$strip>, z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.location" & {
+        readonly __schema: true;
+    }>;
+    altitude: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    altitudeAccuracy: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    quadkey: z.ZodMiniString<string>;
+}, z.core.$strip>]>;
+export type LocationPayload = z.infer<typeof LocationPayloadZod>;
+export declare const isLocationPayload: <T>(value: T) => value is T & ({
+    schema: "network.xyo.location" & {
+        readonly __schema: true;
+    };
+    latitude: number;
+    longitude: number;
+    accuracy?: number | undefined;
+    altitude?: number | undefined;
+    altitudeAccuracy?: number | undefined;
+} | {
+    schema: "network.xyo.location" & {
+        readonly __schema: true;
+    };
+    quadkey: string;
+    altitude?: number | undefined;
+    altitudeAccuracy?: number | undefined;
+});
+export declare const asLocationPayload: {
+    <T>(value: T): (T & ({
+        schema: "network.xyo.location" & {
+            readonly __schema: true;
+        };
+        latitude: number;
+        longitude: number;
+        accuracy?: number | undefined;
+        altitude?: number | undefined;
+        altitudeAccuracy?: number | undefined;
+    } | {
+        schema: "network.xyo.location" & {
+            readonly __schema: true;
+        };
+        quadkey: string;
+        altitude?: number | undefined;
+        altitudeAccuracy?: number | undefined;
+    })) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & ({
+        schema: "network.xyo.location" & {
+            readonly __schema: true;
+        };
+        latitude: number;
+        longitude: number;
+        accuracy?: number | undefined;
+        altitude?: number | undefined;
+        altitudeAccuracy?: number | undefined;
+    } | {
+        schema: "network.xyo.location" & {
+            readonly __schema: true;
+        };
+        quadkey: string;
+        altitude?: number | undefined;
+        altitudeAccuracy?: number | undefined;
+    });
+};
+export declare const toLocationPayload: {
+    <T>(value: T): (T & ({
+        schema: "network.xyo.location" & {
+            readonly __schema: true;
+        };
+        latitude: number;
+        longitude: number;
+        accuracy?: number | undefined;
+        altitude?: number | undefined;
+        altitudeAccuracy?: number | undefined;
+    } | {
+        schema: "network.xyo.location" & {
+            readonly __schema: true;
+        };
+        quadkey: string;
+        altitude?: number | undefined;
+        altitudeAccuracy?: number | undefined;
+    })) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & ({
+        schema: "network.xyo.location" & {
+            readonly __schema: true;
+        };
+        latitude: number;
+        longitude: number;
+        accuracy?: number | undefined;
+        altitude?: number | undefined;
+        altitudeAccuracy?: number | undefined;
+    } | {
+        schema: "network.xyo.location" & {
+            readonly __schema: true;
+        };
+        quadkey: string;
+        altitude?: number | undefined;
+        altitudeAccuracy?: number | undefined;
+    });
+};
 //# sourceMappingURL=GeographicCoordinateSystemLocationPayload.d.ts.map

package/dist/neutral/GeographicCoordinateSystemLocationPayload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GeographicCoordinateSystemLocationPayload.d.ts","sourceRoot":"","sources":["../../src/GeographicCoordinateSystemLocationPayload.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAElD,OAAO,KAAK,EAAE,wCAAwC,EAAE,qBAAqB,EAAE,MAAM,+CAA+C,CAAA;AAGpI,MAAM,WAAW,kCAAkC;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,MAAM,QAAQ,GAAG,kCAAkC,GAAG,eAAe,CAAA;AAE3E,MAAM,MAAM,yCAAyC,GAAG,OAAO,CAAC,kCAAkC,EAAE,wCAAwC,CAAC,CAAA;AAE7I,MAAM,MAAM,sBAAsB,GAAG,OAAO,CAAC,eAAe,EAAE,qBAAqB,CAAC,CAAA;AAEpF,MAAM,MAAM,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"GeographicCoordinateSystemLocationPayload.d.ts","sourceRoot":"","sources":["../../src/GeographicCoordinateSystemLocationPayload.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAO7B,eAAO,MAAM,qCAAqC;;;;;;iBAMhD,CAAA;AAEF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAA;AAEtG,eAAO,MAAM,kBAAkB;;;;iBAI7B,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEhE,eAAO,MAAM,WAAW;;;;;;;;;;mBAAuE,CAAA;AAE/F,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAElD,eAAO,MAAM,4CAA4C;;;;;;;;;iBAA6H,CAAA;AAEtL,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4CAA4C,CAAC,CAAA;AAEpH,eAAO,MAAM,2CAA2C;;;;;;;;;CAA6D,CAAA;AACrH,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;CAGvD,CAAA;AACD,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;CAGvD,CAAA;AAED,eAAO,MAAM,yBAAyB;;;;;;;iBAAuF,CAAA;AAE7H,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE9E,eAAO,MAAM,wBAAwB;;;;;;;CAA0C,CAAA;AAC/E,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;CAAsE,CAAA;AAC3G,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;CAAsE,CAAA;AAE3G,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;mBAG7B,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEhE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;EAAmC,CAAA;AACjE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwD,CAAA;AACtF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwD,CAAA"}

package/dist/neutral/HeadingPayload.d.ts

@@ -1,16 +1,116 @@
-import type { Payload } from '@xyo-network/sdk-js';
-import type { LocationHeadingSchema } from './HeadingSchema.ts';
-export interface Acceleration {
-    acceleration: number;
-}
-export interface Heading {
-    heading: number;
-}
-export interface Speed {
+import * as z from 'zod/mini';
+export declare const AccelerationZod: z.ZodMiniObject<{
+    acceleration: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+export type Acceleration = z.infer<typeof AccelerationZod>;
+export declare const HeadingZod: z.ZodMiniObject<{
+    heading: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+export type Heading = z.infer<typeof HeadingZod>;
+export declare const SpeedZod: z.ZodMiniObject<{
+    speed: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+export type Speed = z.infer<typeof SpeedZod>;
+export declare const VelocityZod: z.ZodMiniObject<{
+    speed: z.ZodMiniNumber<number>;
+    heading: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+export type Velocity = z.infer<typeof VelocityZod>;
+export declare const MotionZod: z.ZodMiniObject<{
+    acceleration: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    speed: z.ZodMiniNumber<number>;
+    heading: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+export type Motion = z.infer<typeof MotionZod>;
+export declare const LocationHeadingZod: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+    acceleration: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    speed: z.ZodMiniNumber<number>;
+    heading: z.ZodMiniNumber<number>;
+}, z.core.$strip>, z.ZodMiniObject<{
+    heading: z.ZodMiniNumber<number>;
+}, z.core.$strip>]>;
+export type LocationHeading = z.infer<typeof LocationHeadingZod>;
+export declare const LocationHeadingPayloadZod: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.location.heading" & {
+        readonly __schema: true;
+    }>;
+    acceleration: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    speed: z.ZodMiniNumber<number>;
+    heading: z.ZodMiniNumber<number>;
+}, z.core.$strip>, z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.location.heading" & {
+        readonly __schema: true;
+    }>;
+    heading: z.ZodMiniNumber<number>;
+}, z.core.$strip>]>;
+export type LocationHeadingPayload = z.infer<typeof LocationHeadingPayloadZod>;
+export declare const isLocationHeadingPayload: <T>(value: T) => value is T & ({
+    schema: "network.xyo.location.heading" & {
+        readonly __schema: true;
+    };
     speed: number;
-}
-export type Velocity = Heading & Speed;
-export type Motion = Velocity & Partial<Acceleration>;
-export type LocationHeading = Motion | Heading;
-export type LocationHeadingPayload = Payload<LocationHeading, LocationHeadingSchema>;
+    heading: number;
+    acceleration?: number | undefined;
+} | {
+    schema: "network.xyo.location.heading" & {
+        readonly __schema: true;
+    };
+    heading: number;
+});
+export declare const asLocationHeadingPayload: {
+    <T>(value: T): (T & ({
+        schema: "network.xyo.location.heading" & {
+            readonly __schema: true;
+        };
+        speed: number;
+        heading: number;
+        acceleration?: number | undefined;
+    } | {
+        schema: "network.xyo.location.heading" & {
+            readonly __schema: true;
+        };
+        heading: number;
+    })) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & ({
+        schema: "network.xyo.location.heading" & {
+            readonly __schema: true;
+        };
+        speed: number;
+        heading: number;
+        acceleration?: number | undefined;
+    } | {
+        schema: "network.xyo.location.heading" & {
+            readonly __schema: true;
+        };
+        heading: number;
+    });
+};
+export declare const toLocationHeadingPayload: {
+    <T>(value: T): (T & ({
+        schema: "network.xyo.location.heading" & {
+            readonly __schema: true;
+        };
+        speed: number;
+        heading: number;
+        acceleration?: number | undefined;
+    } | {
+        schema: "network.xyo.location.heading" & {
+            readonly __schema: true;
+        };
+        heading: number;
+    })) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & ({
+        schema: "network.xyo.location.heading" & {
+            readonly __schema: true;
+        };
+        speed: number;
+        heading: number;
+        acceleration?: number | undefined;
+    } | {
+        schema: "network.xyo.location.heading" & {
+            readonly __schema: true;
+        };
+        heading: number;
+    });
+};
 //# sourceMappingURL=HeadingPayload.d.ts.map

package/dist/neutral/HeadingPayload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HeadingPayload.d.ts","sourceRoot":"","sources":["../../src/HeadingPayload.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAElD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAE/D,MAAM,WAAW,YAAY;IAC3B,YAAY,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,OAAO;IACtB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,KAAK;IACpB,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,KAAK,CAAA;AAEtC,MAAM,MAAM,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAA;AAErD,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,OAAO,CAAA;AAE9C,MAAM,MAAM,sBAAsB,GAAG,OAAO,CAAC,eAAe,EAAE,qBAAqB,CAAC,CAAA"}
+{"version":3,"file":"HeadingPayload.d.ts","sourceRoot":"","sources":["../../src/HeadingPayload.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAI7B,eAAO,MAAM,eAAe;;iBAAyC,CAAA;AAErE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE1D,eAAO,MAAM,UAAU;;iBAAoC,CAAA;AAE3D,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AAEhD,eAAO,MAAM,QAAQ;;iBAAkC,CAAA;AAEvD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE5C,eAAO,MAAM,WAAW;;;iBAGtB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAElD,eAAO,MAAM,SAAS;;;;iBAGpB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAE9C,eAAO,MAAM,kBAAkB;;;;;;mBAAmC,CAAA;AAElE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEhE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;mBAGpC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE9E,eAAO,MAAM,wBAAwB;;;;;;;;;;;;EAA0C,CAAA;AAC/E,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAsE,CAAA;AAC3G,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAsE,CAAA"}

package/dist/neutral/Plugin.d.ts

@@ -1,3 +1,18 @@
-import type { LocationPayload } from './GeographicCoordinateSystemLocationPayload.ts';
-export declare const LocationPayloadPlugin: () => import("@xyo-network/sdk-js").PayloadPlugin<LocationPayload>;
+export declare const LocationPayloadPlugin: () => import("@xyo-network/sdk-js").PayloadPlugin<{
+    schema: "network.xyo.location" & {
+        readonly __schema: true;
+    };
+    latitude: number;
+    longitude: number;
+    accuracy?: number | undefined;
+    altitude?: number | undefined;
+    altitudeAccuracy?: number | undefined;
+} | {
+    schema: "network.xyo.location" & {
+        readonly __schema: true;
+    };
+    quadkey: string;
+    altitude?: number | undefined;
+    altitudeAccuracy?: number | undefined;
+}>;
 //# sourceMappingURL=Plugin.d.ts.map

package/dist/neutral/Plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Plugin.d.ts","sourceRoot":"","sources":["../../src/Plugin.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gDAAgD,CAAA;AAGrF,eAAO,MAAM,qBAAqB,oEACgC,CAAA"}
+{"version":3,"file":"Plugin.d.ts","sourceRoot":"","sources":["../../src/Plugin.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;EACgC,CAAA"}

package/dist/neutral/index.mjs

@@ -1,13 +1,88 @@
+// src/GeographicCoordinateSystemLocationPayload.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk-js";
+import { PayloadZodOfSchema } from "@xyo-network/sdk-js";
+import * as z from "zod/mini";
+
 // src/GeographicCoordinateSystemLocationSchema.ts
 import { asSchema } from "@xyo-network/sdk-js";
 var GeographicCoordinateSystemLocationSchema = asSchema("network.xyo.location.gcs", true);
 var QuadkeyLocationSchema = asSchema("network.xyo.location.quadkey", true);
 var LocationSchema = asSchema("network.xyo.location", true);
 
+// src/GeographicCoordinateSystemLocationPayload.ts
+var GeographicCoordinateSystemLocationZod = z.object({
+  accuracy: z.optional(z.number()),
+  altitude: z.optional(z.number()),
+  altitudeAccuracy: z.optional(z.number()),
+  latitude: z.number(),
+  longitude: z.number()
+});
+var QuadkeyLocationZod = z.object({
+  altitude: z.optional(z.number()),
+  altitudeAccuracy: z.optional(z.number()),
+  quadkey: z.string()
+});
+var LocationZod = z.union([GeographicCoordinateSystemLocationZod, QuadkeyLocationZod]);
+var GeographicCoordinateSystemLocationPayloadZod = z.extend(PayloadZodOfSchema(GeographicCoordinateSystemLocationSchema), { ...GeographicCoordinateSystemLocationZod.shape });
+var isGeographicCoordinateSystemLocationPayload = zodIsFactory(GeographicCoordinateSystemLocationPayloadZod);
+var asGeographicCoordinateSystemLocationPayload = zodAsFactory(
+  GeographicCoordinateSystemLocationPayloadZod,
+  "asGeographicCoordinateSystemLocationPayload"
+);
+var toGeographicCoordinateSystemLocationPayload = zodToFactory(
+  GeographicCoordinateSystemLocationPayloadZod,
+  "toGeographicCoordinateSystemLocationPayload"
+);
+var QuadkeyLocationPayloadZod = z.extend(PayloadZodOfSchema(QuadkeyLocationSchema), { ...QuadkeyLocationZod.shape });
+var isQuadkeyLocationPayload = zodIsFactory(QuadkeyLocationPayloadZod);
+var asQuadkeyLocationPayload = zodAsFactory(QuadkeyLocationPayloadZod, "asQuadkeyLocationPayload");
+var toQuadkeyLocationPayload = zodToFactory(QuadkeyLocationPayloadZod, "toQuadkeyLocationPayload");
+var LocationPayloadZod = z.union([
+  z.extend(PayloadZodOfSchema(LocationSchema), { ...GeographicCoordinateSystemLocationZod.shape }),
+  z.extend(PayloadZodOfSchema(LocationSchema), { ...QuadkeyLocationZod.shape })
+]);
+var isLocationPayload = zodIsFactory(LocationPayloadZod);
+var asLocationPayload = zodAsFactory(LocationPayloadZod, "asLocationPayload");
+var toLocationPayload = zodToFactory(LocationPayloadZod, "toLocationPayload");
+
+// src/HeadingPayload.ts
+import {
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@xylabs/sdk-js";
+import { PayloadZodOfSchema as PayloadZodOfSchema2 } from "@xyo-network/sdk-js";
+import * as z2 from "zod/mini";
+
 // src/HeadingSchema.ts
 import { asSchema as asSchema2 } from "@xyo-network/sdk-js";
 var LocationHeadingSchema = asSchema2("network.xyo.location.heading", true);
 
+// src/HeadingPayload.ts
+var AccelerationZod = z2.object({ acceleration: z2.number() });
+var HeadingZod = z2.object({ heading: z2.number() });
+var SpeedZod = z2.object({ speed: z2.number() });
+var VelocityZod = z2.object({
+  ...HeadingZod.shape,
+  ...SpeedZod.shape
+});
+var MotionZod = z2.object({
+  ...VelocityZod.shape,
+  acceleration: z2.optional(z2.number())
+});
+var LocationHeadingZod = z2.union([MotionZod, HeadingZod]);
+var LocationHeadingPayloadZod = z2.union([
+  z2.extend(PayloadZodOfSchema2(LocationHeadingSchema), { ...MotionZod.shape }),
+  z2.extend(PayloadZodOfSchema2(LocationHeadingSchema), { ...HeadingZod.shape })
+]);
+var isLocationHeadingPayload = zodIsFactory2(LocationHeadingPayloadZod);
+var asLocationHeadingPayload = zodAsFactory2(LocationHeadingPayloadZod, "asLocationHeadingPayload");
+var toLocationHeadingPayload = zodToFactory2(LocationHeadingPayloadZod, "toLocationHeadingPayload");
+
 // src/Plugin.ts
 import { createPayloadPlugin } from "@xyo-network/sdk-js";
 var LocationPayloadPlugin = () => createPayloadPlugin({ schema: LocationSchema });
@@ -16,12 +91,37 @@ var LocationPayloadPlugin = () => createPayloadPlugin({ schema: LocationSchema }
 import { asSchema as asSchema3 } from "@xyo-network/sdk-js";
 var CurrentLocationSchema = asSchema3("network.xyo.location.current", true);
 export {
+  AccelerationZod,
   CurrentLocationSchema,
+  GeographicCoordinateSystemLocationPayloadZod,
   GeographicCoordinateSystemLocationSchema,
+  GeographicCoordinateSystemLocationZod,
+  HeadingZod,
+  LocationHeadingPayloadZod,
   LocationHeadingSchema,
+  LocationHeadingZod,
   LocationPayloadPlugin,
+  LocationPayloadZod,
   LocationSchema,
+  LocationZod,
+  MotionZod,
+  QuadkeyLocationPayloadZod,
   QuadkeyLocationSchema,
-  LocationPayloadPlugin as default
+  QuadkeyLocationZod,
+  SpeedZod,
+  VelocityZod,
+  asGeographicCoordinateSystemLocationPayload,
+  asLocationHeadingPayload,
+  asLocationPayload,
+  asQuadkeyLocationPayload,
+  LocationPayloadPlugin as default,
+  isGeographicCoordinateSystemLocationPayload,
+  isLocationHeadingPayload,
+  isLocationPayload,
+  isQuadkeyLocationPayload,
+  toGeographicCoordinateSystemLocationPayload,
+  toLocationHeadingPayload,
+  toLocationPayload,
+  toQuadkeyLocationPayload
 };
 //# sourceMappingURL=index.mjs.map

package/dist/neutral/index.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../../src/GeographicCoordinateSystemLocationSchema.ts", "../../src/HeadingSchema.ts", "../../src/Plugin.ts", "../../src/Schema.ts"],
-  "sourcesContent": ["import { asSchema } from '@xyo-network/sdk-js'\n\nexport type GeographicCoordinateSystemLocationSchema = typeof GeographicCoordinateSystemLocationSchema\nexport const GeographicCoordinateSystemLocationSchema = asSchema('network.xyo.location.gcs', true)\n\nexport type QuadkeyLocationSchema = typeof QuadkeyLocationSchema\nexport const QuadkeyLocationSchema = asSchema('network.xyo.location.quadkey', true)\n\nexport type LocationSchema = typeof LocationSchema\nexport const LocationSchema = asSchema('network.xyo.location', true)\n", "import { asSchema } from '@xyo-network/sdk-js'\n\nexport type LocationHeadingSchema = typeof LocationHeadingSchema\nexport const LocationHeadingSchema = asSchema('network.xyo.location.heading', true)\n", "import { createPayloadPlugin } from '@xyo-network/sdk-js'\n\nimport type { LocationPayload } from './GeographicCoordinateSystemLocationPayload.ts'\nimport { LocationSchema } from './GeographicCoordinateSystemLocationSchema.ts'\n\nexport const LocationPayloadPlugin = () =>\n  createPayloadPlugin<LocationPayload>({ schema: LocationSchema })\n", "import { asSchema } from '@xyo-network/sdk-js'\n\nexport type CurrentLocationSchema = typeof CurrentLocationSchema\nexport const CurrentLocationSchema = asSchema('network.xyo.location.current', true)\n"],
-  "mappings": ";AAAA,SAAS,gBAAgB;AAGlB,IAAM,2CAA2C,SAAS,4BAA4B,IAAI;AAG1F,IAAM,wBAAwB,SAAS,gCAAgC,IAAI;AAG3E,IAAM,iBAAiB,SAAS,wBAAwB,IAAI;;;ACTnE,SAAS,YAAAA,iBAAgB;AAGlB,IAAM,wBAAwBA,UAAS,gCAAgC,IAAI;;;ACHlF,SAAS,2BAA2B;AAK7B,IAAM,wBAAwB,MACnC,oBAAqC,EAAE,QAAQ,eAAe,CAAC;;;ACNjE,SAAS,YAAAC,iBAAgB;AAGlB,IAAM,wBAAwBA,UAAS,gCAAgC,IAAI;",
-  "names": ["asSchema", "asSchema"]
+  "sources": ["../../src/GeographicCoordinateSystemLocationPayload.ts", "../../src/GeographicCoordinateSystemLocationSchema.ts", "../../src/HeadingPayload.ts", "../../src/HeadingSchema.ts", "../../src/Plugin.ts", "../../src/Schema.ts"],
+  "sourcesContent": ["import {\n  zodAsFactory, zodIsFactory, zodToFactory,\n} from '@xylabs/sdk-js'\nimport { PayloadZodOfSchema } from '@xyo-network/sdk-js'\nimport * as z from 'zod/mini'\n\nimport {\n  GeographicCoordinateSystemLocationSchema, LocationSchema, QuadkeyLocationSchema,\n} from './GeographicCoordinateSystemLocationSchema.ts'\n\n// Geographic Coordinate system (GCS) is the official name of lng/lat system\nexport const GeographicCoordinateSystemLocationZod = z.object({\n  accuracy: z.optional(z.number()),\n  altitude: z.optional(z.number()),\n  altitudeAccuracy: z.optional(z.number()),\n  latitude: z.number(),\n  longitude: z.number(),\n})\n\nexport type GeographicCoordinateSystemLocation = z.infer<typeof GeographicCoordinateSystemLocationZod>\n\nexport const QuadkeyLocationZod = z.object({\n  altitude: z.optional(z.number()),\n  altitudeAccuracy: z.optional(z.number()),\n  quadkey: z.string(),\n})\n\nexport type QuadkeyLocation = z.infer<typeof QuadkeyLocationZod>\n\nexport const LocationZod = z.union([GeographicCoordinateSystemLocationZod, QuadkeyLocationZod])\n\nexport type Location = z.infer<typeof LocationZod>\n\nexport const GeographicCoordinateSystemLocationPayloadZod = z.extend(PayloadZodOfSchema(GeographicCoordinateSystemLocationSchema), { ...GeographicCoordinateSystemLocationZod.shape })\n\nexport type GeographicCoordinateSystemLocationPayload = z.infer<typeof GeographicCoordinateSystemLocationPayloadZod>\n\nexport const isGeographicCoordinateSystemLocationPayload = zodIsFactory(GeographicCoordinateSystemLocationPayloadZod)\nexport const asGeographicCoordinateSystemLocationPayload = zodAsFactory(\n  GeographicCoordinateSystemLocationPayloadZod,\n  'asGeographicCoordinateSystemLocationPayload',\n)\nexport const toGeographicCoordinateSystemLocationPayload = zodToFactory(\n  GeographicCoordinateSystemLocationPayloadZod,\n  'toGeographicCoordinateSystemLocationPayload',\n)\n\nexport const QuadkeyLocationPayloadZod = z.extend(PayloadZodOfSchema(QuadkeyLocationSchema), { ...QuadkeyLocationZod.shape })\n\nexport type QuadkeyLocationPayload = z.infer<typeof QuadkeyLocationPayloadZod>\n\nexport const isQuadkeyLocationPayload = zodIsFactory(QuadkeyLocationPayloadZod)\nexport const asQuadkeyLocationPayload = zodAsFactory(QuadkeyLocationPayloadZod, 'asQuadkeyLocationPayload')\nexport const toQuadkeyLocationPayload = zodToFactory(QuadkeyLocationPayloadZod, 'toQuadkeyLocationPayload')\n\nexport const LocationPayloadZod = z.union([\n  z.extend(PayloadZodOfSchema(LocationSchema), { ...GeographicCoordinateSystemLocationZod.shape }),\n  z.extend(PayloadZodOfSchema(LocationSchema), { ...QuadkeyLocationZod.shape }),\n])\n\nexport type LocationPayload = z.infer<typeof LocationPayloadZod>\n\nexport const isLocationPayload = zodIsFactory(LocationPayloadZod)\nexport const asLocationPayload = zodAsFactory(LocationPayloadZod, 'asLocationPayload')\nexport const toLocationPayload = zodToFactory(LocationPayloadZod, 'toLocationPayload')\n", "import { asSchema } from '@xyo-network/sdk-js'\n\nexport type GeographicCoordinateSystemLocationSchema = typeof GeographicCoordinateSystemLocationSchema\nexport const GeographicCoordinateSystemLocationSchema = asSchema('network.xyo.location.gcs', true)\n\nexport type QuadkeyLocationSchema = typeof QuadkeyLocationSchema\nexport const QuadkeyLocationSchema = asSchema('network.xyo.location.quadkey', true)\n\nexport type LocationSchema = typeof LocationSchema\nexport const LocationSchema = asSchema('network.xyo.location', true)\n", "import {\n  zodAsFactory, zodIsFactory, zodToFactory,\n} from '@xylabs/sdk-js'\nimport { PayloadZodOfSchema } from '@xyo-network/sdk-js'\nimport * as z from 'zod/mini'\n\nimport { LocationHeadingSchema } from './HeadingSchema.ts'\n\nexport const AccelerationZod = z.object({ acceleration: z.number() })\n\nexport type Acceleration = z.infer<typeof AccelerationZod>\n\nexport const HeadingZod = z.object({ heading: z.number() })\n\nexport type Heading = z.infer<typeof HeadingZod>\n\nexport const SpeedZod = z.object({ speed: z.number() })\n\nexport type Speed = z.infer<typeof SpeedZod>\n\nexport const VelocityZod = z.object({\n  ...HeadingZod.shape,\n  ...SpeedZod.shape,\n})\n\nexport type Velocity = z.infer<typeof VelocityZod>\n\nexport const MotionZod = z.object({\n  ...VelocityZod.shape,\n  acceleration: z.optional(z.number()),\n})\n\nexport type Motion = z.infer<typeof MotionZod>\n\nexport const LocationHeadingZod = z.union([MotionZod, HeadingZod])\n\nexport type LocationHeading = z.infer<typeof LocationHeadingZod>\n\nexport const LocationHeadingPayloadZod = z.union([\n  z.extend(PayloadZodOfSchema(LocationHeadingSchema), { ...MotionZod.shape }),\n  z.extend(PayloadZodOfSchema(LocationHeadingSchema), { ...HeadingZod.shape }),\n])\n\nexport type LocationHeadingPayload = z.infer<typeof LocationHeadingPayloadZod>\n\nexport const isLocationHeadingPayload = zodIsFactory(LocationHeadingPayloadZod)\nexport const asLocationHeadingPayload = zodAsFactory(LocationHeadingPayloadZod, 'asLocationHeadingPayload')\nexport const toLocationHeadingPayload = zodToFactory(LocationHeadingPayloadZod, 'toLocationHeadingPayload')\n", "import { asSchema } from '@xyo-network/sdk-js'\n\nexport type LocationHeadingSchema = typeof LocationHeadingSchema\nexport const LocationHeadingSchema = asSchema('network.xyo.location.heading', true)\n", "import { createPayloadPlugin } from '@xyo-network/sdk-js'\n\nimport type { LocationPayload } from './GeographicCoordinateSystemLocationPayload.ts'\nimport { LocationSchema } from './GeographicCoordinateSystemLocationSchema.ts'\n\nexport const LocationPayloadPlugin = () =>\n  createPayloadPlugin<LocationPayload>({ schema: LocationSchema })\n", "import { asSchema } from '@xyo-network/sdk-js'\n\nexport type CurrentLocationSchema = typeof CurrentLocationSchema\nexport const CurrentLocationSchema = asSchema('network.xyo.location.current', true)\n"],
+  "mappings": "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",
+  "names": ["zodAsFactory", "zodIsFactory", "zodToFactory", "PayloadZodOfSchema", "z", "asSchema", "PayloadZodOfSchema", "zodIsFactory", "zodAsFactory", "zodToFactory", "asSchema"]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/location-payload-plugin",
-  "version": "6.1.0",
+  "version": "7.0.0",
   "description": "Typescript/Javascript Plugins for XYO Platform",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -35,21 +35,21 @@
     "@metamask/providers": "^22.1.1",
     "@noble/post-quantum": "~0.6.1",
     "@opentelemetry/api": "^1.9.1",
-    "@opentelemetry/sdk-trace-base": "^2.7.1",
+    "@opentelemetry/sdk-trace-base": "^2.8.0",
     "@scure/base": "^2.2.0",
     "@scure/bip39": "~2.2.0",
-    "@xylabs/geo": "^6.1.0",
-    "@xylabs/sdk-js": "^6.1.0",
-    "@xylabs/threads": "^6.1.0",
-    "@xylabs/toolchain": "~8.1.20",
-    "@xylabs/tsconfig": "~8.1.20",
-    "@xylabs/vitest-extended": "^6.1.0",
-    "@xyo-network/sdk-js": "^6.1.0",
-    "@xyo-network/sdk-protocol-js": "~6.1",
+    "@xylabs/geo": "^6.1.3",
+    "@xylabs/sdk-js": "^6.1.3",
+    "@xylabs/threads": "^6.1.3",
+    "@xylabs/toolchain": "~8.2.7",
+    "@xylabs/tsconfig": "~8.2.7",
+    "@xylabs/vitest-extended": "^6.1.3",
+    "@xyo-network/sdk-js": "^7.0.0",
+    "@xyo-network/sdk-protocol-js": "~7.0",
     "ajv": "^8.20.0",
     "async-mutex": "^0.5.0",
     "debug": "~4.4.3",
-    "eslint": "^10.4.1",
+    "eslint": "^10.5.0",
     "ethers": "^6.16.0",
     "hash-wasm": "^4.12.0",
     "idb": "^8.0.3",
@@ -57,7 +57,7 @@
     "observable-fns": "~0.6.1",
     "typescript": "~6.0.3",
     "vite": "^8.0.16",
-    "vitest": "^4.1.8",
+    "vitest": "^4.1.9",
     "webextension-polyfill": "^0.12.0",
     "zod": "^4.4.3"
   },
@@ -72,8 +72,8 @@
     "@xylabs/geo": "^6.0",
     "@xylabs/sdk-js": "^6.0",
     "@xylabs/threads": "^6.0",
-    "@xyo-network/sdk-js": "^6.0",
-    "@xyo-network/sdk-protocol-js": "^6.1",
+    "@xyo-network/sdk-js": "^7.0",
+    "@xyo-network/sdk-protocol-js": "~7.0",
     "ajv": "^8.20",
     "async-mutex": "^0.5",
     "debug": "~4.4",