@oomol-lab/open-connector 1.9.0 → 1.9.1

package/src/providers/sansan/actions.js

@@ -0,0 +1,165 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { sansanAdminActions } from "./admin-actions.js";
+import { sansanBusinessActions } from "./business-actions.js";
+import { sansanOrganizationActions } from "./organization-actions.js";
+import { businessCardSchema, reportPageSchema, businessCardPageSchema, tagPageSchema, userSchema } from "./schemas.js";
+export const sansanActions = [
+    ...sansanBusinessActions,
+    ...sansanOrganizationActions,
+    ...sansanAdminActions,
+    defineProviderAction("sansan", {
+        name: "get_current_user",
+        operationType: "read",
+        description: "Get the Sansan user and permissions associated with the connected API key.",
+        requiredScopes: [],
+        inputSchema: s.object("No input is required.", {}, { required: [] }),
+        outputSchema: userSchema,
+    }),
+    defineProviderAction("sansan", {
+        name: "list_business_cards",
+        operationType: "read",
+        description: "List business cards updated within a time interval, with optional historical cards and tags. Use nextPageToken to continue.",
+        requiredScopes: [],
+        inputSchema: {
+            ...s.object("Business card update query.", {
+                nextPageToken: s.nonEmptyString("Continue a previous query using its nextPageToken; original query parameters are inherited."),
+                limit: s.integer("Maximum records per page, from 1 to 300; defaults to 100.", {
+                    minimum: 1,
+                    maximum: 300,
+                }),
+                range: s.stringEnum("Record ownership scope: me or all accessible records; defaults to me.", ["me", "all"]),
+                includeTags: s.boolean("Include attached tags and treat tag changes as business card updates."),
+                includePastBizCards: s.boolean("Include older business cards for merged persons; defaults to false."),
+                entryStatus: s.array("Digitization statuses to include; defaults to completed.", s.stringEnum("A business card digitization status.", ["processing", "completed", "unreadable"])),
+                orderBy: s.stringEnum("Sort field; defaults to updatedAt for listing and registeredAt for searching.", [
+                    "registeredAt",
+                    "completedAt",
+                    "updatedAt",
+                ]),
+                orderDirection: s.stringEnum("Sort direction; defaults to asc for listing and desc for searching.", [
+                    "asc",
+                    "desc",
+                ]),
+                updatedFrom: s.string("Start of the update interval as an ISO 8601 timestamp with timezone. Required on the first page.", { format: "date-time" }),
+                updatedTo: s.string("End of the update interval as an ISO 8601 timestamp with timezone. Required on the first page.", { format: "date-time" }),
+            }, { required: [] }),
+            anyOf: [{ required: ["nextPageToken"] }, { required: ["updatedFrom", "updatedTo"] }],
+        },
+        outputSchema: businessCardPageSchema,
+    }),
+    defineProviderAction("sansan", {
+        name: "search_business_cards",
+        operationType: "read",
+        description: "Search accessible Sansan business cards by company, name, email, telephone, mobile, and tags.",
+        requiredScopes: [],
+        inputSchema: s.object("Business card search filters.", {
+            nextPageToken: s.nonEmptyString("Continue a previous query using its nextPageToken; original query parameters are inherited."),
+            limit: s.integer("Maximum records per page, from 1 to 300; defaults to 100.", {
+                minimum: 1,
+                maximum: 300,
+            }),
+            range: s.stringEnum("Record ownership scope: me or all accessible records; defaults to me.", ["me", "all"]),
+            includeTags: s.boolean("Include attached tags and treat tag changes as business card updates."),
+            includePastBizCards: s.boolean("Include older business cards for merged persons; defaults to false."),
+            entryStatus: s.array("Digitization statuses to include; defaults to completed.", s.stringEnum("A business card digitization status.", ["processing", "completed", "unreadable"])),
+            orderBy: s.stringEnum("Sort field; defaults to updatedAt for listing and registeredAt for searching.", [
+                "registeredAt",
+                "completedAt",
+                "updatedAt",
+            ]),
+            orderDirection: s.stringEnum("Sort direction; defaults to asc for listing and desc for searching.", [
+                "asc",
+                "desc",
+            ]),
+            companyName: s.string("Company name substring."),
+            name: s.string("Name prefix."),
+            email: s.string("Exact email address."),
+            tel: s.string("Telephone number substring."),
+            mobile: s.string("Mobile number substring."),
+            tagIds: s.array("Filter by one or more Sansan tag IDs.", s.nonEmptyString("A tag ID.")),
+        }, { required: [] }),
+        outputSchema: businessCardPageSchema,
+    }),
+    defineProviderAction("sansan", {
+        name: "get_business_card",
+        operationType: "read",
+        description: "Get a business card by ID. Sansan may return the latest merged card with a different ID.",
+        requiredScopes: [],
+        inputSchema: s.object("Business card lookup.", {
+            businessCardId: s.nonEmptyString("The Sansan business card ID."),
+            includeTags: s.boolean("Include attached tags and treat tag changes as business card updates."),
+        }, { required: ["businessCardId"] }),
+        outputSchema: businessCardSchema,
+    }),
+    defineProviderAction("sansan", {
+        name: "get_person",
+        operationType: "read",
+        description: "Get the latest business card for a Sansan person, optionally including tags.",
+        requiredScopes: [],
+        inputSchema: s.object("Person lookup.", {
+            personId: s.nonEmptyString("The Sansan person ID."),
+            includeTags: s.boolean("Include attached tags and treat tag changes as business card updates."),
+        }, { required: ["personId"] }),
+        outputSchema: businessCardSchema,
+    }),
+    defineProviderAction("sansan", {
+        name: "list_business_card_tags",
+        operationType: "read",
+        description: "List tags attached to a Sansan business card.",
+        requiredScopes: [],
+        inputSchema: s.object("Business card tag query.", {
+            businessCardId: s.nonEmptyString("The Sansan business card ID."),
+            nextPageToken: s.nonEmptyString("Continue a previous query using its nextPageToken; original query parameters are inherited."),
+            limit: s.integer("Maximum records per page, from 1 to 300; defaults to 100.", {
+                minimum: 1,
+                maximum: 300,
+            }),
+        }, { required: ["businessCardId"] }),
+        outputSchema: tagPageSchema,
+    }),
+    defineProviderAction("sansan", {
+        name: "list_tags",
+        operationType: "read",
+        description: "List Sansan tags by ownership, visibility, owner user, and tag name.",
+        requiredScopes: [],
+        inputSchema: s.object("Tag query filters.", {
+            nextPageToken: s.nonEmptyString("Continue a previous query using its nextPageToken; original query parameters are inherited."),
+            limit: s.integer("Maximum records per page, from 1 to 300; defaults to 100.", {
+                minimum: 1,
+                maximum: 300,
+            }),
+            range: s.stringEnum("Record ownership scope: me or all accessible records; defaults to me.", ["me", "all"]),
+            type: s.array("Tag visibility types to include.", s.stringEnum("A tag visibility type.", ["private", "public", "shared"])),
+            ownerUserId: s.string("Tag owner user ID, effective only when range is all.", {
+                maxLength: 20,
+            }),
+            tagName: s.string("Tag name substring.", { maxLength: 50 }),
+        }, { required: [] }),
+        outputSchema: tagPageSchema,
+    }),
+    defineProviderAction("sansan", {
+        name: "list_contact_reports",
+        operationType: "read",
+        description: "List Sansan contact reports updated within a time interval, including meetings, calls, emails, and business card exchanges.",
+        requiredScopes: [],
+        inputSchema: {
+            ...s.object("Contact report query filters.", {
+                nextPageToken: s.nonEmptyString("Continue a previous query using its nextPageToken; original query parameters are inherited."),
+                limit: s.integer("Maximum records per page, from 1 to 300; defaults to 100.", {
+                    minimum: 1,
+                    maximum: 300,
+                }),
+                updatedFrom: s.string("Start of the update interval as an ISO 8601 timestamp with timezone. Required on the first page.", { format: "date-time" }),
+                updatedTo: s.string("End of the update interval as an ISO 8601 timestamp with timezone. Required on the first page.", { format: "date-time" }),
+                range: s.stringEnum("Record ownership scope: me or all accessible records; defaults to me.", ["me", "all"]),
+                category: s.array("Exact category names to include.", s.string("A report category.")),
+                type: s.array("Contact report types to include.", s.stringEnum("A contact report type.", ["Meeting", "Call", "Email", "BizCardExchange", "OnlineMeeting"])),
+                orderBy: s.stringEnum("Sort field; defaults to updatedAt.", ["registeredAt", "updatedAt"]),
+                orderDirection: s.stringEnum("Sort direction; defaults to desc.", ["asc", "desc"]),
+            }, { required: [] }),
+            anyOf: [{ required: ["nextPageToken"] }, { required: ["updatedFrom", "updatedTo"] }],
+        },
+        outputSchema: reportPageSchema,
+    }),
+];

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

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

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

@@ -0,0 +1,181 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+export const sansanAdminActions = [
+    defineProviderAction("sansan", {
+        name: "list_departments",
+        description: "List administrative department IDs, names, and parents. System administrator only.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Department pagination.", {
+            nextPageToken: s.nonEmptyString("Continue with the next page token; original filters are inherited."),
+        }, { required: [] }),
+        outputSchema: s.object("A page of administration records.", {
+            data: s.array("Records in this page.", s.object("An administrative department.", {
+                id: s.nonEmptyString("The department ID."),
+                name: s.string("Department name."),
+                parentId: s.nullable(s.string("Parent department ID.")),
+            }, { additionalProperties: true, required: [] })),
+            hasMore: s.boolean("Whether another page is available."),
+            nextPageToken: s.nullable(s.string("The next page token, or null.")),
+        }, { additionalProperties: true, required: ["data", "hasMore", "nextPageToken"] }),
+    }),
+    defineProviderAction("sansan", {
+        name: "get_department_access_control",
+        description: "Get the access control pattern assigned to a department. System administrator only.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Department selection.", {
+            departmentId: s.nonEmptyString("The department ID."),
+        }, { required: ["departmentId"] }),
+        outputSchema: s.object("Department access control assignment.", {
+            departmentId: s.nonEmptyString("The department ID."),
+            accessControlPattern: s.object("A Sansan access control pattern, including upstream-defined fields.", {
+                aclPatternId: s.nonEmptyString("The access control pattern ID."),
+                aclPatternName: s.nonEmptyString("Access control pattern name."),
+                description: s.string("Access control pattern description."),
+                details: s.array("Department access rules.", s.object("Access rule for a target department; additional provider-defined fields are accepted.", {
+                    objectDepartmentId: s.nonEmptyString("The department whose data this rule covers."),
+                    accessibleFieldsSettingsName: s.nonEmptyString("The upstream accessible-fields setting name, such as ALL. Use values configured in Sansan; no complete enum is published."),
+                }, { additionalProperties: true, required: ["objectDepartmentId", "accessibleFieldsSettingsName"] })),
+                isInUse: s.boolean("Whether this pattern is in use."),
+            }, { additionalProperties: true, required: [] }),
+        }, { additionalProperties: true, required: [] }),
+    }),
+    defineProviderAction("sansan", {
+        name: "set_department_access_control",
+        description: "Assign an access control pattern to a department. System administrator only.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: s.object("Department and pattern assignment.", {
+            departmentId: s.nonEmptyString("The department ID."),
+            aclPatternId: s.nonEmptyString("The access control pattern ID."),
+        }, { required: ["departmentId", "aclPatternId"] }),
+        outputSchema: s.object("Successful administration change.", {
+            success: s.boolean("Whether the request succeeded."),
+            data: s.nullable(s.unknownObject("Any JSON payload returned by Sansan.")),
+        }, { required: ["success", "data"] }),
+    }),
+    defineProviderAction("sansan", {
+        name: "list_access_control_patterns",
+        description: "List access control patterns, optionally filtering by a name substring. System administrator only.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Access control pattern search.", {
+            nextPageToken: s.nonEmptyString("Continue with the next page token; original filters are inherited."),
+            name: s.string("Pattern name substring."),
+        }, { required: [] }),
+        outputSchema: s.object("A page of administration records.", {
+            data: s.array("Records in this page.", s.object("A Sansan access control pattern, including upstream-defined fields.", {
+                aclPatternId: s.nonEmptyString("The access control pattern ID."),
+                aclPatternName: s.nonEmptyString("Access control pattern name."),
+                description: s.string("Access control pattern description."),
+                details: s.array("Department access rules.", s.object("Access rule for a target department; additional provider-defined fields are accepted.", {
+                    objectDepartmentId: s.nonEmptyString("The department whose data this rule covers."),
+                    accessibleFieldsSettingsName: s.nonEmptyString("The upstream accessible-fields setting name, such as ALL. Use values configured in Sansan; no complete enum is published."),
+                }, { additionalProperties: true, required: ["objectDepartmentId", "accessibleFieldsSettingsName"] })),
+                isInUse: s.boolean("Whether this pattern is in use."),
+            }, { additionalProperties: true, required: [] })),
+            hasMore: s.boolean("Whether another page is available."),
+            nextPageToken: s.nullable(s.string("The next page token, or null.")),
+        }, { additionalProperties: true, required: ["data", "hasMore", "nextPageToken"] }),
+    }),
+    defineProviderAction("sansan", {
+        name: "create_access_control_pattern",
+        description: "Create an access control pattern with department access rules. System administrator only.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: s.object("New access control pattern.", {
+            aclPatternName: s.nonEmptyString("Access control pattern name."),
+            description: s.string("Access control pattern description."),
+            details: s.array("Department access rules.", s.object("Access rule for a target department; additional provider-defined fields are accepted.", {
+                objectDepartmentId: s.nonEmptyString("The department whose data this rule covers."),
+                accessibleFieldsSettingsName: s.nonEmptyString("The upstream accessible-fields setting name, such as ALL. Use values configured in Sansan; no complete enum is published."),
+            }, { additionalProperties: true, required: ["objectDepartmentId", "accessibleFieldsSettingsName"] })),
+        }, { required: ["aclPatternName", "details"] }),
+        outputSchema: s.object("Created access control pattern.", {
+            id: s.nonEmptyString("The access control pattern ID."),
+        }, { additionalProperties: true, required: ["id"] }),
+    }),
+    defineProviderAction("sansan", {
+        name: "update_access_control_pattern",
+        description: "Update an access control pattern and its department rules. System administrator only.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: s.object("Access control pattern changes.", {
+            patternId: s.nonEmptyString("The access control pattern ID."),
+            aclPatternName: s.nonEmptyString("Access control pattern name."),
+            description: s.string("Access control pattern description."),
+            details: s.array("Department access rules.", s.object("Access rule for a target department; additional provider-defined fields are accepted.", {
+                objectDepartmentId: s.nonEmptyString("The department whose data this rule covers."),
+                accessibleFieldsSettingsName: s.nonEmptyString("The upstream accessible-fields setting name, such as ALL. Use values configured in Sansan; no complete enum is published."),
+            }, { additionalProperties: true, required: ["objectDepartmentId", "accessibleFieldsSettingsName"] })),
+        }, { required: ["patternId"] }),
+        outputSchema: s.object("Successful administration change.", {
+            success: s.boolean("Whether the request succeeded."),
+            data: s.nullable(s.unknownObject("Any JSON payload returned by Sansan.")),
+        }, { required: ["success", "data"] }),
+    }),
+    defineProviderAction("sansan", {
+        name: "delete_access_control_pattern",
+        description: "Delete an access control pattern. System administrator only; Sansan may reject a pattern still in use.",
+        operationType: "destructive",
+        requiredScopes: [],
+        inputSchema: s.object("Access control pattern to delete.", {
+            patternId: s.nonEmptyString("The access control pattern ID."),
+        }, { required: ["patternId"] }),
+        outputSchema: s.object("Successful administration change.", {
+            success: s.boolean("Whether the request succeeded."),
+            data: s.nullable(s.unknownObject("Any JSON payload returned by Sansan.")),
+        }, { required: ["success", "data"] }),
+    }),
+    defineProviderAction("sansan", {
+        name: "get_default_email_client",
+        description: "Get the default email client settings for new users. System administrator only.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("No input is required.", {}, { required: [] }),
+        outputSchema: s.object("Organization default email client; null when not configured.", {
+            settings: s.nullable(s.object("Email client configuration.", {
+                emailClient: s.stringEnum("Default email client for newly added users.", [
+                    "clientSoftware",
+                    "gmail",
+                    "office365",
+                ]),
+                encoding: s.stringEnum("Required only for clientSoftware.", ["sjis", "utf8", "iso2022jp"]),
+            }, { additionalProperties: true, required: [] })),
+        }, { required: ["settings"] }),
+    }),
+    defineProviderAction("sansan", {
+        name: "set_default_email_client",
+        description: "Set the default email client for subsequently added users; users may change it later. System administrator only.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: {
+            ...s.object("Default email client settings.", {
+                emailClient: s.stringEnum("Default email client for newly added users.", [
+                    "clientSoftware",
+                    "gmail",
+                    "office365",
+                ]),
+                encoding: s.stringEnum("Required only for clientSoftware.", ["sjis", "utf8", "iso2022jp"]),
+            }, { required: ["emailClient"] }),
+            allOf: [
+                {
+                    if: { properties: { emailClient: { const: "clientSoftware" } } },
+                    then: { required: ["encoding"] },
+                    else: { not: { required: ["encoding"] } },
+                },
+            ],
+        },
+        outputSchema: s.object("Organization default email client; null when not configured.", {
+            settings: s.nullable(s.object("Email client configuration.", {
+                emailClient: s.stringEnum("Default email client for newly added users.", [
+                    "clientSoftware",
+                    "gmail",
+                    "office365",
+                ]),
+                encoding: s.stringEnum("Required only for clientSoftware.", ["sjis", "utf8", "iso2022jp"]),
+            }, { additionalProperties: true, required: [] })),
+        }, { required: ["settings"] }),
+    }),
+];

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

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

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;