@oomol-lab/open-connector 1.9.0 → 1.9.2

package/src/providers/sansan/admin.js

@@ -0,0 +1,42 @@
+import { normalizeSansanPage, readSansanJson, requestSansan, requestSansanJson, sansanPageQuery, sansanPathId, } from "./request.js";
+export const sansanAdminHandlers = {
+    async list_departments(input, context) {
+        return normalizeSansanPage(await requestSansanJson("/admin/departments", { query: sansanPageQuery(input) }, context));
+    },
+    async get_department_access_control(input, context) {
+        return requestSansanJson(departmentPath(input), {}, context);
+    },
+    async set_department_access_control(input, context) {
+        return changeAdmin(departmentPath(input), "PUT", { aclPatternId: input.aclPatternId }, context);
+    },
+    async list_access_control_patterns(input, context) {
+        return normalizeSansanPage(await requestSansanJson("/admin/accessControl/pattern", { query: sansanPageQuery(input) }, context));
+    },
+    async create_access_control_pattern(input, context) {
+        return requestSansanJson("/admin/accessControl/pattern", { method: "POST", json: input }, context);
+    },
+    async update_access_control_pattern(input, context) {
+        const { patternId, ...body } = input;
+        return changeAdmin(`/admin/accessControl/pattern/${sansanPathId(patternId, "patternId")}`, "PUT", body, context);
+    },
+    async delete_access_control_pattern(input, context) {
+        return changeAdmin(`/admin/accessControl/pattern/${sansanPathId(input.patternId, "patternId")}`, "DELETE", undefined, context);
+    },
+    async get_default_email_client(_input, context) {
+        return requestSansan("/organizationSettings/emailClient", {}, context, async (response) => ({
+            settings: await readSansanJson(response, true),
+        }));
+    },
+    async set_default_email_client(input, context) {
+        return requestSansan("/organizationSettings/emailClient", { method: "PUT", json: input }, context, async (response) => ({ settings: await readSansanJson(response) }));
+    },
+};
+function departmentPath(input) {
+    return `/admin/accessControl/department/${sansanPathId(input.departmentId, "departmentId")}/pattern`;
+}
+function changeAdmin(path, method, json, context) {
+    return requestSansan(path, { method, json }, context, async (response) => ({
+        success: true,
+        data: await readSansanJson(response, true),
+    }));
+}

package/src/providers/sansan/business-actions.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const sansanBusinessActions: ActionDefinition[];

package/src/providers/sansan/business-actions.js

@@ -0,0 +1,160 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { sansanFileSchema } from "./file-schema.js";
+import { businessCardSchema, reportSchema } from "./schemas.js";
+export const sansanBusinessActions = [
+    defineProviderAction("sansan", {
+        name: "create_business_card",
+        description: "Create a Sansan business card, optionally for another user through the administrator import API.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: {
+            ...s.object("Business card fields. At least one non-empty companyName, firstName, or lastName is required.", {
+                ownerUserId: s.nonEmptyString("Optional record owner user ID. When provided, use the system-administrator import API; the user must belong to the same company and contract. Omit to create for the connected user."),
+                lastName: s.nullable(s.string("Last name.", { maxLength: 250 })),
+                firstName: s.nullable(s.string("First name.", { maxLength: 250 })),
+                lastNameReading: s.nullable(s.string("Last name reading in kana; do not use kanji, hiragana, or full-width alphanumeric characters.", {
+                    maxLength: 250,
+                })),
+                firstNameReading: s.nullable(s.string("First name reading in kana; do not use kanji, hiragana, or full-width alphanumeric characters.", {
+                    maxLength: 250,
+                })),
+                departmentName: s.nullable(s.string("Department name.", { maxLength: 250 })),
+                title: s.nullable(s.string("Job title.", { maxLength: 250 })),
+                companyName: s.nullable(s.string("Company name.", { maxLength: 250 })),
+                prefecture: s.nullable(s.string("Prefecture or state.", { maxLength: 250 })),
+                city: s.nullable(s.string("City.", { maxLength: 250 })),
+                street: s.nullable(s.string("Street address.", { maxLength: 250 })),
+                building: s.nullable(s.string("Building.", { maxLength: 250 })),
+                email: s.nullable(s.string("Email address.", { maxLength: 250 })),
+                mobile: s.nullable(s.string("Mobile number using digits, plus, and hyphen.", { maxLength: 30 })),
+                tel: s.nullable(s.string("Telephone number using digits, plus, and hyphen.", { maxLength: 30 })),
+                secondTel: s.nullable(s.string("Second telephone number using digits, plus, and hyphen.", { maxLength: 30 })),
+                fax: s.nullable(s.string("Fax number using digits, plus, and hyphen.", { maxLength: 30 })),
+                url: s.nullable(s.string("Website URL.", { maxLength: 250 })),
+                memo: s.nullable(s.string("Memo.", { maxLength: 2000 })),
+                exchangeDate: s.nullable(s.string("Business card exchange date, YYYY-MM-DD.", { format: "date" })),
+                countryCode: s.nullable(s.string("ISO 3166-1 alpha-2 country code or AUTO to infer the country from contact information.")),
+                postalCode: s.nullable(s.string("Postal code: alphanumeric, hyphens and spaces; at most ten characters excluding hyphens and spaces.")),
+                tagIds: s.array("Existing tag IDs to attach, at most fifteen.", s.nonEmptyString("An existing tag ID."), {
+                    maxItems: 15,
+                }),
+                sharingPermissions: s.nullable(s.object("Per-field visibility settings.", {
+                    companyInformation: s.nullable(s.boolean("Whether to share company information.")),
+                    name: s.nullable(s.boolean("Whether to share the name.")),
+                    exchangeDate: s.nullable(s.boolean("Whether to share the exchange date.")),
+                    contact: s.nullable(s.boolean("Whether to share contact details.")),
+                    mobile: s.nullable(s.boolean("Whether to share the mobile number.")),
+                    email: s.nullable(s.boolean("Whether to share the email address.")),
+                    memo: s.nullable(s.boolean("Whether to share the memo.")),
+                    others: s.nullable(s.boolean("Whether to share other information.")),
+                }, { required: [] })),
+            }, { required: [] }),
+            anyOf: [
+                {
+                    required: ["companyName"],
+                    properties: { companyName: { type: "string", minLength: 1 } },
+                },
+                { required: ["firstName"], properties: { firstName: { type: "string", minLength: 1 } } },
+                { required: ["lastName"], properties: { lastName: { type: "string", minLength: 1 } } },
+            ],
+        },
+        outputSchema: businessCardSchema,
+    }),
+    defineProviderAction("sansan", {
+        name: "upload_business_card_image",
+        description: "Submit JPEG business card images for paid Sansan digitization. Optionally use administrator import for another owner.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: s.object("Image URLs and digitization options.", {
+            ownerUserId: s.nonEmptyString("Optional record owner user ID. When provided, use the system-administrator import API; the user must belong to the same company and contract. Omit to create for the connected user."),
+            frontImageUrl: s.string("Public URL of the front JPEG image, at most 5 MB.", {
+                format: "uri",
+            }),
+            backImageUrl: s.string("Public URL of the optional back JPEG image, at most 5 MB.", {
+                format: "uri",
+            }),
+            exchangeDate: s.string("Business card exchange date, YYYY-MM-DD.", { format: "date" }),
+            prioritizeHandWrittenDates: s.boolean("Use a handwritten date on the image as the exchange date."),
+            memo: s.string("Memo attached to the imported card.", { maxLength: 2000 }),
+            languages: s.array("Requested digitization languages, at most two.", s.stringEnum("A supported digitization language.", [
+                "Japanese",
+                "English",
+                "Chinese",
+                "Korean",
+                "Spanish",
+                "Portuguese",
+                "German",
+                "French",
+                "Thai",
+                "Indonesian",
+                "Vietnamese",
+            ]), { maxItems: 2 }),
+            tagIds: s.array("Existing tag IDs to attach, at most fifteen.", s.nonEmptyString("An existing tag ID."), {
+                maxItems: 15,
+            }),
+        }, { required: ["frontImageUrl"] }),
+        outputSchema: s.object("Business cards submitted for paid digitization.", {
+            data: s.array("Created card identifiers for each requested language.", s.object("A card queued for digitization.", {
+                id: s.string("The created business card ID."),
+                language: s.string("The digitization language."),
+            }, { additionalProperties: true, required: [] })),
+        }, { additionalProperties: true, required: ["data"] }),
+    }),
+    defineProviderAction("sansan", {
+        name: "get_business_card_image",
+        description: "Download the front or back of a Sansan business card as a JPEG file URL.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Business card image selection.", {
+            businessCardId: s.nonEmptyString("The Sansan business card ID."),
+            side: s.stringEnum("The card side; defaults to front.", ["front", "back"]),
+        }, { required: ["businessCardId"] }),
+        outputSchema: sansanFileSchema,
+    }),
+    defineProviderAction("sansan", {
+        name: "create_contact_report",
+        description: "Create a Sansan contact report. External attendee details also create new business cards; optionally import for another owner as an administrator.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: s.object("Contact report details.", {
+            ownerUserId: s.nonEmptyString("Optional record owner user ID. When provided, use the system-administrator import API; the user must belong to the same company and contract. Omit to create for the connected user."),
+            startTime: s.string("Start timestamp with timezone; seconds must be 00.", {
+                format: "date-time",
+            }),
+            endTime: s.string("End timestamp with timezone; seconds must be 00.", {
+                format: "date-time",
+            }),
+            externalAttendees: s.array("External attendees whose details create new business cards.", {
+                ...s.object("An external attendee. Sansan creates a new business card from these details.", {
+                    companyName: s.string("Company name.", { maxLength: 250 }),
+                    lastName: s.string("Last name.", { maxLength: 250 }),
+                    firstName: s.string("First name.", { maxLength: 250 }),
+                    email: s.string("Email address.", { maxLength: 250 }),
+                }, { required: [] }),
+                anyOf: [
+                    { required: ["companyName"], properties: { companyName: { minLength: 1 } } },
+                    { required: ["lastName"], properties: { lastName: { minLength: 1 } } },
+                    { required: ["firstName"], properties: { firstName: { minLength: 1 } } },
+                ],
+            }),
+            internalAttendeeUserIds: s.array("Internal attendee user IDs; omission defaults to the report owner.", s.nonEmptyString("An internal user ID.")),
+            type: s.stringEnum("The contact interaction type.", [
+                "Meeting",
+                "Visit",
+                "MeetingAtOffice",
+                "Call",
+                "OutboundCall",
+                "InboundCall",
+                "Email",
+                "SentEmail",
+                "ReceivedEmail",
+                "OnlineMeeting",
+            ]),
+            title: s.string("Contact report title."),
+            location: s.string("Contact location."),
+            memo: s.string("Contact report memo."),
+        }, { required: ["startTime", "endTime", "externalAttendees", "type"] }),
+        outputSchema: reportSchema,
+    }),
+];

package/src/providers/sansan/business.d.ts

@@ -0,0 +1,2 @@
+import type { SansanActionHandler } from "./request.ts";
+export declare const sansanBusinessHandlers: Record<string, SansanActionHandler>;

package/src/providers/sansan/business.js

@@ -0,0 +1,51 @@
+import { looseArray, optionalString } from "../../core/cast.js";
+import { providerInputError } from "../provider-runtime.js";
+import { downloadSansanSource, encodeSansanMultipart, requireSansanTransit, uploadSansanDownload } from "./files.js";
+import { requestSansan, requestSansanJson, sansanPathId } from "./request.js";
+export const sansanBusinessHandlers = {
+    async create_business_card(input, context) {
+        if (![input.companyName, input.firstName, input.lastName].some((value) => optionalString(value)?.trim())) {
+            throw providerInputError("A non-empty companyName, firstName, or lastName is required");
+        }
+        return requestSansanJson(importPath("bizCards", input), { method: "POST", json: input }, context);
+    },
+    async create_contact_report(input, context) {
+        for (const field of ["startTime", "endTime"]) {
+            const time = String(input[field]).slice(11);
+            const seconds = time.split(":")[2]?.split("+")[0]?.split("-")[0]?.toUpperCase().split("Z")[0];
+            const [wholeSeconds, fraction = ""] = (seconds ?? "").split(".");
+            if (wholeSeconds !== "00" || [...fraction].some((digit) => digit !== "0")) {
+                throw providerInputError(`${field} must have zero seconds`);
+            }
+        }
+        return requestSansanJson(importPath("reports", input), { method: "POST", json: input }, context);
+    },
+    async upload_business_card_image(input, context) {
+        const form = new FormData();
+        await addImage(form, "frontImage", "frontImageUrl", input, context);
+        if (input.backImageUrl !== undefined)
+            await addImage(form, "backImage", "backImageUrl", input, context);
+        for (const key of ["ownerUserId", "exchangeDate", "prioritizeHandWrittenDates", "memo"]) {
+            if (input[key] !== undefined)
+                form.append(key, String(input[key]));
+        }
+        for (const value of looseArray(input.languages))
+            form.append("language", String(value));
+        for (const value of looseArray(input.tagIds))
+            form.append("tagIds", String(value));
+        return requestSansanJson(importPath("bizCards/images", input), { method: "POST", ...(await encodeSansanMultipart(form)) }, context);
+    },
+    async get_business_card_image(input, context) {
+        requireSansanTransit(context);
+        const id = sansanPathId(input.businessCardId, "businessCardId");
+        const side = optionalString(input.side) ?? "front";
+        return requestSansan(`/bizCards/${id}/image`, { query: { side } }, context, (response) => uploadSansanDownload(response, `sansan-business-card-${side}.jpg`, "image/jpeg", context));
+    },
+};
+function importPath(resource, input) {
+    return input.ownerUserId === undefined ? `/${resource}` : `/admin/import/${resource}`;
+}
+async function addImage(form, part, field, input, context) {
+    const bytes = await downloadSansanSource(String(input[field]), field, context, true);
+    form.append(part, new Blob([bytes], { type: "image/jpeg" }), `${part}.jpg`);
+}

package/src/providers/sansan/executors.d.ts

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const executors: ProviderExecutors;
+export declare const credentialValidators: CredentialValidators;
+export declare const proxy: ProviderProxyExecutor;

package/src/providers/sansan/executors.js

@@ -0,0 +1,59 @@
+import { optionalString, recordOrEmpty } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, providerResponseError, requiredInputString, } from "../provider-runtime.js";
+import { sansanActions } from "./actions.js";
+import { sansanAdminHandlers } from "./admin.js";
+import { sansanBusinessHandlers } from "./business.js";
+import { sansanOrganizationHandlers } from "./organization.js";
+import { executeSansanRead } from "./read.js";
+import { readSansanError, requestSansanJson, sansanApiBaseUrl } from "./request.js";
+const mutations = { ...sansanAdminHandlers, ...sansanBusinessHandlers, ...sansanOrganizationHandlers };
+export const executors = defineApiKeyProviderExecutors("sansan", mapProviderActionHandlers("sansan", sansanActions, (action) => (input, context) => {
+    input = { ...input };
+    for (const field of [
+        "ownerUserId",
+        "businessCardId",
+        "personId",
+        "nextPageToken",
+        "departmentId",
+        "aclPatternId",
+        "aclPatternName",
+        "patternId",
+        "importId",
+    ]) {
+        if (input[field] !== undefined)
+            input[field] = requiredInputString(input[field], field);
+    }
+    for (const field of ["tagIds", "internalAttendeeUserIds"]) {
+        if (Array.isArray(input[field]))
+            input[field] = input[field].map((value) => requiredInputString(value, field));
+    }
+    if (Array.isArray(input.details))
+        input.details = input.details.map((value) => {
+            const detail = recordOrEmpty(value);
+            return {
+                ...detail,
+                objectDepartmentId: requiredInputString(detail.objectDepartmentId, "objectDepartmentId"),
+                accessibleFieldsSettingsName: requiredInputString(detail.accessibleFieldsSettingsName, "accessibleFieldsSettingsName"),
+            };
+        });
+    const handler = mutations[action.name];
+    return handler ? handler(input, context) : executeSansanRead(action.name, input, context);
+}));
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const user = await requestSansanJson("/me", {}, { apiKey: input.apiKey, fetcher, signal, phase: "validate" });
+        const accountId = optionalString(user.id);
+        if (!accountId)
+            throw providerResponseError("Sansan user response is missing id");
+        return { profile: { accountId, displayName: optionalString(user.name) ?? accountId }, grantedScopes: [] };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "sansan",
+    baseUrl: sansanApiBaseUrl,
+    auth: { type: "api_key_header", name: "X-Sansan-Api-Key" },
+    readError: (response) => readSansanError(response),
+    customizeRequest({ headers }) {
+        headers.set("accept", "application/json");
+    },
+});

package/src/providers/sansan/file-schema.d.ts

@@ -0,0 +1,2 @@
+import type { JsonSchema } from "../../core/types.ts";
+export declare const sansanFileSchema: JsonSchema;

package/src/providers/sansan/file-schema.js

@@ -0,0 +1,8 @@
+import { s } from "../../core/json-schema.js";
+export const sansanFileSchema = s.actionOutput({
+    fileId: s.string("The stored transit file identifier."),
+    downloadUrl: s.string("The transit file download URL."),
+    name: s.string("The file name."),
+    mimeType: s.string("The file media type."),
+    sizeBytes: s.integer("The file size in bytes."),
+}, "A downloaded file in local transit storage.");

package/src/providers/sansan/files.d.ts

@@ -0,0 +1,11 @@
+import type { TransitFileUpload } from "../../core/types.ts";
+import type { ApiKeyProviderContext } from "../provider-runtime.ts";
+export declare function requireSansanTransit(context: ApiKeyProviderContext): void;
+export declare function downloadSansanSource(url: string, fieldName: string, context: ApiKeyProviderContext, jpeg?: boolean): Promise<Uint8Array>;
+interface SansanMultipart {
+    body: Uint8Array<ArrayBuffer>;
+    headers: Record<string, string>;
+}
+export declare function encodeSansanMultipart(form: FormData): Promise<SansanMultipart>;
+export declare function uploadSansanDownload(response: Response, name: string, mimeType: string, context: ApiKeyProviderContext): Promise<TransitFileUpload>;
+export {};

package/src/providers/sansan/files.js

@@ -0,0 +1,49 @@
+import { readBoundedResponseBytes, storeResponseInTransit } from "../../core/request.js";
+import { providerInputError, ProviderRequestError, providerResponseError, runProviderRequest, } from "../provider-runtime.js";
+export function requireSansanTransit(context) {
+    if (!context.transitFiles)
+        throw new ProviderRequestError(501, "Sansan downloads require transit file storage");
+}
+export async function downloadSansanSource(url, fieldName, context, jpeg = false) {
+    return runProviderRequest({ label: "Sansan source download", signal: context.signal }, async (signal) => {
+        const response = await context.fetcher(url, { signal });
+        if (!response.ok)
+            throw new ProviderRequestError(response.status, `Cannot download ${fieldName}`);
+        const bytes = await readBoundedResponseBytes(response, {
+            maxBytes: jpeg ? 5 * 1024 * 1024 : 20 * 1024 * 1024,
+            fieldName,
+            createError: providerInputError,
+            signal,
+        });
+        if (!bytes.length)
+            throw providerInputError(`${fieldName} is empty`);
+        if (jpeg && (bytes[0] !== 0xff || bytes[1] !== 0xd8 || bytes[2] !== 0xff))
+            throw providerInputError(`${fieldName} must contain a JPEG image`);
+        return bytes;
+    });
+}
+export async function encodeSansanMultipart(form) {
+    // Organization imports require a trailing CRLF and an explicit Content-Length.
+    const response = new Response(form);
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    const hasCrLf = bytes.at(-2) === 13 && bytes.at(-1) === 10;
+    const body = hasCrLf ? bytes : new Uint8Array(bytes.length + 2);
+    if (!hasCrLf) {
+        body.set(bytes);
+        body.set([13, 10], bytes.length);
+    }
+    return {
+        body,
+        headers: { "content-type": response.headers.get("content-type"), "content-length": String(body.byteLength) },
+    };
+}
+export function uploadSansanDownload(response, name, mimeType, context) {
+    requireSansanTransit(context);
+    return storeResponseInTransit(response, context.transitFiles, {
+        name,
+        mimeType: response.headers.get("content-type") || mimeType,
+        fieldName: "Sansan download",
+        createError: providerResponseError,
+        signal: context.signal,
+    });
+}

package/src/providers/sansan/organization-actions.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const sansanOrganizationActions: ActionDefinition[];

package/src/providers/sansan/organization-actions.js

@@ -0,0 +1,198 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { sansanFileSchema } from "./file-schema.js";
+const organizationImportInputSchema = {
+    ...s.object("Users and/or departments to check or import. System administrator only.", {
+        users: s.array("Structured user rows; Connector builds the official CSV, preserving all columns. Mutually exclusive with usersFileUrl.", s.object("A user import row using official Sansan CSV columns. Submission requires DepartmentId, UserId, UserName and Email; new users also require TempId and EffectiveDateFrom, while existing users require UserUuid. Blank optional cells preserve unchanged values when editing.", {
+            TempId: s.string("Temporary alphanumeric ID for a new user; blank when editing. Must be unique within the file.", { maxLength: 256 }),
+            UserUuid: s.string("Existing user UUID when editing; blank for a new user."),
+            DepartmentId: s.string("Department IDs separated by semicolons; use tempId:ID for a new department in the same import."),
+            UserId: s.string("Immutable user login ID, up to 20 characters; alphanumeric or .-_&.", { maxLength: 20 }),
+            UserName: s.string("User display name, up to 60 characters.", { maxLength: 60 }),
+            AlternativeName: s.string("User name reading.", { maxLength: 256 }),
+            Email: s.string("Unique primary user email within the company.", { maxLength: 60 }),
+            SubEmail: s.string("Secondary user email.", { maxLength: 60 }),
+            EffectiveDateFrom: s.string("Usage start date for new users, today or later in RFC3339 format; blank when unchanged during editing."),
+            SamlNameId: s.string("Unique SAML Name ID within the company."),
+            Culture: s.integer("Display language: 0 Japanese, 1 English, 2 Simplified Chinese. Omission serializes as a blank CSV cell.", { minimum: 0, maximum: 2 }),
+            MailFormat: s.integer("Email format: 0 HTML, 1 text. Omission serializes as a blank CSV cell.", {
+                minimum: 0,
+                maximum: 1,
+            }),
+            UserType: s.integer("Role: 0 regular, 1 system administrator, 2 departmental administrator. Omission serializes as a blank CSV cell.", { minimum: 0, maximum: 2 }),
+            CanUpdateData: s.integer("Permission to update all data: 1 granted, 0 denied. Omission serializes as a blank CSV cell.", { minimum: 0, maximum: 1 }),
+            DataDownloadPrivilege: s.integer("Download permission: 0 none, 1 own data, 2 all data, 3 assigned departments. Omission serializes as a blank CSV cell.", { minimum: 0, maximum: 3 }),
+            EmailDeliveryPrivilege: s.integer("Email delivery permission: 1 granted, 0 denied. Omission serializes as a blank CSV cell.", { minimum: 0, maximum: 1 }),
+            DealPrivilege: s.integer("Deal permission: 0 none, 1 regular, 2 administrator. Omission serializes as a blank CSV cell.", { minimum: 0, maximum: 2 }),
+            ApiIntegrationPrivilege: s.integer("API integration permission: 1 granted, 0 denied. Omission serializes as a blank CSV cell.", { minimum: 0, maximum: 1 }),
+            UsageStatisticsPrivilege: s.integer("Usage statistics permission: 1 granted, 0 denied. Omission serializes as a blank CSV cell.", { minimum: 0, maximum: 1 }),
+            OrganizationTreeDownloadPrivilege: s.integer("Organization tree download permission: 1 granted, 0 denied. Omission serializes as a blank CSV cell.", { minimum: 0, maximum: 1 }),
+            DeleteFlag: s.integer("Set to 1 to delete the user. Omission serializes as a blank CSV cell.", {
+                minimum: 0,
+                maximum: 1,
+            }),
+            SalesforceIntegrationPrivilege: s.string("Retired field, ignored by Sansan; the CSV column is retained even when omitted."),
+        }, { required: [] }), { minItems: 1 }),
+        departments: s.array("Structured department rows. Mutually exclusive with departmentsFileUrl.", s.object("A department import row using official Sansan CSV columns. Submission requires DepartmentName and either TempId for creation or DepartmentId for editing; the other identifier must be blank or omitted.", {
+            TempId: s.string("Temporary alphanumeric ID for a new department; blank when editing.", { maxLength: 256 }),
+            DepartmentId: s.string("Existing department ID when editing; blank for a new department."),
+            DepartmentName: s.string("Department name.", { maxLength: 30 }),
+            DepartmentNamePhonetic: s.string("Department name reading using lowercase Latin letters, digits, and spaces.", { maxLength: 256 }),
+            ParentDepartmentId: s.string("Parent department ID or tempId:ID for a parent created in the same import; blank for no parent."),
+            Order: s.integer("Department sort order."),
+            DeleteFlag: s.integer("Set to 1 to delete the department; it must have no users or child departments.", {
+                minimum: 0,
+                maximum: 1,
+            }),
+        }, { required: [] }), { minItems: 1 }),
+        usersFileUrl: s.string("Public URL of a UTF-8 user CSV with a header row; maximum 20 MiB per source file.", {
+            format: "uri",
+        }),
+        departmentsFileUrl: s.string("Public URL of a UTF-8 department CSV with a header row; maximum 20 MiB per source file.", { format: "uri" }),
+        delimiter: s.stringEnum("CSV delimiter; defaults to comma.", ["comma", "semicolon", "tab", "space"]),
+    }, { required: [] }),
+    anyOf: [
+        { required: ["users"] },
+        { required: ["departments"] },
+        { required: ["usersFileUrl"] },
+        { required: ["departmentsFileUrl"] },
+    ],
+    allOf: [
+        { not: { required: ["users", "usersFileUrl"] } },
+        { not: { required: ["departments", "departmentsFileUrl"] } },
+    ],
+};
+// Checking accepts incomplete rows for upstream diagnostics; submission enforces creation and update rules.
+const organizationSubmissionInputSchema = {
+    ...organizationImportInputSchema,
+    allOf: [
+        ...organizationImportInputSchema.allOf,
+        {
+            properties: {
+                users: {
+                    items: {
+                        required: ["DepartmentId", "UserId", "UserName", "Email"],
+                        properties: {
+                            DepartmentId: { minLength: 1 },
+                            UserId: { minLength: 1 },
+                            UserName: { minLength: 1 },
+                            Email: { minLength: 1 },
+                        },
+                        oneOf: [
+                            {
+                                required: ["TempId", "EffectiveDateFrom"],
+                                properties: {
+                                    TempId: { minLength: 1 },
+                                    UserUuid: { maxLength: 0 },
+                                    EffectiveDateFrom: { minLength: 1 },
+                                },
+                            },
+                            {
+                                required: ["UserUuid"],
+                                properties: {
+                                    UserUuid: { minLength: 1 },
+                                    TempId: { maxLength: 0 },
+                                },
+                            },
+                        ],
+                    },
+                },
+                departments: {
+                    items: {
+                        required: ["DepartmentName"],
+                        properties: { DepartmentName: { minLength: 1 } },
+                        oneOf: [
+                            {
+                                required: ["TempId"],
+                                properties: { TempId: { minLength: 1 }, DepartmentId: { maxLength: 0 } },
+                            },
+                            {
+                                required: ["DepartmentId"],
+                                properties: { DepartmentId: { minLength: 1 }, TempId: { maxLength: 0 } },
+                            },
+                        ],
+                    },
+                },
+            },
+        },
+    ],
+};
+export const sansanOrganizationActions = [
+    defineProviderAction("sansan", {
+        name: "export_organization_users",
+        description: "Export Sansan organization users as a CSV download. System administrator only.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("User export options.", {
+            delimiter: s.stringEnum("CSV delimiter; defaults to comma.", ["comma", "semicolon", "tab", "space"]),
+        }, { required: [] }),
+        outputSchema: sansanFileSchema,
+    }),
+    defineProviderAction("sansan", {
+        name: "export_organization_departments",
+        description: "Export Sansan organization departments as a CSV download. System administrator only.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Department export options.", {
+            delimiter: s.stringEnum("CSV delimiter; defaults to comma.", ["comma", "semicolon", "tab", "space"]),
+        }, { required: [] }),
+        outputSchema: sansanFileSchema,
+    }),
+    defineProviderAction("sansan", {
+        name: "check_organization_import",
+        description: "Validate user and department import data without applying changes. System administrator only; returns a downloadable CSV report if errors exist.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: organizationImportInputSchema,
+        outputSchema: s.object("Organization import validation result.", {
+            valid: s.boolean("Whether Sansan returned an empty validation response, indicating valid data."),
+            report: s.nullable(sansanFileSchema),
+        }, { required: ["valid", "report"] }),
+    }),
+    defineProviderAction("sansan", {
+        name: "submit_organization_import",
+        description: "Submit user and department additions, updates, or deletions. System administrator only. DeleteFlag can delete users or departments; preserve the import ID to retrieve results.",
+        operationType: "destructive",
+        requiredScopes: [],
+        inputSchema: organizationSubmissionInputSchema,
+        outputSchema: s.object("Submitted organization import.", {
+            importId: s.nonEmptyString("The submitted import job ID."),
+        }, { additionalProperties: true, required: ["importId"] }),
+        asyncLifecycle: {
+            startActionId: "sansan.submit_organization_import",
+            statusActionId: "sansan.get_organization_import_result",
+        },
+    }),
+    defineProviderAction("sansan", {
+        name: "get_organization_import_status",
+        description: "Get the current organization import status. System administrator only.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Organization import job identifier.", {
+            importId: s.nonEmptyString("The import ID returned when the job was submitted."),
+        }, { required: ["importId"] }),
+        outputSchema: s.object("Organization import status.", {
+            importStatus: s.integer("Upstream import status: 0 queued, 1 running, 2 completed, 9 error."),
+            status: s.stringEnum("Normalized import status.", ["queued", "running", "completed", "failed"]),
+        }, { additionalProperties: true, required: ["importStatus", "status"] }),
+    }),
+    defineProviderAction("sansan", {
+        name: "get_organization_import_result",
+        description: "Check an organization import and return its result CSV when completed or failed. System administrator only. The report includes created IDs and row-level errors.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Organization import job identifier.", {
+            importId: s.nonEmptyString("The import ID returned when the job was submitted."),
+        }, { required: ["importId"] }),
+        outputSchema: s.object("Organization import state and result report.", {
+            importId: s.nonEmptyString("The import ID."),
+            importStatus: s.integer("Upstream import status: 0 queued, 1 running, 2 completed, 9 error."),
+            status: s.stringEnum("Normalized import status.", ["queued", "running", "completed", "failed"]),
+            report: s.nullable(sansanFileSchema),
+        }, { additionalProperties: true, required: ["importId", "importStatus", "status", "report"] }),
+        asyncLifecycle: {
+            startActionId: "sansan.submit_organization_import",
+            statusActionId: "sansan.get_organization_import_result",
+        },
+    }),
+];

package/src/providers/sansan/organization-columns.d.ts

@@ -0,0 +1,2 @@
+export declare const sansanUserColumns: readonly string[];
+export declare const sansanDepartmentColumns: readonly string[];

package/src/providers/sansan/organization-columns.js

@@ -0,0 +1,33 @@
+export const sansanUserColumns = [
+    "TempId",
+    "UserUuid",
+    "DepartmentId",
+    "UserId",
+    "UserName",
+    "AlternativeName",
+    "Email",
+    "SubEmail",
+    "EffectiveDateFrom",
+    "Culture",
+    "MailFormat",
+    "SamlNameId",
+    "UserType",
+    "CanUpdateData",
+    "DataDownloadPrivilege",
+    "EmailDeliveryPrivilege",
+    "SalesforceIntegrationPrivilege",
+    "DealPrivilege",
+    "ApiIntegrationPrivilege",
+    "UsageStatisticsPrivilege",
+    "OrganizationTreeDownloadPrivilege",
+    "DeleteFlag",
+];
+export const sansanDepartmentColumns = [
+    "TempId",
+    "DepartmentId",
+    "DepartmentName",
+    "DepartmentNamePhonetic",
+    "ParentDepartmentId",
+    "Order",
+    "DeleteFlag",
+];