lancer-shared 1.2.192 → 1.2.194

package/dist/bundle.cjs.js

@@ -11136,6 +11136,7 @@ const jobFiltersSchema = z.object({
         excludes: z.string().nullable(),
     })
         .nullable(),
+    searchQuery: z.string().nullable(),
     isFeatured: z.enum(['all', 'true', 'false']).nullable(),
     regions: z.array(regionEnum).nullable(),
     categories: z
@@ -13107,6 +13108,7 @@ const campaignSchema = z.object({
     // automatedSuitability: z.boolean().nullable(),
     boostingEnabled: z.boolean().nullable().default(false),
     maximumBoost: z.number().nullable().default(30),
+    minBoost: z.number().nullable().default(1),
     boostDownToNthPlace: z.number().min(1).max(4).nullable(),
     connectsAbovePrevious: z.number().min(1).nullable(),
     insufficeintBoostConnectsAction: insufficeintBoostConnectsActionEnum,
@@ -13406,6 +13408,354 @@ const campaignInsightsSchema = z.object({
     suitabilityRange90to100: z.number(),
 });
 
+// Clean, validated schema using Zod
+const SearchFieldsSchema = z.object({
+    allWords: z.string().default(''),
+    anyWords: z.string().default(''),
+    noneWords: z.string().default(''),
+    exactPhrase: z.string().default(''),
+    titleSearch: z.string().default(''),
+    skillsSearch: z.string().default(''),
+});
+class SearchQueryBuilder {
+    /**
+     * Build a search query from structured fields
+     * Properly handles quoted phrases in all fields
+     */
+    static buildQuery(fields) {
+        const validatedFields = SearchFieldsSchema.parse(fields);
+        const parts = [];
+        // All words (AND logic) - supports phrases
+        if (validatedFields.allWords.trim()) {
+            const terms = this.splitTerms(validatedFields.allWords);
+            if (terms.length === 1) {
+                parts.push(terms[0]);
+            }
+            else if (terms.length > 1) {
+                parts.push(`(${terms.join(' AND ')})`);
+            }
+        }
+        // Any words (OR logic) - supports phrases
+        if (validatedFields.anyWords.trim()) {
+            const terms = this.splitTerms(validatedFields.anyWords);
+            if (terms.length === 1) {
+                parts.push(terms[0]);
+            }
+            else if (terms.length > 1) {
+                parts.push(`(${terms.join(' OR ')})`);
+            }
+        }
+        // Excluded words (NOT logic) - supports phrases
+        if (validatedFields.noneWords.trim()) {
+            const terms = this.splitTerms(validatedFields.noneWords);
+            const notParts = terms.map((term) => `NOT ${term}`);
+            parts.push(...notParts);
+        }
+        // Exact phrase - single phrase only
+        if (validatedFields.exactPhrase.trim()) {
+            parts.push(`"${validatedFields.exactPhrase.trim()}"`);
+        }
+        // Field-specific searches - now support phrases too
+        if (validatedFields.titleSearch.trim()) {
+            const titleTerms = this.splitTerms(validatedFields.titleSearch);
+            if (titleTerms.length === 1) {
+                // Single term or phrase
+                const term = titleTerms[0];
+                const isQuoted = term.startsWith('"') && term.endsWith('"');
+                parts.push(isQuoted ? `title:${term}` : `title:"${term}"`);
+            }
+            else {
+                // Multiple terms - each gets title: prefix
+                const titleParts = titleTerms.map((term) => {
+                    const isQuoted = term.startsWith('"') && term.endsWith('"');
+                    return isQuoted ? `title:${term}` : `title:"${term}"`;
+                });
+                parts.push(`(${titleParts.join(' AND ')})`);
+            }
+        }
+        if (validatedFields.skillsSearch.trim()) {
+            const skillsTerms = this.splitTerms(validatedFields.skillsSearch);
+            if (skillsTerms.length === 1) {
+                const term = skillsTerms[0];
+                const isQuoted = term.startsWith('"') && term.endsWith('"');
+                parts.push(isQuoted ? `skills:${term}` : `skills:"${term}"`);
+            }
+            else {
+                const skillsParts = skillsTerms.map((term) => {
+                    const isQuoted = term.startsWith('"') && term.endsWith('"');
+                    return isQuoted ? `skills:${term}` : `skills:"${term}"`;
+                });
+                parts.push(`(${skillsParts.join(' AND ')})`);
+            }
+        }
+        return parts.join(' AND ').trim() || '*';
+    }
+    /**
+     * Get human-readable description of search criteria
+     */
+    static describe(fields) {
+        const validatedFields = SearchFieldsSchema.parse(fields);
+        const descriptions = [];
+        if (validatedFields.allWords)
+            descriptions.push(`All words: ${validatedFields.allWords}`);
+        if (validatedFields.anyWords)
+            descriptions.push(`Any words: ${validatedFields.anyWords}`);
+        if (validatedFields.noneWords)
+            descriptions.push(`Excluding: ${validatedFields.noneWords}`);
+        if (validatedFields.exactPhrase)
+            descriptions.push(`Exact phrase: "${validatedFields.exactPhrase}"`);
+        if (validatedFields.titleSearch)
+            descriptions.push(`In title: ${validatedFields.titleSearch}`);
+        if (validatedFields.skillsSearch)
+            descriptions.push(`Skills: ${validatedFields.skillsSearch}`);
+        return descriptions.length > 0 ? descriptions.join(' • ') : 'All results';
+    }
+    /**
+     * Validate search fields
+     */
+    static validate(fields) {
+        const result = SearchFieldsSchema.safeParse(fields);
+        if (result.success) {
+            return { valid: true, data: result.data };
+        }
+        return {
+            valid: false,
+            errors: result.error.errors.map((err) => `${err.path.join('.')}: ${err.message}`),
+        };
+    }
+    /**
+     * Test/demo method to show phrase handling
+     * Remove this in production
+     */
+    static examples() {
+        const testFields = {
+            allWords: 'react "senior developer" javascript',
+            anyWords: 'frontend "full stack" backend',
+            noneWords: 'junior "entry level"',
+            exactPhrase: 'tech lead',
+            titleSearch: 'software engineer',
+            skillsSearch: 'node.js',
+        };
+        console.log('Query:', this.buildQuery(testFields));
+        console.log('Description:', this.describe(testFields));
+        // Should produce:
+        // Query: (react AND "senior developer" AND javascript) AND (frontend OR "full stack" OR backend) AND NOT junior AND NOT "entry level" AND "tech lead" AND title:"software engineer" AND skills:"node.js"
+    }
+    /**
+     * Parse a query string back into SearchFields structure
+     * Fixed to handle grouped NOT expressions correctly
+     */
+    static parseQuery(query) {
+        const result = {
+            allWords: '',
+            anyWords: '',
+            noneWords: '',
+            exactPhrase: '',
+            titleSearch: '',
+            skillsSearch: '',
+        };
+        if (!query || query.trim() === '*') {
+            return result;
+        }
+        let remainingQuery = query.trim();
+        // 1. Extract field-specific searches first
+        const fieldPatterns = [
+            { field: 'titleSearch', pattern: /title:("([^"]+)"|([^\s)]+))/g },
+            { field: 'skillsSearch', pattern: /skills:("([^"]+)"|([^\s)]+))/g },
+        ];
+        for (const { field, pattern } of fieldPatterns) {
+            const matches = [...remainingQuery.matchAll(pattern)];
+            if (matches.length > 0) {
+                const terms = matches.map((match) => {
+                    if (match[2]) {
+                        return `"${match[2]}"`;
+                    }
+                    return match[3];
+                });
+                result[field] = terms.join(' ');
+                remainingQuery = remainingQuery.replace(pattern, '').trim();
+            }
+        }
+        // 2. Extract grouped field searches like title:(term1 AND term2)
+        const groupedFieldPattern = /(title|skills):\(([^)]+)\)/g;
+        let groupMatch;
+        while ((groupMatch = groupedFieldPattern.exec(remainingQuery)) !== null) {
+            const fieldName = groupMatch[1] === 'title' ? 'titleSearch' : 'skillsSearch';
+            const groupContent = groupMatch[2];
+            const terms = this.extractTermsFromGroup(groupContent, groupMatch[1]);
+            result[fieldName] = terms.join(' ');
+            remainingQuery = remainingQuery.replace(groupMatch[0], '').trim();
+        }
+        // 3. **NEW** - Extract grouped NOT expressions FIRST: NOT (term1 OR term2 OR ...)
+        const groupedNotPattern = /NOT\s+\(([^)]+(?:\s+OR\s+[^)]+)+)\)/g;
+        const groupedNotMatches = [...remainingQuery.matchAll(groupedNotPattern)];
+        if (groupedNotMatches.length > 0) {
+            const noneTerms = this.extractTermsFromORGroup(groupedNotMatches[0][1]);
+            result.noneWords = noneTerms.join(' ');
+            remainingQuery = remainingQuery
+                .replace(groupedNotMatches[0][0], '')
+                .trim();
+        }
+        // 4. Extract individual NOT terms (only if no grouped NOT was found)
+        if (!result.noneWords) {
+            const notPattern = /NOT\s+("([^"]+)"|([^\s)]+))/g;
+            const notMatches = [...remainingQuery.matchAll(notPattern)];
+            if (notMatches.length > 0) {
+                const noneTerms = notMatches.map((match) => {
+                    if (match[2]) {
+                        return `"${match[2]}"`;
+                    }
+                    return match[3];
+                });
+                result.noneWords = noneTerms.join(' ');
+                remainingQuery = remainingQuery.replace(notPattern, '').trim();
+            }
+        }
+        // 5. Process grouped expressions - Clean up connectors first
+        remainingQuery = this.cleanupConnectors(remainingQuery);
+        // Extract OR groups (anyWords) - PROCESS FIRST
+        const orGroupPattern = /\(([^)]+(?:\s+OR\s+[^)]+)+)\)/g;
+        const orMatches = [...remainingQuery.matchAll(orGroupPattern)];
+        if (orMatches.length > 0) {
+            const orTerms = this.extractTermsFromORGroup(orMatches[0][1]);
+            result.anyWords = orTerms.join(' ');
+            remainingQuery = remainingQuery.replace(orMatches[0][0], '').trim();
+        }
+        // Extract AND groups (allWords) - PROCESS SECOND
+        const andGroupPattern = /\(([^)]+(?:\s+AND\s+[^)]+)+)\)/g;
+        const andMatches = [...remainingQuery.matchAll(andGroupPattern)];
+        if (andMatches.length > 0) {
+            const andTerms = this.extractTermsFromANDGroup(andMatches[0][1]);
+            result.allWords = andTerms.join(' ');
+            remainingQuery = remainingQuery.replace(andMatches[0][0], '').trim();
+        }
+        // 6. Extract standalone quoted phrases (exactPhrase) - ONLY after all groups processed
+        const standaloneQuotePattern = /(?:^|\s)("([^"]+)")(?=\s|$)/g;
+        const quoteMatches = [...remainingQuery.matchAll(standaloneQuotePattern)];
+        if (quoteMatches.length > 0) {
+            result.exactPhrase = quoteMatches[0][2];
+            remainingQuery = remainingQuery.replace(quoteMatches[0][1], '').trim();
+        }
+        // 7. Handle remaining simple terms as allWords
+        if (remainingQuery) {
+            const remainingTerms = this.splitTermsWithQuotes(remainingQuery);
+            if (remainingTerms.length > 0) {
+                result.allWords = result.allWords
+                    ? `${result.allWords} ${remainingTerms.join(' ')}`.trim()
+                    : remainingTerms.join(' ');
+            }
+        }
+        return result;
+    }
+    /**
+     * Extract terms from grouped field content, preserving quotes
+     */
+    static extractTermsFromGroup(content, fieldPrefix) {
+        // Remove field prefixes but preserve quotes
+        let cleanContent = content;
+        const fieldPattern = new RegExp(`${fieldPrefix}:("([^"]+)"|([^\\s]+))`, 'g');
+        const terms = [];
+        let match;
+        while ((match = fieldPattern.exec(content)) !== null) {
+            if (match[2]) {
+                // Quoted content
+                terms.push(`"${match[2]}"`);
+            }
+            else if (match[3]) {
+                // Unquoted content
+                terms.push(match[3]);
+            }
+        }
+        return terms.length > 0
+            ? terms
+            : [
+                cleanContent
+                    .replace(/(title|skills):/g, '')
+                    .replace(/\s+AND\s+/g, ' ')
+                    .trim(),
+            ];
+    }
+    /**
+     * Extract terms from OR group, preserving quotes and removing OR separators
+     */
+    static extractTermsFromORGroup(content) {
+        return content
+            .split(/\s+OR\s+/)
+            .map((term) => term.trim())
+            .filter(Boolean);
+    }
+    /**
+     * Extract terms from AND group, preserving quotes
+     */
+    static extractTermsFromANDGroup(content) {
+        return content
+            .split(/\s+AND\s+/)
+            .map((term) => term.trim())
+            .filter(Boolean);
+    }
+    /**
+     * Split simple terms while preserving quoted phrases
+     */
+    static splitTermsWithQuotes(input) {
+        const terms = [];
+        const regex = /"([^"]+)"|(\S+)/g;
+        let match;
+        while ((match = regex.exec(input)) !== null) {
+            if (match[1]) {
+                // Quoted phrase - preserve quotes
+                terms.push(`"${match[1]}"`);
+            }
+            else if (match[2] && !['AND', 'OR', 'NOT'].includes(match[2])) {
+                // Regular word (not a connector)
+                terms.push(match[2]);
+            }
+        }
+        return terms;
+    }
+    /**
+     * Clean up AND/OR connectors while preserving quotes
+     */
+    static cleanupConnectors(query) {
+        return query
+            .replace(/\s+AND\s+/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+    }
+    /**
+     * Test the roundtrip conversion (buildQuery -> parseQuery)
+     */
+    static testRoundtrip(fields) {
+        const query = this.buildQuery(fields);
+        const parsed = this.parseQuery(query);
+        const matches = JSON.stringify(fields) === JSON.stringify(parsed);
+        return {
+            original: fields,
+            query,
+            parsed,
+            matches,
+        };
+    }
+    /**
+     * Simple term splitting that handles quoted phrases
+     */
+    static splitTerms(input) {
+        const terms = [];
+        const regex = /"([^"]+)"|(\S+)/g;
+        let match;
+        while ((match = regex.exec(input)) !== null) {
+            if (match[1]) {
+                // Quoted phrase
+                terms.push(`"${match[1]}"`);
+            }
+            else if (match[2]) {
+                // Regular word
+                terms.push(match[2]);
+            }
+        }
+        return terms;
+    }
+}
+
 const fallbackEnum = z.enum(['noBoostBid', 'ignore']);
 const boostFormSchema = z.object({
     minPlace: z.number().int().min(1).max(4), // Don't boost below this place
@@ -13416,144 +13766,14 @@ 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;
@@ -13654,27 +13874,6 @@ 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;
 };
@@ -13701,10 +13900,6 @@ const createClientRatingFormSchema = (existingRanges) => z
 });
 const addFromClientRatingNodeFormSchema = createClientRatingFormSchema([]);
 
-const addFromStartNodeFormSchema = z.object({
-    action: nodeEnums,
-});
-
 const rangesOverlap = (range1, range2) => {
     return range1.from < range2.to && range2.from < range1.to;
 };
@@ -13740,6 +13935,7 @@ const bidPayloadProposalDataSchema = z.object({
     boostingEnabled: z.boolean(),
     specialisedProfileOptions: z.array(z.string()),
     maximumBoost: z.number().nullable(),
+    minimumBoost: z.number().nullable(),
     boostDownToNthPlace: z.number().min(1).max(4).nullable(),
     connectsAbovePrevious: z.number().min(1).nullable(),
     insufficeintBoostConnectsAction: insufficeintBoostConnectsActionEnum,
@@ -23526,6 +23722,8 @@ exports.PuppeteerConnectionErrorException = PuppeteerConnectionErrorException;
 exports.QuestionPairNotMatchingException = QuestionPairNotMatchingException;
 exports.ROUTES = ROUTES;
 exports.ScraperAccountProxyNotFoundException = ScraperAccountProxyNotFoundException;
+exports.SearchFieldsSchema = SearchFieldsSchema;
+exports.SearchQueryBuilder = SearchQueryBuilder;
 exports.SelectAgencyException = SelectAgencyException;
 exports.SelectContractorException = SelectContractorException;
 exports.SelectorNotFoundError = SelectorNotFoundError;
@@ -23537,14 +23735,11 @@ 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;
@@ -23579,7 +23774,6 @@ exports.biddingRejectedWithFeedbackEventMetadata = biddingRejectedWithFeedbackEv
 exports.booleanSchema = booleanSchema;
 exports.boostAboveMaxConnectsException = boostAboveMaxConnectsException;
 exports.boostFormSchema = boostFormSchema;
-exports.budgetPaymentTypeEnum = budgetPaymentTypeEnum;
 exports.buildRoute = buildRoute;
 exports.campaignAIMetricsSchema = campaignAIMetricsSchema;
 exports.campaignActivityCreateSchema = campaignActivityCreateSchema;
@@ -23612,7 +23806,6 @@ exports.convertToUtc = convertToUtc;
 exports.countryMapping = countryMapping;
 exports.coverLetterTemplateSchema = coverLetterTemplateSchema;
 exports.createBidderAccountSchema = createBidderAccountSchema;
-exports.createBudgetFormSchema = createBudgetFormSchema;
 exports.createCampaignSchema = createCampaignSchema;
 exports.createChatbotSchema = createChatbotSchema;
 exports.createClientHireRateFormSchema = createClientHireRateFormSchema;
@@ -23623,7 +23816,6 @@ exports.createCoverLetterTemplateSchema = createCoverLetterTemplateSchema;
 exports.createHourlyRateFormSchema = createHourlyRateFormSchema;
 exports.createOrganizationProfileSchema = createOrganizationProfileSchema;
 exports.createOrganizationSchema = createOrganizationSchema;
-exports.createPaymentTypeFormSchema = createPaymentTypeFormSchema;
 exports.createScraperAccountSchema = createScraperAccountSchema;
 exports.createSuitabilityFormSchema = createSuitabilityFormSchema;
 exports.dailyUsageSchema = dailyUsageSchema;
@@ -23715,7 +23907,6 @@ exports.leadSchema = leadSchema;
 exports.leadStatusActivitySchema = leadStatusActivitySchema;
 exports.leadStatusEnum = leadStatusEnum;
 exports.leadStatusEventMetadata = leadStatusEventMetadata;
-exports.limitedPaymentTypeEnum = limitedPaymentTypeEnum;
 exports.limitsSchema = limitsSchema;
 exports.logEventSchema = logEventSchema;
 exports.loginFailedException = loginFailedException;