candidhealth 0.18.2 → 0.23.0

package/dist/core/schemas/builders/schema-utils/getSchemaUtils.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.transform = exports.optional = exports.getSchemaUtils = void 0;
 const Schema_1 = require("../../Schema");
@@ -8,20 +17,20 @@ function getSchemaUtils(schema) {
     return {
         optional: () => optional(schema),
         transform: (transformer) => transform(schema, transformer),
-        parseOrThrow: async (raw, opts) => {
-            const parsed = await schema.parse(raw, opts);
+        parseOrThrow: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+            const parsed = yield schema.parse(raw, opts);
             if (parsed.ok) {
                 return parsed.value;
             }
             throw new ParseError_1.ParseError(parsed.errors);
-        },
-        jsonOrThrow: async (parsed, opts) => {
-            const raw = await schema.json(parsed, opts);
+        }),
+        jsonOrThrow: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
+            const raw = yield schema.json(parsed, opts);
             if (raw.ok) {
                 return raw.value;
             }
             throw new JsonError_1.JsonError(raw.errors);
-        },
+        }),
     };
 }
 exports.getSchemaUtils = getSchemaUtils;
@@ -50,16 +59,13 @@ function optional(schema) {
         },
         getType: () => Schema_1.SchemaType.OPTIONAL,
     };
-    return {
-        ...baseSchema,
-        ...getSchemaUtils(baseSchema),
-    };
+    return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));
 }
 exports.optional = optional;
 function transform(schema, transformer) {
     const baseSchema = {
-        parse: async (raw, opts) => {
-            const parsed = await schema.parse(raw, opts);
+        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+            const parsed = yield schema.parse(raw, opts);
             if (!parsed.ok) {
                 return parsed;
             }
@@ -67,16 +73,13 @@ function transform(schema, transformer) {
                 ok: true,
                 value: transformer.transform(parsed.value),
             };
-        },
-        json: async (transformed, opts) => {
-            const parsed = await transformer.untransform(transformed);
+        }),
+        json: (transformed, opts) => __awaiter(this, void 0, void 0, function* () {
+            const parsed = yield transformer.untransform(transformed);
             return schema.json(parsed, opts);
-        },
+        }),
         getType: () => schema.getType(),
     };
-    return {
-        ...baseSchema,
-        ...getSchemaUtils(baseSchema),
-    };
+    return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));
 }
 exports.transform = transform;

package/dist/core/schemas/builders/schema-utils/index.d.ts

@@ -1,3 +1,4 @@
-export { getSchemaUtils, optional, transform, type SchemaUtils } from "./getSchemaUtils";
+export { getSchemaUtils, optional, transform } from "./getSchemaUtils";
+export type { SchemaUtils } from "./getSchemaUtils";
 export { JsonError } from "./JsonError";
 export { ParseError } from "./ParseError";

package/dist/core/schemas/builders/set/set.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.set = void 0;
 const Schema_1 = require("../../Schema");
@@ -9,8 +18,8 @@ const schema_utils_1 = require("../schema-utils");
 function set(schema) {
     const listSchema = (0, list_1.list)(schema);
     const baseSchema = {
-        parse: async (raw, opts) => {
-            const parsedList = await listSchema.parse(raw, opts);
+        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+            const parsedList = yield listSchema.parse(raw, opts);
             if (parsedList.ok) {
                 return {
                     ok: true,
@@ -20,27 +29,25 @@ function set(schema) {
             else {
                 return parsedList;
             }
-        },
-        json: async (parsed, opts) => {
+        }),
+        json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
             if (!(parsed instanceof Set)) {
                 return {
                     ok: false,
                     errors: [
                         {
-                            path: opts?.breadcrumbsPrefix ?? [],
+                            path: (_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : [],
                             message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(parsed, "Set"),
                         },
                     ],
                 };
             }
-            const jsonList = await listSchema.json([...parsed], opts);
+            const jsonList = yield listSchema.json([...parsed], opts);
             return jsonList;
-        },
+        }),
         getType: () => Schema_1.SchemaType.SET,
     };
-    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.set = set;

package/dist/core/schemas/builders/undiscriminated-union/index.d.ts

@@ -1,2 +1,2 @@
-export { type inferParsedUnidiscriminatedUnionSchema, type inferRawUnidiscriminatedUnionSchema, type UndiscriminatedUnionSchema, } from "./types";
+export type { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema, UndiscriminatedUnionSchema, } from "./types";
 export { undiscriminatedUnion } from "./undiscriminatedUnion";

package/dist/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.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.undiscriminatedUnion = void 0;
 const Schema_1 = require("../../Schema");
@@ -6,38 +15,37 @@ const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
 const schema_utils_1 = require("../schema-utils");
 function undiscriminatedUnion(schemas) {
     const baseSchema = {
-        parse: async (raw, opts) => {
-            return validateAndTransformUndiscriminatedUnion((schema) => schema.parse(raw, opts), schemas);
-        },
-        json: async (parsed, opts) => {
-            return validateAndTransformUndiscriminatedUnion((schema) => schema.json(parsed, opts), schemas);
-        },
+        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+            return validateAndTransformUndiscriminatedUnion((schema, opts) => schema.parse(raw, opts), schemas, opts);
+        }),
+        json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
+            return validateAndTransformUndiscriminatedUnion((schema, opts) => schema.json(parsed, opts), schemas, opts);
+        }),
         getType: () => Schema_1.SchemaType.UNDISCRIMINATED_UNION,
     };
-    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.undiscriminatedUnion = undiscriminatedUnion;
-async function validateAndTransformUndiscriminatedUnion(transform, schemas) {
-    const errors = [];
-    for (const [index, schema] of schemas.entries()) {
-        const transformed = await transform(schema);
-        if (transformed.ok) {
-            return transformed;
-        }
-        else {
-            for (const error of errors) {
-                errors.push({
-                    path: error.path,
-                    message: `[Variant ${index}] ${error.message}`,
-                });
+function validateAndTransformUndiscriminatedUnion(transform, schemas, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const errors = [];
+        for (const [index, schema] of schemas.entries()) {
+            const transformed = yield transform(schema, Object.assign(Object.assign({}, opts), { skipValidation: false }));
+            if (transformed.ok) {
+                return transformed;
+            }
+            else {
+                for (const error of transformed.errors) {
+                    errors.push({
+                        path: error.path,
+                        message: `[Variant ${index}] ${error.message}`,
+                    });
+                }
             }
         }
-    }
-    return {
-        ok: false,
-        errors,
-    };
+        return {
+            ok: false,
+            errors,
+        };
+    });
 }

package/dist/core/schemas/builders/union/index.d.ts

@@ -1,3 +1,4 @@
-export { discriminant, type Discriminant } from "./discriminant";
-export { type inferParsedDiscriminant, type inferParsedUnion, type inferRawDiscriminant, type inferRawUnion, type UnionSubtypes, } from "./types";
+export { discriminant } from "./discriminant";
+export type { Discriminant } from "./discriminant";
+export type { inferParsedDiscriminant, inferParsedUnion, inferRawDiscriminant, inferRawUnion, UnionSubtypes, } from "./types";
 export { union } from "./union";

package/dist/core/schemas/builders/union/union.js

@@ -1,4 +1,24 @@
 "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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.union = void 0;
 const Schema_1 = require("../../Schema");
@@ -16,108 +36,106 @@ function union(discriminant, union) {
         : discriminant.parsedDiscriminant;
     const discriminantValueSchema = (0, enum_1.enum_)((0, keys_1.keys)(union));
     const baseSchema = {
-        parse: async (raw, opts) => {
+        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
             return transformAndValidateUnion({
                 value: raw,
                 discriminant: rawDiscriminant,
                 transformedDiscriminant: parsedDiscriminant,
-                transformDiscriminantValue: (discriminantValue) => discriminantValueSchema.parse(discriminantValue, {
-                    allowUnrecognizedEnumValues: opts?.allowUnrecognizedUnionMembers,
-                    breadcrumbsPrefix: [...(opts?.breadcrumbsPrefix ?? []), rawDiscriminant],
-                }),
+                transformDiscriminantValue: (discriminantValue) => {
+                    var _a;
+                    return discriminantValueSchema.parse(discriminantValue, {
+                        allowUnrecognizedEnumValues: opts === null || opts === void 0 ? void 0 : opts.allowUnrecognizedUnionMembers,
+                        breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), rawDiscriminant],
+                    });
+                },
                 getAdditionalPropertiesSchema: (discriminantValue) => union[discriminantValue],
-                allowUnrecognizedUnionMembers: opts?.allowUnrecognizedUnionMembers,
+                allowUnrecognizedUnionMembers: opts === null || opts === void 0 ? void 0 : opts.allowUnrecognizedUnionMembers,
                 transformAdditionalProperties: (additionalProperties, additionalPropertiesSchema) => additionalPropertiesSchema.parse(additionalProperties, opts),
-                breadcrumbsPrefix: opts?.breadcrumbsPrefix,
+                breadcrumbsPrefix: opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix,
             });
-        },
-        json: async (parsed, opts) => {
+        }),
+        json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
             return transformAndValidateUnion({
                 value: parsed,
                 discriminant: parsedDiscriminant,
                 transformedDiscriminant: rawDiscriminant,
-                transformDiscriminantValue: (discriminantValue) => discriminantValueSchema.json(discriminantValue, {
-                    allowUnrecognizedEnumValues: opts?.allowUnrecognizedUnionMembers,
-                    breadcrumbsPrefix: [...(opts?.breadcrumbsPrefix ?? []), parsedDiscriminant],
-                }),
+                transformDiscriminantValue: (discriminantValue) => {
+                    var _a;
+                    return discriminantValueSchema.json(discriminantValue, {
+                        allowUnrecognizedEnumValues: opts === null || opts === void 0 ? void 0 : opts.allowUnrecognizedUnionMembers,
+                        breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), parsedDiscriminant],
+                    });
+                },
                 getAdditionalPropertiesSchema: (discriminantValue) => union[discriminantValue],
-                allowUnrecognizedUnionMembers: opts?.allowUnrecognizedUnionMembers,
+                allowUnrecognizedUnionMembers: opts === null || opts === void 0 ? void 0 : opts.allowUnrecognizedUnionMembers,
                 transformAdditionalProperties: (additionalProperties, additionalPropertiesSchema) => additionalPropertiesSchema.json(additionalProperties, opts),
-                breadcrumbsPrefix: opts?.breadcrumbsPrefix,
+                breadcrumbsPrefix: opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix,
             });
-        },
+        }),
         getType: () => Schema_1.SchemaType.UNION,
     };
-    return {
-        ...(0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema),
-        ...(0, schema_utils_1.getSchemaUtils)(baseSchema),
-        ...(0, object_like_1.getObjectLikeUtils)(baseSchema),
-    };
+    return Object.assign(Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema));
 }
 exports.union = union;
-async function transformAndValidateUnion({ value, discriminant, transformedDiscriminant, transformDiscriminantValue, getAdditionalPropertiesSchema, allowUnrecognizedUnionMembers = false, transformAdditionalProperties, breadcrumbsPrefix = [], }) {
-    if (!(0, isPlainObject_1.isPlainObject)(value)) {
-        return {
-            ok: false,
-            errors: [
-                {
-                    path: breadcrumbsPrefix,
-                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "object"),
-                },
-            ],
-        };
-    }
-    const { [discriminant]: discriminantValue, ...additionalProperties } = value;
-    if (discriminantValue == null) {
-        return {
-            ok: false,
-            errors: [
-                {
-                    path: breadcrumbsPrefix,
-                    message: `Missing discriminant ("${discriminant}")`,
-                },
-            ],
-        };
-    }
-    const transformedDiscriminantValue = await transformDiscriminantValue(discriminantValue);
-    if (!transformedDiscriminantValue.ok) {
-        return {
-            ok: false,
-            errors: transformedDiscriminantValue.errors,
-        };
-    }
-    const additionalPropertiesSchema = getAdditionalPropertiesSchema(transformedDiscriminantValue.value);
-    if (additionalPropertiesSchema == null) {
-        if (allowUnrecognizedUnionMembers) {
+function transformAndValidateUnion({ value, discriminant, transformedDiscriminant, transformDiscriminantValue, getAdditionalPropertiesSchema, allowUnrecognizedUnionMembers = false, transformAdditionalProperties, breadcrumbsPrefix = [], }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(0, isPlainObject_1.isPlainObject)(value)) {
             return {
-                ok: true,
-                value: {
-                    [transformedDiscriminant]: transformedDiscriminantValue.value,
-                    ...additionalProperties,
-                },
+                ok: false,
+                errors: [
+                    {
+                        path: breadcrumbsPrefix,
+                        message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "object"),
+                    },
+                ],
             };
         }
-        else {
+        const _a = value, _b = discriminant, discriminantValue = _a[_b], additionalProperties = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+        if (discriminantValue == null) {
             return {
                 ok: false,
                 errors: [
                     {
-                        path: [...breadcrumbsPrefix, discriminant],
-                        message: "Unexpected discriminant value",
+                        path: breadcrumbsPrefix,
+                        message: `Missing discriminant ("${discriminant}")`,
                     },
                 ],
             };
         }
-    }
-    const transformedAdditionalProperties = await transformAdditionalProperties(additionalProperties, additionalPropertiesSchema);
-    if (!transformedAdditionalProperties.ok) {
-        return transformedAdditionalProperties;
-    }
-    return {
-        ok: true,
-        value: {
-            [transformedDiscriminant]: discriminantValue,
-            ...transformedAdditionalProperties.value,
-        },
-    };
+        const transformedDiscriminantValue = yield transformDiscriminantValue(discriminantValue);
+        if (!transformedDiscriminantValue.ok) {
+            return {
+                ok: false,
+                errors: transformedDiscriminantValue.errors,
+            };
+        }
+        const additionalPropertiesSchema = getAdditionalPropertiesSchema(transformedDiscriminantValue.value);
+        if (additionalPropertiesSchema == null) {
+            if (allowUnrecognizedUnionMembers) {
+                return {
+                    ok: true,
+                    value: Object.assign({ [transformedDiscriminant]: transformedDiscriminantValue.value }, additionalProperties),
+                };
+            }
+            else {
+                return {
+                    ok: false,
+                    errors: [
+                        {
+                            path: [...breadcrumbsPrefix, discriminant],
+                            message: "Unexpected discriminant value",
+                        },
+                    ],
+                };
+            }
+        }
+        const transformedAdditionalProperties = yield transformAdditionalProperties(additionalProperties, additionalPropertiesSchema);
+        if (!transformedAdditionalProperties.ok) {
+            return transformedAdditionalProperties;
+        }
+        return {
+            ok: true,
+            value: Object.assign({ [transformedDiscriminant]: discriminantValue }, transformedAdditionalProperties.value),
+        };
+    });
 }

package/dist/core/schemas/index.d.ts

@@ -1,2 +1,2 @@
 export * from "./builders";
-export { type inferParsed, type inferRaw, type Schema, type SchemaOptions } from "./Schema";
+export type { inferParsed, inferRaw, Schema, SchemaOptions } from "./Schema";

package/dist/core/schemas/utils/createIdentitySchemaCreator.js

@@ -10,10 +10,7 @@ function createIdentitySchemaCreator(schemaType, validate) {
             json: validate,
             getType: () => schemaType,
         };
-        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.createIdentitySchemaCreator = createIdentitySchemaCreator;

package/dist/core/schemas/utils/maybeSkipValidation.js

@@ -1,18 +1,23 @@
 "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.maybeSkipValidation = void 0;
 function maybeSkipValidation(schema) {
-    return {
-        ...schema,
-        json: transformAndMaybeSkipValidation(schema.json),
-        parse: transformAndMaybeSkipValidation(schema.parse),
-    };
+    return Object.assign(Object.assign({}, schema), { json: transformAndMaybeSkipValidation(schema.json), parse: transformAndMaybeSkipValidation(schema.parse) });
 }
 exports.maybeSkipValidation = maybeSkipValidation;
 function transformAndMaybeSkipValidation(transform) {
-    return async (value, opts) => {
-        const transformed = await transform(value, opts);
-        const { skipValidation = false } = opts ?? {};
+    return (value, opts) => __awaiter(this, void 0, void 0, function* () {
+        const transformed = yield transform(value, opts);
+        const { skipValidation = false } = opts !== null && opts !== void 0 ? opts : {};
         if (!transformed.ok && skipValidation) {
             // eslint-disable-next-line no-console
             console.warn([
@@ -28,5 +33,5 @@ function transformAndMaybeSkipValidation(transform) {
         else {
             return transformed;
         }
-    };
+    });
 }

package/dist/errors/CandidApiError.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+export declare class CandidApiError extends Error {
+    readonly statusCode?: number;
+    readonly body?: unknown;
+    constructor({ message, statusCode, body }: {
+        message?: string;
+        statusCode?: number;
+        body?: unknown;
+    });
+}

package/dist/errors/CandidApiError.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CandidApiError = void 0;
+class CandidApiError extends Error {
+    constructor({ message, statusCode, body }) {
+        super(buildMessage({ message, statusCode, body }));
+        Object.setPrototypeOf(this, CandidApiError.prototype);
+        if (statusCode != null) {
+            this.statusCode = statusCode;
+        }
+        if (body !== undefined) {
+            this.body = body;
+        }
+    }
+}
+exports.CandidApiError = CandidApiError;
+function buildMessage({ message, statusCode, body, }) {
+    let lines = [];
+    if (message != null) {
+        lines.push(message);
+    }
+    if (statusCode != null) {
+        lines.push(`Status code: ${statusCode.toString()}`);
+    }
+    if (body != null) {
+        lines.push(`Body: ${JSON.stringify(body, undefined, 2)}`);
+    }
+    return lines.join("\n");
+}

package/dist/errors/CandidApiTimeoutError.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+export declare class CandidApiTimeoutError extends Error {
+    constructor();
+}

package/dist/errors/CandidApiTimeoutError.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CandidApiTimeoutError = void 0;
+class CandidApiTimeoutError extends Error {
+    constructor() {
+        super("Timeout");
+        Object.setPrototypeOf(this, CandidApiTimeoutError.prototype);
+    }
+}
+exports.CandidApiTimeoutError = CandidApiTimeoutError;

package/dist/errors/index.d.ts

@@ -0,0 +1,2 @@
+export { CandidApiError } from "./CandidApiError";
+export { CandidApiTimeoutError } from "./CandidApiTimeoutError";

package/dist/errors/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CandidApiTimeoutError = exports.CandidApiError = void 0;
+var CandidApiError_1 = require("./CandidApiError");
+Object.defineProperty(exports, "CandidApiError", { enumerable: true, get: function () { return CandidApiError_1.CandidApiError; } });
+var CandidApiTimeoutError_1 = require("./CandidApiTimeoutError");
+Object.defineProperty(exports, "CandidApiTimeoutError", { enumerable: true, get: function () { return CandidApiTimeoutError_1.CandidApiTimeoutError; } });

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * as CandidApi from "./api";
-export { CandidApiClient } from "./CandidApiClient";
+export { CandidApiClient } from "./Client";
 export { CandidApiEnvironment } from "./environments";
+export { CandidApiError, CandidApiTimeoutError } from "./errors";

package/dist/index.js

@@ -23,9 +23,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CandidApiEnvironment = exports.CandidApiClient = exports.CandidApi = void 0;
+exports.CandidApiTimeoutError = exports.CandidApiError = exports.CandidApiEnvironment = exports.CandidApiClient = exports.CandidApi = void 0;
 exports.CandidApi = __importStar(require("./api"));
-var CandidApiClient_1 = require("./CandidApiClient");
-Object.defineProperty(exports, "CandidApiClient", { enumerable: true, get: function () { return CandidApiClient_1.CandidApiClient; } });
+var Client_1 = require("./Client");
+Object.defineProperty(exports, "CandidApiClient", { enumerable: true, get: function () { return Client_1.CandidApiClient; } });
 var environments_1 = require("./environments");
 Object.defineProperty(exports, "CandidApiEnvironment", { enumerable: true, get: function () { return environments_1.CandidApiEnvironment; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "CandidApiError", { enumerable: true, get: function () { return errors_1.CandidApiError; } });
+Object.defineProperty(exports, "CandidApiTimeoutError", { enumerable: true, get: function () { return errors_1.CandidApiTimeoutError; } });

package/dist/serialization/resources/auth/resources/v2/client/getToken.d.ts

@@ -1,14 +1,15 @@
 /**
  * This file was auto-generated by Fern from our API Definition.
  */
-import * as serializers from "../../../../..";
-import * as CandidApi from "../../../../../../api";
+import * as serializers from "../../../../../index";
+import * as CandidApi from "../../../../../../api/index";
 import * as core from "../../../../../../core";
+import { TooManyRequestsErrorType } from "../types/TooManyRequestsErrorType";
 export declare const Error: core.serialization.Schema<serializers.auth.v2.getToken.Error.Raw, CandidApi.auth.v2.getToken.Error>;
 export declare namespace Error {
     type Raw = Error.TooManyRequestsError;
     interface TooManyRequestsError {
         errorName: "TooManyRequestsError";
-        content: serializers.auth.v2.TooManyRequestsErrorType.Raw;
+        content: TooManyRequestsErrorType.Raw;
     }
 }