moon_cpal/pkg.generated.mbti at main · moonbit-community/moon_cpal · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
// Generated using `moon info`, DON'T EDIT IT
package "moonbit-community/moon_cpal"

import {
  "moonbit-community/moon_cpal/core",
  "moonbit-community/moon_cpal/spec",
  "moonbit-community/moon_cpal/traits",
  "moonbitlang/core/builtin",
}

// Values
pub fn all_hosts() -> Array[@core.HostId]

pub fn available_hosts() -> Array[@core.HostId]

pub fn common_sample_rates() -> Array[Int]

pub fn default_host() -> @spec.Host

pub fn host_from_id(@core.HostId) -> @spec.Host raise @core.HostUnavailable

pub fn[A : @core.Sample, B : @core.Sample] sample_cast(A) -> B

pub fn try_host_from_id(@core.HostId) -> @spec.Host?

// Errors

// Types and methods

// Type aliases
pub using @core {type BackendSpecificError}

pub using @core {type BufferSize}

pub using @core {type BuildStreamError}

pub type ChannelCount = Int

pub using @spec {type Data}

pub using @core {type DefaultStreamConfigError}

pub using @spec {type Device}

pub using @core {type DeviceDescription}

pub using @core {type DeviceDescriptionBuilder}

pub using @core {type DeviceDirection}

pub using @core {type DeviceId}

pub using @core {type DeviceIdError}

pub using @core {type DeviceNameError}

pub using @core {type DeviceType}

pub type Devices = Iter[@spec.Device]

pub using @core {type DevicesError}

pub using @builtin {type Iter as DevicesFiltered}

pub using @core {type Duration}

pub type FrameCount = Int

pub using @spec {type Host}

pub using @core {type HostId}

pub using @core {type HostUnavailable}

pub using @core {type I24}

pub using @core {type InputCallbackInfo}

pub using @builtin {type Iter as InputDevices}

pub using @core {type InputStreamTimestamp}

pub using @core {type InterfaceType}

pub using @core {type OutputCallbackInfo}

pub using @builtin {type Iter as OutputDevices}

pub using @core {type OutputStreamTimestamp}

pub using @core {type PauseStreamError}

pub using @core {type PlayStreamError}

pub using @core {type SampleFormat}

pub type SampleRate = Int

pub using @spec {type Stream}

pub using @core {type StreamConfig}

pub using @core {type StreamError}

pub using @core {type StreamInstant}

pub using @core {type SupportedBufferSize}

pub type SupportedInputConfigs = Iter[@core.SupportedStreamConfigRange]

pub type SupportedOutputConfigs = Iter[@core.SupportedStreamConfigRange]

pub using @core {type SupportedStreamConfig}

pub using @core {type SupportedStreamConfigRange}

pub using @core {type SupportedStreamConfigsError}

pub using @core {type U24}

pub using @traits {trait DeviceTrait}

pub using @core {trait FromSample}

pub using @traits {trait HostTrait}

pub using @core {trait Sample}

pub using @core {trait SizedSample}

pub using @traits {trait StreamTrait}

// Traits