lancer-shared 1.2.1 → 1.2.3

package/dist/schemas/bid/bid.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+export const bidPayloadProposalDataSchema = z.object({
+    coverLetter: z.string(),
+    questionAnswerPairs: z
+        .array(z.object({
+        question: z.string(),
+        answer: z.string(),
+    }))
+        .nullable(),
+    boostingEnabled: z.boolean(),
+    minimumBoost: z.number().nullable(),
+    maximumBoost: z.number().nullable(),
+});
+export const freelancerBidProposalDataSchema = bidPayloadProposalDataSchema;
+export const agencyBidProposalDataSchema = bidPayloadProposalDataSchema.extend({
+    agencyName: z.string(),
+    contractorName: z.string(),
+    specializedProfile: z.string().nullable(),
+});
+export const bidPayloadSchema = z.object({
+    jobUrl: z.string(),
+    username: z.string(),
+    password: z.string(),
+});
+export const agencyBidPayloadSchema = bidPayloadSchema.extend({
+    proposalData: agencyBidProposalDataSchema,
+});
+export const freelancerBidPayloadSchema = bidPayloadSchema.extend({
+    proposalData: freelancerBidProposalDataSchema,
+});
+export const bidDtoSchema = z.object({
+    organizationId: z.string(),
+    campaignId: z.string(),
+    leadId: z.string(),
+});

package/dist/schemas/bid/index.js

@@ -0,0 +1,2 @@
+export * from './bid';
+export * from './bid-result';

package/dist/schemas/campaign/campaign-ai-metrics.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export const campaignAIMetricsSchema = z.object({
+    leadsAnalyzed: z.number(),
+    leadsBidded: z.number(),
+    connectsSaved: z.number(),
+});

package/dist/schemas/campaign/campaign-analytics.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { leadStatusSchema, upworkJobSchema } from "../lead";
+export const campaignAnalyticsStatsSchema = z.object({
+    jobsAnalyzed: z.number(),
+    totalStats: z.object({
+        contacted: z.number(),
+        viewed: z.number(),
+        replied: z.number(),
+        negotiations: z.number(),
+        won: z.number(),
+    }),
+    statsByDate: z.array(z.object({
+        label: z.string(),
+        contacted: z.number(),
+        viewed: z.number(),
+        replied: z.number(),
+        negotiations: z.number(),
+        won: z.number(),
+    })),
+});
+export const campaignAnalyticsResponseSchema = z.object({
+    jobsAnalyzed: z.number(),
+    contacted: z.number(),
+    viewed: z.number(),
+    replied: z.number(),
+    negotiations: z.number(),
+    won: z.number(),
+});
+export const campaignActivitySchema = z.object({
+    createdAt: z.number(),
+    status: leadStatusSchema,
+    job: upworkJobSchema.pick({
+        id: true,
+        title: true,
+        datetime: true,
+        jobUrl: true,
+    }),
+});
+export const campaignActivityCreateSchema = campaignActivitySchema.pick({
+    status: true,
+    job: true,
+});

package/dist/schemas/campaign/campaign-expenses.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export const campaignExpensesSchema = z.object({
+    biddingAmount: z.number().default(0),
+    boostingAmount: z.number().default(0),
+    boosted: z.number().default(0),
+});

package/dist/schemas/campaign/campaign-insights.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { agentStatusSchema } from "../lead";
+export const campaignCountByStatusSchema = z.object({
+    // Using z.enum values to create a schema with all possible job statuses
+    ...Object.fromEntries(Object.values(agentStatusSchema.enum).map((status) => [
+        status,
+        z.object({
+            boosted: z.number(),
+            organic: z.number(),
+            total: z.number(),
+        }),
+    ])),
+});
+export const campaignInsightsSchema = z.object({
+    pipelineHealth: campaignCountByStatusSchema,
+    biddingAmount: z.number().default(0),
+    boostingAmount: z.number().default(0),
+    boostedProposalsCount: z.number().default(0),
+    totalProposalsCount: z.number().default(0),
+    totalExpenses: z.number().default(0),
+    suitabilityRange0to10: z.number(),
+    suitabilityRange10to20: z.number(),
+    suitabilityRange20to30: z.number(),
+    suitabilityRange30to40: z.number(),
+    suitabilityRange40to50: z.number(),
+    suitabilityRange50to60: z.number(),
+    suitabilityRange60to70: z.number(),
+    suitabilityRange70to80: z.number(),
+    suitabilityRange80to90: z.number(),
+    suitabilityRange90to100: z.number(),
+});

package/dist/schemas/campaign/campaign-integrations.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export const campaignIntegrations = z.enum(["discord", "slack"]);
+export const campaignIntegrationsSchema = z.object({
+    suitabilityHooks: z.object({
+        discord: z.string().url().nullable(),
+        slack: z.string().url().nullable(),
+    }),
+    proposalSentHooks: z.object({
+        discord: z.string().url().nullable(),
+        slack: z.string().url().nullable(),
+    }),
+});
+export const updateCampaignIntegrationsSchema = campaignIntegrationsSchema.partial();

package/dist/schemas/campaign/campaign-job-count.js

@@ -0,0 +1,3 @@
+import { z } from "zod";
+import { leadStatusSchema } from "../lead";
+export const campaignJobCountSchema = z.record(leadStatusSchema, z.number());

package/dist/schemas/campaign/campaign.js

@@ -0,0 +1,41 @@
+import { number, z } from "zod";
+import { jobFiltersSchema } from "../job-filters";
+import { leadStatusSchema } from "../lead";
+import { campaignExpensesSchema } from "./campaign-expenses";
+import { campaignIntegrationsSchema } from "./campaign-integrations";
+export const campaignStatusSchema = z.union([
+    z.literal("active"),
+    z.literal("draft"),
+    z.literal("paused"),
+    z.literal("error"),
+]);
+export const campaignSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    filters: jobFiltersSchema,
+    createdAt: number(),
+    updatedAt: number(),
+    confirmedBillingAt: number().nullable(),
+    automatedSuitability: z.boolean().nullable(),
+    automatedBidding: z.boolean().nullable(),
+    boostingEnabled: z.boolean().nullable().default(false),
+    maximumBoost: z.number().nullable().default(30),
+    minimumBoost: z.number().nullable().default(0),
+    webhookUrl: z.string().nullable(),
+    monthlyBudget: z.number().nullable(),
+    suitabilityThreshold: z.number().min(0).max(100).nullable().default(0),
+    boostingThreshold: z.number().min(0).max(100).nullable().default(0),
+    leadCounts: z.record(leadStatusSchema, z.number()).nullable(),
+    expenses: campaignExpensesSchema,
+    integrations: campaignIntegrationsSchema,
+    status: campaignStatusSchema.optional(),
+});
+export const createCampaignSchema = campaignSchema.omit({
+    id: true,
+    createdAt: true,
+    updatedAt: true,
+});
+export const updateCampaignSchema = campaignSchema.omit({
+    createdAt: true,
+    updatedAt: true,
+});

package/dist/schemas/campaign/index.js

@@ -0,0 +1,7 @@
+export * from './campaign';
+export * from './campaign-insights';
+export * from './campaign-job-count';
+export * from './campaign-expenses';
+export * from './campaign-integrations';
+export * from './campaign-analytics';
+export * from './campaign-ai-metrics';

package/dist/schemas/chat-message/chat-message.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export const chatMessageSchema = z.object({
+    id: z.string(),
+    content: z.string(),
+    role: z.enum(['user', 'assistant']),
+    timestamp: z.string(),
+});
+export const newChatMessageSchema = chatMessageSchema.omit({
+    id: true,
+});

package/dist/schemas/chat-message/index.js

@@ -0,0 +1 @@
+export * from './chat-message';

package/dist/schemas/config/agency-config.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export const agencyConfigSchema = z.object({
+    agencyName: z.string(),
+    contractorName: z.string(),
+    specializedProfile: z.string().nullable(),
+    accountId: z.string(),
+});

package/dist/schemas/config/index.js

@@ -0,0 +1 @@
+export * from './agency-config';

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

@@ -0,0 +1,58 @@
+export declare const logEventSchemaWithMetadata: import("zod").ZodIntersection<import("zod").ZodIntersection<import("zod").ZodObject<{
+    type: import("zod").ZodEnum<["scraperStarted", "scraperCompleted", "jobScraped", "jobScrapeFailed", "jobsIndexed", "jobDuplicateSkipped", "scraperFailed", "jobActivityScraped", "jobActivityScrapeFailed", "feedScrapeStarted", "feedScrapeCompleted", "feedScrapeFailed", "jobListingScraped", "jobSyncPublished", "jobSyncReceived", "leadsCreatedAndSynced", "suitabilityPending", "suitabilityProcessing", "suitabilityComplete", "suitabilityFailed", "manualSuitabilityAnalyzed", "proposalProcessing", "proposalComplete", "proposalFailed", "manualProposalGenerated", "biddingProcessing", "biddingComplete", "biddingFailed", "biddingSkipped", "biddingPending", "errorLogged", "cloudTaskRetry", "manualLeadEdited", "leadArchived", "auditTrailLogged"]>;
+    source: import("zod").ZodString;
+    resourceType: import("zod").ZodDefault<import("zod").ZodString>;
+    resourceId: import("zod").ZodNullable<import("zod").ZodString>;
+    leadId: import("zod").ZodNullable<import("zod").ZodString>;
+    campaignId: import("zod").ZodNullable<import("zod").ZodString>;
+    userId: import("zod").ZodNullable<import("zod").ZodString>;
+    reason: import("zod").ZodNullable<import("zod").ZodString>;
+    timestamp: import("zod").ZodNumber;
+}, "strip", import("zod").ZodTypeAny, {
+    type: "scraperStarted" | "scraperCompleted" | "jobScraped" | "jobScrapeFailed" | "jobsIndexed" | "jobDuplicateSkipped" | "scraperFailed" | "jobActivityScraped" | "jobActivityScrapeFailed" | "feedScrapeStarted" | "feedScrapeCompleted" | "feedScrapeFailed" | "jobListingScraped" | "jobSyncPublished" | "jobSyncReceived" | "leadsCreatedAndSynced" | "suitabilityPending" | "suitabilityProcessing" | "suitabilityComplete" | "suitabilityFailed" | "manualSuitabilityAnalyzed" | "proposalProcessing" | "proposalComplete" | "proposalFailed" | "manualProposalGenerated" | "biddingProcessing" | "biddingComplete" | "biddingFailed" | "biddingSkipped" | "biddingPending" | "errorLogged" | "cloudTaskRetry" | "manualLeadEdited" | "leadArchived" | "auditTrailLogged";
+    source: string;
+    resourceType: string;
+    resourceId: string | null;
+    leadId: string | null;
+    campaignId: string | null;
+    userId: string | null;
+    reason: string | null;
+    timestamp: number;
+}, {
+    type: "scraperStarted" | "scraperCompleted" | "jobScraped" | "jobScrapeFailed" | "jobsIndexed" | "jobDuplicateSkipped" | "scraperFailed" | "jobActivityScraped" | "jobActivityScrapeFailed" | "feedScrapeStarted" | "feedScrapeCompleted" | "feedScrapeFailed" | "jobListingScraped" | "jobSyncPublished" | "jobSyncReceived" | "leadsCreatedAndSynced" | "suitabilityPending" | "suitabilityProcessing" | "suitabilityComplete" | "suitabilityFailed" | "manualSuitabilityAnalyzed" | "proposalProcessing" | "proposalComplete" | "proposalFailed" | "manualProposalGenerated" | "biddingProcessing" | "biddingComplete" | "biddingFailed" | "biddingSkipped" | "biddingPending" | "errorLogged" | "cloudTaskRetry" | "manualLeadEdited" | "leadArchived" | "auditTrailLogged";
+    source: string;
+    resourceId: string | null;
+    leadId: string | null;
+    campaignId: string | null;
+    userId: string | null;
+    reason: string | null;
+    timestamp: number;
+    resourceType?: string | undefined;
+}>, import("zod").ZodDiscriminatedUnion<"type", [import("zod").ZodObject<{
+    type: import("zod").ZodEnum<["jobActivityScraped"]>;
+}, "strip", import("zod").ZodTypeAny, {
+    type: "jobActivityScraped";
+}, {
+    type: "jobActivityScraped";
+}>, import("zod").ZodObject<{
+    type: import("zod").ZodEnum<["scraperStarted", "scraperCompleted", "jobScraped", "jobScrapeFailed", "jobsIndexed", "jobDuplicateSkipped", "scraperFailed", "jobActivityScrapeFailed", "feedScrapeStarted", "feedScrapeCompleted", "feedScrapeFailed", "jobListingScraped", "jobSyncPublished", "jobSyncReceived", "leadsCreatedAndSynced", "suitabilityPending", "suitabilityProcessing", "suitabilityComplete", "suitabilityFailed", "manualSuitabilityAnalyzed", "proposalProcessing", "proposalComplete", "proposalFailed", "manualProposalGenerated", "biddingProcessing", "biddingComplete", "biddingFailed", "biddingSkipped", "biddingPending", "errorLogged", "cloudTaskRetry", "manualLeadEdited", "leadArchived", "auditTrailLogged"]>;
+    metadata: import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+}, "strip", import("zod").ZodTypeAny, {
+    type: "scraperStarted" | "scraperCompleted" | "jobScraped" | "jobScrapeFailed" | "jobsIndexed" | "jobDuplicateSkipped" | "scraperFailed" | "jobActivityScrapeFailed" | "feedScrapeStarted" | "feedScrapeCompleted" | "feedScrapeFailed" | "jobListingScraped" | "jobSyncPublished" | "jobSyncReceived" | "leadsCreatedAndSynced" | "suitabilityPending" | "suitabilityProcessing" | "suitabilityComplete" | "suitabilityFailed" | "manualSuitabilityAnalyzed" | "proposalProcessing" | "proposalComplete" | "proposalFailed" | "manualProposalGenerated" | "biddingProcessing" | "biddingComplete" | "biddingFailed" | "biddingSkipped" | "biddingPending" | "errorLogged" | "cloudTaskRetry" | "manualLeadEdited" | "leadArchived" | "auditTrailLogged";
+    metadata: Record<string, unknown> | null;
+}, {
+    type: "scraperStarted" | "scraperCompleted" | "jobScraped" | "jobScrapeFailed" | "jobsIndexed" | "jobDuplicateSkipped" | "scraperFailed" | "jobActivityScrapeFailed" | "feedScrapeStarted" | "feedScrapeCompleted" | "feedScrapeFailed" | "jobListingScraped" | "jobSyncPublished" | "jobSyncReceived" | "leadsCreatedAndSynced" | "suitabilityPending" | "suitabilityProcessing" | "suitabilityComplete" | "suitabilityFailed" | "manualSuitabilityAnalyzed" | "proposalProcessing" | "proposalComplete" | "proposalFailed" | "manualProposalGenerated" | "biddingProcessing" | "biddingComplete" | "biddingFailed" | "biddingSkipped" | "biddingPending" | "errorLogged" | "cloudTaskRetry" | "manualLeadEdited" | "leadArchived" | "auditTrailLogged";
+    metadata: Record<string, unknown> | null;
+}>]>>, import("zod").ZodDiscriminatedUnion<"type", [import("zod").ZodObject<{
+    type: import("zod").ZodEnum<["jobActivityScraped"]>;
+}, "strip", import("zod").ZodTypeAny, {
+    type: "jobActivityScraped";
+}, {
+    type: "jobActivityScraped";
+}>, import("zod").ZodObject<{
+    type: import("zod").ZodEnum<["jobActivityScraped"]>;
+}, "strip", import("zod").ZodTypeAny, {
+    type: "jobActivityScraped";
+}, {
+    type: "jobActivityScraped";
+}>]>>;

package/dist/schemas/index.js

@@ -0,0 +1,17 @@
+export * from "./account";
+export * from "./bid";
+export * from "./campaign";
+export * from "./chat-message";
+export * from "./config";
+export * from "./job-filters";
+export * from "./lead";
+export * from "./logger";
+export * from "./organization";
+export * from "./proxy";
+export * from "./saved-search";
+export * from "./scraper";
+export * from "./shared";
+export * from "./time-filter";
+export * from "./user";
+export * from "./usage";
+export * from "./transaction";

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

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1 @@
+export * from './job-filters';

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

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { JOB_FILTER_OPTIONS } from "../../constants/job-filter-options";
+// Enum definitions for fixed options
+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),
+]);
+export const requiredJSSEnum = z.enum(JOB_FILTER_OPTIONS.REQUIRED_JSS);
+// Main job filters schema
+export const jobFiltersSchema = z.object({
+    keywords: z
+        .object({
+        includes: z.string().nullable(),
+        excludes: z.string().nullable(),
+    })
+        .nullable(),
+    isFeatured: z.enum(["all", "true", "false"]).nullable(),
+    regions: z.array(regionEnum).nullable(),
+    categories: z
+        .object({
+        includes: z.array(categoryEnum).nullable(),
+        excludes: z.array(categoryEnum).nullable(),
+    })
+        .nullable(),
+    payment: z
+        .object({
+        paymentType: z.array(paymentTypeEnum).nullable(),
+        minFixedPrice: z.number().nullable(),
+        maxFixedPrice: z.number().nullable(),
+        minHourlyRate: z.number().nullable(),
+        maxHourlyRate: z.number().nullable(),
+    })
+        .nullable(),
+    projectDuration: z.array(projectDurationEnum).nullable(),
+    experienceLevel: z.array(experienceLevelEnum).nullable(),
+    questions: z
+        .object({
+        hasQuestions: z.enum(["all", "yes", "no"]).default("all"),
+    })
+        .nullable(),
+    engagementType: z.array(engagementTypeEnum).nullable(),
+    clientInfo: z
+        .object({
+        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: z
+        .object({
+        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

@@ -0,0 +1,173 @@
+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";