lancer-shared 1.2.2 → 1.2.3

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

@@ -1,3 +1,95 @@
-export * from "./job";
-export * from "./job-note";
-export * from "./job-status";
+import { z } from "zod";
+export declare const jobActivityOffsetEnum: z.ZodEnum<["4h", "24h"]>;
+export declare const jobListingSchema: z.ZodObject<{
+    uid: z.ZodNullable<z.ZodString>;
+    title: z.ZodNullable<z.ZodString>;
+    jobUrl: z.ZodNullable<z.ZodString>;
+    datetime: z.ZodNullable<z.ZodString>;
+    isFeatured: z.ZodNullable<z.ZodBoolean>;
+    region: z.ZodNullable<z.ZodUnion<[z.ZodLiteral<"USOnly">, z.ZodLiteral<"UKOnly">, z.ZodLiteral<"Worldwide">]>>;
+}, "strip", z.ZodTypeAny, {
+    uid: string | null;
+    title: string | null;
+    jobUrl: string | null;
+    datetime: string | null;
+    isFeatured: boolean | null;
+    region: "USOnly" | "UKOnly" | "Worldwide" | null;
+}, {
+    uid: string | null;
+    title: string | null;
+    jobUrl: string | null;
+    datetime: string | null;
+    isFeatured: boolean | null;
+    region: "USOnly" | "UKOnly" | "Worldwide" | null;
+}>;
+export declare const jobActivityUpdateSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        proposals: z.ZodObject<{
+            min: z.ZodNullable<z.ZodNumber>;
+            max: z.ZodNullable<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            min: number | null;
+            max: number | null;
+        }, {
+            min: number | null;
+            max: number | null;
+        }>;
+        lastViewedByClient: z.ZodNullable<z.ZodString>;
+        hires: z.ZodNullable<z.ZodNumber>;
+        interviewing: z.ZodNullable<z.ZodNumber>;
+        invitesSent: z.ZodNullable<z.ZodNumber>;
+        unansweredInvites: z.ZodNullable<z.ZodNumber>;
+        updatedAt: z.ZodNullable<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        proposals: {
+            min: number | null;
+            max: number | null;
+        };
+        lastViewedByClient: string | null;
+        hires: number | null;
+        interviewing: number | null;
+        invitesSent: number | null;
+        unansweredInvites: number | null;
+        updatedAt: number | null;
+    }, {
+        proposals: {
+            min: number | null;
+            max: number | null;
+        };
+        lastViewedByClient: string | null;
+        hires: number | null;
+        interviewing: number | null;
+        invitesSent: number | null;
+        unansweredInvites: number | null;
+        updatedAt: number | null;
+    }>;
+    offset: z.ZodEnum<["4h", "24h"]>;
+}, "strip", z.ZodTypeAny, {
+    data: {
+        proposals: {
+            min: number | null;
+            max: number | null;
+        };
+        lastViewedByClient: string | null;
+        hires: number | null;
+        interviewing: number | null;
+        invitesSent: number | null;
+        unansweredInvites: number | null;
+        updatedAt: number | null;
+    };
+    offset: "4h" | "24h";
+}, {
+    data: {
+        proposals: {
+            min: number | null;
+            max: number | null;
+        };
+        lastViewedByClient: string | null;
+        hires: number | null;
+        interviewing: number | null;
+        invitesSent: number | null;
+        unansweredInvites: number | null;
+        updatedAt: number | null;
+    };
+    offset: "4h" | "24h";
+}>;

package/dist/schemas/job-filters/index.js

@@ -1,17 +1 @@
-"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-filters"), exports);
+export * from './job-filters';

package/dist/schemas/job-filters/job-filters.js

@@ -1,87 +1,84 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.jobFiltersSchema = exports.requiredJSSEnum = exports.requiredEarningsEnum = exports.regionEnum = exports.experienceLevelEnum = exports.englishLevelEnum = exports.talentTypeEnum = exports.clientSizeEnum = exports.clientIndustryEnum = exports.categoryEnum = exports.paymentTypeEnum = exports.vendorTypeEnum = exports.engagementTypeEnum = exports.projectDurationEnum = void 0;
-const zod_1 = require("zod");
-const job_filter_options_1 = require("../../constants/job-filter-options");
+import { z } from "zod";
+import { JOB_FILTER_OPTIONS } from "../../constants/job-filter-options";
 // Enum definitions for fixed options
-exports.projectDurationEnum = zod_1.z.enum(job_filter_options_1.JOB_FILTER_OPTIONS.PROJECT_DURATION);
-exports.engagementTypeEnum = zod_1.z.enum(job_filter_options_1.JOB_FILTER_OPTIONS.ENGAGEMENT_TYPE);
-exports.vendorTypeEnum = zod_1.z.enum(job_filter_options_1.JOB_FILTER_OPTIONS.VENDOR_TYPE);
-exports.paymentTypeEnum = zod_1.z.enum(job_filter_options_1.JOB_FILTER_OPTIONS.PAYMENT_TYPE);
-exports.categoryEnum = zod_1.z.enum(job_filter_options_1.JOB_FILTER_OPTIONS.CATEGORIES);
-exports.clientIndustryEnum = zod_1.z.enum(job_filter_options_1.JOB_FILTER_OPTIONS.CLIENT_INDUSTRY);
-exports.clientSizeEnum = zod_1.z.enum(job_filter_options_1.JOB_FILTER_OPTIONS.CLIENT_SIZE);
-exports.talentTypeEnum = zod_1.z.enum(job_filter_options_1.JOB_FILTER_OPTIONS.TALENT_TYPE);
-exports.englishLevelEnum = zod_1.z.enum(job_filter_options_1.JOB_FILTER_OPTIONS.ENGLISH_LEVELS);
-exports.experienceLevelEnum = zod_1.z.enum(job_filter_options_1.JOB_FILTER_OPTIONS.EXPERIENCE_LEVELS);
-exports.regionEnum = zod_1.z.enum(["all", "Worldwide", "UKOnly", "USOnly"]);
-exports.requiredEarningsEnum = zod_1.z.union([
-    zod_1.z.literal(100),
-    zod_1.z.literal(1000),
-    zod_1.z.literal(10000),
+export const projectDurationEnum = z.enum(JOB_FILTER_OPTIONS.PROJECT_DURATION);
+export const engagementTypeEnum = z.enum(JOB_FILTER_OPTIONS.ENGAGEMENT_TYPE);
+export const vendorTypeEnum = z.enum(JOB_FILTER_OPTIONS.VENDOR_TYPE);
+export const paymentTypeEnum = z.enum(JOB_FILTER_OPTIONS.PAYMENT_TYPE);
+export const categoryEnum = z.enum(JOB_FILTER_OPTIONS.CATEGORIES);
+export const clientIndustryEnum = z.enum(JOB_FILTER_OPTIONS.CLIENT_INDUSTRY);
+export const clientSizeEnum = z.enum(JOB_FILTER_OPTIONS.CLIENT_SIZE);
+export const talentTypeEnum = z.enum(JOB_FILTER_OPTIONS.TALENT_TYPE);
+export const englishLevelEnum = z.enum(JOB_FILTER_OPTIONS.ENGLISH_LEVELS);
+export const experienceLevelEnum = z.enum(JOB_FILTER_OPTIONS.EXPERIENCE_LEVELS);
+export const regionEnum = z.enum(["all", "Worldwide", "UKOnly", "USOnly"]);
+export const requiredEarningsEnum = z.union([
+    z.literal(100),
+    z.literal(1000),
+    z.literal(10000),
 ]);
-exports.requiredJSSEnum = zod_1.z.enum(job_filter_options_1.JOB_FILTER_OPTIONS.REQUIRED_JSS);
+export const requiredJSSEnum = z.enum(JOB_FILTER_OPTIONS.REQUIRED_JSS);
 // Main job filters schema
-exports.jobFiltersSchema = zod_1.z.object({
-    keywords: zod_1.z
+export const jobFiltersSchema = z.object({
+    keywords: z
         .object({
-        includes: zod_1.z.string().nullable(),
-        excludes: zod_1.z.string().nullable(),
+        includes: z.string().nullable(),
+        excludes: z.string().nullable(),
     })
         .nullable(),
-    isFeatured: zod_1.z.enum(["all", "true", "false"]).nullable(),
-    regions: zod_1.z.array(exports.regionEnum).nullable(),
-    categories: zod_1.z
+    isFeatured: z.enum(["all", "true", "false"]).nullable(),
+    regions: z.array(regionEnum).nullable(),
+    categories: z
         .object({
-        includes: zod_1.z.array(exports.categoryEnum).nullable(),
-        excludes: zod_1.z.array(exports.categoryEnum).nullable(),
+        includes: z.array(categoryEnum).nullable(),
+        excludes: z.array(categoryEnum).nullable(),
     })
         .nullable(),
-    payment: zod_1.z
+    payment: z
         .object({
-        paymentType: zod_1.z.array(exports.paymentTypeEnum).nullable(),
-        minFixedPrice: zod_1.z.number().nullable(),
-        maxFixedPrice: zod_1.z.number().nullable(),
-        minHourlyRate: zod_1.z.number().nullable(),
-        maxHourlyRate: zod_1.z.number().nullable(),
+        paymentType: z.array(paymentTypeEnum).nullable(),
+        minFixedPrice: z.number().nullable(),
+        maxFixedPrice: z.number().nullable(),
+        minHourlyRate: z.number().nullable(),
+        maxHourlyRate: z.number().nullable(),
     })
         .nullable(),
-    projectDuration: zod_1.z.array(exports.projectDurationEnum).nullable(),
-    experienceLevel: zod_1.z.array(exports.experienceLevelEnum).nullable(),
-    questions: zod_1.z
+    projectDuration: z.array(projectDurationEnum).nullable(),
+    experienceLevel: z.array(experienceLevelEnum).nullable(),
+    questions: z
         .object({
-        hasQuestions: zod_1.z.enum(["all", "yes", "no"]).default("all"),
+        hasQuestions: z.enum(["all", "yes", "no"]).default("all"),
     })
         .nullable(),
-    engagementType: zod_1.z.array(exports.engagementTypeEnum).nullable(),
-    clientInfo: zod_1.z
+    engagementType: z.array(engagementTypeEnum).nullable(),
+    clientInfo: z
         .object({
-        isPaymentVerified: zod_1.z.enum(["all", "true", "false"]).default("all"),
-        isPhoneVerified: zod_1.z.enum(["all", "true", "false"]).default("all"),
-        enterpriseClient: zod_1.z.enum(["all", "true", "false"]).default("all"),
-        clientLocationIncludes: zod_1.z.array(zod_1.z.string()).nullable(),
-        clientLocationExcludes: zod_1.z.array(zod_1.z.string()).nullable(),
-        minReviewScore: zod_1.z.number().min(0).max(5).nullable(),
-        minTotalSpent: zod_1.z.number().nullable(),
-        minHireRate: zod_1.z.number().min(0).max(100).nullable(),
-        clientIndustry: zod_1.z.array(exports.clientIndustryEnum).nullable(),
-        companySize: zod_1.z.array(exports.clientSizeEnum).nullable(),
-        minJobsPosted: zod_1.z.number().nullable(),
-        minAvgHourlyRate: zod_1.z.number().nullable(),
-        minNumReviews: zod_1.z.number().nullable(),
-        memberSinceFrom: zod_1.z.string().date().nullable(),
-        memberSinceTo: zod_1.z.string().date().nullable(),
+        isPaymentVerified: z.enum(["all", "true", "false"]).default("all"),
+        isPhoneVerified: z.enum(["all", "true", "false"]).default("all"),
+        enterpriseClient: z.enum(["all", "true", "false"]).default("all"),
+        clientLocationIncludes: z.array(z.string()).nullable(),
+        clientLocationExcludes: z.array(z.string()).nullable(),
+        minReviewScore: z.number().min(0).max(5).nullable(),
+        minTotalSpent: z.number().nullable(),
+        minHireRate: z.number().min(0).max(100).nullable(),
+        clientIndustry: z.array(clientIndustryEnum).nullable(),
+        companySize: z.array(clientSizeEnum).nullable(),
+        minJobsPosted: z.number().nullable(),
+        minAvgHourlyRate: z.number().nullable(),
+        minNumReviews: z.number().nullable(),
+        memberSinceFrom: z.string().date().nullable(),
+        memberSinceTo: z.string().date().nullable(),
     })
         .nullable(),
-    vendorQualifications: zod_1.z
+    vendorQualifications: z
         .object({
-        locationIncludes: zod_1.z.array(zod_1.z.string()).nullable(),
-        locationExcludes: zod_1.z.array(zod_1.z.string()).nullable(),
-        talentTypes: zod_1.z.array(exports.talentTypeEnum).nullable(),
-        englishLevels: zod_1.z.array(exports.englishLevelEnum).nullable(),
-        includeRisingTalent: zod_1.z.string().nullable(),
-        requiredEarnings: exports.requiredEarningsEnum.nullable(),
-        requiredJSS: zod_1.z.array(exports.requiredJSSEnum).nullable(),
+        locationIncludes: z.array(z.string()).nullable(),
+        locationExcludes: z.array(z.string()).nullable(),
+        talentTypes: z.array(talentTypeEnum).nullable(),
+        englishLevels: z.array(englishLevelEnum).nullable(),
+        includeRisingTalent: z.string().nullable(),
+        requiredEarnings: requiredEarningsEnum.nullable(),
+        requiredJSS: z.array(requiredJSSEnum).nullable(),
     })
         .nullable(),
 });

package/dist/schemas/lead/index.js

@@ -1,19 +1,173 @@
-"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("./lead"), exports);
-__exportStar(require("./lead-note"), exports);
-__exportStar(require("./lead-status"), exports);
+import { array, boolean, custom, number, object, record, string, z } from "zod";
+import { regionSchema } from "../shared";
+import { leadNoteSchema } from "./lead-note";
+import { agentStatusSchema, leadStatusSchema } from "./lead-status";
+export const jobSkillsSchema = object({
+    name: string(),
+});
+export const vendorQualificationSchema = object({
+    location: string().nullable(),
+    talentType: z.enum(["Agency", "Independent", "unspecified"]).nullable(),
+    englishLevel: string().nullable(),
+    minimumEarnings: number().nullable(),
+    jobSuccessScore: string().nullable(),
+    includeRisingTalent: string().nullable(),
+});
+export const clientInfoSchema = object({
+    isPaymentVerified: boolean().nullable(),
+    isPhoneVerified: boolean().nullable(),
+    numberOfReviews: number().nullable(),
+    rating: number().nullable(),
+    country: string().nullable(),
+    region: string().nullable(),
+    jobsPosted: number().nullable(),
+    totalSpent: number().nullable(),
+    numberOfHires: number().nullable(),
+    activeEngagements: number().nullable(),
+    openJobs: number().nullable(),
+    hireRate: number().nullable(),
+    memberSince: string().nullable(),
+    companyIndustry: string().nullable(),
+    companySize: string().nullable(),
+    enterpriseClient: boolean().nullable(),
+    avgHourlyRatePaid: number().nullable(),
+});
+export const clientReviewSchema = object({
+    jobTitle: string().nullable(),
+    freelancerName: string().nullable(),
+    freelancerRating: number().nullable(),
+    freelancerFeedback: string().nullable(),
+    clientFeedback: string().nullable(),
+    clientFeedbackRating: number().nullable(),
+    dateRange: string().nullable(),
+    paymentType: string().nullable(),
+    fixedPrice: number().nullable(),
+    hourlyRate: number().nullable(),
+    numHours: number().nullable(),
+    totalBilled: number().nullable(),
+});
+export const bidRangeSchema = object({
+    high: number().nullable(),
+    avg: number().nullable(),
+    low: number().nullable(),
+});
+export const jobActivitySchema = object({
+    proposals: object({
+        min: number().nullable(),
+        max: number().nullable(),
+    }),
+    lastViewedByClient: string().nullable(),
+    lastViewedByClientTimestamp: number().nullable(),
+    hires: number().nullable(),
+    interviewing: number().nullable(),
+    invitesSent: number().nullable(),
+    unansweredInvites: number().nullable(),
+    updatedAt: number().nullable(),
+});
+export const jobActivityDeltaSchema = object({
+    proposals: number(),
+    interviewing: number(),
+    hires: number(),
+    invitesSent: number(),
+    unansweredInvites: number(),
+});
+export const metadataSchema = object({
+    hours: string().nullable(),
+    duration: string().nullable(),
+    experienceLevel: string().nullable(),
+    hourlyRate: z
+        .object({
+        min: number().nullable(),
+        max: number().nullable(),
+    })
+        .nullable(),
+    paymentType: string().nullable(),
+    fixedPrice: number().nullable(),
+});
+export const jobActivityOffsetHours = [4, 24];
+export const jobActivityOffsetEnum = z.enum(jobActivityOffsetHours.map((h) => `${h}h`));
+export const upworkJobSchema = object({
+    id: string().nullable(),
+    uid: string().nullable(),
+    createdAt: number().nullable(),
+    title: string().nullable(),
+    category: string().nullable(),
+    skills: array(jobSkillsSchema).nullable(),
+    datetime: number().nullable(),
+    description: string().nullable(),
+    descriptionLength: number().nullable(),
+    connectsRequired: number().nullable(),
+    projectType: string().nullable(),
+    projectDuration: string().nullable(),
+    questions: array(string()).nullable(),
+    jobUrl: string().nullable(),
+    metadata: metadataSchema.nullable(),
+    clientInfo: clientInfoSchema.nullable(),
+    vendorQualifications: vendorQualificationSchema.nullable(),
+    processed: boolean().nullable(),
+    isFeatured: boolean().nullable(),
+    clientReviews: array(clientReviewSchema).nullable(),
+    region: regionSchema.nullable(),
+    bidRange: bidRangeSchema.nullable(),
+    jobActivity: jobActivitySchema.nullable(),
+    activityUpdates: z
+        .union([z.literal(1), z.literal(2), z.literal(3)])
+        .nullable(),
+    activity: record(jobActivityOffsetEnum, jobActivitySchema).nullish(),
+    activityDelta: jobActivityDeltaSchema.nullish(),
+});
+export const questionAnswerPairSchema = z.object({
+    question: z.string(),
+    answer: z.string(),
+});
+export const leadSchema = upworkJobSchema
+    .extend({
+    jobId: string(),
+    updatedAt: number().nullable(),
+    suitabilityRating: number().nullable(),
+    suitabilityReason: string().nullable(),
+    proposal: string().nullable(),
+    questionAnswerPairs: array(questionAnswerPairSchema).nullable(),
+    agentStatus: agentStatusSchema.nullable(),
+    leadStatus: leadStatusSchema.nullable(),
+    notes: array(leadNoteSchema).nullable(),
+    biddingAmount: number().nullable(),
+    boosted: boolean().nullable(),
+    boostingAmount: number().nullable(),
+    biddingTaskScheduled: boolean().nullable(),
+    scheduledBiddingTime: number().nullable(),
+})
+    .omit({
+    processed: true,
+});
+export const leadResponseSchema = object({
+    leads: array(leadSchema),
+    nextCursor: string().nullable(),
+    hasMore: boolean(),
+    leadCounts: number().nullable(),
+});
+export const jobListingSchema = object({
+    uid: string().nullable(),
+    title: string().nullable(),
+    jobUrl: string().nullable(),
+    datetime: string().nullable(),
+    isFeatured: boolean().nullable(),
+    region: regionSchema.nullable(),
+});
+export const jobActivityOffsetHourSchema = custom((val) => jobActivityOffsetHours.includes(val));
+export const jobActivityUpdateSchema = object({
+    jobUrl: string(),
+    data: jobActivitySchema,
+    offsetHour: jobActivityOffsetHourSchema,
+    scrapedAt: number(),
+});
+export const jobActivitySnapshotSchema = object({
+    jobUrl: string(),
+    activity: jobActivitySchema,
+    postedAt: number(),
+    scrapedAt: number(),
+    hoursSincePosted: number(),
+});
+export * from "./lead-note";
+export * from "./lead-status";
+export * from "./nuxt";

package/dist/schemas/lead/lead-note.js

@@ -1,23 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateLeadNotesOrderSchema = exports.updateLeadNoteSchema = exports.createLeadNoteSchema = exports.leadNoteSchema = void 0;
-const zod_1 = require("zod");
-exports.leadNoteSchema = zod_1.z.object({
-    id: zod_1.z.string(),
-    jobId: zod_1.z.string(),
-    content: zod_1.z.string(),
-    order: zod_1.z.number(),
-    bgColor: zod_1.z.string(),
-    createdAt: zod_1.z.number(),
-    updatedAt: zod_1.z.number(),
+import { z } from "zod";
+export const leadNoteSchema = z.object({
+    id: z.string(),
+    jobId: z.string(),
+    content: z.string(),
+    order: z.number(),
+    bgColor: z.string(),
+    createdAt: z.number(),
+    updatedAt: z.number(),
 });
-exports.createLeadNoteSchema = exports.leadNoteSchema.pick({
+export const createLeadNoteSchema = leadNoteSchema.pick({
     id: true,
     content: true,
     order: true,
     bgColor: true,
 });
-exports.updateLeadNoteSchema = exports.leadNoteSchema
+export const updateLeadNoteSchema = leadNoteSchema
     .pick({
     id: true,
     content: true,
@@ -25,6 +22,6 @@ exports.updateLeadNoteSchema = exports.leadNoteSchema
     bgColor: true,
 })
     .partial({ content: true, order: true, bgColor: true });
-exports.updateLeadNotesOrderSchema = zod_1.z.object({
-    order: zod_1.z.array(zod_1.z.object({ id: zod_1.z.string(), order: zod_1.z.number() })),
+export const updateLeadNotesOrderSchema = z.object({
+    order: z.array(z.object({ id: z.string(), order: z.number() })),
 });

package/dist/schemas/lead/lead-status.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.leadStatusSchema = exports.agentStatusSchema = void 0;
-const zod_1 = require("zod");
-exports.agentStatusSchema = zod_1.z.enum([
+import { z } from "zod";
+export const agentStatusSchema = z.enum([
     "suitabilityPending",
     "suitabilityProcessing",
     "suitabilityComplete",
@@ -15,7 +12,7 @@ exports.agentStatusSchema = zod_1.z.enum([
     "biddingFailed",
     "jobArchived",
 ]);
-exports.leadStatusSchema = zod_1.z.enum([
+export const leadStatusSchema = z.enum([
     "leads",
     "contacted",
     "viewed",