@xyo-network/payload-plugins 7.0.3 → 7.1.0

package/dist/neutral/modules/image-thumbnail/Payload/ImageThumbnailResult.d.ts

@@ -0,0 +1,81 @@
+import * as z from 'zod/mini';
+export declare const ImageThumbnailResultSchema: string & {
+    readonly __schema: true;
+};
+export type ImageThumbnailResultSchema = typeof ImageThumbnailResultSchema;
+/**
+ * The result of an image thumbnail witness
+ */
+export declare const ImageThumbnailResultFieldsZod: z.ZodMiniObject<{
+    status: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    success: z.ZodMiniBoolean<boolean>;
+    timestamp: z.ZodMiniNumber<number>;
+    url: z.ZodMiniString<string>;
+}, z.core.$strip>;
+export type ImageThumbnailResultFields = z.infer<typeof ImageThumbnailResultFieldsZod>;
+/**
+ * A payload containing the result of an image thumbnail witness
+ */
+export declare const ImageThumbnailResultZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<string & {
+        readonly __schema: true;
+    }>;
+    status: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    success: z.ZodMiniBoolean<boolean>;
+    timestamp: z.ZodMiniNumber<number>;
+    url: z.ZodMiniString<string>;
+}, z.core.$strip>;
+export type ImageThumbnailResult = z.infer<typeof ImageThumbnailResultZod>;
+/**
+ * A type guard for ImageThumbnailResult
+ */
+export declare const isImageThumbnailResult: <T>(value: T) => value is T & {
+    schema: string & {
+        readonly __schema: true;
+    };
+    success: boolean;
+    timestamp: number;
+    url: string;
+    status?: number | undefined;
+};
+export declare const asImageThumbnailResult: {
+    <T>(value: T): (T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        success: boolean;
+        timestamp: number;
+        url: string;
+        status?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        success: boolean;
+        timestamp: number;
+        url: string;
+        status?: number | undefined;
+    };
+};
+export declare const toImageThumbnailResult: {
+    <T>(value: T): (T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        success: boolean;
+        timestamp: number;
+        url: string;
+        status?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        success: boolean;
+        timestamp: number;
+        url: string;
+        status?: number | undefined;
+    };
+};
+//# sourceMappingURL=ImageThumbnailResult.d.ts.map

package/dist/neutral/modules/image-thumbnail/Payload/ImageThumbnailResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImageThumbnailResult.d.ts","sourceRoot":"","sources":["../../../../../src/modules/image-thumbnail/Payload/ImageThumbnailResult.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAI7B,eAAO,MAAM,0BAA0B;;CAAmD,CAAA;AAC1F,MAAM,MAAM,0BAA0B,GAAG,OAAO,0BAA0B,CAAA;AAE1E;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;iBAiBxC,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEtF;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;iBAAuG,CAAA;AAE3I,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE1E;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;CAAwC,CAAA;AAC3E,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;CAAkE,CAAA;AACrG,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;CAAkE,CAAA"}

package/dist/neutral/modules/image-thumbnail/Payload/ImageThumbnailResultIndex.d.ts

@@ -0,0 +1,92 @@
+import type { Hash } from '@ariestools/sdk';
+import * as z from 'zod/mini';
+export declare const ImageThumbnailResultIndexSchema: string & {
+    readonly __schema: true;
+};
+export type ImageThumbnailResultIndexSchema = typeof ImageThumbnailResultIndexSchema;
+/**
+ * An index which is keyed by a hash. Used to create uniformity in the way
+ * we index data (key length, character set, etc).
+ */
+export type HashKeyedIndex<T> = T & {
+    /**
+     * The key for the index. Should be a hash of the relevant identifying data.
+     */
+    key: Hash;
+};
+/**
+ * The hash-keyed index of an ImageThumbnailResult
+ */
+export declare const ImageThumbnailResultIndexFieldsZod: z.ZodMiniObject<{
+    success: z.ZodMiniBoolean<boolean>;
+    timestamp: z.ZodMiniNumber<number>;
+    status: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    key: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+}, z.core.$strip>;
+export type ImageThumbnailResultIndexFields = z.infer<typeof ImageThumbnailResultIndexFieldsZod>;
+/**
+ * A payload containing the hash-keyed index of an ImageThumbnailResult
+ */
+export declare const ImageThumbnailResultIndexZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<string & {
+        readonly __schema: true;
+    }>;
+    success: z.ZodMiniBoolean<boolean>;
+    timestamp: z.ZodMiniNumber<number>;
+    status: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    key: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+}, z.core.$strip>;
+export type ImageThumbnailResultIndex = z.infer<typeof ImageThumbnailResultIndexZod>;
+/**
+ * A type guard for ImageThumbnailResultIndex
+ */
+export declare const isImageThumbnailResultIndex: <T>(value: T) => value is T & {
+    schema: string & {
+        readonly __schema: true;
+    };
+    success: boolean;
+    timestamp: number;
+    key: import("@ariestools/sdk").BrandedHash;
+    status?: number | undefined;
+};
+export declare const asImageThumbnailResultIndex: {
+    <T>(value: T): (T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        success: boolean;
+        timestamp: number;
+        key: import("@ariestools/sdk").BrandedHash;
+        status?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        success: boolean;
+        timestamp: number;
+        key: import("@ariestools/sdk").BrandedHash;
+        status?: number | undefined;
+    };
+};
+export declare const toImageThumbnailResultIndex: {
+    <T>(value: T): (T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        success: boolean;
+        timestamp: number;
+        key: import("@ariestools/sdk").BrandedHash;
+        status?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        success: boolean;
+        timestamp: number;
+        key: import("@ariestools/sdk").BrandedHash;
+        status?: number | undefined;
+    };
+};
+//# sourceMappingURL=ImageThumbnailResultIndex.d.ts.map

package/dist/neutral/modules/image-thumbnail/Payload/ImageThumbnailResultIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImageThumbnailResultIndex.d.ts","sourceRoot":"","sources":["../../../../../src/modules/image-thumbnail/Payload/ImageThumbnailResultIndex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAK3C,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAI7B,eAAO,MAAM,+BAA+B;;CAAwD,CAAA;AACpG,MAAM,MAAM,+BAA+B,GAAG,OAAO,+BAA+B,CAAA;AAEpF;;;GAGG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,GAAG;IAClC;;OAEG;IACH,GAAG,EAAE,IAAI,CAAA;CACV,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,kCAAkC;;;;;iBAK7C,CAAA;AAEF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAEhG;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;iBAAiH,CAAA;AAE1J,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEpF;;GAEG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;CAA6C,CAAA;AACrF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;CAA4E,CAAA;AACpH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;CAA4E,CAAA"}

package/dist/neutral/modules/image-thumbnail/Payload/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ImageThumbnail.js';
+export * from './ImageThumbnailResult.js';
+export * from './ImageThumbnailResultIndex.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/image-thumbnail/Payload/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/image-thumbnail/Payload/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,2BAA2B,CAAA;AACzC,cAAc,gCAAgC,CAAA"}

package/dist/neutral/modules/image-thumbnail/Plugin.d.ts

@@ -0,0 +1,23 @@
+export declare const ImageThumbnailPayloadPlugin: () => import("@xyo-network/sdk").PayloadPlugin<{
+    schema: "network.xyo.image.thumbnail" & {
+        readonly __schema: true;
+    };
+    sourceUrl: string;
+    http?: {
+        code?: string | undefined;
+        ipAddress?: string | undefined;
+        status?: number | undefined;
+    } | undefined;
+    mime?: {
+        detected?: {
+            ext?: string | undefined;
+            mime?: string | undefined;
+        } | undefined;
+        invalid?: boolean | undefined;
+        returned?: string | undefined;
+        type?: string | undefined;
+    } | undefined;
+    sourceHash?: string | undefined;
+    url?: string | undefined;
+}>;
+//# sourceMappingURL=Plugin.d.ts.map

package/dist/neutral/modules/image-thumbnail/Plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Plugin.d.ts","sourceRoot":"","sources":["../../../../src/modules/image-thumbnail/Plugin.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;EAC+B,CAAA"}

package/dist/neutral/modules/image-thumbnail/Schema.d.ts

@@ -0,0 +1,5 @@
+export declare const ImageThumbnailSchema: "network.xyo.image.thumbnail" & {
+    readonly __schema: true;
+};
+export type ImageThumbnailSchema = typeof ImageThumbnailSchema;
+//# sourceMappingURL=Schema.d.ts.map

package/dist/neutral/modules/image-thumbnail/Schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../../../../src/modules/image-thumbnail/Schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB;;CAAgD,CAAA;AACjF,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA"}

package/dist/neutral/modules/image-thumbnail/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Diviner/index.js';
+export * from './Payload/index.js';
+export { ImageThumbnailPayloadPlugin as default, ImageThumbnailPayloadPlugin } from './Plugin.js';
+export * from './Schema.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/image-thumbnail/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/image-thumbnail/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,OAAO,EAAE,2BAA2B,IAAI,OAAO,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAA;AACjG,cAAc,aAAa,CAAA"}

package/dist/neutral/modules/info-system/index.d.ts

@@ -0,0 +1,5 @@
+export * from '../bowser-system-info/index.js';
+import type { PayloadPluginFunc } from '@xyo-network/sdk';
+export declare const SystemInfoPayloadPlugins: PayloadPluginFunc[];
+export default SystemInfoPayloadPlugins;
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/info-system/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/info-system/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AAEnC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAKzD,eAAO,MAAM,wBAAwB,EAAE,iBAAiB,EAAiE,CAAA;AAEzH,eAAe,wBAAwB,CAAA"}

package/dist/neutral/modules/info-system/indexBrowser.d.ts

@@ -0,0 +1,5 @@
+export * from '../bowser-system-info/index.js';
+import type { PayloadPluginFunc } from '@xyo-network/sdk';
+export declare const SystemInfoPayloadPlugins: PayloadPluginFunc[];
+export default SystemInfoPayloadPlugins;
+//# sourceMappingURL=indexBrowser.d.ts.map

package/dist/neutral/modules/info-system/indexBrowser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexBrowser.d.ts","sourceRoot":"","sources":["../../../../src/modules/info-system/indexBrowser.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AAEnC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAIzD,eAAO,MAAM,wBAAwB,EAAE,iBAAiB,EAAoC,CAAA;AAE5F,eAAe,wBAAwB,CAAA"}

package/dist/neutral/modules/info-system/indexNode.d.ts

@@ -0,0 +1,5 @@
+export * from '../node-system-info/index.js';
+import type { PayloadPluginFunc } from '@xyo-network/sdk';
+export declare const SystemInfoPayloadPlugins: PayloadPluginFunc[];
+export default SystemInfoPayloadPlugins;
+//# sourceMappingURL=indexNode.d.ts.map

package/dist/neutral/modules/info-system/indexNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexNode.d.ts","sourceRoot":"","sources":["../../../../src/modules/info-system/indexNode.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AAEjC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAIzD,eAAO,MAAM,wBAAwB,EAAE,iBAAiB,EAAkC,CAAA;AAE1F,eAAe,wBAAwB,CAAA"}

package/dist/neutral/modules/location/GeographicCoordinateSystemLocationPayload.d.ts

@@ -0,0 +1,253 @@
+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;
+    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("@ariestools/sdk").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("@ariestools/sdk").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;
+    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("@ariestools/sdk").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("@ariestools/sdk").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("@ariestools/sdk").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("@ariestools/sdk").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/modules/location/GeographicCoordinateSystemLocationPayload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeographicCoordinateSystemLocationPayload.d.ts","sourceRoot":"","sources":["../../../../src/modules/location/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/modules/location/GeographicCoordinateSystemLocationSchema.d.ts

@@ -0,0 +1,13 @@
+export type GeographicCoordinateSystemLocationSchema = typeof GeographicCoordinateSystemLocationSchema;
+export declare const GeographicCoordinateSystemLocationSchema: "network.xyo.location.gcs" & {
+    readonly __schema: true;
+};
+export type QuadkeyLocationSchema = typeof QuadkeyLocationSchema;
+export declare const QuadkeyLocationSchema: "network.xyo.location.quadkey" & {
+    readonly __schema: true;
+};
+export type LocationSchema = typeof LocationSchema;
+export declare const LocationSchema: "network.xyo.location" & {
+    readonly __schema: true;
+};
+//# sourceMappingURL=GeographicCoordinateSystemLocationSchema.d.ts.map

package/dist/neutral/modules/location/GeographicCoordinateSystemLocationSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeographicCoordinateSystemLocationSchema.d.ts","sourceRoot":"","sources":["../../../../src/modules/location/GeographicCoordinateSystemLocationSchema.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,wCAAwC,GAAG,OAAO,wCAAwC,CAAA;AACtG,eAAO,MAAM,wCAAwC;;CAA6C,CAAA;AAElG,MAAM,MAAM,qBAAqB,GAAG,OAAO,qBAAqB,CAAA;AAChE,eAAO,MAAM,qBAAqB;;CAAiD,CAAA;AAEnF,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAA;AAClD,eAAO,MAAM,cAAc;;CAAyC,CAAA"}

package/dist/neutral/modules/location/HeadingPayload.d.ts

@@ -0,0 +1,116 @@
+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;
+    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("@ariestools/sdk").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("@ariestools/sdk").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