lancer-shared 1.2.189 → 1.2.191

package/dist/bundle.cjs.js

@@ -13073,7 +13073,30 @@ const biddingHourlyRateStrategyEnum = z.enum([
     'match_profile_rate',
     'fixed_rate',
 ]);
+const weekDaysEnum = z.enum([
+    'monday',
+    'tuesday',
+    'wednesday',
+    'thursday',
+    'friday',
+    'saturday',
+    'sunday',
+]);
 const bidWithWarningEnum = z.enum(['bid', 'skip']);
+const timeBlockSchema = z.object({
+    fromHour: z.number().min(0).max(23),
+    toHour: z.number().min(0).max(23),
+});
+const workTimeSchema = z.object({
+    enabled: z.boolean(),
+    days: z.array(weekDaysEnum),
+    timeBlocks: z.array(timeBlockSchema),
+    timezone: z.string().nullable(),
+});
+const insufficeintBoostConnectsActionEnum = z.enum([
+    'skip',
+    'bid_without_boost',
+]);
 const campaignSchema = z.object({
     id: z.string(),
     name: z.string(),
@@ -13084,6 +13107,9 @@ const campaignSchema = z.object({
     // automatedSuitability: z.boolean().nullable(),
     boostingEnabled: z.boolean().nullable().default(false),
     maximumBoost: z.number().nullable().default(30),
+    boostDownToNthPlace: z.number().min(1).max(4).nullable(),
+    connectsAbovePrevious: z.number().min(1).nullable(),
+    insufficeintBoostConnectsAction: insufficeintBoostConnectsActionEnum,
     // minimumBoost: z.number().nullable().default(0),
     monthlyBudget: z.number().nullable(),
     // suitabilityThreshold: z.number().min(0).max(100).nullable().default(0),
@@ -13093,10 +13119,6 @@ const campaignSchema = z.object({
     biddingFixedHourlyRate: z.number().nullable(),
     biddingHourlyRatePercentage: z.number().min(0).max(100).nullable(),
     bidWithWarning: bidWithWarningEnum,
-    sleepEnabled: z.boolean().nullable().default(false),
-    sleepStartAtHour: z.number().nullable().default(23),
-    sleepEndAtHour: z.number().nullable().default(7),
-    sleepTimezone: z.string().nullable(),
     leadCounts: z.record(leadStatusEnum, z.number()).nullable(),
     expenses: campaignExpensesSchema,
     notificationsEnabled: z.boolean().nullable(),
@@ -13112,6 +13134,7 @@ const campaignSchema = z.object({
         enabled: z.boolean(),
         windowAnchorAt: z.number().nullable(),
     }),
+    workTime: workTimeSchema,
 });
 const upworkAccountConnectStatusSchema = z.union([
     z.literal('processing'),
@@ -13284,6 +13307,7 @@ const campaignNotificationType = z.enum([
     'noConnects',
     'accountDisconnected',
     'biddingWarning',
+    'boostAboveMaxConnects',
 ]);
 const chatbotChannelSchema = z.object({
     id: z.string(),
@@ -13339,6 +13363,7 @@ const CAMPAIGN_NOTIFICATION_TYPES = {
     noConnects: 'No Connects',
     accountDisconnected: 'Account Disconnected',
     biddingWarning: 'Bidding Warning',
+    boostAboveMaxConnects: 'Boost Above Max Connects',
 };
 const CAMPAIGN_NOTIFICATION_SETTINGS = {
     suitableLead: 'When Lancer determines a job is suitable for your company',
@@ -13348,6 +13373,7 @@ const CAMPAIGN_NOTIFICATION_SETTINGS = {
     noConnects: 'When your Agency profile has run out of Upwork connects',
     accountDisconnected: 'When there is an issue with your Upwork Bidder account',
     biddingWarning: 'When there is a bidding warning',
+    boostAboveMaxConnects: 'When there is a boost above max connects',
 };
 
 const campaignCountByStatusSchema = z.object({
@@ -13390,13 +13416,144 @@ const boostFormSchema = z.object({
 const nodeEnums = z.enum([
     'clientAvgHourlyRateNode',
     'bidNode',
-    'suitabilityNode',
     'clientHireRateNode',
     'clientSizeNode',
     'boostNode',
     'clientSpentNode',
+    'clientRatingNode',
+    'startNode',
+    'budgetNode',
+    'paymentTypeNode',
 ]);
 
+const rangesOverlap$5 = (range1, range2) => {
+    return range1.min < range2.max && range2.min < range1.max;
+};
+// Payment type options (excluding 'Unspecified')
+const budgetPaymentTypeEnum = z.enum(['Hourly', 'Fixed-price']);
+const createBudgetFormSchema = (existingHourlyRateRanges, existingFixedBudgetRanges) => z
+    .object({
+    paymentTypes: z
+        .array(budgetPaymentTypeEnum)
+        .min(1, 'Please select at least one payment type'),
+    hourlyRateMin: z
+        .number()
+        .min(0, 'Minimum hourly rate must be non-negative')
+        .optional(),
+    hourlyRateMax: z
+        .number()
+        .min(0, 'Maximum hourly rate must be non-negative')
+        .optional(),
+    fixedBudgetMin: z
+        .number()
+        .min(0, 'Minimum fixed budget must be non-negative')
+        .optional(),
+    fixedBudgetMax: z
+        .number()
+        .min(0, 'Maximum fixed budget must be non-negative')
+        .optional(),
+    action: nodeEnums,
+})
+    // Validate hourly rate fields are provided when Hourly is selected
+    .refine((data) => {
+    if (data.paymentTypes.includes('Hourly')) {
+        return (data.hourlyRateMin !== undefined && data.hourlyRateMax !== undefined);
+    }
+    return true;
+}, {
+    message: 'Hourly rate min and max are required when Hourly payment type is selected',
+    path: ['hourlyRateMin'],
+})
+    // Validate fixed budget fields are provided when Fixed-price is selected
+    .refine((data) => {
+    if (data.paymentTypes.includes('Fixed-price')) {
+        return (data.fixedBudgetMin !== undefined &&
+            data.fixedBudgetMax !== undefined);
+    }
+    return true;
+}, {
+    message: 'Fixed budget min and max are required when Fixed-price payment type is selected',
+    path: ['fixedBudgetMin'],
+})
+    // Validate hourly rate range when provided AND hourly payment type is selected
+    .refine((data) => {
+    if (data.paymentTypes.includes('Hourly') &&
+        data.hourlyRateMin !== undefined &&
+        data.hourlyRateMax !== undefined) {
+        return data.hourlyRateMin < data.hourlyRateMax;
+    }
+    return true;
+}, {
+    message: 'Minimum hourly rate must be less than maximum',
+    path: ['hourlyRateMin'],
+})
+    .refine((data) => {
+    if (data.paymentTypes.includes('Hourly') &&
+        data.hourlyRateMin !== undefined &&
+        data.hourlyRateMax !== undefined) {
+        return data.hourlyRateMax > data.hourlyRateMin;
+    }
+    return true;
+}, {
+    message: 'Maximum hourly rate must be greater than minimum',
+    path: ['hourlyRateMax'],
+})
+    // Validate fixed budget range when provided AND fixed payment type is selected
+    .refine((data) => {
+    if (data.paymentTypes.includes('Fixed-price') &&
+        data.fixedBudgetMin !== undefined &&
+        data.fixedBudgetMax !== undefined) {
+        return data.fixedBudgetMin < data.fixedBudgetMax;
+    }
+    return true;
+}, {
+    message: 'Minimum fixed budget must be less than maximum',
+    path: ['fixedBudgetMin'],
+})
+    .refine((data) => {
+    if (data.paymentTypes.includes('Fixed-price') &&
+        data.fixedBudgetMin !== undefined &&
+        data.fixedBudgetMax !== undefined) {
+        return data.fixedBudgetMax > data.fixedBudgetMin;
+    }
+    return true;
+}, {
+    message: 'Maximum fixed budget must be greater than minimum',
+    path: ['fixedBudgetMax'],
+})
+    // Check for hourly rate range overlaps when provided
+    .refine((data) => {
+    if (data.hourlyRateMin !== undefined &&
+        data.hourlyRateMax !== undefined) {
+        const newHourlyRateRange = {
+            min: data.hourlyRateMin,
+            max: data.hourlyRateMax,
+        };
+        return !existingHourlyRateRanges.some((existingRange) => rangesOverlap$5(newHourlyRateRange, existingRange));
+    }
+    return true;
+}, {
+    message: 'Hourly rate range overlaps with existing hourly rate range',
+    path: ['hourlyRateMin'],
+})
+    // Check for fixed budget range overlaps when provided
+    .refine((data) => {
+    if (data.fixedBudgetMin !== undefined &&
+        data.fixedBudgetMax !== undefined) {
+        const newFixedBudgetRange = {
+            min: data.fixedBudgetMin,
+            max: data.fixedBudgetMax,
+        };
+        return !existingFixedBudgetRanges.some((existingRange) => rangesOverlap$5(newFixedBudgetRange, existingRange));
+    }
+    return true;
+}, {
+    message: 'Fixed budget range overlaps with existing fixed budget range',
+    path: ['fixedBudgetMin'],
+});
+// Default schema for backwards compatibility
+const addBudgetNodeFormSchema = createBudgetFormSchema([], []);
+
 const sizeOverlap = (size1, size2) => {
     if (size1 === size2) {
         return true;
@@ -13418,7 +13575,7 @@ const createClientSizeFormSchema = (existingSizes) => z
 const addFromClientSizeNodeFormSchema = createClientSizeFormSchema([]);
 
 const INFINITY = 99999999999;
-const rangesOverlap$3 = (range1, range2) => {
+const rangesOverlap$4 = (range1, range2) => {
     return range1.from < range2.to && range2.from < range1.to;
 };
 const createClientSpentFormSchema = (existingRanges) => z
@@ -13437,14 +13594,14 @@ const createClientSpentFormSchema = (existingRanges) => z
 })
     .refine((data) => {
     const newRange = { from: data.from, to: data.to };
-    return !existingRanges.some((existingRange) => rangesOverlap$3(newRange, existingRange));
+    return !existingRanges.some((existingRange) => rangesOverlap$4(newRange, existingRange));
 }, {
     message: 'Range overlaps with existing range',
     path: ['from'],
 });
 const addFromClientSpentNodeFormSchema = createClientSpentFormSchema([]);
 
-const rangesOverlap$2 = (range1, range2) => {
+const rangesOverlap$3 = (range1, range2) => {
     return range1.from < range2.to && range2.from < range1.to;
 };
 const createClientHireRateFormSchema = (existingRanges) => z
@@ -13463,14 +13620,14 @@ const createClientHireRateFormSchema = (existingRanges) => z
 })
     .refine((data) => {
     const newRange = { from: data.from, to: data.to };
-    return !existingRanges.some((existingRange) => rangesOverlap$2(newRange, existingRange));
+    return !existingRanges.some((existingRange) => rangesOverlap$3(newRange, existingRange));
 }, {
     message: 'Range overlaps with existing range',
     path: ['from'],
 });
 const addFromClientHireRateNodeFormSchema = createClientHireRateFormSchema([]);
 
-const rangesOverlap$1 = (range1, range2) => {
+const rangesOverlap$2 = (range1, range2) => {
     return range1.from < range2.to && range2.from < range1.to;
 };
 const createHourlyRateFormSchema = (existingRanges) => z
@@ -13489,7 +13646,7 @@ const createHourlyRateFormSchema = (existingRanges) => z
 })
     .refine((data) => {
     const newRange = { from: data.from, to: data.to };
-    return !existingRanges.some((existingRange) => rangesOverlap$1(newRange, existingRange));
+    return !existingRanges.some((existingRange) => rangesOverlap$2(newRange, existingRange));
 }, {
     message: 'Range overlaps with existing range',
     path: ['from'],
@@ -13497,6 +13654,57 @@ const createHourlyRateFormSchema = (existingRanges) => z
 // Keep the original schema for backwards compatibility if needed
 const addFromHourlyRateNodeFormSchema = createHourlyRateFormSchema([]);
 
+const limitedPaymentTypeEnum = paymentTypeEnum.exclude(['Unspecified']);
+const paymentTypeOverlap = (paymentType1, paymentType2) => {
+    if (paymentType1 === paymentType2) {
+        return true;
+    }
+    return false;
+};
+const createPaymentTypeFormSchema = (existingPaymentTypes) => z
+    .object({
+    paymentTypes: z.array(limitedPaymentTypeEnum).min(1),
+    action: nodeEnums,
+})
+    .refine((data) => {
+    const newPaymentTypes = data.paymentTypes;
+    return !existingPaymentTypes.some((existingPaymentType) => newPaymentTypes.some((newPaymentType) => paymentTypeOverlap(newPaymentType, existingPaymentType)));
+}, {
+    message: 'Payment type overlaps with existing payment type',
+    path: ['paymentTypes'],
+});
+const addFromPaymentTypeNodeFormSchema = createPaymentTypeFormSchema([]);
+
+const rangesOverlap$1 = (range1, range2) => {
+    return range1.from < range2.to && range2.from < range1.to;
+};
+const createClientRatingFormSchema = (existingRanges) => z
+    .object({
+    from: z.number().min(0).max(5),
+    to: z.number().min(0).max(5),
+    action: nodeEnums,
+})
+    .refine((data) => data.from < data.to, {
+    message: 'From must be less than To',
+    path: ['from'],
+})
+    .refine((data) => data.to > data.from, {
+    message: 'To must be greater than From',
+    path: ['to'],
+})
+    .refine((data) => {
+    const newRange = { from: data.from, to: data.to };
+    return !existingRanges.some((existingRange) => rangesOverlap$1(newRange, existingRange));
+}, {
+    message: 'Range overlaps with existing range',
+    path: ['from'],
+});
+const addFromClientRatingNodeFormSchema = createClientRatingFormSchema([]);
+
+const addFromStartNodeFormSchema = z.object({
+    action: nodeEnums,
+});
+
 const rangesOverlap = (range1, range2) => {
     return range1.from < range2.to && range2.from < range1.to;
 };
@@ -13532,6 +13740,9 @@ const bidPayloadProposalDataSchema = z.object({
     boostingEnabled: z.boolean(),
     specialisedProfileOptions: z.array(z.string()),
     maximumBoost: z.number().nullable(),
+    boostDownToNthPlace: z.number().min(1).max(4).nullable(),
+    connectsAbovePrevious: z.number().min(1).nullable(),
+    insufficeintBoostConnectsAction: insufficeintBoostConnectsActionEnum,
     biddingHourlyRateStrategy: biddingHourlyRateStrategyEnum,
     biddingHourlyRatePercentage: z.number().min(0).max(100).nullable(),
     biddingFixedHourlyRate: z.number().nullable(),
@@ -13577,6 +13788,14 @@ const bidFailedSchema = z.object({
     errorMessage: z.string(),
 });
 
+class BoostAboveMaxConnectsException extends Error {
+    code = 'BOOST_ABOVE_MAX_CONNECTS_EXCEPTION';
+    constructor(message) {
+        super(message);
+    }
+}
+const boostAboveMaxConnectsException = (message) => new BoostAboveMaxConnectsException(message);
+
 class CloudflareChallengeFailedException extends Error {
     code = 'CLOUDFLARE_CHALLENGE_FAILED_EXCEPTION';
     constructor(url, errorMessage) {
@@ -23209,32 +23428,43 @@ const convertToUtc = (sleepTimezone, sleepStartAtHour, sleepEndAtHour) => {
     if (endHour <= startHour) {
         localEndDt = localEndDt.plus({ days: 1 });
     }
+    if (!localStartDt.isValid || !localEndDt.isValid) {
+        throw new Error('Invalid timezone conversion');
+    }
     return {
-        sleepStartAt: localStartDt.toUTC().toISO(),
-        sleepEndAt: localEndDt.toUTC().toISO(),
+        from: localStartDt.toUTC().toISO(),
+        to: localEndDt.toUTC().toISO(),
     };
 };
-const isSleepTime = (sleepTimezone, sleepStartAtHour, sleepEndAtHour) => {
-    const { sleepStartAt, sleepEndAt } = convertToUtc(sleepTimezone, sleepStartAtHour, sleepEndAtHour);
-    const now = DateTime.now().toUTC();
-    if (!sleepStartAt || !sleepEndAt) {
+const isWorkTime = (workTimezone, workTimeBlocks, workDays) => {
+    const nowInWorkTz = DateTime.now().setZone(workTimezone);
+    const getDayName = (weekday) => {
+        const days = [
+            'monday',
+            'tuesday',
+            'wednesday',
+            'thursday',
+            'friday',
+            'saturday',
+            'sunday',
+        ];
+        return days[weekday - 1];
+    };
+    const currentDay = getDayName(nowInWorkTz.weekday);
+    if (!workDays.includes(currentDay)) {
         return false;
     }
-    const startHour = Number(sleepStartAtHour);
-    const endHour = Number(sleepEndAtHour);
-    const sleepStart = DateTime.fromISO(sleepStartAt);
-    const sleepEnd = DateTime.fromISO(sleepEndAt);
-    if (endHour <= startHour) {
-        // Cross-midnight period: sleep from late evening to early morning
-        // We're in sleep time if:
-        // 1. Current time >= start time, OR
-        // 2. Current time <= end time AND we're on the same day as the end time
-        return (now >= sleepStart || (now <= sleepEnd && now.hasSame(sleepEnd, 'day')));
-    }
-    else {
-        // Same-day period: sleep from morning to evening
-        return now >= sleepStart && now <= sleepEnd;
-    }
+    const currentHour = nowInWorkTz.hour;
+    return workTimeBlocks.some((block) => {
+        if (block.toHour <= block.fromHour) {
+            // Cross-midnight period (e.g., 22:00 to 06:00)
+            return currentHour >= block.fromHour || currentHour < block.toHour;
+        }
+        else {
+            // Same-day period (e.g., 09:00 to 18:00)
+            return currentHour >= block.fromHour && currentHour < block.toHour;
+        }
+    });
 };
 
 // Main wrapper function
@@ -23249,6 +23479,7 @@ async function tryCatch(promise) {
 }
 
 exports.BidderAccountAlreadyConnectedException = BidderAccountAlreadyConnectedException;
+exports.BoostAboveMaxConnectsException = BoostAboveMaxConnectsException;
 exports.CAMPAIGN_NOTIFICATION_SETTINGS = CAMPAIGN_NOTIFICATION_SETTINGS;
 exports.CAMPAIGN_NOTIFICATION_TYPES = CAMPAIGN_NOTIFICATION_TYPES;
 exports.CloudflareChallengeFailedException = CloudflareChallengeFailedException;
@@ -23306,10 +23537,14 @@ exports.acceptUpworkInvitationSchema = acceptUpworkInvitationSchema;
 exports.accountStatusDisplayMap = accountStatusDisplayMap;
 exports.accountStatusOrder = accountStatusOrder;
 exports.accountStatusSchema = accountStatusSchema;
+exports.addBudgetNodeFormSchema = addBudgetNodeFormSchema;
 exports.addFromClientHireRateNodeFormSchema = addFromClientHireRateNodeFormSchema;
+exports.addFromClientRatingNodeFormSchema = addFromClientRatingNodeFormSchema;
 exports.addFromClientSizeNodeFormSchema = addFromClientSizeNodeFormSchema;
 exports.addFromClientSpentNodeFormSchema = addFromClientSpentNodeFormSchema;
 exports.addFromHourlyRateNodeFormSchema = addFromHourlyRateNodeFormSchema;
+exports.addFromPaymentTypeNodeFormSchema = addFromPaymentTypeNodeFormSchema;
+exports.addFromStartNodeFormSchema = addFromStartNodeFormSchema;
 exports.addFromSuitabilityNodeFormSchema = addFromSuitabilityNodeFormSchema;
 exports.agencyBidPayloadSchema = agencyBidPayloadSchema;
 exports.agencyBidProposalDataSchema = agencyBidProposalDataSchema;
@@ -23342,7 +23577,9 @@ exports.biddingFailedEventMetadata = biddingFailedEventMetadata;
 exports.biddingHourlyRateStrategyEnum = biddingHourlyRateStrategyEnum;
 exports.biddingRejectedWithFeedbackEventMetadata = biddingRejectedWithFeedbackEventMetadata;
 exports.booleanSchema = booleanSchema;
+exports.boostAboveMaxConnectsException = boostAboveMaxConnectsException;
 exports.boostFormSchema = boostFormSchema;
+exports.budgetPaymentTypeEnum = budgetPaymentTypeEnum;
 exports.buildRoute = buildRoute;
 exports.campaignAIMetricsSchema = campaignAIMetricsSchema;
 exports.campaignActivityCreateSchema = campaignActivityCreateSchema;
@@ -23375,15 +23612,18 @@ exports.convertToUtc = convertToUtc;
 exports.countryMapping = countryMapping;
 exports.coverLetterTemplateSchema = coverLetterTemplateSchema;
 exports.createBidderAccountSchema = createBidderAccountSchema;
+exports.createBudgetFormSchema = createBudgetFormSchema;
 exports.createCampaignSchema = createCampaignSchema;
 exports.createChatbotSchema = createChatbotSchema;
 exports.createClientHireRateFormSchema = createClientHireRateFormSchema;
+exports.createClientRatingFormSchema = createClientRatingFormSchema;
 exports.createClientSizeFormSchema = createClientSizeFormSchema;
 exports.createClientSpentFormSchema = createClientSpentFormSchema;
 exports.createCoverLetterTemplateSchema = createCoverLetterTemplateSchema;
 exports.createHourlyRateFormSchema = createHourlyRateFormSchema;
 exports.createOrganizationProfileSchema = createOrganizationProfileSchema;
 exports.createOrganizationSchema = createOrganizationSchema;
+exports.createPaymentTypeFormSchema = createPaymentTypeFormSchema;
 exports.createScraperAccountSchema = createScraperAccountSchema;
 exports.createSuitabilityFormSchema = createSuitabilityFormSchema;
 exports.dailyUsageSchema = dailyUsageSchema;
@@ -23437,6 +23677,7 @@ exports.goToUrlException = goToUrlException;
 exports.hasQuestionsEnum = hasQuestionsEnum;
 exports.incorrectSecurityQuestionAnswerException = incorrectSecurityQuestionAnswerException;
 exports.initBrowserException = initBrowserException;
+exports.insufficeintBoostConnectsActionEnum = insufficeintBoostConnectsActionEnum;
 exports.insufficientConnectsException = insufficientConnectsException;
 exports.invalidCredentialsException = invalidCredentialsException;
 exports.invalidGoogleOAuthTokenSchema = invalidGoogleOAuthTokenSchema;
@@ -23450,7 +23691,7 @@ exports.invoiceStripeMetadataSchema = invoiceStripeMetadataSchema;
 exports.isNumeric = isNumeric;
 exports.isPaymentVerifiedEnum = isPaymentVerifiedEnum;
 exports.isPhoneVerifiedEnum = isPhoneVerifiedEnum;
-exports.isSleepTime = isSleepTime;
+exports.isWorkTime = isWorkTime;
 exports.jobActivityDeltaSchema = jobActivityDeltaSchema;
 exports.jobActivityOffsetEnum = jobActivityOffsetEnum;
 exports.jobActivityOffsetHourSchema = jobActivityOffsetHourSchema;
@@ -23474,6 +23715,7 @@ exports.leadSchema = leadSchema;
 exports.leadStatusActivitySchema = leadStatusActivitySchema;
 exports.leadStatusEnum = leadStatusEnum;
 exports.leadStatusEventMetadata = leadStatusEventMetadata;
+exports.limitedPaymentTypeEnum = limitedPaymentTypeEnum;
 exports.limitsSchema = limitsSchema;
 exports.logEventSchema = logEventSchema;
 exports.loginFailedException = loginFailedException;
@@ -23583,6 +23825,7 @@ exports.syncProposalsStatusRequestPayloadSchema = syncProposalsStatusRequestPayl
 exports.systemPromptSchema = systemPromptSchema;
 exports.systemSchema = systemSchema;
 exports.talentTypeEnum = talentTypeEnum;
+exports.timeBlockSchema = timeBlockSchema;
 exports.trackUsageEventTypeEnum = trackUsageEventTypeEnum;
 exports.trackUsagePayloadSchema = trackUsagePayloadSchema;
 exports.transactionSchema = transactionSchema;
@@ -23617,4 +23860,6 @@ exports.vendorTypeEnum = vendorTypeEnum;
 exports.verifyBidderAccountCredentialsResponseSchema = verifyBidderAccountCredentialsResponseSchema;
 exports.verifyBidderAccountCredentialsSchema = verifyBidderAccountCredentialsSchema;
 exports.waitForFunctionTimeoutError = waitForFunctionTimeoutError;
+exports.weekDaysEnum = weekDaysEnum;
+exports.workTimeSchema = workTimeSchema;
 //# sourceMappingURL=bundle.cjs.js.map