candidhealth 0.18.2 → 0.22.2-15e24b1

package/core/runtime/index.d.ts

@@ -0,0 +1 @@
+export { RUNTIME } from "./runtime";

package/core/runtime/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME = void 0;
+var runtime_1 = require("./runtime");
+Object.defineProperty(exports, "RUNTIME", { enumerable: true, get: function () { return runtime_1.RUNTIME; } });

package/core/runtime/runtime.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A constant that indicates which environment and version the SDK is running in.
+ */
+export declare const RUNTIME: Runtime;
+export interface Runtime {
+    type: "browser" | "web-worker" | "deno" | "bun" | "node" | "react-native" | "unknown";
+    version?: string;
+}

package/core/runtime/runtime.js

@@ -0,0 +1,82 @@
+"use strict";
+var _a, _b, _c, _d;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME = void 0;
+/**
+ * A constant that indicates whether the environment the code is running is a Web Browser.
+ */
+const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+/**
+ * A constant that indicates whether the environment the code is running is a Web Worker.
+ */
+const isWebWorker = typeof self === "object" &&
+    // @ts-ignore
+    typeof (self === null || self === void 0 ? void 0 : self.importScripts) === "function" &&
+    (((_a = self.constructor) === null || _a === void 0 ? void 0 : _a.name) === "DedicatedWorkerGlobalScope" ||
+        ((_b = self.constructor) === null || _b === void 0 ? void 0 : _b.name) === "ServiceWorkerGlobalScope" ||
+        ((_c = self.constructor) === null || _c === void 0 ? void 0 : _c.name) === "SharedWorkerGlobalScope");
+/**
+ * A constant that indicates whether the environment the code is running is Deno.
+ */
+const isDeno = typeof Deno !== "undefined" && typeof Deno.version !== "undefined" && typeof Deno.version.deno !== "undefined";
+/**
+ * A constant that indicates whether the environment the code is running is Bun.sh.
+ */
+const isBun = typeof Bun !== "undefined" && typeof Bun.version !== "undefined";
+/**
+ * A constant that indicates whether the environment the code is running is Node.JS.
+ */
+const isNode = typeof process !== "undefined" &&
+    Boolean(process.version) &&
+    Boolean((_d = process.versions) === null || _d === void 0 ? void 0 : _d.node) &&
+    // Deno spoofs process.versions.node, see https://deno.land/std@0.177.0/node/process.ts?s=versions
+    !isDeno &&
+    !isBun;
+/**
+ * A constant that indicates whether the environment the code is running is in React-Native.
+ * https://github.com/facebook/react-native/blob/main/packages/react-native/Libraries/Core/setUpNavigator.js
+ */
+const isReactNative = typeof navigator !== "undefined" && (navigator === null || navigator === void 0 ? void 0 : navigator.product) === "ReactNative";
+/**
+ * A constant that indicates which environment and version the SDK is running in.
+ */
+exports.RUNTIME = evaluateRuntime();
+function evaluateRuntime() {
+    if (isBrowser) {
+        return {
+            type: "browser",
+            version: window.navigator.userAgent,
+        };
+    }
+    if (isWebWorker) {
+        return {
+            type: "web-worker",
+        };
+    }
+    if (isDeno) {
+        return {
+            type: "deno",
+            version: Deno.version.deno,
+        };
+    }
+    if (isBun) {
+        return {
+            type: "bun",
+            version: Bun.version,
+        };
+    }
+    if (isNode) {
+        return {
+            type: "node",
+            version: process.versions.node,
+        };
+    }
+    if (isReactNative) {
+        return {
+            type: "react-native",
+        };
+    }
+    return {
+        type: "unknown",
+    };
+}

package/core/schemas/Schema.d.ts

@@ -13,6 +13,7 @@ export declare const SchemaType: {
     readonly ENUM: "enum";
     readonly LIST: "list";
     readonly STRING_LITERAL: "stringLiteral";
+    readonly BOOLEAN_LITERAL: "booleanLiteral";
     readonly OBJECT: "object";
     readonly ANY: "any";
     readonly BOOLEAN: "boolean";

package/core/schemas/Schema.js

@@ -6,6 +6,7 @@ exports.SchemaType = {
     ENUM: "enum",
     LIST: "list",
     STRING_LITERAL: "stringLiteral",
+    BOOLEAN_LITERAL: "booleanLiteral",
     OBJECT: "object",
     ANY: "any",
     BOOLEAN: "boolean",

package/core/schemas/builders/date/date.js

@@ -58,9 +58,6 @@ function date() {
         },
         getType: () => Schema_1.SchemaType.DATE,
     };
-    return {
-        ...(0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema),
-        ...(0, schema_utils_1.getSchemaUtils)(baseSchema),
-    };
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
 exports.date = date;

package/core/schemas/builders/lazy/index.d.ts

@@ -1,2 +1,3 @@
-export { lazy, type SchemaGetter } from "./lazy";
+export { lazy } from "./lazy";
+export type { SchemaGetter } from "./lazy";
 export { lazyObject } from "./lazyObject";

package/core/schemas/builders/lazy/lazy.js

@@ -1,28 +1,36 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMemoizedSchema = exports.constructLazyBaseSchema = exports.lazy = void 0;
 const schema_utils_1 = require("../schema-utils");
 function lazy(getter) {
     const baseSchema = constructLazyBaseSchema(getter);
-    return {
-        ...baseSchema,
-        ...(0, schema_utils_1.getSchemaUtils)(baseSchema),
-    };
+    return Object.assign(Object.assign({}, baseSchema), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
 exports.lazy = lazy;
 function constructLazyBaseSchema(getter) {
     return {
-        parse: async (raw, opts) => (await getMemoizedSchema(getter)).parse(raw, opts),
-        json: async (parsed, opts) => (await getMemoizedSchema(getter)).json(parsed, opts),
-        getType: async () => (await getMemoizedSchema(getter)).getType(),
+        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () { return (yield getMemoizedSchema(getter)).parse(raw, opts); }),
+        json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () { return (yield getMemoizedSchema(getter)).json(parsed, opts); }),
+        getType: () => __awaiter(this, void 0, void 0, function* () { return (yield getMemoizedSchema(getter)).getType(); }),
     };
 }
 exports.constructLazyBaseSchema = constructLazyBaseSchema;
-async function getMemoizedSchema(getter) {
-    const castedGetter = getter;
-    if (castedGetter.__zurg_memoized == null) {
-        castedGetter.__zurg_memoized = await getter();
-    }
-    return castedGetter.__zurg_memoized;
+function getMemoizedSchema(getter) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const castedGetter = getter;
+        if (castedGetter.__zurg_memoized == null) {
+            castedGetter.__zurg_memoized = yield getter();
+        }
+        return castedGetter.__zurg_memoized;
+    });
 }
 exports.getMemoizedSchema = getMemoizedSchema;

package/core/schemas/builders/lazy/lazyObject.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lazyObject = void 0;
 const object_1 = require("../object");
@@ -6,16 +15,7 @@ const object_like_1 = require("../object-like");
 const schema_utils_1 = require("../schema-utils");
 const lazy_1 = require("./lazy");
 function lazyObject(getter) {
-    const baseSchema = {
-        ...(0, lazy_1.constructLazyBaseSchema)(getter),
-        _getRawProperties: async () => (await (0, lazy_1.getMemoizedSchema)(getter))._getRawProperties(),
-        _getParsedProperties: async () => (await (0, lazy_1.getMemoizedSchema)(getter))._getParsedProperties(),
-    };
-    return {
-        ...baseSchema,
-        ...(0, schema_utils_1.getSchemaUtils)(baseSchema),
-        ...(0, object_like_1.getObjectLikeUtils)(baseSchema),
-        ...(0, object_1.getObjectUtils)(baseSchema),
-    };
+    const baseSchema = Object.assign(Object.assign({}, (0, lazy_1.constructLazyBaseSchema)(getter)), { _getRawProperties: () => __awaiter(this, void 0, void 0, function* () { return (yield (0, lazy_1.getMemoizedSchema)(getter))._getRawProperties(); }), _getParsedProperties: () => __awaiter(this, void 0, void 0, function* () { return (yield (0, lazy_1.getMemoizedSchema)(getter))._getParsedProperties(); }) });
+    return Object.assign(Object.assign(Object.assign(Object.assign({}, baseSchema), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema)), (0, object_1.getObjectUtils)(baseSchema));
 }
 exports.lazyObject = lazyObject;

package/core/schemas/builders/list/list.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.list = void 0;
 const Schema_1 = require("../../Schema");
@@ -7,52 +16,53 @@ const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
 const schema_utils_1 = require("../schema-utils");
 function list(schema) {
     const baseSchema = {
-        parse: async (raw, opts) => validateAndTransformArray(raw, (item, index) => schema.parse(item, {
-            ...opts,
-            breadcrumbsPrefix: [...(opts?.breadcrumbsPrefix ?? []), `[${index}]`],
-        })),
-        json: (parsed, opts) => validateAndTransformArray(parsed, (item, index) => schema.json(item, {
-            ...opts,
-            breadcrumbsPrefix: [...(opts?.breadcrumbsPrefix ?? []), `[${index}]`],
-        })),
+        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+            return validateAndTransformArray(raw, (item, index) => {
+                var _a;
+                return schema.parse(item, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `[${index}]`] }));
+            });
+        }),
+        json: (parsed, opts) => validateAndTransformArray(parsed, (item, index) => {
+            var _a;
+            return schema.json(item, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `[${index}]`] }));
+        }),
         getType: () => Schema_1.SchemaType.LIST,
     };
-    return {
-        ...(0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema),
-        ...(0, schema_utils_1.getSchemaUtils)(baseSchema),
-    };
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
 exports.list = list;
-async function validateAndTransformArray(value, transformItem) {
-    if (!Array.isArray(value)) {
-        return {
-            ok: false,
-            errors: [
-                {
-                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "list"),
-                    path: [],
-                },
-            ],
-        };
-    }
-    const maybeValidItems = await Promise.all(value.map((item, index) => transformItem(item, index)));
-    return maybeValidItems.reduce((acc, item) => {
-        if (acc.ok && item.ok) {
+function validateAndTransformArray(value, transformItem) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!Array.isArray(value)) {
             return {
-                ok: true,
-                value: [...acc.value, item.value],
+                ok: false,
+                errors: [
+                    {
+                        message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "list"),
+                        path: [],
+                    },
+                ],
             };
         }
-        const errors = [];
-        if (!acc.ok) {
-            errors.push(...acc.errors);
-        }
-        if (!item.ok) {
-            errors.push(...item.errors);
-        }
-        return {
-            ok: false,
-            errors,
-        };
-    }, { ok: true, value: [] });
+        const maybeValidItems = yield Promise.all(value.map((item, index) => transformItem(item, index)));
+        return maybeValidItems.reduce((acc, item) => {
+            if (acc.ok && item.ok) {
+                return {
+                    ok: true,
+                    value: [...acc.value, item.value],
+                };
+            }
+            const errors = [];
+            if (!acc.ok) {
+                errors.push(...acc.errors);
+            }
+            if (!item.ok) {
+                errors.push(...item.errors);
+            }
+            return {
+                ok: false,
+                errors,
+            };
+        }, { ok: true, value: [] });
+    });
 }

package/core/schemas/builders/literals/booleanLiteral.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from "../../Schema";
+export declare function booleanLiteral<V extends boolean>(literal: V): Schema<V, V>;

package/core/schemas/builders/literals/booleanLiteral.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.booleanLiteral = void 0;
+const Schema_1 = require("../../Schema");
+const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+function booleanLiteral(literal) {
+    const schemaCreator = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.BOOLEAN_LITERAL, (value, { breadcrumbsPrefix = [] } = {}) => {
+        if (value === literal) {
+            return {
+                ok: true,
+                value: literal,
+            };
+        }
+        else {
+            return {
+                ok: false,
+                errors: [
+                    {
+                        path: breadcrumbsPrefix,
+                        message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, `${literal.toString()}`),
+                    },
+                ],
+            };
+        }
+    });
+    return schemaCreator();
+}
+exports.booleanLiteral = booleanLiteral;

package/core/schemas/builders/literals/index.d.ts

@@ -1 +1,2 @@
 export { stringLiteral } from "./stringLiteral";
+export { booleanLiteral } from "./booleanLiteral";

package/core/schemas/builders/literals/index.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringLiteral = void 0;
+exports.booleanLiteral = exports.stringLiteral = void 0;
 var stringLiteral_1 = require("./stringLiteral");
 Object.defineProperty(exports, "stringLiteral", { enumerable: true, get: function () { return stringLiteral_1.stringLiteral; } });
+var booleanLiteral_1 = require("./booleanLiteral");
+Object.defineProperty(exports, "booleanLiteral", { enumerable: true, get: function () { return booleanLiteral_1.booleanLiteral; } });

package/core/schemas/builders/object/index.d.ts

@@ -1,3 +1,6 @@
 export { getObjectUtils, object } from "./object";
-export { isProperty, property, type Property } from "./property";
-export { type BaseObjectSchema, type inferObjectSchemaFromPropertySchemas, type inferParsedObject, type inferParsedObjectFromPropertySchemas, type inferParsedPropertySchema, type inferRawKey, type inferRawObject, type inferRawObjectFromPropertySchemas, type inferRawPropertySchema, type ObjectSchema, type ObjectUtils, type PropertySchemas, } from "./types";
+export { objectWithoutOptionalProperties } from "./objectWithoutOptionalProperties";
+export type { inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas, inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas, } from "./objectWithoutOptionalProperties";
+export { isProperty, property } from "./property";
+export type { Property } from "./property";
+export type { BaseObjectSchema, inferObjectSchemaFromPropertySchemas, inferParsedObject, inferParsedObjectFromPropertySchemas, inferParsedPropertySchema, inferRawKey, inferRawObject, inferRawObjectFromPropertySchemas, inferRawPropertySchema, ObjectSchema, ObjectUtils, PropertySchemas, } from "./types";

package/core/schemas/builders/object/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.property = exports.isProperty = exports.object = exports.getObjectUtils = void 0;
+exports.property = exports.isProperty = exports.objectWithoutOptionalProperties = exports.object = exports.getObjectUtils = void 0;
 var object_1 = require("./object");
 Object.defineProperty(exports, "getObjectUtils", { enumerable: true, get: function () { return object_1.getObjectUtils; } });
 Object.defineProperty(exports, "object", { enumerable: true, get: function () { return object_1.object; } });
+var objectWithoutOptionalProperties_1 = require("./objectWithoutOptionalProperties");
+Object.defineProperty(exports, "objectWithoutOptionalProperties", { enumerable: true, get: function () { return objectWithoutOptionalProperties_1.objectWithoutOptionalProperties; } });
 var property_1 = require("./property");
 Object.defineProperty(exports, "isProperty", { enumerable: true, get: function () { return property_1.isProperty; } });
 Object.defineProperty(exports, "property", { enumerable: true, get: function () { return property_1.property; } });