lancer-shared 1.2.123 → 1.2.125

package/dist/bundle.cjs.js

@@ -66,274 +66,276 @@ const invoiceStatusNames = {
 };
 
 const JOB_FILTER_OPTIONS = {
-    REGIONS: ["Worldwide", "USOnly", "UKOnly"],
+    REGIONS: ['Worldwide', 'USOnly', 'UKOnly'],
     PROJECT_DURATION: [
-        "Less than 1 month",
-        "1 to 3 months",
-        "3 to 6 months",
-        "More than 6 months",
-        "Unspecified",
+        'Less than 1 month',
+        '1 to 3 months',
+        '3 to 6 months',
+        'More than 6 months',
+        'Unspecified',
     ],
     ENGAGEMENT_TYPE: [
-        "Less than 30 hrs/week",
-        "More than 30 hrs/week",
-        "Unspecified",
+        'Less than 30 hrs/week',
+        'More than 30 hrs/week',
+        'Unspecified',
     ],
-    VENDOR_TYPE: ["Independent", "Agency", "Unspecified"],
-    PAYMENT_TYPE: ["Unspecified", "Hourly", "Fixed-price"],
-    TALENT_TYPE: ["Agency", "Independent", "Unspecified"],
+    VENDOR_TYPE: ['Independent', 'Agency', 'Unspecified'],
+    PAYMENT_TYPE: ['Unspecified', 'Hourly', 'Fixed-price'],
+    TALENT_TYPE: ['Agency', 'Independent', 'Unspecified'],
     ENGLISH_LEVELS: [
-        "Fluent",
-        "Conversational",
-        "Native or Bilingual",
-        "Unspecified",
+        'Fluent',
+        'Conversational',
+        'Native or Bilingual',
+        'Unspecified',
     ],
-    EXPERIENCE_LEVELS: ["Entry level", "Intermediate", "Expert"],
+    EXPERIENCE_LEVELS: ['Entry level', 'Intermediate', 'Expert'],
     REQUIRED_EARNINGS: [100, 1000, 10000],
-    REQUIRED_JSS: [">80%", ">90%", "100%", "RT"],
+    REQUIRED_JSS: ['>80%', '>90%', '100%', 'RT'],
     HIERARCHICAL_CATEGORIES: [
         {
-            label: "Accounting & Consulting",
-            value: "accounting-consulting",
+            label: 'Accounting & Consulting',
+            value: 'accounting-consulting',
             children: [
-                "Accounting & Bookkeeping",
-                "Financial Planning",
-                "Management Consulting & Analysis",
-                "Other - Accounting & Consulting",
-                "Personal & Professional Coaching",
-                "Recruiting & Human Resources",
+                'Accounting & Bookkeeping',
+                'Financial Planning',
+                'Management Consulting & Analysis',
+                'Other - Accounting & Consulting',
+                'Personal & Professional Coaching',
+                'Recruiting & Human Resources',
             ],
         },
         {
-            label: "Admin Support",
-            value: "admin-support",
+            label: 'Admin Support',
+            value: 'admin-support',
             children: [
-                "Data Entry & Transcription Services",
-                "Market Research & Product Reviews",
-                "Project Management",
-                "Virtual Assistance",
+                'Data Entry & Transcription Services',
+                'Market Research & Product Reviews',
+                'Project Management',
+                'Virtual Assistance',
             ],
         },
         {
-            label: "Customer Service",
-            value: "customer-service",
+            label: 'Customer Service',
+            value: 'customer-service',
             children: [
-                "Community Management & Tagging",
-                "Customer Service & Tech Support",
+                'Community Management & Tagging',
+                'Customer Service & Tech Support',
             ],
         },
         {
-            label: "Data Science & Analytics",
-            value: "data-science-analytics",
+            label: 'Data Science & Analytics',
+            value: 'data-science-analytics',
             children: [
-                "AI & Machine Learning",
-                "Data Analysis & Testing",
-                "Data Extraction/ETL",
-                "Data Mining & Management",
+                'AI & Machine Learning',
+                'Data Analysis & Testing',
+                'Data Extraction/ETL',
+                'Data Mining & Management',
             ],
         },
         {
-            label: "Design & Creative",
-            value: "design-creative",
+            label: 'Design & Creative',
+            value: 'design-creative',
             children: [
-                "Art & Illustration",
-                "Audio & Music Production",
-                "Branding & Logo Design",
-                "Graphic, Editorial & Presentation Design",
-                "NFT, AR/VR & Game Art",
-                "Performing Arts",
-                "Photography",
-                "Product Design",
-                "Video & Animation",
+                'Art & Illustration',
+                'Audio & Music Production',
+                'Branding & Logo Design',
+                'Graphic, Editorial & Presentation Design',
+                'NFT, AR/VR & Game Art',
+                'Performing Arts',
+                'Photography',
+                'Product Design',
+                'Video & Animation',
             ],
         },
         {
-            label: "Engineering & Architecture",
-            value: "engineering-architecture",
+            label: 'Engineering & Architecture',
+            value: 'engineering-architecture',
             children: [
-                "3D Modeling & CAD",
-                "Building & Landscape Architecture",
-                "Chemical Engineering",
-                "Civil & Structural Engineering",
-                "Contract Manufacturing",
-                "Electrical & Electronic Engineering",
-                "Energy & Mechanical Engineering",
+                '3D Modeling & CAD',
+                'Building & Landscape Architecture',
+                'Chemical Engineering',
+                'Civil & Structural Engineering',
+                'Contract Manufacturing',
+                'Electrical & Electronic Engineering',
+                'Energy & Mechanical Engineering',
             ],
         },
         {
-            label: "IT & Networking",
-            value: "it-networking",
+            label: 'IT & Networking',
+            value: 'it-networking',
             children: [
-                "Database Management & Administration",
-                "DevOps & Solution Architecture",
-                "ERP/CRM Software",
-                "Information Security & Compliance",
-                "Network & System Administration",
+                'Database Management & Administration',
+                'DevOps & Solution Architecture',
+                'ERP/CRM Software',
+                'Information Security & Compliance',
+                'Network & System Administration',
             ],
         },
         {
-            label: "Legal",
-            value: "legal",
+            label: 'Legal',
+            value: 'legal',
             children: [
-                "Corporate & Contract Law",
-                "Finance & Tax Law",
-                "International & Immigration Law",
-                "Public Law",
+                'Corporate & Contract Law',
+                'Finance & Tax Law',
+                'International & Immigration Law',
+                'Public Law',
             ],
         },
         {
-            label: "Sales & Marketing",
-            value: "sales-marketing",
+            label: 'Sales & Marketing',
+            value: 'sales-marketing',
             children: [
-                "Digital Marketing",
-                "Lead Generation & Telemarketing",
-                "Marketing, PR & Brand Strategy",
+                'Digital Marketing',
+                'Lead Generation & Telemarketing',
+                'Marketing, PR & Brand Strategy',
             ],
         },
         {
-            label: "Translation",
-            value: "translation",
+            label: 'Translation',
+            value: 'translation',
             children: [
-                "Language Tutoring & Interpretation",
-                "Translation & Localization Services",
+                'Language Tutoring & Interpretation',
+                'Translation & Localization Services',
             ],
         },
         {
-            label: "Software Development",
-            value: "software-development",
+            label: 'Software Development',
+            value: 'software-development',
             children: [
-                "AI Apps & Integration",
-                "Blockchain, NFT & Cryptocurrency",
-                "Desktop Application Development",
-                "Ecommerce Development",
-                "Game Design & Development",
-                "Mobile Development",
-                "Other - Software Development",
-                "Product Management & Scrum",
-                "QA Testing",
-                "Scripts & Utilities",
-                "Web & Mobile Design",
-                "Web Development",
+                'AI Apps & Integration',
+                'Blockchain, NFT & Cryptocurrency',
+                'Desktop Application Development',
+                'Ecommerce Development',
+                'Game Design & Development',
+                'Mobile Development',
+                'Other - Software Development',
+                'Product Management & Scrum',
+                'QA Testing',
+                'Scripts & Utilities',
+                'Web & Mobile Design',
+                'Web Development',
             ],
         },
         {
-            label: "Writing",
-            value: "writing",
+            label: 'Writing',
+            value: 'writing',
             children: [
-                "Content Writing",
-                "Editing & Proofreading Services",
-                "Professional & Business Writing",
-                "Sales & Marketing Copywriting",
+                'Content Writing',
+                'Editing & Proofreading Services',
+                'Professional & Business Writing',
+                'Sales & Marketing Copywriting',
             ],
         },
     ],
     CATEGORIES: [
-        "Personal & Professional Coaching",
-        "Accounting & Bookkeeping",
-        "Financial Planning",
-        "Recruiting & Human Resources",
-        "Management Consulting & Analysis",
-        "Other - Accounting & Consulting",
-        "Data Entry & Transcription Services",
-        "Virtual Assistance",
-        "Project Management",
-        "Market Research & Product Reviews",
-        "Community Management & Tagging",
-        "Customer Service & Tech Support",
-        "Data Analysis & Testing",
-        "Data Extraction/ETL",
-        "Data Mining & Management",
-        "AI & Machine Learning",
-        "Art & Illustration",
-        "Audio & Music Production",
-        "Branding & Logo Design",
-        "NFT, AR/VR & Game Art",
-        "Graphic, Editorial & Presentation Design",
-        "Performing Arts",
-        "Photography",
-        "Product Design",
-        "Video & Animation",
-        "Building & Landscape Architecture",
-        "Chemical Engineering",
-        "Civil & Structural Engineering",
-        "Contract Manufacturing",
-        "Electrical & Electronic Engineering",
-        "Energy & Mechanical Engineering",
-        "3D Modeling & CAD",
-        "Database Management & Administration",
-        "ERP/CRM Software",
-        "Information Security & Compliance",
-        "Network & System Administration",
-        "DevOps & Solution Architecture",
-        "Corporate & Contract Law",
-        "International & Immigration Law",
-        "Finance & Tax Law",
-        "Public Law",
-        "Digital Marketing",
-        "Lead Generation & Telemarketing",
-        "Marketing, PR & Brand Strategy",
-        "Language Tutoring & Interpretation",
-        "Translation & Localization Services",
-        "Blockchain, NFT & Cryptocurrency",
-        "AI Apps & Integration",
-        "Desktop Application Development",
-        "Ecommerce Development",
-        "Game Design & Development",
-        "Mobile Development",
-        "Other - Software Development",
-        "Product Management & Scrum",
-        "QA Testing",
-        "Scripts & Utilities",
-        "Web & Mobile Design",
-        "Web Development",
-        "Sales & Marketing Copywriting",
-        "Content Writing",
-        "Editing & Proofreading Services",
-        "Professional & Business Writing",
+        'Interior & Trade Show Design',
+        'Physical Sciences',
+        'Personal & Professional Coaching',
+        'Accounting & Bookkeeping',
+        'Financial Planning',
+        'Recruiting & Human Resources',
+        'Management Consulting & Analysis',
+        'Other - Accounting & Consulting',
+        'Data Entry & Transcription Services',
+        'Virtual Assistance',
+        'Project Management',
+        'Market Research & Product Reviews',
+        'Community Management & Tagging',
+        'Customer Service & Tech Support',
+        'Data Analysis & Testing',
+        'Data Extraction/ETL',
+        'Data Mining & Management',
+        'AI & Machine Learning',
+        'Art & Illustration',
+        'Audio & Music Production',
+        'Branding & Logo Design',
+        'NFT, AR/VR & Game Art',
+        'Graphic, Editorial & Presentation Design',
+        'Performing Arts',
+        'Photography',
+        'Product Design',
+        'Video & Animation',
+        'Building & Landscape Architecture',
+        'Chemical Engineering',
+        'Civil & Structural Engineering',
+        'Contract Manufacturing',
+        'Electrical & Electronic Engineering',
+        'Energy & Mechanical Engineering',
+        '3D Modeling & CAD',
+        'Database Management & Administration',
+        'ERP/CRM Software',
+        'Information Security & Compliance',
+        'Network & System Administration',
+        'DevOps & Solution Architecture',
+        'Corporate & Contract Law',
+        'International & Immigration Law',
+        'Finance & Tax Law',
+        'Public Law',
+        'Digital Marketing',
+        'Lead Generation & Telemarketing',
+        'Marketing, PR & Brand Strategy',
+        'Language Tutoring & Interpretation',
+        'Translation & Localization Services',
+        'Blockchain, NFT & Cryptocurrency',
+        'AI Apps & Integration',
+        'Desktop Application Development',
+        'Ecommerce Development',
+        'Game Design & Development',
+        'Mobile Development',
+        'Other - Software Development',
+        'Product Management & Scrum',
+        'QA Testing',
+        'Scripts & Utilities',
+        'Web & Mobile Design',
+        'Web Development',
+        'Sales & Marketing Copywriting',
+        'Content Writing',
+        'Editing & Proofreading Services',
+        'Professional & Business Writing',
     ],
     CLIENT_INDUSTRY: [
-        "Aerospace",
-        "Agriculture & Forestry",
-        "Art & Design",
-        "Automotive",
-        "Aviation",
-        "Education",
-        "Energy & Utilities",
-        "Engineering & Architecture",
-        "Fashion & Beauty",
-        "Finance & Accounting",
-        "Food & Beverage",
-        "Government & Public Sector",
-        "Health & Fitness",
-        "HR & Business Services",
-        "Legal",
-        "Manufacturing & Construction",
-        "Media & Entertainment",
-        "Military & Defense",
-        "Mining",
-        "Real Estate",
-        "Retail & Consumer Goods",
-        "Sales & Marketing",
-        "Science & Medicine",
-        "Sports & Recreation",
-        "Supply Chain & Logistics",
-        "Tech & IT",
-        "Transportation & Warehousing",
-        "Travel & Hospitality",
+        'Aerospace',
+        'Agriculture & Forestry',
+        'Art & Design',
+        'Automotive',
+        'Aviation',
+        'Education',
+        'Energy & Utilities',
+        'Engineering & Architecture',
+        'Fashion & Beauty',
+        'Finance & Accounting',
+        'Food & Beverage',
+        'Government & Public Sector',
+        'Health & Fitness',
+        'HR & Business Services',
+        'Legal',
+        'Manufacturing & Construction',
+        'Media & Entertainment',
+        'Military & Defense',
+        'Mining',
+        'Real Estate',
+        'Retail & Consumer Goods',
+        'Sales & Marketing',
+        'Science & Medicine',
+        'Sports & Recreation',
+        'Supply Chain & Logistics',
+        'Tech & IT',
+        'Transportation & Warehousing',
+        'Travel & Hospitality',
     ],
     CLIENT_SIZE: [
-        "Individual client",
-        "Small company (2-9 people)",
-        "Mid-sized company (10-99 people)",
-        "Large company (100-1,000 people)",
-        "Large company (1,000+ people)",
-        "Unspecified",
+        'Individual client',
+        'Small company (2-9 people)',
+        'Mid-sized company (10-99 people)',
+        'Large company (100-1,000 people)',
+        'Large company (1,000+ people)',
+        'Unspecified',
     ],
 };
 const regionNames = {
-    Worldwide: "Worldwide",
-    USOnly: "US Only",
-    UKOnly: "UK Only",
+    Worldwide: 'Worldwide',
+    USOnly: 'US Only',
+    UKOnly: 'UK Only',
 };
 
 const jobStatusOrder = [
@@ -11094,16 +11096,16 @@ const clientSizeEnum = z.enum(JOB_FILTER_OPTIONS.CLIENT_SIZE);
 const talentTypeEnum = z.enum(JOB_FILTER_OPTIONS.TALENT_TYPE);
 const englishLevelEnum = z.enum(JOB_FILTER_OPTIONS.ENGLISH_LEVELS);
 const experienceLevelEnum = z.enum(JOB_FILTER_OPTIONS.EXPERIENCE_LEVELS);
-const regionEnum = z.enum(["all", "Worldwide", "UKOnly", "USOnly"]);
+const regionEnum = z.enum(['all', 'Worldwide', 'UKOnly', 'USOnly']);
 const requiredEarningsEnum = z.union([
     z.literal(100),
     z.literal(1000),
     z.literal(10000),
 ]);
 const requiredJSSEnum = z.enum(JOB_FILTER_OPTIONS.REQUIRED_JSS);
-const isPaymentVerifiedEnum = z.enum(["all", "true", "false"]);
-const isPhoneVerifiedEnum = z.enum(["all", "true", "false"]);
-const hasQuestionsEnum = z.enum(["all", "yes", "no"]);
+const isPaymentVerifiedEnum = z.enum(['all', 'true', 'false']);
+const isPhoneVerifiedEnum = z.enum(['all', 'true', 'false']);
+const hasQuestionsEnum = z.enum(['all', 'yes', 'no']);
 // Main job filters schema
 const jobFiltersSchema = z.object({
     keywords: z
@@ -11112,7 +11114,7 @@ const jobFiltersSchema = z.object({
         excludes: z.string().nullable(),
     })
         .nullable(),
-    isFeatured: z.enum(["all", "true", "false"]).nullable(),
+    isFeatured: z.enum(['all', 'true', 'false']).nullable(),
     regions: z.array(regionEnum).nullable(),
     categories: z
         .object({
@@ -11139,9 +11141,9 @@ const jobFiltersSchema = z.object({
     engagementType: z.array(engagementTypeEnum).nullable(),
     clientInfo: z
         .object({
-        isPaymentVerified: isPaymentVerifiedEnum.default("all"),
-        isPhoneVerified: isPhoneVerifiedEnum.default("all"),
-        enterpriseClient: z.enum(["all", "true", "false"]).default("all"),
+        isPaymentVerified: isPaymentVerifiedEnum.default('all'),
+        isPhoneVerified: isPhoneVerifiedEnum.default('all'),
+        enterpriseClient: z.enum(['all', 'true', 'false']).default('all'),
         clientLocationIncludes: z.array(z.string()).nullable(),
         clientLocationExcludes: z.array(z.string()).nullable(),
         minReviewScore: z.number().min(0).max(5).nullable(),
@@ -11982,7 +11984,7 @@ const hourlyBudgetSchema$1 = objectType({
     min: numberType(),
     max: numberType(),
 });
-const feedJobSchemaV2 = objectType({
+const jobListingSchema = objectType({
     uid: stringType(),
     ciphertext: stringType(),
     title: stringType(),
@@ -12022,7 +12024,7 @@ const jobsSearchSchema = objectType({
         loaded: booleanType(),
         failed: booleanType(),
     }),
-    jobs: arrayType(feedJobSchemaV2),
+    jobs: arrayType(jobListingSchema),
     paging: pagingSchema,
     abortController: anyType().nullable(),
     currentPage: numberType(),
@@ -12034,90 +12036,6 @@ const nuxtStateJobsSearchSchema = objectType({
         jobsSearch: jobsSearchSchema,
     }),
 });
-// import { any, array, boolean, number, object, record, string, z } from 'zod';
-// import { Region } from '../shared';
-// // This schema is now more lenient to handle null values for visitor data.
-// const clientSchema = object({
-//   location: object({
-//     country: string().nullable(),
-//   }),
-//   isPaymentVerified: boolean(),
-//   totalSpent: string().nullable(),
-//   totalReviews: number().nullable(), // Changed from number()
-//   totalFeedback: number().nullable(), // Changed from number()
-//   hasFinancialPrivacy: boolean().nullable(), // Changed from boolean()
-// });
-// const attrsSchema = object({
-//   uid: string(),
-//   parentSkillUid: string().nullable(),
-//   prefLabel: string(),
-//   prettyName: string(),
-//   freeText: any().nullable(),
-//   highlighted: boolean(),
-// });
-// const amountSchema = object({
-//   amount: number(),
-// });
-// const hourlyBudgetSchema = object({
-//   min: number(),
-//   max: number(),
-// });
-// export const feedJobSchemaV2 = object({
-//   uid: string(),
-//   ciphertext: string(),
-//   title: string(),
-//   description: string(),
-//   createdOn: string(),
-//   publishedOn: string(),
-//   renewedOn: string().nullable(),
-//   type: number(),
-//   durationLabel: string().nullable(),
-//   engagement: string().nullable(),
-//   amount: amountSchema,
-//   connectPrice: number().nullable(),
-//   client: clientSchema, // Uses the updated clientSchema above
-//   clientRelation: any().nullable(),
-//   freelancersToHire: number().nullable(), // Changed from number()
-//   relevanceEncoded: string(),
-//   enterpriseJob: boolean().nullable(), // Changed from boolean()
-//   tierText: z.string().nullable(),
-//   isApplied: boolean(),
-//   proposalsTier: string().nullable(),
-//   premium: boolean(),
-//   attrs: array(attrsSchema),
-//   hourlyBudget: hourlyBudgetSchema,
-//   weeklyBudget: amountSchema,
-//   isSTSVectorSearchResult: boolean().optional(), // Changed from boolean()
-// });
-// const pagingSchema = object({
-//   total: number(),
-//   offset: number(),
-//   count: number(),
-// });
-// const jobsSearchSchema = object({
-//   status: object({
-//     loading: boolean(),
-//     loaded: boolean(),
-//     failed: boolean(),
-//   }),
-//   jobs: array(feedJobSchemaV2),
-//   paging: pagingSchema,
-//   abortController: any().nullable(),
-//   currentPage: number(),
-//   jobsPerPage: number(),
-//   searchQueryCache: record(string()),
-// });
-// export const nuxtStateJobsSearchSchema = object({
-//   state: object({
-//     jobsSearch: jobsSearchSchema,
-//   }),
-// });
-// export interface NuxtStateJobsSearch
-//   extends z.infer<typeof nuxtStateJobsSearchSchema> {}
-// export interface FeedJobV2 extends z.infer<typeof feedJobSchemaV2> {
-//   jobUrl: string;
-//   region: Region;
-// }
 
 // Field mapping from feed-job to job-details for the missing fields that were added
 const FEED_JOB_TO_JOB_DETAILS_FIELD_MAPPING = {
@@ -12816,6 +12734,9 @@ const agencyBidProposalDataSchema = bidPayloadProposalDataSchema.extend({
     specializedProfile: z.string().nullable(),
 });
 const bidPayloadSchema = z.object({
+    organizationId: z.string(),
+    campaignId: z.string(),
+    lead: leadSchema,
     jobUrl: z.string(),
     username: z.string(),
     password: z.string(),
@@ -13025,6 +12946,14 @@ function proposalFormWarningAlertException(message) {
     return new ProposalFormWarningAlertException(message);
 }
 
+class ProposalGenerationFailedException extends Error {
+    code = 'PROPOSAL_GENERATION_FAILED_EXCEPTION';
+    constructor(message, organizationId, campaignId, leadId) {
+        super(`Proposal generation failed for lead ${leadId} in campaign ${campaignId} in organization ${organizationId}\n\n${message}`);
+    }
+}
+const proposalGenerationFailed = (message, leadId, campaignId, organizationId) => new ProposalGenerationFailedException(message, organizationId, campaignId, leadId);
+
 class ProposalSubmitFailedException extends Error {
     code = 'PROPOSAL_SUBMIT_FAILED';
     constructor(message) {
@@ -13109,250 +13038,10 @@ class WaitForFunctionTimeoutError extends Error {
 }
 const waitForFunctionTimeoutError = (fn, timeout) => new WaitForFunctionTimeoutError(fn, timeout);
 
-const proposalSchema = z.object({
-    coverLetter: z.string(),
-    questionAnswerPairs: questionAnswerPairSchema.array(),
-});
-
-const LogEventTypeEnum = z.enum([
-    // Scraper Events
-    'scraperStarted',
-    'scraperCompleted',
-    'scrapeJobStarted',
-    'jobScraped',
-    'jobScrapeFailed',
-    'scrapeJobDetailsStarted',
-    'scrapeJobDetailsCompleted',
-    'scrapeJobDetailsFailed',
-    'jobsIndexed',
-    'jobDuplicateSkipped',
-    'scraperFailed',
-    'jobActivityScraped',
-    'jobActivityScrapeFailed',
-    'leadStatusCheckFailed',
-    'leadStatusUpdated',
-    // Feed Scraper Events
-    'feedScrapeStarted',
-    'feedScrapeCompleted',
-    'feedScrapeFailed',
-    'jobListingScraped',
-    // Job Sync & Campaign Matching
-    'jobSyncPublished',
-    'jobSyncReceived',
-    'leadsCreatedAndSynced',
-    // Suitability Events
-    'suitabilityPending',
-    'suitabilityProcessing',
+const usageEventTypeEnum = z.enum([
     'suitabilityComplete',
-    'suitabilityFailed',
-    'manualSuitabilityAnalyzed',
-    // Proposal Events
-    'proposalProcessing',
     'proposalComplete',
-    'proposalFailed',
-    'manualProposalGenerated',
-    // Bidding Events
-    'biddingProcessing',
     'biddingComplete',
-    'biddingFailed',
-    'biddingSkipped',
-    'biddingPending',
-    'biddingRetry',
-    'biddingInsufficientConnects',
-    'biddingWarningAlert',
-    'biddingRejected',
-    'biddingRejectedWithFeedback',
-    'checkSuitableLeadFeedbackStatus',
-    'biddingApproved',
-    // System/Generic Events
-    'errorLogged',
-    'cloudTaskRetry',
-    'manualLeadEdited',
-    'leadArchived',
-    'auditTrailLogged',
-    // Account Events
-    'scraperAccountError',
-]);
-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
-    organizationId: z.string().nullable(),
-    userId: z.string().nullable(),
-    campaignId: z.string().nullable(),
-    leadId: 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(),
-});
-const listingScrapedEventMetadata = objectType({
-    listing: feedJobSchemaV2,
-    region: regionSchema,
-});
-const scrapeFeedEventMetadata = objectType({
-    region: regionSchema,
-    error: stringType(),
-});
-const scrapeFeedJobsDetailsStartedEventMetadata = objectType({
-    region: regionSchema,
-    accounts: z.array(z.object({
-        id: stringType(),
-        email: stringType(),
-    })),
-    feedJobsCount: numberType(),
-    chunksSize: numberType(),
-});
-const scrapeFeedJobsDetailsCompletedEventMetadata = objectType({
-    region: regionSchema,
-    accountId: stringType(),
-    accountEmail: stringType(),
-    feedJobsCount: numberType(),
-    duration: stringType(),
-});
-const scrapeFeedJobsDetailsFailedEventMetadata = objectType({
-    region: regionSchema,
-    accountId: stringType(),
-    accountEmail: stringType(),
-    error: stringType(),
-    duration: stringType(),
-});
-const scrapeJobStartedEventMetadata = objectType({
-    listing: feedJobSchemaV2,
-    region: regionSchema,
-    accountId: stringType(),
-    accountEmail: stringType(),
-});
-const scrapeJobFailedEventMetadata = objectType({
-    listing: feedJobSchemaV2,
-    region: regionSchema,
-    error: stringType(),
-});
-const jobActivityScrapedEventMetadata = objectType({
-    activity: jobActivitySchema,
-    region: regionSchema,
-    offsetHour: jobActivityOffsetHourSchema,
-    scrapedAt: numberType(),
-});
-const jobActivityScrapeFailedEventMetadata = objectType({
-    listing: feedJobSchemaV2,
-    region: regionSchema,
-    offsetHour: jobActivityOffsetHourSchema,
-});
-const feedScrapeStartedEventMetadata = objectType({
-    id: stringType(),
-    startTime: numberType(),
-    region: regionSchema,
-});
-const feedScrapeCompletedEventMetadata = objectType({
-    id: stringType(),
-    endTime: numberType(),
-    listingCount: numberType(),
-    duration: stringType(),
-    accountEmail: stringType(),
-    region: regionSchema,
-    durationMillis: numberType().nullish(),
-});
-const biddingCompletedEventMetadata = objectType({
-    biddingAmount: numberType(),
-    boosted: booleanType(),
-    boostingAmount: numberType(),
-});
-const biddingFailedEventMetadata = objectType({
-    error: z.any(),
-});
-const userAccountBiddingExceptionEventMetadata = objectType({
-    errorType: z.enum(['insufficientConnects', 'proposalFormWarningAlert']),
-    context: z.string().optional(),
-});
-const lancerBiddingExceptionEventMetadata = objectType({
-    errorType: z.string(),
-    errorMessage: z.string(),
-    context: z.string().optional(),
-});
-const leadStatusEventMetadata = objectType({
-    campaignId: stringType(),
-    organizationId: stringType(),
-    leadId: stringType(),
-    userId: stringType(),
-    metadata: z
-        .object({
-        status: leadStatusSchema,
-        proposalId: stringType().nullable(),
-    })
-        .optional(),
-    reason: z.string().optional(),
-});
-const scraperAccountErrorEventMetadata = objectType({
-    accountId: stringType(),
-    accountEmail: stringType(),
-    errorCode: stringType(),
-    errorMessage: stringType(),
-});
-const biddingRejectedWithFeedbackEventMetadata = objectType({
-    feedback: z.string(),
-});
-const suitabilityPendingEventMetadataSchema = objectType({
-    jobId: z.string(),
-    jobUrl: z.string(),
-    title: z.string(),
-    timestamp: z.number(),
-    applyToLeads: z.array(z.object({ leadId: z.string(), campaignId: z.string() })),
-});
-const suitabilityCompleteEventMetadataSchema = objectType({
-    suitabilityRating: z.number(),
-    suitabilityReason: z.string(),
-    agentStatus: z.string().optional(),
-    model: z.string().optional(),
-    provider: z.string().optional(),
-    promptTokens: z.number().optional(),
-    completionTokens: z.number().optional(),
-    messages: z
-        .array(objectType({
-        role: z.string(),
-        content: z.string(),
-    }))
-        .optional(),
-    jobId: z.string(),
-    applyToLeads: z.array(z.object({ leadId: z.string(), campaignId: z.string() })),
-});
-const suitabilityFailedEventMetadataSchema = objectType({
-    agentStatus: z.string(),
-    reason: z.string(),
-});
-const proposalCompleteEventMetadataSchema = objectType({
-    proposal: proposalSchema,
-    model: z.string().optional(),
-    provider: z.string().optional(),
-    promptTokens: z.number().optional(),
-    completionTokens: z.number().optional(),
-    messages: z
-        .array(objectType({
-        role: z.string(),
-        content: z.string(),
-    }))
-        .optional(),
-    jobId: z.string(),
-    isOverallHighestPriorityCampaign: z.boolean(),
-    applyToLeads: z.array(z.object({ leadId: z.string(), campaignId: z.string() })),
-});
-const eventLoggerPayloadSchema = unionType([
-    logEventSchema,
-    arrayType(logEventSchema),
-]);
-
-const usageEventTypeEnum = LogEventTypeEnum.extract([
-    "suitabilityComplete",
-    "proposalComplete",
-    "biddingComplete",
 ]);
 const usageEventMetadataSchema = objectType({
     campaignId: stringType().nullable(),
@@ -13438,8 +13127,8 @@ const onboardingProgressSchema = z.object({
     startCampaign: z.boolean(),
 });
 
-const organizationTypeSchema = z.enum(["agency", "freelancer"]);
-const organizationTierEnum = z.enum(["free", "premium"]);
+const organizationTypeSchema = z.enum(['agency', 'freelancer']);
+const organizationTierEnum = z.enum(['free', 'premium']);
 const limitsSchema = objectType({
     monthlyCredits: numberType(),
     usedCredits: numberType(),
@@ -13467,7 +13156,7 @@ const caseStudySchema = objectType({
     description: stringType(),
 });
 z.object({
-    type: z.enum(["freelancer", "agency"]),
+    type: z.enum(['freelancer', 'agency']),
     name: z.string(),
     summary: z.string(),
     coreServices: z.string(),
@@ -13487,10 +13176,10 @@ const createOrganizationSchema = organizationSchema.pick({
     name: true,
     type: true,
 });
-const trackUsageEventTypeEnum = LogEventTypeEnum.extract([
-    "suitabilityComplete",
-    "proposalComplete",
-    "biddingComplete",
+const trackUsageEventTypeEnum = z.enum([
+    'suitabilityComplete',
+    'proposalComplete',
+    'biddingComplete',
 ]);
 const trackUsagePayloadSchema = objectType({
     event: usageEventTypeEnum,
@@ -13521,8 +13210,8 @@ const organizationSettingsSchema = objectType({
     aiConfig: aiConfigSchema,
 });
 const subscribePayloadSchema = objectType({
-    planId: stringType().min(1, "Plan id is required."),
-    paymentMethodId: stringType().min(1, "Payment method is required."),
+    planId: stringType().min(1, 'Plan id is required.'),
+    paymentMethodId: stringType().min(1, 'Payment method is required.'),
     toltReferral: stringType().optional(),
     couponCode: stringType().nullish(),
 });
@@ -13859,7 +13548,35 @@ const invoiceSchema = objectType({
     updatedAt: numberType(),
 });
 
-const agentTaskRequestSchema = z.object({
+const proposalSchema = z.object({
+    coverLetter: z.string(),
+    questionAnswerPairs: questionAnswerPairSchema.array(),
+});
+
+const agentGenerateProposalRequestSchema = z.object({
+    userId: z.string().nullable(),
+    organizationId: z.string(),
+    campaignId: z.string(),
+    job: z.object({
+        id: z.string(),
+        title: z.string(),
+        description: z.string(),
+        questions: z.array(z.string()),
+        clientCountry: z.string(),
+    }),
+    isOverallHighestPriorityCampaign: z.boolean().optional(),
+    applyToLeads: z
+        .array(z.object({ leadId: z.string(), campaignId: z.string() }))
+        .optional(),
+});
+const agentGenerateProposalResponseSchema = z.object({
+    coverLetter: z.string(),
+    questionAnswerPairs: z.array(z.object({
+        question: z.string(),
+        answer: z.string(),
+    })),
+});
+const agentCalculateSuitabilityRequestSchema = z.object({
     userId: z.string().nullable(),
     organizationId: z.string(),
     campaignId: z.string(),
@@ -13885,6 +13602,247 @@ const agentTaskResponseSchema = z.object({
     completionTokens: z.number(),
 });
 
+const LogEventTypeEnum = z.enum([
+    // Lead Status Events
+    'leadStatusCheckFailed',
+    'leadStatusUpdated',
+    // Job Sync & Campaign Matching
+    'jobSyncPublished',
+    'jobSyncReceived',
+    'jobsIndexed',
+    'leadsCreatedAndSynced',
+    'jobDuplicateSkipped',
+    // Suitability Events
+    'suitabilityPending',
+    'suitabilityProcessing',
+    'suitabilityComplete',
+    'suitabilityFailed',
+    'manualSuitabilityAnalyzed',
+    // Proposal Events
+    'proposalProcessing',
+    'proposalComplete',
+    'proposalFailed',
+    'manualProposalGenerated',
+    // Bidding Events
+    'biddingProcessing',
+    'biddingComplete',
+    'biddingFailed',
+    'biddingSkipped',
+    'biddingPending',
+    'biddingRetry',
+    'biddingInsufficientConnects',
+    'biddingWarningAlert',
+    'biddingRejected',
+    'biddingRejectedWithFeedback',
+    'checkSuitableLeadFeedbackStatus',
+    'biddingApproved',
+    // System/Generic Events
+    'errorLogged',
+    'cloudTaskRetry',
+    'manualLeadEdited',
+    'leadArchived',
+    'auditTrailLogged',
+    // Scraper Events
+    'scrapeFeedStarted',
+    'scrapeFeedCompleted',
+    'scrapeFeedFailed',
+    'scrapeJobDetailsStarted',
+    'jobScraped',
+    'scrapeJobDetailsFailed',
+    'scrapeJobsDetailsStarted',
+    'scrapeJobsDetailsCompleted',
+    'scrapeJobsDetailsFailed',
+    'scrapeJobsCompleted',
+    'scraperAccountError',
+]);
+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
+    organizationId: z.string().nullable(),
+    userId: z.string().nullable(),
+    campaignId: z.string().nullable(),
+    leadId: 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(),
+});
+const biddingCompletedEventMetadata = objectType({
+    biddingAmount: numberType(),
+    boosted: booleanType(),
+    boostingAmount: numberType(),
+});
+const biddingFailedEventMetadata = objectType({
+    error: z.any(),
+});
+const userAccountBiddingExceptionEventMetadata = objectType({
+    errorType: z.enum(['insufficientConnects', 'proposalFormWarningAlert']),
+    context: z.string().optional(),
+});
+const lancerBiddingExceptionEventMetadata = objectType({
+    errorType: z.string(),
+    errorMessage: z.string(),
+    context: z.string().optional(),
+});
+const leadStatusEventMetadata = objectType({
+    campaignId: stringType(),
+    organizationId: stringType(),
+    leadId: stringType(),
+    userId: stringType(),
+    metadata: z
+        .object({
+        status: leadStatusSchema,
+        proposalId: stringType().nullable(),
+    })
+        .optional(),
+    reason: z.string().optional(),
+});
+const biddingRejectedWithFeedbackEventMetadata = objectType({
+    feedback: z.string(),
+});
+const suitabilityPendingEventMetadataSchema = objectType({
+    jobId: z.string(),
+    jobUrl: z.string(),
+    title: z.string(),
+    timestamp: z.number(),
+    applyToLeads: z.array(z.object({ leadId: z.string(), campaignId: z.string() })),
+});
+const suitabilityCompleteEventMetadataSchema = objectType({
+    suitabilityRating: z.number(),
+    suitabilityReason: z.string(),
+    agentStatus: z.string().optional(),
+    model: z.string().optional(),
+    provider: z.string().optional(),
+    promptTokens: z.number().optional(),
+    completionTokens: z.number().optional(),
+    messages: z
+        .array(objectType({
+        role: z.string(),
+        content: z.string(),
+    }))
+        .optional(),
+    jobId: z.string(),
+    applyToLeads: z.array(z.object({ leadId: z.string(), campaignId: z.string() })),
+});
+const suitabilityFailedEventMetadataSchema = objectType({
+    agentStatus: z.string(),
+    reason: z.string(),
+});
+const proposalCompleteEventMetadataSchema = objectType({
+    proposal: proposalSchema,
+    model: z.string().optional(),
+    provider: z.string().optional(),
+    promptTokens: z.number().optional(),
+    completionTokens: z.number().optional(),
+    messages: z
+        .array(objectType({
+        role: z.string(),
+        content: z.string(),
+    }))
+        .optional(),
+    jobId: z.string(),
+    isOverallHighestPriorityCampaign: z.boolean(),
+    applyToLeads: z.array(z.object({ leadId: z.string(), campaignId: z.string() })),
+});
+const eventLoggerPayloadSchema = unionType([
+    logEventSchema,
+    arrayType(logEventSchema),
+]);
+
+const scrapeFeedStartedEventMetadata = objectType({
+    region: regionSchema,
+    accountId: stringType(),
+    accountEmail: stringType(),
+});
+const scrapeFeedCompletedEventMetadata = objectType({
+    region: regionSchema,
+    accountId: stringType(),
+    accountEmail: stringType(),
+    listingsCount: numberType(),
+    duration: stringType(),
+});
+const scrapeFeedFailedEventMetadata = objectType({
+    region: regionSchema,
+    accountId: stringType(),
+    accountEmail: stringType(),
+    errorMessage: stringType(),
+    errorCode: stringType(),
+    errorStack: stringType(),
+});
+const scrapeJobDetailsStartedEventMetadata = objectType({
+    listing: jobListingSchema,
+    region: regionSchema,
+    accountId: stringType(),
+    accountEmail: stringType(),
+});
+const jobScrapedEventMetadata = objectType({
+    job: jobListingSchema,
+    region: regionSchema,
+    duration: stringType(),
+});
+const scrapeJobDetailsFailedEventMetadata = objectType({
+    listing: jobListingSchema,
+    region: regionSchema,
+    error: stringType(),
+});
+const scrapeJobsDetailsStartedEventMetadata = objectType({
+    region: regionSchema,
+    accountIds: arrayType(stringType()),
+    accountEmails: arrayType(stringType()),
+    jobListingsCount: numberType(),
+});
+const scrapeJobsDetailsCompletedEventMetadata = objectType({
+    region: regionSchema,
+    feedScraperAccountId: stringType(),
+    feedScraperAccountEmail: stringType(),
+    uniqueJobsFound: numberType(),
+    duration: stringType(),
+    successfullyScrapedJobsCount: numberType(),
+    failedToScrapeJobsCount: numberType(),
+});
+const scrapeJobsDetailsFailedEventMetadata = objectType({
+    region: regionSchema,
+    accountId: stringType(),
+    accountEmail: stringType(),
+    errorMessage: stringType(),
+    errorCode: stringType(),
+    errorStack: stringType(),
+});
+const scrapeJobsCompletedEventMetadata = objectType({
+    region: regionSchema,
+    feedScraperAccountId: stringType(),
+    feedScraperAccountEmail: stringType(),
+    uniqueJobsFound: numberType(),
+    duration: stringType(),
+    successfullyScrapedJobsCount: numberType(),
+    failedToScrapeJobsCount: numberType(),
+});
+const jobActivityScrapedEventMetadata = objectType({
+    activity: jobActivitySchema,
+    region: regionSchema,
+    offsetHour: jobActivityOffsetHourSchema,
+    scrapedAt: numberType(),
+});
+const jobActivityScrapeFailedEventMetadata = objectType({
+    listing: jobListingSchema,
+    region: regionSchema,
+    offsetHour: jobActivityOffsetHourSchema,
+});
+const scraperAccountErrorEventMetadata = objectType({
+    errorStack: stringType(),
+    errorCode: stringType(),
+    errorMessage: stringType(),
+});
+
 const planStripeMetadataSchema = objectType({
     id: stringType().regex(/^prod_[a-zA-Z0-9]+$/),
     name: stringType(),
@@ -13929,7 +13887,7 @@ const scrapeUserProfileRequestSchema = objectType({
     profileUrl: stringType(),
 });
 const scrapeJobPayloadSchema = objectType({
-    listing: feedJobSchema,
+    listing: jobListingSchema,
 });
 const processFeedPayloadSchema = objectType({
     region: regionSchema,
@@ -13983,8 +13941,8 @@ const upworkProfileSchema = objectType({
 });
 
 class NoScraperAccountAvailableException extends Error {
-    code = "NO_SCRAPER_ACCOUNT_AVAILABLE";
-    constructor(message = "No scraper account available.") {
+    code = 'NO_SCRAPER_ACCOUNT_AVAILABLE';
+    constructor(message = 'No scraper account available.') {
         super(message);
     }
 }
@@ -13992,8 +13950,8 @@ const noScraperAccountAvailableException = (message) => {
     return new NoScraperAccountAvailableException(message);
 };
 class OpenPageException extends Error {
-    code = "OPEN_PAGE_FAILED";
-    constructor(message = "Failed to open page.") {
+    code = 'OPEN_PAGE_FAILED';
+    constructor(message = 'Failed to open page.') {
         super(message);
     }
 }
@@ -14001,14 +13959,32 @@ const openPageException = (message) => {
     return new OpenPageException(message);
 };
 class FeedScrapeException extends Error {
-    code = "FEED_SCRAPE_FAILED";
-    constructor(message = "Feed scrape failed.") {
+    code = 'FEED_SCRAPE_FAILED';
+    constructor(message = 'Feed scrape failed.') {
         super(message);
     }
 }
 const feedScrapeException = (message) => {
     return new FeedScrapeException(message);
 };
+class ParseJobListingsException extends Error {
+    code = 'PARSE_JOB_LISTINGS_FAILED';
+    constructor(message = 'Failed to parse job listings.') {
+        super(message);
+    }
+}
+const parseJobListingsException = (message) => {
+    return new ParseJobListingsException(message);
+};
+class ScrapeJobDetailsException extends Error {
+    code = 'SCRAPE_JOB_DETAILS_FAILED';
+    constructor(jobListing) {
+        super(`Failed to scrape job details for ${JSON.stringify(jobListing)}.`);
+    }
+}
+const scrapeJobDetailsException = (jobListing) => {
+    return new ScrapeJobDetailsException(jobListing);
+};
 
 const systemPromptSchema = objectType({
     suitability: stringType(),
@@ -14552,12 +14528,15 @@ exports.NoGoogleOAuthTokensFoundException = NoGoogleOAuthTokensFoundException;
 exports.NoScraperAccountAvailableException = NoScraperAccountAvailableException;
 exports.OpenPageException = OpenPageException;
 exports.ParseConnectsException = ParseConnectsException;
+exports.ParseJobListingsException = ParseJobListingsException;
 exports.ProposalErrorAlertException = ProposalErrorAlertException;
 exports.ProposalFormWarningAlertException = ProposalFormWarningAlertException;
+exports.ProposalGenerationFailedException = ProposalGenerationFailedException;
 exports.ProposalSubmitFailedException = ProposalSubmitFailedException;
 exports.PuppeteerConnectionErrorException = PuppeteerConnectionErrorException;
 exports.QuestionPairNotMatchingException = QuestionPairNotMatchingException;
 exports.ROUTES = ROUTES;
+exports.ScrapeJobDetailsException = ScrapeJobDetailsException;
 exports.SelectAgencyException = SelectAgencyException;
 exports.SelectContractorException = SelectContractorException;
 exports.SelectorNotFoundError = SelectorNotFoundError;
@@ -14571,8 +14550,10 @@ exports.accountStatusOrder = accountStatusOrder;
 exports.accountStatusSchema = accountStatusSchema;
 exports.agencyBidPayloadSchema = agencyBidPayloadSchema;
 exports.agencyBidProposalDataSchema = agencyBidProposalDataSchema;
+exports.agentCalculateSuitabilityRequestSchema = agentCalculateSuitabilityRequestSchema;
+exports.agentGenerateProposalRequestSchema = agentGenerateProposalRequestSchema;
+exports.agentGenerateProposalResponseSchema = agentGenerateProposalResponseSchema;
 exports.agentStatusSchema = agentStatusSchema;
-exports.agentTaskRequestSchema = agentTaskRequestSchema;
 exports.agentTaskResponseSchema = agentTaskResponseSchema;
 exports.aiConfigSchema = aiConfigSchema;
 exports.bidConfigSchema = bidConfigSchema;
@@ -14644,10 +14625,7 @@ exports.experienceLevelEnum = experienceLevelEnum;
 exports.externalProxySchema = externalProxySchema;
 exports.failedToParseNuxtJobException = failedToParseNuxtJobException;
 exports.feedJobSchema = feedJobSchema;
-exports.feedJobSchemaV2 = feedJobSchemaV2;
-exports.feedScrapeCompletedEventMetadata = feedScrapeCompletedEventMetadata;
 exports.feedScrapeException = feedScrapeException;
-exports.feedScrapeStartedEventMetadata = feedScrapeStartedEventMetadata;
 exports.filterOptionItemSchema = filterOptionItemSchema;
 exports.filterOptionsResponseSchema = filterOptionsResponseSchema;
 exports.findLeadsRequestSchema = findLeadsRequestSchema;
@@ -14691,7 +14669,9 @@ exports.jobActivityUpdateSchema = jobActivityUpdateSchema;
 exports.jobDetailsStateSchema = jobDetailsStateSchema;
 exports.jobFiltersSchema = jobFiltersSchema;
 exports.jobIsPrivateException = jobIsPrivateException;
+exports.jobListingSchema = jobListingSchema;
 exports.jobQualityScoreSchema = jobQualityScoreSchema;
+exports.jobScrapedEventMetadata = jobScrapedEventMetadata;
 exports.jobSkillsSchema = jobSkillsSchema;
 exports.jobStatusOrder = jobStatusOrder;
 exports.lancerBiddingExceptionEventMetadata = lancerBiddingExceptionEventMetadata;
@@ -14702,7 +14682,6 @@ exports.leadStatusActivitySchema = leadStatusActivitySchema;
 exports.leadStatusEventMetadata = leadStatusEventMetadata;
 exports.leadStatusSchema = leadStatusSchema;
 exports.limitsSchema = limitsSchema;
-exports.listingScrapedEventMetadata = listingScrapedEventMetadata;
 exports.logEventSchema = logEventSchema;
 exports.loginFailedException = loginFailedException;
 exports.loginSchema = loginSchema;
@@ -14728,6 +14707,7 @@ exports.organizationSettingsSchema = organizationSettingsSchema;
 exports.organizationTierEnum = organizationTierEnum;
 exports.organizationTypeSchema = organizationTypeSchema;
 exports.parseConnectsException = parseConnectsException;
+exports.parseJobListingsException = parseJobListingsException;
 exports.passwordSchema = passwordSchema;
 exports.paymentTypeEnum = paymentTypeEnum;
 exports.periodTypeSchema = periodTypeSchema;
@@ -14742,6 +14722,7 @@ exports.projectDurationEnum = projectDurationEnum;
 exports.proposalCompleteEventMetadataSchema = proposalCompleteEventMetadataSchema;
 exports.proposalErrorAlertException = proposalErrorAlertException;
 exports.proposalFormWarningAlertException = proposalFormWarningAlertException;
+exports.proposalGenerationFailed = proposalGenerationFailed;
 exports.proposalSchema = proposalSchema;
 exports.proposalSentActivitySchema = proposalSentActivitySchema;
 exports.proposalSubmitFailedException = proposalSubmitFailedException;
@@ -14763,15 +14744,19 @@ exports.registerSchema = registerSchema;
 exports.requiredEarningsEnum = requiredEarningsEnum;
 exports.requiredJSSEnum = requiredJSSEnum;
 exports.savedSearchSchema = savedSearchSchema;
-exports.scrapeFeedEventMetadata = scrapeFeedEventMetadata;
-exports.scrapeFeedJobsDetailsCompletedEventMetadata = scrapeFeedJobsDetailsCompletedEventMetadata;
-exports.scrapeFeedJobsDetailsFailedEventMetadata = scrapeFeedJobsDetailsFailedEventMetadata;
-exports.scrapeFeedJobsDetailsStartedEventMetadata = scrapeFeedJobsDetailsStartedEventMetadata;
+exports.scrapeFeedCompletedEventMetadata = scrapeFeedCompletedEventMetadata;
+exports.scrapeFeedFailedEventMetadata = scrapeFeedFailedEventMetadata;
 exports.scrapeFeedResultSchema = scrapeFeedResultSchema;
+exports.scrapeFeedStartedEventMetadata = scrapeFeedStartedEventMetadata;
 exports.scrapeJobActivityPayloadSchema = scrapeJobActivityPayloadSchema;
-exports.scrapeJobFailedEventMetadata = scrapeJobFailedEventMetadata;
+exports.scrapeJobDetailsException = scrapeJobDetailsException;
+exports.scrapeJobDetailsFailedEventMetadata = scrapeJobDetailsFailedEventMetadata;
+exports.scrapeJobDetailsStartedEventMetadata = scrapeJobDetailsStartedEventMetadata;
 exports.scrapeJobPayloadSchema = scrapeJobPayloadSchema;
-exports.scrapeJobStartedEventMetadata = scrapeJobStartedEventMetadata;
+exports.scrapeJobsCompletedEventMetadata = scrapeJobsCompletedEventMetadata;
+exports.scrapeJobsDetailsCompletedEventMetadata = scrapeJobsDetailsCompletedEventMetadata;
+exports.scrapeJobsDetailsFailedEventMetadata = scrapeJobsDetailsFailedEventMetadata;
+exports.scrapeJobsDetailsStartedEventMetadata = scrapeJobsDetailsStartedEventMetadata;
 exports.scrapePayloadSchema = scrapePayloadSchema;
 exports.scrapeResultSchema = scrapeResultSchema;
 exports.scrapeUserProfileRequestSchema = scrapeUserProfileRequestSchema;