export interface PluginProvider {
  name: string;
  initializer: () =>
    | InitializedPlugin
    | void
    | Promise<InitializedPlugin | void>;
  resolver?: (action: ActionType, target: string) => Promise<void>;
  listActions?: () => Promise<ActionMetadata[]>;
}

export interface InitializedPlugin {
  models?: Action<z.ZodTypeAny, z.ZodTypeAny>[];
  retrievers?: Action<z.ZodTypeAny, z.ZodTypeAny>[];
  embedders?: Action<z.ZodTypeAny, z.ZodTypeAny>[];
  indexers?: Action<z.ZodTypeAny, z.ZodTypeAny>[];
  evaluators?: Action<z.ZodTypeAny, z.ZodTypeAny>[];
}

type ActionType = 
  | 'model'
  | 'retriever'
  | 'embedder'
  | 'indexer'
  | 'evaluator'
  | 'flow'
  | 'tool';

function genkitPlugin(
  name: string,
  initializer: (ai: Genkit) => Promise<void> | void,
  resolver?: (ai: Genkit, actionType: ActionType, actionName: string) => Promise<void>,
  listActions?: () => Promise<ActionMetadata[]>
): GenkitPlugin

import { genkitPlugin } from 'genkit/plugin';

export function myPlugin(options) {
  return genkitPlugin(
    'my-plugin',
    async (ai) => {
      ai.defineModel(/* ... */);
    }
  );
}

function genkitPluginV2(config: {
  name: string;
  init: () => Promise<InitializedPlugin> | InitializedPlugin;
  resolve?: (actionType: ActionType, name: string) => Action | undefined;
  list?: () => Promise<ActionMetadata[]>;
}): GenkitPluginV2

import { genkitPluginV2 } from 'genkit/plugin';

export function myPlugin(options) {
  return genkitPluginV2({
    name: 'my-plugin',
    init: async () => {
      return [createModel('model-1'), createModel('model-2')];
    },
    resolve: (actionType, name) => {
      if (actionType === 'model') {
        return createModel(name);
      }
    },
  });
}

interface ModelAction {
  name: string;
  label?: string;
  configSchema: z.ZodTypeAny;
  info?: ModelInfo;
  generate: (
    input: GenerateRequest,
    streamingCallback?: (chunk: GenerateResponseChunk) => void
  ) => Promise<GenerateResponseData>;
}

interface ModelInfo {
  supports?: {
    multiturn?: boolean;      // Multi-turn conversations
    media?: boolean;          // Image/audio input
    tools?: boolean;          // Tool calling
    toolChoice?: boolean;     // Tool choice control
    systemRole?: boolean;     // System messages
    constrained?: 'all' | 'structured' | false;  // Structured output
  };
}

interface GenerateRequest {
  messages: MessageData[];
  config?: Record<string, any>;
  tools?: ToolDefinition[];
  output?: {
    schema?: z.ZodTypeAny;
    format?: 'json' | 'text';
  };
}

interface GenerateResponseData {
  message: MessageData;
  usage?: {
    inputTokens?: number;
    outputTokens?: number;
    totalTokens?: number;
  };
  finishReason: 'stop' | 'length' | 'tool-call' | 'error' | 'blocked' | 'unknown';
}

interface MessageData {
  role: 'user' | 'model' | 'system' | 'tool';
  content: Part[];
}

type Part = 
  | { text: string }
  | { media: { url: string; contentType?: string } }
  | { toolRequest: ToolRequest }
  | { toolResponse: ToolResponse }
  | { custom: any };

function modelRef<ConfigSchema extends z.ZodTypeAny>(params: {
  name: string;
  config?: z.infer<ConfigSchema>;
  configSchema?: ConfigSchema;
  info?: ModelInfo;
}): ModelReference<ConfigSchema>

import { modelRef } from 'genkit/model';

export const myModel = modelRef({
  name: 'my-provider/my-model',
  config: { temperature: 0.7 },
  configSchema: MyConfigSchema,
});

interface EmbedderAction {
  name: string;
  info?: {
    dimensions?: number;
    label?: string;
  };
  embed: (input: EmbedRequest) => Promise<EmbedResponse>;
}

interface EmbedRequest {
  content: Document[];
  options?: Record<string, any>;
}

interface EmbedResponse {
  embeddings: Embedding[];
}

interface Embedding {
  embedding: number[];
}

function embedderRef<ConfigSchema extends z.ZodTypeAny = z.ZodTypeAny>(params: {
  name: string;
  config?: z.infer<ConfigSchema>;
  configSchema?: ConfigSchema;
}): EmbedderReference<ConfigSchema>

interface RetrieverAction {
  name: string;
  retrieve: (
    query: Document,
    options?: Record<string, any>
  ) => Promise<{ documents: Document[] }>;
}

const CommonRetrieverOptionsSchema = z.object({
  k: z.number().optional(),  // Number of results
});

function retrieverRef<ConfigSchema extends z.ZodTypeAny = z.ZodTypeAny>(params: {
  name: string;
  info?: {
    label?: string;
  };
  configSchema?: ConfigSchema;
}): RetrieverReference<ConfigSchema>

interface IndexerAction {
  name: string;
  index: (
    documents: Document[],
    options?: Record<string, any>
  ) => Promise<void>;
}

function indexerRef<ConfigSchema extends z.ZodTypeAny = z.ZodTypeAny>(params: {
  name: string;
  info?: {
    label?: string;
  };
  configSchema?: ConfigSchema;
}): IndexerReference<ConfigSchema>

class Document {
  static fromText(text: string, metadata?: Record<string, any>): Document;
  static fromData(data: any, dataType: string, metadata?: Record<string, any>): Document;
  
  text: string;
  metadata?: Record<string, any>;
  
  toJSON(): any;
}

import { Document } from 'genkit';

const doc = Document.fromText('Hello world', {
  source: 'example',
  timestamp: Date.now(),
});

const GenerationCommonConfigSchema = z.object({
  temperature: z.number().min(0).max(2).optional(),
  maxOutputTokens: z.number().optional(),
  topK: z.number().optional(),
  topP: z.number().min(0).max(1).optional(),
  stopSequences: z.array(z.string()).optional(),
});

function getBasicUsageStats(
  input: MessageData[],
  output: MessageData
): {
  inputTokens: number;
  outputTokens: number;
  totalTokens: number;
}

function modelActionMetadata(params: {
  name: string;
  info: ModelInfo;
}): ActionMetadata

function isModelAction(action: any): action is ModelAction

function isRetrieverAction(action: any): action is RetrieverAction

import {
  genkitPluginV2,
  type GenkitPluginV2,
} from 'genkit/plugin';
import {
  modelRef,
  type ModelReference,
  type GenerateRequest,
  type GenerateResponseData,
} from 'genkit/model';
import { z } from 'genkit';

const ConfigSchema = z.object({
  temperature: z.number().min(0).max(2).optional(),
});

type MyPluginOptions = {
  apiKey?: string;
};

function myPlugin(options?: MyPluginOptions): GenkitPluginV2 {
  const apiKey = options?.apiKey || process.env.MY_API_KEY;

  return genkitPluginV2({
    name: 'my-plugin',
    init: async () => {
      return [
        {
          name: 'my-plugin/model',
          label: 'My Model',
          configSchema: ConfigSchema,
          info: {
            supports: {
              multiturn: true,
              tools: true,
            },
          },
          async generate(
            input: GenerateRequest,
            streamingCallback?
          ): Promise<GenerateResponseData> {
            // Implementation
            return {
              message: {
                role: 'model',
                content: [{ text: 'Response' }],
              },
              finishReason: 'stop',
            };
          },
        },
      ];
    },
  });
}

// Export with model helper
export const myProvider = myPlugin as typeof myPlugin & {
  model: (name: string) => ModelReference<typeof ConfigSchema>;
};

myProvider.model = (name: string) => {
  return modelRef({
    name: `my-plugin/${name}`,
    configSchema: ConfigSchema,
  });
};

export default myProvider;