@awarevue/api-types 1.0.1

package/dist/device/intercom-terminal.d.ts

@@ -0,0 +1,244 @@
+import { z } from 'zod';
+export declare const INTERCOM_TERMINAL: "intercom-terminal";
+export declare const sIntercomTerminalSpecs: z.ZodObject<{
+    sipUri: z.ZodString;
+    sipUser: z.ZodString;
+    sipPassword: z.ZodString;
+    sipRealm: z.ZodString;
+    remoteExtension: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sipUri: string;
+    sipUser: string;
+    sipPassword: string;
+    sipRealm: string;
+    remoteExtension: string;
+}, {
+    sipUri: string;
+    sipUser: string;
+    sipPassword: string;
+    sipRealm: string;
+    remoteExtension: string;
+}>;
+export declare const sAddIntercomTerminal: z.ZodObject<{
+    name: z.ZodString;
+    foreignRef: z.ZodString;
+    specs: z.ZodObject<{
+        sipUri: z.ZodString;
+        sipUser: z.ZodString;
+        sipPassword: z.ZodString;
+        sipRealm: z.ZodString;
+        remoteExtension: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        sipUri: string;
+        sipUser: string;
+        sipPassword: string;
+        sipRealm: string;
+        remoteExtension: string;
+    }, {
+        sipUri: string;
+        sipUser: string;
+        sipPassword: string;
+        sipRealm: string;
+        remoteExtension: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    foreignRef: string;
+    specs: {
+        sipUri: string;
+        sipUser: string;
+        sipPassword: string;
+        sipRealm: string;
+        remoteExtension: string;
+    };
+}, {
+    name: string;
+    foreignRef: string;
+    specs: {
+        sipUri: string;
+        sipUser: string;
+        sipPassword: string;
+        sipRealm: string;
+        remoteExtension: string;
+    };
+}>;
+export type IntercomTerminalSpecs = z.infer<typeof sIntercomTerminalSpecs>;
+export type AddIntercomTerminalRequest = z.infer<typeof sAddIntercomTerminal>;
+export interface IntercomConnectCommand {
+    command: 'intercom-terminal.connect';
+    params: {
+        clientId: number;
+    };
+}
+export interface IntercomDisconnectCommand {
+    command: 'intercom-terminal.disconnect';
+    params: {
+        clientId: number;
+    };
+}
+export interface IntercomDialCommand {
+    command: 'intercom-terminal.dial';
+    params: {
+        callId: string;
+        offerSdp: string;
+    };
+}
+export interface IntercomCancelCallCommand {
+    command: 'intercom-terminal.cancel-call';
+    params: {
+        callId: string;
+    };
+}
+export interface IntercomAnswerCallCommand {
+    command: 'intercom-terminal.answer';
+    params: {
+        callId: string;
+        userAgentId: string;
+        answerSdp: string;
+    };
+}
+export interface IntercomHangUpCommand {
+    command: 'intercom-terminal.hang-up';
+    params: {
+        callId: string;
+    };
+}
+export type IntercomTerminalCommand = IntercomConnectCommand | IntercomDisconnectCommand | IntercomDialCommand | IntercomCancelCallCommand | IntercomAnswerCallCommand | IntercomHangUpCommand;
+export interface IntercomTerminalStateDto {
+    connected: boolean;
+    clientId: number | null;
+    callId: string | null;
+    userAgentId: string | null;
+    offerSdp: string | null;
+    answerSdp: string | null;
+    callState: 'idle' | 'ringing' | 'active';
+}
+export declare const sIntercomCallEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"intercom-call">;
+    userId: z.ZodOptional<z.ZodString>;
+    personId: z.ZodOptional<z.ZodString>;
+    callId: z.ZodString;
+    offerSdp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "intercom-call";
+    callId: string;
+    offerSdp: string;
+    personId?: string | undefined;
+    userId?: string | undefined;
+}, {
+    kind: "intercom-call";
+    callId: string;
+    offerSdp: string;
+    personId?: string | undefined;
+    userId?: string | undefined;
+}>;
+export declare const sIntercomCallCancelledEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"intercom-call-cancelled">;
+    userId: z.ZodOptional<z.ZodString>;
+    callId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "intercom-call-cancelled";
+    callId: string;
+    userId?: string | undefined;
+}, {
+    kind: "intercom-call-cancelled";
+    callId: string;
+    userId?: string | undefined;
+}>;
+export declare const sIntercomCallAnsweredEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"intercom-call-answered">;
+    userId: z.ZodOptional<z.ZodString>;
+    userAgentId: z.ZodString;
+    callId: z.ZodString;
+    answerSdp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "intercom-call-answered";
+    callId: string;
+    userAgentId: string;
+    answerSdp: string;
+    userId?: string | undefined;
+}, {
+    kind: "intercom-call-answered";
+    callId: string;
+    userAgentId: string;
+    answerSdp: string;
+    userId?: string | undefined;
+}>;
+export declare const sIntercomCallEndedEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"intercom-call-ended">;
+    callId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "intercom-call-ended";
+    callId: string;
+}, {
+    kind: "intercom-call-ended";
+    callId: string;
+}>;
+export declare const intercomTerminalEventSchemaByKind: {
+    'intercom-call': z.ZodObject<{
+        kind: z.ZodLiteral<"intercom-call">;
+        userId: z.ZodOptional<z.ZodString>;
+        personId: z.ZodOptional<z.ZodString>;
+        callId: z.ZodString;
+        offerSdp: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "intercom-call";
+        callId: string;
+        offerSdp: string;
+        personId?: string | undefined;
+        userId?: string | undefined;
+    }, {
+        kind: "intercom-call";
+        callId: string;
+        offerSdp: string;
+        personId?: string | undefined;
+        userId?: string | undefined;
+    }>;
+    'intercom-call-cancelled': z.ZodObject<{
+        kind: z.ZodLiteral<"intercom-call-cancelled">;
+        userId: z.ZodOptional<z.ZodString>;
+        callId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "intercom-call-cancelled";
+        callId: string;
+        userId?: string | undefined;
+    }, {
+        kind: "intercom-call-cancelled";
+        callId: string;
+        userId?: string | undefined;
+    }>;
+    'intercom-call-answered': z.ZodObject<{
+        kind: z.ZodLiteral<"intercom-call-answered">;
+        userId: z.ZodOptional<z.ZodString>;
+        userAgentId: z.ZodString;
+        callId: z.ZodString;
+        answerSdp: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "intercom-call-answered";
+        callId: string;
+        userAgentId: string;
+        answerSdp: string;
+        userId?: string | undefined;
+    }, {
+        kind: "intercom-call-answered";
+        callId: string;
+        userAgentId: string;
+        answerSdp: string;
+        userId?: string | undefined;
+    }>;
+    'intercom-call-ended': z.ZodObject<{
+        kind: z.ZodLiteral<"intercom-call-ended">;
+        callId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "intercom-call-ended";
+        callId: string;
+    }, {
+        kind: "intercom-call-ended";
+        callId: string;
+    }>;
+};
+export type IntercomCallEvent = z.infer<typeof sIntercomCallEvent>;
+export type IntercomCallCancelledEvent = z.infer<typeof sIntercomCallCancelledEvent>;
+export type IntercomCallAnsweredEvent = z.infer<typeof sIntercomCallAnsweredEvent>;
+export type IntercomCallEndedEvent = z.infer<typeof sIntercomCallEndedEvent>;
+export type IntercomTerminalEvent = IntercomCallEvent | IntercomCallCancelledEvent | IntercomCallAnsweredEvent | IntercomCallEndedEvent;

package/dist/device/intercom-terminal.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.intercomTerminalEventSchemaByKind = exports.sIntercomCallEndedEvent = exports.sIntercomCallAnsweredEvent = exports.sIntercomCallCancelledEvent = exports.sIntercomCallEvent = exports.sAddIntercomTerminal = exports.sIntercomTerminalSpecs = exports.INTERCOM_TERMINAL = void 0;
+const zod_1 = require("zod");
+exports.INTERCOM_TERMINAL = 'intercom-terminal';
+// SPECS
+exports.sIntercomTerminalSpecs = zod_1.z.object({
+    sipUri: zod_1.z.string(),
+    sipUser: zod_1.z.string(),
+    sipPassword: zod_1.z.string(),
+    sipRealm: zod_1.z.string(),
+    remoteExtension: zod_1.z.string(),
+});
+exports.sAddIntercomTerminal = zod_1.z.object({
+    name: zod_1.z.string(),
+    foreignRef: zod_1.z.string(),
+    specs: exports.sIntercomTerminalSpecs,
+});
+// EVENTS
+exports.sIntercomCallEvent = zod_1.z.object({
+    kind: zod_1.z.literal('intercom-call'),
+    userId: zod_1.z.string().optional(),
+    personId: zod_1.z.string().optional(),
+    callId: zod_1.z.string().nonempty(),
+    offerSdp: zod_1.z.string().nonempty(),
+});
+exports.sIntercomCallCancelledEvent = zod_1.z.object({
+    kind: zod_1.z.literal('intercom-call-cancelled'),
+    userId: zod_1.z.string().optional(),
+    callId: zod_1.z.string().nonempty(),
+});
+exports.sIntercomCallAnsweredEvent = zod_1.z.object({
+    kind: zod_1.z.literal('intercom-call-answered'),
+    userId: zod_1.z.string().optional(),
+    userAgentId: zod_1.z.string().nonempty(),
+    callId: zod_1.z.string().nonempty(),
+    answerSdp: zod_1.z.string().nonempty(),
+});
+exports.sIntercomCallEndedEvent = zod_1.z.object({
+    kind: zod_1.z.literal('intercom-call-ended'),
+    callId: zod_1.z.string().nonempty(),
+});
+exports.intercomTerminalEventSchemaByKind = {
+    'intercom-call': exports.sIntercomCallEvent,
+    'intercom-call-cancelled': exports.sIntercomCallCancelledEvent,
+    'intercom-call-answered': exports.sIntercomCallAnsweredEvent,
+    'intercom-call-ended': exports.sIntercomCallEndedEvent,
+};

package/dist/device/io-board.d.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+export declare const IO_BOARD: "io-board";
+export declare const sIoBoardSpecs: z.ZodObject<{
+    inputs: z.ZodArray<z.ZodString, "many">;
+    outputs: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    inputs: string[];
+    outputs: string[];
+}, {
+    inputs: string[];
+    outputs: string[];
+}>;
+export type IoBoardSpecs = z.infer<typeof sIoBoardSpecs>;
+export interface IoBoardSetOutputCommand {
+    command: 'io-board.set-output';
+    params: {
+        output: string;
+        value: boolean;
+    };
+}
+export type IoBoardCommand = IoBoardSetOutputCommand;
+export interface IoBoardStateDto {
+    inputValues: Record<string, boolean>;
+    outputValues: Record<string, boolean>;
+}
+export declare const sIoBoardInputChangedEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"io-board-input-changed">;
+    inputName: z.ZodString;
+    value: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    value: boolean;
+    kind: "io-board-input-changed";
+    inputName: string;
+}, {
+    value: boolean;
+    kind: "io-board-input-changed";
+    inputName: string;
+}>;
+export declare const ioBoardEventSchemaByKind: {
+    readonly 'io-board-input-changed': z.ZodObject<{
+        kind: z.ZodLiteral<"io-board-input-changed">;
+        inputName: z.ZodString;
+        value: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        value: boolean;
+        kind: "io-board-input-changed";
+        inputName: string;
+    }, {
+        value: boolean;
+        kind: "io-board-input-changed";
+        inputName: string;
+    }>;
+};
+export type IoBoardInputChangedEvent = z.infer<typeof sIoBoardInputChangedEvent>;
+export type IoBoardEvent = IoBoardInputChangedEvent;

package/dist/device/io-board.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ioBoardEventSchemaByKind = exports.sIoBoardInputChangedEvent = exports.sIoBoardSpecs = exports.IO_BOARD = void 0;
+const zod_1 = require("zod");
+exports.IO_BOARD = 'io-board';
+// SPECS
+exports.sIoBoardSpecs = zod_1.z.object({
+    inputs: zod_1.z.array(zod_1.z.string().nonempty()),
+    outputs: zod_1.z.array(zod_1.z.string().nonempty()),
+});
+// EVENTS
+exports.sIoBoardInputChangedEvent = zod_1.z.object({
+    kind: zod_1.z.literal('io-board-input-changed'),
+    inputName: zod_1.z.string().nonempty(),
+    value: zod_1.z.boolean(),
+});
+exports.ioBoardEventSchemaByKind = {
+    'io-board-input-changed': exports.sIoBoardInputChangedEvent,
+};

package/dist/device/motion-sensor.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const MOTION_SENSOR: "motion-sensor";
+export declare const sMotionSensorSpecs: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export type MotionSensorSpecs = z.infer<typeof sMotionSensorSpecs>;
+export interface MotionSensorStateDto {
+    isMotionDetected: boolean;
+    connected: boolean;
+}

package/dist/device/motion-sensor.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sMotionSensorSpecs = exports.MOTION_SENSOR = void 0;
+const zod_1 = require("zod");
+exports.MOTION_SENSOR = 'motion-sensor';
+// SPECS
+exports.sMotionSensorSpecs = zod_1.z.object({});
+// EVENTS

package/dist/device/panic-button.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export declare const PANIC_BUTTON: "panic-button";
+export declare const sPanicButtonSpecs: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export type PanicButtonSpecs = z.infer<typeof sPanicButtonSpecs>;
+export interface PanicButtonStateDto {
+    isPressed: boolean;
+    connected: boolean;
+}
+export declare const sPanicButtonPressedEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"panic-button-pressed">;
+}, "strip", z.ZodTypeAny, {
+    kind: "panic-button-pressed";
+}, {
+    kind: "panic-button-pressed";
+}>;
+export declare const panicButtonEventSchemaByKind: {
+    readonly 'panic-button-pressed': z.ZodObject<{
+        kind: z.ZodLiteral<"panic-button-pressed">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "panic-button-pressed";
+    }, {
+        kind: "panic-button-pressed";
+    }>;
+};
+export type PanicButtonPressedEvent = z.infer<typeof sPanicButtonPressedEvent>;
+export type PanicButtonEvent = PanicButtonPressedEvent;

package/dist/device/panic-button.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.panicButtonEventSchemaByKind = exports.sPanicButtonPressedEvent = exports.sPanicButtonSpecs = exports.PANIC_BUTTON = void 0;
+const zod_1 = require("zod");
+exports.PANIC_BUTTON = 'panic-button';
+// SPECS
+exports.sPanicButtonSpecs = zod_1.z.object({});
+// EVENTS
+exports.sPanicButtonPressedEvent = zod_1.z.object({
+    kind: zod_1.z.literal('panic-button-pressed'),
+});
+exports.panicButtonEventSchemaByKind = {
+    'panic-button-pressed': exports.sPanicButtonPressedEvent,
+};

package/dist/device/pbx.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const PBX: "pbx";
+export declare const sPbxSpecs: z.ZodObject<{
+    sipWsUrl: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sipWsUrl: string;
+}, {
+    sipWsUrl: string;
+}>;
+export type PbxSpecs = z.infer<typeof sPbxSpecs>;
+export interface PbxCallCommand {
+    command: 'pbx.call';
+    params: {
+        endpoint: string;
+        soundFile: string;
+        context?: string;
+        callerId?: string;
+    };
+}
+export type PbxCommand = PbxCallCommand;

package/dist/device/pbx.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sPbxSpecs = exports.PBX = void 0;
+const zod_1 = require("zod");
+exports.PBX = 'pbx';
+// SPECS
+exports.sPbxSpecs = zod_1.z.object({
+    sipWsUrl: zod_1.z.string(),
+});
+// STATE
+// EVENTS

package/dist/device/presence-tracker.d.ts

@@ -0,0 +1,127 @@
+import { z } from 'zod';
+export declare const PRESENCE_TRACKER = "presence-tracker";
+export interface PresenceTrackerState {
+    zonePeople: Record<string, string[]>;
+}
+export interface CheckInPerson {
+    command: 'presence-tracker.check-in';
+    params: {
+        personId: string;
+        zoneId: string | null;
+    };
+}
+export interface CheckOutPerson {
+    command: 'presence-tracker.check-out';
+    params: {
+        personId: string;
+        zoneId: string | null;
+        leave: boolean;
+    };
+}
+export interface TogglePresence {
+    command: 'presence-tracker.toggle-presence';
+    params: {
+        personId: string;
+        zoneId: string | null;
+    };
+}
+export type PresenceTrackerCommand = CheckInPerson | CheckOutPerson | TogglePresence;
+export declare const sPersonIn: z.ZodObject<{
+    kind: z.ZodLiteral<"person-in">;
+    personId: z.ZodString;
+    personFirstName: z.ZodString;
+    personLastName: z.ZodString;
+    personAvatarId: z.ZodNullable<z.ZodString>;
+    zoneId: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "person-in";
+    personId: string;
+    zoneId: string | null;
+    personFirstName: string;
+    personLastName: string;
+    personAvatarId: string | null;
+}, {
+    kind: "person-in";
+    personId: string;
+    zoneId: string | null;
+    personFirstName: string;
+    personLastName: string;
+    personAvatarId: string | null;
+}>;
+export declare const sPersonOut: z.ZodObject<{
+    kind: z.ZodLiteral<"person-out">;
+    personId: z.ZodString;
+    personFirstName: z.ZodString;
+    personLastName: z.ZodString;
+    personAvatarId: z.ZodNullable<z.ZodString>;
+    isLeave: z.ZodBoolean;
+    zoneId: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "person-out";
+    personId: string;
+    isLeave: boolean;
+    zoneId: string | null;
+    personFirstName: string;
+    personLastName: string;
+    personAvatarId: string | null;
+}, {
+    kind: "person-out";
+    personId: string;
+    isLeave: boolean;
+    zoneId: string | null;
+    personFirstName: string;
+    personLastName: string;
+    personAvatarId: string | null;
+}>;
+export declare const presenceTrackerEventSchemaByKind: {
+    readonly 'person-in': z.ZodObject<{
+        kind: z.ZodLiteral<"person-in">;
+        personId: z.ZodString;
+        personFirstName: z.ZodString;
+        personLastName: z.ZodString;
+        personAvatarId: z.ZodNullable<z.ZodString>;
+        zoneId: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "person-in";
+        personId: string;
+        zoneId: string | null;
+        personFirstName: string;
+        personLastName: string;
+        personAvatarId: string | null;
+    }, {
+        kind: "person-in";
+        personId: string;
+        zoneId: string | null;
+        personFirstName: string;
+        personLastName: string;
+        personAvatarId: string | null;
+    }>;
+    readonly 'person-out': z.ZodObject<{
+        kind: z.ZodLiteral<"person-out">;
+        personId: z.ZodString;
+        personFirstName: z.ZodString;
+        personLastName: z.ZodString;
+        personAvatarId: z.ZodNullable<z.ZodString>;
+        isLeave: z.ZodBoolean;
+        zoneId: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "person-out";
+        personId: string;
+        isLeave: boolean;
+        zoneId: string | null;
+        personFirstName: string;
+        personLastName: string;
+        personAvatarId: string | null;
+    }, {
+        kind: "person-out";
+        personId: string;
+        isLeave: boolean;
+        zoneId: string | null;
+        personFirstName: string;
+        personLastName: string;
+        personAvatarId: string | null;
+    }>;
+};
+export type PersonIn = z.infer<typeof sPersonIn>;
+export type PersonOut = z.infer<typeof sPersonOut>;
+export type PresenceTrackerEvent = PersonIn | PersonOut;

package/dist/device/presence-tracker.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.presenceTrackerEventSchemaByKind = exports.sPersonOut = exports.sPersonIn = exports.PRESENCE_TRACKER = void 0;
+const zod_1 = require("zod");
+exports.PRESENCE_TRACKER = 'presence-tracker';
+// EVENTS
+exports.sPersonIn = zod_1.z.object({
+    kind: zod_1.z.literal('person-in'),
+    personId: zod_1.z.string().nonempty(),
+    personFirstName: zod_1.z.string().nonempty(),
+    personLastName: zod_1.z.string().nonempty(),
+    personAvatarId: zod_1.z.string().nullable(),
+    zoneId: zod_1.z.string().nullable(),
+});
+exports.sPersonOut = zod_1.z.object({
+    kind: zod_1.z.literal('person-out'),
+    personId: zod_1.z.string().nonempty(),
+    personFirstName: zod_1.z.string().nonempty(),
+    personLastName: zod_1.z.string().nonempty(),
+    personAvatarId: zod_1.z.string().nullable(),
+    isLeave: zod_1.z.boolean(),
+    zoneId: zod_1.z.string().nullable(),
+});
+exports.presenceTrackerEventSchemaByKind = {
+    'person-in': exports.sPersonIn,
+    'person-out': exports.sPersonOut,
+};

package/dist/device/reader/commands.d.ts

@@ -0,0 +1 @@
+export type ReaderCommand = never;

package/dist/device/reader/commands.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/device/reader/events.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const sTokenAuthorized: z.ZodObject<{
+    kind: z.ZodLiteral<"reader-auth">;
+    token: z.ZodNullable<z.ZodString>;
+    personId: z.ZodOptional<z.ZodString>;
+    allowed: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    kind: "reader-auth";
+    token: string | null;
+    allowed: boolean;
+    personId?: string | undefined;
+}, {
+    kind: "reader-auth";
+    token: string | null;
+    allowed: boolean;
+    personId?: string | undefined;
+}>;
+export type TokenAuthorized = z.infer<typeof sTokenAuthorized>;
+export declare const readerEventSchemaByKind: {
+    readonly 'reader-auth': z.ZodObject<{
+        kind: z.ZodLiteral<"reader-auth">;
+        token: z.ZodNullable<z.ZodString>;
+        personId: z.ZodOptional<z.ZodString>;
+        allowed: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        kind: "reader-auth";
+        token: string | null;
+        allowed: boolean;
+        personId?: string | undefined;
+    }, {
+        kind: "reader-auth";
+        token: string | null;
+        allowed: boolean;
+        personId?: string | undefined;
+    }>;
+};
+export type ReaderEvent = TokenAuthorized;

package/dist/device/reader/events.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readerEventSchemaByKind = exports.sTokenAuthorized = void 0;
+const zod_1 = require("zod");
+exports.sTokenAuthorized = zod_1.z.object({
+    kind: zod_1.z.literal('reader-auth'),
+    token: zod_1.z.string().nullable(),
+    personId: zod_1.z.string().optional(),
+    allowed: zod_1.z.boolean(),
+});
+exports.readerEventSchemaByKind = {
+    'reader-auth': exports.sTokenAuthorized,
+};

package/dist/device/reader/index.d.ts

@@ -0,0 +1,3 @@
+export * from './commands';
+export * from './events';
+export * from './specs';