@thejob/schema 1.0.1 → 1.0.2

package/dist/cjs/job-application/job-application.constant.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupportedJobApplicationScores = exports.JobApplicationScore = exports.SupportedJobApplicationsStatuses = exports.JobApplicationStatus = void 0;
+var JobApplicationStatus;
+(function (JobApplicationStatus) {
+    JobApplicationStatus["Open"] = "open";
+    JobApplicationStatus["Shortlisted"] = "shortlisted";
+    JobApplicationStatus["Interview"] = "interview";
+    JobApplicationStatus["Offered"] = "offered";
+    JobApplicationStatus["Rejected"] = "rejected";
+    JobApplicationStatus["Hired"] = "hired";
+    JobApplicationStatus["Closed"] = "closed";
+    JobApplicationStatus["Archived"] = "archived";
+    JobApplicationStatus["Expired"] = "expired";
+})(JobApplicationStatus || (exports.JobApplicationStatus = JobApplicationStatus = {}));
+exports.SupportedJobApplicationsStatuses = [
+    JobApplicationStatus.Open,
+    JobApplicationStatus.Shortlisted,
+    JobApplicationStatus.Interview,
+    JobApplicationStatus.Offered,
+    JobApplicationStatus.Rejected,
+    JobApplicationStatus.Hired,
+    JobApplicationStatus.Closed,
+    JobApplicationStatus.Archived,
+];
+var JobApplicationScore;
+(function (JobApplicationScore) {
+    JobApplicationScore[JobApplicationScore["Exceptional"] = 10] = "Exceptional";
+    JobApplicationScore[JobApplicationScore["Qualified"] = 9] = "Qualified";
+    JobApplicationScore[JobApplicationScore["Potential"] = 8] = "Potential";
+    JobApplicationScore[JobApplicationScore["NotRecommended"] = 1] = "NotRecommended";
+})(JobApplicationScore || (exports.JobApplicationScore = JobApplicationScore = {}));
+exports.SupportedJobApplicationScores = [
+    JobApplicationScore.Exceptional,
+    JobApplicationScore.Qualified,
+    JobApplicationScore.Potential,
+    JobApplicationScore.NotRecommended,
+];

package/dist/cjs/job-application/job-application.schema.d.ts

@@ -0,0 +1,211 @@
+import { AnswerChoiceType, QuestionType } from "../question";
+import { InferType, ObjectSchema } from "../yup-extended";
+import { JobApplicationStatus } from "./job-application.constant";
+export declare const JobApplicationSchema: ObjectSchema<{
+    name: {
+        first: string;
+        last: string;
+    };
+    email: string;
+    emailVerified: NonNullable<boolean | undefined>;
+    mobile: {
+        number: string;
+        country: {
+            locale?: string | undefined;
+            name: string;
+            dial_code: string;
+            code: string;
+        };
+    };
+    jobId: string;
+    userId: string;
+    applicationSummary: string | undefined;
+    score: number | undefined;
+    experienceLevel: NonNullable<import("../common").ExperienceLevel | undefined>;
+    location: {
+        state?: string | undefined;
+        stateCode?: string | undefined;
+        country: string;
+        countryCode: string;
+        city: string;
+        address: string;
+        latLong: {
+            country?: (number | undefined)[] | undefined;
+            state?: number[] | undefined;
+            city?: number[] | undefined;
+        };
+    };
+    recentWork: {
+        description?: string | undefined;
+        duration: {
+            startDate: string;
+            endDate: string;
+            isActive: boolean;
+        };
+        location: {
+            state?: string | undefined;
+            stateCode?: string | undefined;
+            country: string;
+            countryCode: string;
+            city: string;
+            address: string;
+            latLong: {
+                country?: (number | undefined)[] | undefined;
+                state?: number[] | undefined;
+                city?: number[] | undefined;
+            };
+        };
+        company: NonNullable<{
+            logo?: string | undefined;
+            name: string;
+            id: string;
+        } | {
+            value: "others" | (string | undefined)[];
+            otherValue: string | string[];
+        } | undefined>;
+        designation: NonNullable<{
+            logo?: string | undefined;
+            name: string;
+            id: string;
+        } | {
+            value: "others" | (string | undefined)[];
+            otherValue: string | string[];
+        } | undefined>;
+        isRemote: boolean;
+    };
+    recentEducation: {
+        description?: string | undefined;
+        institute: NonNullable<{
+            logo?: string | undefined;
+            name: string;
+            id: string;
+        } | {
+            value: "others" | (string | undefined)[];
+            otherValue: string | string[];
+        } | undefined>;
+        course: NonNullable<{
+            logo?: string | undefined;
+            name: string;
+            id: string;
+        } | {
+            value: "others" | (string | undefined)[];
+            otherValue: string | string[];
+        } | undefined>;
+        fieldOfStudy: NonNullable<NonNullable<{
+            logo?: string | undefined;
+            name: string;
+            id: string;
+        } | {
+            value: "others" | (string | undefined)[];
+            otherValue: string | string[];
+        } | undefined>>;
+        isDistanceLearning: boolean;
+        studyType: NonNullable<import("../common").StudyType | undefined>;
+        duration: {
+            startDate: string;
+            endDate: string;
+            isActive: boolean;
+        };
+        location: {
+            state?: string | undefined;
+            stateCode?: string | undefined;
+            country: string;
+            countryCode: string;
+            city: string;
+            address: string;
+            latLong: {
+                country?: (number | undefined)[] | undefined;
+                state?: number[] | undefined;
+                city?: number[] | undefined;
+            };
+        };
+    };
+    resume: {
+        markdown: string;
+        markdownStyling: import("../resume").ResumeMarkdownStyle;
+    };
+    status: JobApplicationStatus;
+    questionnaire: {
+        description?: string | undefined;
+        label?: string | undefined;
+        isNew?: boolean | undefined;
+        isOptional?: boolean | undefined;
+        readonly?: boolean | undefined;
+        preferredAnswer?: import("../question").TMixedValue | undefined;
+        optionsFrom?: string | undefined;
+        answers?: string | {
+            logo?: string | undefined;
+            name: string;
+            id: string;
+        } | {
+            value: "others" | (string | undefined)[];
+            otherValue: string | string[];
+        } | undefined;
+        type: NonNullable<QuestionType | undefined>;
+        default: boolean;
+        title: string;
+        options: (string | {
+            logo?: string | undefined;
+            name: string;
+            id: string;
+        } | {
+            value: "others" | (string | undefined)[];
+            otherValue: string | string[];
+        })[];
+        answerChoiceType: NonNullable<AnswerChoiceType | undefined>;
+    }[] | undefined;
+    history: {
+        message?: string | undefined;
+        updatedBy: string;
+        updatedAt: Date;
+        status: NonNullable<JobApplicationStatus | undefined>;
+    }[];
+} & {
+    id: string;
+    shortId: string;
+    createdBy: string;
+    createdAt: string;
+    updatedBy: string | undefined;
+    updatedAt: string | undefined;
+}, import("yup").AnyObject, {
+    name: {
+        first: undefined;
+        last: undefined;
+    };
+    email: undefined;
+    emailVerified: undefined;
+    mobile: undefined;
+    jobId: undefined;
+    userId: undefined;
+    applicationSummary: undefined;
+    score: undefined;
+    experienceLevel: undefined;
+    location: any;
+    recentWork: any;
+    recentEducation: any;
+    resume: {
+        title: undefined;
+        userId: undefined;
+        slug: undefined;
+        status: import("../resume").ResumeStatus.Draft;
+        markdown: undefined;
+        markdownStyling: import("../resume").ResumeMarkdownStyle.Classic;
+        id: undefined;
+        shortId: undefined;
+        createdBy: undefined;
+        createdAt: undefined;
+        updatedBy: undefined;
+        updatedAt: undefined;
+    };
+    status: JobApplicationStatus.Open;
+    questionnaire: "";
+    history: never[];
+    id: undefined;
+    shortId: undefined;
+    createdBy: undefined;
+    createdAt: undefined;
+    updatedBy: undefined;
+    updatedAt: undefined;
+}, "">;
+export type TJobApplicationSchema = InferType<typeof JobApplicationSchema>;
+//# sourceMappingURL=job-application.schema.d.ts.map

package/dist/cjs/job-application/job-application.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-application.schema.d.ts","sourceRoot":"","sources":["../../../src/job-application/job-application.schema.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAmB,MAAM,aAAa,CAAC;AAQ9E,OAAO,EAIL,SAAS,EAKT,YAAY,EAEb,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,oBAAoB,EAGrB,MAAM,4BAA4B,CAAC;AAEpC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgHN,CAAC;AAE5B,MAAM,MAAM,qBAAqB,GAAG,SAAS,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/cjs/job-application/job-application.schema.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobApplicationSchema = void 0;
+const common_1 = require("../common");
+const utils_1 = require("../job/utils");
+const location_1 = require("../location");
+const phone_1 = require("../phone");
+const question_1 = require("../question");
+const resume_1 = require("../resume");
+const user_1 = require("../user");
+const yup_extended_1 = require("../yup-extended");
+const job_application_constant_1 = require("./job-application.constant");
+exports.JobApplicationSchema = (0, yup_extended_1.object)()
+    .shape({
+    name: (0, yup_extended_1.object)().shape({
+        first: (0, yup_extended_1.string)().trim().max(50).required().label("First Name"),
+        last: (0, yup_extended_1.string)().trim().max(50).required().label("Last Name"),
+    }),
+    email: (0, yup_extended_1.string)().email().required().label("Email"),
+    emailVerified: (0, yup_extended_1.boolean)().required().label("Email Verified"),
+    mobile: phone_1.MobileNumberSchema,
+    jobId: (0, yup_extended_1.string)().required().label("Job"),
+    userId: (0, yup_extended_1.string)().required().label("User"),
+    applicationSummary: (0, yup_extended_1.string)().optional().label("Application Summary"),
+    score: (0, yup_extended_1.number)()
+        .oneOf(job_application_constant_1.SupportedJobApplicationScores)
+        .optional()
+        .label("Score"),
+    experienceLevel: (0, yup_extended_1.string)()
+        .oneOf(common_1.SupportedExperienceLevels)
+        .required()
+        .label("Experience Level"),
+    location: (location_1.LocationSchema.required().label("Location")),
+    recentWork: (user_1.WorkExperienceSchema.optional().label("Recent Work")),
+    recentEducation: (user_1.EducationSchema.optional().label("Recent Education")),
+    resume: resume_1.ResumeSchema.pick(["markdown", "markdownStyling"])
+        .required()
+        .label("Resume"),
+    status: (0, yup_extended_1.string)()
+        .oneOf(job_application_constant_1.SupportedJobApplicationsStatuses)
+        .default(job_application_constant_1.JobApplicationStatus.Open)
+        .label("Status"),
+    questionnaire: (0, yup_extended_1.array)().of((0, yup_extended_1.lazy)((question) => {
+        const StringSchema = (0, yup_extended_1.string)().max(500);
+        return (0, utils_1.getSchemaByQuestion)(question.type).concat((0, yup_extended_1.object)().shape({
+            answers: (0, yup_extended_1.mixed)().when("type", {
+                is: (type) => type === question_1.QuestionType.Input,
+                then: () => (0, yup_extended_1.lazy)(() => {
+                    if (question.isOptional) {
+                        return StringSchema.optional().label("Answer");
+                    }
+                    else {
+                        return StringSchema.required().label("Answer");
+                    }
+                }),
+                otherwise: () => (0, yup_extended_1.lazy)(() => {
+                    const commonSchema = (0, yup_extended_1.mixed)().oneOfSchema([
+                        StringSchema,
+                        common_1.NameIdLogoSchema,
+                        common_1.OtherValueSchema,
+                    ]);
+                    if (question.answerChoiceType === question_1.AnswerChoiceType.Multiple) {
+                        return (0, yup_extended_1.lazy)(() => {
+                            const subCommonSchema = (0, yup_extended_1.array)().of(commonSchema);
+                            if (question.isOptional) {
+                                return subCommonSchema
+                                    .optional()
+                                    .default([])
+                                    .label("Answer");
+                            }
+                            else {
+                                return subCommonSchema
+                                    .default([])
+                                    .min(1, "Select at least 1 option")
+                                    .required("Select at least 1 option")
+                                    .label("Answer");
+                            }
+                        });
+                    }
+                    else {
+                        return (0, yup_extended_1.lazy)(() => {
+                            if (question.isOptional) {
+                                return commonSchema.optional().label("Answer");
+                            }
+                            else {
+                                return commonSchema
+                                    .required("Select an option")
+                                    .label("Answer");
+                            }
+                        });
+                    }
+                }),
+            }),
+        }));
+    })),
+    history: (0, yup_extended_1.array)()
+        .of((0, yup_extended_1.object)().shape({
+        status: (0, yup_extended_1.string)()
+            .oneOf(job_application_constant_1.SupportedJobApplicationsStatuses)
+            .required()
+            .label("Status"),
+        message: (0, yup_extended_1.string)().max(500).optional().label("Message"),
+        updatedAt: (0, yup_extended_1.date)().required().label("Updated At"),
+        updatedBy: (0, yup_extended_1.string)().required().label("Updated By"),
+    }))
+        .min(1)
+        .default([])
+        .label("History"),
+})
+    .concat(common_1.DbDefaultSchema)
+    .noUnknown()
+    .strict()
+    .label("Job Application");

package/dist/cjs/job-role-template/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./job-role-template.schema";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/job-role-template/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/job-role-template/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC"}

package/dist/cjs/job-role-template/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./job-role-template.schema"), exports);

package/dist/cjs/job-role-template/job-role-template.schema.d.ts

@@ -0,0 +1,93 @@
+import { InferType } from "../yup-extended";
+export declare const JobRoleTemplateSchema: import("yup").ObjectSchema<{
+    skills: ({
+        logo?: string | undefined;
+        name: string;
+        id: string;
+    } | {
+        value: "others" | (string | undefined)[];
+        otherValue: string | string[];
+    } | undefined)[] | undefined;
+    educationLevel: (import("..").EducationLevel | undefined)[];
+    description: string;
+    headline: string;
+    designation: NonNullable<{
+        logo?: string | undefined;
+        name: string;
+        id: string;
+    } | {
+        value: "others" | (string | undefined)[];
+        otherValue: string | string[];
+    } | undefined>;
+    tags: any[] | undefined;
+    questionnaire: {
+        description?: string | undefined;
+        label?: string | undefined;
+        isNew?: boolean | undefined;
+        isOptional?: boolean | undefined;
+        readonly?: boolean | undefined;
+        preferredAnswer?: import("..").TMixedValue | undefined;
+        optionsFrom?: string | undefined;
+        answers?: import("..").TMixedValue | undefined;
+        type: NonNullable<import("..").QuestionType | undefined>;
+        default: boolean;
+        title: string;
+        options: (string | {
+            logo?: string | undefined;
+            name: string;
+            id: string;
+        } | {
+            value: "others" | (string | undefined)[];
+            otherValue: string | string[];
+        })[];
+        answerChoiceType: NonNullable<import("..").AnswerChoiceType | undefined>;
+    }[] | undefined;
+}, import("yup").AnyObject, {
+    headline: undefined;
+    slug: undefined;
+    applicationReceivePreference: undefined;
+    externalApplyLink: undefined;
+    company: undefined;
+    designation: undefined;
+    employmentType: undefined;
+    workMode: undefined;
+    skills: "";
+    bookmarks: "";
+    applicants: "";
+    externalApplicants: "";
+    description: undefined;
+    descriptionHTML: undefined;
+    descriptionMarkdown: undefined;
+    promoted: undefined;
+    locations: "";
+    educationLevel: undefined;
+    validity: any;
+    experienceLevel: undefined;
+    contactEmail: undefined;
+    workingHoursPerWeek: undefined;
+    tags: undefined;
+    questionnaire: "";
+    status: import("..").JobStatus.Draft;
+    seoTags: {
+        meta: {
+            description: undefined;
+            keywords: "";
+        };
+    };
+    jdSummary: undefined;
+    canCreateAlert: undefined;
+    canDirectApply: undefined;
+    hasApplied: undefined;
+    isOwner: undefined;
+    hasBookmarked: undefined;
+    applicantCount: undefined;
+    externalApplicantCount: undefined;
+    id: undefined;
+    shortId: undefined;
+    createdBy: undefined;
+    createdAt: undefined;
+    updatedBy: undefined;
+    updatedAt: undefined;
+}, "">;
+export type TJobRoleTemplateSchema = InferType<typeof JobRoleTemplateSchema>;
+//# sourceMappingURL=job-role-template.schema.d.ts.map

package/dist/cjs/job-role-template/job-role-template.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-role-template.schema.d.ts","sourceRoot":"","sources":["../../../src/job-role-template/job-role-template.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG5C,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAQhC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,SAAS,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/cjs/job-role-template/job-role-template.schema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobRoleTemplateSchema = void 0;
+const job_schema_1 = require("../job/job.schema");
+exports.JobRoleTemplateSchema = job_schema_1.JobSchema.pick([
+    "headline",
+    "skills",
+    "description",
+    "designation",
+    "questionnaire",
+    "tags",
+    "educationLevel",
+]);

package/dist/cjs/language/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./language.schema";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/language/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/language/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/cjs/language/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./language.schema"), exports);

package/dist/cjs/language/language.schema.d.ts

@@ -0,0 +1,8 @@
+import { InferType } from "../yup-extended";
+export declare const LanguageSchema: import("yup").ObjectSchema<{
+    name: string;
+}, import("yup").AnyObject, {
+    name: undefined;
+}, "">;
+export type TLanguageSchema = InferType<typeof LanguageSchema>;
+//# sourceMappingURL=language.schema.d.ts.map

package/dist/cjs/language/language.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language.schema.d.ts","sourceRoot":"","sources":["../../../src/language/language.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAkB,MAAM,iBAAiB,CAAC;AAE5D,eAAO,MAAM,cAAc;;;;MAeP,CAAC;AAErB,MAAM,MAAM,eAAe,GAAG,SAAS,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/cjs/language/language.schema.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LanguageSchema = void 0;
+const yup_extended_1 = require("../yup-extended");
+exports.LanguageSchema = (0, yup_extended_1.object)()
+    .shape({
+    name: (0, yup_extended_1.string)().trim().max(50).required().label("Name"),
+    // name: mixed<TNameIdSchema | TOtherValueSchema>()
+    //   .oneOfSchema([NameIdSchema, OtherValueSchema])
+    //   .required()
+    //   .label("Name"),
+    // proficiencyLevel: string()
+    //   .trim()
+    //   .max(50)
+    //   .required()
+    //   .label("Proficiency Level"),
+})
+    .noUnknown()
+    .strict()
+    .label("Language");

package/dist/cjs/location/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./location.schema";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/location/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/location/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/cjs/location/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./location.schema"), exports);

package/dist/cjs/location/location.schema.d.ts

@@ -0,0 +1,28 @@
+import { InferType } from "../yup-extended";
+export declare const LocationSchema: import("yup").ObjectSchema<{
+    country: string;
+    countryCode: string;
+    state: string | undefined;
+    stateCode: string | undefined;
+    city: string;
+    address: string;
+    latLong: {
+        country?: (number | undefined)[] | undefined;
+        state?: number[] | undefined;
+        city?: number[] | undefined;
+    };
+}, import("yup").AnyObject, {
+    country: undefined;
+    countryCode: undefined;
+    state: undefined;
+    stateCode: undefined;
+    city: undefined;
+    address: undefined;
+    latLong: {
+        city: "";
+        state: "";
+        country: "";
+    };
+}, "">;
+export type TLocationSchema = InferType<typeof LocationSchema>;
+//# sourceMappingURL=location.schema.d.ts.map

package/dist/cjs/location/location.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"location.schema.d.ts","sourceRoot":"","sources":["../../../src/location/location.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,SAAS,EAA0B,MAAM,iBAAiB,CAAC;AAE3E,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;MA2BzB,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,SAAS,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/cjs/location/location.schema.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocationSchema = void 0;
+const yup_extended_1 = require("../yup-extended");
+exports.LocationSchema = (0, yup_extended_1.object)().shape({
+    country: (0, yup_extended_1.string)().required().label("Country"),
+    countryCode: (0, yup_extended_1.string)().required().label("Country code"),
+    state: (0, yup_extended_1.string)().optional().label("State"),
+    stateCode: (0, yup_extended_1.string)().optional().label("State code"),
+    city: (0, yup_extended_1.string)().required().label("City"),
+    address: (0, yup_extended_1.string)().required().label("Address"),
+    latLong: (0, yup_extended_1.object)()
+        .shape({
+        city: (0, yup_extended_1.array)()
+            .of((0, yup_extended_1.number)().required())
+            .length(2)
+            .optional()
+            .label("City long lat"),
+        state: (0, yup_extended_1.array)()
+            .of((0, yup_extended_1.number)().required())
+            .length(2)
+            .optional()
+            .label("State long lat"),
+        country: (0, yup_extended_1.array)()
+            .of((0, yup_extended_1.number)())
+            .length(2)
+            .optional()
+            .label("Country long lat"),
+    })
+        .required()
+        .label("Long lats"),
+});