lancer-shared 1.2.19 → 1.2.20

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

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export const agentStatusSchema = z.enum([
+    "suitabilityPending",
+    "suitabilityProcessing",
+    "suitabilityComplete",
+    "suitabilityFailed",
+    "proposalProcessing",
+    "proposalComplete",
+    "proposalFailed",
+    "biddingProcessing",
+    "biddingComplete",
+    "biddingFailed",
+    "jobArchived",
+]);
+export const leadStatusSchema = z.enum([
+    "leads",
+    "contacted",
+    "viewed",
+    "replied",
+    "negotiations",
+    "won",
+    "lost",
+]);

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

@@ -0,0 +1 @@
+export * from "./log-event";

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

@@ -0,0 +1,117 @@
+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',
+    'jobScrapeFailed',
+    'jobsIndexed',
+    'jobDuplicateSkipped',
+    'scraperFailed',
+    'jobActivityScraped',
+    'jobActivityScrapeFailed',
+    // Feed Scraper Events
+    'feedScrapeStarted',
+    'feedScrapeCompleted',
+    'feedScrapeFailed',
+    'jobListingScraped',
+    // Job Sync & Campaign Matching
+    'jobSyncPublished',
+    'jobSyncReceived',
+    'leadsCreatedAndSynced',
+    // Suitability Events
+    'suitabilityPending',
+    'suitabilityProcessing',
+    'suitabilityComplete',
+    'suitabilityFailed',
+    'manualSuitabilityAnalyzed',
+    // Proposal Events
+    'proposalProcessing',
+    'proposalComplete',
+    'proposalFailed',
+    'manualProposalGenerated',
+    // Bidding Events
+    'biddingProcessing',
+    'biddingComplete',
+    'biddingFailed',
+    'biddingSkipped',
+    'biddingPending',
+    'biddingRetry',
+    'biddingInsufficientConnects',
+    'biddingWarningAlert',
+    // System/Generic Events
+    'errorLogged',
+    'cloudTaskRetry',
+    'manualLeadEdited',
+    'leadArchived',
+    'auditTrailLogged',
+    // Knowledge Base Events
+    'knowledgeBaseGenerationComplete',
+    'knowledgeBaseGenerationFailed',
+    // Model Chain Events
+    'modelFailed',
+]);
+export const logEventSchema = z.object({
+    // The type of event (use a z.enum if possible)
+    type: LogEventTypeEnum, // e.g. "suitability-failed", "proposal-generated"
+    // The service that triggered the event
+    source: z.string(), // e.g. "lancer-agents", "lancer-bidding"
+    // Optional: Allow logging non-lead events in the future
+    resourceType: z.string().default('lead'), // e.g. "lead", "campaign", "user"
+    // ID of the resource (primary entity affected)
+    resourceId: z.string().nullable(), // fallback if leadId is not applicable
+    // Lead-level metadata
+    leadId: z.string().nullable(),
+    campaignId: z.string().nullable(),
+    userId: z.string().nullable(),
+    // Reason or message for the event
+    reason: z.string().nullable(),
+    // Generic metadata (stacktrace, score, raw request, etc.)
+    metadata: z.record(z.unknown()).nullable(),
+    // Optional timestamp override
+    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/organization/index.d.ts

@@ -37,6 +37,7 @@ export declare const organizationSchema: z.ZodObject<{
     tierId: z.ZodEnum<["free", "premium"]>;
     subscription: z.ZodNullable<z.ZodObject<{
         planId: z.ZodString;
+        pendingPlanId: z.ZodNullable<z.ZodString>;
         status: z.ZodEnum<["active", "trialing", "cancelled", "paused", "payment_pending", "payment_failed"]>;
         startedAt: z.ZodNumber;
         currentPeriodEnd: z.ZodNumber;
@@ -62,6 +63,16 @@ export declare const organizationSchema: z.ZodObject<{
                     id: string;
                 };
             }>, "many">;
+            invoice: z.ZodObject<{
+                id: z.ZodString;
+                hosted_invoice_url: z.ZodNullable<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                id: string;
+                hosted_invoice_url: string | null;
+            }, {
+                id: string;
+                hosted_invoice_url: string | null;
+            }>;
         }, "strip", z.ZodTypeAny, {
             id: string;
             items: {
@@ -70,6 +81,10 @@ export declare const organizationSchema: z.ZodObject<{
                     id: string;
                 };
             }[];
+            invoice: {
+                id: string;
+                hosted_invoice_url: string | null;
+            };
         }, {
             id: string;
             items: {
@@ -78,11 +93,16 @@ export declare const organizationSchema: z.ZodObject<{
                     id: string;
                 };
             }[];
+            invoice: {
+                id: string;
+                hosted_invoice_url: string | null;
+            };
         }>;
         source: z.ZodEnum<["stripe", "manual"]>;
     }, "strip", z.ZodTypeAny, {
         status: "active" | "trialing" | "cancelled" | "paused" | "payment_pending" | "payment_failed";
         planId: string;
+        pendingPlanId: string | null;
         startedAt: number;
         currentPeriodEnd: number;
         stripe: {
@@ -93,11 +113,16 @@ export declare const organizationSchema: z.ZodObject<{
                     id: string;
                 };
             }[];
+            invoice: {
+                id: string;
+                hosted_invoice_url: string | null;
+            };
         };
         source: "stripe" | "manual";
     }, {
         status: "active" | "trialing" | "cancelled" | "paused" | "payment_pending" | "payment_failed";
         planId: string;
+        pendingPlanId: string | null;
         startedAt: number;
         currentPeriodEnd: number;
         stripe: {
@@ -108,6 +133,10 @@ export declare const organizationSchema: z.ZodObject<{
                     id: string;
                 };
             }[];
+            invoice: {
+                id: string;
+                hosted_invoice_url: string | null;
+            };
         };
         source: "stripe" | "manual";
     }>>;
@@ -186,6 +215,7 @@ export declare const organizationSchema: z.ZodObject<{
     subscription: {
         status: "active" | "trialing" | "cancelled" | "paused" | "payment_pending" | "payment_failed";
         planId: string;
+        pendingPlanId: string | null;
         startedAt: number;
         currentPeriodEnd: number;
         stripe: {
@@ -196,6 +226,10 @@ export declare const organizationSchema: z.ZodObject<{
                     id: string;
                 };
             }[];
+            invoice: {
+                id: string;
+                hosted_invoice_url: string | null;
+            };
         };
         source: "stripe" | "manual";
     } | null;
@@ -229,6 +263,7 @@ export declare const organizationSchema: z.ZodObject<{
     subscription: {
         status: "active" | "trialing" | "cancelled" | "paused" | "payment_pending" | "payment_failed";
         planId: string;
+        pendingPlanId: string | null;
         startedAt: number;
         currentPeriodEnd: number;
         stripe: {
@@ -239,6 +274,10 @@ export declare const organizationSchema: z.ZodObject<{
                     id: string;
                 };
             }[];
+            invoice: {
+                id: string;
+                hosted_invoice_url: string | null;
+            };
         };
         source: "stripe" | "manual";
     } | null;
@@ -271,6 +310,7 @@ export declare const createOrganizationSchema: z.ZodObject<Pick<{
     tierId: z.ZodEnum<["free", "premium"]>;
     subscription: z.ZodNullable<z.ZodObject<{
         planId: z.ZodString;
+        pendingPlanId: z.ZodNullable<z.ZodString>;
         status: z.ZodEnum<["active", "trialing", "cancelled", "paused", "payment_pending", "payment_failed"]>;
         startedAt: z.ZodNumber;
         currentPeriodEnd: z.ZodNumber;
@@ -296,6 +336,16 @@ export declare const createOrganizationSchema: z.ZodObject<Pick<{
                     id: string;
                 };
             }>, "many">;
+            invoice: z.ZodObject<{
+                id: z.ZodString;
+                hosted_invoice_url: z.ZodNullable<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                id: string;
+                hosted_invoice_url: string | null;
+            }, {
+                id: string;
+                hosted_invoice_url: string | null;
+            }>;
         }, "strip", z.ZodTypeAny, {
             id: string;
             items: {
@@ -304,6 +354,10 @@ export declare const createOrganizationSchema: z.ZodObject<Pick<{
                     id: string;
                 };
             }[];
+            invoice: {
+                id: string;
+                hosted_invoice_url: string | null;
+            };
         }, {
             id: string;
             items: {
@@ -312,11 +366,16 @@ export declare const createOrganizationSchema: z.ZodObject<Pick<{
                     id: string;
                 };
             }[];
+            invoice: {
+                id: string;
+                hosted_invoice_url: string | null;
+            };
         }>;
         source: z.ZodEnum<["stripe", "manual"]>;
     }, "strip", z.ZodTypeAny, {
         status: "active" | "trialing" | "cancelled" | "paused" | "payment_pending" | "payment_failed";
         planId: string;
+        pendingPlanId: string | null;
         startedAt: number;
         currentPeriodEnd: number;
         stripe: {
@@ -327,11 +386,16 @@ export declare const createOrganizationSchema: z.ZodObject<Pick<{
                     id: string;
                 };
             }[];
+            invoice: {
+                id: string;
+                hosted_invoice_url: string | null;
+            };
         };
         source: "stripe" | "manual";
     }, {
         status: "active" | "trialing" | "cancelled" | "paused" | "payment_pending" | "payment_failed";
         planId: string;
+        pendingPlanId: string | null;
         startedAt: number;
         currentPeriodEnd: number;
         stripe: {
@@ -342,6 +406,10 @@ export declare const createOrganizationSchema: z.ZodObject<Pick<{
                     id: string;
                 };
             }[];
+            invoice: {
+                id: string;
+                hosted_invoice_url: string | null;
+            };
         };
         source: "stripe" | "manual";
     }>>;
@@ -527,7 +595,6 @@ export declare const subscribePayloadSchema: z.ZodObject<{
     paymentMethodId: string;
 }>;
 export interface Organization extends infer<typeof organizationSchema> {
-    planName?: string;
 }
 export type TrackUsageEventType = z.infer<typeof trackUsageEventTypeEnum>;
 export interface TrackUsagePayloadSchema extends infer<typeof trackUsagePayloadSchema> {

package/dist/schemas/organization/index.js

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