lancer-shared 1.2.35 → 1.2.37

package/dist/schemas/lead/nuxt.js

@@ -0,0 +1,287 @@
+import { any, array, boolean, number, object, record, string } from "zod";
+const segmentationDataSchema = object({
+    customValue: string().nullable(),
+    label: string(),
+    name: string(),
+    sortOrder: number(),
+    type: string(),
+    value: string(),
+    skill: any().nullable(),
+});
+const clientActivitySchema = object({
+    lastBuyerActivity: string(),
+    totalApplicants: number(),
+    totalHired: number(),
+    totalInvitedToInterview: number(),
+    unansweredInvites: number(),
+    invitationsSent: number(),
+    numberOfPositionsToHire: number(),
+});
+const annotationsSchema = object({
+    tags: array(string()),
+});
+const budgetSchema = object({
+    amount: number(),
+    currencyCode: string(),
+});
+const engagementDurationSchema = object({
+    label: string(),
+    weeks: number(),
+});
+const extendedBudgetInfoSchema = object({
+    hourlyBudgetMin: number().nullable(),
+    hourlyBudgetMax: number().nullable(),
+    hourlyBudgetType: string().nullable(),
+});
+const qualificationsSchema = object({
+    countries: any().nullable(),
+    earnings: any().nullable(),
+    groupRecno: any().nullable(),
+    languages: any().nullable(),
+    localDescription: any().nullable(),
+    localFlexibilityDescription: any().nullable(),
+    localMarket: boolean(),
+    minJobSuccessScore: number(),
+    minOdeskHours: number(),
+    onSiteType: any().nullable(),
+    prefEnglishSkill: number(),
+    regions: any().nullable(),
+    risingTalent: boolean(),
+    shouldHavePortfolio: boolean(),
+    states: any().nullable(),
+    tests: any().nullable(),
+    timezones: any().nullable(),
+    type: number(),
+    locationCheckRequired: boolean(),
+    group: any().nullable(),
+    location: any().nullable(),
+    locations: any().nullable(),
+});
+const jobSchema = object({
+    status: number(),
+    category: object({
+        name: string(),
+        urlSlug: string(),
+    }),
+    categoryGroup: object({
+        name: string(),
+        urlSlug: string(),
+    }),
+    budget: budgetSchema,
+    postedOn: string(),
+    publishTime: string(),
+    wasRenewed: boolean(),
+    startDate: string().nullable(),
+    deliveryDate: string().nullable(),
+    workload: string().nullable(),
+    engagementDuration: engagementDurationSchema,
+    extendedBudgetInfo: extendedBudgetInfoSchema,
+    contractorTier: number(),
+    description: string(),
+    segmentationData: array(segmentationDataSchema),
+    clientActivity: clientActivitySchema,
+    annotations: annotationsSchema,
+    uid: string(),
+    title: string(),
+    type: number(),
+    ciphertext: string(),
+    access: number(),
+    createdOn: string(),
+    hideBudget: boolean(),
+    notSureProjectDuration: boolean(),
+    notSureFreelancersToHire: boolean(),
+    notSureExperienceLevel: boolean(),
+    numberOfPositionsToHire: number(),
+    isContractToHire: boolean(),
+    attachments: array(any()),
+    isPremium: boolean(),
+    qualifications: qualificationsSchema,
+    questions: array(object({ question: string(), position: number() })),
+    durationIdV3: number(),
+    durationLabel: string(),
+});
+const buyerSchema = object({
+    isEnterprise: boolean(),
+    isPaymentMethodVerified: boolean(),
+    stats: object({
+        totalAssignments: number(),
+        activeAssignmentsCount: number(),
+        hoursCount: number(),
+        feedbackCount: number(),
+        score: number(),
+        totalJobsWithHires: number(),
+        totalCharges: object({
+            amount: number(),
+        }),
+    }),
+    location: object({
+        offsetFromUtcMillis: number(),
+        countryTimezone: string(),
+        city: string(),
+        country: string(),
+    }),
+    company: object({
+        isEDCReplicated: any().nullable(),
+        contractDate: string(),
+        profile: object({
+            industry: string(),
+            size: number(),
+        }),
+        name: string().nullable(),
+    }),
+    jobs: object({
+        postedCount: number(),
+        openCount: number(),
+    }),
+    avgHourlyJobsRate: object({
+        amount: number(),
+    }).nullable(),
+});
+const currentUserInfoSchema = object({
+    owner: boolean(),
+    freelancerInfo: object({
+        profileState: string(),
+        applied: any().nullable(),
+        devProfileCiphertext: string(),
+        hired: any().nullable(),
+        application: record(any()),
+        pendingInvite: record(any()),
+        contract: any().nullable(),
+        hourlyRate: object({
+            amount: number(),
+        }),
+        qualificationsMatches: object({
+            matches: array(object({
+                clientPreferred: string(),
+                clientPreferredLabel: string().nullable(),
+                freelancerValue: string(),
+                freelancerValueLabel: string(),
+                qualification: number(),
+                qualified: boolean(),
+            })),
+        }),
+    }),
+});
+const workHistorySchema = array(object({
+    isPtcJob: any().nullable(),
+    status: any().nullable(),
+    isEDCReplicated: any().nullable(),
+    startDate: string(),
+    endDate: string(),
+    totalCharge: number(),
+    totalHours: number(),
+    jobInfo: object({
+        title: string(),
+        id: any().nullable(),
+        uid: any().nullable(),
+        access: number(),
+        type: number(),
+        ciphertext: any().nullable(),
+    }),
+    contractorInfo: object({
+        contractorName: string(),
+        accessType: string(),
+        ciphertext: string(),
+    }),
+    rate: object({
+        amount: number(),
+    }).nullable(),
+    feedback: object({
+        feedbackSuppressed: boolean(),
+        score: number(),
+        comment: string(),
+        feedback_suppressed: boolean(),
+    }),
+    feedbackToClient: object({
+        feedbackSuppressed: boolean(),
+        score: number(),
+        comment: string(),
+        feedback_suppressed: boolean(),
+    }),
+    isEDCPublic: boolean(),
+}));
+const sandsSchema = object({
+    occupation: object({
+        freeText: string().nullable(),
+        ontologyId: string(),
+        prefLabel: string(),
+        id: string(),
+        uid: string(),
+    }),
+    ontologySkills: array(any()),
+    additionalSkills: array(object({
+        uid: string(),
+        name: string(),
+        isFreeText: boolean(),
+    })),
+});
+const connectsSchema = object({
+    pricing: object({
+        price: number(),
+        context: string(),
+        auctionPrice: number(),
+    }),
+    requiredConnects: number(),
+    availableConnects: number(),
+    chooseConnectsStatus: object({
+        isExplainerModalShown: boolean().nullable(),
+    }),
+    canSeeApplicantsRates: boolean(),
+});
+const authSchema = object({
+    canFlagOpening: boolean(),
+    canPostJob: boolean(),
+    domestic: object({
+        country: string().nullable(),
+        isInfographicTooltipAvailable: boolean(),
+    }),
+});
+const applicationContextSchema = object({
+    freelancerAllowed: boolean(),
+    clientAllowed: boolean(),
+    userIntentEvaluation: object({
+        isDeclined: boolean(),
+        reason: string().nullable(),
+    }),
+    canApplyOnBehalfOfAgencyFreelancers: boolean(),
+    canSubmitMoreProposals: boolean(),
+    submittedProposals: any().nullable(),
+});
+export const nuxtStateJobSchema = object({
+    cache: boolean(),
+    job: jobSchema,
+    buyer: buyerSchema,
+    currentUserInfo: currentUserInfoSchema,
+    isVisitor: boolean(),
+    openJobs: array(any()),
+    workHistory: workHistorySchema,
+    similarJobs: array(any()),
+    sands: sandsSchema,
+    auth: authSchema,
+    applicants: object({
+        applicantsBidsStats: any().nullable(),
+    }),
+    connects: connectsSchema.nullish(),
+    enterpriseJobAdditionalInfo: record(any()),
+    applicationContext: applicationContextSchema,
+    profileMatchServiceUid: string(),
+    seo: object({
+        title: string(),
+        description: string(),
+        url: string(),
+    }),
+    teamUid: any().nullable(),
+    proposalPermissions: object({
+        freelancerAllowed: boolean(),
+        clientAllowed: boolean(),
+    }),
+    jobSlug: any().nullable(),
+    prefillWith: any().nullable(),
+    isGroupOpportunity: boolean(),
+    workLocation: any().nullable(),
+    isPhoneVerified: boolean(),
+    errorResponse: any().nullable(),
+    isApplyBlocked: boolean(),
+    hasAiInterview: boolean(),
+    talentFeePromotion: boolean().nullish(),
+});

package/dist/schemas/logger/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("./log-event"), exports);
+export * from "./log-event";

package/dist/schemas/logger/log-event.js

@@ -1,66 +1,117 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logEventSchema = exports.LogEventTypeEnum = void 0;
-const zod_1 = require("zod");
-exports.LogEventTypeEnum = zod_1.z.enum([
+import { boolean, number, object, string, z } from 'zod';
+import { jobActivityOffsetHourSchema, jobActivitySchema, jobListingSchema, } from '../lead';
+import { regionSchema } from '../shared';
+export const LogEventTypeEnum = z.enum([
     // Scraper Events
-    "scraperStarted",
-    "scraperCompleted",
-    "jobScraped",
-    "jobsIndexed",
-    "jobDuplicateSkipped",
-    "scraperFailed",
-    "userProfileScrapingStarted",
-    "userProfileScrapingComplete",
-    "userProfileScrapingFailed",
+    'scraperStarted',
+    'scraperCompleted',
+    'jobScraped',
+    'jobScrapeFailed',
+    'jobsIndexed',
+    'jobDuplicateSkipped',
+    'scraperFailed',
+    'jobActivityScraped',
+    'jobActivityScrapeFailed',
+    // Feed Scraper Events
+    'feedScrapeStarted',
+    'feedScrapeCompleted',
+    'feedScrapeFailed',
+    'jobListingScraped',
     // Job Sync & Campaign Matching
-    "jobSyncPublished",
-    "jobSyncReceived",
-    "leadsCreatedAndSynced",
+    'jobSyncPublished',
+    'jobSyncReceived',
+    'leadsCreatedAndSynced',
     // Suitability Events
-    "suitabilityPending",
-    "suitabilityProcessing",
-    "suitabilityComplete",
-    "suitabilityFailed",
-    "manualSuitabilityAnalyzed",
+    'suitabilityPending',
+    'suitabilityProcessing',
+    'suitabilityComplete',
+    'suitabilityFailed',
+    'manualSuitabilityAnalyzed',
     // Proposal Events
-    "proposalProcessing",
-    "proposalComplete",
-    "proposalFailed",
-    "manualProposalGenerated",
+    'proposalProcessing',
+    'proposalComplete',
+    'proposalFailed',
+    'manualProposalGenerated',
     // Bidding Events
-    "biddingProcessing",
-    "biddingComplete",
-    "biddingFailed",
-    "biddingSkipped",
-    "biddingPending",
+    'biddingProcessing',
+    'biddingComplete',
+    'biddingFailed',
+    'biddingSkipped',
+    'biddingPending',
+    'biddingRetry',
+    'biddingInsufficientConnects',
+    'biddingWarningAlert',
     // System/Generic Events
-    "errorLogged",
-    "cloudTaskRetry",
-    "manualLeadEdited",
-    "leadArchived",
-    "auditTrailLogged",
+    'errorLogged',
+    'cloudTaskRetry',
+    'manualLeadEdited',
+    'leadArchived',
+    'auditTrailLogged',
     // Knowledge Base Events
-    "knowledgeBaseGenerationComplete",
-    "knowledgeBaseGenerationFailed",
+    'knowledgeBaseGenerationComplete',
+    'knowledgeBaseGenerationFailed',
+    // Model Chain Events
+    'modelFailed',
 ]);
-exports.logEventSchema = zod_1.z.object({
+export const logEventSchema = z.object({
     // The type of event (use a z.enum if possible)
-    type: exports.LogEventTypeEnum, // e.g. "suitability-failed", "proposal-generated"
+    type: LogEventTypeEnum, // e.g. "suitability-failed", "proposal-generated"
     // The service that triggered the event
-    source: zod_1.z.string(), // e.g. "lancer-agents", "lancer-bidding"
+    source: z.string(), // e.g. "lancer-agents", "lancer-bidding"
     // Optional: Allow logging non-lead events in the future
-    resourceType: zod_1.z.string().default("lead"), // e.g. "lead", "campaign", "user"
+    resourceType: z.string().default('lead'), // e.g. "lead", "campaign", "user"
     // ID of the resource (primary entity affected)
-    resourceId: zod_1.z.string().nullable(), // fallback if leadId is not applicable
+    resourceId: z.string().nullable(), // fallback if leadId is not applicable
     // Lead-level metadata
-    leadId: zod_1.z.string().nullable(),
-    campaignId: zod_1.z.string().nullable(),
-    userId: zod_1.z.string().nullable(),
+    leadId: z.string().nullable(),
+    campaignId: z.string().nullable(),
+    userId: z.string().nullable(),
     // Reason or message for the event
-    reason: zod_1.z.string().nullable(),
+    reason: z.string().nullable(),
     // Generic metadata (stacktrace, score, raw request, etc.)
-    metadata: zod_1.z.record(zod_1.z.unknown()).nullable(),
+    metadata: z.record(z.unknown()).nullable(),
     // Optional timestamp override
-    timestamp: zod_1.z.number(),
+    timestamp: z.number(),
+});
+export const listingScrapedEventMetadata = object({
+    listing: jobListingSchema,
+    region: regionSchema,
+});
+export const jobActivityScrapedEventMetadata = object({
+    activity: jobActivitySchema,
+    region: regionSchema,
+    offsetHour: jobActivityOffsetHourSchema,
+    scrapedAt: number(),
+});
+export const jobActivityScrapeFailedEventMetadata = object({
+    listing: jobListingSchema,
+    region: regionSchema,
+    offsetHour: jobActivityOffsetHourSchema,
+});
+export const feedScrapeStartedEventMetadata = object({
+    id: string(),
+    startTime: number(),
+    region: regionSchema,
+});
+export const feedScrapeCompletedEventMetadata = object({
+    id: string(),
+    endTime: number(),
+    region: regionSchema,
+    accountUsername: string(),
+});
+export const biddingCompletedEventMetadata = object({
+    biddingAmount: number(),
+    boosted: boolean(),
+    boostingAmount: number(),
+});
+export const biddingFailedEventMetadata = object({
+    errorType: string(),
+    errorMessage: string(),
+    context: z.string().optional(),
+});
+export const biddingWarningAlertEventMetadata = object({
+    warningMessage: string(),
+});
+export const biddingRetryEventMetadata = object({
+    errorMessage: string(),
 });

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

@@ -0,0 +1,12 @@
+export declare const usageEventSchema: import("zod").ZodObject<{
+    organizationId: import("zod").ZodString;
+    eventId: any;
+}, "strip", import("zod").ZodTypeAny, {
+    [x: string]: any;
+    organizationId?: unknown;
+    eventId?: unknown;
+}, {
+    [x: string]: any;
+    organizationId?: unknown;
+    eventId?: unknown;
+}>;

package/dist/schemas/organization/cover-letter.d.ts

@@ -1,33 +1,37 @@
 import { z } from "zod";
-export declare const coverLetterSchema: z.ZodObject<{
+export declare const coverLetterTemplateSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
-    coverLetterExample: z.ZodString;
-    coverLetterRules: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    template: z.ZodString;
+    instructions: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     id: string;
     name: string;
-    coverLetterExample: string;
-    coverLetterRules: string;
+    description: string | null;
+    template: string;
+    instructions: string;
 }, {
     id: string;
     name: string;
-    coverLetterExample: string;
-    coverLetterRules: string;
+    description: string | null;
+    template: string;
+    instructions: string;
 }>;
-export declare const createCoverLetterSchema: z.ZodObject<Pick<{
+export declare const createCoverLetterTemplateSchema: z.ZodObject<Pick<{
     id: z.ZodString;
     name: z.ZodString;
-    coverLetterExample: z.ZodString;
-    coverLetterRules: z.ZodString;
-}, "name" | "coverLetterExample" | "coverLetterRules">, "strip", z.ZodTypeAny, {
+    description: z.ZodNullable<z.ZodString>;
+    template: z.ZodString;
+    instructions: z.ZodString;
+}, "name" | "template" | "instructions">, "strip", z.ZodTypeAny, {
     name: string;
-    coverLetterExample: string;
-    coverLetterRules: string;
+    template: string;
+    instructions: string;
 }, {
     name: string;
-    coverLetterExample: string;
-    coverLetterRules: string;
+    template: string;
+    instructions: string;
 }>;
-export type CoverLetter = z.infer<typeof coverLetterSchema>;
-export type CreateCoverLetter = z.infer<typeof createCoverLetterSchema>;
+export type CoverLetterTemplate = z.infer<typeof coverLetterTemplateSchema>;
+export type CreateCoverLetterTemplate = z.infer<typeof createCoverLetterTemplateSchema>;

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

@@ -1,5 +1,6 @@
 import { infer, z } from "zod";
-import { CoverLetter } from "./cover-letter";
+import { OnboardingProgress } from "./onboarding";
+import { CoverLetterTemplate } from "./cover-letter";
 export declare const organizationTypeSchema: z.ZodEnum<["agency", "freelancer"]>;
 export declare const organizationTierEnum: z.ZodEnum<["free", "premium"]>;
 export declare const limitsSchema: z.ZodObject<{
@@ -673,9 +674,10 @@ export declare const subscribePayloadSchema: z.ZodObject<{
     toltReferral?: string | undefined;
 }>;
 export interface Organization extends infer<typeof organizationSchema> {
-    coverLetterTemplates: CoverLetter[] | null;
+    coverLetterTemplates: CoverLetterTemplate[] | null;
     settings: OrganizationSettings | null;
     profile: OrganizationProfile | null;
+    onboarding: OnboardingProgress | null;
 }
 export interface TrackUsagePayloadSchema extends infer<typeof trackUsagePayloadSchema> {
 }

package/dist/schemas/organization/index.js

@@ -1,17 +1,70 @@
-"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("./organization"), exports);
+import { boolean, number, object, string, z } from "zod";
+import { LogEventTypeEnum } from "../logger";
+import { organizationSubscriptionSchema } from "./subscription";
+export const bidConfigSchema = object({
+    agencyName: string().nullable(),
+    bidderId: string().nullable(),
+    contractorName: string().nullable(),
+    specialisedProfile: string().nullable(),
+});
+export const organizationTypeSchema = z.enum(["agency", "freelancer"]);
+export const organizationTierEnum = z.enum(["free", "premium"]);
+export const organizationLimitsSchema = object({
+    monthlyCredits: number(),
+    usedCredits: number(),
+    extraCredits: number(),
+});
+export const organizationBillingSchema = object({
+    stripeCustomerId: string(),
+    savedCard: boolean(),
+    creditsRemaining: number(),
+});
+export const organizationSchema = object({
+    id: string(),
+    name: string(),
+    type: organizationTypeSchema,
+    tierId: organizationTierEnum,
+    subscription: organizationSubscriptionSchema.nullable(),
+    bidConfig: bidConfigSchema,
+    active: boolean(),
+    limits: organizationLimitsSchema,
+    billing: organizationBillingSchema.nullable(),
+    createdAt: number(),
+    updatedAt: number(),
+});
+export const creditDeductionEventTypeEnum = LogEventTypeEnum.extract([
+    "suitabilityComplete",
+    "proposalComplete",
+]);
+export const creditDeductionPayloadSchema = object({
+    event: creditDeductionEventTypeEnum,
+    campaignId: string().nullish(),
+});
+export const aiConfigOldSchema = object({
+    id: string(),
+    suitabilityPrompt: string().nullable(),
+    proposalPrompt: string().nullable(),
+    questionProposalPrompt: string().nullable(),
+    knowledgeBase: string().nullable(),
+});
+export const aiConfigSchema = object({
+    suitabilityRules: string().nullable(),
+    coverLetterRules: string().nullable(),
+    questionRules: string().nullable(),
+});
+export const knowledgeBaseSchema = object({
+    about: string(),
+    caseStudies: string(),
+});
+export const notificationConfigSchema = object({
+    emailEnabled: boolean(),
+    discordWebhookUrl: string().nullable(),
+    slackWebhookUrl: string().nullable(),
+});
+export const organizationSettingsSchema = object({
+    aiConfig: aiConfigSchema,
+    knowledgeBase: knowledgeBaseSchema,
+    notifications: notificationConfigSchema,
+});
+export * from "./member";
+export * from "./subscription";

package/dist/schemas/organization/member.js

@@ -0,0 +1,7 @@
+import { number, object, string, z } from "zod";
+export const organizationMemberRoleEnum = z.enum(["admin", "member"]);
+export const organizationMemberSchema = object({
+    role: organizationMemberRoleEnum,
+    joinedAt: number(),
+    invitedBy: string(),
+});