lancer-shared 1.2.126 → 1.2.128

package/dist/bundle.cjs.js

@@ -11171,475 +11171,6 @@ const jobFiltersSchema = z.object({
         .nullable(),
 });
 
-const proxyCountryEnum = z.enum([
-    'US',
-    'CA',
-    'GB',
-    'AF',
-    'AX',
-    'AL',
-    'DZ',
-    'AS',
-    'AD',
-    'AO',
-    'AI',
-    'AQ',
-    'AG',
-    'AR',
-    'AM',
-    'AW',
-    'AU',
-    'AT',
-    'AZ',
-    'BS',
-    'BH',
-    'BD',
-    'BB',
-    'BY',
-    'BE',
-    'BZ',
-    'BJ',
-    'BM',
-    'BT',
-    'BO',
-    'BA',
-    'BW',
-    'BV',
-    'BR',
-    'IO',
-    'BN',
-    'BG',
-    'BF',
-    'BI',
-    'KH',
-    'CM',
-    'CV',
-    'KY',
-    'CF',
-    'TD',
-    'CL',
-    'CN',
-    'CX',
-    'CC',
-    'CO',
-    'KM',
-    'CG',
-    'CD',
-    'CK',
-    'CR',
-    'CI',
-    'HR',
-    'CU',
-    'CY',
-    'CZ',
-    'DK',
-    'DJ',
-    'DM',
-    'DO',
-    'EC',
-    'EG',
-    'SV',
-    'GQ',
-    'ER',
-    'EE',
-    'ET',
-    'FK',
-    'FO',
-    'FJ',
-    'FI',
-    'FR',
-    'GF',
-    'PF',
-    'TF',
-    'GA',
-    'GM',
-    'GE',
-    'DE',
-    'GH',
-    'GI',
-    'GR',
-    'GL',
-    'GD',
-    'GP',
-    'GU',
-    'GT',
-    'GG',
-    'GN',
-    'GW',
-    'GY',
-    'HT',
-    'HM',
-    'VA',
-    'HN',
-    'HK',
-    'HU',
-    'IS',
-    'IN',
-    'ID',
-    'IR',
-    'IQ',
-    'IE',
-    'IM',
-    'IL',
-    'IT',
-    'JM',
-    'JP',
-    'JE',
-    'JO',
-    'KZ',
-    'KE',
-    'KI',
-    'KP',
-    'KR',
-    'KW',
-    'KG',
-    'LA',
-    'LV',
-    'LB',
-    'LS',
-    'LR',
-    'LY',
-    'LI',
-    'LT',
-    'LU',
-    'MO',
-    'MK',
-    'MG',
-    'MW',
-    'MY',
-    'MV',
-    'ML',
-    'MT',
-    'MH',
-    'MQ',
-    'MR',
-    'MU',
-    'YT',
-    'MX',
-    'FM',
-    'MD',
-    'MC',
-    'MN',
-    'ME',
-    'MS',
-    'MA',
-    'MZ',
-    'MM',
-    'NA',
-    'NR',
-    'NP',
-    'NL',
-    'AN',
-    'NC',
-    'NZ',
-    'NI',
-    'NE',
-    'NG',
-    'NU',
-    'NF',
-    'MP',
-    'NO',
-    'OM',
-    'PK',
-    'PW',
-    'PS',
-    'PA',
-    'PG',
-    'PY',
-    'PE',
-    'PH',
-    'PN',
-    'PL',
-    'PT',
-    'PR',
-    'QA',
-    'RE',
-    'RO',
-    'RU',
-    'RW',
-    'BL',
-    'SH',
-    'KN',
-    'LC',
-    'MF',
-    'PM',
-    'VC',
-    'WS',
-    'SM',
-    'ST',
-    'SA',
-    'SN',
-    'RS',
-    'SC',
-    'SL',
-    'SG',
-    'SK',
-    'SI',
-    'SB',
-    'SO',
-    'ZA',
-    'GS',
-    'ES',
-    'LK',
-    'SD',
-    'SR',
-    'SJ',
-    'SZ',
-    'SE',
-    'CH',
-    'SY',
-    'TW',
-    'TJ',
-    'TZ',
-    'TH',
-    'TL',
-    'TG',
-    'TK',
-    'TO',
-    'TT',
-    'TN',
-    'TR',
-    'TM',
-    'TC',
-    'TV',
-    'UG',
-    'UA',
-    'AE',
-    'UM',
-    'UY',
-    'UZ',
-    'VU',
-    'VE',
-    'VN',
-    'VG',
-    'VI',
-    'WF',
-    'EH',
-    'YE',
-    'ZM',
-    'ZW',
-]);
-
-const proxyStatusSchema = z.enum([
-    'invalid',
-    'valid',
-    'pending_validation',
-]);
-const proxyProviderSchema = z.enum([
-    'webshare',
-    'decodo',
-    'proxy-cheap',
-]);
-const proxyTypeSchema = z.enum(['rotating', 'static']);
-const proxySchema = z.object({
-    id: z.string(),
-    externalId: z.string(),
-    host: z.string(),
-    port: z.number(),
-    username: z.string(),
-    password: z.string(),
-    provider: proxyProviderSchema,
-    fraudScore: z.number().nullable(),
-    claimedCountry: proxyCountryEnum,
-    status: proxyStatusSchema.nullable(),
-    country: proxyCountryEnum.nullable(),
-    accountId: z.string().nullable(),
-    type: proxyTypeSchema,
-});
-const externalProxySchema = proxySchema.omit({
-    id: true,
-    accountId: true,
-    status: true,
-    country: true,
-    fraudScore: true,
-});
-
-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 scraperAccountType = z.enum([
-    'feed',
-    'job',
-    'status',
-    'activity',
-    'profile',
-    'unauthenticated',
-]);
-const scraperAccountRegionEnum = z.enum([
-    'Worldwide',
-    'UKOnly',
-    'USOnly',
-]);
-const scraperAccountSchema = z.object({
-    id: z.string(),
-    isActive: z.boolean(),
-    region: scraperAccountRegionEnum,
-    email: z.string().email(),
-    password: z.string(),
-    securityQuestionAnswer: z.string().nullable(),
-    lastUsed: z.number().nullable(),
-    multiloginProfileId: z.string().nullable(),
-    proxyId: z.string().nullable(),
-    type: scraperAccountType,
-    createdAt: z.number(),
-    updatedAt: z.number(),
-    isProtected: z.boolean().optional(),
-});
-const createScraperAccountSchema = scraperAccountSchema
-    .pick({
-    region: true,
-    email: true,
-    password: true,
-    securityQuestionAnswer: true,
-    isActive: true,
-    type: true,
-})
-    .extend({
-    proxyCountry: proxyCountryEnum.optional(),
-    rotatingProxy: z.boolean().optional(),
-});
-const updateScraperAccountSchema = scraperAccountSchema
-    .omit({
-    id: true,
-})
-    .partial();
-
-const agentStatusSchema = z.enum([
-    "suitabilityPending",
-    "suitabilityProcessing",
-    "suitabilityComplete",
-    "suitabilityFailed",
-    "proposalProcessing",
-    "proposalComplete",
-    "proposalFailed",
-    "biddingProcessing",
-    "biddingComplete",
-    "biddingFailed",
-    "jobArchived",
-]);
-const leadStatusSchema = z.enum([
-    "leads",
-    "contacted",
-    "viewed",
-    "replied",
-    "won",
-]);
-const updateLeadStatusSchema = z.object({
-    leadId: z.string(),
-    organizationId: z.string(),
-    campaignId: z.string(),
-    status: leadStatusSchema,
-    proposalId: z.string().optional(),
-    userId: z.string().optional(),
-    wonAmount: z.number().optional(),
-});
-
 const booleanSchema = z
     .union([z.boolean(), z.literal("true"), z.literal("false")])
     .transform((value) => value === true || value === "true");
@@ -12197,471 +11728,943 @@ const jobDetailsSchema = objectType({
     hourlyBudget: hourlyBudgetSchema.nullable().optional(),
     weeklyBudget: objectType({
         amount: numberType(),
-    })
-        .nullable()
-        .optional(),
-    isSTSVectorSearchResult: booleanType().nullable().optional(),
+    })
+        .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(),
 });
-// 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(),
+// SANDS (Skills and Services) schema
+const sandsSkillSchema = objectType({
+    uid: stringType().nullable(),
+    name: stringType(),
+    isFreeText: booleanType(),
+    relevance: stringType(),
+});
+const sandsSchema = objectType({
+    occupation: objectType({
+        freeText: stringType().nullable(),
+        ontologyId: stringType(),
+        prefLabel: stringType(),
+        id: stringType(),
+        uid: stringType(),
     }),
-    location: objectType({
-        offsetFromUtcMillis: numberType(),
-        countryTimezone: stringType(),
-        city: stringType().nullable(),
-        country: 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: anyType().nullable(),
+        isInfographicTooltipAvailable: booleanType(),
     }),
-    company: objectType({
-        isEDCReplicated: anyType().nullable(),
-        contractDate: stringType().nullable(),
-        profile: objectType({
-            industry: stringType().nullable(),
-            size: anyType().nullable(), // Can be string or number
+});
+// 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(),
+    isPhoneVerified: booleanType(),
+    errorResponse: anyType().nullable(),
+    isApplyBlocked: booleanType(),
+    hasAiInterview: booleanType(),
+    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(),
         }),
     }),
-    jobs: objectType({
-        postedCount: numberType().nullable(),
-        openCount: numberType(),
+    isCacheable: booleanType(),
+    __i18n: objectType({
+        langs: recordType(anyType()),
+    }),
+    microAppUtilsOverrides: objectType({
+        userNavOverrides: recordType(anyType()).optional(),
+        userSkinnyNavSkinnyOverrides: recordType(anyType()).optional(),
+        visitorNavSkinnyOverrides: recordType(anyType()).optional(),
     }),
-    avgHourlyJobsRate: anyType().nullable(),
 });
-// Current user info schema
-const currentUserInfoSchema = objectType({
-    freelancerInfo: objectType({
-        qualificationsMatches: anyType().nullable(),
+
+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(),
+});
+const vendorQualificationSchema = objectType({
+    location: stringType().nullable(),
+    talentType: z.enum(['Agency', 'Independent', 'unspecified']).nullable(),
+    englishLevel: stringType().nullable(),
+    minimumEarnings: numberType().nullable(),
+    jobSuccessScore: stringType().nullable(),
+    includeRisingTalent: stringType().nullable(),
+});
+const clientInfoSchema = objectType({
+    isPaymentVerified: booleanType().nullable(),
+    isPhoneVerified: booleanType().nullable(),
+    numberOfReviews: numberType().nullable(),
+    rating: numberType().nullable(),
+    country: stringType().nullable(),
+    region: stringType().nullable(),
+    jobsPosted: numberType().nullable(),
+    totalSpent: numberType().nullable(),
+    numberOfHires: numberType().nullable(),
+    activeEngagements: numberType().nullable(),
+    openJobs: numberType().nullable(),
+    hireRate: numberType().nullable(),
+    memberSince: stringType().nullable(),
+    companyIndustry: stringType().nullable(),
+    companySize: stringType().nullable(),
+    enterpriseClient: booleanType().nullable(),
+    avgHourlyRatePaid: numberType().nullable(),
+});
+const clientReviewSchema = objectType({
+    jobTitle: stringType().nullable(),
+    freelancerName: stringType().nullable(),
+    freelancerRating: numberType().nullable(),
+    freelancerFeedback: stringType().nullable(),
+    clientFeedback: stringType().nullable(),
+    clientFeedbackRating: numberType().nullable(),
+    dateRange: stringType().nullable(),
+    paymentType: stringType().nullable(),
+    fixedPrice: numberType().nullable(),
+    hourlyRate: numberType().nullable(),
+    numHours: numberType().nullable(),
+    totalBilled: numberType().nullable(),
+});
+const bidRangeSchema = objectType({
+    high: numberType().nullable(),
+    avg: numberType().nullable(),
+    low: numberType().nullable(),
+});
+const jobActivitySchema = objectType({
+    proposals: objectType({
+        min: numberType().nullable(),
+        max: numberType().nullable(),
     }),
+    lastViewedByClient: stringType().nullable(),
+    lastViewedByClientTimestamp: numberType().nullable(),
+    hires: numberType().nullable(),
+    interviewing: numberType().nullable(),
+    invitesSent: numberType().nullable(),
+    unansweredInvites: numberType().nullable(),
+    updatedAt: numberType().nullable(),
 });
-// Open jobs schema
-const openJobSchema = objectType({
-    id: stringType(),
-    uid: stringType(),
-    isPtcPrivate: booleanType(),
-    ciphertext: stringType(),
-    title: stringType(),
-    type: numberType(),
-    access: numberType().nullable(),
+const jobActivityDeltaSchema = objectType({
+    proposals: numberType(),
+    interviewing: numberType(),
+    hires: numberType(),
+    invitesSent: numberType(),
+    unansweredInvites: numberType(),
 });
-// Similar jobs skill schema
-const similarJobSkillSchema = objectType({
-    id: stringType().nullable(),
-    prefLabel: stringType(),
+const metadataSchema = objectType({
+    hours: stringType().nullable(),
+    duration: stringType().nullable(),
+    experienceLevel: stringType().nullable(),
+    hourlyRate: z
+        .object({
+        min: numberType().nullable(),
+        max: numberType().nullable(),
+    })
+        .nullable(),
+    paymentType: stringType().nullable(),
+    fixedPrice: numberType().nullable(),
 });
-// Similar jobs schema
-const similarJobSchema = objectType({
+const jobActivityOffsetHours = [4, 24];
+const jobActivityOffsetEnum = z.enum(jobActivityOffsetHours.map((h) => `${h}h`));
+const upworkJobSchema = 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(),
+    uid: stringType().nullable(),
+    createdAt: numberType().nullable(),
+    title: stringType().nullable(),
+    category: stringType().nullable(),
+    skills: arrayType(jobSkillsSchema).nullable(),
+    datetime: numberType().nullable(),
+    description: stringType().nullable(),
+    descriptionLength: numberType().nullable(),
+    connectsRequired: numberType().nullable(),
+    projectType: stringType().nullable(),
+    projectDuration: stringType().nullable(),
+    questions: arrayType(stringType()).nullable(),
+    jobUrl: stringType().nullable(),
+    metadata: metadataSchema.nullable(),
+    clientInfo: clientInfoSchema.nullable(),
+    vendorQualifications: vendorQualificationSchema.nullable(),
+    processed: booleanType().nullable(),
+    isFeatured: booleanType().nullable(),
+    clientReviews: arrayType(clientReviewSchema).nullable(),
+    region: regionSchema.nullable(),
+    bidRange: bidRangeSchema.nullable(),
+    jobActivity: jobActivitySchema.nullable(),
+    activityUpdates: z
+        .union([z.literal(1), z.literal(2), z.literal(3)])
+        .nullable(),
+    activity: recordType(jobActivityOffsetEnum, jobActivitySchema).nullish(),
+    activityDelta: jobActivityDeltaSchema.nullish(),
+});
+const jobActivityOffsetHourSchema = custom((val) => jobActivityOffsetHours.includes(val));
+const jobActivityUpdateSchema = objectType({
+    jobUrl: stringType(),
+    data: jobActivitySchema,
+    offsetHour: jobActivityOffsetHourSchema,
+    scrapedAt: numberType(),
+});
+const jobActivitySnapshotSchema = objectType({
+    jobUrl: stringType(),
+    activity: jobActivitySchema,
+    postedAt: numberType(),
+    scrapedAt: numberType(),
+    hoursSincePosted: numberType(),
+});
+const feedJobSchema = objectType({
+    uid: stringType().nullable(),
+    title: stringType().nullable(),
+    jobUrl: stringType().nullable(),
+    datetime: stringType().nullable(),
+    isFeatured: booleanType().nullable(),
+    region: regionSchema.nullable(),
+});
+
+const proxyCountryEnum = z.enum([
+    'US',
+    'CA',
+    'GB',
+    'AF',
+    'AX',
+    'AL',
+    'DZ',
+    'AS',
+    'AD',
+    'AO',
+    'AI',
+    'AQ',
+    'AG',
+    'AR',
+    'AM',
+    'AW',
+    'AU',
+    'AT',
+    'AZ',
+    'BS',
+    'BH',
+    'BD',
+    'BB',
+    'BY',
+    'BE',
+    'BZ',
+    'BJ',
+    'BM',
+    'BT',
+    'BO',
+    'BA',
+    'BW',
+    'BV',
+    'BR',
+    'IO',
+    'BN',
+    'BG',
+    'BF',
+    'BI',
+    'KH',
+    'CM',
+    'CV',
+    'KY',
+    'CF',
+    'TD',
+    'CL',
+    'CN',
+    'CX',
+    'CC',
+    'CO',
+    'KM',
+    'CG',
+    'CD',
+    'CK',
+    'CR',
+    'CI',
+    'HR',
+    'CU',
+    'CY',
+    'CZ',
+    'DK',
+    'DJ',
+    'DM',
+    'DO',
+    'EC',
+    'EG',
+    'SV',
+    'GQ',
+    'ER',
+    'EE',
+    'ET',
+    'FK',
+    'FO',
+    'FJ',
+    'FI',
+    'FR',
+    'GF',
+    'PF',
+    'TF',
+    'GA',
+    'GM',
+    'GE',
+    'DE',
+    'GH',
+    'GI',
+    'GR',
+    'GL',
+    'GD',
+    'GP',
+    'GU',
+    'GT',
+    'GG',
+    'GN',
+    'GW',
+    'GY',
+    'HT',
+    'HM',
+    'VA',
+    'HN',
+    'HK',
+    'HU',
+    'IS',
+    'IN',
+    'ID',
+    'IR',
+    'IQ',
+    'IE',
+    'IM',
+    'IL',
+    'IT',
+    'JM',
+    'JP',
+    'JE',
+    'JO',
+    'KZ',
+    'KE',
+    'KI',
+    'KP',
+    'KR',
+    'KW',
+    'KG',
+    'LA',
+    'LV',
+    'LB',
+    'LS',
+    'LR',
+    'LY',
+    'LI',
+    'LT',
+    'LU',
+    'MO',
+    'MK',
+    'MG',
+    'MW',
+    'MY',
+    'MV',
+    'ML',
+    'MT',
+    'MH',
+    'MQ',
+    'MR',
+    'MU',
+    'YT',
+    'MX',
+    'FM',
+    'MD',
+    'MC',
+    'MN',
+    'ME',
+    'MS',
+    'MA',
+    'MZ',
+    'MM',
+    'NA',
+    'NR',
+    'NP',
+    'NL',
+    'AN',
+    'NC',
+    'NZ',
+    'NI',
+    'NE',
+    'NG',
+    'NU',
+    'NF',
+    'MP',
+    'NO',
+    'OM',
+    'PK',
+    'PW',
+    'PS',
+    'PA',
+    'PG',
+    'PY',
+    'PE',
+    'PH',
+    'PN',
+    'PL',
+    'PT',
+    'PR',
+    'QA',
+    'RE',
+    'RO',
+    'RU',
+    'RW',
+    'BL',
+    'SH',
+    'KN',
+    'LC',
+    'MF',
+    'PM',
+    'VC',
+    'WS',
+    'SM',
+    'ST',
+    'SA',
+    'SN',
+    'RS',
+    'SC',
+    'SL',
+    'SG',
+    'SK',
+    'SI',
+    'SB',
+    'SO',
+    'ZA',
+    'GS',
+    'ES',
+    'LK',
+    'SD',
+    'SR',
+    'SJ',
+    'SZ',
+    'SE',
+    'CH',
+    'SY',
+    'TW',
+    'TJ',
+    'TZ',
+    'TH',
+    'TL',
+    'TG',
+    'TK',
+    'TO',
+    'TT',
+    'TN',
+    'TR',
+    'TM',
+    'TC',
+    'TV',
+    'UG',
+    'UA',
+    'AE',
+    'UM',
+    'UY',
+    'UZ',
+    'VU',
+    'VE',
+    'VN',
+    'VG',
+    'VI',
+    'WF',
+    'EH',
+    'YE',
+    'ZM',
+    'ZW',
+]);
+
+const proxyStatusSchema = z.enum([
+    'invalid',
+    'valid',
+    'pending_validation',
+]);
+const proxyProviderSchema = z.enum([
+    'webshare',
+    'decodo',
+    'proxy-cheap',
+]);
+const proxyTypeSchema = z.enum(['rotating', 'static']);
+const proxySchema = z.object({
+    id: z.string(),
+    externalId: z.string(),
+    host: z.string(),
+    port: z.number(),
+    username: z.string(),
+    password: z.string(),
+    provider: proxyProviderSchema,
+    fraudScore: z.number().nullable(),
+    claimedCountry: proxyCountryEnum,
+    status: proxyStatusSchema.nullable(),
+    country: proxyCountryEnum.nullable(),
+    accountId: z.string().nullable(),
+    type: proxyTypeSchema,
 });
-// SANDS (Skills and Services) schema
-const sandsSkillSchema = objectType({
-    uid: stringType().nullable(),
-    name: stringType(),
-    isFreeText: booleanType(),
-    relevance: stringType(),
+const externalProxySchema = proxySchema.omit({
+    id: true,
+    accountId: true,
+    status: true,
+    country: true,
+    fraudScore: true,
 });
-const sandsSchema = objectType({
-    occupation: objectType({
-        freeText: stringType().nullable(),
-        ontologyId: stringType(),
-        prefLabel: stringType(),
-        id: stringType(),
-        uid: stringType(),
-    }),
-    ontologySkills: arrayType(anyType()),
-    additionalSkills: arrayType(sandsSkillSchema),
+const refreshRotatingProxiesRequestBodySchema = z.object({
+    region: regionEnum,
 });
-// Auth schema
-const authSchema = objectType({
-    isVisitor: booleanType(),
-    isAgency: booleanType(),
-    isFreelancer: booleanType(),
-    isClient: booleanType(),
-    isUpworkPlusBuyer: booleanType(),
-    domestic: objectType({
-        country: anyType().nullable(),
-        isInfographicTooltipAvailable: booleanType(),
-    }),
+
+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(),
 });
-// SEO schema
-const seoSchema = objectType({
-    title: stringType(),
-    description: stringType(),
-    url: stringType(),
+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(),
 });
-// 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(),
-    isPhoneVerified: booleanType(),
-    errorResponse: anyType().nullable(),
-    isApplyBlocked: booleanType(),
-    hasAiInterview: booleanType(),
-    talentFeePromotion: anyType().nullable(),
-    aiInterviewRoomId: anyType().nullable(),
-    aiInterviewLinkSent: booleanType(),
-    aiInterviewStatus: anyType().nullable(),
-    aiInterviewJoinLimitReached: booleanType(),
+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 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()).optional(),
-        userSkinnyNavSkinnyOverrides: recordType(anyType()).optional(),
-        visitorNavSkinnyOverrides: recordType(anyType()).optional(),
-    }),
+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 JobIsPrivateException extends Error {
-    code = 'JOB_IS_PRIVATE';
-    constructor(url) {
-        super(`Job is private: ${url}`);
+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 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 bidderAccountAlreadyConnectedException = (email) => new BidderAccountAlreadyConnectedException(email);
+
+class InvalidGoogleOAuthTokenException extends Error {
+    code = 'INVALID_GOOGLE_OAUTH_TOKEN';
+    constructor(message) {
+        super(message);
     }
 }
-const failedToParseNuxtJobException = (message, url) => new FailedToParseNuxtJobException(`${message}: ${url}`);
+const invalidGoogleOAuthTokenSchema = (message) => new InvalidGoogleOAuthTokenException(message);
 
-const jobSkillsSchema = objectType({
-    name: stringType(),
-});
-const vendorQualificationSchema = objectType({
-    location: stringType().nullable(),
-    talentType: z.enum(['Agency', 'Independent', 'unspecified']).nullable(),
-    englishLevel: stringType().nullable(),
-    minimumEarnings: numberType().nullable(),
-    jobSuccessScore: stringType().nullable(),
-    includeRisingTalent: stringType().nullable(),
-});
-const clientInfoSchema = objectType({
-    isPaymentVerified: booleanType().nullable(),
-    isPhoneVerified: booleanType().nullable(),
-    numberOfReviews: numberType().nullable(),
-    rating: numberType().nullable(),
-    country: stringType().nullable(),
-    region: stringType().nullable(),
-    jobsPosted: numberType().nullable(),
-    totalSpent: numberType().nullable(),
-    numberOfHires: numberType().nullable(),
-    activeEngagements: numberType().nullable(),
-    openJobs: numberType().nullable(),
-    hireRate: numberType().nullable(),
-    memberSince: stringType().nullable(),
-    companyIndustry: stringType().nullable(),
-    companySize: stringType().nullable(),
-    enterpriseClient: booleanType().nullable(),
-    avgHourlyRatePaid: numberType().nullable(),
-});
-const clientReviewSchema = objectType({
-    jobTitle: stringType().nullable(),
-    freelancerName: stringType().nullable(),
-    freelancerRating: numberType().nullable(),
-    freelancerFeedback: stringType().nullable(),
-    clientFeedback: stringType().nullable(),
-    clientFeedbackRating: numberType().nullable(),
-    dateRange: stringType().nullable(),
-    paymentType: stringType().nullable(),
-    fixedPrice: numberType().nullable(),
-    hourlyRate: numberType().nullable(),
-    numHours: numberType().nullable(),
-    totalBilled: numberType().nullable(),
-});
-const bidRangeSchema = objectType({
-    high: numberType().nullable(),
-    avg: numberType().nullable(),
-    low: numberType().nullable(),
-});
-const jobActivitySchema = objectType({
-    proposals: objectType({
-        min: numberType().nullable(),
-        max: numberType().nullable(),
-    }),
-    lastViewedByClient: stringType().nullable(),
-    lastViewedByClientTimestamp: numberType().nullable(),
-    hires: numberType().nullable(),
-    interviewing: numberType().nullable(),
-    invitesSent: numberType().nullable(),
-    unansweredInvites: numberType().nullable(),
-    updatedAt: numberType().nullable(),
-});
-const jobActivityDeltaSchema = objectType({
-    proposals: numberType(),
-    interviewing: numberType(),
-    hires: numberType(),
-    invitesSent: numberType(),
-    unansweredInvites: numberType(),
-});
-const metadataSchema = objectType({
-    hours: stringType().nullable(),
-    duration: stringType().nullable(),
-    experienceLevel: stringType().nullable(),
-    hourlyRate: z
-        .object({
-        min: numberType().nullable(),
-        max: numberType().nullable(),
-    })
-        .nullable(),
-    paymentType: stringType().nullable(),
-    fixedPrice: numberType().nullable(),
-});
-const jobActivityOffsetHours = [4, 24];
-const jobActivityOffsetEnum = z.enum(jobActivityOffsetHours.map((h) => `${h}h`));
-const upworkJobSchema = objectType({
-    id: stringType().nullable(),
-    uid: stringType().nullable(),
-    createdAt: numberType().nullable(),
-    title: stringType().nullable(),
-    category: stringType().nullable(),
-    skills: arrayType(jobSkillsSchema).nullable(),
-    datetime: numberType().nullable(),
-    description: stringType().nullable(),
-    descriptionLength: numberType().nullable(),
-    connectsRequired: numberType().nullable(),
-    projectType: stringType().nullable(),
-    projectDuration: stringType().nullable(),
-    questions: arrayType(stringType()).nullable(),
-    jobUrl: stringType().nullable(),
-    metadata: metadataSchema.nullable(),
-    clientInfo: clientInfoSchema.nullable(),
-    vendorQualifications: vendorQualificationSchema.nullable(),
-    processed: booleanType().nullable(),
-    isFeatured: booleanType().nullable(),
-    clientReviews: arrayType(clientReviewSchema).nullable(),
-    region: regionSchema.nullable(),
-    bidRange: bidRangeSchema.nullable(),
-    jobActivity: jobActivitySchema.nullable(),
-    activityUpdates: z
-        .union([z.literal(1), z.literal(2), z.literal(3)])
-        .nullable(),
-    activity: recordType(jobActivityOffsetEnum, jobActivitySchema).nullish(),
-    activityDelta: jobActivityDeltaSchema.nullish(),
-});
-const jobActivityOffsetHourSchema = custom((val) => jobActivityOffsetHours.includes(val));
-const jobActivityUpdateSchema = objectType({
-    jobUrl: stringType(),
-    data: jobActivitySchema,
-    offsetHour: jobActivityOffsetHourSchema,
-    scrapedAt: numberType(),
+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',
+    'unauthenticated',
+]);
+const scraperAccountRegionEnum = z.enum([
+    'Worldwide',
+    'UKOnly',
+    'USOnly',
+]);
+const scraperAccountSchema = z.object({
+    id: z.string(),
+    isActive: z.boolean(),
+    region: scraperAccountRegionEnum,
+    email: z.string().email(),
+    password: z.string(),
+    securityQuestionAnswer: z.string().nullable(),
+    lastUsed: z.number().nullable(),
+    multiloginProfileId: z.string().nullable(),
+    proxyId: z.string().nullable(),
+    type: scraperAccountType,
+    createdAt: z.number(),
+    updatedAt: z.number(),
+    isProtected: z.boolean().optional(),
 });
-const jobActivitySnapshotSchema = objectType({
-    jobUrl: stringType(),
-    activity: jobActivitySchema,
-    postedAt: numberType(),
-    scrapedAt: numberType(),
-    hoursSincePosted: numberType(),
+const createScraperAccountSchema = scraperAccountSchema
+    .pick({
+    region: true,
+    email: true,
+    password: true,
+    securityQuestionAnswer: true,
+    isActive: true,
+    type: true,
+})
+    .extend({
+    proxyCountry: proxyCountryEnum.optional(),
+    rotatingProxy: z.boolean().optional(),
 });
-const feedJobSchema = objectType({
-    uid: stringType().nullable(),
-    title: stringType().nullable(),
-    jobUrl: stringType().nullable(),
-    datetime: stringType().nullable(),
-    isFeatured: booleanType().nullable(),
-    region: regionSchema.nullable(),
+const updateScraperAccountSchema = scraperAccountSchema
+    .omit({
+    id: true,
+})
+    .partial();
+
+const agentStatusSchema = z.enum([
+    "suitabilityPending",
+    "suitabilityProcessing",
+    "suitabilityComplete",
+    "suitabilityFailed",
+    "proposalProcessing",
+    "proposalComplete",
+    "proposalFailed",
+    "biddingProcessing",
+    "biddingComplete",
+    "biddingFailed",
+    "jobArchived",
+]);
+const leadStatusSchema = z.enum([
+    "leads",
+    "contacted",
+    "viewed",
+    "replied",
+    "won",
+]);
+const updateLeadStatusSchema = z.object({
+    leadId: z.string(),
+    organizationId: z.string(),
+    campaignId: z.string(),
+    status: leadStatusSchema,
+    proposalId: z.string().optional(),
+    userId: z.string().optional(),
+    wonAmount: z.number().optional(),
 });
 
 const questionAnswerPairSchema = z.object({
@@ -13558,7 +13561,8 @@ const agentGenerateProposalRequestSchema = z.object({
     organizationId: z.string(),
     campaignId: z.string(),
     job: z.object({
-        id: z.string(),
+        leadId: z.string(),
+        jobId: z.string(),
         title: z.string(),
         description: z.string(),
         questions: z.array(z.string()),
@@ -14736,6 +14740,7 @@ exports.puppeteerConnectionErrorException = puppeteerConnectionErrorException;
 exports.questionAnswerPairSchema = questionAnswerPairSchema;
 exports.questionPairNotMatchingException = questionPairNotMatchingException;
 exports.questionRulesSchema = questionRulesSchema;
+exports.refreshRotatingProxiesRequestBodySchema = refreshRotatingProxiesRequestBodySchema;
 exports.regionEnum = regionEnum;
 exports.regionMapping = regionMapping;
 exports.regionNames = regionNames;