@lssm/lib.contracts-integrations 9.0.1

package/dist/integrations/linkedin/media-job.d.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+export declare const LinkedInMediaJobPlanSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    workspaceId: z.ZodString;
+    accountId: z.ZodString;
+    key: z.ZodString;
+    assetRevisionRef: z.ZodString;
+    assetDigest: z.ZodString;
+    rightsGrantRef: z.ZodString;
+    qualificationRef: z.ZodString;
+    media: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"image">;
+        owner: z.ZodString;
+        bytes: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"video">;
+        owner: z.ZodString;
+        bytes: z.ZodNumber;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export declare const LinkedInMediaJobSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    plan: z.ZodObject<{
+        tenantId: z.ZodString;
+        workspaceId: z.ZodString;
+        accountId: z.ZodString;
+        key: z.ZodString;
+        assetRevisionRef: z.ZodString;
+        assetDigest: z.ZodString;
+        rightsGrantRef: z.ZodString;
+        qualificationRef: z.ZodString;
+        media: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"image">;
+            owner: z.ZodString;
+            bytes: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"video">;
+            owner: z.ZodString;
+            bytes: z.ZodNumber;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>;
+    planDigest: z.ZodString;
+    version: z.ZodNumber;
+    state: z.ZodEnum<{
+        dispatching: "dispatching";
+        expired: "expired";
+        failed: "failed";
+        processing: "processing";
+        ready: "ready";
+        reserved: "reserved";
+        unknown: "unknown";
+        uploading: "uploading";
+    }>;
+    session: z.ZodOptional<z.ZodObject<{
+        reference: z.ZodString;
+        version: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>>;
+    mediaUrn: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodISODateTime>;
+    parts: z.ZodArray<z.ZodObject<{
+        firstByte: z.ZodNumber;
+        lastByte: z.ZodNumber;
+        digest: z.ZodOptional<z.ZodString>;
+        etag: z.ZodOptional<z.ZodString>;
+        evidenceRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    claim: z.ZodOptional<z.ZodObject<{
+        action: z.ZodEnum<{
+            finalize: "finalize";
+            initialize: "initialize";
+            transfer: "transfer";
+        }>;
+        partIndex: z.ZodOptional<z.ZodNumber>;
+        requestDigest: z.ZodString;
+        authorityRef: z.ZodString;
+        submittedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+    nextPollAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type LinkedInMediaJobPlan = z.infer<typeof LinkedInMediaJobPlanSchema>;
+export type LinkedInMediaJob = z.infer<typeof LinkedInMediaJobSchema>;
+export interface LinkedInMediaJobStore {
+    get(tenantId: string, accountId: string, key: string): Promise<LinkedInMediaJob | undefined>;
+    reserve(job: LinkedInMediaJob): Promise<LinkedInMediaJob>;
+    save(job: LinkedInMediaJob, expectedVersion: number): Promise<boolean>;
+}

package/dist/integrations/linkedin/media-job.js

@@ -0,0 +1,2 @@
+// @bun
+import{z as i}from"zod";import{z as r}from"zod";var l=r.string().regex(/^urn:li:(person|organization):[A-Za-z0-9_-]+$/),g=r.discriminatedUnion("kind",[r.strictObject({kind:r.literal("image"),owner:l,bytes:r.number().int().positive().max(20000000)}),r.strictObject({kind:r.literal("video"),owner:l,bytes:r.number().int().positive().max(5000000000)})]);import{z as n}from"zod";var d=n.string().trim().min(1).max(200),u=n.string().regex(/^sha256:[a-f0-9]{64}$/),L=n.strictObject({tenantId:d,workspaceId:d,accountId:d,uploadKey:d,requestDigest:u}),M=n.strictObject({kind:n.enum(["image","video"]),owner:n.string().regex(/^urn:li:(person|organization):[A-Za-z0-9_-]+$/),mediaUrn:d,bytes:n.number().int().positive().max(5000000000),expiresAt:n.iso.datetime(),uploadToken:n.string().max(1e4).optional(),parts:n.array(n.strictObject({firstByte:n.number().int().nonnegative(),lastByte:n.number().int().nonnegative(),uploadUrl:n.string().max(16000)})).min(1).max(2000)}).superRefine((e,m)=>{let t=(s)=>m.addIssue({code:"custom",message:s});if(!new RegExp(`^urn:li:${e.kind}:[A-Za-z0-9_-]+$`).test(e.mediaUrn))t("Media identity mismatch.");if(e.kind==="video"&&e.uploadToken===void 0)t("Video sessions require an upload token.");if(e.kind==="image"&&(e.parts.length!==1||e.uploadToken!==void 0))t("Invalid image session.");let o=0;for(let s of e.parts){if(s.firstByte!==o||s.lastByte<s.firstByte||s.lastByte>=e.bytes)t("Invalid media byte range.");o=s.lastByte+1;try{let p=new URL(s.uploadUrl);if(p.origin!=="https://www.linkedin.com"||!p.pathname.startsWith("/dms-uploads/")||p.username||p.password||p.hash)t("Invalid upload origin.")}catch{t("Invalid upload URL.")}}if(o!==e.bytes)t("Incomplete media byte range.")}),f=n.strictObject({reference:n.string().min(1).max(2000),version:d,digest:u});var a=i.string().trim().min(1).max(200),c=i.string().regex(/^sha256:[a-f0-9]{64}$/),k=i.strictObject({tenantId:a,workspaceId:a,accountId:a,key:a,assetRevisionRef:a,assetDigest:c,rightsGrantRef:a,qualificationRef:a,media:g}),R=i.strictObject({schemaVersion:i.literal(1),plan:k,planDigest:c,version:i.number().int().positive(),state:i.enum(["reserved","dispatching","unknown","uploading","processing","ready","failed","expired"]),session:f.optional(),mediaUrn:a.optional(),expiresAt:i.iso.datetime().optional(),parts:i.array(i.strictObject({firstByte:i.number().int().nonnegative(),lastByte:i.number().int().nonnegative(),digest:c.optional(),etag:i.string().min(1).max(1e4).optional(),evidenceRef:a.optional()})).max(2000),claim:i.strictObject({action:i.enum(["initialize","transfer","finalize"]),partIndex:i.number().int().nonnegative().optional(),requestDigest:c,authorityRef:a,submittedAt:i.iso.datetime()}).optional(),evidenceRefs:i.array(a).max(4000),nextPollAt:i.iso.datetime().optional()}).superRefine((e,m)=>{let t=(o)=>m.addIssue({code:"custom",message:o});if(["dispatching","unknown"].includes(e.state)!==!!e.claim)t("Dispatch claims must remain visible until reconciled.");if(["uploading","processing","ready"].includes(e.state)&&(!e.session||!e.mediaUrn||!e.expiresAt||!e.parts.length))t("Upload session is missing.");if(["processing","ready"].includes(e.state)&&e.parts.some((o)=>!o.evidenceRef))t("Media transfer is incomplete.");if(e.state==="reserved"&&(e.session||e.parts.length||e.claim))t("Reserved job already has effects.")});export{k as LinkedInMediaJobPlanSchema,R as LinkedInMediaJobSchema};

package/dist/integrations/linkedin/media-session.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import type { LinkedInMediaSession } from './media.js';
+export declare const LinkedInMediaSessionScopeSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    workspaceId: z.ZodString;
+    accountId: z.ZodString;
+    uploadKey: z.ZodString;
+    requestDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const LinkedInMediaSessionSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        image: "image";
+        video: "video";
+    }>;
+    owner: z.ZodString;
+    mediaUrn: z.ZodString;
+    bytes: z.ZodNumber;
+    expiresAt: z.ZodISODateTime;
+    uploadToken: z.ZodOptional<z.ZodString>;
+    parts: z.ZodArray<z.ZodObject<{
+        firstByte: z.ZodNumber;
+        lastByte: z.ZodNumber;
+        uploadUrl: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const LinkedInMediaSessionReferenceSchema: z.ZodObject<{
+    reference: z.ZodString;
+    version: z.ZodString;
+    digest: z.ZodString;
+}, z.core.$strict>;
+export type LinkedInMediaSessionScope = z.infer<typeof LinkedInMediaSessionScopeSchema>;
+export type LinkedInMediaSessionReference = z.infer<typeof LinkedInMediaSessionReferenceSchema>;
+/** A reference-only boundary. Implementations bind scope and exact version on every read. */
+export interface LinkedInMediaSessionVault {
+    put(scope: LinkedInMediaSessionScope, session: LinkedInMediaSession): Promise<LinkedInMediaSessionReference>;
+    get(scope: LinkedInMediaSessionScope, reference: LinkedInMediaSessionReference): Promise<LinkedInMediaSession>;
+}

package/dist/integrations/linkedin/media-session.js

@@ -0,0 +1,2 @@
+// @bun
+import{z as e}from"zod";var a=e.string().trim().min(1).max(200),s=e.string().regex(/^sha256:[a-f0-9]{64}$/),p=e.strictObject({tenantId:a,workspaceId:a,accountId:a,uploadKey:a,requestDigest:s}),m=e.strictObject({kind:e.enum(["image","video"]),owner:e.string().regex(/^urn:li:(person|organization):[A-Za-z0-9_-]+$/),mediaUrn:a,bytes:e.number().int().positive().max(5000000000),expiresAt:e.iso.datetime(),uploadToken:e.string().max(1e4).optional(),parts:e.array(e.strictObject({firstByte:e.number().int().nonnegative(),lastByte:e.number().int().nonnegative(),uploadUrl:e.string().max(16000)})).min(1).max(2000)}).superRefine((n,d)=>{let t=(i)=>d.addIssue({code:"custom",message:i});if(!new RegExp(`^urn:li:${n.kind}:[A-Za-z0-9_-]+$`).test(n.mediaUrn))t("Media identity mismatch.");if(n.kind==="video"&&n.uploadToken===void 0)t("Video sessions require an upload token.");if(n.kind==="image"&&(n.parts.length!==1||n.uploadToken!==void 0))t("Invalid image session.");let r=0;for(let i of n.parts){if(i.firstByte!==r||i.lastByte<i.firstByte||i.lastByte>=n.bytes)t("Invalid media byte range.");r=i.lastByte+1;try{let o=new URL(i.uploadUrl);if(o.origin!=="https://www.linkedin.com"||!o.pathname.startsWith("/dms-uploads/")||o.username||o.password||o.hash)t("Invalid upload origin.")}catch{t("Invalid upload URL.")}}if(r!==n.bytes)t("Incomplete media byte range.")}),f=e.strictObject({reference:e.string().min(1).max(2000),version:a,digest:s});export{f as LinkedInMediaSessionReferenceSchema,m as LinkedInMediaSessionSchema,p as LinkedInMediaSessionScopeSchema};

package/dist/integrations/linkedin/media.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import type { LinkedInRequestContext } from './operations.js';
+export declare const LinkedInMediaInitializeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"image">;
+    owner: z.ZodString;
+    bytes: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"video">;
+    owner: z.ZodString;
+    bytes: z.ZodNumber;
+}, z.core.$strict>], "kind">;
+export type LinkedInMediaInitialize = z.infer<typeof LinkedInMediaInitializeSchema>;
+/** Transient private capability material. Store in a secret vault, never job/event payloads or logs. */
+export interface LinkedInMediaSession {
+    kind: 'image' | 'video';
+    owner: string;
+    mediaUrn: string;
+    bytes: number;
+    expiresAt: string;
+    uploadToken?: string;
+    parts: readonly {
+        firstByte: number;
+        lastByte: number;
+        uploadUrl: string;
+    }[];
+}
+export interface LinkedInMediaObservation {
+    mediaUrn: string;
+    owner: string;
+    state: 'waiting' | 'processing' | 'available' | 'failed' | 'unknown';
+}
+export interface LinkedInMediaProvider {
+    initializeMedia(input: LinkedInMediaInitialize, context: LinkedInRequestContext): Promise<LinkedInMediaSession>;
+    finalizeMedia(input: {
+        mediaUrn: string;
+        uploadToken: string;
+        uploadedPartIds: readonly string[];
+    }, context: LinkedInRequestContext): Promise<void>;
+    readMedia(input: {
+        kind: 'image' | 'video';
+        mediaUrn: string;
+        owner: string;
+    }, context: LinkedInRequestContext): Promise<LinkedInMediaObservation>;
+    transferMedia(input: {
+        uploadUrl: string;
+        bytes: Uint8Array;
+        expectedDigest: string;
+    }, context: LinkedInRequestContext): Promise<{
+        etag?: string;
+    }>;
+}

package/dist/integrations/linkedin/media.js

@@ -0,0 +1,2 @@
+// @bun
+import{z as e}from"zod";var i=e.string().regex(/^urn:li:(person|organization):[A-Za-z0-9_-]+$/),t=e.discriminatedUnion("kind",[e.strictObject({kind:e.literal("image"),owner:i,bytes:e.number().int().positive().max(20000000)}),e.strictObject({kind:e.literal("video"),owner:i,bytes:e.number().int().positive().max(5000000000)})]);export{t as LinkedInMediaInitializeSchema};

package/dist/integrations/linkedin/messaging.d.ts

@@ -0,0 +1,70 @@
+import type { LinkedInPage, LinkedInRecordEvidence, LinkedInUrn } from './models.js';
+import type { LinkedInOperationRequestFor, LinkedInOperationResult } from './operations.js';
+export interface LinkedInInvitationInput {
+    recipientUrn: LinkedInUrn;
+    message?: string;
+    recipientEligibilityEvidenceRefId: string;
+    suppressionCheckRefId: string;
+    legalBasisRefId: string;
+}
+export interface LinkedInInvitation {
+    urn: LinkedInUrn;
+    senderUrn: LinkedInUrn;
+    recipientUrn: LinkedInUrn;
+    state: 'pending' | 'accepted' | 'declined' | 'withdrawn' | 'expired';
+    message?: string;
+    sentAt?: string;
+    evidence: LinkedInRecordEvidence;
+}
+export interface LinkedInMessageInput {
+    conversationUrn?: LinkedInUrn;
+    recipientUrns?: readonly LinkedInUrn[];
+    text: string;
+    recipientEligibilityEvidenceRefId: string;
+    suppressionCheckRefId: string;
+    legalBasisRefId: string;
+}
+export interface LinkedInConversation {
+    urn: LinkedInUrn;
+    participantUrns: readonly LinkedInUrn[];
+    lastActivityAt?: string;
+    evidence: LinkedInRecordEvidence;
+}
+export interface LinkedInMessage {
+    urn: LinkedInUrn;
+    conversationUrn: LinkedInUrn;
+    senderUrn: LinkedInUrn;
+    text: string;
+    sentAt: string;
+    evidence: LinkedInRecordEvidence;
+}
+export interface LinkedInMessagingProvider {
+    listInvitations(request: LinkedInOperationRequestFor<'linkedin.network.invitations.list', {
+        start?: number;
+        count?: number;
+    }>): Promise<LinkedInOperationResult<{
+        items: readonly LinkedInInvitation[];
+        page: LinkedInPage;
+    }>>;
+    sendInvitation(request: LinkedInOperationRequestFor<'linkedin.network.invitations.send', LinkedInInvitationInput>): Promise<LinkedInOperationResult<{
+        invitationUrn: LinkedInUrn;
+    }>>;
+    respondToInvitation(request: LinkedInOperationRequestFor<'linkedin.network.invitations.respond', {
+        invitationUrn: LinkedInUrn;
+        action: 'accept' | 'decline' | 'withdraw';
+    }>): Promise<LinkedInOperationResult<LinkedInInvitation>>;
+    listConversations(request: LinkedInOperationRequestFor<'linkedin.messaging.conversations.list', {
+        start?: number;
+        count?: number;
+    }>): Promise<LinkedInOperationResult<{
+        items: readonly LinkedInConversation[];
+        page: LinkedInPage;
+    }>>;
+    listMessages(request: LinkedInOperationRequestFor<'linkedin.messaging.messages.list', {
+        conversationUrn: LinkedInUrn;
+    }>): Promise<LinkedInOperationResult<readonly LinkedInMessage[]>>;
+    sendMessage(request: LinkedInOperationRequestFor<'linkedin.messaging.messages.send', LinkedInMessageInput>): Promise<LinkedInOperationResult<LinkedInMessage>>;
+    replyToMessage(request: LinkedInOperationRequestFor<'linkedin.messaging.messages.reply', LinkedInMessageInput & {
+        conversationUrn: LinkedInUrn;
+    }>): Promise<LinkedInOperationResult<LinkedInMessage>>;
+}

package/dist/integrations/linkedin/messaging.js

@@ -0,0 +1 @@
+// @bun

package/dist/integrations/linkedin/models.d.ts

@@ -0,0 +1,42 @@
+export type LinkedInUrn = `urn:li:${string}`;
+export type LinkedInProduct = 'sign-in' | 'share-on-linkedin' | 'community-management' | 'communications' | 'sales-navigator' | 'sales-navigator-sync' | 'marketing' | 'lead-sync';
+export type LinkedInActorType = 'member' | 'organization' | 'application';
+export interface LinkedInActorRef {
+    type: LinkedInActorType;
+    urn: LinkedInUrn;
+    displayName?: string;
+}
+export interface LinkedInResourceRef {
+    type: 'organization' | 'ad-account' | 'sales-contract' | 'crm-instance' | 'lead-form';
+    id: string;
+    urn?: LinkedInUrn;
+}
+export interface LinkedInPage {
+    start: number;
+    count: number;
+    total?: number;
+    nextCursor?: string;
+}
+export interface LinkedInRecordEvidence {
+    providerApiVersion: string;
+    capturedAt: string;
+    sourceRevision?: string;
+    evidenceRefIds: readonly string[];
+}
+export interface LinkedInProfessionalProfile {
+    memberUrn: LinkedInUrn;
+    canonicalUrl?: string;
+    vanityName?: string;
+    firstName?: string;
+    lastName?: string;
+    headline?: string;
+    currentOrganizationUrn?: LinkedInUrn;
+    evidence: LinkedInRecordEvidence;
+}
+export interface LinkedInOrganization {
+    organizationUrn: LinkedInUrn;
+    canonicalUrl?: string;
+    vanityName?: string;
+    localizedName: string;
+    evidence: LinkedInRecordEvidence;
+}

package/dist/integrations/linkedin/models.js

@@ -0,0 +1 @@
+// @bun

package/dist/integrations/linkedin/native-publication.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+/** Native publication material must be resolved from the exact reviewed revision by the host. */
+export declare const LinkedInNativePublicationSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    accountId: z.ZodString;
+    contentRevisionId: z.ZodString;
+    contentDigest: z.ZodString;
+    author: z.ZodString;
+    commentary: z.ZodString;
+    visibility: z.ZodEnum<{
+        CONNECTIONS: "CONNECTIONS";
+        PUBLIC: "PUBLIC";
+    }>;
+    isReshareDisabledByAuthor: z.ZodBoolean;
+    content: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"text">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"image">;
+        id: z.ZodString;
+        altText: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"video">;
+        id: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"document">;
+        id: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"multi-image">;
+        images: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            altText: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"article">;
+        source: z.ZodURL;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        thumbnail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export type LinkedInNativePublication = z.infer<typeof LinkedInNativePublicationSchema>;

package/dist/integrations/linkedin/native-publication.js

@@ -0,0 +1,2 @@
+// @bun
+import{z as i}from"zod";var n=i.string().trim().min(1).max(200),e=i.string().regex(/^urn:li:image:[A-Za-z0-9_-]+$/),r=i.string().min(1).max(400),o=i.strictObject({tenantId:n,accountId:n,contentRevisionId:n,contentDigest:i.string().regex(/^sha256:[a-f0-9]{64}$/),author:i.string().regex(/^urn:li:(person|organization):[A-Za-z0-9_-]+$/),commentary:i.string().min(1).max(3000),visibility:i.enum(["PUBLIC","CONNECTIONS"]),isReshareDisabledByAuthor:i.boolean(),content:i.discriminatedUnion("kind",[i.strictObject({kind:i.literal("text")}),i.strictObject({kind:i.literal("image"),id:e,altText:i.string().max(4086).optional()}),i.strictObject({kind:i.literal("video"),id:i.string().regex(/^urn:li:video:[A-Za-z0-9_-]+$/),title:r}),i.strictObject({kind:i.literal("document"),id:i.string().regex(/^urn:li:document:[A-Za-z0-9_-]+$/),title:r}),i.strictObject({kind:i.literal("multi-image"),images:i.array(i.strictObject({id:e,altText:i.string().max(4086).optional()})).min(2).max(20)}),i.strictObject({kind:i.literal("article"),source:i.url().refine((t)=>new URL(t).protocol==="https:"),title:r,description:i.string().max(500).optional(),thumbnail:e.optional()})])}).refine((t)=>!t.author.startsWith("urn:li:organization:")||t.visibility==="PUBLIC","Organization posts require public visibility.");export{o as LinkedInNativePublicationSchema};

package/dist/integrations/linkedin/native-withdrawal.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const LinkedInWithdrawalTargetSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    workspaceId: z.ZodString;
+    accountId: z.ZodString;
+    useId: z.ZodString;
+    publicationRef: z.ZodString;
+    postUrn: z.ZodString;
+    author: z.ZodString;
+    ownershipEvidenceRef: z.ZodString;
+}, z.core.$strict>;
+export type LinkedInWithdrawalTarget = z.infer<typeof LinkedInWithdrawalTargetSchema>;

package/dist/integrations/linkedin/native-withdrawal.js

@@ -0,0 +1,2 @@
+// @bun
+import{z as n}from"zod";var r=n.strictObject({tenantId:n.string().min(1),workspaceId:n.string().min(1),accountId:n.string().min(1),useId:n.string().min(1),publicationRef:n.string().min(1),postUrn:n.string().regex(/^urn:li:(share|ugcPost):[0-9]+$/),author:n.string().regex(/^urn:li:(person|organization):[A-Za-z0-9_-]+$/),ownershipEvidenceRef:n.string().min(1)});export{r as LinkedInWithdrawalTargetSchema};