import { VoicePlugin, VoiceRecorder, VoicePlayer } from '@nself/plugin-voice'

// Register plugin
app.use(VoicePlugin)

// Use components
<VoiceRecorder onComplete={handleRecording} maxDuration={300} />
<VoicePlayer src={audioUrl} waveform={waveformData} />

VoicePlugin.configure({
  maxDuration: 300, // 5 minutes
  format: 'webm', // audio format
  sampleRate: 44100, // sample rate
  bitRate: 128000, // bit rate
  showWaveform: true, // show visualization
})

import { VideoPlugin, VideoCall, VideoRoom } from '@nself/plugin-video'

// Start a call
<VideoCall
  roomId="meeting-123"
  userId={user.id}
  onEnd={handleEndCall}
/>

// Join a room
<VideoRoom
  roomId="room-456"
  participants={participants}
/>

VideoPlugin.configure({
  provider: 'livekit', // or 'twilio', 'daily', 'custom'
  maxParticipants: 50,
  recording: {
    enabled: true,
    storage: 's3',
  },
  features: {
    screenShare: true,
    virtualBackground: true,
    noiseSuppression: true,
  },
})

import { BotPlugin, Bot, BotBuilder } from '@nself/plugin-bots'

// Create a bot
const myBot = BotBuilder.create('my-bot')
  .name('My Bot')
  .avatar('🤖')
  .command('hello', async (ctx) => ({
    type: 'message',
    content: `Hello, ${ctx.user.displayName}!`,
  }))
  .onMessage(async (ctx) => {
    if (ctx.message.content.includes('help')) {
      return { type: 'message', content: 'How can I help?' }
    }
    return null
  })
  .build()

// Register bot
BotPlugin.register(myBot)

interface Bot {
  id: string
  name: string
  description: string
  avatar: string
  version: string

  getCommands(): BotCommand[]
  onMessage(ctx: BotContext): Promise<BotResponse | null>
  onCommand(cmd: string, args: string[], ctx: BotContext): Promise<BotResponse>
  onMention(ctx: BotContext): Promise<BotResponse>
  onMemberJoin?(ctx: BotContext): Promise<BotResponse | null>
}

import { IDmePlugin, IDmeButton, useIDmeVerification } from '@nself/plugin-idme'

// Verification button
<IDmeButton
  groups={['military', 'veteran']}
  onVerified={handleVerified}
/>

// Check verification status
const { isVerified, groups, badges } = useIDmeVerification(userId)

IDmePlugin.configure({
  clientId: process.env.IDME_CLIENT_ID,
  clientSecret: process.env.IDME_CLIENT_SECRET,
  environment: 'production',
  scopes: ['military', 'veteran', 'first_responder'],
  badgeDisplay: true,
})

import { PollPlugin, PollCreator, PollDisplay, usePoll } from '@nself/plugin-polls'

// Create a poll
<PollCreator
  onSubmit={handleCreatePoll}
  maxOptions={10}
/>

// Display a poll
<PollDisplay
  pollId={poll.id}
  onVote={handleVote}
/>

import { AnalyticsPlugin, AnalyticsDashboard, useAnalytics } from '@nself/plugin-analytics'

// Dashboard component
<AnalyticsDashboard
  dateRange={{ start, end }}
  metrics={['messages', 'users', 'channels']}
/>

// Hook usage
const { trackEvent, getMetrics } = useAnalytics()
trackEvent('message_sent', { channelId, userId })

import { AuditPlugin, AuditLogViewer, useAuditLog } from '@nself/plugin-audit'

// View audit logs
<AuditLogViewer
  filters={{ userId, action, dateRange }}
  onExport={handleExport}
/>

// Log custom events
const { logEvent } = useAuditLog()
logEvent('custom_action', { details })

// src/index.ts
import type { Plugin, PluginContext } from '@nself/core'

export interface MyPluginConfig {
  option1: string
  option2: boolean
}

export const MyPlugin: Plugin<MyPluginConfig> = {
  name: 'my-plugin',
  version: '1.0.0',

  // Called when plugin is registered
  install(ctx: PluginContext, config: MyPluginConfig) {
    // Register components
    ctx.components.register('MyComponent', MyComponent)

    // Register hooks
    ctx.hooks.register('useMyHook', useMyHook)

    // Add GraphQL operations
    ctx.graphql.register(MY_QUERIES, MY_MUTATIONS)

    // Subscribe to events
    ctx.events.on('message:created', handleMessage)
  },

  // Called when plugin is uninstalled
  uninstall(ctx: PluginContext) {
    ctx.events.off('message:created', handleMessage)
  },
}

interface PluginContext {
  // Component registration
  components: {
    register(name: string, component: React.FC): void
    unregister(name: string): void
  }

  // Hook registration
  hooks: {
    register(name: string, hook: Function): void
    unregister(name: string): void
  }

  // GraphQL operations
  graphql: {
    register(queries: DocumentNode, mutations?: DocumentNode): void
    extend(schema: string): void
  }

  // Event system
  events: {
    on(event: string, handler: Function): void
    off(event: string, handler: Function): void
    emit(event: string, data: any): void
  }

  // Storage
  storage: {
    get(key: string): Promise<any>
    set(key: string, value: any): Promise<void>
    remove(key: string): Promise<void>
  }

  // Configuration
  config: {
    get<T>(key: string): T
    set(key: string, value: any): void
  }
}

// src/plugins.ts
import { registerPlugins } from '@nself/core'
import { PollPlugin } from '@nself/plugin-polls'
import { VoicePlugin } from '@nself/plugin-voice'
import { BotPlugin } from '@nself/plugin-bots'

registerPlugins([
  PollPlugin.configure({
    /* config */
  }),
  VoicePlugin.configure({
    /* config */
  }),
  BotPlugin.configure({
    /* config */
  }),
])