type stringclasses 7
values | content stringlengths 4 9.55k | repo stringlengths 7 96 | path stringlengths 4 178 | language stringclasses 1
value |
|---|---|---|---|---|
FunctionDeclaration |
function validateCommands(commands: string[]): void {
for (let i = 0; i < commands.length; i++) {
const cmd = commands[i];
if (cmd == null) {
throw new Error(`The requested path contains ${cmd} segment at index ${i}`);
}
}
} | atscott/angular | packages/router/src/router.ts | TypeScript |
FunctionDeclaration |
function isBrowserTriggeredNavigation(source: 'imperative'|'popstate'|'hashchange') {
return source !== 'imperative';
} | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
(r: Route) => this.triggerEvent(new RouteConfigLoadStart(r)) | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
(r: Route) => this.triggerEvent(new RouteConfigLoadEnd(r)) | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
t => t.id !== 0 | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
t =>
({...t, extractedUrl: this.urlHandlingStrategy.extract(t.rawUrl)} as
NavigationTransition) | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
t => {
this.currentNavigation = {
id: t.id,
initialUrl: t.currentRawUrl,
extractedUrl: t.extractedUrl,
trigger: t.source,
extras: t.extras,
previo... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
t => {
const browserUrlTree = this.browserUrlTree.toString();
const urlTransition = !this.navigated ||
t.extractedUrl.toString() !== browserUrlTree ||
// Navigations which succeed or ones which fail and are cleaned up
... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
t => {
const transition = this.transitions.getValue();
eventsSubject.next(new NavigationStart(
t.id, this.serializeUrl(t.extractedUrl), t.source,
t.restoredState));
... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
t => {
this.currentNavigation = {
...this.currentNavigation!,
finalUrl: t.urlAfterRedirects
};
} | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
(url) => this.serializeUrl(url) | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
t => {
if (this.urlUpdateStrategy === 'eager') {
if (!t.extras.skipLocationChange) {
const rawUrl = this.urlHandlingStrategy.merge(
t.urlAfterRedirects, t.rawUrl);
... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
t => {
const {
targetSnapshot,
id: navigationId,
extractedUrl: appliedUrlTree,
rawUrl: rawUrlTree,
extras: {skipLocationChange, replaceUrl}
} = t;
... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
t => {
const guardsStart = new GuardsCheckStart(
t.id, this.serializeUrl(t.extractedUrl),
this.serializeUrl(t.urlAfterRedirects), t.targetSnapshot!);
this.triggerEvent(guardsStart);
} | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
t => ({
...t,
guards: getAllRouteGuards(
t.targetSnapshot!, t.currentSnapshot, this.rootContexts)
}) | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
(evt: Event) => this.triggerEvent(evt) | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
t => {
if (isUrlTree(t.guardsResult)) {
const error: Error&{url?: UrlTree} = navigationCancelingError(
`Redirecting to "${this.serializeUrl(t.guardsResult)}"`);
error.url = t.guardsResult;
thr... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
t => {
if (!t.guardsResult) {
this.restoreHistory(t);
this.cancelNavigationTransition(t, '');
return false;
}
return true;
} | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
t => {
if (t.guards.canActivateChecks.length) {
return of(t).pipe(
tap(t => {
const resolveStart = new ResolveStart(
t.id, this.serializeUrl(t.extractedUrl),
... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
t => {
const resolveStart = new ResolveStart(
t.id, this.serializeUrl(t.extractedUrl),
this.serializeUrl(t.urlAfterRedirects), t.targetSnapshot!);
this.triggerEvent(resolveStart);
... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
t => {
let dataResolved = false;
return of(t).pipe(
resolveData(
this.paramsInheritanceStrategy, this.ngModule.injector),
tap({
... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
() => dataResolved = true | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
() => {
if (!dataResolved) {
this.restoreHistory(t);
this.cancelNavigationTransition(
t,
`At least one route... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
t => {
const resolveEnd = new ResolveEnd(
t.id, this.serializeUrl(t.extractedUrl),
this.serializeUrl(t.urlAfterRedirects), t.targetSnapshot!);
this.triggerEvent(resolveEnd);
... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
(t: NavigationTransition) => {
const {
targetSnapshot,
id: navigationId,
extractedUrl: appliedUrlTree,
rawUrl: rawUrlTree,
extras: {skipLocationChange, replaceUrl}
... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
(t: NavigationTransition) => {
const targetRouterState = createRouterState(
this.routeReuseStrategy, t.targetSnapshot!, t.currentRouterState);
return ({...t, targetRouterState});
} | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
(t: NavigationTransition) => {
this.currentUrlTree = t.urlAfterRedirects;
this.rawUrlTree =
this.urlHandlingStrategy.merge(t.urlAfterRedirects, t.rawUrl);
(this as {routerState: RouterState}).routerState = t.targetRouterSt... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
() => {
/* When the navigation stream finishes either through error or success, we
* set the `completed` or `errored` flag. However, there are some situations
* where we could get here without either of those being set. For instance, a
... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
(e) => {
// TODO(atscott): The NavigationTransition `t` used here does not accurately
// reflect the current state of the whole transition because some operations
// return a new object rather than modifying the one in the outermost
... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
() => {
const mergedTree =
this.urlHandlingStrategy.merge(e.url, this.rawUrlTree);
const extras = {
skipLocationChange: t.extras.skipLocationChange,
// The URL is alr... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
event => {
const source = event['type'] === 'popstate' ? 'popstate' : 'hashchange';
if (source === 'popstate') {
// The `setTimeout` was added in #12160 and is likely to support Angular/AngularJS
// hybrid apps.
setTimeout(() => {
const extras: NavigationExtras... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
() => {
const extras: NavigationExtras = {replaceUrl: true};
// Navigations coming from Angular router have a navigationId state
// property. When this exists, restore the state.
const state = event.state?.navigationId ? event.state : null;
if (state) {
... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
(result: Params, key: string) => {
const value: any = params[key];
if (value !== null && value !== undefined) {
result[key] = value;
}
return result;
} | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
t => {
this.navigated = true;
this.lastSuccessfulId = t.id;
this.currentPageId = t.targetPageId;
(this.events as Subject<Event>)
.next(new NavigationEnd(
t.id, this.serializeUrl(t.extractedUrl), this.serializeUrl(this.currentUrlTree)));
... | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
e => {
this.console.warn(`Unhandled Navigation Error: ${e}`);
} | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
(res, rej) => {
resolve = res;
reject = rej;
} | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
(e: any) => {
return Promise.reject(e);
} | atscott/angular | packages/router/src/router.ts | TypeScript |
InterfaceDeclaration | /**
* @description
*
* Options that modify the `Router` URL.
* Supply an object containing any of these properties to a `Router` navigation function to
* control how the target URL should be constructed.
*
* @see [Router.navigate() method](api/router/Router#navigate)
* @see [Router.createUrlTree() method](api/r... | atscott/angular | packages/router/src/router.ts | TypeScript |
InterfaceDeclaration | /**
* @description
*
* Options that modify the `Router` navigation strategy.
* Supply an object containing any of these properties to a `Router` navigation function to
* control how the navigation should be handled.
*
* @see [Router.navigate() method](api/router/Router#navigate)
* @see [Router.navigateByUrl() m... | atscott/angular | packages/router/src/router.ts | TypeScript |
InterfaceDeclaration | /**
* @description
*
* Options that modify the `Router` navigation strategy.
* Supply an object containing any of these properties to a `Router` navigation function to
* control how the target URL should be constructed or interpreted.
*
* @see [Router.navigate() method](api/router/Router#navigate)
* @see [Route... | atscott/angular | packages/router/src/router.ts | TypeScript |
InterfaceDeclaration | /**
* Information about a navigation operation.
* Retrieve the most recent navigation object with the
* [Router.getCurrentNavigation() method](api/router/Router#getcurrentnavigation) .
*
* * *id* : The unique identifier of the current navigation.
* * *initialUrl* : The target URL passed into the `Router#navigateB... | atscott/angular | packages/router/src/router.ts | TypeScript |
TypeAliasDeclaration | /**
* Error handler that is invoked when a navigation error occurs.
*
* If the handler returns a value, the navigation Promise is resolved with this value.
* If the handler throws an exception, the navigation Promise is rejected with
* the exception.
*
* @publicApi
*/
export type ErrorHandler = (error: any) => ... | atscott/angular | packages/router/src/router.ts | TypeScript |
TypeAliasDeclaration |
export type RestoredState = {
[k: string]: any,
// TODO(#27607): Remove `navigationId` and `ɵrouterPageId` and move to `ng` or `ɵ` namespace.
navigationId: number,
// The `ɵ` prefix is there to reduce the chance of colliding with any existing user properties on
// the history state.
ɵrouterPageId?: number,... | atscott/angular | packages/router/src/router.ts | TypeScript |
TypeAliasDeclaration |
export type NavigationTransition = {
id: number,
targetPageId: number,
currentUrlTree: UrlTree,
currentRawUrl: UrlTree,
extractedUrl: UrlTree,
urlAfterRedirects: UrlTree,
rawUrl: UrlTree,
extras: NavigationExtras,
resolve: any,
reject: any,
promise: Promise<boolean>,
source: NavigationTrigger,
... | atscott/angular | packages/router/src/router.ts | TypeScript |
TypeAliasDeclaration | /**
* @internal
*/
export type RouterHook = (snapshot: RouterStateSnapshot, runExtras: {
appliedUrlTree: UrlTree,
rawUrlTree: UrlTree,
skipLocationChange: boolean,
replaceUrl: boolean,
navigationId: number
}) => Observable<void>; | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration |
next() {
completed = true;
} | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration |
complete() {
completed = true;
} | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration | /**
* @internal
* TODO: this should be removed once the constructor of the router made internal
*/
resetRootComponentType(rootComponentType: Type<any>): void {
this.rootComponentType = rootComponentType;
// TODO: vsavkin router 4.0 should make the root component set to null
// this will simplify th... | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration |
private getTransition(): NavigationTransition {
const transition = this.transitions.value;
// TODO(atscott): This comment doesn't make it clear why this value needs to be set. In the case
// described below (where we don't handle previous or current url), the `browserUrlTree` is set
// to the `urlAfter... | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration |
private setTransition(t: Partial<NavigationTransition>): void {
this.transitions.next({...this.getTransition(), ...t});
} | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration | /**
* Sets up the location change listener and performs the initial navigation.
*/
initialNavigation(): void {
this.setUpLocationChangeListener();
if (this.navigationId === 0) {
this.navigateByUrl(this.location.path(true), {replaceUrl: true});
}
} | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration | /**
* Sets up the location change listener. This listener detects navigations triggered from outside
* the Router (the browser back/forward buttons, for example) and schedules a corresponding Router
* navigation so that the correct events, guards, etc. are triggered.
*/
setUpLocationChangeListener(): void {... | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration | /**
* Returns the current `Navigation` object when the router is navigating,
* and `null` when idle.
*/
getCurrentNavigation(): Navigation|null {
return this.currentNavigation;
} | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration | /** @internal */
triggerEvent(event: Event): void {
(this.events as Subject<Event>).next(event);
} | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration | /**
* Resets the route configuration used for navigation and generating links.
*
* @param config The route array for the new configuration.
*
* @usageNotes
*
* ```
* router.resetConfig([
* { path: 'team/:id', component: TeamCmp, children: [
* { path: 'simple', component: SimpleCmp },
... | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration | /** @nodoc */
ngOnDestroy(): void {
this.dispose();
} | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration | /** Disposes of the router. */
dispose(): void {
this.transitions.complete();
if (this.locationSubscription) {
this.locationSubscription.unsubscribe();
this.locationSubscription = undefined;
}
this.disposed = true;
} | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration | /**
* Appends URL segments to the current URL tree to create a new URL tree.
*
* @param commands An array of URL fragments with which to construct the new URL tree.
* If the path is static, can be the literal URL string. For a dynamic path, pass an array of path
* segments, followed by the parameters for... | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration | /**
* Navigates to a view using an absolute route path.
*
* @param url An absolute path for a defined route. The function does not apply any delta to the
* current URL.
* @param extras An object containing properties that modify the navigation strategy.
*
* @returns A Promise that resolves to '... | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration | /**
* Navigate based on the provided array of commands and a starting point.
* If no starting route is provided, the navigation is absolute.
*
* @param commands An array of URL fragments with which to construct the target URL.
* If the path is static, can be the literal URL string. For a dynamic path, pa... | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration | /** Serializes a `UrlTree` into a string */
serializeUrl(url: UrlTree): string {
return this.urlSerializer.serialize(url);
} | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration | /** Parses a string into a `UrlTree` */
parseUrl(url: string): UrlTree {
let urlTree: UrlTree;
try {
urlTree = this.urlSerializer.parse(url);
} catch (e) {
urlTree = this.malformedUriErrorHandler(e, this.urlSerializer, url);
}
return urlTree;
} | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration | /**
* Returns whether the url is activated.
*
* @deprecated
* Use `IsActiveMatchOptions` instead.
*
* - The equivalent `IsActiveMatchOptions` for `true` is
* `{paths: 'exact', queryParams: 'exact', fragment: 'ignored', matrixParams: 'ignored'}`.
* - The equivalent for `false` is
* `{paths: 's... | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration | /**
* Returns whether the url is activated.
*/
isActive(url: string|UrlTree, matchOptions: IsActiveMatchOptions): boolean; | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration | /** @internal */
isActive(url: string|UrlTree, matchOptions: boolean|IsActiveMatchOptions): boolean; | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration |
isActive(url: string|UrlTree, matchOptions: boolean|IsActiveMatchOptions): boolean {
let options: IsActiveMatchOptions;
if (matchOptions === true) {
options = {...exactMatchOptions};
} else if (matchOptions === false) {
options = {...subsetMatchOptions};
} else {
options = matchOption... | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration |
private removeEmptyProps(params: Params): Params {
return Object.keys(params).reduce((result: Params, key: string) => {
const value: any = params[key];
if (value !== null && value !== undefined) {
result[key] = value;
}
return result;
}, {});
} | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration |
private processNavigations(): void {
this.navigations.subscribe(
t => {
this.navigated = true;
this.lastSuccessfulId = t.id;
this.currentPageId = t.targetPageId;
(this.events as Subject<Event>)
.next(new NavigationEnd(
t.id, this.seria... | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration |
private scheduleNavigation(
rawUrl: UrlTree, source: NavigationTrigger, restoredState: RestoredState|null,
extras: NavigationExtras,
priorPromise?: {resolve: any, reject: any, promise: Promise<boolean>}): Promise<boolean> {
if (this.disposed) {
return Promise.resolve(false);
}
// *... | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration |
private setBrowserUrl(url: UrlTree, t: NavigationTransition) {
const path = this.urlSerializer.serialize(url);
const state = {...t.extras.state, ...this.generateNgRouterState(t.id, t.targetPageId)};
if (this.location.isCurrentPathEqualTo(path) || !!t.extras.replaceUrl) {
this.location.replaceState(pa... | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration | /**
* Performs the necessary rollback action to restore the browser URL to the
* state before the transition.
*/
private restoreHistory(t: NavigationTransition, restoringFromCaughtError = false) {
if (this.canceledNavigationResolution === 'computed') {
const targetPagePosition = this.currentPageId - ... | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration |
private resetState(t: NavigationTransition): void {
(this as {routerState: RouterState}).routerState = t.currentRouterState;
this.currentUrlTree = t.currentUrlTree;
// Note here that we use the urlHandlingStrategy to get the reset `rawUrlTree` because it may be
// configured to handle only part of the ... | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration |
private resetUrlToCurrentUrlTree(): void {
this.location.replaceState(
this.urlSerializer.serialize(this.rawUrlTree), '',
this.generateNgRouterState(this.lastSuccessfulId, this.currentPageId));
} | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration |
private cancelNavigationTransition(t: NavigationTransition, reason: string) {
const navCancel = new NavigationCancel(t.id, this.serializeUrl(t.extractedUrl), reason);
this.triggerEvent(navCancel);
t.resolve(false);
} | atscott/angular | packages/router/src/router.ts | TypeScript |
MethodDeclaration |
private generateNgRouterState(navigationId: number, routerPageId?: number) {
if (this.canceledNavigationResolution === 'computed') {
return {navigationId, ɵrouterPageId: routerPageId};
}
return {navigationId};
} | atscott/angular | packages/router/src/router.ts | TypeScript |
ArrowFunction |
<P extends InjectedProjectProps>(
WrappedComponent: React.ComponentType<P>
) =>
class extends React.Component<
Omit<P, keyof InjectedProjectProps> & Partial<InjectedProjectProps>
> {
static displayName = `withProject(${getDisplayName(WrappedComponent)})`;
static contextTypes = {
project: Sentry... | pierredup/sentry | src/sentry/static/sentry/app/utils/withProject.tsx | TypeScript |
TypeAliasDeclaration |
type InjectedProjectProps = {
project: Project;
}; | pierredup/sentry | src/sentry/static/sentry/app/utils/withProject.tsx | TypeScript |
MethodDeclaration |
render() {
return (
<WrappedComponent
project={this.context.project as Project}
{...(this.props as P)}
/> | pierredup/sentry | src/sentry/static/sentry/app/utils/withProject.tsx | TypeScript |
EnumDeclaration | /** Methods to use when ordering `Hero`. */
export enum HeroesOrderBy {
Natural = 'NATURAL',
IdAsc = 'ID_ASC',
IdDesc = 'ID_DESC',
NameAsc = 'NAME_ASC',
NameDesc = 'NAME_DESC',
PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
PrimaryKeyDesc = 'PRIMARY_KEY_DESC'
} | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
ID: string;
String: string;
Boolean: boolean;
Int: number;
Float: number;
/** A location in a connection that can be used for resuming pagination. */
Cursor: any;
}; | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** All input for the create `Hero` mutation. */
export type CreateHeroInput = {
/**
* An arbitrary string value with no semantic meaning. Will be included in the
* payload verbatim. May be used to track mutations by the client.
*/
clientMutationId?: Maybe<Scalars['String']>;
/** The `Hero` to be created... | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** The output of our create `Hero` mutation. */
export type CreateHeroPayload = {
__typename?: 'CreateHeroPayload';
/**
* The exact same `clientMutationId` that was provided in the mutation input,
* unchanged and unused. May be used by a client to track mutations.
*/
clientMutationId?: Maybe<Scalars['S... | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** The output of our create `Hero` mutation. */
export type CreateHeroPayloadHeroEdgeArgs = {
orderBy?: Maybe<Array<HeroesOrderBy>>;
}; | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** All input for the `deleteHeroById` mutation. */
export type DeleteHeroByIdInput = {
/**
* An arbitrary string value with no semantic meaning. Will be included in the
* payload verbatim. May be used to track mutations by the client.
*/
clientMutationId?: Maybe<Scalars['String']>;
id: Scalars['Int'];
}... | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** All input for the `deleteHero` mutation. */
export type DeleteHeroInput = {
/**
* An arbitrary string value with no semantic meaning. Will be included in the
* payload verbatim. May be used to track mutations by the client.
*/
clientMutationId?: Maybe<Scalars['String']>;
/** The globally unique `ID` ... | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** The output of our delete `Hero` mutation. */
export type DeleteHeroPayload = {
__typename?: 'DeleteHeroPayload';
/**
* The exact same `clientMutationId` that was provided in the mutation input,
* unchanged and unused. May be used by a client to track mutations.
*/
clientMutationId?: Maybe<Scalars['S... | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** The output of our delete `Hero` mutation. */
export type DeleteHeroPayloadHeroEdgeArgs = {
orderBy?: Maybe<Array<HeroesOrderBy>>;
}; | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration |
export type Hero = Node & {
__typename?: 'Hero';
/** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
nodeId: Scalars['ID'];
id: Scalars['Int'];
name: Scalars['String'];
}; | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** A condition to be used against `Hero` object types. All fields are tested for equality and combined with a logical ‘and.’ */
export type HeroCondition = {
/** Checks for equality with the object’s `id` field. */
id?: Maybe<Scalars['Int']>;
/** Checks for equality with the object’s `name` field. */
name?: Ma... | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** A connection to a list of `Hero` values. */
export type HeroesConnection = {
__typename?: 'HeroesConnection';
/** A list of `Hero` objects. */
nodes: Array<Maybe<Hero>>;
/** A list of edges which contains the `Hero` and cursor to aid in pagination. */
edges: Array<HeroesEdge>;
/** Information to aid in... | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** A `Hero` edge in the connection. */
export type HeroesEdge = {
__typename?: 'HeroesEdge';
/** A cursor for use in pagination. */
cursor?: Maybe<Scalars['Cursor']>;
/** The `Hero` at the end of the edge. */
node?: Maybe<Hero>;
}; | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** An input for mutations affecting `Hero` */
export type HeroInput = {
id?: Maybe<Scalars['Int']>;
name: Scalars['String'];
}; | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** Represents an update to a `Hero`. Fields that are set will be updated. */
export type HeroPatch = {
id?: Maybe<Scalars['Int']>;
name?: Maybe<Scalars['String']>;
}; | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** The root mutation type which contains root level fields which mutate data. */
export type Mutation = {
__typename?: 'Mutation';
/** Creates a single `Hero`. */
createHero?: Maybe<CreateHeroPayload>;
/** Updates a single `Hero` using its globally unique id and a patch. */
updateHero?: Maybe<UpdateHeroPayl... | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** The root mutation type which contains root level fields which mutate data. */
export type MutationCreateHeroArgs = {
input: CreateHeroInput;
}; | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** The root mutation type which contains root level fields which mutate data. */
export type MutationUpdateHeroArgs = {
input: UpdateHeroInput;
}; | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** The root mutation type which contains root level fields which mutate data. */
export type MutationUpdateHeroByIdArgs = {
input: UpdateHeroByIdInput;
}; | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** The root mutation type which contains root level fields which mutate data. */
export type MutationDeleteHeroArgs = {
input: DeleteHeroInput;
}; | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** The root mutation type which contains root level fields which mutate data. */
export type MutationDeleteHeroByIdArgs = {
input: DeleteHeroByIdInput;
}; | tjme/opinionate | models/types.d.ts | TypeScript |
TypeAliasDeclaration | /** An object with a globally unique `ID`. */
export type Node = {
/** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
nodeId: Scalars['ID'];
}; | tjme/opinionate | models/types.d.ts | TypeScript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.