@zapier/zapier-sdk 0.77.1 → 0.77.2

package/dist/plugins/tables/createTableRecords/schemas.js

@@ -1,55 +0,0 @@
-import { z } from "zod";
-import { TablePropertySchema } from "../../../types/properties";
-import { RecordApiItemSchema, RecordItemSchema, } from "../getTableRecord/schemas";
-import { KeyModeSchema } from "../utils";
-// Re-export for consumers
-export { RecordItemSchema };
-// The API returns changesets with old/new values
-const RecordChangesetSchema = z.object({
-    change_id: z.string(),
-    old: RecordApiItemSchema.nullable(),
-    new: RecordApiItemSchema,
-    changed_field_ids: z.array(z.number()).nullable(),
-    record_id: z.string(),
-});
-export const CreateTableRecordsApiResponseSchema = z.object({
-    data: z.array(RecordChangesetSchema),
-});
-export const NewRecordSchema = z.object({
-    data: z
-        .record(z.string(), z.unknown())
-        .describe("The field values for the record, keyed by field ID"),
-});
-const CreateTableRecordsDescription = "Create one or more records in a table";
-const CreateTableRecordsBase = z.object({
-    records: z
-        .array(NewRecordSchema)
-        .min(1)
-        .max(100)
-        .describe("Array of records to create (max 100)"),
-    keyMode: KeyModeSchema,
-});
-// Schema for docs/registry (new param names only)
-export const CreateTableRecordsOptionsSchema = z
-    .object({
-    table: TablePropertySchema,
-})
-    .merge(CreateTableRecordsBase)
-    .describe(CreateTableRecordsDescription)
-    .meta({ aliases: { tableId: "table" } });
-// Deprecated schema (backward compat)
-const CreateTableRecordsOptionsSchemaDeprecated = z
-    .object({
-    tableId: z
-        .string()
-        .regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID")
-        .describe("The unique identifier of the table"),
-})
-    .merge(CreateTableRecordsBase);
-// Union for runtime validation
-export const CreateTableRecordsOptionsInputSchema = z
-    .union([
-    CreateTableRecordsOptionsSchema,
-    CreateTableRecordsOptionsSchemaDeprecated,
-])
-    .describe(CreateTableRecordsDescription);

package/dist/plugins/tables/deleteTable/index.d.ts

@@ -1,74 +0,0 @@
-import type { CapabilitiesContext } from "../../capabilities";
-export declare const deleteTablePlugin: (sdk: {
-    context: {
-        api: import("../../..").ApiClient;
-        resolveCredentials: () => Promise<string | {
-            clientId: string;
-            clientSecret: string;
-            type?: "client_credentials" | undefined;
-            baseUrl?: string | undefined;
-            scope?: string | undefined;
-        } | {
-            clientId: string;
-            type?: "pkce" | undefined;
-            baseUrl?: string | undefined;
-            scope?: string | undefined;
-        } | undefined>;
-    };
-} & {
-    context: import("../../eventEmission").EventEmissionContext;
-} & {
-    listTables: (options?: ({
-        tables?: string[] | undefined;
-        tableIds?: string[] | undefined;
-        kind?: "table" | "virtual_table" | "both" | undefined;
-        search?: string | undefined;
-        owner?: string | undefined;
-        includeShared?: boolean | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        id: string;
-        name: string;
-        created_at: string;
-        edited_at: string;
-        kind: "table" | "virtual_table";
-        account_id: string;
-        profile_id: string;
-        description?: string | undefined;
-        parent_table_id?: string | undefined;
-    }>;
-} & {
-    context: {
-        meta: {
-            listTables: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    context: CapabilitiesContext;
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    deleteTable: (options?: {
-        table: string;
-    } | {
-        tableId: string;
-    } | undefined) => Promise<{
-        success: boolean;
-    }>;
-} & {
-    context: {
-        meta: {
-            deleteTable: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type DeleteTablePluginProvides = ReturnType<typeof deleteTablePlugin>;
-//# sourceMappingURL=index.d.ts.map

package/dist/plugins/tables/deleteTable/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/deleteTable/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAK9D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAIc,mBAAmB;;;;;;;;;;;;;;;;;;;CAwB9D,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/plugins/tables/deleteTable/index.js

@@ -1,23 +0,0 @@
-import { definePlugin } from "kitcore";
-import { createPluginMethod } from "kitcore";
-import { DeleteTableOptionsInputSchema } from "./schemas";
-import { tableIdResolver } from "../../../resolvers";
-import { tablesDefaults } from "../shared";
-export const deleteTablePlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...tablesDefaults,
-    name: "deleteTable",
-    type: "delete",
-    itemType: "Table",
-    inputSchema: DeleteTableOptionsInputSchema,
-    resolvers: { table: tableIdResolver },
-    confirm: "delete",
-    handler: async ({ sdk, options }) => {
-        await sdk.context.checkCapability("canDeleteTables");
-        const tableId = "table" in options ? options.table : options.tableId;
-        await sdk.context.api.delete(`/tables/api/v1/tables/${tableId}`, undefined, {
-            authRequired: true,
-            resource: { type: "table", id: tableId },
-        });
-        return { success: true };
-    },
-}));

package/dist/plugins/tables/deleteTable/schemas.d.ts

@@ -1,28 +0,0 @@
-import { z } from "zod";
-export declare const DeleteTableOptionsSchema: z.ZodObject<{
-    table: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-}, z.core.$strip>;
-declare const DeleteTableOptionsSchemaDeprecated: z.ZodObject<{
-    tableId: z.ZodString;
-}, z.core.$strip>;
-export declare const DeleteTableOptionsInputSchema: z.ZodUnion<readonly [z.ZodObject<{
-    table: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-}, z.core.$strip>, z.ZodObject<{
-    tableId: z.ZodString;
-}, z.core.$strip>]>;
-export type DeleteTableOptions = z.infer<typeof DeleteTableOptionsSchema> | (Omit<z.infer<typeof DeleteTableOptionsSchemaDeprecated>, "tableId"> & {
-    /** @deprecated Use `table` instead. */
-    tableId: z.infer<typeof DeleteTableOptionsSchemaDeprecated>["tableId"];
-});
-export interface DeleteTableResult {
-    success: boolean;
-}
-export interface DeleteTableSdkFunction {
-    deleteTable: (options: DeleteTableOptions) => Promise<DeleteTableResult>;
-}
-export {};
-//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/tables/deleteTable/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/deleteTable/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,wBAAwB;;;;iBAKK,CAAC;AAG3C,QAAA,MAAM,kCAAkC;;iBAKtC,CAAC;AAGH,eAAO,MAAM,6BAA6B;;;;;;mBAEP,CAAC;AAGpC,MAAM,MAAM,kBAAkB,GAC1B,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,GACxC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,EAAE,SAAS,CAAC,GAAG;IACrE,uCAAuC;IACvC,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC,SAAS,CAAC,CAAC;CACxE,CAAC,CAAC;AAGP,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;CAClB;AAGD,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC;CAC1E"}

package/dist/plugins/tables/deleteTable/schemas.js

@@ -1,21 +0,0 @@
-import { z } from "zod";
-import { TablePropertySchema } from "../../../types/properties";
-const DeleteTableDescription = "Delete a table by its ID";
-// Schema for docs/registry (new param names only)
-export const DeleteTableOptionsSchema = z
-    .object({
-    table: TablePropertySchema,
-})
-    .describe(DeleteTableDescription)
-    .meta({ aliases: { tableId: "table" } });
-// Deprecated schema (backward compat)
-const DeleteTableOptionsSchemaDeprecated = z.object({
-    tableId: z
-        .string()
-        .regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID")
-        .describe("The unique identifier of the table to delete"),
-});
-// Union for runtime validation
-export const DeleteTableOptionsInputSchema = z
-    .union([DeleteTableOptionsSchema, DeleteTableOptionsSchemaDeprecated])
-    .describe(DeleteTableDescription);

package/dist/plugins/tables/deleteTableFields/index.d.ts

@@ -1,102 +0,0 @@
-export declare const deleteTableFieldsPlugin: (sdk: {
-    context: {
-        api: import("../../..").ApiClient;
-        resolveCredentials: () => Promise<string | {
-            clientId: string;
-            clientSecret: string;
-            type?: "client_credentials" | undefined;
-            baseUrl?: string | undefined;
-            scope?: string | undefined;
-        } | {
-            clientId: string;
-            type?: "pkce" | undefined;
-            baseUrl?: string | undefined;
-            scope?: string | undefined;
-        } | undefined>;
-    };
-} & {
-    context: import("../../eventEmission").EventEmissionContext;
-} & {
-    listTables: (options?: ({
-        tables?: string[] | undefined;
-        tableIds?: string[] | undefined;
-        kind?: "table" | "virtual_table" | "both" | undefined;
-        search?: string | undefined;
-        owner?: string | undefined;
-        includeShared?: boolean | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        id: string;
-        name: string;
-        created_at: string;
-        edited_at: string;
-        kind: "table" | "virtual_table";
-        account_id: string;
-        profile_id: string;
-        description?: string | undefined;
-        parent_table_id?: string | undefined;
-    }>;
-} & {
-    context: {
-        meta: {
-            listTables: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    listTableFields: (options?: {
-        table: string;
-        fields?: (string | number)[] | undefined;
-        fieldKeys?: (string | number)[] | undefined;
-        trash?: "only" | "include" | "exclude" | undefined;
-    } | {
-        tableId: string;
-        fields?: (string | number)[] | undefined;
-        fieldKeys?: (string | number)[] | undefined;
-        trash?: "only" | "include" | "exclude" | undefined;
-    } | undefined) => Promise<{
-        data: {
-            id: string;
-            type: "string" | "number" | "boolean" | "text" | "datetime" | "decimal" | "json" | "email" | "link" | "multiple_string" | "labeled_string" | "multiple_labeled_string" | "multiple_text" | "multiple_boolean" | "multiple_number" | "multiple_decimal" | "multiple_datetime" | "uuid" | "multiple_uuid" | "multiple_json" | "formula" | "button_trigger_zap" | "button_continue_zap" | "multiple_email" | "multiple_link" | "currency" | "phone_number" | "ai_formula" | "linked_record" | "multiple_linked_record";
-            name: string;
-            created_at?: string | undefined;
-            edited_at?: string | undefined;
-            options?: Record<string, unknown> | undefined;
-            config?: Record<string, unknown> | undefined;
-            deleted_at?: string | null | undefined;
-        }[];
-    }>;
-} & {
-    context: {
-        meta: {
-            listTableFields: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    deleteTableFields: (options?: {
-        table: string;
-        fields: (string | number)[];
-    } | {
-        tableId: string;
-        fieldKeys: (string | number)[];
-    } | undefined) => Promise<{
-        success: boolean;
-    }>;
-} & {
-    context: {
-        meta: {
-            deleteTableFields: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type DeleteTableFieldsPluginProvides = ReturnType<typeof deleteTableFieldsPlugin>;
-//# sourceMappingURL=index.d.ts.map

package/dist/plugins/tables/deleteTableFields/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/deleteTableFields/index.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCnC,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG,UAAU,CACtD,OAAO,uBAAuB,CAC/B,CAAC"}

package/dist/plugins/tables/deleteTableFields/index.js

@@ -1,30 +0,0 @@
-import { definePlugin } from "kitcore";
-import { createPluginMethod } from "kitcore";
-import { DeleteTableFieldsOptionsInputSchema } from "./schemas";
-import { tableIdResolver, tableFieldIdsResolver } from "../../../resolvers";
-import { resolveFieldKeys } from "../utils";
-import { tablesDefaults } from "../shared";
-export const deleteTableFieldsPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...tablesDefaults,
-    name: "deleteTableFields",
-    type: "delete",
-    itemType: "Field",
-    inputSchema: DeleteTableFieldsOptionsInputSchema,
-    resolvers: { table: tableIdResolver, fields: tableFieldIdsResolver },
-    confirm: "delete",
-    handler: async ({ sdk, options }) => {
-        const { api } = sdk.context;
-        const tableId = "table" in options ? options.table : options.tableId;
-        const fieldKeys = "fields" in options ? options.fields : options.fieldKeys;
-        const numericFieldIds = await resolveFieldKeys({
-            api,
-            tableId,
-            fieldKeys,
-        });
-        await api.delete(`/tables/api/v1/tables/${tableId}/fields`, { field_ids: numericFieldIds }, {
-            authRequired: true,
-            resource: { type: "table", id: tableId },
-        });
-        return { success: true };
-    },
-}));

package/dist/plugins/tables/deleteTableFields/schemas.d.ts

@@ -1,34 +0,0 @@
-import { z } from "zod";
-export declare const DeleteTableFieldsOptionsSchema: z.ZodObject<{
-    table: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-    fields: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-}, z.core.$strip>;
-declare const DeleteTableFieldsOptionsSchemaDeprecated: z.ZodObject<{
-    tableId: z.ZodString;
-    fieldKeys: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-}, z.core.$strip>;
-export declare const DeleteTableFieldsOptionsInputSchema: z.ZodUnion<readonly [z.ZodObject<{
-    table: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-    fields: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-}, z.core.$strip>, z.ZodObject<{
-    tableId: z.ZodString;
-    fieldKeys: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-}, z.core.$strip>]>;
-export type DeleteTableFieldsOptions = z.infer<typeof DeleteTableFieldsOptionsSchema> | (Omit<z.infer<typeof DeleteTableFieldsOptionsSchemaDeprecated>, "tableId" | "fieldKeys"> & {
-    /** @deprecated Use `table` instead. */
-    tableId: z.infer<typeof DeleteTableFieldsOptionsSchemaDeprecated>["tableId"];
-    /** @deprecated Use `fields` instead. */
-    fieldKeys: z.infer<typeof DeleteTableFieldsOptionsSchemaDeprecated>["fieldKeys"];
-});
-export interface DeleteTableFieldsResult {
-    success: boolean;
-}
-export interface DeleteTableFieldsSdkFunction {
-    deleteTableFields: (options: DeleteTableFieldsOptions) => Promise<DeleteTableFieldsResult>;
-}
-export {};
-//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/tables/deleteTableFields/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/deleteTableFields/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,8BAA8B;;;;;iBAMoB,CAAC;AAGhE,QAAA,MAAM,wCAAwC;;;iBAW5C,CAAC;AAGH,eAAO,MAAM,mCAAmC;;;;;;;;mBAKP,CAAC;AAG1C,MAAM,MAAM,wBAAwB,GAChC,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,GAC9C,CAAC,IAAI,CACH,CAAC,CAAC,KAAK,CAAC,OAAO,wCAAwC,CAAC,EACxD,SAAS,GAAG,WAAW,CACxB,GAAG;IACF,uCAAuC;IACvC,OAAO,EAAE,CAAC,CAAC,KAAK,CACd,OAAO,wCAAwC,CAChD,CAAC,SAAS,CAAC,CAAC;IACb,wCAAwC;IACxC,SAAS,EAAE,CAAC,CAAC,KAAK,CAChB,OAAO,wCAAwC,CAChD,CAAC,WAAW,CAAC,CAAC;CAChB,CAAC,CAAC;AAGP,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAC;CAClB;AAGD,MAAM,WAAW,4BAA4B;IAC3C,iBAAiB,EAAE,CACjB,OAAO,EAAE,wBAAwB,KAC9B,OAAO,CAAC,uBAAuB,CAAC,CAAC;CACvC"}

package/dist/plugins/tables/deleteTableFields/schemas.js

@@ -1,29 +0,0 @@
-import { z } from "zod";
-import { TablePropertySchema, FieldsPropertySchema, } from "../../../types/properties";
-const DeleteTableFieldsDescription = "Delete one or more fields from a table";
-// Schema for docs/registry (new param names only)
-export const DeleteTableFieldsOptionsSchema = z
-    .object({
-    table: TablePropertySchema,
-    fields: FieldsPropertySchema.min(1),
-})
-    .describe(DeleteTableFieldsDescription)
-    .meta({ aliases: { tableId: "table", fieldKeys: "fields" } });
-// Deprecated schema (backward compat)
-const DeleteTableFieldsOptionsSchemaDeprecated = z.object({
-    tableId: z
-        .string()
-        .regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID")
-        .describe("The unique identifier of the table"),
-    fieldKeys: z
-        .array(z.union([z.string(), z.number()]))
-        .min(1)
-        .describe('Fields to delete. Accepts field names (e.g., "Email") or IDs (e.g., "f6", "6", or 6).'),
-});
-// Union for runtime validation
-export const DeleteTableFieldsOptionsInputSchema = z
-    .union([
-    DeleteTableFieldsOptionsSchema,
-    DeleteTableFieldsOptionsSchemaDeprecated,
-])
-    .describe(DeleteTableFieldsDescription);

package/dist/plugins/tables/deleteTableRecords/index.d.ts

@@ -1,123 +0,0 @@
-export declare const deleteTableRecordsPlugin: (sdk: {
-    context: {
-        api: import("../../..").ApiClient;
-        resolveCredentials: () => Promise<string | {
-            clientId: string;
-            clientSecret: string;
-            type?: "client_credentials" | undefined;
-            baseUrl?: string | undefined;
-            scope?: string | undefined;
-        } | {
-            clientId: string;
-            type?: "pkce" | undefined;
-            baseUrl?: string | undefined;
-            scope?: string | undefined;
-        } | undefined>;
-    };
-} & {
-    context: import("../../eventEmission").EventEmissionContext;
-} & {
-    listTables: (options?: ({
-        tables?: string[] | undefined;
-        tableIds?: string[] | undefined;
-        kind?: "table" | "virtual_table" | "both" | undefined;
-        search?: string | undefined;
-        owner?: string | undefined;
-        includeShared?: boolean | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        id: string;
-        name: string;
-        created_at: string;
-        edited_at: string;
-        kind: "table" | "virtual_table";
-        account_id: string;
-        profile_id: string;
-        description?: string | undefined;
-        parent_table_id?: string | undefined;
-    }>;
-} & {
-    context: {
-        meta: {
-            listTables: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    listTableRecords: (options?: (({
-        table: string;
-        keyMode: "names" | "ids";
-        filters?: {
-            fieldKey: string;
-            operator: "in" | "contains" | "gt" | "gte" | "lt" | "lte" | "search" | "exact" | "different" | "icontains" | "range" | "isnull" | "startswith" | "is_within";
-            value?: unknown;
-        }[] | undefined;
-        sort?: {
-            fieldKey: string;
-            direction: "asc" | "desc";
-        } | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-        trash?: "only" | "include" | "exclude" | undefined;
-    } | {
-        tableId: string;
-        keyMode: "names" | "ids";
-        filters?: {
-            fieldKey: string;
-            operator: "in" | "contains" | "gt" | "gte" | "lt" | "lte" | "search" | "exact" | "different" | "icontains" | "range" | "isnull" | "startswith" | "is_within";
-            value?: unknown;
-        }[] | undefined;
-        sort?: {
-            fieldKey: string;
-            direction: "asc" | "desc";
-        } | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-        trash?: "only" | "include" | "exclude" | undefined;
-    }) & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        data: Record<string, unknown>;
-        id: string;
-        created_at: string;
-        edited_at: string;
-        deleted_at?: string | null | undefined;
-    }>;
-} & {
-    context: {
-        meta: {
-            listTableRecords: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    deleteTableRecords: (options?: {
-        table: string;
-        records: string[];
-    } | {
-        tableId: string;
-        recordIds: string[];
-    } | undefined) => Promise<{
-        success: boolean;
-    }>;
-} & {
-    context: {
-        meta: {
-            deleteTableRecords: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type DeleteTableRecordsPluginProvides = ReturnType<typeof deleteTableRecordsPlugin>;
-//# sourceMappingURL=index.d.ts.map

package/dist/plugins/tables/deleteTableRecords/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/deleteTableRecords/index.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BpC,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG,UAAU,CACvD,OAAO,wBAAwB,CAChC,CAAC"}

package/dist/plugins/tables/deleteTableRecords/index.js

@@ -1,23 +0,0 @@
-import { definePlugin } from "kitcore";
-import { createPluginMethod } from "kitcore";
-import { DeleteTableRecordsOptionsInputSchema } from "./schemas";
-import { tableIdResolver, tableRecordIdsResolver } from "../../../resolvers";
-import { tablesDefaults } from "../shared";
-export const deleteTableRecordsPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...tablesDefaults,
-    name: "deleteTableRecords",
-    type: "delete",
-    itemType: "Record",
-    inputSchema: DeleteTableRecordsOptionsInputSchema,
-    resolvers: { table: tableIdResolver, records: tableRecordIdsResolver },
-    confirm: "delete",
-    handler: async ({ sdk, options }) => {
-        const tableId = "table" in options ? options.table : options.tableId;
-        const recordIds = "records" in options ? options.records : options.recordIds;
-        await sdk.context.api.delete(`/tables/api/v1/tables/${tableId}/records`, { record_ids: recordIds }, {
-            authRequired: true,
-            resource: { type: "table", id: tableId },
-        });
-        return { success: true };
-    },
-}));

package/dist/plugins/tables/deleteTableRecords/schemas.d.ts

@@ -1,34 +0,0 @@
-import { z } from "zod";
-export declare const DeleteTableRecordsOptionsSchema: z.ZodObject<{
-    table: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-    records: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
-declare const DeleteTableRecordsOptionsSchemaDeprecated: z.ZodObject<{
-    tableId: z.ZodString;
-    recordIds: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
-export declare const DeleteTableRecordsOptionsInputSchema: z.ZodUnion<readonly [z.ZodObject<{
-    table: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-    records: z.ZodArray<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    tableId: z.ZodString;
-    recordIds: z.ZodArray<z.ZodString>;
-}, z.core.$strip>]>;
-export type DeleteTableRecordsOptions = z.infer<typeof DeleteTableRecordsOptionsSchema> | (Omit<z.infer<typeof DeleteTableRecordsOptionsSchemaDeprecated>, "tableId" | "recordIds"> & {
-    /** @deprecated Use `table` instead. */
-    tableId: z.infer<typeof DeleteTableRecordsOptionsSchemaDeprecated>["tableId"];
-    /** @deprecated Use `records` instead. */
-    recordIds: z.infer<typeof DeleteTableRecordsOptionsSchemaDeprecated>["recordIds"];
-});
-export interface DeleteTableRecordsResult {
-    success: boolean;
-}
-export interface DeleteTableRecordsSdkFunction {
-    deleteTableRecords: (options: DeleteTableRecordsOptions) => Promise<DeleteTableRecordsResult>;
-}
-export {};
-//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/tables/deleteTableRecords/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/deleteTableRecords/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,+BAA+B;;;;;iBAMoB,CAAC;AAGjE,QAAA,MAAM,yCAAyC;;;iBAU7C,CAAC;AAGH,eAAO,MAAM,oCAAoC;;;;;;;;mBAKP,CAAC;AAG3C,MAAM,MAAM,yBAAyB,GACjC,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,GAC/C,CAAC,IAAI,CACH,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,EACzD,SAAS,GAAG,WAAW,CACxB,GAAG;IACF,uCAAuC;IACvC,OAAO,EAAE,CAAC,CAAC,KAAK,CACd,OAAO,yCAAyC,CACjD,CAAC,SAAS,CAAC,CAAC;IACb,yCAAyC;IACzC,SAAS,EAAE,CAAC,CAAC,KAAK,CAChB,OAAO,yCAAyC,CACjD,CAAC,WAAW,CAAC,CAAC;CAChB,CAAC,CAAC;AAEP,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,6BAA6B;IAC5C,kBAAkB,EAAE,CAClB,OAAO,EAAE,yBAAyB,KAC/B,OAAO,CAAC,wBAAwB,CAAC,CAAC;CACxC"}

package/dist/plugins/tables/deleteTableRecords/schemas.js

@@ -1,30 +0,0 @@
-import { z } from "zod";
-import { TablePropertySchema, RecordsPropertySchema, } from "../../../types/properties";
-const DeleteTableRecordsDescription = "Delete one or more records from a table";
-// Schema for docs/registry (new param names only)
-export const DeleteTableRecordsOptionsSchema = z
-    .object({
-    table: TablePropertySchema,
-    records: RecordsPropertySchema,
-})
-    .describe(DeleteTableRecordsDescription)
-    .meta({ aliases: { tableId: "table", recordIds: "records" } });
-// Deprecated schema (backward compat)
-const DeleteTableRecordsOptionsSchemaDeprecated = z.object({
-    tableId: z
-        .string()
-        .regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID")
-        .describe("The unique identifier of the table"),
-    recordIds: z
-        .array(z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID"))
-        .min(1)
-        .max(100)
-        .describe("Array of record IDs to delete (max 100)"),
-});
-// Union for runtime validation
-export const DeleteTableRecordsOptionsInputSchema = z
-    .union([
-    DeleteTableRecordsOptionsSchema,
-    DeleteTableRecordsOptionsSchemaDeprecated,
-])
-    .describe(DeleteTableRecordsDescription);