Types

interface ApiResponse<T> {
  success: boolean;
  payload: T;
  error?: string;
  message?: string;
  status?: number;
}

interface Member {
  id?: string;
  projectId?: string;
  name?: string;
  email?: string;
  role?: string;
  metadata?: Record<string, string | number | boolean | null | undefined>;
  createdAt?: Date | string;
  updatedAt?: Date | string;
}

interface AuthResult {
  token: string;
  member: Member;
}

interface IdpOpenParams {
  /** Resource key for RBAC check (e.g. 'users', 'revenue') */
  resource: string;
  /** CRUD action type */
  action: 'create' | 'read' | 'update' | 'delete';
  /** Force step-up regardless of permission level. Default: false */
  forceStepUp?: boolean;
  /** Slack webhook notifications. Default: false */
  webhookNotification?: boolean;
}

interface IdpAuthResponse {
  success: boolean;
  sid?: string;
  error?: string;
  timestamp: number;
  action?: string;
}

const TranscodesEventNames = {
  AUTH_STATE_CHANGED: 'AUTH_STATE_CHANGED',
  TOKEN_REFRESHED: 'TOKEN_REFRESHED',
  TOKEN_EXPIRED: 'TOKEN_EXPIRED',
  ERROR: 'ERROR',
} as const;
 
type TranscodesEventName = (typeof TranscodesEventNames)[keyof typeof TranscodesEventNames];

interface TranscodesEventMap {
  AUTH_STATE_CHANGED: AuthStateChangedPayload;
  TOKEN_REFRESHED: TokenRefreshedPayload;
  TOKEN_EXPIRED: TokenExpiredPayload;
  ERROR: ErrorPayload;
}

interface AuthStateChangedPayload {
  isAuthenticated: boolean;
  accessToken: string | null;
  expiresAt: number | null;
  member: Member | null;
}

interface TokenRefreshedPayload {
  accessToken: string;
  expiresAt: number;
}

interface TokenExpiredPayload {
  expiredAt: number;
}

interface ErrorPayload {
  code: string;
  message: string;
  context?: string;
}

type EventCallback<T extends TranscodesEventName> = (
  payload: TranscodesEventMap[T]
) => void;

interface TokenAPI {
  getCurrentMember(): Promise<Member | null>;
  getAccessToken(): Promise<string | null>;
  hasToken(): boolean;
  isAuthenticated(): Promise<boolean>;
  signOut(options?: { webhookNotification?: boolean }): Promise<void>;
}

interface PublicMemberAPI {
  get(params: {
    projectId?: string;
    memberId?: string;
    email?: string;
    fields?: string;
  }): Promise<ApiResponse<Member[]>>;
}

interface PublicEventAPI {
  on<T extends TranscodesEventName>(
    event: T,
    callback: EventCallback<T>
  ): () => void;
  off<T extends TranscodesEventName>(
    event: T,
    callback: EventCallback<T>
  ): void;
}

declare global {
  interface Window {
    transcodes: TranscodesAPI;
  }
  var transcodes: Window['transcodes'];
}

{
  "compilerOptions": {
    "typeRoots": ["./node_modules/@types", "./types"]
  },
  "include": ["src", "types"]
}