@danyow/lark-mcp 0.5.1

package/dist/mcp-tool/tools/en/gen-tools/zod/tenant_v2.d.ts

@@ -0,0 +1,31 @@
+export type tenantV2ToolName = 'tenant.v2.tenantProductAssignInfo.query' | 'tenant.v2.tenant.query';
+export declare const tenantV2TenantProductAssignInfoQuery: {
+    project: string;
+    name: string;
+    sdkName: string;
+    path: string;
+    httpMethod: string;
+    description: string;
+    accessTokens: string[];
+    schema: {};
+};
+export declare const tenantV2TenantQuery: {
+    project: string;
+    name: string;
+    sdkName: string;
+    path: string;
+    httpMethod: string;
+    description: string;
+    accessTokens: string[];
+    schema: {};
+};
+export declare const tenantV2Tools: {
+    project: string;
+    name: string;
+    sdkName: string;
+    path: string;
+    httpMethod: string;
+    description: string;
+    accessTokens: string[];
+    schema: {};
+}[];

package/dist/mcp-tool/tools/en/gen-tools/zod/tenant_v2.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tenantV2Tools = exports.tenantV2TenantQuery = exports.tenantV2TenantProductAssignInfoQuery = void 0;
+exports.tenantV2TenantProductAssignInfoQuery = {
+    project: 'tenant',
+    name: 'tenant.v2.tenantProductAssignInfo.query',
+    sdkName: 'tenant.v2.tenantProductAssignInfo.query',
+    path: '/open-apis/tenant/v2/tenant/assign_info_list/query',
+    httpMethod: 'GET',
+    description: '[Feishu/Lark]-Company Information-Tenant Product Assign Info-Obtain company assign information-Obtain the seat list to be allocated under the tenant, including seat name, subscription ID, quantity and validity period',
+    accessTokens: ['tenant'],
+    schema: {},
+};
+exports.tenantV2TenantQuery = {
+    project: 'tenant',
+    name: 'tenant.v2.tenant.query',
+    sdkName: 'tenant.v2.tenant.query',
+    path: '/open-apis/tenant/v2/tenant/query',
+    httpMethod: 'GET',
+    description: '[Feishu/Lark]-Company Information-Obtain company information-Obtains company information such as the company name and the company ID',
+    accessTokens: ['tenant'],
+    schema: {},
+};
+exports.tenantV2Tools = [exports.tenantV2TenantProductAssignInfoQuery, exports.tenantV2TenantQuery];

package/dist/mcp-tool/tools/en/gen-tools/zod/translation_v1.d.ts

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+export type translationV1ToolName = 'translation.v1.text.detect' | 'translation.v1.text.translate';
+export declare const translationV1TextDetect: {
+    project: string;
+    name: string;
+    sdkName: string;
+    path: string;
+    httpMethod: string;
+    description: string;
+    accessTokens: string[];
+    schema: {
+        data: z.ZodObject<{
+            text: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            text: string;
+        }, {
+            text: string;
+        }>;
+    };
+};
+export declare const translationV1TextTranslate: {
+    project: string;
+    name: string;
+    sdkName: string;
+    path: string;
+    httpMethod: string;
+    description: string;
+    accessTokens: string[];
+    schema: {
+        data: z.ZodObject<{
+            source_language: z.ZodString;
+            text: z.ZodString;
+            target_language: z.ZodString;
+            glossary: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                from: string;
+                to: string;
+            }, {
+                from: string;
+                to: string;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            text: string;
+            source_language: string;
+            target_language: string;
+            glossary?: {
+                from: string;
+                to: string;
+            }[] | undefined;
+        }, {
+            text: string;
+            source_language: string;
+            target_language: string;
+            glossary?: {
+                from: string;
+                to: string;
+            }[] | undefined;
+        }>;
+    };
+};
+export declare const translationV1Tools: {
+    project: string;
+    name: string;
+    sdkName: string;
+    path: string;
+    httpMethod: string;
+    description: string;
+    accessTokens: string[];
+    schema: {
+        data: z.ZodObject<{
+            text: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            text: string;
+        }, {
+            text: string;
+        }>;
+    };
+}[];

package/dist/mcp-tool/tools/en/gen-tools/zod/translation_v1.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translationV1Tools = exports.translationV1TextTranslate = exports.translationV1TextDetect = void 0;
+const zod_1 = require("zod");
+exports.translationV1TextDetect = {
+    project: 'translation',
+    name: 'translation.v1.text.detect',
+    sdkName: 'translation.v1.text.detect',
+    path: '/open-apis/translation/v1/text/detect',
+    httpMethod: 'POST',
+    description: '[Feishu/Lark]-AI-Machine Translation-Text language recognition-Machine translation (MT), supporting recognition of over 100 languages. The return value is ISO 639-1 compliant',
+    accessTokens: ['tenant'],
+    schema: {
+        data: zod_1.z.object({ text: zod_1.z.string().describe('Text whose language is to be recognized') }),
+    },
+};
+exports.translationV1TextTranslate = {
+    project: 'translation',
+    name: 'translation.v1.text.translate',
+    sdkName: 'translation.v1.text.translate',
+    path: '/open-apis/translation/v1/text/translate',
+    httpMethod: 'POST',
+    description: '[Feishu/Lark]-AI-Machine Translation-Translate text-The following languages are supported for translation: "Zh": Chinese ; "Zh-Hant": Traditional Chinese ; "En": English; " Ja ": Japanese ; " Ru ": Russian ; " de ": German ; " Fr ": French ; "It": Italian ; " pl ": Polish ; " Th ": Thai ; "Hi": Hindi ; "Id": Indonesian ; " es ": Spanish ; " Pt ": Portuguese ; " Ko ": Korean ; " vi ": Vietnamese',
+    accessTokens: ['tenant'],
+    schema: {
+        data: zod_1.z.object({
+            source_language: zod_1.z.string().describe('Source language'),
+            text: zod_1.z.string().describe('Source text, character limit is 1,000'),
+            target_language: zod_1.z.string().describe('Target language'),
+            glossary: zod_1.z
+                .array(zod_1.z.object({ from: zod_1.z.string().describe('Associated text'), to: zod_1.z.string().describe('Translation') }))
+                .describe('Request level glossary with at most 128 terms, valid only in this translation')
+                .optional(),
+        }),
+    },
+};
+exports.translationV1Tools = [exports.translationV1TextDetect, exports.translationV1TextTranslate];

package/dist/mcp-tool/tools/en/gen-tools/zod/trust_party_v1.d.ts

@@ -0,0 +1,182 @@
+import { z } from 'zod';
+export type trustPartyV1ToolName = 'trust_party.v1.collaborationTenantCollaborationDepartment.get' | 'trust_party.v1.collaborationTenantCollaborationUser.get' | 'trust_party.v1.collaborationTenant.get' | 'trust_party.v1.collaborationTenant.list' | 'trust_party.v1.collaborationTenant.visibleOrganization';
+export declare const trustPartyV1CollaborationTenantCollaborationDepartmentGet: {
+    project: string;
+    name: string;
+    sdkName: string;
+    path: string;
+    httpMethod: string;
+    description: string;
+    accessTokens: string[];
+    schema: {
+        params: z.ZodOptional<z.ZodObject<{
+            target_department_id_type: z.ZodOptional<z.ZodEnum<["department_id", "open_department_id"]>>;
+        }, "strip", z.ZodTypeAny, {
+            target_department_id_type?: "department_id" | "open_department_id" | undefined;
+        }, {
+            target_department_id_type?: "department_id" | "open_department_id" | undefined;
+        }>>;
+        path: z.ZodObject<{
+            target_tenant_key: z.ZodString;
+            target_department_id: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            target_tenant_key: string;
+            target_department_id: string;
+        }, {
+            target_tenant_key: string;
+            target_department_id: string;
+        }>;
+        useUAT: z.ZodOptional<z.ZodBoolean>;
+    };
+};
+export declare const trustPartyV1CollaborationTenantCollaborationUserGet: {
+    project: string;
+    name: string;
+    sdkName: string;
+    path: string;
+    httpMethod: string;
+    description: string;
+    accessTokens: string[];
+    schema: {
+        params: z.ZodOptional<z.ZodObject<{
+            target_user_id_type: z.ZodOptional<z.ZodEnum<["user_id", "union_id", "open_id"]>>;
+        }, "strip", z.ZodTypeAny, {
+            target_user_id_type?: "user_id" | "union_id" | "open_id" | undefined;
+        }, {
+            target_user_id_type?: "user_id" | "union_id" | "open_id" | undefined;
+        }>>;
+        path: z.ZodObject<{
+            target_tenant_key: z.ZodString;
+            target_user_id: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            target_tenant_key: string;
+            target_user_id: string;
+        }, {
+            target_tenant_key: string;
+            target_user_id: string;
+        }>;
+        useUAT: z.ZodOptional<z.ZodBoolean>;
+    };
+};
+export declare const trustPartyV1CollaborationTenantGet: {
+    project: string;
+    name: string;
+    sdkName: string;
+    path: string;
+    httpMethod: string;
+    description: string;
+    accessTokens: string[];
+    schema: {
+        path: z.ZodObject<{
+            target_tenant_key: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            target_tenant_key: string;
+        }, {
+            target_tenant_key: string;
+        }>;
+        useUAT: z.ZodOptional<z.ZodBoolean>;
+    };
+};
+export declare const trustPartyV1CollaborationTenantList: {
+    project: string;
+    name: string;
+    sdkName: string;
+    path: string;
+    httpMethod: string;
+    description: string;
+    accessTokens: string[];
+    schema: {
+        params: z.ZodOptional<z.ZodObject<{
+            page_token: z.ZodOptional<z.ZodString>;
+            page_size: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            page_size?: number | undefined;
+            page_token?: string | undefined;
+        }, {
+            page_size?: number | undefined;
+            page_token?: string | undefined;
+        }>>;
+        useUAT: z.ZodOptional<z.ZodBoolean>;
+    };
+};
+export declare const trustPartyV1CollaborationTenantVisibleOrganization: {
+    project: string;
+    name: string;
+    sdkName: string;
+    path: string;
+    httpMethod: string;
+    description: string;
+    accessTokens: string[];
+    schema: {
+        params: z.ZodOptional<z.ZodObject<{
+            department_id_type: z.ZodOptional<z.ZodEnum<["department_id", "open_department_id"]>>;
+            target_department_id: z.ZodOptional<z.ZodString>;
+            page_token: z.ZodOptional<z.ZodString>;
+            page_size: z.ZodOptional<z.ZodNumber>;
+            group_id_type: z.ZodOptional<z.ZodEnum<["group_id", "open_group_id"]>>;
+            target_group_id: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            page_size?: number | undefined;
+            page_token?: string | undefined;
+            department_id_type?: "department_id" | "open_department_id" | undefined;
+            target_department_id?: string | undefined;
+            target_group_id?: string | undefined;
+            group_id_type?: "group_id" | "open_group_id" | undefined;
+        }, {
+            page_size?: number | undefined;
+            page_token?: string | undefined;
+            department_id_type?: "department_id" | "open_department_id" | undefined;
+            target_department_id?: string | undefined;
+            target_group_id?: string | undefined;
+            group_id_type?: "group_id" | "open_group_id" | undefined;
+        }>>;
+        path: z.ZodObject<{
+            target_tenant_key: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            target_tenant_key: string;
+        }, {
+            target_tenant_key: string;
+        }>;
+        useUAT: z.ZodOptional<z.ZodBoolean>;
+    };
+};
+export declare const trustPartyV1Tools: ({
+    project: string;
+    name: string;
+    sdkName: string;
+    path: string;
+    httpMethod: string;
+    description: string;
+    accessTokens: string[];
+    schema: {
+        path: z.ZodObject<{
+            target_tenant_key: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            target_tenant_key: string;
+        }, {
+            target_tenant_key: string;
+        }>;
+        useUAT: z.ZodOptional<z.ZodBoolean>;
+    };
+} | {
+    project: string;
+    name: string;
+    sdkName: string;
+    path: string;
+    httpMethod: string;
+    description: string;
+    accessTokens: string[];
+    schema: {
+        params: z.ZodOptional<z.ZodObject<{
+            page_token: z.ZodOptional<z.ZodString>;
+            page_size: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            page_size?: number | undefined;
+            page_token?: string | undefined;
+        }, {
+            page_size?: number | undefined;
+            page_token?: string | undefined;
+        }>>;
+        useUAT: z.ZodOptional<z.ZodBoolean>;
+    };
+})[];

package/dist/mcp-tool/tools/en/gen-tools/zod/trust_party_v1.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trustPartyV1Tools = exports.trustPartyV1CollaborationTenantVisibleOrganization = exports.trustPartyV1CollaborationTenantList = exports.trustPartyV1CollaborationTenantGet = exports.trustPartyV1CollaborationTenantCollaborationUserGet = exports.trustPartyV1CollaborationTenantCollaborationDepartmentGet = void 0;
+const zod_1 = require("zod");
+exports.trustPartyV1CollaborationTenantCollaborationDepartmentGet = {
+    project: 'trust_party',
+    name: 'trust_party.v1.collaborationTenantCollaborationDepartment.get',
+    sdkName: 'trust_party.v1.collaborationTenantCollaborationDepartment.get',
+    path: '/open-apis/trust_party/v1/collaboration_tenants/:target_tenant_key/collaboration_departments/:target_department_id',
+    httpMethod: 'GET',
+    description: "[Feishu/Lark]-Trust Party-Collaboraiton Organization-Query department details of trusted party-Get the details of the organization's trusted party department, and you nee permission to the department to query the information. When using the user_access_token, the verification shall be aligned with the visibility rules set for the user in the trusted party list on the admin console. When using the tenant_access_token, the verification shall be aligned with the rules set for the application in the application sharing",
+    accessTokens: ['tenant', 'user'],
+    schema: {
+        params: zod_1.z
+            .object({
+            target_department_id_type: zod_1.z
+                .enum(['department_id', 'open_department_id'])
+                .describe('Related organization imported parameters Department type Options:department_id(Department ID),open_department_id(Department open ID)')
+                .optional(),
+        })
+            .optional(),
+        path: zod_1.z.object({
+            target_tenant_key: zod_1.z.string().describe('The tenant key of the collaboration organization'),
+            target_department_id: zod_1.z.string().describe("The department of the other party's collaboration organization"),
+        }),
+        useUAT: zod_1.z.boolean().describe('Use user access token, otherwise use tenant access token').optional(),
+    },
+};
+exports.trustPartyV1CollaborationTenantCollaborationUserGet = {
+    project: 'trust_party',
+    name: 'trust_party.v1.collaborationTenantCollaborationUser.get',
+    sdkName: 'trust_party.v1.collaborationTenantCollaborationUser.get',
+    path: '/open-apis/trust_party/v1/collaboration_tenants/:target_tenant_key/collaboration_users/:target_user_id',
+    httpMethod: 'GET',
+    description: '[Feishu/Lark]-Trust Party-Collaboraiton Organization-Query the details of trusted party members-To obtain the trusted party member details, you need to have permissions on the trust party members to obtain them',
+    accessTokens: ['tenant', 'user'],
+    schema: {
+        params: zod_1.z
+            .object({
+            target_user_id_type: zod_1.z
+                .enum(['user_id', 'union_id', 'open_id'])
+                .describe('user ID type, can be obtained by [Query details of trusted party members and departments] Options:user_id(Identify users user_id),union_id(Identify users union_id),open_id(Identify users open_id)')
+                .optional(),
+        })
+            .optional(),
+        path: zod_1.z.object({
+            target_tenant_key: zod_1.z
+                .string()
+                .describe('The tenant key of the other party. It can be obtained through [Query the list of trusted parties by Admin]'),
+            target_user_id: zod_1.z.string().describe('The requested collaboration user ID'),
+        }),
+        useUAT: zod_1.z.boolean().describe('Use user access token, otherwise use tenant access token').optional(),
+    },
+};
+exports.trustPartyV1CollaborationTenantGet = {
+    project: 'trust_party',
+    name: 'trust_party.v1.collaborationTenant.get',
+    sdkName: 'trust_party.v1.collaborationTenant.get',
+    path: '/open-apis/trust_party/v1/collaboration_tenants/:target_tenant_key',
+    httpMethod: 'GET',
+    description: '[Feishu/Lark]-Trust Party-Collaboraiton Organization-Query the trusted party information-Obtain the trusted party information based on the tenant key, and you need to have permission to the other tenant to obtain it.When using the user_access_token, the verification shall be aligned with the visibility rules set for the user in the trusted party on the admin console. When using the tenant_access_token, the verification shall be aligned with the visibility rules set for the application in the application sharing',
+    accessTokens: ['tenant', 'user'],
+    schema: {
+        path: zod_1.z.object({
+            target_tenant_key: zod_1.z
+                .string()
+                .describe('The tenant key of the associated organization of the other party. It can be obtained through [Query the list of trusted parties by Admin]'),
+        }),
+        useUAT: zod_1.z.boolean().describe('Use user access token, otherwise use tenant access token').optional(),
+    },
+};
+exports.trustPartyV1CollaborationTenantList = {
+    project: 'trust_party',
+    name: 'trust_party.v1.collaborationTenant.list',
+    sdkName: 'trust_party.v1.collaborationTenant.list',
+    path: '/open-apis/trust_party/v1/collaboration_tenants',
+    httpMethod: 'GET',
+    description: '[Feishu/Lark]-Trust Party-Collaboraiton Organization-Query visible trusted parties list-Query a list of trusted parties visible to the user. When using the user_access_token, the permissions shall be aligned with the visibility rules set for the user in the trusted parties list on the admin console. When using the tenant_access_token, the permissions shall be aligned with the visibility rules set for the application in the application sharing',
+    accessTokens: ['tenant', 'user'],
+    schema: {
+        params: zod_1.z
+            .object({
+            page_token: zod_1.z
+                .string()
+                .describe('Page identifier. It is not filled in the first request, indicating traversal from the beginning when there will be more groups, the new page_token will be returned at the same time, and the next traversal can use the page_token to get more groups')
+                .optional(),
+            page_size: zod_1.z.number().describe('Number of affiliated organizations per request').optional(),
+        })
+            .optional(),
+        useUAT: zod_1.z.boolean().describe('Use user access token, otherwise use tenant access token').optional(),
+    },
+};
+exports.trustPartyV1CollaborationTenantVisibleOrganization = {
+    project: 'trust_party',
+    name: 'trust_party.v1.collaborationTenant.visibleOrganization',
+    sdkName: 'trust_party.v1.collaborationTenant.visibleOrganization',
+    path: '/open-apis/trust_party/v1/collaboration_tenants/:target_tenant_key/visible_organization',
+    httpMethod: 'GET',
+    description: '[Feishu/Lark]-Trust Party-Collaboraiton Organization-Query department and member information for trusted party-The query will return the lower-level departments, users, and user groups that are visible to the user under the collaboration department',
+    accessTokens: ['tenant', 'user'],
+    schema: {
+        params: zod_1.z
+            .object({
+            department_id_type: zod_1.z
+                .enum(['department_id', 'open_department_id'])
+                .describe('The type of department ID used in this function call Options:department_id(Identify departments with custom department_id),open_department_id(Identify departments by open_department_id)')
+                .optional(),
+            target_department_id: zod_1.z
+                .string()
+                .describe('Request the department ID of the associated organization, 0 represents the root department, and choose one of the target_group_id it can be obtained from [Query departments and member information for truyst parties]')
+                .optional(),
+            page_token: zod_1.z
+                .string()
+                .describe('Page identifier. It is not filled in the first request, indicating traversal from the beginning; when there will be more groups, the new page_token will be returned at the same time, and the next traversal can use the page_token to get more groups')
+                .optional(),
+            page_size: zod_1.z.number().describe('Number of visible entities requested').optional(),
+            group_id_type: zod_1.z
+                .enum(['group_id', 'open_group_id'])
+                .describe('The type of user group ID used in this call Options:group_id(group_id),open_group_id(Identify group by open_group_id)')
+                .optional(),
+            target_group_id: zod_1.z
+                .string()
+                .describe('Request the user group ID of the associated organization, choose one of target_department_id')
+                .optional(),
+        })
+            .optional(),
+        path: zod_1.z.object({
+            target_tenant_key: zod_1.z
+                .string()
+                .describe('The tenant key of the associated organization of the other party. It can be obtained through [Query the list of trusted parties by Admin]'),
+        }),
+        useUAT: zod_1.z.boolean().describe('Use user access token, otherwise use tenant access token').optional(),
+    },
+};
+exports.trustPartyV1Tools = [
+    exports.trustPartyV1CollaborationTenantCollaborationDepartmentGet,
+    exports.trustPartyV1CollaborationTenantCollaborationUserGet,
+    exports.trustPartyV1CollaborationTenantGet,
+    exports.trustPartyV1CollaborationTenantList,
+    exports.trustPartyV1CollaborationTenantVisibleOrganization,
+];