lancer-shared 1.2.119 → 1.2.120

package/dist/bundle.cjs.js

@@ -6419,105 +6419,106 @@ var moment = /*@__PURE__*/getDefaultExportFromCjs(momentExports);
 
 const ROUTES = {
     AUTH: {
-        BASE: "auth",
-        REGISTER: "auth/register",
+        BASE: 'auth',
+        REGISTER: 'auth/register',
     },
     SYSTEM: {
-        BASE: "system",
+        BASE: 'system',
         PROMPTS: {
-            BASE: "system/prompts",
+            BASE: 'system/prompts',
         },
     },
     EVENTS: {
-        BASE: "events",
+        BASE: 'events',
         BY_ID: (id) => `events/${id}`,
     },
     JOBS: {
-        BASE: "jobs",
+        BASE: 'jobs',
         BY_ID: (id) => `jobs/${id}`,
         UPDATE_ACTIVITY: `jobs/update-activity`,
-        IMPORT: "jobs/import",
-        FILTER_OPTIONS: "jobs/filter-options",
-        TOTAL_JOBS: "jobs/total-jobs",
+        IMPORT: 'jobs/import',
+        FILTER_OPTIONS: 'jobs/filter-options',
+        TOTAL_JOBS: 'jobs/total-jobs',
         GET_JOB_TITLE: (jobId) => `jobs/get-job-title/${jobId}`,
-        GET_JOBS_COUNT: "jobs/get-jobs-count",
+        GET_JOBS_COUNT: 'jobs/get-jobs-count',
     },
     USERS: {
-        BASE: "users",
+        BASE: 'users',
         BY_ID: (id) => `users/${id}`,
         ORGANIZATIONS: (id) => `users/${id}/organizations`,
     },
     COOKIES: {
-        BASE: "cookies",
-        SCRAPE: "cookies/scrape-cookies",
+        BASE: 'cookies',
+        SCRAPE: 'cookies/scrape-cookies',
     },
     SCRAPING: {
-        BASE: "scraping",
-        START_SCRAPING: "scraping/start",
-        START_WORLDWIDE_SCRAPING: "scraping/start-worldwide",
-        START_US_SCRAPING: "scraping/start-us",
-        START_UK_SCRAPING: "scraping/start-uk",
-        UPDATE_ACTIVITY_4H_WORLDWIDE: "scraping/update-activity/4h",
-        UPDATE_ACTIVITY_4H_UK: "scraping/update-activity/4h/uk",
-        UPDATE_ACTIVITY_4H_US: "scraping/update-activity/4h/us",
-        UPDATE_ACTIVITY_24H_WORLDWIDE: "scraping/update-activity/24h",
-        UPDATE_ACTIVITY_24H_UK: "scraping/update-activity/24h/uk",
-        UPDATE_ACTIVITY_24H_US: "scraping/update-activity/24h/us",
-        SCRAPE_FEED_WORLDWIDE: "scraping/feed-worldwide",
-        SCRAPE_FEED_UK: "scraping/feed-uk",
-        SCRAPE_FEED_US: "scraping/feed-us",
-        SCRAPE_JOB: "scraping/job",
-        PROCESS_FEED: "scraping/process-feed",
-        SCRAPE_JOB_ACTIVITY: "scraping/job-activity",
-        USER_PROFILE: "scraping/user-profile",
-        CHECK_LEAD_STATUS: "scraping/check-lead-status",
+        BASE: 'scraping',
+        START_SCRAPING: 'scraping/start',
+        START_WORLDWIDE_SCRAPING: 'scraping/start-worldwide',
+        START_US_SCRAPING: 'scraping/start-us',
+        START_UK_SCRAPING: 'scraping/start-uk',
+        UPDATE_ACTIVITY_4H_WORLDWIDE: 'scraping/update-activity/4h',
+        UPDATE_ACTIVITY_4H_UK: 'scraping/update-activity/4h/uk',
+        UPDATE_ACTIVITY_4H_US: 'scraping/update-activity/4h/us',
+        UPDATE_ACTIVITY_24H_WORLDWIDE: 'scraping/update-activity/24h',
+        UPDATE_ACTIVITY_24H_UK: 'scraping/update-activity/24h/uk',
+        UPDATE_ACTIVITY_24H_US: 'scraping/update-activity/24h/us',
+        SCRAPE_FEED_WORLDWIDE: 'scraping/feed-worldwide',
+        SCRAPE_FEED_UK: 'scraping/feed-uk',
+        SCRAPE_FEED_US: 'scraping/feed-us',
+        SCRAPE_JOB: 'scraping/job',
+        PROCESS_FEED: 'scraping/process-feed',
+        SCRAPE_JOB_ACTIVITY: 'scraping/job-activity',
+        USER_PROFILE: 'scraping/user-profile',
+        CHECK_LEAD_STATUS: 'scraping/check-lead-status',
     },
     ADMIN: {
-        BASE: "admin",
+        BASE: 'admin',
         BIDDER_ACCOUNTS: {
-            BASE: "admin/bidder-accounts",
+            BASE: 'admin/bidder-accounts',
             BY_ID: (id) => `admin/bidder-accounts/${id}`,
             BY_PROVIDER: (provider) => `admin/bidder-accounts/${provider}`,
             BY_PROVIDER_AND_ID: (provider, id) => `admin/bidder-accounts/${provider}/${id}`,
         },
         SCRAPER_ACCOUNTS: {
-            BASE: "admin/scraper-accounts",
+            BASE: 'admin/scraper-accounts',
             BY_ID: (id) => `admin/scraper-accounts/${id}`,
             BY_PROVIDER: (provider) => `admin/scraper-accounts/${provider}`,
             BY_PROVIDER_AND_ID: (provider, id) => `admin/scraper-accounts/${provider}/${id}`,
+            REFRESH_ROTATING_PROXIES: (provider) => `admin/scraper-accounts/${provider}/refresh-rotating-proxies`,
         },
         PROXIES: {
-            BASE: "admin/proxies",
+            BASE: 'admin/proxies',
             BY_ID: (id) => `admin/proxies/${id}`,
             REPLACE_PROXY: (id) => `admin/proxies/${id}/replace`,
-            SYNC: "admin/proxies/sync",
-            AVAILABLE_REPLACEMENTS: "admin/proxies/available-replacements",
-            AVAILABLE_COUNTRIES: "admin/proxies/available-countries",
+            SYNC: 'admin/proxies/sync',
+            AVAILABLE_REPLACEMENTS: 'admin/proxies/available-replacements',
+            AVAILABLE_COUNTRIES: 'admin/proxies/available-countries',
         },
         DASHBOARD: {
-            CAMPAIGN_STATS: "admin/dashboard/campaign-stats",
+            CAMPAIGN_STATS: 'admin/dashboard/campaign-stats',
         },
         ALERTS: {
-            BASE: "admin/alerts",
-            SEND_ALERT: "admin/alerts/send",
+            BASE: 'admin/alerts',
+            SEND_ALERT: 'admin/alerts/send',
         },
         AGENT: {
-            BASE: "admin/agent",
-            TEST_JOB_QUALITY: "admin/agent/test-job-quality",
-            TEST_SUITABILITY: "admin/agent/test-suitability",
-            TEST_PROPOSAL: "admin/agent/test-proposal",
+            BASE: 'admin/agent',
+            TEST_JOB_QUALITY: 'admin/agent/test-job-quality',
+            TEST_SUITABILITY: 'admin/agent/test-suitability',
+            TEST_PROPOSAL: 'admin/agent/test-proposal',
         },
     },
     BID: {
-        BASE: "bid",
+        BASE: 'bid',
         BID_ON_JOB: (userId, campaignId, leadId) => `bid/${userId}/${campaignId}/${leadId}`,
     },
     BIDDER_ACCOUNTS: {
-        BASE: "bidder-accounts",
+        BASE: 'bidder-accounts',
         BY_ID: (id) => `bidder-accounts/${id}`,
     },
     ORGANIZATIONS: {
-        BASE: "organizations",
+        BASE: 'organizations',
         BY_ID: (id) => `organizations/${id}`,
         ONBOARDING: {
             BASE: (id) => `organizations/${id}/onboarding`,
@@ -6570,8 +6571,8 @@ const ROUTES = {
                 BY_PLATFORM: (organizationId, campaignId, platform) => `organizations/${organizationId}/campaigns/${campaignId}/chat-bots/${platform}`,
                 OAUTH_URL: (organizationId, campaignId, platform) => `organizations/${organizationId}/campaigns/${campaignId}/chat-bots/${platform}/oauth-url`,
                 CALLBACK: (platform) => `chat-bots/${platform}/callback`,
-                SEND_NOTIFICATION: () => "chat-bots/send-notification",
-                REMOVE_SUITABLE_LEAD_MESSAGE_BUTTONS: () => "chat-bots/remove-suitable-lead-message-buttons",
+                SEND_NOTIFICATION: () => 'chat-bots/send-notification',
+                REMOVE_SUITABLE_LEAD_MESSAGE_BUTTONS: () => 'chat-bots/remove-suitable-lead-message-buttons',
             },
             ACTIVITIES: {
                 BASE: (organizationId, campaignId) => `organizations/${organizationId}/campaigns/${campaignId}/activities`,
@@ -6582,26 +6583,26 @@ const ROUTES = {
         USAGE_SUMMARIES: {
             DAILY: {
                 BASE: (organizationId) => `usage-summaries/${organizationId}/daily`,
-                BY_DATE: (organizationId, date) => `usage-summaries/${organizationId}/daily/${moment(date).format("YYYY-MM-DD")}`,
+                BY_DATE: (organizationId, date) => `usage-summaries/${organizationId}/daily/${moment(date).format('YYYY-MM-DD')}`,
             },
             WEEKLY: {
                 BASE: (organizationId) => `usage-summaries/${organizationId}/weekly`,
-                BY_DATE: (organizationId, date) => `usage-summaries/${organizationId}/weekly/${moment(date).format("YYYY-WW")}`,
+                BY_DATE: (organizationId, date) => `usage-summaries/${organizationId}/weekly/${moment(date).format('YYYY-WW')}`,
             },
             MONTHLY: {
                 BASE: (organizationId) => `usage-summaries/${organizationId}/monthly`,
-                BY_DATE: (organizationId, date) => `usage-summaries/${organizationId}/monthly/${moment(date).format("YYYY-MM")}`,
+                BY_DATE: (organizationId, date) => `usage-summaries/${organizationId}/monthly/${moment(date).format('YYYY-MM')}`,
             },
             QUARTERLY: {
                 BASE: (organizationId) => `usage-summaries/${organizationId}/quarterly`,
                 BY_DATE: (organizationId, date) => {
                     const parsed = moment(date);
-                    return `usage-summaries/${organizationId}/quarterly/${parsed.format("YYYY")}-Q${parsed.quarter()}`;
+                    return `usage-summaries/${organizationId}/quarterly/${parsed.format('YYYY')}-Q${parsed.quarter()}`;
                 },
             },
             YEARLY: {
                 BASE: (organizationId) => `usage-summaries/${organizationId}/yearly`,
-                BY_DATE: (organizationId, date) => `usage-summaries/${organizationId}/yearly/${moment(date).format("YYYY")}`,
+                BY_DATE: (organizationId, date) => `usage-summaries/${organizationId}/yearly/${moment(date).format('YYYY')}`,
             },
         },
         INVOICES: {
@@ -6615,35 +6616,35 @@ const ROUTES = {
         INVOICE_PREVIEW: (id) => `organizations/${id}/invoice-preview`,
     },
     TRANSACTIONS: {
-        BASE: "transactions",
+        BASE: 'transactions',
         BY_ID: (id) => `transactions/${id}`,
     },
     AGENT: {
-        BASE: "agent",
-        SCRAPE_UPWORK_PROFILE: "agent/scrape-upwork-profile",
-        GENERATE_DEFAULT_AI_CONFIG: "agent/generate-ai-config",
-        TEST_JOB_QUALITY: "agent/test-job-quality",
-        TEST_SUITABILITY: "agent/test-suitability",
-        TEST_PROPOSAL: "agent/test-proposal",
-        TEST_SYSTEM_PROMPTS: "agent/test-system-prompts",
-        ANALYZE_LEAD: "agent/analyze-lead",
-        GENERATE_PROPOSAL: "agent/generate-proposal",
-        BID: "agent/bid",
+        BASE: 'agent',
+        SCRAPE_UPWORK_PROFILE: 'agent/scrape-upwork-profile',
+        GENERATE_DEFAULT_AI_CONFIG: 'agent/generate-ai-config',
+        TEST_JOB_QUALITY: 'agent/test-job-quality',
+        TEST_SUITABILITY: 'agent/test-suitability',
+        TEST_PROPOSAL: 'agent/test-proposal',
+        TEST_SYSTEM_PROMPTS: 'agent/test-system-prompts',
+        ANALYZE_LEAD: 'agent/analyze-lead',
+        GENERATE_PROPOSAL: 'agent/generate-proposal',
+        BID: 'agent/bid',
     },
     PLANS: {
-        BASE: "plans",
+        BASE: 'plans',
         BY_ID: (id) => `plans/${id}`,
     },
     NOTIFICATIONS: {
-        BASE: "notifications",
-        SEND_NOTIFICATION: "notifications/send",
+        BASE: 'notifications',
+        SEND_NOTIFICATION: 'notifications/send',
     },
     USAGE_EVENTS: {
-        BASE: "usage-events",
+        BASE: 'usage-events',
         BY_ID: (id) => `usage-events/${id}`,
     },
     BIDDER_INSTANCES: {
-        BASE: "bidder-instances",
+        BASE: 'bidder-instances',
         BY_ID: (id) => `bidder-instances/${id}`,
     },
 };
@@ -6657,7 +6658,7 @@ const buildRoute = (route, params = {}) => {
 };
 // Helper function to get route without admin prefix
 const getRouteWithoutAdminPrefix = (route) => {
-    return route.replace("admin/", "");
+    return route.replace('admin/', '');
 };
 
 const accountStatusOrder = [
@@ -11082,6 +11083,92 @@ const accountStatusSchema = z.enum([
     'invalid_credentials',
 ]);
 
+// Enum definitions for fixed options
+const projectDurationEnum = z.enum(JOB_FILTER_OPTIONS.PROJECT_DURATION);
+const engagementTypeEnum = z.enum(JOB_FILTER_OPTIONS.ENGAGEMENT_TYPE);
+const vendorTypeEnum = z.enum(JOB_FILTER_OPTIONS.VENDOR_TYPE);
+const paymentTypeEnum = z.enum(JOB_FILTER_OPTIONS.PAYMENT_TYPE);
+const categoryEnum = z.enum(JOB_FILTER_OPTIONS.CATEGORIES);
+const clientIndustryEnum = z.enum(JOB_FILTER_OPTIONS.CLIENT_INDUSTRY);
+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 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"]);
+// Main job filters schema
+const jobFiltersSchema = z.object({
+    keywords: z
+        .object({
+        includes: z.string().nullable(),
+        excludes: z.string().nullable(),
+    })
+        .nullable(),
+    isFeatured: z.enum(["all", "true", "false"]).nullable(),
+    regions: z.array(regionEnum).nullable(),
+    categories: z
+        .object({
+        includes: z.array(categoryEnum).nullable(),
+        excludes: z.array(categoryEnum).nullable(),
+    })
+        .nullable(),
+    payment: z
+        .object({
+        paymentType: z.array(paymentTypeEnum).nullable(),
+        minFixedPrice: z.number().nullable(),
+        maxFixedPrice: z.number().nullable(),
+        minHourlyRate: z.number().nullable(),
+        maxHourlyRate: z.number().nullable(),
+    })
+        .nullable(),
+    projectDuration: z.array(projectDurationEnum).nullable(),
+    experienceLevel: z.array(experienceLevelEnum).nullable(),
+    questions: z
+        .object({
+        hasQuestions: arrayType(hasQuestionsEnum),
+    })
+        .nullable(),
+    engagementType: z.array(engagementTypeEnum).nullable(),
+    clientInfo: z
+        .object({
+        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(),
+        minTotalSpent: z.number().nullable(),
+        minHireRate: z.number().min(0).max(100).nullable(),
+        clientIndustry: z.array(clientIndustryEnum).nullable(),
+        companySize: z.array(clientSizeEnum).nullable(),
+        minJobsPosted: z.number().nullable(),
+        minAvgHourlyRate: z.number().nullable(),
+        minNumReviews: z.number().nullable(),
+        memberSinceFrom: z.string().date().nullable(),
+        memberSinceTo: z.string().date().nullable(),
+    })
+        .nullable(),
+    vendorQualifications: z
+        .object({
+        locationIncludes: z.array(z.string()).nullable(),
+        locationExcludes: z.array(z.string()).nullable(),
+        talentTypes: z.array(talentTypeEnum).nullable(),
+        englishLevels: z.array(englishLevelEnum).nullable(),
+        includeRisingTalent: z.string().nullable(),
+        requiredEarnings: requiredEarningsEnum.nullable(),
+        requiredJSS: z.array(requiredJSSEnum).nullable(),
+    })
+        .nullable(),
+});
+
 const proxyCountryEnum = z.enum([
     'US',
     'CA',
@@ -11332,11 +11419,16 @@ const proxyCountryEnum = z.enum([
 ]);
 
 const proxyStatusSchema = z.enum([
-    "invalid",
-    "valid",
-    "pending_validation",
+    'invalid',
+    'valid',
+    'pending_validation',
 ]);
-const proxyProviderSchema = z.enum(["webshare", "decodo"]);
+const proxyProviderSchema = z.enum([
+    'webshare',
+    'decodo',
+    'proxy-cheap',
+]);
+const proxyTypeSchema = z.enum(['rotating', 'static']);
 const proxySchema = z.object({
     id: z.string(),
     externalId: z.string(),
@@ -11350,6 +11442,7 @@ const proxySchema = z.object({
     status: proxyStatusSchema.nullable(),
     country: proxyCountryEnum.nullable(),
     accountId: z.string().nullable(),
+    type: proxyTypeSchema,
 });
 const externalProxySchema = proxySchema.omit({
     id: true,
@@ -11361,6 +11454,113 @@ const externalProxySchema = proxySchema.omit({
 
 const proxyAvailableReplacementsSchema = z.record(proxyProviderSchema, z.number());
 
+const bidderAccountProvider = z.enum([
+    'user-provided',
+    'lancer-provided',
+]);
+const bidderAccountAgencySchema = z.object({
+    name: z.string(),
+    logoUrl: z.string().nullable(),
+    contractors: z.array(z.string()),
+    organizationId: z.string(),
+});
+const bidderAccountSchema = z.object({
+    id: z.string(),
+    provider: bidderAccountProvider,
+    email: z.string().email(),
+    password: z.string(),
+    securityQuestionAnswer: z.string().nullable(),
+    assignedOrganizations: z.array(z.string()),
+    googleOauthTokens: z.any().nullable(),
+    lastUsed: z.number().nullable(),
+    multiLoginProfileId: z.string().nullable(),
+    proxyId: z.string().nullable(),
+    profilePhotoUrl: z.string().nullable(),
+    name: z.string().nullable(),
+    agencies: z.array(bidderAccountAgencySchema).nullable(),
+    instanceId: stringType().nullable(),
+    createdAt: z.number(),
+    updatedAt: z.number(),
+    region: regionEnum,
+    isProtected: z.boolean().optional(),
+});
+const createBidderAccountSchema = bidderAccountSchema
+    .pick({
+    email: true,
+    password: true,
+    provider: true,
+    securityQuestionAnswer: true,
+    profilePhotoUrl: true,
+    name: true,
+    agencies: true,
+    assignedOrganizations: true,
+    region: true,
+})
+    .extend({
+    proxyCountry: proxyCountryEnum.nullable(),
+});
+const updateBidderAccountSchema = bidderAccountSchema
+    .omit({
+    id: true,
+})
+    .partial();
+const verifyBidderAccountCredentialsSchema = z.object({
+    email: z.string().email(),
+    password: z.string(),
+    securityQuestionAnswer: z.string(),
+    multiloginProfileId: z.string(),
+    proxy: proxySchema,
+});
+const verifyBidderAccountCredentialsResponseSchema = z.object({
+    accountName: z.string().nullable(),
+    accountPhotoUrl: z.string().nullable(),
+    agencies: z.array(bidderAccountAgencySchema).nullable(),
+});
+const acceptUpworkInvitationSchema = z.object({
+    code: z.string(),
+});
+const acceptUpworkInvitationResponseSchema = z.object({
+    agencyName: z.string(),
+    photoUrl: z.string(),
+    contractors: z.array(z.string()),
+});
+
+class BidderAccountAlreadyConnectedException extends Error {
+    code = 'BIDDER_ACCOUNT_ALREADY_CONNECTED';
+    email;
+    constructor(email) {
+        super(`Bidder account ${email} is already connected to a scraper account`);
+        this.email = email;
+    }
+}
+const bidderAccountAlreadyConnectedException = (email) => new BidderAccountAlreadyConnectedException(email);
+
+class InvalidGoogleOAuthTokenException extends Error {
+    code = 'INVALID_GOOGLE_OAUTH_TOKEN';
+    constructor(message) {
+        super(message);
+    }
+}
+const invalidGoogleOAuthTokenSchema = (message) => new InvalidGoogleOAuthTokenException(message);
+
+class NoBidderAccountsAvailableException extends Error {
+    code = 'NO_BIDDER_ACCOUNTS_AVAILABLE';
+    constructor(message) {
+        super(message);
+    }
+}
+const noBidderAccountsAvailableException = (message) => {
+    return new NoBidderAccountsAvailableException(message);
+};
+
+class NoGoogleOAuthTokensFoundException extends Error {
+    code = 'NO_GOOGLE_OAUTH_TOKENS_FOUND';
+    constructor(message) {
+        super(message);
+    }
+}
+const noGoogleOAuthTokensFoundException = (message) => new NoGoogleOAuthTokensFoundException(message);
+
 const booleanSchema = z
     .union([z.boolean(), z.literal("true"), z.literal("false")])
     .transform((value) => value === true || value === "true");
@@ -11380,7 +11580,7 @@ const regionSchema = z.union([
     z.literal("Worldwide"),
 ]);
 
-const segmentationDataSchema = objectType({
+const segmentationDataSchema$1 = objectType({
     customValue: stringType().nullable(),
     label: stringType(),
     name: stringType(),
@@ -11389,7 +11589,7 @@ const segmentationDataSchema = objectType({
     value: stringType(),
     skill: anyType().nullable(),
 });
-const clientActivitySchema = objectType({
+const clientActivitySchema$1 = objectType({
     lastBuyerActivity: stringType(),
     totalApplicants: numberType(),
     totalHired: numberType(),
@@ -11398,23 +11598,23 @@ const clientActivitySchema = objectType({
     invitationsSent: numberType(),
     numberOfPositionsToHire: numberType(),
 });
-const annotationsSchema = objectType({
+const annotationsSchema$1 = objectType({
     tags: arrayType(stringType()),
 });
-const budgetSchema = objectType({
+const budgetSchema$1 = objectType({
     amount: numberType(),
     currencyCode: stringType(),
 });
-const engagementDurationSchema = objectType({
+const engagementDurationSchema$1 = objectType({
     label: stringType(),
     weeks: numberType(),
 });
-const extendedBudgetInfoSchema = objectType({
+const extendedBudgetInfoSchema$1 = objectType({
     hourlyBudgetMin: numberType().nullable(),
     hourlyBudgetMax: numberType().nullable(),
     hourlyBudgetType: stringType().nullable(),
 });
-const qualificationsSchema = objectType({
+const qualificationsSchema$1 = objectType({
     countries: anyType().nullable(),
     earnings: anyType().nullable(),
     groupRecno: anyType().nullable(),
@@ -11448,20 +11648,20 @@ const jobSchema = objectType({
         name: stringType(),
         urlSlug: stringType(),
     }),
-    budget: budgetSchema,
+    budget: budgetSchema$1,
     postedOn: stringType(),
     publishTime: stringType(),
     wasRenewed: booleanType(),
     startDate: stringType().nullable(),
     deliveryDate: stringType().nullable(),
     workload: stringType().nullable(),
-    engagementDuration: engagementDurationSchema,
-    extendedBudgetInfo: extendedBudgetInfoSchema,
+    engagementDuration: engagementDurationSchema$1,
+    extendedBudgetInfo: extendedBudgetInfoSchema$1,
     contractorTier: numberType(),
     description: stringType(),
-    segmentationData: arrayType(segmentationDataSchema),
-    clientActivity: clientActivitySchema,
-    annotations: annotationsSchema,
+    segmentationData: arrayType(segmentationDataSchema$1),
+    clientActivity: clientActivitySchema$1,
+    annotations: annotationsSchema$1,
     uid: stringType(),
     title: stringType(),
     type: numberType(),
@@ -11476,12 +11676,12 @@ const jobSchema = objectType({
     isContractToHire: booleanType(),
     attachments: arrayType(anyType()),
     isPremium: booleanType(),
-    qualifications: qualificationsSchema,
+    qualifications: qualificationsSchema$1,
     questions: arrayType(objectType({ question: stringType(), position: numberType() })),
     durationIdV3: numberType(),
     durationLabel: stringType(),
 });
-const buyerSchema = objectType({
+const buyerSchema$1 = objectType({
     isEnterprise: booleanType(),
     isPaymentMethodVerified: booleanType(),
     stats: objectType({
@@ -11518,7 +11718,7 @@ const buyerSchema = objectType({
         amount: numberType(),
     }).nullable(),
 });
-const currentUserInfoSchema = objectType({
+const currentUserInfoSchema$1 = objectType({
     owner: booleanType(),
     freelancerInfo: objectType({
         profileState: stringType(),
@@ -11581,7 +11781,7 @@ const workHistorySchema = arrayType(objectType({
     }),
     isEDCPublic: booleanType(),
 }));
-const sandsSchema = objectType({
+const sandsSchema$1 = objectType({
     occupation: objectType({
         freeText: stringType().nullable(),
         ontologyId: stringType(),
@@ -11609,7 +11809,7 @@ const connectsSchema = objectType({
     }),
     canSeeApplicantsRates: booleanType(),
 });
-const authSchema = objectType({
+const authSchema$1 = objectType({
     canFlagOpening: booleanType(),
     canPostJob: booleanType(),
     domestic: objectType({
@@ -11631,14 +11831,14 @@ const applicationContextSchema = objectType({
 const nuxtStateJobSchema = objectType({
     cache: booleanType(),
     job: jobSchema,
-    buyer: buyerSchema,
-    currentUserInfo: currentUserInfoSchema,
+    buyer: buyerSchema$1,
+    currentUserInfo: currentUserInfoSchema$1,
     isVisitor: booleanType(),
     openJobs: arrayType(anyType()),
     workHistory: workHistorySchema,
     similarJobs: arrayType(anyType()),
-    sands: sandsSchema,
-    auth: authSchema,
+    sands: sandsSchema$1,
+    auth: authSchema$1,
     applicants: objectType({
         applicantsBidsStats: anyType().nullable(),
     }),
@@ -11652,119 +11852,599 @@ const nuxtStateJobSchema = objectType({
         url: stringType(),
     }),
     teamUid: anyType().nullable(),
-    proposalPermissions: objectType({
-        freelancerAllowed: booleanType(),
-        clientAllowed: booleanType(),
-    }),
+    proposalPermissions: objectType({
+        freelancerAllowed: booleanType(),
+        clientAllowed: booleanType(),
+    }),
+    jobSlug: anyType().nullable(),
+    prefillWith: anyType().nullable(),
+    isGroupOpportunity: booleanType(),
+    workLocation: anyType().nullable(),
+    isPhoneVerified: booleanType(),
+    errorResponse: anyType().nullable(),
+    isApplyBlocked: booleanType(),
+    hasAiInterview: booleanType(),
+    talentFeePromotion: booleanType().nullish(),
+});
+
+// Filter Option Schema
+const filterOptionItemSchema = z.object({
+    key: z.string(),
+    count: z.number(),
+});
+// Filter Options Response Schema
+const filterOptionsResponseSchema = z.object({
+    locations: z.array(filterOptionItemSchema),
+    englishLevels: z.array(filterOptionItemSchema),
+    talentTypes: z.array(filterOptionItemSchema),
+    experienceLevels: z.array(filterOptionItemSchema),
+});
+
+const clientSchema = objectType({
+    location: objectType({
+        country: stringType().nullable(),
+    }),
+    isPaymentVerified: booleanType(),
+    totalSpent: stringType().nullable(),
+    totalReviews: numberType(),
+    totalFeedback: numberType(),
+    hasFinancialPrivacy: booleanType(),
+});
+const attrsSchema$1 = objectType({
+    uid: stringType(),
+    parentSkillUid: stringType().nullable(),
+    prefLabel: stringType(),
+    prettyName: stringType(),
+    freeText: anyType().nullable(),
+    highlighted: booleanType(),
+});
+const amountSchema = objectType({
+    amount: numberType(),
+});
+const hourlyBudgetSchema$1 = objectType({
+    min: numberType(),
+    max: numberType(),
+});
+const feedJobSchemaV2 = objectType({
+    uid: stringType(),
+    ciphertext: stringType(),
+    title: stringType(),
+    description: stringType(),
+    createdOn: stringType(),
+    publishedOn: stringType(),
+    renewedOn: stringType().nullable(),
+    type: numberType(),
+    durationLabel: stringType().nullable(), // <--- FIX IS HERE
+    engagement: stringType().nullable(),
+    amount: amountSchema,
+    connectPrice: numberType().nullable(),
+    client: clientSchema,
+    clientRelation: anyType().nullable(),
+    freelancersToHire: numberType(),
+    relevanceEncoded: stringType(),
+    enterpriseJob: booleanType(),
+    tierText: stringType(),
+    isApplied: booleanType(),
+    proposalsTier: stringType().nullable(),
+    premium: booleanType(),
+    attrs: arrayType(attrsSchema$1),
+    hourlyBudget: hourlyBudgetSchema$1,
+    weeklyBudget: amountSchema,
+    isSTSVectorSearchResult: booleanType(),
+});
+const pagingSchema = objectType({
+    total: numberType(),
+    offset: numberType(),
+    count: numberType(),
+});
+const jobsSearchSchema = objectType({
+    status: objectType({
+        loading: booleanType(),
+        loaded: booleanType(),
+        failed: booleanType(),
+    }),
+    jobs: arrayType(feedJobSchemaV2),
+    paging: pagingSchema,
+    abortController: anyType().nullable(),
+    currentPage: numberType(),
+    jobsPerPage: numberType(),
+    searchQueryCache: recordType(stringType()),
+});
+const nuxtStateJobsSearchSchema = objectType({
+    state: objectType({
+        jobsSearch: jobsSearchSchema,
+    }),
+});
+
+// Field mapping from feed-job to job-details for the missing fields that were added
+const FEED_JOB_TO_JOB_DETAILS_FIELD_MAPPING = {
+    // Fields that were missing in job-details and added from feed-job
+    publishedOn: 'publishedOn',
+    renewedOn: 'renewedOn',
+    engagement: 'engagement',
+    freelancersToHire: 'freelancersToHire',
+    connectPrice: 'connectPrice',
+    clientRelation: 'clientRelation',
+    relevanceEncoded: 'relevanceEncoded',
+    enterpriseJob: 'enterpriseJob',
+    tierText: 'tierText',
+    isApplied: 'isApplied',
+    proposalsTier: 'proposalsTier',
+    premium: 'premium',
+    attrs: 'attrs',
+    hourlyBudget: 'hourlyBudget',
+    weeklyBudget: 'weeklyBudget',
+    isSTSVectorSearchResult: 'isSTSVectorSearchResult',
+};
+// Segmentation data schema
+const segmentationDataSchema = objectType({
+    customValue: stringType().nullable(),
+    label: stringType(),
+    name: stringType(),
+    sortOrder: numberType(),
+    type: stringType(),
+    value: stringType(),
+    skill: anyType().nullable(),
+});
+// Client activity schema
+const clientActivitySchema = objectType({
+    lastBuyerActivity: stringType().nullable(),
+    totalApplicants: numberType().nullable(),
+    totalHired: numberType().nullable(),
+    totalInvitedToInterview: numberType().nullable(),
+    unansweredInvites: numberType().nullable(),
+    invitationsSent: numberType().nullable(),
+    numberOfPositionsToHire: numberType(),
+});
+// Annotations schema
+const annotationsSchema = objectType({
+    tags: arrayType(stringType()),
+});
+// Budget schema
+const budgetSchema = objectType({
+    amount: numberType(),
+    currencyCode: stringType(),
+});
+// Engagement duration schema
+const engagementDurationSchema = objectType({
+    label: stringType(),
+    weeks: numberType(),
+});
+// Extended budget info schema
+const extendedBudgetInfoSchema = objectType({
+    hourlyBudgetMin: numberType().nullable(),
+    hourlyBudgetMax: numberType().nullable(),
+    hourlyBudgetType: stringType().nullable(),
+});
+// Qualifications schema
+const qualificationsSchema = objectType({
+    countries: anyType().nullable(),
+    earnings: anyType().nullable(),
+    groupRecno: anyType().nullable(),
+    languages: anyType().nullable(),
+    localDescription: anyType().nullable(),
+    localFlexibilityDescription: anyType().nullable(),
+    localMarket: booleanType(),
+    minJobSuccessScore: numberType(),
+    minOdeskHours: numberType(),
+    onSiteType: anyType().nullable(),
+    prefEnglishSkill: numberType(),
+    regions: anyType().nullable(),
+    risingTalent: booleanType(),
+    shouldHavePortfolio: booleanType(),
+    states: anyType().nullable(),
+    tests: anyType().nullable(),
+    timezones: anyType().nullable(),
+    type: numberType(),
+    locationCheckRequired: booleanType(),
+    group: anyType().nullable(),
+    location: anyType().nullable(),
+    locations: anyType().nullable(),
+    minHoursWeek: numberType().nullable(),
+});
+// Attrs schema (from feed-job.ts)
+const attrsSchema = objectType({
+    uid: stringType(),
+    parentSkillUid: stringType().nullable(),
+    prefLabel: stringType(),
+    prettyName: stringType(),
+    freeText: anyType().nullable(),
+    highlighted: booleanType(),
+});
+// Hourly budget schema (from feed-job.ts)
+const hourlyBudgetSchema = objectType({
+    min: numberType(),
+    max: numberType(),
+});
+// Job details schema
+const jobDetailsSchema = objectType({
+    status: numberType(),
+    category: objectType({
+        name: stringType(),
+        urlSlug: stringType(),
+    }),
+    categoryGroup: objectType({
+        name: stringType(),
+        urlSlug: stringType(),
+    }),
+    budget: budgetSchema,
+    postedOn: stringType(),
+    publishTime: stringType(),
+    publishedOn: stringType().nullable().optional(),
+    wasRenewed: booleanType(),
+    renewedOn: stringType().nullable().optional(),
+    startDate: stringType().nullable(),
+    deliveryDate: stringType().nullable(),
+    workload: stringType().nullable(),
+    engagement: stringType().nullable().optional(),
+    engagementDuration: engagementDurationSchema,
+    extendedBudgetInfo: extendedBudgetInfoSchema,
+    contractorTier: numberType(),
+    description: stringType(),
+    segmentationData: arrayType(segmentationDataSchema),
+    clientActivity: clientActivitySchema,
+    annotations: annotationsSchema,
+    uid: stringType(),
+    title: stringType(),
+    type: numberType(),
+    ciphertext: stringType(),
+    access: numberType(),
+    createdOn: stringType(),
+    hideBudget: booleanType(),
+    notSureProjectDuration: booleanType(),
+    notSureFreelancersToHire: booleanType(),
+    notSureExperienceLevel: booleanType(),
+    numberOfPositionsToHire: numberType(),
+    freelancersToHire: numberType().nullable().optional(),
+    isContractToHire: booleanType(),
+    deliverables: stringType().nullable(),
+    deadline: stringType().nullable(),
+    tools: arrayType(anyType()),
+    weeklyRetainerBudget: anyType().nullable(),
+    qualifications: qualificationsSchema,
+    durationIdV3: numberType(),
+    durationLabel: stringType(),
+    connectPrice: numberType().nullable().optional(),
+    clientRelation: anyType().nullable().optional(),
+    relevanceEncoded: stringType().nullable().optional(),
+    enterpriseJob: booleanType().nullable().optional(),
+    tierText: stringType().nullable().optional(),
+    isApplied: booleanType().nullable().optional(),
+    proposalsTier: stringType().nullable().optional(),
+    premium: booleanType().nullable().optional(),
+    attrs: arrayType(attrsSchema).nullable().optional(),
+    hourlyBudget: hourlyBudgetSchema.nullable().optional(),
+    weeklyBudget: objectType({
+        amount: numberType(),
+    })
+        .nullable()
+        .optional(),
+    isSTSVectorSearchResult: booleanType().nullable().optional(),
+});
+// Buyer schema
+const buyerSchema = objectType({
+    isEnterprise: booleanType(),
+    isPaymentMethodVerified: booleanType(),
+    stats: objectType({
+        totalAssignments: numberType().nullable(),
+        activeAssignmentsCount: numberType().nullable(),
+        hoursCount: numberType(),
+        feedbackCount: numberType(),
+        score: numberType().nullable(),
+        totalJobsWithHires: numberType(),
+        totalCharges: objectType({
+            amount: numberType(),
+        }).nullable(),
+    }),
+    location: objectType({
+        offsetFromUtcMillis: numberType(),
+        countryTimezone: stringType(),
+        city: stringType().nullable(),
+        country: stringType(),
+    }),
+    company: objectType({
+        isEDCReplicated: anyType().nullable(),
+        contractDate: stringType().nullable(),
+        profile: objectType({
+            industry: stringType().nullable(),
+            size: anyType().nullable(), // Can be string or number
+        }),
+    }),
+    jobs: objectType({
+        postedCount: numberType().nullable(),
+        openCount: numberType(),
+    }),
+    avgHourlyJobsRate: anyType().nullable(),
+});
+// Current user info schema
+const currentUserInfoSchema = objectType({
+    freelancerInfo: objectType({
+        qualificationsMatches: anyType().nullable(),
+    }),
+});
+// Open jobs schema
+const openJobSchema = objectType({
+    id: stringType(),
+    uid: stringType(),
+    isPtcPrivate: booleanType(),
+    ciphertext: stringType(),
+    title: stringType(),
+    type: numberType(),
+    access: numberType().nullable(),
+});
+// Similar jobs skill schema
+const similarJobSkillSchema = objectType({
+    id: stringType().nullable(),
+    prefLabel: stringType(),
+});
+// Similar jobs schema
+const similarJobSchema = objectType({
+    id: stringType().nullable(),
+    ciphertext: stringType(),
+    title: stringType(),
+    description: stringType(),
+    engagement: stringType().nullable(),
+    durationLabel: stringType(),
+    contractorTier: numberType(),
+    type: numberType(),
+    createdOn: stringType(),
+    renewedOn: stringType().nullable(),
+    amount: objectType({
+        amount: numberType(),
+    }),
+    maxAmount: anyType().nullable(),
+    ontologySkills: arrayType(similarJobSkillSchema),
+    hourlyBudgetMin: numberType(),
+    hourlyBudgetMax: numberType(),
+});
+// SANDS (Skills and Services) schema
+const sandsSkillSchema = objectType({
+    uid: stringType(),
+    name: stringType(),
+    isFreeText: booleanType(),
+    relevance: stringType(),
+});
+const sandsSchema = objectType({
+    occupation: objectType({
+        freeText: stringType().nullable(),
+        ontologyId: stringType(),
+        prefLabel: stringType(),
+        id: stringType(),
+        uid: stringType(),
+    }),
+    ontologySkills: arrayType(anyType()),
+    additionalSkills: arrayType(sandsSkillSchema),
+});
+// Auth schema
+const authSchema = objectType({
+    isVisitor: booleanType(),
+    isAgency: booleanType(),
+    isFreelancer: booleanType(),
+    isClient: booleanType(),
+    isUpworkPlusBuyer: booleanType(),
+    domestic: objectType({
+        country: stringType().nullable(),
+        isInfographicTooltipAvailable: booleanType(),
+    }),
+});
+// SEO schema
+const seoSchema = objectType({
+    title: stringType(),
+    description: stringType(),
+    url: stringType(),
+});
+// Main job details state schema
+const jobDetailsStateSchema = objectType({
+    cache: booleanType(),
+    job: jobDetailsSchema,
+    buyer: buyerSchema,
+    currentUserInfo: currentUserInfoSchema,
+    openJobs: arrayType(openJobSchema),
+    workHistory: arrayType(anyType()),
+    similarJobs: arrayType(similarJobSchema),
+    sands: sandsSchema,
+    auth: authSchema,
+    applicants: anyType().nullable(),
+    connects: anyType().nullable(),
+    enterpriseJobAdditionalInfo: recordType(anyType()),
+    applicationContext: anyType().nullable(),
+    profileMatchServiceUid: stringType().nullable(),
+    seo: seoSchema,
+    teamUid: anyType().nullable(),
+    proposalPermissions: anyType().nullable(),
     jobSlug: anyType().nullable(),
     prefillWith: anyType().nullable(),
     isGroupOpportunity: booleanType(),
-    workLocation: anyType().nullable(),
     isPhoneVerified: booleanType(),
     errorResponse: anyType().nullable(),
     isApplyBlocked: booleanType(),
     hasAiInterview: booleanType(),
-    talentFeePromotion: booleanType().nullish(),
-});
-
-// Enum definitions for fixed options
-const projectDurationEnum = z.enum(JOB_FILTER_OPTIONS.PROJECT_DURATION);
-const engagementTypeEnum = z.enum(JOB_FILTER_OPTIONS.ENGAGEMENT_TYPE);
-const vendorTypeEnum = z.enum(JOB_FILTER_OPTIONS.VENDOR_TYPE);
-const paymentTypeEnum = z.enum(JOB_FILTER_OPTIONS.PAYMENT_TYPE);
-const categoryEnum = z.enum(JOB_FILTER_OPTIONS.CATEGORIES);
-const clientIndustryEnum = z.enum(JOB_FILTER_OPTIONS.CLIENT_INDUSTRY);
-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 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"]);
-// Main job filters schema
-const jobFiltersSchema = z.object({
-    keywords: z
-        .object({
-        includes: z.string().nullable(),
-        excludes: z.string().nullable(),
-    })
-        .nullable(),
-    isFeatured: z.enum(["all", "true", "false"]).nullable(),
-    regions: z.array(regionEnum).nullable(),
-    categories: z
-        .object({
-        includes: z.array(categoryEnum).nullable(),
-        excludes: z.array(categoryEnum).nullable(),
-    })
-        .nullable(),
-    payment: z
-        .object({
-        paymentType: z.array(paymentTypeEnum).nullable(),
-        minFixedPrice: z.number().nullable(),
-        maxFixedPrice: z.number().nullable(),
-        minHourlyRate: z.number().nullable(),
-        maxHourlyRate: z.number().nullable(),
-    })
-        .nullable(),
-    projectDuration: z.array(projectDurationEnum).nullable(),
-    experienceLevel: z.array(experienceLevelEnum).nullable(),
-    questions: z
-        .object({
-        hasQuestions: arrayType(hasQuestionsEnum),
-    })
-        .nullable(),
-    engagementType: z.array(engagementTypeEnum).nullable(),
-    clientInfo: z
-        .object({
-        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(),
-        minTotalSpent: z.number().nullable(),
-        minHireRate: z.number().min(0).max(100).nullable(),
-        clientIndustry: z.array(clientIndustryEnum).nullable(),
-        companySize: z.array(clientSizeEnum).nullable(),
-        minJobsPosted: z.number().nullable(),
-        minAvgHourlyRate: z.number().nullable(),
-        minNumReviews: z.number().nullable(),
-        memberSinceFrom: z.string().date().nullable(),
-        memberSinceTo: z.string().date().nullable(),
-    })
-        .nullable(),
-    vendorQualifications: z
-        .object({
-        locationIncludes: z.array(z.string()).nullable(),
-        locationExcludes: z.array(z.string()).nullable(),
-        talentTypes: z.array(talentTypeEnum).nullable(),
-        englishLevels: z.array(englishLevelEnum).nullable(),
-        includeRisingTalent: z.string().nullable(),
-        requiredEarnings: requiredEarningsEnum.nullable(),
-        requiredJSS: z.array(requiredJSSEnum).nullable(),
-    })
-        .nullable(),
+    talentFeePromotion: anyType().nullable(),
+    aiInterviewRoomId: anyType().nullable(),
+    aiInterviewLinkSent: booleanType(),
+    aiInterviewStatus: anyType().nullable(),
+    aiInterviewJoinLimitReached: booleanType(),
+});
+const nuxtStateJobDetailsSchema = objectType({
+    layout: stringType(),
+    data: arrayType(recordType(anyType())),
+    fetch: recordType(anyType()),
+    error: anyType().nullable(),
+    state: objectType({
+        job: objectType({
+            errorResponse: anyType().nullable(),
+            channel: anyType().nullable(),
+            visitedJobs: arrayType(anyType()),
+        }),
+        qt: objectType({
+            isNewVisitorNavV1Enabled: booleanType(),
+        }),
+        tracker: objectType({
+            guids: recordType(anyType()),
+        }),
+        tracing: objectType({
+            native: objectType({
+                span: objectType({
+                    id: stringType(),
+                    parentId: stringType(),
+                    traceId: stringType(),
+                    isPopulated: booleanType(),
+                    geoIpHeader: stringType(),
+                }),
+            }),
+        }),
+        context: objectType({
+            loaded: booleanType(),
+            loading: booleanType(),
+            error: anyType().nullable(),
+            isLoggedIn: booleanType().nullable(),
+            auth: booleanType(),
+        }),
+        orgs: objectType({
+            current: objectType({
+                id: stringType().nullable(),
+                rid: stringType().nullable(),
+                type: stringType().nullable(),
+                legacyType: stringType().nullable(),
+                enterpriseType: stringType().nullable(),
+                title: stringType().nullable(),
+                typeTitle: stringType().nullable(),
+                photoUrl: stringType().nullable(),
+                flag: objectType({
+                    client: booleanType().nullable(),
+                    vendor: booleanType().nullable(),
+                    agency: booleanType().nullable(),
+                    individual: booleanType().nullable(),
+                }),
+                portrait100: stringType().nullable(),
+            }),
+            orgs: arrayType(anyType()),
+            loading: booleanType().nullable(),
+            loaded: booleanType().nullable(),
+        }),
+        user: objectType({
+            id: stringType().nullable(),
+            rid: stringType().nullable(),
+            nid: stringType().nullable(),
+            loading: booleanType().nullable(),
+            loaded: booleanType().nullable(),
+            isSudo: booleanType().nullable(),
+        }),
+        visitor: objectType({
+            id: stringType(),
+            ip: stringType(),
+        }),
+        vpn: objectType({
+            isVpn: booleanType(),
+            loading: booleanType(),
+            loaded: booleanType(),
+            error: anyType().nullable(),
+        }),
+        organizations: objectType({
+            items: arrayType(anyType()),
+        }),
+        currency: objectType({
+            currencyRate: anyType().nullable(),
+            currencyCode: stringType().nullable(),
+            currencyPopupShow: booleanType().nullable(),
+            currencyName: stringType().nullable(),
+            currencySymbol: stringType().nullable(),
+        }),
+        bot: objectType({
+            isBot: booleanType(),
+            loaded: booleanType(),
+        }),
+        flags: objectType({
+            qt: recordType(anyType()),
+            qtAllocationType: recordType(anyType()),
+            ff: recordType(booleanType()),
+            computedName: recordType(anyType()),
+        }),
+        geo: objectType({
+            countryCode: stringType(),
+            promise: anyType().nullable(),
+        }),
+        i18n: objectType({
+            routeParams: recordType(anyType()),
+        }),
+        umq: objectType({
+            width: numberType().nullable(),
+            mobile: booleanType(),
+            desktop: booleanType(),
+            tablet: booleanType(),
+        }),
+        tracking: objectType({
+            location: stringType(),
+            visitorApiKey: stringType().nullable(),
+            loading: booleanType().nullable(),
+            loaded: booleanType().nullable(),
+            promise: anyType().nullable(),
+            error: anyType().nullable(),
+            suit2Enabled: booleanType(),
+            context: objectType({
+                visitor_id: stringType().nullable(),
+                user_uid: stringType().nullable(),
+                user_nid: stringType().nullable(),
+                organization_uid: stringType().nullable(),
+                organization_type_title: stringType().nullable(),
+                user_is_sudo: booleanType().nullable(),
+                is_logged_in: booleanType().nullable(),
+            }),
+        }),
+        theme: objectType({
+            isSystemThemeMode: booleanType().nullable(),
+        }),
+        getfeedback: objectType({
+            disabled: booleanType(),
+            event: anyType().nullable(),
+        }),
+        statsig: objectType({
+            experiments: recordType(objectType({
+                name: stringType(),
+                params: recordType(anyType()),
+            })),
+        }),
+        jobDetails: jobDetailsStateSchema,
+        forter: objectType({
+            core: booleanType(),
+            token: stringType(),
+        }).optional(),
+    }),
+    serverRendered: booleanType(),
+    routePath: stringType(),
+    config: objectType({
+        designSystem: stringType(),
+        _app: objectType({
+            basePath: stringType(),
+            assetsPath: stringType(),
+            cdnURL: stringType(),
+        }),
+    }),
+    isCacheable: booleanType(),
+    __i18n: objectType({
+        langs: recordType(anyType()),
+    }),
+    microAppUtilsOverrides: objectType({
+        userNavOverrides: recordType(anyType()),
+        userSkinnyNavSkinnyOverrides: recordType(anyType()),
+        visitorNavSkinnyOverrides: recordType(anyType()),
+    }),
 });
 
-// Filter Option Schema
-const filterOptionItemSchema = z.object({
-    key: z.string(),
-    count: z.number(),
-});
-// Filter Options Response Schema
-const filterOptionsResponseSchema = z.object({
-    locations: z.array(filterOptionItemSchema),
-    englishLevels: z.array(filterOptionItemSchema),
-    talentTypes: z.array(filterOptionItemSchema),
-    experienceLevels: z.array(filterOptionItemSchema),
-});
+class JobIsPrivateException extends Error {
+    code = 'JOB_IS_PRIVATE';
+    constructor(url) {
+        super(`Job is private: ${url}`);
+    }
+}
+const jobIsPrivateException = (url) => new JobIsPrivateException(url);
+class FailedToParseNuxtJobException extends Error {
+    code = 'FAILED_TO_PARSE_NUXT_JOB';
+    constructor(url) {
+        super(`Failed to parse Nuxt job: ${url}`);
+    }
+}
+const failedToParseNuxtJobException = (message, url) => new FailedToParseNuxtJobException(`${message}: ${url}`);
 
 const jobSkillsSchema = objectType({
     name: stringType(),
@@ -11903,119 +12583,13 @@ const feedJobSchema = objectType({
     region: regionSchema.nullable(),
 });
 
-const bidderAccountProvider = z.enum([
-    "user-provided",
-    "lancer-provided",
-]);
-const bidderAccountAgencySchema = z.object({
-    name: z.string(),
-    logoUrl: z.string().nullable(),
-    contractors: z.array(z.string()),
-    organizationId: z.string(),
-});
-const bidderAccountSchema = z.object({
-    id: z.string(),
-    provider: bidderAccountProvider,
-    email: z.string().email(),
-    password: z.string(),
-    securityQuestionAnswer: z.string().nullable(),
-    assignedOrganizations: z.array(z.string()),
-    googleOauthTokens: z.any().nullable(),
-    lastUsed: z.number().nullable(),
-    multiLoginProfileId: z.string().nullable(),
-    proxyId: z.string().nullable(),
-    profilePhotoUrl: z.string().nullable(),
-    name: z.string().nullable(),
-    agencies: z.array(bidderAccountAgencySchema).nullable(),
-    instanceId: stringType().nullable(),
-    createdAt: z.number(),
-    updatedAt: z.number(),
-    region: regionEnum,
-    isProtected: z.boolean().optional(),
-});
-const createBidderAccountSchema = bidderAccountSchema
-    .pick({
-    email: true,
-    password: true,
-    provider: true,
-    securityQuestionAnswer: true,
-    profilePhotoUrl: true,
-    name: true,
-    agencies: true,
-    assignedOrganizations: true,
-    region: true,
-})
-    .extend({
-    proxyCountry: proxyCountryEnum.nullable(),
-});
-const updateBidderAccountSchema = bidderAccountSchema
-    .omit({
-    id: true,
-})
-    .partial();
-const verifyBidderAccountCredentialsSchema = z.object({
-    email: z.string().email(),
-    password: z.string(),
-    securityQuestionAnswer: z.string(),
-    multiloginProfileId: z.string(),
-    proxy: proxySchema,
-});
-const verifyBidderAccountCredentialsResponseSchema = z.object({
-    accountName: z.string().nullable(),
-    accountPhotoUrl: z.string().nullable(),
-    agencies: z.array(bidderAccountAgencySchema).nullable(),
-});
-const acceptUpworkInvitationSchema = z.object({
-    code: z.string(),
-});
-const acceptUpworkInvitationResponseSchema = z.object({
-    agencyName: z.string(),
-    photoUrl: z.string(),
-    contractors: z.array(z.string()),
-});
-
-class BidderAccountAlreadyConnectedException extends Error {
-    code = 'BIDDER_ACCOUNT_ALREADY_CONNECTED';
-    email;
-    constructor(email) {
-        super(`Bidder account ${email} is already connected to a scraper account`);
-        this.email = email;
-    }
-}
-const bidderAccountAlreadyConnectedException = (email) => new BidderAccountAlreadyConnectedException(email);
-
-class InvalidGoogleOAuthTokenException extends Error {
-    code = 'INVALID_GOOGLE_OAUTH_TOKEN';
-    constructor(message) {
-        super(message);
-    }
-}
-const invalidGoogleOAuthTokenSchema = (message) => new InvalidGoogleOAuthTokenException(message);
-
-class NoBidderAccountsAvailableException extends Error {
-    code = 'NO_BIDDER_ACCOUNTS_AVAILABLE';
-    constructor(message) {
-        super(message);
-    }
-}
-const noBidderAccountsAvailableException = (message) => {
-    return new NoBidderAccountsAvailableException(message);
-};
-
-class NoGoogleOAuthTokensFoundException extends Error {
-    code = 'NO_GOOGLE_OAUTH_TOKENS_FOUND';
-    constructor(message) {
-        super(message);
-    }
-}
-const noGoogleOAuthTokensFoundException = (message) => new NoGoogleOAuthTokensFoundException(message);
-
 const scraperAccountType = z.enum([
-    "feed",
-    "job",
-    "status",
-    "activity",
-    "profile",
+    'feed',
+    'job',
+    'status',
+    'activity',
+    'profile',
+    'unauthenticated',
 ]);
 const scraperAccountSchema = z.object({
     id: z.string(),
@@ -12032,16 +12606,13 @@ const scraperAccountSchema = z.object({
     updatedAt: z.number(),
     isProtected: z.boolean().optional(),
 });
-const createScraperAccountSchema = scraperAccountSchema
-    .pick({
+const createScraperAccountSchema = scraperAccountSchema.pick({
     region: true,
     email: true,
     password: true,
     securityQuestionAnswer: true,
     isActive: true,
-})
-    .extend({
-    proxyCountry: proxyCountryEnum.nullable(),
+    type: true,
 });
 const updateScraperAccountSchema = scraperAccountSchema
     .omit({
@@ -12565,10 +13136,8 @@ const scrapeJobStartedEventMetadata = objectType({
     accountEmail: stringType(),
 });
 const scrapeJobFailedEventMetadata = objectType({
-    listing: feedJobSchema,
+    listing: feedJobSchemaV2,
     region: regionSchema,
-    accountId: stringType(),
-    accountEmail: stringType(),
     error: stringType(),
 });
 const jobActivityScrapedEventMetadata = objectType({
@@ -13863,6 +14432,8 @@ exports.DropdownOptionNotPresentException = DropdownOptionNotPresentException;
 exports.ElementNotClickableException = ElementNotClickableException;
 exports.EvaluateElementException = EvaluateElementException;
 exports.EvaluateFunctionException = EvaluateFunctionException;
+exports.FEED_JOB_TO_JOB_DETAILS_FIELD_MAPPING = FEED_JOB_TO_JOB_DETAILS_FIELD_MAPPING;
+exports.FailedToParseNuxtJobException = FailedToParseNuxtJobException;
 exports.FeedScrapeException = FeedScrapeException;
 exports.GetMultiloginBrowserException = GetMultiloginBrowserException;
 exports.GoToUrlException = GoToUrlException;
@@ -13873,6 +14444,7 @@ exports.InvalidCredentialsException = InvalidCredentialsException;
 exports.InvalidGoogleOAuthTokenException = InvalidGoogleOAuthTokenException;
 exports.InvalidJobUrlException = InvalidJobUrlException;
 exports.JOB_FILTER_OPTIONS = JOB_FILTER_OPTIONS;
+exports.JobIsPrivateException = JobIsPrivateException;
 exports.LogEventTypeEnum = LogEventTypeEnum;
 exports.LoginFailedException = LoginFailedException;
 exports.MultiloginAuthenticationException = MultiloginAuthenticationException;
@@ -13974,7 +14546,9 @@ exports.evaluateFunctionException = evaluateFunctionException;
 exports.eventLoggerPayloadSchema = eventLoggerPayloadSchema;
 exports.experienceLevelEnum = experienceLevelEnum;
 exports.externalProxySchema = externalProxySchema;
+exports.failedToParseNuxtJobException = failedToParseNuxtJobException;
 exports.feedJobSchema = feedJobSchema;
+exports.feedJobSchemaV2 = feedJobSchemaV2;
 exports.feedScrapeCompletedEventMetadata = feedScrapeCompletedEventMetadata;
 exports.feedScrapeException = feedScrapeException;
 exports.feedScrapeStartedEventMetadata = feedScrapeStartedEventMetadata;
@@ -14018,7 +14592,9 @@ exports.jobActivityScrapeFailedEventMetadata = jobActivityScrapeFailedEventMetad
 exports.jobActivityScrapedEventMetadata = jobActivityScrapedEventMetadata;
 exports.jobActivitySnapshotSchema = jobActivitySnapshotSchema;
 exports.jobActivityUpdateSchema = jobActivityUpdateSchema;
+exports.jobDetailsStateSchema = jobDetailsStateSchema;
 exports.jobFiltersSchema = jobFiltersSchema;
+exports.jobIsPrivateException = jobIsPrivateException;
 exports.jobQualityScoreSchema = jobQualityScoreSchema;
 exports.jobSkillsSchema = jobSkillsSchema;
 exports.jobStatusOrder = jobStatusOrder;
@@ -14043,7 +14619,9 @@ exports.noBidderAccountsAvailableException = noBidderAccountsAvailableException;
 exports.noGoogleOAuthTokensFoundException = noGoogleOAuthTokensFoundException;
 exports.noScraperAccountAvailableException = noScraperAccountAvailableException;
 exports.notificationConfigSchema = notificationConfigSchema;
+exports.nuxtStateJobDetailsSchema = nuxtStateJobDetailsSchema;
 exports.nuxtStateJobSchema = nuxtStateJobSchema;
+exports.nuxtStateJobsSearchSchema = nuxtStateJobsSearchSchema;
 exports.onboardingProgressSchema = onboardingProgressSchema;
 exports.openPageException = openPageException;
 exports.organizationCampaignStatsSchema = organizationCampaignStatsSchema;
@@ -14076,6 +14654,7 @@ exports.proxyCountryEnum = proxyCountryEnum;
 exports.proxyProviderSchema = proxyProviderSchema;
 exports.proxySchema = proxySchema;
 exports.proxyStatusSchema = proxyStatusSchema;
+exports.proxyTypeSchema = proxyTypeSchema;
 exports.puppeteerConnectionErrorException = puppeteerConnectionErrorException;
 exports.questionAnswerPairSchema = questionAnswerPairSchema;
 exports.questionPairNotMatchingException = questionPairNotMatchingException;