UNPKG

shapelessai-ai-sdk

Version:

ShapelessAI tools for the Vercel AI SDK: list connected social accounts, schedule or publish posts, read post status.

shapelessai.com/docs/ai-sdk

FirstClassTree/shapelessai

2,112 lines • 87.1 kB
export type ShapelessAIOptions = {
    /** An slk_ API key from https://shapelessai.com/studio/api-keys. Defaults to process.env.SHAPELESSAI_API_KEY. */
    apiKey?: string;
    baseURL?: string;
    /** Ask the user before a post is created. On by default: a post is visible to the account's audience. */
    needsApproval?: boolean;
};
/** The social accounts the key's owner connected, the ones a post can go to. */
export declare function listAccounts(opts?: ShapelessAIOptions): ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        platform?: string | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        platform?: string | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            platform?: string | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            platform?: string | undefined;
        };
        output: NoInfer<{
            connectionId: string;
            platform: string;
            handle: string;
            name: string;
        }[]>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        connectionId: string;
        platform: string;
        handle: string;
        name: string;
    }[]> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        platform?: string | undefined;
    }, {
        connectionId: string;
        platform: string;
        handle: string;
        name: string;
    }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            platform?: string | undefined;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type?: undefined | "function";
} & {
    execute: import("ai").ToolExecuteFunction<{
        platform?: string | undefined;
    }, {
        connectionId: string;
        platform: string;
        handle: string;
        name: string;
    }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        platform?: string | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        platform?: string | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            platform?: string | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            platform?: string | undefined;
        };
        output: NoInfer<{
            connectionId: string;
            platform: string;
            handle: string;
            name: string;
        }[]>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        connectionId: string;
        platform: string;
        handle: string;
        name: string;
    }[]> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        platform?: string | undefined;
    }, {
        connectionId: string;
        platform: string;
        handle: string;
        name: string;
    }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            platform?: string | undefined;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type: "dynamic";
} & {
    execute: import("ai").ToolExecuteFunction<{
        platform?: string | undefined;
    }, {
        connectionId: string;
        platform: string;
        handle: string;
        name: string;
    }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        platform?: string | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        platform?: string | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            platform?: string | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            platform?: string | undefined;
        };
        output: NoInfer<{
            connectionId: string;
            platform: string;
            handle: string;
            name: string;
        }[]>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        connectionId: string;
        platform: string;
        handle: string;
        name: string;
    }[]> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        platform?: string | undefined;
    }, {
        connectionId: string;
        platform: string;
        handle: string;
        name: string;
    }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: "provider";
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: false;
    supportsDeferredResults?: never;
} & {
    execute: import("ai").ToolExecuteFunction<{
        platform?: string | undefined;
    }, {
        connectionId: string;
        platform: string;
        handle: string;
        name: string;
    }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        platform?: string | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        platform?: string | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            platform?: string | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            platform?: string | undefined;
        };
        output: NoInfer<{
            connectionId: string;
            platform: string;
            handle: string;
            name: string;
        }[]>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        connectionId: string;
        platform: string;
        handle: string;
        name: string;
    }[]> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        platform?: string | undefined;
    }, {
        connectionId: string;
        platform: string;
        handle: string;
        name: string;
    }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: "provider";
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: true;
    supportsDeferredResults?: boolean;
} & {
    execute: import("ai").ToolExecuteFunction<{
        platform?: string | undefined;
    }, {
        connectionId: string;
        platform: string;
        handle: string;
        name: string;
    }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
});
/** Schedule a post to the account's next free queue slot, at a set time, or now. */
export declare function createPost(opts?: ShapelessAIOptions): ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        connectionId: string;
        text: string;
        scheduledAt?: string | undefined;
        publishNow?: boolean | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        connectionId: string;
        text: string;
        scheduledAt?: string | undefined;
        publishNow?: boolean | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        };
        output: NoInfer<{
            id: string;
            status: string;
            scheduledAt: string | null;
            url: string | null;
            error: string | null;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        id: string;
        status: string;
        scheduledAt: string | null;
        url: string | null;
        error: string | null;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        connectionId: string;
        text: string;
        scheduledAt?: string | undefined;
        publishNow?: boolean | undefined;
    }, {
        id: string;
        status: string;
        scheduledAt: string | null;
        url: string | null;
        error: string | null;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type?: undefined | "function";
} & {
    execute: import("ai").ToolExecuteFunction<{
        connectionId: string;
        text: string;
        scheduledAt?: string | undefined;
        publishNow?: boolean | undefined;
    }, {
        id: string;
        status: string;
        scheduledAt: string | null;
        url: string | null;
        error: string | null;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        connectionId: string;
        text: string;
        scheduledAt?: string | undefined;
        publishNow?: boolean | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        connectionId: string;
        text: string;
        scheduledAt?: string | undefined;
        publishNow?: boolean | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        };
        output: NoInfer<{
            id: string;
            status: string;
            scheduledAt: string | null;
            url: string | null;
            error: string | null;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        id: string;
        status: string;
        scheduledAt: string | null;
        url: string | null;
        error: string | null;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        connectionId: string;
        text: string;
        scheduledAt?: string | undefined;
        publishNow?: boolean | undefined;
    }, {
        id: string;
        status: string;
        scheduledAt: string | null;
        url: string | null;
        error: string | null;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type: "dynamic";
} & {
    execute: import("ai").ToolExecuteFunction<{
        connectionId: string;
        text: string;
        scheduledAt?: string | undefined;
        publishNow?: boolean | undefined;
    }, {
        id: string;
        status: string;
        scheduledAt: string | null;
        url: string | null;
        error: string | null;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        connectionId: string;
        text: string;
        scheduledAt?: string | undefined;
        publishNow?: boolean | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        connectionId: string;
        text: string;
        scheduledAt?: string | undefined;
        publishNow?: boolean | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        };
        output: NoInfer<{
            id: string;
            status: string;
            scheduledAt: string | null;
            url: string | null;
            error: string | null;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        id: string;
        status: string;
        scheduledAt: string | null;
        url: string | null;
        error: string | null;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        connectionId: string;
        text: string;
        scheduledAt?: string | undefined;
        publishNow?: boolean | undefined;
    }, {
        id: string;
        status: string;
        scheduledAt: string | null;
        url: string | null;
        error: string | null;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: "provider";
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: false;
    supportsDeferredResults?: never;
} & {
    execute: import("ai").ToolExecuteFunction<{
        connectionId: string;
        text: string;
        scheduledAt?: string | undefined;
        publishNow?: boolean | undefined;
    }, {
        id: string;
        status: string;
        scheduledAt: string | null;
        url: string | null;
        error: string | null;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        connectionId: string;
        text: string;
        scheduledAt?: string | undefined;
        publishNow?: boolean | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        connectionId: string;
        text: string;
        scheduledAt?: string | undefined;
        publishNow?: boolean | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        };
        output: NoInfer<{
            id: string;
            status: string;
            scheduledAt: string | null;
            url: string | null;
            error: string | null;
        }>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        id: string;
        status: string;
        scheduledAt: string | null;
        url: string | null;
        error: string | null;
    }> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        connectionId: string;
        text: string;
        scheduledAt?: string | undefined;
        publishNow?: boolean | undefined;
    }, {
        id: string;
        status: string;
        scheduledAt: string | null;
        url: string | null;
        error: string | null;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: "provider";
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: true;
    supportsDeferredResults?: boolean;
} & {
    execute: import("ai").ToolExecuteFunction<{
        connectionId: string;
        text: string;
        scheduledAt?: string | undefined;
        publishNow?: boolean | undefined;
    }, {
        id: string;
        status: string;
        scheduledAt: string | null;
        url: string | null;
        error: string | null;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
});
/** Recent posts and their status: scheduled, published (with its URL) or failed (with the reason). */
export declare function listPosts(opts?: ShapelessAIOptions): ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
        limit?: number | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
        limit?: number | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        };
        output: NoInfer<{
            id: string;
            connectionId: string;
            platform: string;
            status: string;
            text: string;
            scheduledAt: string | null;
            publishedAt: string | null;
            url: string | null;
            error: string | null;
        }[]>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        id: string;
        connectionId: string;
        platform: string;
        status: string;
        text: string;
        scheduledAt: string | null;
        publishedAt: string | null;
        url: string | null;
        error: string | null;
    }[]> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
        limit?: number | undefined;
    }, {
        id: string;
        connectionId: string;
        platform: string;
        status: string;
        text: string;
        scheduledAt: string | null;
        publishedAt: string | null;
        url: string | null;
        error: string | null;
    }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type?: undefined | "function";
} & {
    execute: import("ai").ToolExecuteFunction<{
        status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
        limit?: number | undefined;
    }, {
        id: string;
        connectionId: string;
        platform: string;
        status: string;
        text: string;
        scheduledAt: string | null;
        publishedAt: string | null;
        url: string | null;
        error: string | null;
    }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
        limit?: number | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
        limit?: number | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        };
        output: NoInfer<{
            id: string;
            connectionId: string;
            platform: string;
            status: string;
            text: string;
            scheduledAt: string | null;
            publishedAt: string | null;
            url: string | null;
            error: string | null;
        }[]>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        id: string;
        connectionId: string;
        platform: string;
        status: string;
        text: string;
        scheduledAt: string | null;
        publishedAt: string | null;
        url: string | null;
        error: string | null;
    }[]> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
        limit?: number | undefined;
    }, {
        id: string;
        connectionId: string;
        platform: string;
        status: string;
        text: string;
        scheduledAt: string | null;
        publishedAt: string | null;
        url: string | null;
        error: string | null;
    }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
        experimental_sandbox?: import("ai").Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type: "dynamic";
} & {
    execute: import("ai").ToolExecuteFunction<{
        status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
        limit?: number | undefined;
    }, {
        id: string;
        connectionId: string;
        platform: string;
        status: string;
        text: string;
        scheduledAt: string | null;
        publishedAt: string | null;
        url: string | null;
        error: string | null;
    }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
        limit?: number | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
        limit?: number | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        };
        output: NoInfer<{
            id: string;
            connectionId: string;
            platform: string;
            status: string;
            text: string;
            scheduledAt: string | null;
            publishedAt: string | null;
            url: string | null;
            error: string | null;
        }[]>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        id: string;
        connectionId: string;
        platform: string;
        status: string;
        text: string;
        scheduledAt: string | null;
        publishedAt: string | null;
        url: string | null;
        error: string | null;
    }[]> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
        limit?: number | undefined;
    }, {
        id: string;
        connectionId: string;
        platform: string;
        status: string;
        text: string;
        scheduledAt: string | null;
        publishedAt: string | null;
        url: string | null;
        error: string | null;
    }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: "provider";
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: false;
    supportsDeferredResults?: never;
} & {
    execute: import("ai").ToolExecuteFunction<{
        status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
        limit?: number | undefined;
    }, {
        id: string;
        connectionId: string;
        platform: string;
        status: string;
        text: string;
        scheduledAt: string | null;
        publishedAt: string | null;
        url: string | null;
        error: string | null;
    }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
    metadata?: import("@ai-sdk/provider").JSONObject;
    inputSchema: import("ai").FlexibleSchema<{
        status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
        limit?: number | undefined;
    }>;
    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
        status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
        limit?: number | undefined;
    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        };
    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        };
        output: NoInfer<{
            id: string;
            connectionId: string;
            platform: string;
            status: string;
            text: string;
            scheduledAt: string | null;
            publishedAt: string | null;
            url: string | null;
            error: string | null;
        }[]>;
    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
} & {
    outputSchema?: import("ai").FlexibleSchema<{
        id: string;
        connectionId: string;
        platform: string;
        status: string;
        text: string;
        scheduledAt: string | null;
        publishedAt: string | null;
        url: string | null;
        error: string | null;
    }[]> | undefined;
    execute: import("ai").ToolExecuteFunction<{
        status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
        limit?: number | undefined;
    }, {
        id: string;
        connectionId: string;
        platform: string;
        status: string;
        text: string;
        scheduledAt: string | null;
        publishedAt: string | null;
        url: string | null;
        error: string | null;
    }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
} & {
    type: "provider";
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: true;
    supportsDeferredResults?: boolean;
} & {
    execute: import("ai").ToolExecuteFunction<{
        status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
        limit?: number | undefined;
    }, {
        id: string;
        connectionId: string;
        platform: string;
        status: string;
        text: string;
        scheduledAt: string | null;
        publishedAt: string | null;
        url: string | null;
        error: string | null;
    }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
});
/** All three tools, ready to spread into generateText({ tools }). */
export declare function shapelessaiTools(opts?: ShapelessAIOptions): {
    listAccounts: ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
        metadata?: import("@ai-sdk/provider").JSONObject;
        inputSchema: import("ai").FlexibleSchema<{
            platform?: string | undefined;
        }>;
        contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
        needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
            platform?: string | undefined;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
        onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                platform?: string | undefined;
            };
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                platform?: string | undefined;
            };
            output: NoInfer<{
                connectionId: string;
                platform: string;
                handle: string;
                name: string;
            }[]>;
        }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
    } & {
        outputSchema?: import("ai").FlexibleSchema<{
            connectionId: string;
            platform: string;
            handle: string;
            name: string;
        }[]> | undefined;
        execute: import("ai").ToolExecuteFunction<{
            platform?: string | undefined;
        }, {
            connectionId: string;
            platform: string;
            handle: string;
            name: string;
        }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<import("@ai-sdk/provider-utils").Context>;
            experimental_sandbox?: import("ai").Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<{
                platform?: string | undefined;
            }>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type?: undefined | "function";
    } & {
        execute: import("ai").ToolExecuteFunction<{
            platform?: string | undefined;
        }, {
            connectionId: string;
            platform: string;
            handle: string;
            name: string;
        }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
        metadata?: import("@ai-sdk/provider").JSONObject;
        inputSchema: import("ai").FlexibleSchema<{
            platform?: string | undefined;
        }>;
        contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
        needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
            platform?: string | undefined;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
        onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                platform?: string | undefined;
            };
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                platform?: string | undefined;
            };
            output: NoInfer<{
                connectionId: string;
                platform: string;
                handle: string;
                name: string;
            }[]>;
        }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
    } & {
        outputSchema?: import("ai").FlexibleSchema<{
            connectionId: string;
            platform: string;
            handle: string;
            name: string;
        }[]> | undefined;
        execute: import("ai").ToolExecuteFunction<{
            platform?: string | undefined;
        }, {
            connectionId: string;
            platform: string;
            handle: string;
            name: string;
        }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<import("@ai-sdk/provider-utils").Context>;
            experimental_sandbox?: import("ai").Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<{
                platform?: string | undefined;
            }>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type: "dynamic";
    } & {
        execute: import("ai").ToolExecuteFunction<{
            platform?: string | undefined;
        }, {
            connectionId: string;
            platform: string;
            handle: string;
            name: string;
        }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
        metadata?: import("@ai-sdk/provider").JSONObject;
        inputSchema: import("ai").FlexibleSchema<{
            platform?: string | undefined;
        }>;
        contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
        needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
            platform?: string | undefined;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
        onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                platform?: string | undefined;
            };
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                platform?: string | undefined;
            };
            output: NoInfer<{
                connectionId: string;
                platform: string;
                handle: string;
                name: string;
            }[]>;
        }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
    } & {
        outputSchema?: import("ai").FlexibleSchema<{
            connectionId: string;
            platform: string;
            handle: string;
            name: string;
        }[]> | undefined;
        execute: import("ai").ToolExecuteFunction<{
            platform?: string | undefined;
        }, {
            connectionId: string;
            platform: string;
            handle: string;
            name: string;
        }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: false;
        supportsDeferredResults?: never;
    } & {
        execute: import("ai").ToolExecuteFunction<{
            platform?: string | undefined;
        }, {
            connectionId: string;
            platform: string;
            handle: string;
            name: string;
        }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
        metadata?: import("@ai-sdk/provider").JSONObject;
        inputSchema: import("ai").FlexibleSchema<{
            platform?: string | undefined;
        }>;
        contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
        needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
            platform?: string | undefined;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
        onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                platform?: string | undefined;
            };
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                platform?: string | undefined;
            };
            output: NoInfer<{
                connectionId: string;
                platform: string;
                handle: string;
                name: string;
            }[]>;
        }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
    } & {
        outputSchema?: import("ai").FlexibleSchema<{
            connectionId: string;
            platform: string;
            handle: string;
            name: string;
        }[]> | undefined;
        execute: import("ai").ToolExecuteFunction<{
            platform?: string | undefined;
        }, {
            connectionId: string;
            platform: string;
            handle: string;
            name: string;
        }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: true;
        supportsDeferredResults?: boolean;
    } & {
        execute: import("ai").ToolExecuteFunction<{
            platform?: string | undefined;
        }, {
            connectionId: string;
            platform: string;
            handle: string;
            name: string;
        }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
    });
    createPost: ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
        metadata?: import("@ai-sdk/provider").JSONObject;
        inputSchema: import("ai").FlexibleSchema<{
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        }>;
        contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
        needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
        onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                connectionId: string;
                text: string;
                scheduledAt?: string | undefined;
                publishNow?: boolean | undefined;
            };
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                connectionId: string;
                text: string;
                scheduledAt?: string | undefined;
                publishNow?: boolean | undefined;
            };
            output: NoInfer<{
                id: string;
                status: string;
                scheduledAt: string | null;
                url: string | null;
                error: string | null;
            }>;
        }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
    } & {
        outputSchema?: import("ai").FlexibleSchema<{
            id: string;
            status: string;
            scheduledAt: string | null;
            url: string | null;
            error: string | null;
        }> | undefined;
        execute: import("ai").ToolExecuteFunction<{
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        }, {
            id: string;
            status: string;
            scheduledAt: string | null;
            url: string | null;
            error: string | null;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<import("@ai-sdk/provider-utils").Context>;
            experimental_sandbox?: import("ai").Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<{
                connectionId: string;
                text: string;
                scheduledAt?: string | undefined;
                publishNow?: boolean | undefined;
            }>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type?: undefined | "function";
    } & {
        execute: import("ai").ToolExecuteFunction<{
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        }, {
            id: string;
            status: string;
            scheduledAt: string | null;
            url: string | null;
            error: string | null;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
        metadata?: import("@ai-sdk/provider").JSONObject;
        inputSchema: import("ai").FlexibleSchema<{
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        }>;
        contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
        needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
        onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                connectionId: string;
                text: string;
                scheduledAt?: string | undefined;
                publishNow?: boolean | undefined;
            };
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                connectionId: string;
                text: string;
                scheduledAt?: string | undefined;
                publishNow?: boolean | undefined;
            };
            output: NoInfer<{
                id: string;
                status: string;
                scheduledAt: string | null;
                url: string | null;
                error: string | null;
            }>;
        }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
    } & {
        outputSchema?: import("ai").FlexibleSchema<{
            id: string;
            status: string;
            scheduledAt: string | null;
            url: string | null;
            error: string | null;
        }> | undefined;
        execute: import("ai").ToolExecuteFunction<{
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        }, {
            id: string;
            status: string;
            scheduledAt: string | null;
            url: string | null;
            error: string | null;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<import("@ai-sdk/provider-utils").Context>;
            experimental_sandbox?: import("ai").Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<{
                connectionId: string;
                text: string;
                scheduledAt?: string | undefined;
                publishNow?: boolean | undefined;
            }>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type: "dynamic";
    } & {
        execute: import("ai").ToolExecuteFunction<{
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        }, {
            id: string;
            status: string;
            scheduledAt: string | null;
            url: string | null;
            error: string | null;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
        metadata?: import("@ai-sdk/provider").JSONObject;
        inputSchema: import("ai").FlexibleSchema<{
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        }>;
        contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
        needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
        onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                connectionId: string;
                text: string;
                scheduledAt?: string | undefined;
                publishNow?: boolean | undefined;
            };
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                connectionId: string;
                text: string;
                scheduledAt?: string | undefined;
                publishNow?: boolean | undefined;
            };
            output: NoInfer<{
                id: string;
                status: string;
                scheduledAt: string | null;
                url: string | null;
                error: string | null;
            }>;
        }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
    } & {
        outputSchema?: import("ai").FlexibleSchema<{
            id: string;
            status: string;
            scheduledAt: string | null;
            url: string | null;
            error: string | null;
        }> | undefined;
        execute: import("ai").ToolExecuteFunction<{
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        }, {
            id: string;
            status: string;
            scheduledAt: string | null;
            url: string | null;
            error: string | null;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: false;
        supportsDeferredResults?: never;
    } & {
        execute: import("ai").ToolExecuteFunction<{
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        }, {
            id: string;
            status: string;
            scheduledAt: string | null;
            url: string | null;
            error: string | null;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
        metadata?: import("@ai-sdk/provider").JSONObject;
        inputSchema: import("ai").FlexibleSchema<{
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        }>;
        contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
        needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
        onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                connectionId: string;
                text: string;
                scheduledAt?: string | undefined;
                publishNow?: boolean | undefined;
            };
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                connectionId: string;
                text: string;
                scheduledAt?: string | undefined;
                publishNow?: boolean | undefined;
            };
            output: NoInfer<{
                id: string;
                status: string;
                scheduledAt: string | null;
                url: string | null;
                error: string | null;
            }>;
        }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
    } & {
        outputSchema?: import("ai").FlexibleSchema<{
            id: string;
            status: string;
            scheduledAt: string | null;
            url: string | null;
            error: string | null;
        }> | undefined;
        execute: import("ai").ToolExecuteFunction<{
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        }, {
            id: string;
            status: string;
            scheduledAt: string | null;
            url: string | null;
            error: string | null;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: true;
        supportsDeferredResults?: boolean;
    } & {
        execute: import("ai").ToolExecuteFunction<{
            connectionId: string;
            text: string;
            scheduledAt?: string | undefined;
            publishNow?: boolean | undefined;
        }, {
            id: string;
            status: string;
            scheduledAt: string | null;
            url: string | null;
            error: string | null;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
    });
    listPosts: ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
        metadata?: import("@ai-sdk/provider").JSONObject;
        inputSchema: import("ai").FlexibleSchema<{
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        }>;
        contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
        needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
        onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
                limit?: number | undefined;
            };
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
                limit?: number | undefined;
            };
            output: NoInfer<{
                id: string;
                connectionId: string;
                platform: string;
                status: string;
                text: string;
                scheduledAt: string | null;
                publishedAt: string | null;
                url: string | null;
                error: string | null;
            }[]>;
        }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
    } & {
        outputSchema?: import("ai").FlexibleSchema<{
            id: string;
            connectionId: string;
            platform: string;
            status: string;
            text: string;
            scheduledAt: string | null;
            publishedAt: string | null;
            url: string | null;
            error: string | null;
        }[]> | undefined;
        execute: import("ai").ToolExecuteFunction<{
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        }, {
            id: string;
            connectionId: string;
            platform: string;
            status: string;
            text: string;
            scheduledAt: string | null;
            publishedAt: string | null;
            url: string | null;
            error: string | null;
        }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<import("@ai-sdk/provider-utils").Context>;
            experimental_sandbox?: import("ai").Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<{
                status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
                limit?: number | undefined;
            }>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type?: undefined | "function";
    } & {
        execute: import("ai").ToolExecuteFunction<{
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        }, {
            id: string;
            connectionId: string;
            platform: string;
            status: string;
            text: string;
            scheduledAt: string | null;
            publishedAt: string | null;
            url: string | null;
            error: string | null;
        }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
        metadata?: import("@ai-sdk/provider").JSONObject;
        inputSchema: import("ai").FlexibleSchema<{
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        }>;
        contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
        needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
        onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
                limit?: number | undefined;
            };
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
                limit?: number | undefined;
            };
            output: NoInfer<{
                id: string;
                connectionId: string;
                platform: string;
                status: string;
                text: string;
                scheduledAt: string | null;
                publishedAt: string | null;
                url: string | null;
                error: string | null;
            }[]>;
        }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
    } & {
        outputSchema?: import("ai").FlexibleSchema<{
            id: string;
            connectionId: string;
            platform: string;
            status: string;
            text: string;
            scheduledAt: string | null;
            publishedAt: string | null;
            url: string | null;
            error: string | null;
        }[]> | undefined;
        execute: import("ai").ToolExecuteFunction<{
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        }, {
            id: string;
            connectionId: string;
            platform: string;
            status: string;
            text: string;
            scheduledAt: string | null;
            publishedAt: string | null;
            url: string | null;
            error: string | null;
        }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<import("@ai-sdk/provider-utils").Context>;
            experimental_sandbox?: import("ai").Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<{
                status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
                limit?: number | undefined;
            }>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type: "dynamic";
    } & {
        execute: import("ai").ToolExecuteFunction<{
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        }, {
            id: string;
            connectionId: string;
            platform: string;
            status: string;
            text: string;
            scheduledAt: string | null;
            publishedAt: string | null;
            url: string | null;
            error: string | null;
        }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
        metadata?: import("@ai-sdk/provider").JSONObject;
        inputSchema: import("ai").FlexibleSchema<{
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        }>;
        contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
        needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
        onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
                limit?: number | undefined;
            };
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
                limit?: number | undefined;
            };
            output: NoInfer<{
                id: string;
                connectionId: string;
                platform: string;
                status: string;
                text: string;
                scheduledAt: string | null;
                publishedAt: string | null;
                url: string | null;
                error: string | null;
            }[]>;
        }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
    } & {
        outputSchema?: import("ai").FlexibleSchema<{
            id: string;
            connectionId: string;
            platform: string;
            status: string;
            text: string;
            scheduledAt: string | null;
            publishedAt: string | null;
            url: string | null;
            error: string | null;
        }[]> | undefined;
        execute: import("ai").ToolExecuteFunction<{
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        }, {
            id: string;
            connectionId: string;
            platform: string;
            status: string;
            text: string;
            scheduledAt: string | null;
            publishedAt: string | null;
            url: string | null;
            error: string | null;
        }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: false;
        supportsDeferredResults?: never;
    } & {
        execute: import("ai").ToolExecuteFunction<{
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        }, {
            id: string;
            connectionId: string;
            platform: string;
            status: string;
            text: string;
            scheduledAt: string | null;
            publishedAt: string | null;
            url: string | null;
            error: string | null;
        }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
        metadata?: import("@ai-sdk/provider").JSONObject;
        inputSchema: import("ai").FlexibleSchema<{
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        }>;
        contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
        needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
        onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
                limit?: number | undefined;
            };
        } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
                limit?: number | undefined;
            };
            output: NoInfer<{
                id: string;
                connectionId: string;
                platform: string;
                status: string;
                text: string;
                scheduledAt: string | null;
                publishedAt: string | null;
                url: string | null;
                error: string | null;
            }[]>;
        }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
    } & {
        outputSchema?: import("ai").FlexibleSchema<{
            id: string;
            connectionId: string;
            platform: string;
            status: string;
            text: string;
            scheduledAt: string | null;
            publishedAt: string | null;
            url: string | null;
            error: string | null;
        }[]> | undefined;
        execute: import("ai").ToolExecuteFunction<{
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        }, {
            id: string;
            connectionId: string;
            platform: string;
            status: string;
            text: string;
            scheduledAt: string | null;
            publishedAt: string | null;
            url: string | null;
            error: string | null;
        }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: true;
        supportsDeferredResults?: boolean;
    } & {
        execute: import("ai").ToolExecuteFunction<{
            status?: "proposed" | "scheduled" | "publishing" | "published" | "handoff" | "failed" | "canceled" | undefined;
            limit?: number | undefined;
        }, {
            id: string;
            connectionId: string;
            platform: string;
            status: string;
            text: string;
            scheduledAt: string | null;
            publishedAt: string | null;
            url: string | null;
            error: string | null;
        }[], NoInfer<import("@ai-sdk/provider-utils").Context>>;
    });
};