Class Hop

Constructs a new instance of Hop and all of its SDKs.

Example

const hop = new Hop(bearerTokenOrPATOrProjectToken);
await hop.ignite.containers.create(deploymentId);

Hierarchy

  • Hop

Constructors

constructor

Properties

channels client ignite pipe projects registry users

Constructors

constructor

  • Parameters

    Returns Hop

  • Parameters

    • authentication: `ptk_${string}` | `pat_${string}` | `bearer_${string}`
    • Optional baseurl: string

    Returns Hop

Properties

Readonly channels

channels: {
    tokens: {
        create(state?: State, project?: `project_${string}`): Promise<ChannelToken>;
        delete(token: `leap_token_${string}`): Promise<void>;
        get(id: `leap_token_${string}`): Promise<ChannelToken>;
        isOnline(idOrToken: `leap_token_${string}` | ChannelToken): Promise<boolean>;
        publishDirectMessage<T>(token: `leap_token_${string}`, event: string, data: T): Promise<void>;
        setState(id: `leap_token_${string}`, state: State): Promise<ChannelToken>;
    };
    create<T>(type: ChannelType, id?: null | string, options?: null | {
        state?: T;
    }, project?: `project_${string}`): Promise<Channel & {
        patchState<T>(state: SetStateAction<T>): Promise<void>;
        publishMessage(name: string, data: unknown): Promise<void>;
        setState<T>(state: SetStateAction<T>): Promise<void>;
        subscribeToken(token: `leap_token_${string}`): Promise<void>;
        subscribeTokens(tokens: `leap_token_${string}`[] | Set<`leap_token_${string}`>): Promise<void>;
    }>;
    delete(id: string): Promise<void>;
    get(id: string): Promise<Channel & {
        patchState<T>(state: SetStateAction<T>): Promise<void>;
        publishMessage(name: string, data: unknown): Promise<void>;
        setState<T>(state: SetStateAction<T>): Promise<void>;
        subscribeToken(token: `leap_token_${string}`): Promise<void>;
        subscribeTokens(tokens: `leap_token_${string}`[] | Set<`leap_token_${string}`>): Promise<void>;
    }>;
    getAll(project?: `project_${string}`): Promise<(Channel & {
        patchState<T>(state: SetStateAction<T>): Promise<void>;
        publishMessage(name: string, data: unknown): Promise<void>;
        setState<T>(state: SetStateAction<T>): Promise<void>;
        subscribeToken(token: `leap_token_${string}`): Promise<void>;
        subscribeTokens(tokens: `leap_token_${string}`[] | Set<`leap_token_${string}`>): Promise<void>;
    })[]>;
    getAllTokens(channel: string | Channel): Promise<ChannelToken[]>;
    getStats(id: string): Promise<{
        online_count: number;
    }>;
    patchState<T>(channel: string | Channel, state: SetStateAction<T>): Promise<void>;
    publishMessage<T>(channel: string | Channel, event: string, data: T): Promise<void>;
    setState<T>(channel: string | Channel, state: SetStateAction<T>): Promise<void>;
    subscribeToken(channel: string | Channel, token: `leap_token_${string}`): Promise<void>;
    subscribeTokens(channel: string | Channel, tokens: `leap_token_${string}`[] | Set<`leap_token_${string}`>): Promise<void>;
}

Type declaration

  • tokens: {
        create(state?: State, project?: `project_${string}`): Promise<ChannelToken>;
        delete(token: `leap_token_${string}`): Promise<void>;
        get(id: `leap_token_${string}`): Promise<ChannelToken>;
        isOnline(idOrToken: `leap_token_${string}` | ChannelToken): Promise<boolean>;
        publishDirectMessage<T>(token: `leap_token_${string}`, event: string, data: T): Promise<void>;
        setState(id: `leap_token_${string}`, state: State): Promise<ChannelToken>;
    }
    • create:function
      • create(state?: State, project?: `project_${string}`): Promise<ChannelToken>

      • Creates a new channel token for a project

        Parameters

        • state: State = {}

          The state to set on the token

        • Optional project: `project_${string}`

          The project to attach this token to

        Returns Promise<ChannelToken>

    • delete:function
      • delete(token: `leap_token_${string}`): Promise<void>

      • Parameters

        • token: `leap_token_${string}`

        Returns Promise<void>

    • get:function
      • get(id: `leap_token_${string}`): Promise<ChannelToken>

      • Parameters

        • id: `leap_token_${string}`

        Returns Promise<ChannelToken>

    • isOnline:function
      • isOnline(idOrToken: `leap_token_${string}` | ChannelToken): Promise<boolean>

      • Parameters

        Returns Promise<boolean>

    • publishDirectMessage:function
      • publishDirectMessage<T>(token: `leap_token_${string}`, event: string, data: T): Promise<void>

      • Publishes a direct message to a single token

        Type Parameters

        • T

        Parameters

        • token: `leap_token_${string}`

          The token to publish a direct message to

        • event: string

          The event name

        • data: T

          The data for this event

        Returns Promise<void>

    • setState:function
      • setState(id: `leap_token_${string}`, state: State): Promise<ChannelToken>

      • Parameters

        • id: `leap_token_${string}`
        • state: State

        Returns Promise<ChannelToken>

  • create:function
    • create<T>(type: ChannelType, id?: null | string, options?: null | {
          state?: T;
      }, project?: `project_${string}`): Promise<Channel & {
          patchState<T>(state: SetStateAction<T>): Promise<void>;
          publishMessage(name: string, data: unknown): Promise<void>;
          setState<T>(state: SetStateAction<T>): Promise<void>;
          subscribeToken(token: `leap_token_${string}`): Promise<void>;
          subscribeTokens(tokens: `leap_token_${string}`[] | Set<`leap_token_${string}`>): Promise<void>;
      }>

    • Creates a new channel

      Type Parameters

      Parameters

      • type: ChannelType

        The type of the channel to create

      • Optional id: null | string

        An ID to assign to the channel (optional, set this to undefined or null if you do not want to specify an ID)

      • Optional options: null | {
            state?: T;
        }
      • Optional project: `project_${string}`

        A project ID (if necessary) to assign this to

      Returns Promise<Channel & {
          patchState<T>(state: SetStateAction<T>): Promise<void>;
          publishMessage(name: string, data: unknown): Promise<void>;
          setState<T>(state: SetStateAction<T>): Promise<void>;
          subscribeToken(token: `leap_token_${string}`): Promise<void>;
          subscribeTokens(tokens: `leap_token_${string}`[] | Set<`leap_token_${string}`>): Promise<void>;
      }>

  • delete:function
    • delete(id: string): Promise<void>

    • Parameters

      • id: string

      Returns Promise<void>

  • get:function
    • get(id: string): Promise<Channel & {
          patchState<T>(state: SetStateAction<T>): Promise<void>;
          publishMessage(name: string, data: unknown): Promise<void>;
          setState<T>(state: SetStateAction<T>): Promise<void>;
          subscribeToken(token: `leap_token_${string}`): Promise<void>;
          subscribeTokens(tokens: `leap_token_${string}`[] | Set<`leap_token_${string}`>): Promise<void>;
      }>

    • Parameters

      • id: string

      Returns Promise<Channel & {
          patchState<T>(state: SetStateAction<T>): Promise<void>;
          publishMessage(name: string, data: unknown): Promise<void>;
          setState<T>(state: SetStateAction<T>): Promise<void>;
          subscribeToken(token: `leap_token_${string}`): Promise<void>;
          subscribeTokens(tokens: `leap_token_${string}`[] | Set<`leap_token_${string}`>): Promise<void>;
      }>

  • getAll:function
    • getAll(project?: `project_${string}`): Promise<(Channel & {
          patchState<T>(state: SetStateAction<T>): Promise<void>;
          publishMessage(name: string, data: unknown): Promise<void>;
          setState<T>(state: SetStateAction<T>): Promise<void>;
          subscribeToken(token: `leap_token_${string}`): Promise<void>;
          subscribeTokens(tokens: `leap_token_${string}`[] | Set<`leap_token_${string}`>): Promise<void>;
      })[]>

    • Get all channels for a project

      Parameters

      • Optional project: `project_${string}`

        An optional project ID if authenticating with a PAT or Bearer

      Returns Promise<(Channel & {
          patchState<T>(state: SetStateAction<T>): Promise<void>;
          publishMessage(name: string, data: unknown): Promise<void>;
          setState<T>(state: SetStateAction<T>): Promise<void>;
          subscribeToken(token: `leap_token_${string}`): Promise<void>;
          subscribeTokens(tokens: `leap_token_${string}`[] | Set<`leap_token_${string}`>): Promise<void>;
      })[]>

  • getAllTokens:function
  • getStats:function
    • getStats(id: string): Promise<{
          online_count: number;
      }>

    • Parameters

      • id: string

      Returns Promise<{
          online_count: number;
      }>

  • patchState:function
  • publishMessage:function
    • publishMessage<T>(channel: string | Channel, event: string, data: T): Promise<void>

    • Publishes a new event to a channel

      Type Parameters

      • T

      Parameters

      • channel: string | Channel

        The channel to publish to

      • event: string

        The event name

      • data: T

        The data for this event

      Returns Promise<void>

  • setState:function
  • subscribeToken:function
    • subscribeToken(channel: string | Channel, token: `leap_token_${string}`): Promise<void>

    • Parameters

      • channel: string | Channel
      • token: `leap_token_${string}`

      Returns Promise<void>

  • subscribeTokens:function
    • subscribeTokens(channel: string | Channel, tokens: `leap_token_${string}`[] | Set<`leap_token_${string}`>): Promise<void>

    • Parameters

      • channel: string | Channel
      • tokens: `leap_token_${string}`[] | Set<`leap_token_${string}`>

      Returns Promise<void>

Readonly client

client: APIClient

Readonly ignite

ignite: {
    containers: {
        create(deployment: `deployment_${string}`): Promise<Container>;
        delete(container_id: `container_${string}`, options?: Partial<{
            recreate: boolean;
        }>): Promise<undefined | {
            container: Container;
        }>;
        getLogs(container: `container_${string}`, options?: Partial<{
            limit: number;
            offset: number;
            orderBy: "desc" | "asc";
            sortBy: "timestamp";
        }>): Promise<ContainerLog[]>;
        start(container: `container_${string}`): Promise<void>;
        stop(container: `container_${string}`): Promise<void>;
    };
    deployments: {
        create: {
            (configOrProject: `project_${string}`, bearerOrPatConfig: CreateDeploymentConfig): Promise<Infer<typeof Deployments>>;
            (configOrProject: CreateDeploymentConfig): Promise<Infer<typeof Deployments>>;
        };
        gateways: {
            create(deployment: `deployment_${string}` | Deployment, config: {
                name: string;
                protocol: null | "http";
                targetPort: number;
                type: EXTERNAL;
            } | {
                internalDomain: string;
                name: string;
                protocol: null | "http";
                targetPort: number;
                type: INTERNAL;
            }): Promise<Gateway & {
                addDomain(domain: string): Promise<void>;
                deleteDomain(domainId: `domain_${string}`): Promise<void>;
            }>;
            getAll(deploymentId: `deployment_${string}`): Promise<(Gateway & {
                addDomain(domain: string): Promise<void>;
                deleteDomain(domainId: `domain_${string}`): Promise<void>;
            })[]>;
        };
        get: {
            (name: string, projectId?: `project_${string}`): Promise<Infer<typeof Deployments>>;
            (id: `deployment_${string}`, projectId?: `project_${string}`): Promise<Infer<typeof Deployments>>;
        };
        delete(deployment: `deployment_${string}`): Promise<void>;
        getAll(projectId?: `project_${string}`): Promise<(Deployment & {
            createContainer(): Promise<Container>;
            createGateway(config: {
                name: string;
                protocol: null | "http";
                targetPort: number;
                type: EXTERNAL;
            } | {
                internalDomain: string;
                name: string;
                protocol: null | "http";
                targetPort: number;
                type: INTERNAL;
            }): Promise<Gateway & {
                addDomain(domain: string): Promise<void>;
                deleteDomain(domainId: `domain_${string}`): Promise<void>;
            }>;
            delete(): Promise<void>;
            getContainers(): Promise<Container[]>;
            getStorageStats(): Promise<Record<"volume" | "build_cache", null | Record<"provisioned_size" | "used_size", number>>>;
        })[]>;
        getContainers(deployment: `deployment_${string}`): Promise<Container[]>;
        getStorageStats(id: `deployment_${string}`): Promise<Record<"volume" | "build_cache", null | Record<"provisioned_size" | "used_size", number>>>;
        patchMetadata(deploymentId: `deployment_${string}`, metadata: Partial<DeploymentMetaData>): Promise<Deployment>;
        rollout(id: `deployment_${string}`): Promise<DeploymentRollout>;
        update(deploymentId: `deployment_${string}`, config: Partial<DeploymentConfig>): Promise<Deployment>;
    };
    domains: {
        delete: ((id: `domain_${string}`) => Promise<void>);
        get: ((id: `domain_${string}`) => Promise<Domain>);
    };
    gateways: {
        addDomain(gatewayId: `gateway_${string}`, domain: string): Promise<void>;
        create(deployment: `deployment_${string}` | Deployment, config: {
            name: string;
            protocol: null | "http";
            targetPort: number;
            type: EXTERNAL;
        } | {
            internalDomain: string;
            name: string;
            protocol: null | "http";
            targetPort: number;
            type: INTERNAL;
        }): Promise<Gateway & {
            addDomain(domain: string): Promise<void>;
            deleteDomain(domainId: `domain_${string}`): Promise<void>;
        }>;
        get(gatewayId: `gateway_${string}`): Promise<Gateway>;
        getAll(deploymentId: `deployment_${string}`): Promise<(Gateway & {
            addDomain(domain: string): Promise<void>;
            deleteDomain(domainId: `domain_${string}`): Promise<void>;
        })[]>;
    };
    healthChecks: {
        create: ((deployment: `deployment_${string}`, config: Omit<HealthCheck, "id">) => Promise<HealthCheck>);
        update: ((deployment: `deployment_${string}`, config: Partial<Omit<HealthCheck, "id">>) => Promise<void>);
    };
}

Type declaration

  • containers: {
        create(deployment: `deployment_${string}`): Promise<Container>;
        delete(container_id: `container_${string}`, options?: Partial<{
            recreate: boolean;
        }>): Promise<undefined | {
            container: Container;
        }>;
        getLogs(container: `container_${string}`, options?: Partial<{
            limit: number;
            offset: number;
            orderBy: "desc" | "asc";
            sortBy: "timestamp";
        }>): Promise<ContainerLog[]>;
        start(container: `container_${string}`): Promise<void>;
        stop(container: `container_${string}`): Promise<void>;
    }
    • create:function
      • create(deployment: `deployment_${string}`): Promise<Container>

      • Creates a container

        Returns

        The newly created container.

        Parameters

        • deployment: `deployment_${string}`

          The ID of a deployment to create a container in.

        Returns Promise<Container>

    • delete:function
      • delete(container_id: `container_${string}`, options?: Partial<{
            recreate: boolean;
        }>): Promise<undefined | {
            container: Container;
        }>

      • Deletes a container

        Parameters

        • container_id: `container_${string}`
        • options: Partial<{
              recreate: boolean;
          }> = {}

        Returns Promise<undefined | {
            container: Container;
        }>

    • getLogs:function
      • getLogs(container: `container_${string}`, options?: Partial<{
            limit: number;
            offset: number;
            orderBy: "desc" | "asc";
            sortBy: "timestamp";
        }>): Promise<ContainerLog[]>

      • Get the logs for a container

        Returns

        Parameters

        • container: `container_${string}`

          The ID of the container

        • options: Partial<{
              limit: number;
              offset: number;
              orderBy: "desc" | "asc";
              sortBy: "timestamp";
          }> = {}

        Returns Promise<ContainerLog[]>

    • start:function
      • start(container: `container_${string}`): Promise<void>

      • Parameters

        • container: `container_${string}`

        Returns Promise<void>

    • stop:function
      • stop(container: `container_${string}`): Promise<void>

      • Parameters

        • container: `container_${string}`

        Returns Promise<void>

  • deployments: {
        create: {
            (configOrProject: `project_${string}`, bearerOrPatConfig: CreateDeploymentConfig): Promise<Infer<typeof Deployments>>;
            (configOrProject: CreateDeploymentConfig): Promise<Infer<typeof Deployments>>;
        };
        gateways: {
            create(deployment: `deployment_${string}` | Deployment, config: {
                name: string;
                protocol: null | "http";
                targetPort: number;
                type: EXTERNAL;
            } | {
                internalDomain: string;
                name: string;
                protocol: null | "http";
                targetPort: number;
                type: INTERNAL;
            }): Promise<Gateway & {
                addDomain(domain: string): Promise<void>;
                deleteDomain(domainId: `domain_${string}`): Promise<void>;
            }>;
            getAll(deploymentId: `deployment_${string}`): Promise<(Gateway & {
                addDomain(domain: string): Promise<void>;
                deleteDomain(domainId: `domain_${string}`): Promise<void>;
            })[]>;
        };
        get: {
            (name: string, projectId?: `project_${string}`): Promise<Infer<typeof Deployments>>;
            (id: `deployment_${string}`, projectId?: `project_${string}`): Promise<Infer<typeof Deployments>>;
        };
        delete(deployment: `deployment_${string}`): Promise<void>;
        getAll(projectId?: `project_${string}`): Promise<(Deployment & {
            createContainer(): Promise<Container>;
            createGateway(config: {
                name: string;
                protocol: null | "http";
                targetPort: number;
                type: EXTERNAL;
            } | {
                internalDomain: string;
                name: string;
                protocol: null | "http";
                targetPort: number;
                type: INTERNAL;
            }): Promise<Gateway & {
                addDomain(domain: string): Promise<void>;
                deleteDomain(domainId: `domain_${string}`): Promise<void>;
            }>;
            delete(): Promise<void>;
            getContainers(): Promise<Container[]>;
            getStorageStats(): Promise<Record<"volume" | "build_cache", null | Record<"provisioned_size" | "used_size", number>>>;
        })[]>;
        getContainers(deployment: `deployment_${string}`): Promise<Container[]>;
        getStorageStats(id: `deployment_${string}`): Promise<Record<"volume" | "build_cache", null | Record<"provisioned_size" | "used_size", number>>>;
        patchMetadata(deploymentId: `deployment_${string}`, metadata: Partial<DeploymentMetaData>): Promise<Deployment>;
        rollout(id: `deployment_${string}`): Promise<DeploymentRollout>;
        update(deploymentId: `deployment_${string}`, config: Partial<DeploymentConfig>): Promise<Deployment>;
    }
    • create: {
          (configOrProject: `project_${string}`, bearerOrPatConfig: CreateDeploymentConfig): Promise<Infer<typeof Deployments>>;
          (configOrProject: CreateDeploymentConfig): Promise<Infer<typeof Deployments>>;
      }
        • (configOrProject: `project_${string}`, bearerOrPatConfig: CreateDeploymentConfig): Promise<Infer<typeof Deployments>>

        • Creates a new deployment. You should use this overload if you are authorizing with a bearer or pat.

          Parameters

          • configOrProject: `project_${string}`

            The project ID to create the deployment in.

          • bearerOrPatConfig: CreateDeploymentConfig

            The deployment config to create.

          Returns Promise<Infer<typeof Deployments>>

        • (configOrProject: CreateDeploymentConfig): Promise<Infer<typeof Deployments>>

        • Create a new deployment. You should use this overload if you are authorizing with a project token and not with a bearer or pat.

          Parameters

          Returns Promise<Infer<typeof Deployments>>

    • gateways: {
          create(deployment: `deployment_${string}` | Deployment, config: {
              name: string;
              protocol: null | "http";
              targetPort: number;
              type: EXTERNAL;
          } | {
              internalDomain: string;
              name: string;
              protocol: null | "http";
              targetPort: number;
              type: INTERNAL;
          }): Promise<Gateway & {
              addDomain(domain: string): Promise<void>;
              deleteDomain(domainId: `domain_${string}`): Promise<void>;
          }>;
          getAll(deploymentId: `deployment_${string}`): Promise<(Gateway & {
              addDomain(domain: string): Promise<void>;
              deleteDomain(domainId: `domain_${string}`): Promise<void>;
          })[]>;
      }

      Deprecated

      This property has moved — use hop.ignite.gateways instead

      • create:function
        • create(deployment: `deployment_${string}` | Deployment, config: {
              name: string;
              protocol: null | "http";
              targetPort: number;
              type: EXTERNAL;
          } | {
              internalDomain: string;
              name: string;
              protocol: null | "http";
              targetPort: number;
              type: INTERNAL;
          }): Promise<Gateway & {
              addDomain(domain: string): Promise<void>;
              deleteDomain(domainId: `domain_${string}`): Promise<void>;
          }>

        • Creates and attaches a gateway to a deployment

          Parameters

          • deployment: `deployment_${string}` | Deployment

            The deployment to create a gateway on

          • config: {
                name: string;
                protocol: null | "http";
                targetPort: number;
                type: EXTERNAL;
            } | {
                internalDomain: string;
                name: string;
                protocol: null | "http";
                targetPort: number;
                type: INTERNAL;
            }

          Returns Promise<Gateway & {
              addDomain(domain: string): Promise<void>;
              deleteDomain(domainId: `domain_${string}`): Promise<void>;
          }>

      • getAll:function
        • getAll(deploymentId: `deployment_${string}`): Promise<(Gateway & {
              addDomain(domain: string): Promise<void>;
              deleteDomain(domainId: `domain_${string}`): Promise<void>;
          })[]>

        • Fecthes all gateways attached to a deployment

          Parameters

          • deploymentId: `deployment_${string}`

            The ID of the deployment to fetch gateways for

          Returns Promise<(Gateway & {
              addDomain(domain: string): Promise<void>;
              deleteDomain(domainId: `domain_${string}`): Promise<void>;
          })[]>

    • get: {
          (name: string, projectId?: `project_${string}`): Promise<Infer<typeof Deployments>>;
          (id: `deployment_${string}`, projectId?: `project_${string}`): Promise<Infer<typeof Deployments>>;
      }
        • (name: string, projectId?: `project_${string}`): Promise<Infer<typeof Deployments>>

        • Gets a deployment by name

          Parameters

          • name: string

            The deployment name to get

          • Optional projectId: `project_${string}`

            The project ID. You only need to provide this if you are getting by name.

          Returns Promise<Infer<typeof Deployments>>

        • (id: `deployment_${string}`, projectId?: `project_${string}`): Promise<Infer<typeof Deployments>>

        • Gets a deployment by id

          Parameters

          • id: `deployment_${string}`

            The deployment ID

          • Optional projectId: `project_${string}`

          Returns Promise<Infer<typeof Deployments>>

    • delete:function
      • delete(deployment: `deployment_${string}`): Promise<void>

      • Deletes a deployment

        Parameters

        • deployment: `deployment_${string}`

          The ID of the deployment

        Returns Promise<void>

    • getAll:function
      • getAll(projectId?: `project_${string}`): Promise<(Deployment & {
            createContainer(): Promise<Container>;
            createGateway(config: {
                name: string;
                protocol: null | "http";
                targetPort: number;
                type: EXTERNAL;
            } | {
                internalDomain: string;
                name: string;
                protocol: null | "http";
                targetPort: number;
                type: INTERNAL;
            }): Promise<Gateway & {
                addDomain(domain: string): Promise<void>;
                deleteDomain(domainId: `domain_${string}`): Promise<void>;
            }>;
            delete(): Promise<void>;
            getContainers(): Promise<Container[]>;
            getStorageStats(): Promise<Record<"volume" | "build_cache", null | Record<"provisioned_size" | "used_size", number>>>;
        })[]>

      • Gets all deployments for a project

        Returns

        A list of deployments for the given project.

        Parameters

        • Optional projectId: `project_${string}`

          The project ID to list deployments for. You only need to provide this if you are using bearer or PAT authentication.

        Returns Promise<(Deployment & {
            createContainer(): Promise<Container>;
            createGateway(config: {
                name: string;
                protocol: null | "http";
                targetPort: number;
                type: EXTERNAL;
            } | {
                internalDomain: string;
                name: string;
                protocol: null | "http";
                targetPort: number;
                type: INTERNAL;
            }): Promise<Gateway & {
                addDomain(domain: string): Promise<void>;
                deleteDomain(domainId: `domain_${string}`): Promise<void>;
            }>;
            delete(): Promise<void>;
            getContainers(): Promise<Container[]>;
            getStorageStats(): Promise<Record<"volume" | "build_cache", null | Record<"provisioned_size" | "used_size", number>>>;
        })[]>

    • getContainers:function
      • getContainers(deployment: `deployment_${string}`): Promise<Container[]>

      • Get all containers for a deployment

        Returns

        A list of all containers for that project

        Parameters

        • deployment: `deployment_${string}`

          The ID of the deployment to get

        Returns Promise<Container[]>

    • getStorageStats:function
      • getStorageStats(id: `deployment_${string}`): Promise<Record<"volume" | "build_cache", null | Record<"provisioned_size" | "used_size", number>>>

      • Parameters

        • id: `deployment_${string}`

        Returns Promise<Record<"volume" | "build_cache", null | Record<"provisioned_size" | "used_size", number>>>

    • patchMetadata:function
    • rollout:function
      • rollout(id: `deployment_${string}`): Promise<DeploymentRollout>

      • Parameters

        • id: `deployment_${string}`

        Returns Promise<DeploymentRollout>

    • update:function
  • domains: {
        delete: ((id: `domain_${string}`) => Promise<void>);
        get: ((id: `domain_${string}`) => Promise<Domain>);
    }
    • delete: ((id: `domain_${string}`) => Promise<void>)
        • (id: `domain_${string}`): Promise<void>

        • Parameters

          • id: `domain_${string}`

          Returns Promise<void>

    • get: ((id: `domain_${string}`) => Promise<Domain>)
        • (id: `domain_${string}`): Promise<Domain>

        • Parameters

          • id: `domain_${string}`

          Returns Promise<Domain>

  • gateways: {
        addDomain(gatewayId: `gateway_${string}`, domain: string): Promise<void>;
        create(deployment: `deployment_${string}` | Deployment, config: {
            name: string;
            protocol: null | "http";
            targetPort: number;
            type: EXTERNAL;
        } | {
            internalDomain: string;
            name: string;
            protocol: null | "http";
            targetPort: number;
            type: INTERNAL;
        }): Promise<Gateway & {
            addDomain(domain: string): Promise<void>;
            deleteDomain(domainId: `domain_${string}`): Promise<void>;
        }>;
        get(gatewayId: `gateway_${string}`): Promise<Gateway>;
        getAll(deploymentId: `deployment_${string}`): Promise<(Gateway & {
            addDomain(domain: string): Promise<void>;
            deleteDomain(domainId: `domain_${string}`): Promise<void>;
        })[]>;
    }
    • addDomain:function
      • addDomain(gatewayId: `gateway_${string}`, domain: string): Promise<void>

      • Adds a domain to a gateway

        Parameters

        • gatewayId: `gateway_${string}`

          The ID of the gateway

        • domain: string

          The full name of the domain

        Returns Promise<void>

    • create:function
      • create(deployment: `deployment_${string}` | Deployment, config: {
            name: string;
            protocol: null | "http";
            targetPort: number;
            type: EXTERNAL;
        } | {
            internalDomain: string;
            name: string;
            protocol: null | "http";
            targetPort: number;
            type: INTERNAL;
        }): Promise<Gateway & {
            addDomain(domain: string): Promise<void>;
            deleteDomain(domainId: `domain_${string}`): Promise<void>;
        }>

      • Creates and attaches a gateway to a deployment

        Parameters

        • deployment: `deployment_${string}` | Deployment

          The deployment to create a gateway on

        • config: {
              name: string;
              protocol: null | "http";
              targetPort: number;
              type: EXTERNAL;
          } | {
              internalDomain: string;
              name: string;
              protocol: null | "http";
              targetPort: number;
              type: INTERNAL;
          }

        Returns Promise<Gateway & {
            addDomain(domain: string): Promise<void>;
            deleteDomain(domainId: `domain_${string}`): Promise<void>;
        }>

    • get:function
      • get(gatewayId: `gateway_${string}`): Promise<Gateway>

      • Fetches a gateway by ID

        Parameters

        • gatewayId: `gateway_${string}`

          The ID of the gateway to retrieve

        Returns Promise<Gateway>

    • getAll:function
      • getAll(deploymentId: `deployment_${string}`): Promise<(Gateway & {
            addDomain(domain: string): Promise<void>;
            deleteDomain(domainId: `domain_${string}`): Promise<void>;
        })[]>

      • Fecthes all gateways attached to a deployment

        Parameters

        • deploymentId: `deployment_${string}`

          The ID of the deployment to fetch gateways for

        Returns Promise<(Gateway & {
            addDomain(domain: string): Promise<void>;
            deleteDomain(domainId: `domain_${string}`): Promise<void>;
        })[]>

  • healthChecks: {
        create: ((deployment: `deployment_${string}`, config: Omit<HealthCheck, "id">) => Promise<HealthCheck>);
        update: ((deployment: `deployment_${string}`, config: Partial<Omit<HealthCheck, "id">>) => Promise<void>);
    }

Readonly pipe

pipe: {
    rooms: {
        create(name: string, options: {
            deliveryProtocols: DeliveryProtocol[];
            ephemeral?: boolean;
            hlsConfig?: {
                artificial_delay: number;
                max_playout_bitrate_preset: string;
                wcl_delay: number;
            };
            ingestProtocol: "rtmp" | "rtp";
        }): Promise<Room & {
            delete(): Promise<void>;
        }>;
        delete(room: `pipe_room_${string}`): Promise<void>;
        getAll(project?: `project_${string}`): Promise<(Room & {
            delete(): Promise<void>;
        })[]>;
    };
}

Type declaration

  • rooms: {
        create(name: string, options: {
            deliveryProtocols: DeliveryProtocol[];
            ephemeral?: boolean;
            hlsConfig?: {
                artificial_delay: number;
                max_playout_bitrate_preset: string;
                wcl_delay: number;
            };
            ingestProtocol: "rtmp" | "rtp";
        }): Promise<Room & {
            delete(): Promise<void>;
        }>;
        delete(room: `pipe_room_${string}`): Promise<void>;
        getAll(project?: `project_${string}`): Promise<(Room & {
            delete(): Promise<void>;
        })[]>;
    }
    • create:function
      • create(name: string, options: {
            deliveryProtocols: DeliveryProtocol[];
            ephemeral?: boolean;
            hlsConfig?: {
                artificial_delay: number;
                max_playout_bitrate_preset: string;
                wcl_delay: number;
            };
            ingestProtocol: "rtmp" | "rtp";
        }): Promise<Room & {
            delete(): Promise<void>;
        }>

      • Parameters

        • name: string
        • options: {
              deliveryProtocols: DeliveryProtocol[];
              ephemeral?: boolean;
              hlsConfig?: {
                  artificial_delay: number;
                  max_playout_bitrate_preset: string;
                  wcl_delay: number;
              };
              ingestProtocol: "rtmp" | "rtp";
          }
          • deliveryProtocols: DeliveryProtocol[]
          • Optional ephemeral?: boolean
          • Optional hlsConfig?: {
                artificial_delay: number;
                max_playout_bitrate_preset: string;
                wcl_delay: number;
            }
            • artificial_delay: number
            • max_playout_bitrate_preset: string
            • wcl_delay: number
          • ingestProtocol: "rtmp" | "rtp"

        Returns Promise<Room & {
            delete(): Promise<void>;
        }>

    • delete:function
      • delete(room: `pipe_room_${string}`): Promise<void>

      • Deletes a Pipe room

        Parameters

        • room: `pipe_room_${string}`

          The ID of the Pipe room to delete.

        Returns Promise<void>

    • getAll:function
      • getAll(project?: `project_${string}`): Promise<(Room & {
            delete(): Promise<void>;
        })[]>

      • Parameters

        • Optional project: `project_${string}`

        Returns Promise<(Room & {
            delete(): Promise<void>;
        })[]>

Readonly projects

projects: {
    projectTokens: {
        create(flags: number, projectId?: `project_${string}`): Promise<ProjectToken & {
            project: Project;
        }>;
        delete(projectTokenId: `ptkid_${string}`, project?: `project_${string}`): Promise<void>;
        get(projectId?: `project_${string}`): Promise<ProjectToken[]>;
    };
    secrets: {
        create(name: string, value: string, projectId?: `project_${string}`): Promise<Secret>;
        delete(id: string, projectId?: `project_${string}`): Promise<void>;
        getAll(projectId?: `project_${string}`): Promise<Secret[]>;
    };
    tokens: {
        create(flags: number, projectId?: `project_${string}`): Promise<ProjectToken & {
            project: Project;
        }>;
        delete(projectTokenId: `ptkid_${string}`, project?: `project_${string}`): Promise<void>;
        get(projectId?: `project_${string}`): Promise<ProjectToken[]>;
    };
    getAllMembers(projectId?: `project_${string}`): Promise<Member[]>;
    getCurrentMember(projectId: `project_${string}`): Promise<Member>;
}

Type declaration

  • projectTokens: {
        create(flags: number, projectId?: `project_${string}`): Promise<ProjectToken & {
            project: Project;
        }>;
        delete(projectTokenId: `ptkid_${string}`, project?: `project_${string}`): Promise<void>;
        get(projectId?: `project_${string}`): Promise<ProjectToken[]>;
    }

    Deprecated

    Use .tokens instead

    • create:function
      • create(flags: number, projectId?: `project_${string}`): Promise<ProjectToken & {
            project: Project;
        }>

      • Creates a new project token

        Returns

        A newly created project token

        Parameters

        • flags: number

          Permissions for this flag

        • Optional projectId: `project_${string}`

          The project to create a key for

        Returns Promise<ProjectToken & {
            project: Project;
        }>

    • delete:function
      • delete(projectTokenId: `ptkid_${string}`, project?: `project_${string}`): Promise<void>

      • Deletes a project token by its ID

        Parameters

        • projectTokenId: `ptkid_${string}`

          The ID of the project token to delete

        • Optional project: `project_${string}`

        Returns Promise<void>

    • get:function
      • get(projectId?: `project_${string}`): Promise<ProjectToken[]>

      • Get all project tokens for a project

        Returns

        An array of all secrets for the project

        Parameters

        • Optional projectId: `project_${string}`

          The project to fetch secrets for

        Returns Promise<ProjectToken[]>

  • secrets: {
        create(name: string, value: string, projectId?: `project_${string}`): Promise<Secret>;
        delete(id: string, projectId?: `project_${string}`): Promise<void>;
        getAll(projectId?: `project_${string}`): Promise<Secret[]>;
    }
    • create:function
      • create(name: string, value: string, projectId?: `project_${string}`): Promise<Secret>

      • Creates a new project secret

        Parameters

        • name: string

          The name of the secret

        • value: string

          The value of the secret

        • Optional projectId: `project_${string}`

          The project to create the secret in

        Returns Promise<Secret>

    • delete:function
      • delete(id: string, projectId?: `project_${string}`): Promise<void>

      • Deletes a secret from a project

        Parameters

        • id: string

          The secret ID to delete

        • Optional projectId: `project_${string}`

          The project to delete the secret from

        Returns Promise<void>

    • getAll:function
      • getAll(projectId?: `project_${string}`): Promise<Secret[]>

      • Gets all secrets in a project

        Parameters

        • Optional projectId: `project_${string}`

          The project to fetch secrets for

        Returns Promise<Secret[]>

  • tokens: {
        create(flags: number, projectId?: `project_${string}`): Promise<ProjectToken & {
            project: Project;
        }>;
        delete(projectTokenId: `ptkid_${string}`, project?: `project_${string}`): Promise<void>;
        get(projectId?: `project_${string}`): Promise<ProjectToken[]>;
    }
    • create:function
      • create(flags: number, projectId?: `project_${string}`): Promise<ProjectToken & {
            project: Project;
        }>

      • Creates a new project token

        Returns

        A newly created project token

        Parameters

        • flags: number

          Permissions for this flag

        • Optional projectId: `project_${string}`

          The project to create a key for

        Returns Promise<ProjectToken & {
            project: Project;
        }>

    • delete:function
      • delete(projectTokenId: `ptkid_${string}`, project?: `project_${string}`): Promise<void>

      • Deletes a project token by its ID

        Parameters

        • projectTokenId: `ptkid_${string}`

          The ID of the project token to delete

        • Optional project: `project_${string}`

        Returns Promise<void>

    • get:function
      • get(projectId?: `project_${string}`): Promise<ProjectToken[]>

      • Get all project tokens for a project

        Returns

        An array of all secrets for the project

        Parameters

        • Optional projectId: `project_${string}`

          The project to fetch secrets for

        Returns Promise<ProjectToken[]>

  • getAllMembers:function
    • getAllMembers(projectId?: `project_${string}`): Promise<Member[]>

    • Parameters

      • Optional projectId: `project_${string}`

      Returns Promise<Member[]>

  • getCurrentMember:function
    • getCurrentMember(projectId: `project_${string}`): Promise<Member>

    • Fetch the currently authorized member from a project. You cannot use this route if you are authorizing with a project token as there is no user attached to it.

      Returns

      The member authorized by the SDK

      Parameters

      • projectId: `project_${string}`

        The project ID to fetch a member from

      Returns Promise<Member>

Readonly registry

registry: {
    images: {
        delete(image: string): Promise<void>;
        getAll(project?: `project_${string}`): Promise<string[]>;
        getManifest(image: string): Promise<{
            digest: {
                digest: string;
                size: number;
                uploaded: string;
            };
            tag: null | string;
        }[]>;
    };
}

Type declaration

  • images: {
        delete(image: string): Promise<void>;
        getAll(project?: `project_${string}`): Promise<string[]>;
        getManifest(image: string): Promise<{
            digest: {
                digest: string;
                size: number;
                uploaded: string;
            };
            tag: null | string;
        }[]>;
    }
    • delete:function
      • delete(image: string): Promise<void>

      • Parameters

        • image: string

        Returns Promise<void>

    • getAll:function
      • getAll(project?: `project_${string}`): Promise<string[]>

      • Parameters

        • Optional project: `project_${string}`

        Returns Promise<string[]>

    • getManifest:function
      • getManifest(image: string): Promise<{
            digest: {
                digest: string;
                size: number;
                uploaded: string;
            };
            tag: null | string;
        }[]>

      • Parameters

        • image: string

        Returns Promise<{
            digest: {
                digest: string;
                size: number;
                uploaded: string;
            };
            tag: null | string;
        }[]>

Readonly users

users: {
    me: {
        pats: {
            create(name: string): Promise<PAT>;
            delete(id: `pat_${string}`): Promise<void>;
            getAll(): Promise<PAT[]>;
        };
        get(): Promise<{
            leap_token: null | string;
            project_member_role_map: Record<`project_${string}`, MemberRole>;
            projects: Project[];
            user: SelfUser;
        }>;
    };
}

Type declaration

  • me: {
        pats: {
            create(name: string): Promise<PAT>;
            delete(id: `pat_${string}`): Promise<void>;
            getAll(): Promise<PAT[]>;
        };
        get(): Promise<{
            leap_token: null | string;
            project_member_role_map: Record<`project_${string}`, MemberRole>;
            projects: Project[];
            user: SelfUser;
        }>;
    }
    • pats: {
          create(name: string): Promise<PAT>;
          delete(id: `pat_${string}`): Promise<void>;
          getAll(): Promise<PAT[]>;
      }
      • create:function
        • create(name: string): Promise<PAT>

        • Creates a PAT for the current user

          Returns

          The created PAT

          Parameters

          • name: string

          Returns Promise<PAT>

      • delete:function
        • delete(id: `pat_${string}`): Promise<void>

        • Deletes a pat

          Parameters

          • id: `pat_${string}`

            The ID of the pat to delete

          Returns Promise<void>

      • getAll:function
        • getAll(): Promise<PAT[]>

        • Fetches all PATs for this user

          Returns

          A list of all pats

          Returns Promise<PAT[]>

    • get:function
      • get(): Promise<{
            leap_token: null | string;
            project_member_role_map: Record<`project_${string}`, MemberRole>;
            projects: Project[];
            user: SelfUser;
        }>

      • Gets the current user

        Returns

        The current user authorized by the SDK

        Returns Promise<{
            leap_token: null | string;
            project_member_role_map: Record<`project_${string}`, MemberRole>;
            projects: Project[];
            user: SelfUser;
        }>

Settings

Member Visibility

Theme

Generated using TypeDoc