@roastery/terroir 0.0.1 → 0.0.3

package/dist/exceptions/infra/index.js

@@ -0,0 +1,107 @@
+import {
+  InfraException
+} from "../../chunk-WY3PDSMZ.js";
+import "../../chunk-UEZ4EF5Z.js";
+import "../../chunk-N6MCTGZD.js";
+
+// src/exceptions/infra/cache-unavailable.exception.ts
+var CacheUnavailableException = class extends InfraException {
+  constructor(source, message = "The cache is currently unavailable.") {
+    super(message);
+    this.source = source;
+    this.message = message;
+  }
+  name = "Cache Unavailable Exception";
+};
+
+// src/exceptions/infra/conflict.exception.ts
+var ConflictException = class extends InfraException {
+  constructor(source, message = "A conflict occurred in the database.") {
+    super(message);
+    this.source = source;
+    this.message = message;
+  }
+  name = "Conflict Exception";
+};
+
+// src/exceptions/infra/operation-not-allowed.exception.ts
+var OperationNotAllowedException = class extends InfraException {
+  constructor(source, message = "The operation is not allowed.") {
+    super(message);
+    this.source = source;
+    this.message = message;
+  }
+  name = "Operation Not Allowed Exception";
+};
+
+// src/exceptions/infra/database-unavailable.exception.ts
+var DatabaseUnavailableException = class extends InfraException {
+  constructor(source, message = "The database is currently unavailable.") {
+    super(message);
+    this.source = source;
+    this.message = message;
+  }
+  name = "Database Unavailable Exception";
+};
+
+// src/exceptions/infra/resource-not-found.exception.ts
+var ResourceNotFoundException = class extends InfraException {
+  constructor(source, message = "The resource was not found.") {
+    super(message);
+    this.source = source;
+    this.message = message;
+  }
+  name = "Resource Not Found Exception";
+};
+
+// src/exceptions/infra/foreign-dependency-constraint.exception.ts
+var ForeignDependencyConstraintException = class extends InfraException {
+  constructor(source, message = `It was not possible to remove the ${source} resource due to its usefulness in other domains.`) {
+    super(message);
+    this.source = source;
+    this.message = message;
+  }
+  name = "Foreign Dependency Constraint Exception";
+};
+
+// src/exceptions/infra/unexpected-cache-value.exception.ts
+var UnexpectedCacheValueException = class extends InfraException {
+  constructor(key, source, message = `The value from cache for key '${key}' was unexpected.`) {
+    super(message);
+    this.key = key;
+    this.source = source;
+    this.message = message;
+  }
+  name = "Unexpected Cache Value Exception";
+};
+
+// src/exceptions/infra/missing-plugin-dependency.exception.ts
+var MissingPluginDependencyException = class extends InfraException {
+  constructor(source, message = `The dependencies of the "${source}" plugin are not satisfied.`) {
+    super(message);
+    this.source = source;
+    this.message = message;
+  }
+  name = "Missing Plugin Dependency Exception";
+};
+
+// src/exceptions/infra/invalid-environment.exception.ts
+var InvalidEnvironmentException = class extends InfraException {
+  constructor(source, message = "The required environment variables are invalid or missing.") {
+    super(message);
+    this.source = source;
+    this.message = message;
+  }
+  name = "Invalid Environment Exception";
+};
+export {
+  CacheUnavailableException,
+  ConflictException,
+  DatabaseUnavailableException,
+  ForeignDependencyConstraintException,
+  InvalidEnvironmentException,
+  MissingPluginDependencyException,
+  OperationNotAllowedException,
+  ResourceNotFoundException,
+  UnexpectedCacheValueException
+};

package/dist/exceptions/models/index.cjs

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/exceptions/models/index.ts
+var models_exports = {};
+__export(models_exports, {
+  ApplicationException: () => ApplicationException,
+  DomainException: () => DomainException,
+  InfraException: () => InfraException
+});
+module.exports = __toCommonJS(models_exports);
+
+// src/exceptions/symbols/exception-layer.ts
+var ExceptionLayer = /* @__PURE__ */ Symbol("exception:layer");
+
+// src/exceptions/core/core-exception.ts
+var CoreException = class extends Error {
+};
+
+// src/exceptions/models/domain-exception.ts
+var DomainException = class extends CoreException {
+  [ExceptionLayer] = "domain";
+};
+
+// src/exceptions/models/infra-exception.ts
+var InfraException = class extends CoreException {
+  [ExceptionLayer] = "infra";
+};
+
+// src/exceptions/models/application-exception.ts
+var ApplicationException = class extends CoreException {
+  [ExceptionLayer] = "application";
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApplicationException,
+  DomainException,
+  InfraException
+});

package/dist/exceptions/models/index.d.cts

@@ -0,0 +1,6 @@
+export { D as DomainException } from '../../domain-exception-BJknDTC7.cjs';
+export { I as InfraException } from '../../infra-exception-Dm1D9yrN.cjs';
+export { A as ApplicationException } from '../../application-exception-Ck-CRA9W.cjs';
+import '../symbols/index.cjs';
+import '../core/index.cjs';
+import '../core/types/index.cjs';

package/dist/exceptions/models/index.d.ts

@@ -0,0 +1,6 @@
+export { D as DomainException } from '../../domain-exception-2mxDRlhr.js';
+export { I as InfraException } from '../../infra-exception-1PUIDeP4.js';
+export { A as ApplicationException } from '../../application-exception-mi3iXk8r.js';
+import '../symbols/index.js';
+import '../core/index.js';
+import '../core/types/index.js';

package/dist/exceptions/models/index.js

@@ -0,0 +1,12 @@
+import {
+  ApplicationException,
+  DomainException,
+  InfraException
+} from "../../chunk-WY3PDSMZ.js";
+import "../../chunk-UEZ4EF5Z.js";
+import "../../chunk-N6MCTGZD.js";
+export {
+  ApplicationException,
+  DomainException,
+  InfraException
+};

package/dist/exceptions/symbols/index.cjs

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/exceptions/symbols/index.ts
+var symbols_exports = {};
+__export(symbols_exports, {
+  ExceptionLayer: () => ExceptionLayer
+});
+module.exports = __toCommonJS(symbols_exports);
+
+// src/exceptions/symbols/exception-layer.ts
+var ExceptionLayer = /* @__PURE__ */ Symbol("exception:layer");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExceptionLayer
+});

package/dist/exceptions/symbols/index.d.cts

@@ -0,0 +1,3 @@
+declare const ExceptionLayer: unique symbol;
+
+export { ExceptionLayer };

package/dist/exceptions/symbols/index.d.ts

@@ -0,0 +1,3 @@
+declare const ExceptionLayer: unique symbol;
+
+export { ExceptionLayer };

package/dist/exceptions/symbols/index.js

@@ -0,0 +1,6 @@
+import {
+  ExceptionLayer
+} from "../../chunk-N6MCTGZD.js";
+export {
+  ExceptionLayer
+};

package/dist/exceptions/types/index.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/exceptions/types/index.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/exceptions/types/index.d.cts

@@ -0,0 +1,30 @@
+import { CoreExceptionType } from '../core/types/index.cjs';
+import { I as InternalErrors } from '../../index-g4_PChJX.cjs';
+import { D as DomainExceptions } from '../../index-YFuBgYBS.cjs';
+import { A as ApplicationExceptions } from '../../index-B_h1N1CO.cjs';
+import { I as InfraExceptions } from '../../index-DaS_UsEv.cjs';
+import '../core/index.cjs';
+import '../symbols/index.cjs';
+import '../../domain-exception-BJknDTC7.cjs';
+import '../../application-exception-Ck-CRA9W.cjs';
+import '../application/jwt/index.cjs';
+import '../../infra-exception-Dm1D9yrN.cjs';
+
+type CaffeineDomainExceptions = keyof typeof DomainExceptions;
+
+type CaffeineApplicationExceptions = keyof typeof ApplicationExceptions;
+
+type CaffeineInfraExceptions = keyof typeof InfraExceptions;
+
+type CaffeineExceptionKeysByLayer = {
+    internal: keyof typeof InternalErrors;
+    domain: CaffeineDomainExceptions;
+    application: CaffeineApplicationExceptions;
+    infra: CaffeineInfraExceptions;
+};
+type CaffeineExceptionKeys<T extends CoreExceptionType> = CaffeineExceptionKeysByLayer[T];
+type CaffeineExceptionRecords<T> = {
+    [Key in keyof CaffeineExceptionKeysByLayer]: Record<CaffeineExceptionKeysByLayer[Key], T>;
+};
+
+export type { CaffeineExceptionKeys, CaffeineExceptionKeysByLayer, CaffeineExceptionRecords };

package/dist/exceptions/types/index.d.ts

@@ -0,0 +1,30 @@
+import { CoreExceptionType } from '../core/types/index.js';
+import { I as InternalErrors } from '../../index-C4-MCapS.js';
+import { D as DomainExceptions } from '../../index-CNApJ5kV.js';
+import { A as ApplicationExceptions } from '../../index-E6KvVxtW.js';
+import { I as InfraExceptions } from '../../index-0ZqtQ0BA.js';
+import '../core/index.js';
+import '../symbols/index.js';
+import '../../domain-exception-2mxDRlhr.js';
+import '../../application-exception-mi3iXk8r.js';
+import '../application/jwt/index.js';
+import '../../infra-exception-1PUIDeP4.js';
+
+type CaffeineDomainExceptions = keyof typeof DomainExceptions;
+
+type CaffeineApplicationExceptions = keyof typeof ApplicationExceptions;
+
+type CaffeineInfraExceptions = keyof typeof InfraExceptions;
+
+type CaffeineExceptionKeysByLayer = {
+    internal: keyof typeof InternalErrors;
+    domain: CaffeineDomainExceptions;
+    application: CaffeineApplicationExceptions;
+    infra: CaffeineInfraExceptions;
+};
+type CaffeineExceptionKeys<T extends CoreExceptionType> = CaffeineExceptionKeysByLayer[T];
+type CaffeineExceptionRecords<T> = {
+    [Key in keyof CaffeineExceptionKeysByLayer]: Record<CaffeineExceptionKeysByLayer[Key], T>;
+};
+
+export type { CaffeineExceptionKeys, CaffeineExceptionKeysByLayer, CaffeineExceptionRecords };

package/dist/index-0ZqtQ0BA.d.ts

@@ -0,0 +1,89 @@
+import { I as InfraException } from './infra-exception-1PUIDeP4.js';
+
+declare class CacheUnavailableException extends InfraException {
+    source: string;
+    message: string;
+    name: string;
+    constructor(source: string, message?: string);
+}
+
+declare class ConflictException extends InfraException {
+    source: string;
+    message: string;
+    name: string;
+    constructor(source: string, message?: string);
+}
+
+declare class OperationNotAllowedException extends InfraException {
+    source: string;
+    message: string;
+    name: string;
+    constructor(source: string, message?: string);
+}
+
+declare class DatabaseUnavailableException extends InfraException {
+    source: string;
+    message: string;
+    name: string;
+    constructor(source: string, message?: string);
+}
+
+declare class ResourceNotFoundException extends InfraException {
+    source: string;
+    message: string;
+    name: string;
+    constructor(source: string, message?: string);
+}
+
+declare class ForeignDependencyConstraintException extends InfraException {
+    source: string;
+    message: string;
+    name: string;
+    constructor(source: string, message?: string);
+}
+
+declare class UnexpectedCacheValueException extends InfraException {
+    readonly key: string;
+    readonly source: string;
+    readonly message: string;
+    readonly name = "Unexpected Cache Value Exception";
+    constructor(key: string, source: string, message?: string);
+}
+
+declare class MissingPluginDependencyException extends InfraException {
+    source: string;
+    message: string;
+    name: string;
+    constructor(source: string, message?: string);
+}
+
+declare class InvalidEnvironmentException extends InfraException {
+    source: string;
+    message: string;
+    name: string;
+    constructor(source: string, message?: string);
+}
+
+type InfraExceptions_CacheUnavailableException = CacheUnavailableException;
+declare const InfraExceptions_CacheUnavailableException: typeof CacheUnavailableException;
+type InfraExceptions_ConflictException = ConflictException;
+declare const InfraExceptions_ConflictException: typeof ConflictException;
+type InfraExceptions_DatabaseUnavailableException = DatabaseUnavailableException;
+declare const InfraExceptions_DatabaseUnavailableException: typeof DatabaseUnavailableException;
+type InfraExceptions_ForeignDependencyConstraintException = ForeignDependencyConstraintException;
+declare const InfraExceptions_ForeignDependencyConstraintException: typeof ForeignDependencyConstraintException;
+type InfraExceptions_InvalidEnvironmentException = InvalidEnvironmentException;
+declare const InfraExceptions_InvalidEnvironmentException: typeof InvalidEnvironmentException;
+type InfraExceptions_MissingPluginDependencyException = MissingPluginDependencyException;
+declare const InfraExceptions_MissingPluginDependencyException: typeof MissingPluginDependencyException;
+type InfraExceptions_OperationNotAllowedException = OperationNotAllowedException;
+declare const InfraExceptions_OperationNotAllowedException: typeof OperationNotAllowedException;
+type InfraExceptions_ResourceNotFoundException = ResourceNotFoundException;
+declare const InfraExceptions_ResourceNotFoundException: typeof ResourceNotFoundException;
+type InfraExceptions_UnexpectedCacheValueException = UnexpectedCacheValueException;
+declare const InfraExceptions_UnexpectedCacheValueException: typeof UnexpectedCacheValueException;
+declare namespace InfraExceptions {
+  export { InfraExceptions_CacheUnavailableException as CacheUnavailableException, InfraExceptions_ConflictException as ConflictException, InfraExceptions_DatabaseUnavailableException as DatabaseUnavailableException, InfraExceptions_ForeignDependencyConstraintException as ForeignDependencyConstraintException, InfraExceptions_InvalidEnvironmentException as InvalidEnvironmentException, InfraExceptions_MissingPluginDependencyException as MissingPluginDependencyException, InfraExceptions_OperationNotAllowedException as OperationNotAllowedException, InfraExceptions_ResourceNotFoundException as ResourceNotFoundException, InfraExceptions_UnexpectedCacheValueException as UnexpectedCacheValueException };
+}
+
+export { CacheUnavailableException as C, DatabaseUnavailableException as D, ForeignDependencyConstraintException as F, InfraExceptions as I, MissingPluginDependencyException as M, OperationNotAllowedException as O, ResourceNotFoundException as R, UnexpectedCacheValueException as U, ConflictException as a, InvalidEnvironmentException as b };

package/dist/index-B_h1N1CO.d.cts

@@ -0,0 +1,55 @@
+import { A as ApplicationException } from './application-exception-Ck-CRA9W.cjs';
+import { InvalidJWTException, UnableToSignPayloadException } from './exceptions/application/jwt/index.cjs';
+
+declare class ResourceAlreadyExistsException extends ApplicationException {
+    source: string;
+    message: string;
+    readonly name = "Resource Already Exists";
+    constructor(source: string, message?: string);
+}
+
+declare class ResourceNotFoundException extends ApplicationException {
+    source: string;
+    message: string;
+    readonly name = "Resource Not Found";
+    constructor(source: string, message?: string);
+}
+
+declare class BadRequestException extends ApplicationException {
+    source: string;
+    message: string;
+    readonly name = "Bad Request";
+    constructor(source: string, message?: string);
+}
+
+declare class UnauthorizedException extends ApplicationException {
+    source: string;
+    message: string;
+    readonly name = "Unauthorized";
+    constructor(source: string, message?: string);
+}
+
+declare class InvalidOperationException extends ApplicationException {
+    source: string;
+    message: string;
+    readonly name = "Invalid Operation";
+    constructor(source: string, message?: string);
+}
+
+type ApplicationExceptions_BadRequestException = BadRequestException;
+declare const ApplicationExceptions_BadRequestException: typeof BadRequestException;
+declare const ApplicationExceptions_InvalidJWTException: typeof InvalidJWTException;
+type ApplicationExceptions_InvalidOperationException = InvalidOperationException;
+declare const ApplicationExceptions_InvalidOperationException: typeof InvalidOperationException;
+type ApplicationExceptions_ResourceAlreadyExistsException = ResourceAlreadyExistsException;
+declare const ApplicationExceptions_ResourceAlreadyExistsException: typeof ResourceAlreadyExistsException;
+type ApplicationExceptions_ResourceNotFoundException = ResourceNotFoundException;
+declare const ApplicationExceptions_ResourceNotFoundException: typeof ResourceNotFoundException;
+declare const ApplicationExceptions_UnableToSignPayloadException: typeof UnableToSignPayloadException;
+type ApplicationExceptions_UnauthorizedException = UnauthorizedException;
+declare const ApplicationExceptions_UnauthorizedException: typeof UnauthorizedException;
+declare namespace ApplicationExceptions {
+  export { ApplicationExceptions_BadRequestException as BadRequestException, ApplicationExceptions_InvalidJWTException as InvalidJWTException, ApplicationExceptions_InvalidOperationException as InvalidOperationException, ApplicationExceptions_ResourceAlreadyExistsException as ResourceAlreadyExistsException, ApplicationExceptions_ResourceNotFoundException as ResourceNotFoundException, ApplicationExceptions_UnableToSignPayloadException as UnableToSignPayloadException, ApplicationExceptions_UnauthorizedException as UnauthorizedException };
+}
+
+export { ApplicationExceptions as A, BadRequestException as B, InvalidOperationException as I, ResourceAlreadyExistsException as R, UnauthorizedException as U, ResourceNotFoundException as a };

package/dist/index-C4-MCapS.d.ts

@@ -0,0 +1,40 @@
+import { CoreException } from './exceptions/core/index.js';
+import { CoreExceptionType } from './exceptions/core/types/index.js';
+import { ExceptionLayer } from './exceptions/symbols/index.js';
+
+declare class InvalidEntityData extends CoreException {
+    message: string;
+    readonly [ExceptionLayer]: CoreExceptionType;
+    name: string;
+    source: string;
+    constructor(message?: string);
+}
+
+declare class InvalidObjectValueException extends CoreException {
+    objectValueName: string;
+    message: string;
+    readonly [ExceptionLayer]: CoreExceptionType;
+    readonly name = "Invalid Object Value";
+    source: string;
+    constructor(objectValueName: string, message?: string);
+}
+
+declare class UnknownException extends CoreException {
+    message: string;
+    readonly [ExceptionLayer]: CoreExceptionType;
+    name: string;
+    source: string;
+    constructor(message?: string);
+}
+
+type InternalErrors_InvalidEntityData = InvalidEntityData;
+declare const InternalErrors_InvalidEntityData: typeof InvalidEntityData;
+type InternalErrors_InvalidObjectValueException = InvalidObjectValueException;
+declare const InternalErrors_InvalidObjectValueException: typeof InvalidObjectValueException;
+type InternalErrors_UnknownException = UnknownException;
+declare const InternalErrors_UnknownException: typeof UnknownException;
+declare namespace InternalErrors {
+  export { InternalErrors_InvalidEntityData as InvalidEntityData, InternalErrors_InvalidObjectValueException as InvalidObjectValueException, InternalErrors_UnknownException as UnknownException };
+}
+
+export { InternalErrors as I, UnknownException as U, InvalidEntityData as a, InvalidObjectValueException as b };

package/dist/index-CNApJ5kV.d.ts

@@ -0,0 +1,35 @@
+import { D as DomainException } from './domain-exception-2mxDRlhr.js';
+
+declare class InvalidDomainDataException extends DomainException {
+    source: string;
+    message: string;
+    readonly name = "Invalid Domain Data";
+    constructor(source: string, message?: string);
+}
+
+declare class OperationFailedException extends DomainException {
+    source: string;
+    message: string;
+    readonly name = "Operation Failed";
+    constructor(source: string, message?: string);
+}
+
+declare class InvalidPropertyException extends DomainException {
+    readonly property: string;
+    readonly source: string;
+    readonly message: string;
+    readonly name = "Invalid Property";
+    constructor(property: string, source: string, message?: string);
+}
+
+type DomainExceptions_InvalidDomainDataException = InvalidDomainDataException;
+declare const DomainExceptions_InvalidDomainDataException: typeof InvalidDomainDataException;
+type DomainExceptions_InvalidPropertyException = InvalidPropertyException;
+declare const DomainExceptions_InvalidPropertyException: typeof InvalidPropertyException;
+type DomainExceptions_OperationFailedException = OperationFailedException;
+declare const DomainExceptions_OperationFailedException: typeof OperationFailedException;
+declare namespace DomainExceptions {
+  export { DomainExceptions_InvalidDomainDataException as InvalidDomainDataException, DomainExceptions_InvalidPropertyException as InvalidPropertyException, DomainExceptions_OperationFailedException as OperationFailedException };
+}
+
+export { DomainExceptions as D, InvalidDomainDataException as I, OperationFailedException as O, InvalidPropertyException as a };

package/dist/index-DaS_UsEv.d.cts

@@ -0,0 +1,89 @@
+import { I as InfraException } from './infra-exception-Dm1D9yrN.cjs';
+
+declare class CacheUnavailableException extends InfraException {
+    source: string;
+    message: string;
+    name: string;
+    constructor(source: string, message?: string);
+}
+
+declare class ConflictException extends InfraException {
+    source: string;
+    message: string;
+    name: string;
+    constructor(source: string, message?: string);
+}
+
+declare class OperationNotAllowedException extends InfraException {
+    source: string;
+    message: string;
+    name: string;
+    constructor(source: string, message?: string);
+}
+
+declare class DatabaseUnavailableException extends InfraException {
+    source: string;
+    message: string;
+    name: string;
+    constructor(source: string, message?: string);
+}
+
+declare class ResourceNotFoundException extends InfraException {
+    source: string;
+    message: string;
+    name: string;
+    constructor(source: string, message?: string);
+}
+
+declare class ForeignDependencyConstraintException extends InfraException {
+    source: string;
+    message: string;
+    name: string;
+    constructor(source: string, message?: string);
+}
+
+declare class UnexpectedCacheValueException extends InfraException {
+    readonly key: string;
+    readonly source: string;
+    readonly message: string;
+    readonly name = "Unexpected Cache Value Exception";
+    constructor(key: string, source: string, message?: string);
+}
+
+declare class MissingPluginDependencyException extends InfraException {
+    source: string;
+    message: string;
+    name: string;
+    constructor(source: string, message?: string);
+}
+
+declare class InvalidEnvironmentException extends InfraException {
+    source: string;
+    message: string;
+    name: string;
+    constructor(source: string, message?: string);
+}
+
+type InfraExceptions_CacheUnavailableException = CacheUnavailableException;
+declare const InfraExceptions_CacheUnavailableException: typeof CacheUnavailableException;
+type InfraExceptions_ConflictException = ConflictException;
+declare const InfraExceptions_ConflictException: typeof ConflictException;
+type InfraExceptions_DatabaseUnavailableException = DatabaseUnavailableException;
+declare const InfraExceptions_DatabaseUnavailableException: typeof DatabaseUnavailableException;
+type InfraExceptions_ForeignDependencyConstraintException = ForeignDependencyConstraintException;
+declare const InfraExceptions_ForeignDependencyConstraintException: typeof ForeignDependencyConstraintException;
+type InfraExceptions_InvalidEnvironmentException = InvalidEnvironmentException;
+declare const InfraExceptions_InvalidEnvironmentException: typeof InvalidEnvironmentException;
+type InfraExceptions_MissingPluginDependencyException = MissingPluginDependencyException;
+declare const InfraExceptions_MissingPluginDependencyException: typeof MissingPluginDependencyException;
+type InfraExceptions_OperationNotAllowedException = OperationNotAllowedException;
+declare const InfraExceptions_OperationNotAllowedException: typeof OperationNotAllowedException;
+type InfraExceptions_ResourceNotFoundException = ResourceNotFoundException;
+declare const InfraExceptions_ResourceNotFoundException: typeof ResourceNotFoundException;
+type InfraExceptions_UnexpectedCacheValueException = UnexpectedCacheValueException;
+declare const InfraExceptions_UnexpectedCacheValueException: typeof UnexpectedCacheValueException;
+declare namespace InfraExceptions {
+  export { InfraExceptions_CacheUnavailableException as CacheUnavailableException, InfraExceptions_ConflictException as ConflictException, InfraExceptions_DatabaseUnavailableException as DatabaseUnavailableException, InfraExceptions_ForeignDependencyConstraintException as ForeignDependencyConstraintException, InfraExceptions_InvalidEnvironmentException as InvalidEnvironmentException, InfraExceptions_MissingPluginDependencyException as MissingPluginDependencyException, InfraExceptions_OperationNotAllowedException as OperationNotAllowedException, InfraExceptions_ResourceNotFoundException as ResourceNotFoundException, InfraExceptions_UnexpectedCacheValueException as UnexpectedCacheValueException };
+}
+
+export { CacheUnavailableException as C, DatabaseUnavailableException as D, ForeignDependencyConstraintException as F, InfraExceptions as I, MissingPluginDependencyException as M, OperationNotAllowedException as O, ResourceNotFoundException as R, UnexpectedCacheValueException as U, ConflictException as a, InvalidEnvironmentException as b };