// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.

import { APIResource } from '../../../../core/resource';
import { APIPromise } from '../../../../core/api-promise';
import { RequestOptions } from '../../../../internal/request-options';
import { path } from '../../../../internal/utils/path';

export class BaseLatest extends APIResource {
  static override readonly _key: readonly ['magicTransit', 'connectors', 'events', 'latest'] = Object.freeze([
    'magicTransit',
    'connectors',
    'events',
    'latest',
  ] as const);

  /**
   * Get latest Events
   *
   * @example
   * ```ts
   * const latests =
   *   await client.magicTransit.connectors.events.latest.list(
   *     'connector_id',
   *     { account_id: '023e105f4ecef8ad9ca31a8372d0c353' },
   *   );
   * ```
   */
  list(
    connectorID: string,
    params: LatestListParams,
    options?: RequestOptions,
  ): APIPromise<LatestListResponse> {
    const { account_id } = params;
    return (
      this._client.get(
        path`/accounts/${account_id}/magic/connectors/${connectorID}/telemetry/events/latest`,
        options,
      ) as APIPromise<{ result: LatestListResponse }>
    )._thenUnwrap((obj) => obj.result);
  }
}
export class Latest extends BaseLatest {}

export interface LatestListResponse {
  count: number;

  items: Array<LatestListResponse.Item>;
}

export namespace LatestListResponse {
  /**
   * Recorded Event
   */
  export interface Item {
    e:
      | Item.Init
      | Item.Leave
      | Item.StartAttestation
      | Item.FinishAttestationSuccess
      | Item.FinishAttestationFailure
      | Item.StartRotateCryptKey
      | Item.FinishRotateCryptKeySuccess
      | Item.FinishRotateCryptKeyFailure
      | Item.StartRotatePki
      | Item.FinishRotatePkiSuccess
      | Item.FinishRotatePkiFailure
      | Item.StartUpgrade
      | Item.FinishUpgradeSuccess
      | Item.FinishUpgradeFailure
      | Item.Reconcile
      | Item.ConfigureCloudflaredTunnel
      | Item.RekeyInstallBoth
      | Item.RekeyStart
      | Item.RekeyAdvance
      | Item.RekeyComplete
      | Item.RekeyReset;

    /**
     * Sequence number, used to order events with the same timestamp
     */
    n: number;

    /**
     * Time the Event was recorded (seconds since the Unix epoch)
     */
    t: number;

    /**
     * Version
     */
    v?: string;
  }

  export namespace Item {
    export interface Init {
      /**
       * Initialized process
       */
      k: 'Init';
    }

    export interface Leave {
      /**
       * Stopped process
       */
      k: 'Leave';
    }

    export interface StartAttestation {
      /**
       * Started attestation
       */
      k: 'StartAttestation';
    }

    export interface FinishAttestationSuccess {
      /**
       * Finished attestation
       */
      k: 'FinishAttestationSuccess';
    }

    export interface FinishAttestationFailure {
      /**
       * Failed attestation
       */
      k: 'FinishAttestationFailure';
    }

    export interface StartRotateCryptKey {
      /**
       * Started crypt key rotation
       */
      k: 'StartRotateCryptKey';
    }

    export interface FinishRotateCryptKeySuccess {
      /**
       * Finished crypt key rotation
       */
      k: 'FinishRotateCryptKeySuccess';
    }

    export interface FinishRotateCryptKeyFailure {
      /**
       * Failed crypt key rotation
       */
      k: 'FinishRotateCryptKeyFailure';
    }

    export interface StartRotatePki {
      /**
       * Started PKI rotation
       */
      k: 'StartRotatePki';
    }

    export interface FinishRotatePkiSuccess {
      /**
       * Finished PKI rotation
       */
      k: 'FinishRotatePkiSuccess';
    }

    export interface FinishRotatePkiFailure {
      /**
       * Failed PKI rotation
       */
      k: 'FinishRotatePkiFailure';
    }

    export interface StartUpgrade {
      /**
       * Started upgrade
       */
      k: 'StartUpgrade';

      /**
       * Location of upgrade bundle
       */
      url: string;
    }

    export interface FinishUpgradeSuccess {
      /**
       * Finished upgrade
       */
      k: 'FinishUpgradeSuccess';
    }

    export interface FinishUpgradeFailure {
      /**
       * Failed upgrade
       */
      k: 'FinishUpgradeFailure';
    }

    export interface Reconcile {
      /**
       * Reconciled
       */
      k: 'Reconcile';
    }

    export interface ConfigureCloudflaredTunnel {
      /**
       * Configured Cloudflared tunnel
       */
      k: 'ConfigureCloudflaredTunnel';
    }

    export interface RekeyInstallBoth {
      /**
       * Installed initial inbound and outbound keys
       */
      k: 'RekeyInstallBoth';

      /**
       * Tunnel identifier
       */
      tunnel_id: string;
    }

    export interface RekeyStart {
      /**
       * Installed new inbound key, kept old outbound
       */
      k: 'RekeyStart';

      /**
       * Tunnel identifier
       */
      tunnel_id: string;
    }

    export interface RekeyAdvance {
      /**
       * Confirmed traffic on new inbound key, swapped outbound to new
       */
      k: 'RekeyAdvance';

      /**
       * Tunnel identifier
       */
      tunnel_id: string;
    }

    export interface RekeyComplete {
      /**
       * Deleted old keys
       */
      k: 'RekeyComplete';

      /**
       * Tunnel identifier
       */
      tunnel_id: string;
    }

    export interface RekeyReset {
      /**
       * Deleted all keys after receiving an unexpected key
       */
      k: 'RekeyReset';

      /**
       * Tunnel identifier
       */
      tunnel_id: string;
    }
  }
}

export interface LatestListParams {
  /**
   * Account identifier
   */
  account_id: string;
}

export declare namespace Latest {
  export { type LatestListResponse as LatestListResponse, type LatestListParams as LatestListParams };
}