@sprucelabs/mercury-client 42.0.557 → 42.0.558

package/build/esm/.spruce/errors/errors.types.d.ts

@@ -0,0 +1,324 @@
+import { default as SchemaEntity } from '@sprucelabs/schema';
+import * as SpruceSchema from '@sprucelabs/schema';
+export declare namespace SpruceErrors.MercuryClient {
+    interface UnknownError {
+    }
+    interface UnknownErrorSchema extends SpruceSchema.Schema {
+        id: 'unknownError';
+        namespace: 'MercuryClient';
+        name: 'Unknown error';
+        fields: {};
+    }
+    type UnknownErrorEntity = SchemaEntity<SpruceErrors.MercuryClient.UnknownErrorSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface UnexpectedPayload {
+        'eventName': string;
+    }
+    interface UnexpectedPayloadSchema extends SpruceSchema.Schema {
+        id: 'unexpectedPayload';
+        namespace: 'MercuryClient';
+        name: 'Unexpected payload';
+        fields: {
+            /** . */
+            'eventName': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type UnexpectedPayloadEntity = SchemaEntity<SpruceErrors.MercuryClient.UnexpectedPayloadSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface UnauthorizedTarget {
+        'locationId'?: string | undefined | null;
+        'personId'?: string | undefined | null;
+        'organizationId'?: string | undefined | null;
+        'skillId'?: string | undefined | null;
+        'roleId'?: string | undefined | null;
+    }
+    interface UnauthorizedTargetSchema extends SpruceSchema.Schema {
+        id: 'unauthorizedTarget';
+        namespace: 'MercuryClient';
+        name: '';
+        fields: {
+            /** . */
+            'locationId': {
+                type: 'id';
+                options: undefined;
+            };
+            /** . */
+            'personId': {
+                type: 'id';
+                options: undefined;
+            };
+            /** . */
+            'organizationId': {
+                type: 'id';
+                options: undefined;
+            };
+            /** . */
+            'skillId': {
+                type: 'id';
+                options: undefined;
+            };
+            /** . */
+            'roleId': {
+                type: 'id';
+                options: undefined;
+            };
+        };
+    }
+    type UnauthorizedTargetEntity = SchemaEntity<SpruceErrors.MercuryClient.UnauthorizedTargetSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface UnauthorizedAccess {
+        'fqen': string;
+        'action': ("emit");
+        'target': SpruceErrors.MercuryClient.UnauthorizedTarget;
+        'permissionContractId': string;
+    }
+    interface UnauthorizedAccessSchema extends SpruceSchema.Schema {
+        id: 'unauthorizedAccess';
+        namespace: 'MercuryClient';
+        name: 'Unauthorized Access';
+        fields: {
+            /** . */
+            'fqen': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+            /** . */
+            'action': {
+                type: 'select';
+                isRequired: true;
+                options: {
+                    choices: [{
+                        "value": "emit";
+                        "label": "emit";
+                    }];
+                };
+            };
+            /** . */
+            'target': {
+                type: 'schema';
+                isRequired: true;
+                options: {
+                    schema: SpruceErrors.MercuryClient.UnauthorizedTargetSchema;
+                };
+            };
+            /** . */
+            'permissionContractId': {
+                type: 'id';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type UnauthorizedAccessEntity = SchemaEntity<SpruceErrors.MercuryClient.UnauthorizedAccessSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface Timeout {
+        'eventName': string;
+        'timeoutMs': number;
+        'isConnected'?: boolean | undefined | null;
+        'totalRetries'?: number | undefined | null;
+    }
+    interface TimeoutSchema extends SpruceSchema.Schema {
+        id: 'timeout';
+        namespace: 'MercuryClient';
+        name: 'Timeout';
+        fields: {
+            /** . */
+            'eventName': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+            /** . */
+            'timeoutMs': {
+                type: 'number';
+                isRequired: true;
+                options: undefined;
+            };
+            /** . */
+            'isConnected': {
+                type: 'boolean';
+                options: undefined;
+            };
+            /** . */
+            'totalRetries': {
+                type: 'number';
+                options: undefined;
+            };
+        };
+    }
+    type TimeoutEntity = SchemaEntity<SpruceErrors.MercuryClient.TimeoutSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface NotConnected {
+        'action': string;
+        'fqen': string;
+    }
+    interface NotConnectedSchema extends SpruceSchema.Schema {
+        id: 'notConnected';
+        namespace: 'MercuryClient';
+        name: 'Not connected';
+        fields: {
+            /** . */
+            'action': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+            /** . */
+            'fqen': {
+                type: 'id';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type NotConnectedEntity = SchemaEntity<SpruceErrors.MercuryClient.NotConnectedSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface MustHandleLocally {
+        'fqen': string;
+    }
+    interface MustHandleLocallySchema extends SpruceSchema.Schema {
+        id: 'mustHandleLocally';
+        namespace: 'MercuryClient';
+        name: 'Must handle locally';
+        fields: {
+            /** . */
+            'fqen': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type MustHandleLocallyEntity = SchemaEntity<SpruceErrors.MercuryClient.MustHandleLocallySchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface MustCreateEvent {
+        'fqen': string;
+    }
+    interface MustCreateEventSchema extends SpruceSchema.Schema {
+        id: 'mustCreateEvent';
+        namespace: 'MercuryClient';
+        name: 'must create event';
+        fields: {
+            /** . */
+            'fqen': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type MustCreateEventEntity = SchemaEntity<SpruceErrors.MercuryClient.MustCreateEventSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface MissingTestCacheDir {
+    }
+    interface MissingTestCacheDirSchema extends SpruceSchema.Schema {
+        id: 'missingTestCacheDir';
+        namespace: 'MercuryClient';
+        name: 'Missing test cache dir';
+        fields: {};
+    }
+    type MissingTestCacheDirEntity = SchemaEntity<SpruceErrors.MercuryClient.MissingTestCacheDirSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface InvalidProtocol {
+        'uri': string;
+    }
+    interface InvalidProtocolSchema extends SpruceSchema.Schema {
+        id: 'invalidProtocol';
+        namespace: 'MercuryClient';
+        name: 'Invalid protocol';
+        fields: {
+            /** . */
+            'uri': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type InvalidProtocolEntity = SchemaEntity<SpruceErrors.MercuryClient.InvalidProtocolSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface InvalidPayload {
+        'eventName': string;
+    }
+    interface InvalidPayloadSchema extends SpruceSchema.Schema {
+        id: 'invalidPayload';
+        namespace: 'MercuryClient';
+        name: 'Invalid payload';
+        fields: {
+            /** . */
+            'eventName': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type InvalidPayloadEntity = SchemaEntity<SpruceErrors.MercuryClient.InvalidPayloadSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface InvalidEventSignature {
+        'fqen': string;
+        'instructions': string;
+    }
+    interface InvalidEventSignatureSchema extends SpruceSchema.Schema {
+        id: 'invalidEventSignature';
+        namespace: 'MercuryClient';
+        name: 'Invalid event contract';
+        fields: {
+            /** . */
+            'fqen': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+            /** . */
+            'instructions': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type InvalidEventSignatureEntity = SchemaEntity<SpruceErrors.MercuryClient.InvalidEventSignatureSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface ConnectionFailed {
+        'host': string;
+        'statusCode': number;
+    }
+    interface ConnectionFailedSchema extends SpruceSchema.Schema {
+        id: 'connectionFailed';
+        namespace: 'MercuryClient';
+        name: 'Connection failed';
+        fields: {
+            /** . */
+            'host': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+            /** . */
+            'statusCode': {
+                type: 'number';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type ConnectionFailedEntity = SchemaEntity<SpruceErrors.MercuryClient.ConnectionFailedSchema>;
+}

package/build/esm/.spruce/errors/errors.types.js

@@ -0,0 +1 @@
+export {};

package/build/esm/.spruce/errors/mercuryClient/connectionFailed.schema.d.ts

@@ -0,0 +1,3 @@
+import { SpruceErrors } from '../errors.types';
+declare const connectionFailedSchema: SpruceErrors.MercuryClient.ConnectionFailedSchema;
+export default connectionFailedSchema;

package/build/esm/.spruce/errors/mercuryClient/connectionFailed.schema.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require('@sprucelabs/schema');
+const connectionFailedSchema = {
+    id: 'connectionFailed',
+    namespace: 'MercuryClient',
+    name: 'Connection failed',
+    fields: {
+        /** . */
+        'host': {
+            type: 'text',
+            isRequired: true,
+            options: undefined
+        },
+        /** . */
+        'statusCode': {
+            type: 'number',
+            isRequired: true,
+            options: undefined
+        },
+    }
+};
+schema_1.SchemaRegistry.getInstance().trackSchema(connectionFailedSchema);
+exports.default = connectionFailedSchema;
+//# sourceMappingURL=connectionFailed.schema.js.map

package/build/esm/.spruce/errors/mercuryClient/invalidEventSignature.schema.d.ts

@@ -0,0 +1,3 @@
+import { SpruceErrors } from '../errors.types';
+declare const invalidEventSignatureSchema: SpruceErrors.MercuryClient.InvalidEventSignatureSchema;
+export default invalidEventSignatureSchema;

package/build/esm/.spruce/errors/mercuryClient/invalidEventSignature.schema.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require('@sprucelabs/schema');
+const invalidEventSignatureSchema = {
+    id: 'invalidEventSignature',
+    namespace: 'MercuryClient',
+    name: 'Invalid event contract',
+    fields: {
+        /** . */
+        'fqen': {
+            type: 'text',
+            isRequired: true,
+            options: undefined
+        },
+        /** . */
+        'instructions': {
+            type: 'text',
+            isRequired: true,
+            options: undefined
+        },
+    }
+};
+schema_1.SchemaRegistry.getInstance().trackSchema(invalidEventSignatureSchema);
+exports.default = invalidEventSignatureSchema;
+//# sourceMappingURL=invalidEventSignature.schema.js.map

package/build/esm/.spruce/errors/mercuryClient/invalidPayload.schema.d.ts

@@ -0,0 +1,3 @@
+import { SpruceErrors } from '../errors.types';
+declare const invalidPayloadSchema: SpruceErrors.MercuryClient.InvalidPayloadSchema;
+export default invalidPayloadSchema;

package/build/esm/.spruce/errors/mercuryClient/invalidPayload.schema.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require('@sprucelabs/schema');
+const invalidPayloadSchema = {
+    id: 'invalidPayload',
+    namespace: 'MercuryClient',
+    name: 'Invalid payload',
+    fields: {
+        /** . */
+        'eventName': {
+            type: 'text',
+            isRequired: true,
+            options: undefined
+        },
+    }
+};
+schema_1.SchemaRegistry.getInstance().trackSchema(invalidPayloadSchema);
+exports.default = invalidPayloadSchema;
+//# sourceMappingURL=invalidPayload.schema.js.map

package/build/esm/.spruce/errors/mercuryClient/invalidProtocol.schema.d.ts

@@ -0,0 +1,3 @@
+import { SpruceErrors } from '../errors.types';
+declare const invalidProtocolSchema: SpruceErrors.MercuryClient.InvalidProtocolSchema;
+export default invalidProtocolSchema;

package/build/esm/.spruce/errors/mercuryClient/invalidProtocol.schema.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require('@sprucelabs/schema');
+const invalidProtocolSchema = {
+    id: 'invalidProtocol',
+    namespace: 'MercuryClient',
+    name: 'Invalid protocol',
+    fields: {
+        /** . */
+        'uri': {
+            type: 'text',
+            isRequired: true,
+            options: undefined
+        },
+    }
+};
+schema_1.SchemaRegistry.getInstance().trackSchema(invalidProtocolSchema);
+exports.default = invalidProtocolSchema;
+//# sourceMappingURL=invalidProtocol.schema.js.map

package/build/esm/.spruce/errors/mercuryClient/missingTestCacheDir.schema.d.ts

@@ -0,0 +1,3 @@
+import { SpruceErrors } from '../errors.types';
+declare const missingTestCacheDirSchema: SpruceErrors.MercuryClient.MissingTestCacheDirSchema;
+export default missingTestCacheDirSchema;

package/build/esm/.spruce/errors/mercuryClient/missingTestCacheDir.schema.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require('@sprucelabs/schema');
+const missingTestCacheDirSchema = {
+    id: 'missingTestCacheDir',
+    namespace: 'MercuryClient',
+    name: 'Missing test cache dir',
+    fields: {}
+};
+schema_1.SchemaRegistry.getInstance().trackSchema(missingTestCacheDirSchema);
+exports.default = missingTestCacheDirSchema;
+//# sourceMappingURL=missingTestCacheDir.schema.js.map

package/build/esm/.spruce/errors/mercuryClient/mustCreateEvent.schema.d.ts

@@ -0,0 +1,3 @@
+import { SpruceErrors } from '../errors.types';
+declare const mustCreateEventSchema: SpruceErrors.MercuryClient.MustCreateEventSchema;
+export default mustCreateEventSchema;

package/build/esm/.spruce/errors/mercuryClient/mustCreateEvent.schema.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require('@sprucelabs/schema');
+const mustCreateEventSchema = {
+    id: 'mustCreateEvent',
+    namespace: 'MercuryClient',
+    name: 'must create event',
+    fields: {
+        /** . */
+        'fqen': {
+            type: 'text',
+            isRequired: true,
+            options: undefined
+        },
+    }
+};
+schema_1.SchemaRegistry.getInstance().trackSchema(mustCreateEventSchema);
+exports.default = mustCreateEventSchema;
+//# sourceMappingURL=mustCreateEvent.schema.js.map

package/build/esm/.spruce/errors/mercuryClient/mustHandleLocally.schema.d.ts

@@ -0,0 +1,3 @@
+import { SpruceErrors } from '../errors.types';
+declare const mustHandleLocallySchema: SpruceErrors.MercuryClient.MustHandleLocallySchema;
+export default mustHandleLocallySchema;

package/build/esm/.spruce/errors/mercuryClient/mustHandleLocally.schema.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require('@sprucelabs/schema');
+const mustHandleLocallySchema = {
+    id: 'mustHandleLocally',
+    namespace: 'MercuryClient',
+    name: 'Must handle locally',
+    fields: {
+        /** . */
+        'fqen': {
+            type: 'text',
+            isRequired: true,
+            options: undefined
+        },
+    }
+};
+schema_1.SchemaRegistry.getInstance().trackSchema(mustHandleLocallySchema);
+exports.default = mustHandleLocallySchema;
+//# sourceMappingURL=mustHandleLocally.schema.js.map

package/build/esm/.spruce/errors/mercuryClient/notConnected.schema.d.ts

@@ -0,0 +1,3 @@
+import { SpruceErrors } from '../errors.types';
+declare const notConnectedSchema: SpruceErrors.MercuryClient.NotConnectedSchema;
+export default notConnectedSchema;

package/build/esm/.spruce/errors/mercuryClient/notConnected.schema.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require('@sprucelabs/schema');
+const notConnectedSchema = {
+    id: 'notConnected',
+    namespace: 'MercuryClient',
+    name: 'Not connected',
+    fields: {
+        /** . */
+        'action': {
+            type: 'text',
+            isRequired: true,
+            options: undefined
+        },
+        /** . */
+        'fqen': {
+            type: 'id',
+            isRequired: true,
+            options: undefined
+        },
+    }
+};
+schema_1.SchemaRegistry.getInstance().trackSchema(notConnectedSchema);
+exports.default = notConnectedSchema;
+//# sourceMappingURL=notConnected.schema.js.map

package/build/esm/.spruce/errors/mercuryClient/timeout.schema.d.ts

@@ -0,0 +1,3 @@
+import { SpruceErrors } from '../errors.types';
+declare const timeoutSchema: SpruceErrors.MercuryClient.TimeoutSchema;
+export default timeoutSchema;

package/build/esm/.spruce/errors/mercuryClient/timeout.schema.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require('@sprucelabs/schema');
+const timeoutSchema = {
+    id: 'timeout',
+    namespace: 'MercuryClient',
+    name: 'Timeout',
+    fields: {
+        /** . */
+        'eventName': {
+            type: 'text',
+            isRequired: true,
+            options: undefined
+        },
+        /** . */
+        'timeoutMs': {
+            type: 'number',
+            isRequired: true,
+            options: undefined
+        },
+        /** . */
+        'isConnected': {
+            type: 'boolean',
+            options: undefined
+        },
+        /** . */
+        'totalRetries': {
+            type: 'number',
+            options: undefined
+        },
+    }
+};
+schema_1.SchemaRegistry.getInstance().trackSchema(timeoutSchema);
+exports.default = timeoutSchema;
+//# sourceMappingURL=timeout.schema.js.map

package/build/esm/.spruce/errors/mercuryClient/unauthorizedAccess.schema.d.ts

@@ -0,0 +1,3 @@
+import { SpruceErrors } from '../errors.types';
+declare const unauthorizedAccessSchema: SpruceErrors.MercuryClient.UnauthorizedAccessSchema;
+export default unauthorizedAccessSchema;

package/build/esm/.spruce/errors/mercuryClient/unauthorizedAccess.schema.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require('@sprucelabs/schema');
+const unauthorizedTarget_schema_1 = __importDefault(require('./unauthorizedTarget.schema.js'));
+const unauthorizedAccessSchema = {
+    id: 'unauthorizedAccess',
+    namespace: 'MercuryClient',
+    name: 'Unauthorized Access',
+    fields: {
+        /** . */
+        'fqen': {
+            type: 'text',
+            isRequired: true,
+            options: undefined
+        },
+        /** . */
+        'action': {
+            type: 'select',
+            isRequired: true,
+            options: { choices: [{ "value": "emit", "label": "emit" }], }
+        },
+        /** . */
+        'target': {
+            type: 'schema',
+            isRequired: true,
+            options: { schema: unauthorizedTarget_schema_1.default, }
+        },
+        /** . */
+        'permissionContractId': {
+            type: 'id',
+            isRequired: true,
+            options: undefined
+        },
+    }
+};
+schema_1.SchemaRegistry.getInstance().trackSchema(unauthorizedAccessSchema);
+exports.default = unauthorizedAccessSchema;
+//# sourceMappingURL=unauthorizedAccess.schema.js.map

package/build/esm/.spruce/errors/mercuryClient/unauthorizedTarget.schema.d.ts

@@ -0,0 +1,3 @@
+import { SpruceErrors } from '../errors.types';
+declare const unauthorizedTargetSchema: SpruceErrors.MercuryClient.UnauthorizedTargetSchema;
+export default unauthorizedTargetSchema;

package/build/esm/.spruce/errors/mercuryClient/unauthorizedTarget.schema.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require('@sprucelabs/schema');
+const unauthorizedTargetSchema = {
+    id: 'unauthorizedTarget',
+    namespace: 'MercuryClient',
+    name: '',
+    fields: {
+        /** . */
+        'locationId': {
+            type: 'id',
+            options: undefined
+        },
+        /** . */
+        'personId': {
+            type: 'id',
+            options: undefined
+        },
+        /** . */
+        'organizationId': {
+            type: 'id',
+            options: undefined
+        },
+        /** . */
+        'skillId': {
+            type: 'id',
+            options: undefined
+        },
+        /** . */
+        'roleId': {
+            type: 'id',
+            options: undefined
+        },
+    }
+};
+schema_1.SchemaRegistry.getInstance().trackSchema(unauthorizedTargetSchema);
+exports.default = unauthorizedTargetSchema;
+//# sourceMappingURL=unauthorizedTarget.schema.js.map

package/build/esm/.spruce/errors/mercuryClient/unexpectedPayload.schema.d.ts

@@ -0,0 +1,3 @@
+import { SpruceErrors } from '../errors.types';
+declare const unexpectedPayloadSchema: SpruceErrors.MercuryClient.UnexpectedPayloadSchema;
+export default unexpectedPayloadSchema;